@aws-sdk/client-iot-events 3.928.0 → 3.929.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 IoTEventsClient 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 IoTEventsClient extends smithyClient.Client {
     }
 }
 
-class IoTEventsServiceException extends smithyClient.ServiceException {
+let IoTEventsServiceException$1 = class IoTEventsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, IoTEventsServiceException.prototype);
     }
-}
+};
 
 const PayloadType = {
     JSON: "JSON",
@@ -145,7 +145,7 @@ const AnalysisStatus = {
     FAILED: "FAILED",
     RUNNING: "RUNNING",
 };
-class InternalFailureException extends IoTEventsServiceException {
+let InternalFailureException$1 = class InternalFailureException extends IoTEventsServiceException$1 {
     name = "InternalFailureException";
     $fault = "server";
     constructor(opts) {
@@ -156,8 +156,8 @@ class InternalFailureException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, InternalFailureException.prototype);
     }
-}
-class InvalidRequestException extends IoTEventsServiceException {
+};
+let InvalidRequestException$1 = class InvalidRequestException extends IoTEventsServiceException$1 {
     name = "InvalidRequestException";
     $fault = "client";
     constructor(opts) {
@@ -168,8 +168,8 @@ class InvalidRequestException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, InvalidRequestException.prototype);
     }
-}
-class LimitExceededException extends IoTEventsServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends IoTEventsServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -180,8 +180,8 @@ class LimitExceededException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-class ResourceAlreadyExistsException extends IoTEventsServiceException {
+};
+let ResourceAlreadyExistsException$1 = class ResourceAlreadyExistsException extends IoTEventsServiceException$1 {
     name = "ResourceAlreadyExistsException";
     $fault = "client";
     resourceId;
@@ -196,8 +196,8 @@ class ResourceAlreadyExistsException extends IoTEventsServiceException {
         this.resourceId = opts.resourceId;
         this.resourceArn = opts.resourceArn;
     }
-}
-class ResourceInUseException extends IoTEventsServiceException {
+};
+let ResourceInUseException$1 = class ResourceInUseException extends IoTEventsServiceException$1 {
     name = "ResourceInUseException";
     $fault = "client";
     constructor(opts) {
@@ -208,8 +208,8 @@ class ResourceInUseException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, ResourceInUseException.prototype);
     }
-}
-class ServiceUnavailableException extends IoTEventsServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends IoTEventsServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     constructor(opts) {
@@ -220,8 +220,8 @@ class ServiceUnavailableException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-}
-class ThrottlingException extends IoTEventsServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends IoTEventsServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -232,7 +232,7 @@ class ThrottlingException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
+};
 const EvaluationMethod = {
     BATCH: "BATCH",
     SERIAL: "SERIAL",
@@ -252,7 +252,7 @@ const InputStatus = {
     DELETING: "DELETING",
     UPDATING: "UPDATING",
 };
-class ResourceNotFoundException extends IoTEventsServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends IoTEventsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -263,13 +263,13 @@ class ResourceNotFoundException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
+};
 const LoggingLevel = {
     DEBUG: "DEBUG",
     ERROR: "ERROR",
     INFO: "INFO",
 };
-class UnsupportedOperationException extends IoTEventsServiceException {
+let UnsupportedOperationException$1 = class UnsupportedOperationException extends IoTEventsServiceException$1 {
     name = "UnsupportedOperationException";
     $fault = "server";
     constructor(opts) {
@@ -280,1045 +280,1370 @@ class UnsupportedOperationException extends IoTEventsServiceException {
         });
         Object.setPrototypeOf(this, UnsupportedOperationException.prototype);
     }
-}
-
-const se_CreateAlarmModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarm-models");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        alarmCapabilities: (_) => smithyClient._json(_),
-        alarmEventActions: (_) => smithyClient._json(_),
-        alarmModelDescription: [],
-        alarmModelName: [],
-        alarmNotification: (_) => smithyClient._json(_),
-        alarmRule: (_) => smithyClient._json(_),
-        key: [],
-        roleArn: [],
-        severity: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDetectorModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/detector-models");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        detectorModelDefinition: (_) => se_DetectorModelDefinition(_),
-        detectorModelDescription: [],
-        detectorModelName: [],
-        evaluationMethod: [],
-        key: [],
-        roleArn: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateInputCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/inputs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        inputDefinition: (_) => smithyClient._json(_),
-        inputDescription: [],
-        inputName: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteAlarmModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarm-models/{alarmModelName}");
-    b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDetectorModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detector-models/{detectorModelName}");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteInputCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/inputs/{inputName}");
-    b.p("inputName", () => input.inputName, "{inputName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeAlarmModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarm-models/{alarmModelName}");
-    b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
-    const query = smithyClient.map({
-        [_v]: [, input[_aMV]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DescribeDetectorModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detector-models/{detectorModelName}");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
-    const query = smithyClient.map({
-        [_v]: [, input[_dMV]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DescribeDetectorModelAnalysisCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/analysis/detector-models/{analysisId}");
-    b.p("analysisId", () => input.analysisId, "{analysisId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeInputCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/inputs/{inputName}");
-    b.p("inputName", () => input.inputName, "{inputName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeLoggingOptionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/logging");
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDetectorModelAnalysisResultsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/analysis/detector-models/{analysisId}/results");
-    b.p("analysisId", () => input.analysisId, "{analysisId}", 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_ListAlarmModelsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarm-models");
-    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_ListAlarmModelVersionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/alarm-models/{alarmModelName}/versions");
-    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_ListDetectorModelsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detector-models");
-    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_ListDetectorModelVersionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/detector-models/{detectorModelName}/versions");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", 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_ListInputRoutingsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/input-routings");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        inputIdentifier: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListInputsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/inputs");
-    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_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags");
-    const query = smithyClient.map({
-        [_rA]: [, smithyClient.expectNonNull(input[_rA], `resourceArn`)],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_PutLoggingOptionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/logging");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        loggingOptions: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StartDetectorModelAnalysisCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/analysis/detector-models");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        detectorModelDefinition: (_) => se_DetectorModelDefinition(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags");
-    const query = smithyClient.map({
-        [_rA]: [, smithyClient.expectNonNull(input[_rA], `resourceArn`)],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags");
-    const query = smithyClient.map({
-        [_rA]: [, smithyClient.expectNonNull(input[_rA], `resourceArn`)],
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateAlarmModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/alarm-models/{alarmModelName}");
-    b.p("alarmModelName", () => input.alarmModelName, "{alarmModelName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        alarmCapabilities: (_) => smithyClient._json(_),
-        alarmEventActions: (_) => smithyClient._json(_),
-        alarmModelDescription: [],
-        alarmNotification: (_) => smithyClient._json(_),
-        alarmRule: (_) => smithyClient._json(_),
-        roleArn: [],
-        severity: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateDetectorModelCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/detector-models/{detectorModelName}");
-    b.p("detectorModelName", () => input.detectorModelName, "{detectorModelName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        detectorModelDefinition: (_) => se_DetectorModelDefinition(_),
-        detectorModelDescription: [],
-        evaluationMethod: [],
-        roleArn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateInputCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/inputs/{inputName}");
-    b.p("inputName", () => input.inputName, "{inputName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        inputDefinition: (_) => smithyClient._json(_),
-        inputDescription: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const de_CreateAlarmModelCommand = 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, {
-        alarmModelArn: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDetectorModelCommand = 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, {
-        detectorModelConfiguration: (_) => de_DetectorModelConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateInputCommand = async (output, context) => {
-    if (output.statusCode !== 201 && 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, {
-        inputConfiguration: (_) => de_InputConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteAlarmModelCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteDetectorModelCommand = async (output, context) => {
-    if (output.statusCode !== 204 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteInputCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DescribeAlarmModelCommand = 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, {
-        alarmCapabilities: smithyClient._json,
-        alarmEventActions: smithyClient._json,
-        alarmModelArn: smithyClient.expectString,
-        alarmModelDescription: smithyClient.expectString,
-        alarmModelName: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        alarmNotification: smithyClient._json,
-        alarmRule: smithyClient._json,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        key: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        roleArn: smithyClient.expectString,
-        severity: smithyClient.expectInt32,
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeDetectorModelCommand = 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, {
-        detectorModel: (_) => de_DetectorModel(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeDetectorModelAnalysisCommand = 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, {
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeInputCommand = 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, {
-        input: (_) => de_Input(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeLoggingOptionsCommand = 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, {
-        loggingOptions: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDetectorModelAnalysisResultsCommand = 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, {
-        analysisResults: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListAlarmModelsCommand = 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, {
-        alarmModelSummaries: (_) => de_AlarmModelSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListAlarmModelVersionsCommand = 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, {
-        alarmModelVersionSummaries: (_) => de_AlarmModelVersionSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDetectorModelsCommand = 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, {
-        detectorModelSummaries: (_) => de_DetectorModelSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDetectorModelVersionsCommand = 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, {
-        detectorModelVersionSummaries: (_) => de_DetectorModelVersionSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListInputRoutingsCommand = 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, {
-        nextToken: smithyClient.expectString,
-        routedResources: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListInputsCommand = 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, {
-        inputSummaries: (_) => de_InputSummaries(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = 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, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutLoggingOptionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StartDetectorModelAnalysisCommand = 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, {
-        analysisId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateAlarmModelCommand = 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, {
-        alarmModelArn: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateDetectorModelCommand = 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, {
-        detectorModelConfiguration: (_) => de_DetectorModelConfiguration(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateInputCommand = 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, {
-        inputConfiguration: (_) => de_InputConfiguration(_),
-    });
-    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.iotevents#InternalFailureException":
-            throw await de_InternalFailureExceptionRes(parsedOutput);
-        case "InvalidRequestException":
-        case "com.amazonaws.iotevents#InvalidRequestException":
-            throw await de_InvalidRequestExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.iotevents#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "ResourceAlreadyExistsException":
-        case "com.amazonaws.iotevents#ResourceAlreadyExistsException":
-            throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput);
-        case "ResourceInUseException":
-        case "com.amazonaws.iotevents#ResourceInUseException":
-            throw await de_ResourceInUseExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.iotevents#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.iotevents#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.iotevents#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "UnsupportedOperationException":
-        case "com.amazonaws.iotevents#UnsupportedOperationException":
-            throw await de_UnsupportedOperationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(IoTEventsServiceException);
-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_LimitExceededExceptionRes = 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 LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceAlreadyExistsExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceArn: smithyClient.expectString,
-        resourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceAlreadyExistsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceInUseExceptionRes = 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 ResourceInUseException({
-        $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 de_UnsupportedOperationExceptionRes = 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 UnsupportedOperationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_DetectorModelDefinition = (input, context) => {
-    return smithyClient.take(input, {
-        initialStateName: [],
-        states: smithyClient._json,
-    });
-};
-const de_AlarmModelSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AlarmModelSummary(entry);
-    });
-    return retVal;
-};
-const de_AlarmModelSummary = (output, context) => {
-    return smithyClient.take(output, {
-        alarmModelDescription: smithyClient.expectString,
-        alarmModelName: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
 };
-const de_AlarmModelVersionSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_AlarmModelVersionSummary(entry);
-    });
-    return retVal;
-};
-const de_AlarmModelVersionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        alarmModelArn: smithyClient.expectString,
-        alarmModelName: smithyClient.expectString,
-        alarmModelVersion: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        roleArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-        statusMessage: smithyClient.expectString,
-    });
-};
-const de_DetectorModel = (output, context) => {
-    return smithyClient.take(output, {
-        detectorModelConfiguration: (_) => de_DetectorModelConfiguration(_),
-        detectorModelDefinition: (_) => de_DetectorModelDefinition(_),
-    });
-};
-const de_DetectorModelConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        detectorModelArn: smithyClient.expectString,
-        detectorModelDescription: smithyClient.expectString,
-        detectorModelName: smithyClient.expectString,
-        detectorModelVersion: smithyClient.expectString,
-        evaluationMethod: smithyClient.expectString,
-        key: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        roleArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_DetectorModelDefinition = (output, context) => {
-    return smithyClient.take(output, {
-        initialStateName: smithyClient.expectString,
-        states: smithyClient._json,
-    });
-};
-const de_DetectorModelSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DetectorModelSummary(entry);
-    });
-    return retVal;
-};
-const de_DetectorModelSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        detectorModelDescription: smithyClient.expectString,
-        detectorModelName: smithyClient.expectString,
-    });
-};
-const de_DetectorModelVersionSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DetectorModelVersionSummary(entry);
-    });
-    return retVal;
-};
-const de_DetectorModelVersionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        detectorModelArn: smithyClient.expectString,
-        detectorModelName: smithyClient.expectString,
-        detectorModelVersion: smithyClient.expectString,
-        evaluationMethod: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        roleArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_Input = (output, context) => {
-    return smithyClient.take(output, {
-        inputConfiguration: (_) => de_InputConfiguration(_),
-        inputDefinition: smithyClient._json,
-    });
-};
-const de_InputConfiguration = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        inputArn: smithyClient.expectString,
-        inputDescription: smithyClient.expectString,
-        inputName: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-};
-const de_InputSummaries = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_InputSummary(entry);
-    });
-    return retVal;
-};
-const de_InputSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        inputArn: smithyClient.expectString,
-        inputDescription: smithyClient.expectString,
-        inputName: smithyClient.expectString,
-        lastUpdateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-};
-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 = "Action";
+const _AA = "AlarmAction";
+const _AAl = "AlarmActions";
+const _AC = "AlarmCapabilities";
+const _AEA = "AlarmEventActions";
+const _AF = "AcknowledgeFlow";
+const _AMS = "AlarmModelSummary";
+const _AMSl = "AlarmModelSummaries";
+const _AMVS = "AlarmModelVersionSummary";
+const _AMVSl = "AlarmModelVersionSummaries";
+const _AN = "AlarmNotification";
+const _APT = "AssetPropertyTimestamp";
+const _APV = "AssetPropertyValue";
+const _APVs = "AssetPropertyVariant";
+const _AR = "AlarmRule";
+const _ARL = "AnalysisResultLocation";
+const _ARLn = "AnalysisResultLocations";
+const _ARn = "AnalysisResult";
+const _ARna = "AnalysisResults";
+const _Ac = "Actions";
+const _At = "Attribute";
+const _Att = "Attributes";
+const _CAM = "CreateAlarmModel";
+const _CAMR = "CreateAlarmModelRequest";
+const _CAMRr = "CreateAlarmModelResponse";
+const _CDM = "CreateDetectorModel";
+const _CDMR = "CreateDetectorModelRequest";
+const _CDMRr = "CreateDetectorModelResponse";
+const _CI = "CreateInput";
+const _CIR = "CreateInputRequest";
+const _CIRr = "CreateInputResponse";
+const _CTA = "ClearTimerAction";
+const _DAM = "DeleteAlarmModel";
+const _DAMR = "DeleteAlarmModelRequest";
+const _DAMRe = "DeleteAlarmModelResponse";
+const _DAMRes = "DescribeAlarmModelRequest";
+const _DAMResc = "DescribeAlarmModelResponse";
+const _DAMe = "DescribeAlarmModel";
+const _DDBA = "DynamoDBAction";
+const _DDBAy = "DynamoDBv2Action";
+const _DDM = "DeleteDetectorModel";
+const _DDMA = "DescribeDetectorModelAnalysis";
+const _DDMAR = "DescribeDetectorModelAnalysisRequest";
+const _DDMARe = "DescribeDetectorModelAnalysisResponse";
+const _DDMR = "DeleteDetectorModelRequest";
+const _DDMRe = "DeleteDetectorModelResponse";
+const _DDMRes = "DescribeDetectorModelRequest";
+const _DDMResc = "DescribeDetectorModelResponse";
+const _DDMe = "DescribeDetectorModel";
+const _DDO = "DetectorDebugOption";
+const _DDOe = "DetectorDebugOptions";
+const _DI = "DeleteInput";
+const _DIR = "DeleteInputRequest";
+const _DIRe = "DeleteInputResponse";
+const _DIRes = "DescribeInputRequest";
+const _DIResc = "DescribeInputResponse";
+const _DIe = "DescribeInput";
+const _DLO = "DescribeLoggingOptions";
+const _DLOR = "DescribeLoggingOptionsRequest";
+const _DLORe = "DescribeLoggingOptionsResponse";
+const _DM = "DetectorModel";
+const _DMC = "DetectorModelConfiguration";
+const _DMD = "DetectorModelDefinition";
+const _DMS = "DetectorModelSummary";
+const _DMSe = "DetectorModelSummaries";
+const _DMVS = "DetectorModelVersionSummary";
+const _DMVSe = "DetectorModelVersionSummaries";
+const _E = "Event";
+const _EC = "EmailConfiguration";
+const _ECm = "EmailContent";
+const _ECma = "EmailConfigurations";
+const _ER = "EmailRecipients";
+const _Ev = "Events";
+const _FA = "FirehoseAction";
+const _GDMAR = "GetDetectorModelAnalysisResults";
+const _GDMARR = "GetDetectorModelAnalysisResultsRequest";
+const _GDMARRe = "GetDetectorModelAnalysisResultsResponse";
+const _I = "Input";
+const _IC = "InitializationConfiguration";
+const _ICn = "InputConfiguration";
+const _ID = "InputDefinition";
+const _IEA = "IotEventsAction";
+const _IEII = "IotEventsInputIdentifier";
+const _IFE = "InternalFailureException";
+const _II = "InputIdentifier";
+const _IRE = "InvalidRequestException";
+const _IS = "InputSummary";
+const _ISWA = "IotSiteWiseAction";
+const _ISWAMPI = "IotSiteWiseAssetModelPropertyIdentifier";
+const _ISWII = "IotSiteWiseInputIdentifier";
+const _ISn = "InputSummaries";
+const _ITPA = "IotTopicPublishAction";
+const _LA = "LambdaAction";
+const _LAM = "ListAlarmModels";
+const _LAMR = "ListAlarmModelsRequest";
+const _LAMRi = "ListAlarmModelsResponse";
+const _LAMV = "ListAlarmModelVersions";
+const _LAMVR = "ListAlarmModelVersionsRequest";
+const _LAMVRi = "ListAlarmModelVersionsResponse";
+const _LDM = "ListDetectorModels";
+const _LDMR = "ListDetectorModelsRequest";
+const _LDMRi = "ListDetectorModelsResponse";
+const _LDMV = "ListDetectorModelVersions";
+const _LDMVR = "ListDetectorModelVersionsRequest";
+const _LDMVRi = "ListDetectorModelVersionsResponse";
+const _LEE = "LimitExceededException";
+const _LI = "ListInputs";
+const _LIR = "ListInputsRequest";
+const _LIRR = "ListInputRoutingsRequest";
+const _LIRRi = "ListInputRoutingsResponse";
+const _LIRi = "ListInputsResponse";
+const _LIRis = "ListInputRoutings";
+const _LO = "LoggingOptions";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _NA = "NotificationAction";
+const _NAo = "NotificationActions";
+const _NTA = "NotificationTargetActions";
+const _OEL = "OnEnterLifecycle";
+const _OELn = "OnExitLifecycle";
+const _OIL = "OnInputLifecycle";
+const _P = "Payload";
+const _PLO = "PutLoggingOptions";
+const _PLOR = "PutLoggingOptionsRequest";
+const _RAEE = "ResourceAlreadyExistsException";
+const _RD = "RecipientDetail";
+const _RDe = "RecipientDetails";
+const _RIUE = "ResourceInUseException";
+const _RNFE = "ResourceNotFoundException";
+const _RR = "RoutedResource";
+const _RRo = "RoutedResources";
+const _RTA = "ResetTimerAction";
+const _S = "State";
+const _SA = "SqsAction";
+const _SDMA = "StartDetectorModelAnalysis";
+const _SDMAR = "StartDetectorModelAnalysisRequest";
+const _SDMARt = "StartDetectorModelAnalysisResponse";
+const _SMSC = "SMSConfiguration";
+const _SMSCo = "SMSConfigurations";
+const _SNSTPA = "SNSTopicPublishAction";
+const _SR = "SimpleRule";
+const _SSOI = "SSOIdentity";
+const _STA = "SetTimerAction";
+const _SUE = "ServiceUnavailableException";
+const _SVA = "SetVariableAction";
+const _St = "States";
+const _T = "Tag";
+const _TE = "ThrottlingException";
+const _TEr = "TransitionEvent";
+const _TEra = "TransitionEvents";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _Ta = "Tags";
+const _UAM = "UpdateAlarmModel";
+const _UAMR = "UpdateAlarmModelRequest";
+const _UAMRp = "UpdateAlarmModelResponse";
+const _UDM = "UpdateDetectorModel";
+const _UDMR = "UpdateDetectorModelRequest";
+const _UDMRp = "UpdateDetectorModelResponse";
+const _UI = "UpdateInput";
+const _UIR = "UpdateInputRequest";
+const _UIRp = "UpdateInputResponse";
+const _UOE = "UnsupportedOperationException";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _a = "actions";
+const _aA = "alarmActions";
+const _aC = "alarmCapabilities";
+const _aEA = "alarmEventActions";
+const _aF = "acknowledgeFlow";
+const _aI = "analysisId";
+const _aIs = "assetId";
+const _aM = "additionalMessage";
+const _aMA = "alarmModelArn";
+const _aMD = "alarmModelDescription";
+const _aMI = "assetModelId";
+const _aMN = "alarmModelName";
+const _aMS = "alarmModelSummaries";
 const _aMV = "alarmModelVersion";
+const _aMVS = "alarmModelVersionSummaries";
+const _aN = "alarmNotification";
+const _aR = "alarmRule";
+const _aRn = "analysisResults";
+const _ac = "action";
+const _ar = "arn";
+const _at = "attributes";
+const _bV = "booleanValue";
+const _c = "content";
+const _cE = "contentExpression";
+const _cO = "comparisonOperator";
+const _cT = "clearTimer";
+const _cTr = "creationTime";
+const _cl = "client";
+const _co = "condition";
+const _dDB = "dynamoDB";
+const _dDBy = "dynamoDBv2";
+const _dDO = "detectorDebugOptions";
+const _dE = "durationExpression";
+const _dM = "detectorModel";
+const _dMA = "detectorModelArn";
+const _dMC = "detectorModelConfiguration";
+const _dMD = "detectorModelDefinition";
+const _dMDe = "detectorModelDescription";
+const _dMN = "detectorModelName";
+const _dMS = "detectorModelSummaries";
 const _dMV = "detectorModelVersion";
+const _dMVS = "detectorModelVersionSummaries";
+const _dOI = "disabledOnInitialization";
+const _dSN = "deliveryStreamName";
+const _dV = "doubleValue";
+const _e = "enabled";
+const _eC = "emailConfigurations";
+const _eI = "entryId";
+const _eM = "evaluationMethod";
+const _eN = "eventName";
+const _er = "error";
+const _ev = "events";
+const _f = "firehose";
+const _fA = "functionArn";
+const _fr = "from";
+const _h = "http";
+const _hE = "httpError";
+const _hKF = "hashKeyField";
+const _hKT = "hashKeyType";
+const _hKV = "hashKeyValue";
+const _hQ = "httpQuery";
+const _i = "input";
+const _iA = "inputArn";
+const _iC = "initializationConfiguration";
+const _iCn = "inputConfiguration";
+const _iD = "inputDescription";
+const _iDn = "inputDefinition";
+const _iE = "iotEvents";
+const _iEII = "iotEventsInputIdentifier";
+const _iI = "inputIdentifier";
+const _iN = "inputName";
+const _iP = "inputProperty";
+const _iS = "inputSummaries";
+const _iSI = "identityStoreId";
+const _iSN = "initialStateName";
+const _iSW = "iotSiteWise";
+const _iSWAMPI = "iotSiteWiseAssetModelPropertyIdentifier";
+const _iSWII = "iotSiteWiseInputIdentifier";
+const _iTP = "iotTopicPublish";
+const _iV = "integerValue";
+const _jP = "jsonPath";
+const _k = "key";
+const _kV = "keyValue";
+const _l = "lambda";
+const _lA = "lambdaAction";
+const _lO = "loggingOptions";
+const _lUT = "lastUpdateTime";
+const _le = "level";
+const _lo = "locations";
+const _m = "message";
 const _mR = "maxResults";
+const _mT = "mqttTopic";
+const _n = "name";
+const _nA = "notificationActions";
+const _nS = "nextState";
 const _nT = "nextToken";
-const _rA = "resourceArn";
+const _o = "operation";
+const _oE = "onEnter";
+const _oEn = "onExit";
+const _oI = "onInput";
+const _oIN = "offsetInNanos";
+const _p = "path";
+const _pA = "propertyAlias";
+const _pF = "payloadField";
+const _pI = "propertyId";
+const _pV = "propertyValue";
+const _pa = "payload";
+const _q = "quality";
+const _qU = "queueUrl";
+const _r = "recipients";
+const _rA = "roleArn";
+const _rAe = "resourceArn";
+const _rI = "resourceId";
+const _rKF = "rangeKeyField";
+const _rKT = "rangeKeyType";
+const _rKV = "rangeKeyValue";
+const _rR = "routedResources";
+const _rT = "resetTimer";
+const _s = "sns";
+const _sC = "smsConfigurations";
+const _sI = "ssoIdentity";
+const _sIe = "senderId";
+const _sM = "statusMessage";
+const _sN = "stateName";
+const _sR = "simpleRule";
+const _sT = "setTimer";
+const _sV = "setVariable";
+const _sVt = "stringValue";
+const _se = "severity";
+const _sec = "seconds";
+const _sep = "separator";
+const _ser = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.iotevents";
+const _sq = "sqs";
+const _st = "status";
+const _sta = "states";
+const _su = "subject";
+const _t = "type";
+const _tA = "targetArn";
+const _tE = "transitionEvents";
+const _tIS = "timeInSeconds";
 const _tK = "tagKeys";
-const _v = "version";
+const _tN = "timerName";
+const _tNa = "tableName";
+const _ta = "tags";
+const _th = "threshold";
+const _ti = "timestamp";
+const _to = "to";
+const _uB = "useBase64";
+const _uI = "userId";
+const _v = "value";
+const _vN = "variableName";
+const _ve = "version";
+const n0 = "com.amazonaws.iotevents";
+var AcknowledgeFlow = [3, n0, _AF, 0, [_e], [2]];
+var Action = [
+    3,
+    n0,
+    _A,
+    0,
+    [_sV, _s, _iTP, _sT, _cT, _rT, _l, _iE, _sq, _f, _dDB, _dDBy, _iSW],
+    [
+        () => SetVariableAction,
+        () => SNSTopicPublishAction,
+        () => IotTopicPublishAction,
+        () => SetTimerAction,
+        () => ClearTimerAction,
+        () => ResetTimerAction,
+        () => LambdaAction,
+        () => IotEventsAction,
+        () => SqsAction,
+        () => FirehoseAction,
+        () => DynamoDBAction,
+        () => DynamoDBv2Action,
+        () => IotSiteWiseAction,
+    ],
+];
+var AlarmAction = [
+    3,
+    n0,
+    _AA,
+    0,
+    [_s, _iTP, _l, _iE, _sq, _f, _dDB, _dDBy, _iSW],
+    [
+        () => SNSTopicPublishAction,
+        () => IotTopicPublishAction,
+        () => LambdaAction,
+        () => IotEventsAction,
+        () => SqsAction,
+        () => FirehoseAction,
+        () => DynamoDBAction,
+        () => DynamoDBv2Action,
+        () => IotSiteWiseAction,
+    ],
+];
+var AlarmCapabilities = [
+    3,
+    n0,
+    _AC,
+    0,
+    [_iC, _aF],
+    [() => InitializationConfiguration, () => AcknowledgeFlow],
+];
+var AlarmEventActions = [3, n0, _AEA, 0, [_aA], [() => AlarmActions]];
+var AlarmModelSummary = [3, n0, _AMS, 0, [_cTr, _aMD, _aMN], [4, 0, 0]];
+var AlarmModelVersionSummary = [
+    3,
+    n0,
+    _AMVS,
+    0,
+    [_aMN, _aMA, _aMV, _rA, _cTr, _lUT, _st, _sM],
+    [0, 0, 0, 0, 4, 4, 0, 0],
+];
+var AlarmNotification = [3, n0, _AN, 0, [_nA], [() => NotificationActions]];
+var AlarmRule = [3, n0, _AR, 0, [_sR], [() => SimpleRule]];
+var AnalysisResult = [
+    3,
+    n0,
+    _ARn,
+    0,
+    [_t, _le, _m, _lo],
+    [0, 0, 0, () => AnalysisResultLocations],
+];
+var AnalysisResultLocation = [3, n0, _ARL, 0, [_p], [0]];
+var AssetPropertyTimestamp = [3, n0, _APT, 0, [_tIS, _oIN], [0, 0]];
+var AssetPropertyValue = [
+    3,
+    n0,
+    _APV,
+    0,
+    [_v, _ti, _q],
+    [() => AssetPropertyVariant, () => AssetPropertyTimestamp, 0],
+];
+var AssetPropertyVariant = [3, n0, _APVs, 0, [_sVt, _iV, _dV, _bV], [0, 0, 0, 0]];
+var Attribute = [3, n0, _At, 0, [_jP], [0]];
+var ClearTimerAction = [3, n0, _CTA, 0, [_tN], [0]];
+var CreateAlarmModelRequest = [
+    3,
+    n0,
+    _CAMR,
+    0,
+    [_aMN, _aMD, _rA, _ta, _k, _se, _aR, _aN, _aEA, _aC],
+    [
+        0,
+        0,
+        0,
+        () => Tags,
+        0,
+        1,
+        () => AlarmRule,
+        () => AlarmNotification,
+        () => AlarmEventActions,
+        () => AlarmCapabilities,
+    ],
+];
+var CreateAlarmModelResponse = [
+    3,
+    n0,
+    _CAMRr,
+    0,
+    [_cTr, _aMA, _aMV, _lUT, _st],
+    [4, 0, 0, 4, 0],
+];
+var CreateDetectorModelRequest = [
+    3,
+    n0,
+    _CDMR,
+    0,
+    [_dMN, _dMD, _dMDe, _k, _rA, _ta, _eM],
+    [0, () => DetectorModelDefinition, 0, 0, 0, () => Tags, 0],
+];
+var CreateDetectorModelResponse = [
+    3,
+    n0,
+    _CDMRr,
+    0,
+    [_dMC],
+    [() => DetectorModelConfiguration],
+];
+var CreateInputRequest = [
+    3,
+    n0,
+    _CIR,
+    0,
+    [_iN, _iD, _iDn, _ta],
+    [0, 0, () => InputDefinition, () => Tags],
+];
+var CreateInputResponse = [3, n0, _CIRr, 0, [_iCn], [() => InputConfiguration]];
+var DeleteAlarmModelRequest = [3, n0, _DAMR, 0, [_aMN], [[0, 1]]];
+var DeleteAlarmModelResponse = [3, n0, _DAMRe, 0, [], []];
+var DeleteDetectorModelRequest = [3, n0, _DDMR, 0, [_dMN], [[0, 1]]];
+var DeleteDetectorModelResponse = [3, n0, _DDMRe, 0, [], []];
+var DeleteInputRequest = [3, n0, _DIR, 0, [_iN], [[0, 1]]];
+var DeleteInputResponse = [3, n0, _DIRe, 0, [], []];
+var DescribeAlarmModelRequest = [
+    3,
+    n0,
+    _DAMRes,
+    0,
+    [_aMN, _aMV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _ve,
+            },
+        ],
+    ],
+];
+var DescribeAlarmModelResponse = [
+    3,
+    n0,
+    _DAMResc,
+    0,
+    [_cTr, _aMA, _aMV, _lUT, _st, _sM, _aMN, _aMD, _rA, _k, _se, _aR, _aN, _aEA, _aC],
+    [
+        4,
+        0,
+        0,
+        4,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        () => AlarmRule,
+        () => AlarmNotification,
+        () => AlarmEventActions,
+        () => AlarmCapabilities,
+    ],
+];
+var DescribeDetectorModelAnalysisRequest = [3, n0, _DDMAR, 0, [_aI], [[0, 1]]];
+var DescribeDetectorModelAnalysisResponse = [3, n0, _DDMARe, 0, [_st], [0]];
+var DescribeDetectorModelRequest = [
+    3,
+    n0,
+    _DDMRes,
+    0,
+    [_dMN, _dMV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _ve,
+            },
+        ],
+    ],
+];
+var DescribeDetectorModelResponse = [3, n0, _DDMResc, 0, [_dM], [() => DetectorModel]];
+var DescribeInputRequest = [3, n0, _DIRes, 0, [_iN], [[0, 1]]];
+var DescribeInputResponse = [3, n0, _DIResc, 0, [_i], [() => Input]];
+var DescribeLoggingOptionsRequest = [3, n0, _DLOR, 0, [], []];
+var DescribeLoggingOptionsResponse = [3, n0, _DLORe, 0, [_lO], [() => LoggingOptions]];
+var DetectorDebugOption = [3, n0, _DDO, 0, [_dMN, _kV], [0, 0]];
+var DetectorModel = [
+    3,
+    n0,
+    _DM,
+    0,
+    [_dMD, _dMC],
+    [() => DetectorModelDefinition, () => DetectorModelConfiguration],
+];
+var DetectorModelConfiguration = [
+    3,
+    n0,
+    _DMC,
+    0,
+    [_dMN, _dMV, _dMDe, _dMA, _rA, _cTr, _lUT, _st, _k, _eM],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0],
+];
+var DetectorModelDefinition = [3, n0, _DMD, 0, [_sta, _iSN], [() => States, 0]];
+var DetectorModelSummary = [3, n0, _DMS, 0, [_dMN, _dMDe, _cTr], [0, 0, 4]];
+var DetectorModelVersionSummary = [
+    3,
+    n0,
+    _DMVS,
+    0,
+    [_dMN, _dMV, _dMA, _rA, _cTr, _lUT, _st, _eM],
+    [0, 0, 0, 0, 4, 4, 0, 0],
+];
+var DynamoDBAction = [
+    3,
+    n0,
+    _DDBA,
+    0,
+    [_hKT, _hKF, _hKV, _rKT, _rKF, _rKV, _o, _pF, _tNa, _pa],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, () => Payload],
+];
+var DynamoDBv2Action = [3, n0, _DDBAy, 0, [_tNa, _pa], [0, () => Payload]];
+var EmailConfiguration = [
+    3,
+    n0,
+    _EC,
+    0,
+    [_fr, _c, _r],
+    [0, () => EmailContent, () => EmailRecipients],
+];
+var EmailContent = [3, n0, _ECm, 0, [_su, _aM], [0, 0]];
+var EmailRecipients = [3, n0, _ER, 0, [_to], [() => RecipientDetails]];
+var Event = [3, n0, _E, 0, [_eN, _co, _a], [0, 0, () => Actions]];
+var FirehoseAction = [3, n0, _FA, 0, [_dSN, _sep, _pa], [0, 0, () => Payload]];
+var GetDetectorModelAnalysisResultsRequest = [
+    3,
+    n0,
+    _GDMARR,
+    0,
+    [_aI, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var GetDetectorModelAnalysisResultsResponse = [
+    3,
+    n0,
+    _GDMARRe,
+    0,
+    [_aRn, _nT],
+    [() => AnalysisResults, 0],
+];
+var InitializationConfiguration = [3, n0, _IC, 0, [_dOI], [2]];
+var Input = [
+    3,
+    n0,
+    _I,
+    0,
+    [_iCn, _iDn],
+    [() => InputConfiguration, () => InputDefinition],
+];
+var InputConfiguration = [
+    3,
+    n0,
+    _ICn,
+    0,
+    [_iN, _iD, _iA, _cTr, _lUT, _st],
+    [0, 0, 0, 4, 4, 0],
+];
+var InputDefinition = [3, n0, _ID, 0, [_at], [() => Attributes]];
+var InputIdentifier = [
+    3,
+    n0,
+    _II,
+    0,
+    [_iEII, _iSWII],
+    [() => IotEventsInputIdentifier, () => IotSiteWiseInputIdentifier],
+];
+var InputSummary = [3, n0, _IS, 0, [_iN, _iD, _iA, _cTr, _lUT, _st], [0, 0, 0, 4, 4, 0]];
+var InternalFailureException = [
+    -3,
+    n0,
+    _IFE,
+    {
+        [_er]: _ser,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalFailureException, InternalFailureException$1);
+var InvalidRequestException = [
+    -3,
+    n0,
+    _IRE,
+    {
+        [_er]: _cl,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidRequestException, InvalidRequestException$1);
+var IotEventsAction = [3, n0, _IEA, 0, [_iN, _pa], [0, () => Payload]];
+var IotEventsInputIdentifier = [3, n0, _IEII, 0, [_iN], [0]];
+var IotSiteWiseAction = [
+    3,
+    n0,
+    _ISWA,
+    0,
+    [_eI, _aIs, _pI, _pA, _pV],
+    [0, 0, 0, 0, () => AssetPropertyValue],
+];
+var IotSiteWiseAssetModelPropertyIdentifier = [3, n0, _ISWAMPI, 0, [_aMI, _pI], [0, 0]];
+var IotSiteWiseInputIdentifier = [
+    3,
+    n0,
+    _ISWII,
+    0,
+    [_iSWAMPI],
+    [() => IotSiteWiseAssetModelPropertyIdentifier],
+];
+var IotTopicPublishAction = [3, n0, _ITPA, 0, [_mT, _pa], [0, () => Payload]];
+var LambdaAction = [3, n0, _LA, 0, [_fA, _pa], [0, () => Payload]];
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_er]: _cl,
+        [_hE]: 410,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListAlarmModelsRequest = [
+    3,
+    n0,
+    _LAMR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListAlarmModelsResponse = [
+    3,
+    n0,
+    _LAMRi,
+    0,
+    [_aMS, _nT],
+    [() => AlarmModelSummaries, 0],
+];
+var ListAlarmModelVersionsRequest = [
+    3,
+    n0,
+    _LAMVR,
+    0,
+    [_aMN, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListAlarmModelVersionsResponse = [
+    3,
+    n0,
+    _LAMVRi,
+    0,
+    [_aMVS, _nT],
+    [() => AlarmModelVersionSummaries, 0],
+];
+var ListDetectorModelsRequest = [
+    3,
+    n0,
+    _LDMR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDetectorModelsResponse = [
+    3,
+    n0,
+    _LDMRi,
+    0,
+    [_dMS, _nT],
+    [() => DetectorModelSummaries, 0],
+];
+var ListDetectorModelVersionsRequest = [
+    3,
+    n0,
+    _LDMVR,
+    0,
+    [_dMN, _nT, _mR],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDetectorModelVersionsResponse = [
+    3,
+    n0,
+    _LDMVRi,
+    0,
+    [_dMVS, _nT],
+    [() => DetectorModelVersionSummaries, 0],
+];
+var ListInputRoutingsRequest = [
+    3,
+    n0,
+    _LIRR,
+    0,
+    [_iI, _mR, _nT],
+    [() => InputIdentifier, 1, 0],
+];
+var ListInputRoutingsResponse = [
+    3,
+    n0,
+    _LIRRi,
+    0,
+    [_rR, _nT],
+    [() => RoutedResources, 0],
+];
+var ListInputsRequest = [
+    3,
+    n0,
+    _LIR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListInputsResponse = [3, n0, _LIRi, 0, [_iS, _nT], [() => InputSummaries, 0]];
+var ListTagsForResourceRequest = [
+    3,
+    n0,
+    _LTFRR,
+    0,
+    [_rAe],
+    [
+        [
+            0,
+            {
+                [_hQ]: _rAe,
+            },
+        ],
+    ],
+];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [() => Tags]];
+var LoggingOptions = [
+    3,
+    n0,
+    _LO,
+    0,
+    [_rA, _le, _e, _dDO],
+    [0, 0, 2, () => DetectorDebugOptions],
+];
+var NotificationAction = [
+    3,
+    n0,
+    _NA,
+    0,
+    [_ac, _sC, _eC],
+    [() => NotificationTargetActions, () => SMSConfigurations, () => EmailConfigurations],
+];
+var NotificationTargetActions = [3, n0, _NTA, 0, [_lA], [() => LambdaAction]];
+var OnEnterLifecycle = [3, n0, _OEL, 0, [_ev], [() => Events]];
+var OnExitLifecycle = [3, n0, _OELn, 0, [_ev], [() => Events]];
+var OnInputLifecycle = [
+    3,
+    n0,
+    _OIL,
+    0,
+    [_ev, _tE],
+    [() => Events, () => TransitionEvents],
+];
+var Payload = [3, n0, _P, 0, [_cE, _t], [0, 0]];
+var PutLoggingOptionsRequest = [3, n0, _PLOR, 0, [_lO], [() => LoggingOptions]];
+var RecipientDetail = [3, n0, _RD, 0, [_sI], [() => SSOIdentity]];
+var ResetTimerAction = [3, n0, _RTA, 0, [_tN], [0]];
+var ResourceAlreadyExistsException = [
+    -3,
+    n0,
+    _RAEE,
+    {
+        [_er]: _cl,
+        [_hE]: 409,
+    },
+    [_m, _rI, _rAe],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceAlreadyExistsException, ResourceAlreadyExistsException$1);
+var ResourceInUseException = [
+    -3,
+    n0,
+    _RIUE,
+    {
+        [_er]: _cl,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceInUseException, ResourceInUseException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_er]: _cl,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RoutedResource = [3, n0, _RR, 0, [_n, _ar], [0, 0]];
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_er]: _ser,
+        [_hE]: 503,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var SetTimerAction = [3, n0, _STA, 0, [_tN, _sec, _dE], [0, 1, 0]];
+var SetVariableAction = [3, n0, _SVA, 0, [_vN, _v], [0, 0]];
+var SimpleRule = [3, n0, _SR, 0, [_iP, _cO, _th], [0, 0, 0]];
+var SMSConfiguration = [3, n0, _SMSC, 0, [_sIe, _aM, _r], [0, 0, () => RecipientDetails]];
+var SNSTopicPublishAction = [3, n0, _SNSTPA, 0, [_tA, _pa], [0, () => Payload]];
+var SqsAction = [3, n0, _SA, 0, [_qU, _uB, _pa], [0, 2, () => Payload]];
+var SSOIdentity = [3, n0, _SSOI, 0, [_iSI, _uI], [0, 0]];
+var StartDetectorModelAnalysisRequest = [
+    3,
+    n0,
+    _SDMAR,
+    0,
+    [_dMD],
+    [() => DetectorModelDefinition],
+];
+var StartDetectorModelAnalysisResponse = [3, n0, _SDMARt, 0, [_aI], [0]];
+var State = [
+    3,
+    n0,
+    _S,
+    0,
+    [_sN, _oI, _oE, _oEn],
+    [0, () => OnInputLifecycle, () => OnEnterLifecycle, () => OnExitLifecycle],
+];
+var Tag = [3, n0, _T, 0, [_k, _v], [0, 0]];
+var TagResourceRequest = [
+    3,
+    n0,
+    _TRR,
+    0,
+    [_rAe, _ta],
+    [
+        [
+            0,
+            {
+                [_hQ]: _rAe,
+            },
+        ],
+        () => Tags,
+    ],
+];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_er]: _cl,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TransitionEvent = [3, n0, _TEr, 0, [_eN, _co, _a, _nS], [0, 0, () => Actions, 0]];
+var UnsupportedOperationException = [
+    -3,
+    n0,
+    _UOE,
+    {
+        [_er]: _ser,
+        [_hE]: 501,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnsupportedOperationException, UnsupportedOperationException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rAe, _tK],
+    [
+        [
+            0,
+            {
+                [_hQ]: _rAe,
+            },
+        ],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateAlarmModelRequest = [
+    3,
+    n0,
+    _UAMR,
+    0,
+    [_aMN, _aMD, _rA, _se, _aR, _aN, _aEA, _aC],
+    [[0, 1], 0, 0, 1, () => AlarmRule, () => AlarmNotification, () => AlarmEventActions, () => AlarmCapabilities],
+];
+var UpdateAlarmModelResponse = [
+    3,
+    n0,
+    _UAMRp,
+    0,
+    [_cTr, _aMA, _aMV, _lUT, _st],
+    [4, 0, 0, 4, 0],
+];
+var UpdateDetectorModelRequest = [
+    3,
+    n0,
+    _UDMR,
+    0,
+    [_dMN, _dMD, _dMDe, _rA, _eM],
+    [[0, 1], () => DetectorModelDefinition, 0, 0, 0],
+];
+var UpdateDetectorModelResponse = [
+    3,
+    n0,
+    _UDMRp,
+    0,
+    [_dMC],
+    [() => DetectorModelConfiguration],
+];
+var UpdateInputRequest = [
+    3,
+    n0,
+    _UIR,
+    0,
+    [_iN, _iD, _iDn],
+    [[0, 1], 0, () => InputDefinition],
+];
+var UpdateInputResponse = [3, n0, _UIRp, 0, [_iCn], [() => InputConfiguration]];
+var __Unit = "unit";
+var IoTEventsServiceException = [-3, _sm, "IoTEventsServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(IoTEventsServiceException, IoTEventsServiceException$1);
+var Actions = [1, n0, _Ac, 0, () => Action];
+var AlarmActions = [1, n0, _AAl, 0, () => AlarmAction];
+var AlarmModelSummaries = [1, n0, _AMSl, 0, () => AlarmModelSummary];
+var AlarmModelVersionSummaries = [1, n0, _AMVSl, 0, () => AlarmModelVersionSummary];
+var AnalysisResultLocations = [1, n0, _ARLn, 0, () => AnalysisResultLocation];
+var AnalysisResults = [1, n0, _ARna, 0, () => AnalysisResult];
+var Attributes = [1, n0, _Att, 0, () => Attribute];
+var DetectorDebugOptions = [1, n0, _DDOe, 0, () => DetectorDebugOption];
+var DetectorModelSummaries = [1, n0, _DMSe, 0, () => DetectorModelSummary];
+var DetectorModelVersionSummaries = [1, n0, _DMVSe, 0, () => DetectorModelVersionSummary];
+var EmailConfigurations = [1, n0, _ECma, 0, () => EmailConfiguration];
+var Events = [1, n0, _Ev, 0, () => Event];
+var InputSummaries = [1, n0, _ISn, 0, () => InputSummary];
+var NotificationActions = [1, n0, _NAo, 0, () => NotificationAction];
+var RecipientDetails = [1, n0, _RDe, 0, () => RecipientDetail];
+var RoutedResources = [1, n0, _RRo, 0, () => RoutedResource];
+var SMSConfigurations = [1, n0, _SMSCo, 0, () => SMSConfiguration];
+var States = [1, n0, _St, 0, () => State];
+var Tags = [1, n0, _Ta, 0, () => Tag];
+var TransitionEvents = [1, n0, _TEra, 0, () => TransitionEvent];
+var CreateAlarmModel = [
+    9,
+    n0,
+    _CAM,
+    {
+        [_h]: ["POST", "/alarm-models", 200],
+    },
+    () => CreateAlarmModelRequest,
+    () => CreateAlarmModelResponse,
+];
+var CreateDetectorModel = [
+    9,
+    n0,
+    _CDM,
+    {
+        [_h]: ["POST", "/detector-models", 200],
+    },
+    () => CreateDetectorModelRequest,
+    () => CreateDetectorModelResponse,
+];
+var CreateInput = [
+    9,
+    n0,
+    _CI,
+    {
+        [_h]: ["POST", "/inputs", 201],
+    },
+    () => CreateInputRequest,
+    () => CreateInputResponse,
+];
+var DeleteAlarmModel = [
+    9,
+    n0,
+    _DAM,
+    {
+        [_h]: ["DELETE", "/alarm-models/{alarmModelName}", 204],
+    },
+    () => DeleteAlarmModelRequest,
+    () => DeleteAlarmModelResponse,
+];
+var DeleteDetectorModel = [
+    9,
+    n0,
+    _DDM,
+    {
+        [_h]: ["DELETE", "/detector-models/{detectorModelName}", 204],
+    },
+    () => DeleteDetectorModelRequest,
+    () => DeleteDetectorModelResponse,
+];
+var DeleteInput = [
+    9,
+    n0,
+    _DI,
+    {
+        [_h]: ["DELETE", "/inputs/{inputName}", 200],
+    },
+    () => DeleteInputRequest,
+    () => DeleteInputResponse,
+];
+var DescribeAlarmModel = [
+    9,
+    n0,
+    _DAMe,
+    {
+        [_h]: ["GET", "/alarm-models/{alarmModelName}", 200],
+    },
+    () => DescribeAlarmModelRequest,
+    () => DescribeAlarmModelResponse,
+];
+var DescribeDetectorModel = [
+    9,
+    n0,
+    _DDMe,
+    {
+        [_h]: ["GET", "/detector-models/{detectorModelName}", 200],
+    },
+    () => DescribeDetectorModelRequest,
+    () => DescribeDetectorModelResponse,
+];
+var DescribeDetectorModelAnalysis = [
+    9,
+    n0,
+    _DDMA,
+    {
+        [_h]: ["GET", "/analysis/detector-models/{analysisId}", 200],
+    },
+    () => DescribeDetectorModelAnalysisRequest,
+    () => DescribeDetectorModelAnalysisResponse,
+];
+var DescribeInput = [
+    9,
+    n0,
+    _DIe,
+    {
+        [_h]: ["GET", "/inputs/{inputName}", 200],
+    },
+    () => DescribeInputRequest,
+    () => DescribeInputResponse,
+];
+var DescribeLoggingOptions = [
+    9,
+    n0,
+    _DLO,
+    {
+        [_h]: ["GET", "/logging", 200],
+    },
+    () => DescribeLoggingOptionsRequest,
+    () => DescribeLoggingOptionsResponse,
+];
+var GetDetectorModelAnalysisResults = [
+    9,
+    n0,
+    _GDMAR,
+    {
+        [_h]: ["GET", "/analysis/detector-models/{analysisId}/results", 200],
+    },
+    () => GetDetectorModelAnalysisResultsRequest,
+    () => GetDetectorModelAnalysisResultsResponse,
+];
+var ListAlarmModels = [
+    9,
+    n0,
+    _LAM,
+    {
+        [_h]: ["GET", "/alarm-models", 200],
+    },
+    () => ListAlarmModelsRequest,
+    () => ListAlarmModelsResponse,
+];
+var ListAlarmModelVersions = [
+    9,
+    n0,
+    _LAMV,
+    {
+        [_h]: ["GET", "/alarm-models/{alarmModelName}/versions", 200],
+    },
+    () => ListAlarmModelVersionsRequest,
+    () => ListAlarmModelVersionsResponse,
+];
+var ListDetectorModels = [
+    9,
+    n0,
+    _LDM,
+    {
+        [_h]: ["GET", "/detector-models", 200],
+    },
+    () => ListDetectorModelsRequest,
+    () => ListDetectorModelsResponse,
+];
+var ListDetectorModelVersions = [
+    9,
+    n0,
+    _LDMV,
+    {
+        [_h]: ["GET", "/detector-models/{detectorModelName}/versions", 200],
+    },
+    () => ListDetectorModelVersionsRequest,
+    () => ListDetectorModelVersionsResponse,
+];
+var ListInputRoutings = [
+    9,
+    n0,
+    _LIRis,
+    {
+        [_h]: ["POST", "/input-routings", 200],
+    },
+    () => ListInputRoutingsRequest,
+    () => ListInputRoutingsResponse,
+];
+var ListInputs = [
+    9,
+    n0,
+    _LI,
+    {
+        [_h]: ["GET", "/inputs", 200],
+    },
+    () => ListInputsRequest,
+    () => ListInputsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PutLoggingOptions = [
+    9,
+    n0,
+    _PLO,
+    {
+        [_h]: ["PUT", "/logging", 200],
+    },
+    () => PutLoggingOptionsRequest,
+    () => __Unit,
+];
+var StartDetectorModelAnalysis = [
+    9,
+    n0,
+    _SDMA,
+    {
+        [_h]: ["POST", "/analysis/detector-models", 200],
+    },
+    () => StartDetectorModelAnalysisRequest,
+    () => StartDetectorModelAnalysisResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateAlarmModel = [
+    9,
+    n0,
+    _UAM,
+    {
+        [_h]: ["POST", "/alarm-models/{alarmModelName}", 200],
+    },
+    () => UpdateAlarmModelRequest,
+    () => UpdateAlarmModelResponse,
+];
+var UpdateDetectorModel = [
+    9,
+    n0,
+    _UDM,
+    {
+        [_h]: ["POST", "/detector-models/{detectorModelName}", 200],
+    },
+    () => UpdateDetectorModelRequest,
+    () => UpdateDetectorModelResponse,
+];
+var UpdateInput = [
+    9,
+    n0,
+    _UI,
+    {
+        [_h]: ["PUT", "/inputs/{inputName}", 200],
+    },
+    () => UpdateInputRequest,
+    () => UpdateInputResponse,
+];
 
 class CreateAlarmModelCommand 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("IotColumboService", "CreateAlarmModel", {})
     .n("IoTEventsClient", "CreateAlarmModelCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateAlarmModelCommand)
-    .de(de_CreateAlarmModelCommand)
+    .sc(CreateAlarmModel)
     .build() {
 }
 
@@ -1326,16 +1651,11 @@ class CreateDetectorModelCommand 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("IotColumboService", "CreateDetectorModel", {})
     .n("IoTEventsClient", "CreateDetectorModelCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDetectorModelCommand)
-    .de(de_CreateDetectorModelCommand)
+    .sc(CreateDetectorModel)
     .build() {
 }
 
@@ -1343,16 +1663,11 @@ class CreateInputCommand 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("IotColumboService", "CreateInput", {})
     .n("IoTEventsClient", "CreateInputCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateInputCommand)
-    .de(de_CreateInputCommand)
+    .sc(CreateInput)
     .build() {
 }
 
@@ -1360,16 +1675,11 @@ class DeleteAlarmModelCommand 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("IotColumboService", "DeleteAlarmModel", {})
     .n("IoTEventsClient", "DeleteAlarmModelCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteAlarmModelCommand)
-    .de(de_DeleteAlarmModelCommand)
+    .sc(DeleteAlarmModel)
     .build() {
 }
 
@@ -1377,16 +1687,11 @@ class DeleteDetectorModelCommand 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("IotColumboService", "DeleteDetectorModel", {})
     .n("IoTEventsClient", "DeleteDetectorModelCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDetectorModelCommand)
-    .de(de_DeleteDetectorModelCommand)
+    .sc(DeleteDetectorModel)
     .build() {
 }
 
@@ -1394,16 +1699,11 @@ class DeleteInputCommand 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("IotColumboService", "DeleteInput", {})
     .n("IoTEventsClient", "DeleteInputCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteInputCommand)
-    .de(de_DeleteInputCommand)
+    .sc(DeleteInput)
     .build() {
 }
 
@@ -1411,16 +1711,11 @@ class DescribeAlarmModelCommand 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("IotColumboService", "DescribeAlarmModel", {})
     .n("IoTEventsClient", "DescribeAlarmModelCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeAlarmModelCommand)
-    .de(de_DescribeAlarmModelCommand)
+    .sc(DescribeAlarmModel)
     .build() {
 }
 
@@ -1428,16 +1723,11 @@ class DescribeDetectorModelAnalysisCommand 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("IotColumboService", "DescribeDetectorModelAnalysis", {})
     .n("IoTEventsClient", "DescribeDetectorModelAnalysisCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDetectorModelAnalysisCommand)
-    .de(de_DescribeDetectorModelAnalysisCommand)
+    .sc(DescribeDetectorModelAnalysis)
     .build() {
 }
 
@@ -1445,16 +1735,11 @@ class DescribeDetectorModelCommand 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("IotColumboService", "DescribeDetectorModel", {})
     .n("IoTEventsClient", "DescribeDetectorModelCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDetectorModelCommand)
-    .de(de_DescribeDetectorModelCommand)
+    .sc(DescribeDetectorModel)
     .build() {
 }
 
@@ -1462,16 +1747,11 @@ class DescribeInputCommand 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("IotColumboService", "DescribeInput", {})
     .n("IoTEventsClient", "DescribeInputCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeInputCommand)
-    .de(de_DescribeInputCommand)
+    .sc(DescribeInput)
     .build() {
 }
 
@@ -1479,16 +1759,11 @@ class DescribeLoggingOptionsCommand 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("IotColumboService", "DescribeLoggingOptions", {})
     .n("IoTEventsClient", "DescribeLoggingOptionsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeLoggingOptionsCommand)
-    .de(de_DescribeLoggingOptionsCommand)
+    .sc(DescribeLoggingOptions)
     .build() {
 }
 
@@ -1496,16 +1771,11 @@ class GetDetectorModelAnalysisResultsCommand 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("IotColumboService", "GetDetectorModelAnalysisResults", {})
     .n("IoTEventsClient", "GetDetectorModelAnalysisResultsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDetectorModelAnalysisResultsCommand)
-    .de(de_GetDetectorModelAnalysisResultsCommand)
+    .sc(GetDetectorModelAnalysisResults)
     .build() {
 }
 
@@ -1513,16 +1783,11 @@ class ListAlarmModelsCommand 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("IotColumboService", "ListAlarmModels", {})
     .n("IoTEventsClient", "ListAlarmModelsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListAlarmModelsCommand)
-    .de(de_ListAlarmModelsCommand)
+    .sc(ListAlarmModels)
     .build() {
 }
 
@@ -1530,16 +1795,11 @@ class ListAlarmModelVersionsCommand 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("IotColumboService", "ListAlarmModelVersions", {})
     .n("IoTEventsClient", "ListAlarmModelVersionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListAlarmModelVersionsCommand)
-    .de(de_ListAlarmModelVersionsCommand)
+    .sc(ListAlarmModelVersions)
     .build() {
 }
 
@@ -1547,16 +1807,11 @@ class ListDetectorModelsCommand 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("IotColumboService", "ListDetectorModels", {})
     .n("IoTEventsClient", "ListDetectorModelsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDetectorModelsCommand)
-    .de(de_ListDetectorModelsCommand)
+    .sc(ListDetectorModels)
     .build() {
 }
 
@@ -1564,16 +1819,11 @@ class ListDetectorModelVersionsCommand 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("IotColumboService", "ListDetectorModelVersions", {})
     .n("IoTEventsClient", "ListDetectorModelVersionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDetectorModelVersionsCommand)
-    .de(de_ListDetectorModelVersionsCommand)
+    .sc(ListDetectorModelVersions)
     .build() {
 }
 
@@ -1581,16 +1831,11 @@ class ListInputRoutingsCommand 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("IotColumboService", "ListInputRoutings", {})
     .n("IoTEventsClient", "ListInputRoutingsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListInputRoutingsCommand)
-    .de(de_ListInputRoutingsCommand)
+    .sc(ListInputRoutings)
     .build() {
 }
 
@@ -1598,16 +1843,11 @@ class ListInputsCommand 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("IotColumboService", "ListInputs", {})
     .n("IoTEventsClient", "ListInputsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListInputsCommand)
-    .de(de_ListInputsCommand)
+    .sc(ListInputs)
     .build() {
 }
 
@@ -1615,16 +1855,11 @@ class ListTagsForResourceCommand 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("IotColumboService", "ListTagsForResource", {})
     .n("IoTEventsClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1632,16 +1867,11 @@ class PutLoggingOptionsCommand 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("IotColumboService", "PutLoggingOptions", {})
     .n("IoTEventsClient", "PutLoggingOptionsCommand")
-    .f(void 0, void 0)
-    .ser(se_PutLoggingOptionsCommand)
-    .de(de_PutLoggingOptionsCommand)
+    .sc(PutLoggingOptions)
     .build() {
 }
 
@@ -1649,16 +1879,11 @@ class StartDetectorModelAnalysisCommand 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("IotColumboService", "StartDetectorModelAnalysis", {})
     .n("IoTEventsClient", "StartDetectorModelAnalysisCommand")
-    .f(void 0, void 0)
-    .ser(se_StartDetectorModelAnalysisCommand)
-    .de(de_StartDetectorModelAnalysisCommand)
+    .sc(StartDetectorModelAnalysis)
     .build() {
 }
 
@@ -1666,16 +1891,11 @@ class TagResourceCommand 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("IotColumboService", "TagResource", {})
     .n("IoTEventsClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1683,16 +1903,11 @@ class UntagResourceCommand 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("IotColumboService", "UntagResource", {})
     .n("IoTEventsClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1700,16 +1915,11 @@ class UpdateAlarmModelCommand 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("IotColumboService", "UpdateAlarmModel", {})
     .n("IoTEventsClient", "UpdateAlarmModelCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateAlarmModelCommand)
-    .de(de_UpdateAlarmModelCommand)
+    .sc(UpdateAlarmModel)
     .build() {
 }
 
@@ -1717,16 +1927,11 @@ class UpdateDetectorModelCommand 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("IotColumboService", "UpdateDetectorModel", {})
     .n("IoTEventsClient", "UpdateDetectorModelCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDetectorModelCommand)
-    .de(de_UpdateDetectorModelCommand)
+    .sc(UpdateDetectorModel)
     .build() {
 }
 
@@ -1734,16 +1939,11 @@ class UpdateInputCommand 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("IotColumboService", "UpdateInput", {})
     .n("IoTEventsClient", "UpdateInputCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateInputCommand)
-    .de(de_UpdateInputCommand)
+    .sc(UpdateInput)
     .build() {
 }
 
@@ -1806,12 +2006,12 @@ exports.DetectorModelVersionStatus = DetectorModelVersionStatus;
 exports.EvaluationMethod = EvaluationMethod;
 exports.GetDetectorModelAnalysisResultsCommand = GetDetectorModelAnalysisResultsCommand;
 exports.InputStatus = InputStatus;
-exports.InternalFailureException = InternalFailureException;
-exports.InvalidRequestException = InvalidRequestException;
+exports.InternalFailureException = InternalFailureException$1;
+exports.InvalidRequestException = InvalidRequestException$1;
 exports.IoTEvents = IoTEvents;
 exports.IoTEventsClient = IoTEventsClient;
-exports.IoTEventsServiceException = IoTEventsServiceException;
-exports.LimitExceededException = LimitExceededException;
+exports.IoTEventsServiceException = IoTEventsServiceException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListAlarmModelVersionsCommand = ListAlarmModelVersionsCommand;
 exports.ListAlarmModelsCommand = ListAlarmModelsCommand;
 exports.ListDetectorModelVersionsCommand = ListDetectorModelVersionsCommand;
@@ -1822,14 +2022,14 @@ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.LoggingLevel = LoggingLevel;
 exports.PayloadType = PayloadType;
 exports.PutLoggingOptionsCommand = PutLoggingOptionsCommand;
-exports.ResourceAlreadyExistsException = ResourceAlreadyExistsException;
-exports.ResourceInUseException = ResourceInUseException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
-exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.ResourceAlreadyExistsException = ResourceAlreadyExistsException$1;
+exports.ResourceInUseException = ResourceInUseException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
 exports.StartDetectorModelAnalysisCommand = StartDetectorModelAnalysisCommand;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
-exports.UnsupportedOperationException = UnsupportedOperationException;
+exports.ThrottlingException = ThrottlingException$1;
+exports.UnsupportedOperationException = UnsupportedOperationException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateAlarmModelCommand = UpdateAlarmModelCommand;
 exports.UpdateDetectorModelCommand = UpdateDetectorModelCommand;