@aws-sdk/client-iotsecuretunneling 3.927.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 IoTSecureTunnelingClient 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,19 +110,19 @@ class IoTSecureTunnelingClient extends smithyClient.Client {
     }
 }
 
-class IoTSecureTunnelingServiceException extends smithyClient.ServiceException {
+let IoTSecureTunnelingServiceException$1 = class IoTSecureTunnelingServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, IoTSecureTunnelingServiceException.prototype);
     }
-}
+};
 
 const ClientMode = {
     ALL: "ALL",
     DESTINATION: "DESTINATION",
     SOURCE: "SOURCE",
 };
-class ResourceNotFoundException extends IoTSecureTunnelingServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends IoTSecureTunnelingServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -133,7 +133,7 @@ class ResourceNotFoundException extends IoTSecureTunnelingServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
+};
 const ConnectionStatus = {
     CONNECTED: "CONNECTED",
     DISCONNECTED: "DISCONNECTED",
@@ -142,7 +142,7 @@ const TunnelStatus = {
     CLOSED: "CLOSED",
     OPEN: "OPEN",
 };
-class LimitExceededException extends IoTSecureTunnelingServiceException {
+let LimitExceededException$1 = class LimitExceededException extends IoTSecureTunnelingServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -153,303 +153,330 @@ class LimitExceededException extends IoTSecureTunnelingServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
-const OpenTunnelResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sourceAccessToken && { sourceAccessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.destinationAccessToken && { destinationAccessToken: smithyClient.SENSITIVE_STRING }),
-});
-const RotateTunnelAccessTokenResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.sourceAccessToken && { sourceAccessToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.destinationAccessToken && { destinationAccessToken: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_CloseTunnelCommand = async (input, context) => {
-    const headers = sharedHeaders("CloseTunnel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeTunnelCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeTunnel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTunnelsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTunnels");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_OpenTunnelCommand = async (input, context) => {
-    const headers = sharedHeaders("OpenTunnel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RotateTunnelAccessTokenCommand = async (input, context) => {
-    const headers = sharedHeaders("RotateTunnelAccessToken");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CloseTunnelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTunnelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeTunnelResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTunnelsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListTunnelsResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_OpenTunnelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RotateTunnelAccessTokenCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-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 "ResourceNotFoundException":
-        case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.iotsecuretunneling#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ConnectionState = (output, context) => {
-    return smithyClient.take(output, {
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-    });
-};
-const de_DescribeTunnelResponse = (output, context) => {
-    return smithyClient.take(output, {
-        tunnel: (_) => de_Tunnel(_),
-    });
 };
-const de_ListTunnelsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        tunnelSummaries: (_) => de_TunnelSummaryList(_),
-    });
-};
-const de_Tunnel = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        destinationConfig: smithyClient._json,
-        destinationConnectionState: (_) => de_ConnectionState(_),
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        sourceConnectionState: (_) => de_ConnectionState(_),
-        status: smithyClient.expectString,
-        tags: smithyClient._json,
-        timeoutConfig: smithyClient._json,
-        tunnelArn: smithyClient.expectString,
-        tunnelId: smithyClient.expectString,
-    });
-};
-const de_TunnelSummary = (output, context) => {
-    return smithyClient.take(output, {
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        lastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-        tunnelArn: smithyClient.expectString,
-        tunnelId: smithyClient.expectString,
-    });
-};
-const de_TunnelSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TunnelSummary(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(IoTSecureTunnelingServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `IoTSecuredTunneling.${operation}`,
-    };
-}
+
+const _CAT = "ClientAccessToken";
+const _CS = "ConnectionState";
+const _CT = "CloseTunnel";
+const _CTR = "CloseTunnelRequest";
+const _CTRl = "CloseTunnelResponse";
+const _DC = "DestinationConfig";
+const _DT = "DescribeTunnel";
+const _DTR = "DescribeTunnelRequest";
+const _DTRe = "DescribeTunnelResponse";
+const _LEE = "LimitExceededException";
+const _LT = "ListTunnels";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LTR = "ListTunnelsRequest";
+const _LTRi = "ListTunnelsResponse";
+const _OT = "OpenTunnel";
+const _OTR = "OpenTunnelRequest";
+const _OTRp = "OpenTunnelResponse";
+const _RNFE = "ResourceNotFoundException";
+const _RTAT = "RotateTunnelAccessToken";
+const _RTATR = "RotateTunnelAccessTokenRequest";
+const _RTATRo = "RotateTunnelAccessTokenResponse";
+const _T = "Tag";
+const _TC = "TimeoutConfig";
+const _TL = "TagList";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TS = "TunnelSummary";
+const _TSL = "TunnelSummaryList";
+const _Tu = "Tunnel";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _cA = "createdAt";
+const _cM = "clientMode";
+const _d = "delete";
+const _dAT = "destinationAccessToken";
+const _dC = "destinationConfig";
+const _dCS = "destinationConnectionState";
+const _de = "description";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _k = "key";
+const _lUA = "lastUpdatedAt";
+const _m = "message";
+const _mLTM = "maxLifetimeTimeoutMinutes";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _rA = "resourceArn";
+const _s = "status";
+const _sAT = "sourceAccessToken";
+const _sCS = "sourceConnectionState";
+const _se = "services";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.iotsecuretunneling";
+const _t = "tunnel";
+const _tA = "tunnelArn";
+const _tC = "timeoutConfig";
+const _tI = "tunnelId";
+const _tK = "tagKeys";
+const _tN = "thingName";
+const _tS = "tunnelSummaries";
+const _ta = "tags";
+const _v = "value";
+const n0 = "com.amazonaws.iotsecuretunneling";
+var ClientAccessToken = [0, n0, _CAT, 8, 0];
+var CloseTunnelRequest = [
+    3,
+    n0,
+    _CTR,
+    0,
+    [_tI, _d],
+    [
+        [0, 1],
+        [
+            2,
+            {
+                [_hQ]: _d,
+            },
+        ],
+    ],
+];
+var CloseTunnelResponse = [3, n0, _CTRl, 0, [], []];
+var ConnectionState = [3, n0, _CS, 0, [_s, _lUA], [0, 4]];
+var DescribeTunnelRequest = [3, n0, _DTR, 0, [_tI], [[0, 1]]];
+var DescribeTunnelResponse = [3, n0, _DTRe, 0, [_t], [() => Tunnel]];
+var DestinationConfig = [3, n0, _DC, 0, [_tN, _se], [0, 64 | 0]];
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`LimitExceededException`, 403],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListTagsForResourceRequest = [
+    3,
+    n0,
+    _LTFRR,
+    0,
+    [_rA],
+    [
+        [
+            0,
+            {
+                [_hQ]: _rA,
+            },
+        ],
+    ],
+];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_ta], [() => TagList]];
+var ListTunnelsRequest = [
+    3,
+    n0,
+    _LTR,
+    0,
+    [_tN, _mR, _nT],
+    [
+        [
+            0,
+            {
+                [_hQ]: _tN,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var ListTunnelsResponse = [3, n0, _LTRi, 0, [_tS, _nT], [() => TunnelSummaryList, 0]];
+var OpenTunnelRequest = [
+    3,
+    n0,
+    _OTR,
+    0,
+    [_de, _ta, _dC, _tC],
+    [0, () => TagList, () => DestinationConfig, () => TimeoutConfig],
+];
+var OpenTunnelResponse = [
+    3,
+    n0,
+    _OTRp,
+    0,
+    [_tI, _tA, _sAT, _dAT],
+    [0, 0, [() => ClientAccessToken, 0], [() => ClientAccessToken, 0]],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+        [_aQE]: [`ResourceNotFoundException`, 404],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var RotateTunnelAccessTokenRequest = [
+    3,
+    n0,
+    _RTATR,
+    0,
+    [_tI, _cM, _dC],
+    [[0, 1], 0, () => DestinationConfig],
+];
+var RotateTunnelAccessTokenResponse = [
+    3,
+    n0,
+    _RTATRo,
+    0,
+    [_tA, _sAT, _dAT],
+    [0, [() => ClientAccessToken, 0], [() => ClientAccessToken, 0]],
+];
+var Tag = [3, n0, _T, 0, [_k, _v], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _ta], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TimeoutConfig = [3, n0, _TC, 0, [_mLTM], [1]];
+var Tunnel = [
+    3,
+    n0,
+    _Tu,
+    0,
+    [_tI, _tA, _s, _sCS, _dCS, _de, _dC, _tC, _ta, _cA, _lUA],
+    [
+        0,
+        0,
+        0,
+        () => ConnectionState,
+        () => ConnectionState,
+        0,
+        () => DestinationConfig,
+        () => TimeoutConfig,
+        () => TagList,
+        4,
+        4,
+    ],
+];
+var TunnelSummary = [3, n0, _TS, 0, [_tI, _tA, _s, _de, _cA, _lUA], [0, 0, 0, 0, 4, 4]];
+var UntagResourceRequest = [3, n0, _URR, 0, [_rA, _tK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var IoTSecureTunnelingServiceException = [
+    -3,
+    _sm,
+    "IoTSecureTunnelingServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(IoTSecureTunnelingServiceException, IoTSecureTunnelingServiceException$1);
+var TagList = [1, n0, _TL, 0, () => Tag];
+var TunnelSummaryList = [1, n0, _TSL, 0, () => TunnelSummary];
+var CloseTunnel = [
+    9,
+    n0,
+    _CT,
+    {
+        [_h]: ["DELETE", "/tunnels/{tunnelId}", 200],
+    },
+    () => CloseTunnelRequest,
+    () => CloseTunnelResponse,
+];
+var DescribeTunnel = [
+    9,
+    n0,
+    _DT,
+    {
+        [_h]: ["GET", "/tunnels/{tunnelId}", 200],
+    },
+    () => DescribeTunnelRequest,
+    () => DescribeTunnelResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var ListTunnels = [
+    9,
+    n0,
+    _LT,
+    {
+        [_h]: ["GET", "/tunnels", 200],
+    },
+    () => ListTunnelsRequest,
+    () => ListTunnelsResponse,
+];
+var OpenTunnel = [
+    9,
+    n0,
+    _OT,
+    {
+        [_h]: ["POST", "/tunnels", 200],
+    },
+    () => OpenTunnelRequest,
+    () => OpenTunnelResponse,
+];
+var RotateTunnelAccessToken = [
+    9,
+    n0,
+    _RTAT,
+    {
+        [_h]: ["POST", "/tunnel/{tunnelId}/rotate", 200],
+    },
+    () => RotateTunnelAccessTokenRequest,
+    () => RotateTunnelAccessTokenResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/tags", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/untag", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
 
 class CloseTunnelCommand 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("IoTSecuredTunneling", "CloseTunnel", {})
     .n("IoTSecureTunnelingClient", "CloseTunnelCommand")
-    .f(void 0, void 0)
-    .ser(se_CloseTunnelCommand)
-    .de(de_CloseTunnelCommand)
+    .sc(CloseTunnel)
     .build() {
 }
 
@@ -457,16 +484,11 @@ class DescribeTunnelCommand 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("IoTSecuredTunneling", "DescribeTunnel", {})
     .n("IoTSecureTunnelingClient", "DescribeTunnelCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeTunnelCommand)
-    .de(de_DescribeTunnelCommand)
+    .sc(DescribeTunnel)
     .build() {
 }
 
@@ -474,16 +496,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("IoTSecuredTunneling", "ListTagsForResource", {})
     .n("IoTSecureTunnelingClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -491,16 +508,11 @@ class ListTunnelsCommand 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("IoTSecuredTunneling", "ListTunnels", {})
     .n("IoTSecureTunnelingClient", "ListTunnelsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTunnelsCommand)
-    .de(de_ListTunnelsCommand)
+    .sc(ListTunnels)
     .build() {
 }
 
@@ -508,16 +520,11 @@ class OpenTunnelCommand 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("IoTSecuredTunneling", "OpenTunnel", {})
     .n("IoTSecureTunnelingClient", "OpenTunnelCommand")
-    .f(void 0, OpenTunnelResponseFilterSensitiveLog)
-    .ser(se_OpenTunnelCommand)
-    .de(de_OpenTunnelCommand)
+    .sc(OpenTunnel)
     .build() {
 }
 
@@ -525,16 +532,11 @@ class RotateTunnelAccessTokenCommand 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("IoTSecuredTunneling", "RotateTunnelAccessToken", {})
     .n("IoTSecureTunnelingClient", "RotateTunnelAccessTokenCommand")
-    .f(void 0, RotateTunnelAccessTokenResponseFilterSensitiveLog)
-    .ser(se_RotateTunnelAccessTokenCommand)
-    .de(de_RotateTunnelAccessTokenCommand)
+    .sc(RotateTunnelAccessToken)
     .build() {
 }
 
@@ -542,16 +544,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("IoTSecuredTunneling", "TagResource", {})
     .n("IoTSecureTunnelingClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -559,16 +556,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("IoTSecuredTunneling", "UntagResource", {})
     .n("IoTSecureTunnelingClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -602,15 +594,13 @@ exports.ConnectionStatus = ConnectionStatus;
 exports.DescribeTunnelCommand = DescribeTunnelCommand;
 exports.IoTSecureTunneling = IoTSecureTunneling;
 exports.IoTSecureTunnelingClient = IoTSecureTunnelingClient;
-exports.IoTSecureTunnelingServiceException = IoTSecureTunnelingServiceException;
-exports.LimitExceededException = LimitExceededException;
+exports.IoTSecureTunnelingServiceException = IoTSecureTunnelingServiceException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListTunnelsCommand = ListTunnelsCommand;
 exports.OpenTunnelCommand = OpenTunnelCommand;
-exports.OpenTunnelResponseFilterSensitiveLog = OpenTunnelResponseFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.RotateTunnelAccessTokenCommand = RotateTunnelAccessTokenCommand;
-exports.RotateTunnelAccessTokenResponseFilterSensitiveLog = RotateTunnelAccessTokenResponseFilterSensitiveLog;
 exports.TagResourceCommand = TagResourceCommand;
 exports.TunnelStatus = TunnelStatus;
 exports.UntagResourceCommand = UntagResourceCommand;