New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
@aws-sdk/client-iotsecuretunneling
Advanced tools
@aws-sdk/client-iotsecuretunneling - npm Package Compare versions
Comparing version 3.490.0 to 3.495.0
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.CloseTunnelCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class CloseTunnelCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "CloseTunnel", {}) | ||
| .n("IoTSecureTunnelingClient", "CloseTunnelCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_CloseTunnelCommand) | ||
| .de(Aws_json1_1_1.de_CloseTunnelCommand) | ||
| .build() { | ||
| } | ||
| exports.CloseTunnelCommand = CloseTunnelCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.DescribeTunnelCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class DescribeTunnelCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "DescribeTunnel", {}) | ||
| .n("IoTSecureTunnelingClient", "DescribeTunnelCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_DescribeTunnelCommand) | ||
| .de(Aws_json1_1_1.de_DescribeTunnelCommand) | ||
| .build() { | ||
| } | ||
| exports.DescribeTunnelCommand = DescribeTunnelCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,11 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| const tslib_1 = require("tslib"); | ||
| tslib_1.__exportStar(require("./CloseTunnelCommand"), exports); | ||
| tslib_1.__exportStar(require("./DescribeTunnelCommand"), exports); | ||
| tslib_1.__exportStar(require("./ListTagsForResourceCommand"), exports); | ||
| tslib_1.__exportStar(require("./ListTunnelsCommand"), exports); | ||
| tslib_1.__exportStar(require("./OpenTunnelCommand"), exports); | ||
| tslib_1.__exportStar(require("./RotateTunnelAccessTokenCommand"), exports); | ||
| tslib_1.__exportStar(require("./TagResourceCommand"), exports); | ||
| tslib_1.__exportStar(require("./UntagResourceCommand"), exports); | ||
| module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.ListTagsForResourceCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class ListTagsForResourceCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "ListTagsForResource", {}) | ||
| .n("IoTSecureTunnelingClient", "ListTagsForResourceCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_ListTagsForResourceCommand) | ||
| .de(Aws_json1_1_1.de_ListTagsForResourceCommand) | ||
| .build() { | ||
| } | ||
| exports.ListTagsForResourceCommand = ListTagsForResourceCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.ListTunnelsCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class ListTunnelsCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "ListTunnels", {}) | ||
| .n("IoTSecureTunnelingClient", "ListTunnelsCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_ListTunnelsCommand) | ||
| .de(Aws_json1_1_1.de_ListTunnelsCommand) | ||
| .build() { | ||
| } | ||
| exports.ListTunnelsCommand = ListTunnelsCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,29 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.OpenTunnelCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const models_0_1 = require("../models/models_0"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class OpenTunnelCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "OpenTunnel", {}) | ||
| .n("IoTSecureTunnelingClient", "OpenTunnelCommand") | ||
| .f(void 0, models_0_1.OpenTunnelResponseFilterSensitiveLog) | ||
| .ser(Aws_json1_1_1.se_OpenTunnelCommand) | ||
| .de(Aws_json1_1_1.de_OpenTunnelCommand) | ||
| .build() { | ||
| } | ||
| exports.OpenTunnelCommand = OpenTunnelCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,29 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.RotateTunnelAccessTokenCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const models_0_1 = require("../models/models_0"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class RotateTunnelAccessTokenCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "RotateTunnelAccessToken", {}) | ||
| .n("IoTSecureTunnelingClient", "RotateTunnelAccessTokenCommand") | ||
| .f(void 0, models_0_1.RotateTunnelAccessTokenResponseFilterSensitiveLog) | ||
| .ser(Aws_json1_1_1.se_RotateTunnelAccessTokenCommand) | ||
| .de(Aws_json1_1_1.de_RotateTunnelAccessTokenCommand) | ||
| .build() { | ||
| } | ||
| exports.RotateTunnelAccessTokenCommand = RotateTunnelAccessTokenCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.TagResourceCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class TagResourceCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "TagResource", {}) | ||
| .n("IoTSecureTunnelingClient", "TagResourceCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_TagResourceCommand) | ||
| .de(Aws_json1_1_1.de_TagResourceCommand) | ||
| .build() { | ||
| } | ||
| exports.TagResourceCommand = TagResourceCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,28 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.UntagResourceCommand = exports.$Command = void 0; | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_serde_1 = require("@smithy/middleware-serde"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "$Command", { enumerable: true, get: function () { return smithy_client_1.Command; } }); | ||
| const EndpointParameters_1 = require("../endpoint/EndpointParameters"); | ||
| const Aws_json1_1_1 = require("../protocols/Aws_json1_1"); | ||
| class UntagResourceCommand extends smithy_client_1.Command | ||
| .classBuilder() | ||
| .ep({ | ||
| ...EndpointParameters_1.commonParams, | ||
| }) | ||
| .m(function (Command, cs, config, o) { | ||
| return [ | ||
| (0, middleware_serde_1.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, middleware_endpoint_1.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()), | ||
| ]; | ||
| }) | ||
| .s("IoTSecuredTunneling", "UntagResource", {}) | ||
| .n("IoTSecureTunnelingClient", "UntagResourceCommand") | ||
| .f(void 0, void 0) | ||
| .ser(Aws_json1_1_1.se_UntagResourceCommand) | ||
| .de(Aws_json1_1_1.de_UntagResourceCommand) | ||
| .build() { | ||
| } | ||
| exports.UntagResourceCommand = UntagResourceCommand; | ||
| module.exports = require("../index.js"); |
@@ -1,18 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.commonParams = exports.resolveClientEndpointParameters = void 0; | ||
| const resolveClientEndpointParameters = (options) => { | ||
| return { | ||
| ...options, | ||
| useDualstackEndpoint: options.useDualstackEndpoint ?? false, | ||
| useFipsEndpoint: options.useFipsEndpoint ?? false, | ||
| defaultSigningName: "IoTSecuredTunneling", | ||
| }; | ||
| }; | ||
| exports.resolveClientEndpointParameters = resolveClientEndpointParameters; | ||
| exports.commonParams = { | ||
| UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, | ||
| Endpoint: { type: "builtInParams", name: "endpoint" }, | ||
| Region: { type: "builtInParams", name: "region" }, | ||
| UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }, | ||
| }; | ||
| module.exports = require("../index.js"); |
@@ -1,2 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| module.exports = require("./index.js"); |
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.IoTSecureTunnelingServiceException = void 0; | ||
| const tslib_1 = require("tslib"); | ||
| tslib_1.__exportStar(require("./IoTSecureTunnelingClient"), exports); | ||
| tslib_1.__exportStar(require("./IoTSecureTunneling"), exports); | ||
| tslib_1.__exportStar(require("./commands"), exports); | ||
| tslib_1.__exportStar(require("./pagination"), exports); | ||
| tslib_1.__exportStar(require("./models"), exports); | ||
| require("@aws-sdk/util-endpoints"); | ||
| var IoTSecureTunnelingServiceException_1 = require("./models/IoTSecureTunnelingServiceException"); | ||
| Object.defineProperty(exports, "IoTSecureTunnelingServiceException", { enumerable: true, get: function () { return IoTSecureTunnelingServiceException_1.IoTSecureTunnelingServiceException; } }); | ||
| var __defProp = Object.defineProperty; | ||
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
| var __getOwnPropNames = Object.getOwnPropertyNames; | ||
| var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
| var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); | ||
| var __export = (target, all) => { | ||
| for (var name in all) | ||
| __defProp(target, name, { get: all[name], enumerable: true }); | ||
| }; | ||
| var __copyProps = (to, from, except, desc) => { | ||
| if (from && typeof from === "object" || typeof from === "function") { | ||
| for (let key of __getOwnPropNames(from)) | ||
| if (!__hasOwnProp.call(to, key) && key !== except) | ||
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
| } | ||
| return to; | ||
| }; | ||
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
| // src/index.ts | ||
| var src_exports = {}; | ||
| __export(src_exports, { | ||
| ClientMode: () => ClientMode, | ||
| CloseTunnelCommand: () => CloseTunnelCommand, | ||
| ConnectionStatus: () => ConnectionStatus, | ||
| DescribeTunnelCommand: () => DescribeTunnelCommand, | ||
| IoTSecureTunneling: () => IoTSecureTunneling, | ||
| IoTSecureTunnelingClient: () => IoTSecureTunnelingClient, | ||
| IoTSecureTunnelingServiceException: () => IoTSecureTunnelingServiceException, | ||
| LimitExceededException: () => LimitExceededException, | ||
| ListTagsForResourceCommand: () => ListTagsForResourceCommand, | ||
| ListTunnelsCommand: () => ListTunnelsCommand, | ||
| OpenTunnelCommand: () => OpenTunnelCommand, | ||
| OpenTunnelResponseFilterSensitiveLog: () => OpenTunnelResponseFilterSensitiveLog, | ||
| ResourceNotFoundException: () => ResourceNotFoundException, | ||
| RotateTunnelAccessTokenCommand: () => RotateTunnelAccessTokenCommand, | ||
| RotateTunnelAccessTokenResponseFilterSensitiveLog: () => RotateTunnelAccessTokenResponseFilterSensitiveLog, | ||
| TagResourceCommand: () => TagResourceCommand, | ||
| TunnelStatus: () => TunnelStatus, | ||
| UntagResourceCommand: () => UntagResourceCommand, | ||
| __Client: () => import_smithy_client.Client, | ||
| paginateListTunnels: () => paginateListTunnels | ||
| }); | ||
| module.exports = __toCommonJS(src_exports); | ||
| // src/IoTSecureTunnelingClient.ts | ||
| var import_middleware_host_header = require("@aws-sdk/middleware-host-header"); | ||
| var import_middleware_logger = require("@aws-sdk/middleware-logger"); | ||
| var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection"); | ||
| var import_middleware_signing = require("@aws-sdk/middleware-signing"); | ||
| var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent"); | ||
| var import_config_resolver = require("@smithy/config-resolver"); | ||
| var import_middleware_content_length = require("@smithy/middleware-content-length"); | ||
| var import_middleware_endpoint = require("@smithy/middleware-endpoint"); | ||
| var import_middleware_retry = require("@smithy/middleware-retry"); | ||
| // src/endpoint/EndpointParameters.ts | ||
| var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => { | ||
| return { | ||
| ...options, | ||
| useDualstackEndpoint: options.useDualstackEndpoint ?? false, | ||
| useFipsEndpoint: options.useFipsEndpoint ?? false, | ||
| defaultSigningName: "IoTSecuredTunneling" | ||
| }; | ||
| }, "resolveClientEndpointParameters"); | ||
| var commonParams = { | ||
| UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" }, | ||
| Endpoint: { type: "builtInParams", name: "endpoint" }, | ||
| Region: { type: "builtInParams", name: "region" }, | ||
| UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" } | ||
| }; | ||
| // src/IoTSecureTunnelingClient.ts | ||
| var import_runtimeConfig = require("././runtimeConfig"); | ||
| // src/runtimeExtensions.ts | ||
| var import_region_config_resolver = require("@aws-sdk/region-config-resolver"); | ||
| var import_protocol_http = require("@smithy/protocol-http"); | ||
| var import_smithy_client = require("@smithy/smithy-client"); | ||
| var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial"); | ||
| var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => { | ||
| const extensionConfiguration = { | ||
| ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)), | ||
| ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)), | ||
| ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)) | ||
| }; | ||
| extensions.forEach((extension) => extension.configure(extensionConfiguration)); | ||
| return { | ||
| ...runtimeConfig, | ||
| ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration), | ||
| ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration), | ||
| ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration) | ||
| }; | ||
| }, "resolveRuntimeExtensions"); | ||
| // src/IoTSecureTunnelingClient.ts | ||
| var _IoTSecureTunnelingClient = class _IoTSecureTunnelingClient extends import_smithy_client.Client { | ||
| constructor(...[configuration]) { | ||
| const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {}); | ||
| const _config_1 = resolveClientEndpointParameters(_config_0); | ||
| const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1); | ||
| const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2); | ||
| const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3); | ||
| const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4); | ||
| const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5); | ||
| const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6); | ||
| const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []); | ||
| super(_config_8); | ||
| this.config = _config_8; | ||
| this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config)); | ||
| this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config)); | ||
| } | ||
| /** | ||
| * Destroy underlying resources, like sockets. It's usually not necessary to do this. | ||
| * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed. | ||
| * Otherwise, sockets might stay open for quite a long time before the server terminates them. | ||
| */ | ||
| destroy() { | ||
| super.destroy(); | ||
| } | ||
| }; | ||
| __name(_IoTSecureTunnelingClient, "IoTSecureTunnelingClient"); | ||
| var IoTSecureTunnelingClient = _IoTSecureTunnelingClient; | ||
| // src/IoTSecureTunneling.ts | ||
| // src/commands/CloseTunnelCommand.ts | ||
| var import_middleware_serde = require("@smithy/middleware-serde"); | ||
| var import_types = require("@smithy/types"); | ||
| // src/protocols/Aws_json1_1.ts | ||
| // src/models/IoTSecureTunnelingServiceException.ts | ||
| var _IoTSecureTunnelingServiceException = class _IoTSecureTunnelingServiceException extends import_smithy_client.ServiceException { | ||
| /** | ||
| * @internal | ||
| */ | ||
| constructor(options) { | ||
| super(options); | ||
| Object.setPrototypeOf(this, _IoTSecureTunnelingServiceException.prototype); | ||
| } | ||
| }; | ||
| __name(_IoTSecureTunnelingServiceException, "IoTSecureTunnelingServiceException"); | ||
| var IoTSecureTunnelingServiceException = _IoTSecureTunnelingServiceException; | ||
| // src/models/models_0.ts | ||
| var ClientMode = { | ||
| ALL: "ALL", | ||
| DESTINATION: "DESTINATION", | ||
| SOURCE: "SOURCE" | ||
| }; | ||
| var _ResourceNotFoundException = class _ResourceNotFoundException extends IoTSecureTunnelingServiceException { | ||
| /** | ||
| * @internal | ||
| */ | ||
| constructor(opts) { | ||
| super({ | ||
| name: "ResourceNotFoundException", | ||
| $fault: "client", | ||
| ...opts | ||
| }); | ||
| this.name = "ResourceNotFoundException"; | ||
| this.$fault = "client"; | ||
| Object.setPrototypeOf(this, _ResourceNotFoundException.prototype); | ||
| } | ||
| }; | ||
| __name(_ResourceNotFoundException, "ResourceNotFoundException"); | ||
| var ResourceNotFoundException = _ResourceNotFoundException; | ||
| var ConnectionStatus = { | ||
| CONNECTED: "CONNECTED", | ||
| DISCONNECTED: "DISCONNECTED" | ||
| }; | ||
| var TunnelStatus = { | ||
| CLOSED: "CLOSED", | ||
| OPEN: "OPEN" | ||
| }; | ||
| var _LimitExceededException = class _LimitExceededException extends IoTSecureTunnelingServiceException { | ||
| /** | ||
| * @internal | ||
| */ | ||
| constructor(opts) { | ||
| super({ | ||
| name: "LimitExceededException", | ||
| $fault: "client", | ||
| ...opts | ||
| }); | ||
| this.name = "LimitExceededException"; | ||
| this.$fault = "client"; | ||
| Object.setPrototypeOf(this, _LimitExceededException.prototype); | ||
| } | ||
| }; | ||
| __name(_LimitExceededException, "LimitExceededException"); | ||
| var LimitExceededException = _LimitExceededException; | ||
| var OpenTunnelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({ | ||
| ...obj, | ||
| ...obj.sourceAccessToken && { sourceAccessToken: import_smithy_client.SENSITIVE_STRING }, | ||
| ...obj.destinationAccessToken && { destinationAccessToken: import_smithy_client.SENSITIVE_STRING } | ||
| }), "OpenTunnelResponseFilterSensitiveLog"); | ||
| var RotateTunnelAccessTokenResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({ | ||
| ...obj, | ||
| ...obj.sourceAccessToken && { sourceAccessToken: import_smithy_client.SENSITIVE_STRING }, | ||
| ...obj.destinationAccessToken && { destinationAccessToken: import_smithy_client.SENSITIVE_STRING } | ||
| }), "RotateTunnelAccessTokenResponseFilterSensitiveLog"); | ||
| // src/protocols/Aws_json1_1.ts | ||
| var se_CloseTunnelCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("CloseTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_CloseTunnelCommand"); | ||
| var se_DescribeTunnelCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("DescribeTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_DescribeTunnelCommand"); | ||
| var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("ListTagsForResource"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_ListTagsForResourceCommand"); | ||
| var se_ListTunnelsCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("ListTunnels"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_ListTunnelsCommand"); | ||
| var se_OpenTunnelCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("OpenTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_OpenTunnelCommand"); | ||
| var se_RotateTunnelAccessTokenCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("RotateTunnelAccessToken"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_RotateTunnelAccessTokenCommand"); | ||
| var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("TagResource"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_TagResourceCommand"); | ||
| var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => { | ||
| const headers = sharedHeaders("UntagResource"); | ||
| let body; | ||
| body = JSON.stringify((0, import_smithy_client._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", void 0, body); | ||
| }, "se_UntagResourceCommand"); | ||
| var de_CloseTunnelCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_CloseTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_CloseTunnelCommand"); | ||
| var de_CloseTunnelCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_CloseTunnelCommandError"); | ||
| var de_DescribeTunnelCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_DescribeTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = de_DescribeTunnelResponse(data, context); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_DescribeTunnelCommand"); | ||
| var de_DescribeTunnelCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_DescribeTunnelCommandError"); | ||
| var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_ListTagsForResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_ListTagsForResourceCommand"); | ||
| var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_ListTagsForResourceCommandError"); | ||
| var de_ListTunnelsCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_ListTunnelsCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = de_ListTunnelsResponse(data, context); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_ListTunnelsCommand"); | ||
| var de_ListTunnelsCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| }, "de_ListTunnelsCommandError"); | ||
| var de_OpenTunnelCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_OpenTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_OpenTunnelCommand"); | ||
| var de_OpenTunnelCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "LimitExceededException": | ||
| case "com.amazonaws.iotsecuretunneling#LimitExceededException": | ||
| throw await de_LimitExceededExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_OpenTunnelCommandError"); | ||
| var de_RotateTunnelAccessTokenCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_RotateTunnelAccessTokenCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_RotateTunnelAccessTokenCommand"); | ||
| var de_RotateTunnelAccessTokenCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_RotateTunnelAccessTokenCommandError"); | ||
| var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_TagResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_TagResourceCommand"); | ||
| var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_TagResourceCommandError"); | ||
| var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_UntagResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, import_smithy_client._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents | ||
| }; | ||
| return response; | ||
| }, "de_UntagResourceCommand"); | ||
| var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context) | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode | ||
| }); | ||
| } | ||
| }, "de_UntagResourceCommandError"); | ||
| var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => { | ||
| const body = parsedOutput.body; | ||
| const deserialized = (0, import_smithy_client._json)(body); | ||
| const exception = new LimitExceededException({ | ||
| $metadata: deserializeMetadata(parsedOutput), | ||
| ...deserialized | ||
| }); | ||
| return (0, import_smithy_client.decorateServiceException)(exception, body); | ||
| }, "de_LimitExceededExceptionRes"); | ||
| var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => { | ||
| const body = parsedOutput.body; | ||
| const deserialized = (0, import_smithy_client._json)(body); | ||
| const exception = new ResourceNotFoundException({ | ||
| $metadata: deserializeMetadata(parsedOutput), | ||
| ...deserialized | ||
| }); | ||
| return (0, import_smithy_client.decorateServiceException)(exception, body); | ||
| }, "de_ResourceNotFoundExceptionRes"); | ||
| var de_ConnectionState = /* @__PURE__ */ __name((output, context) => { | ||
| return (0, import_smithy_client.take)(output, { | ||
| lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), | ||
| status: import_smithy_client.expectString | ||
| }); | ||
| }, "de_ConnectionState"); | ||
| var de_DescribeTunnelResponse = /* @__PURE__ */ __name((output, context) => { | ||
| return (0, import_smithy_client.take)(output, { | ||
| tunnel: (_) => de_Tunnel(_, context) | ||
| }); | ||
| }, "de_DescribeTunnelResponse"); | ||
| var de_ListTunnelsResponse = /* @__PURE__ */ __name((output, context) => { | ||
| return (0, import_smithy_client.take)(output, { | ||
| nextToken: import_smithy_client.expectString, | ||
| tunnelSummaries: (_) => de_TunnelSummaryList(_, context) | ||
| }); | ||
| }, "de_ListTunnelsResponse"); | ||
| var de_Tunnel = /* @__PURE__ */ __name((output, context) => { | ||
| return (0, import_smithy_client.take)(output, { | ||
| createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), | ||
| description: import_smithy_client.expectString, | ||
| destinationConfig: import_smithy_client._json, | ||
| destinationConnectionState: (_) => de_ConnectionState(_, context), | ||
| lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), | ||
| sourceConnectionState: (_) => de_ConnectionState(_, context), | ||
| status: import_smithy_client.expectString, | ||
| tags: import_smithy_client._json, | ||
| timeoutConfig: import_smithy_client._json, | ||
| tunnelArn: import_smithy_client.expectString, | ||
| tunnelId: import_smithy_client.expectString | ||
| }); | ||
| }, "de_Tunnel"); | ||
| var de_TunnelSummary = /* @__PURE__ */ __name((output, context) => { | ||
| return (0, import_smithy_client.take)(output, { | ||
| createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), | ||
| description: import_smithy_client.expectString, | ||
| lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), | ||
| status: import_smithy_client.expectString, | ||
| tunnelArn: import_smithy_client.expectString, | ||
| tunnelId: import_smithy_client.expectString | ||
| }); | ||
| }, "de_TunnelSummary"); | ||
| var de_TunnelSummaryList = /* @__PURE__ */ __name((output, context) => { | ||
| const retVal = (output || []).filter((e) => e != null).map((entry) => { | ||
| return de_TunnelSummary(entry, context); | ||
| }); | ||
| return retVal; | ||
| }, "de_TunnelSummaryList"); | ||
| var deserializeMetadata = /* @__PURE__ */ __name((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"] | ||
| }), "deserializeMetadata"); | ||
| var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString"); | ||
| var throwDefaultError = (0, import_smithy_client.withBaseException)(IoTSecureTunnelingServiceException); | ||
| var buildHttpRpcRequest = /* @__PURE__ */ __name(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 (resolvedHostname !== void 0) { | ||
| contents.hostname = resolvedHostname; | ||
| } | ||
| if (body !== void 0) { | ||
| contents.body = body; | ||
| } | ||
| return new import_protocol_http.HttpRequest(contents); | ||
| }, "buildHttpRpcRequest"); | ||
| function sharedHeaders(operation) { | ||
| return { | ||
| "content-type": "application/x-amz-json-1.1", | ||
| "x-amz-target": `IoTSecuredTunneling.${operation}` | ||
| }; | ||
| } | ||
| __name(sharedHeaders, "sharedHeaders"); | ||
| var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { | ||
| if (encoded.length) { | ||
| return JSON.parse(encoded); | ||
| } | ||
| return {}; | ||
| }), "parseBody"); | ||
| var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => { | ||
| const value = await parseBody(errorBody, context); | ||
| value.message = value.message ?? value.Message; | ||
| return value; | ||
| }, "parseErrorBody"); | ||
| var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => { | ||
| const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey"); | ||
| const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => { | ||
| let cleanValue = rawValue; | ||
| if (typeof cleanValue === "number") { | ||
| cleanValue = cleanValue.toString(); | ||
| } | ||
| if (cleanValue.indexOf(",") >= 0) { | ||
| cleanValue = cleanValue.split(",")[0]; | ||
| } | ||
| if (cleanValue.indexOf(":") >= 0) { | ||
| cleanValue = cleanValue.split(":")[0]; | ||
| } | ||
| if (cleanValue.indexOf("#") >= 0) { | ||
| cleanValue = cleanValue.split("#")[1]; | ||
| } | ||
| return cleanValue; | ||
| }, "sanitizeErrorCode"); | ||
| const headerKey = findKey(output.headers, "x-amzn-errortype"); | ||
| if (headerKey !== void 0) { | ||
| return sanitizeErrorCode(output.headers[headerKey]); | ||
| } | ||
| if (data.code !== void 0) { | ||
| return sanitizeErrorCode(data.code); | ||
| } | ||
| if (data["__type"] !== void 0) { | ||
| return sanitizeErrorCode(data["__type"]); | ||
| } | ||
| }, "loadRestJsonErrorCode"); | ||
| // src/commands/CloseTunnelCommand.ts | ||
| var _CloseTunnelCommand = class _CloseTunnelCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "CloseTunnel", {}).n("IoTSecureTunnelingClient", "CloseTunnelCommand").f(void 0, void 0).ser(se_CloseTunnelCommand).de(de_CloseTunnelCommand).build() { | ||
| }; | ||
| __name(_CloseTunnelCommand, "CloseTunnelCommand"); | ||
| var CloseTunnelCommand = _CloseTunnelCommand; | ||
| // src/commands/DescribeTunnelCommand.ts | ||
| var _DescribeTunnelCommand = class _DescribeTunnelCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "DescribeTunnel", {}).n("IoTSecureTunnelingClient", "DescribeTunnelCommand").f(void 0, void 0).ser(se_DescribeTunnelCommand).de(de_DescribeTunnelCommand).build() { | ||
| }; | ||
| __name(_DescribeTunnelCommand, "DescribeTunnelCommand"); | ||
| var DescribeTunnelCommand = _DescribeTunnelCommand; | ||
| // src/commands/ListTagsForResourceCommand.ts | ||
| var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "ListTagsForResource", {}).n("IoTSecureTunnelingClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() { | ||
| }; | ||
| __name(_ListTagsForResourceCommand, "ListTagsForResourceCommand"); | ||
| var ListTagsForResourceCommand = _ListTagsForResourceCommand; | ||
| // src/commands/ListTunnelsCommand.ts | ||
| var _ListTunnelsCommand = class _ListTunnelsCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "ListTunnels", {}).n("IoTSecureTunnelingClient", "ListTunnelsCommand").f(void 0, void 0).ser(se_ListTunnelsCommand).de(de_ListTunnelsCommand).build() { | ||
| }; | ||
| __name(_ListTunnelsCommand, "ListTunnelsCommand"); | ||
| var ListTunnelsCommand = _ListTunnelsCommand; | ||
| // src/commands/OpenTunnelCommand.ts | ||
| var _OpenTunnelCommand = class _OpenTunnelCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "OpenTunnel", {}).n("IoTSecureTunnelingClient", "OpenTunnelCommand").f(void 0, OpenTunnelResponseFilterSensitiveLog).ser(se_OpenTunnelCommand).de(de_OpenTunnelCommand).build() { | ||
| }; | ||
| __name(_OpenTunnelCommand, "OpenTunnelCommand"); | ||
| var OpenTunnelCommand = _OpenTunnelCommand; | ||
| // src/commands/RotateTunnelAccessTokenCommand.ts | ||
| var _RotateTunnelAccessTokenCommand = class _RotateTunnelAccessTokenCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "RotateTunnelAccessToken", {}).n("IoTSecureTunnelingClient", "RotateTunnelAccessTokenCommand").f(void 0, RotateTunnelAccessTokenResponseFilterSensitiveLog).ser(se_RotateTunnelAccessTokenCommand).de(de_RotateTunnelAccessTokenCommand).build() { | ||
| }; | ||
| __name(_RotateTunnelAccessTokenCommand, "RotateTunnelAccessTokenCommand"); | ||
| var RotateTunnelAccessTokenCommand = _RotateTunnelAccessTokenCommand; | ||
| // src/commands/TagResourceCommand.ts | ||
| var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "TagResource", {}).n("IoTSecureTunnelingClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() { | ||
| }; | ||
| __name(_TagResourceCommand, "TagResourceCommand"); | ||
| var TagResourceCommand = _TagResourceCommand; | ||
| // src/commands/UntagResourceCommand.ts | ||
| var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({ | ||
| ...commonParams | ||
| }).m(function(Command, cs, config, o) { | ||
| return [ | ||
| (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize), | ||
| (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()) | ||
| ]; | ||
| }).s("IoTSecuredTunneling", "UntagResource", {}).n("IoTSecureTunnelingClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() { | ||
| }; | ||
| __name(_UntagResourceCommand, "UntagResourceCommand"); | ||
| var UntagResourceCommand = _UntagResourceCommand; | ||
| // src/IoTSecureTunneling.ts | ||
| var commands = { | ||
| CloseTunnelCommand, | ||
| DescribeTunnelCommand, | ||
| ListTagsForResourceCommand, | ||
| ListTunnelsCommand, | ||
| OpenTunnelCommand, | ||
| RotateTunnelAccessTokenCommand, | ||
| TagResourceCommand, | ||
| UntagResourceCommand | ||
| }; | ||
| var _IoTSecureTunneling = class _IoTSecureTunneling extends IoTSecureTunnelingClient { | ||
| }; | ||
| __name(_IoTSecureTunneling, "IoTSecureTunneling"); | ||
| var IoTSecureTunneling = _IoTSecureTunneling; | ||
| (0, import_smithy_client.createAggregatedClient)(commands, IoTSecureTunneling); | ||
| // src/pagination/ListTunnelsPaginator.ts | ||
| var import_core = require("@smithy/core"); | ||
| var paginateListTunnels = (0, import_core.createPaginator)(IoTSecureTunnelingClient, ListTunnelsCommand, "nextToken", "nextToken", "maxResults"); | ||
| // src/index.ts | ||
| var import_util_endpoints = require("@aws-sdk/util-endpoints"); | ||
| // Annotate the CommonJS export names for ESM import in node: | ||
| 0 && (module.exports = { | ||
| ClientMode, | ||
| CloseTunnelCommand, | ||
| ConnectionStatus, | ||
| DescribeTunnelCommand, | ||
| IoTSecureTunneling, | ||
| IoTSecureTunnelingClient, | ||
| IoTSecureTunnelingServiceException, | ||
| LimitExceededException, | ||
| ListTagsForResourceCommand, | ||
| ListTunnelsCommand, | ||
| OpenTunnelCommand, | ||
| OpenTunnelResponseFilterSensitiveLog, | ||
| ResourceNotFoundException, | ||
| RotateTunnelAccessTokenCommand, | ||
| RotateTunnelAccessTokenResponseFilterSensitiveLog, | ||
| TagResourceCommand, | ||
| TunnelStatus, | ||
| UntagResourceCommand, | ||
| __Client, | ||
| paginateListTunnels | ||
| }); |
@@ -1,27 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.IoTSecureTunneling = void 0; | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| const CloseTunnelCommand_1 = require("./commands/CloseTunnelCommand"); | ||
| const DescribeTunnelCommand_1 = require("./commands/DescribeTunnelCommand"); | ||
| const ListTagsForResourceCommand_1 = require("./commands/ListTagsForResourceCommand"); | ||
| const ListTunnelsCommand_1 = require("./commands/ListTunnelsCommand"); | ||
| const OpenTunnelCommand_1 = require("./commands/OpenTunnelCommand"); | ||
| const RotateTunnelAccessTokenCommand_1 = require("./commands/RotateTunnelAccessTokenCommand"); | ||
| const TagResourceCommand_1 = require("./commands/TagResourceCommand"); | ||
| const UntagResourceCommand_1 = require("./commands/UntagResourceCommand"); | ||
| const IoTSecureTunnelingClient_1 = require("./IoTSecureTunnelingClient"); | ||
| const commands = { | ||
| CloseTunnelCommand: CloseTunnelCommand_1.CloseTunnelCommand, | ||
| DescribeTunnelCommand: DescribeTunnelCommand_1.DescribeTunnelCommand, | ||
| ListTagsForResourceCommand: ListTagsForResourceCommand_1.ListTagsForResourceCommand, | ||
| ListTunnelsCommand: ListTunnelsCommand_1.ListTunnelsCommand, | ||
| OpenTunnelCommand: OpenTunnelCommand_1.OpenTunnelCommand, | ||
| RotateTunnelAccessTokenCommand: RotateTunnelAccessTokenCommand_1.RotateTunnelAccessTokenCommand, | ||
| TagResourceCommand: TagResourceCommand_1.TagResourceCommand, | ||
| UntagResourceCommand: UntagResourceCommand_1.UntagResourceCommand, | ||
| }; | ||
| class IoTSecureTunneling extends IoTSecureTunnelingClient_1.IoTSecureTunnelingClient { | ||
| } | ||
| exports.IoTSecureTunneling = IoTSecureTunneling; | ||
| (0, smithy_client_1.createAggregatedClient)(commands, IoTSecureTunneling); | ||
| module.exports = require("./index.js"); |
@@ -1,43 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.IoTSecureTunnelingClient = exports.__Client = void 0; | ||
| const middleware_host_header_1 = require("@aws-sdk/middleware-host-header"); | ||
| const middleware_logger_1 = require("@aws-sdk/middleware-logger"); | ||
| const middleware_recursion_detection_1 = require("@aws-sdk/middleware-recursion-detection"); | ||
| const middleware_signing_1 = require("@aws-sdk/middleware-signing"); | ||
| const middleware_user_agent_1 = require("@aws-sdk/middleware-user-agent"); | ||
| const config_resolver_1 = require("@smithy/config-resolver"); | ||
| const middleware_content_length_1 = require("@smithy/middleware-content-length"); | ||
| const middleware_endpoint_1 = require("@smithy/middleware-endpoint"); | ||
| const middleware_retry_1 = require("@smithy/middleware-retry"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "__Client", { enumerable: true, get: function () { return smithy_client_1.Client; } }); | ||
| const EndpointParameters_1 = require("./endpoint/EndpointParameters"); | ||
| const runtimeConfig_1 = require("./runtimeConfig"); | ||
| const runtimeExtensions_1 = require("./runtimeExtensions"); | ||
| class IoTSecureTunnelingClient extends smithy_client_1.Client { | ||
| constructor(...[configuration]) { | ||
| const _config_0 = (0, runtimeConfig_1.getRuntimeConfig)(configuration || {}); | ||
| const _config_1 = (0, EndpointParameters_1.resolveClientEndpointParameters)(_config_0); | ||
| const _config_2 = (0, config_resolver_1.resolveRegionConfig)(_config_1); | ||
| const _config_3 = (0, middleware_endpoint_1.resolveEndpointConfig)(_config_2); | ||
| const _config_4 = (0, middleware_retry_1.resolveRetryConfig)(_config_3); | ||
| const _config_5 = (0, middleware_host_header_1.resolveHostHeaderConfig)(_config_4); | ||
| const _config_6 = (0, middleware_signing_1.resolveAwsAuthConfig)(_config_5); | ||
| const _config_7 = (0, middleware_user_agent_1.resolveUserAgentConfig)(_config_6); | ||
| const _config_8 = (0, runtimeExtensions_1.resolveRuntimeExtensions)(_config_7, configuration?.extensions || []); | ||
| super(_config_8); | ||
| this.config = _config_8; | ||
| this.middlewareStack.use((0, middleware_retry_1.getRetryPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_content_length_1.getContentLengthPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_host_header_1.getHostHeaderPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_logger_1.getLoggerPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_recursion_detection_1.getRecursionDetectionPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_signing_1.getAwsAuthPlugin)(this.config)); | ||
| this.middlewareStack.use((0, middleware_user_agent_1.getUserAgentPlugin)(this.config)); | ||
| } | ||
| destroy() { | ||
| super.destroy(); | ||
| } | ||
| } | ||
| exports.IoTSecureTunnelingClient = IoTSecureTunnelingClient; | ||
| module.exports = require("./index.js"); |
@@ -1,4 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| const tslib_1 = require("tslib"); | ||
| tslib_1.__exportStar(require("./models_0"), exports); | ||
| module.exports = require("../index.js"); |
@@ -1,12 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.IoTSecureTunnelingServiceException = exports.__ServiceException = void 0; | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| Object.defineProperty(exports, "__ServiceException", { enumerable: true, get: function () { return smithy_client_1.ServiceException; } }); | ||
| class IoTSecureTunnelingServiceException extends smithy_client_1.ServiceException { | ||
| constructor(options) { | ||
| super(options); | ||
| Object.setPrototypeOf(this, IoTSecureTunnelingServiceException.prototype); | ||
| } | ||
| } | ||
| exports.IoTSecureTunnelingServiceException = IoTSecureTunnelingServiceException; | ||
| module.exports = require("../index.js"); |
@@ -1,56 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.RotateTunnelAccessTokenResponseFilterSensitiveLog = exports.OpenTunnelResponseFilterSensitiveLog = exports.LimitExceededException = exports.TunnelStatus = exports.ConnectionStatus = exports.ResourceNotFoundException = exports.ClientMode = void 0; | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| const IoTSecureTunnelingServiceException_1 = require("./IoTSecureTunnelingServiceException"); | ||
| exports.ClientMode = { | ||
| ALL: "ALL", | ||
| DESTINATION: "DESTINATION", | ||
| SOURCE: "SOURCE", | ||
| }; | ||
| class ResourceNotFoundException extends IoTSecureTunnelingServiceException_1.IoTSecureTunnelingServiceException { | ||
| constructor(opts) { | ||
| super({ | ||
| name: "ResourceNotFoundException", | ||
| $fault: "client", | ||
| ...opts, | ||
| }); | ||
| this.name = "ResourceNotFoundException"; | ||
| this.$fault = "client"; | ||
| Object.setPrototypeOf(this, ResourceNotFoundException.prototype); | ||
| } | ||
| } | ||
| exports.ResourceNotFoundException = ResourceNotFoundException; | ||
| exports.ConnectionStatus = { | ||
| CONNECTED: "CONNECTED", | ||
| DISCONNECTED: "DISCONNECTED", | ||
| }; | ||
| exports.TunnelStatus = { | ||
| CLOSED: "CLOSED", | ||
| OPEN: "OPEN", | ||
| }; | ||
| class LimitExceededException extends IoTSecureTunnelingServiceException_1.IoTSecureTunnelingServiceException { | ||
| constructor(opts) { | ||
| super({ | ||
| name: "LimitExceededException", | ||
| $fault: "client", | ||
| ...opts, | ||
| }); | ||
| this.name = "LimitExceededException"; | ||
| this.$fault = "client"; | ||
| Object.setPrototypeOf(this, LimitExceededException.prototype); | ||
| } | ||
| } | ||
| exports.LimitExceededException = LimitExceededException; | ||
| const OpenTunnelResponseFilterSensitiveLog = (obj) => ({ | ||
| ...obj, | ||
| ...(obj.sourceAccessToken && { sourceAccessToken: smithy_client_1.SENSITIVE_STRING }), | ||
| ...(obj.destinationAccessToken && { destinationAccessToken: smithy_client_1.SENSITIVE_STRING }), | ||
| }); | ||
| exports.OpenTunnelResponseFilterSensitiveLog = OpenTunnelResponseFilterSensitiveLog; | ||
| const RotateTunnelAccessTokenResponseFilterSensitiveLog = (obj) => ({ | ||
| ...obj, | ||
| ...(obj.sourceAccessToken && { sourceAccessToken: smithy_client_1.SENSITIVE_STRING }), | ||
| ...(obj.destinationAccessToken && { destinationAccessToken: smithy_client_1.SENSITIVE_STRING }), | ||
| }); | ||
| exports.RotateTunnelAccessTokenResponseFilterSensitiveLog = RotateTunnelAccessTokenResponseFilterSensitiveLog; | ||
| module.exports = require("../index.js"); |
@@ -1,5 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| const tslib_1 = require("tslib"); | ||
| tslib_1.__exportStar(require("./Interfaces"), exports); | ||
| tslib_1.__exportStar(require("./ListTunnelsPaginator"), exports); | ||
| module.exports = require("../index.js"); |
@@ -1,2 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| module.exports = require("../index.js"); |
@@ -1,7 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.paginateListTunnels = void 0; | ||
| const core_1 = require("@smithy/core"); | ||
| const ListTunnelsCommand_1 = require("../commands/ListTunnelsCommand"); | ||
| const IoTSecureTunnelingClient_1 = require("../IoTSecureTunnelingClient"); | ||
| exports.paginateListTunnels = (0, core_1.createPaginator)(IoTSecureTunnelingClient_1.IoTSecureTunnelingClient, ListTunnelsCommand_1.ListTunnelsCommand, "nextToken", "nextToken", "maxResults"); | ||
| module.exports = require("../index.js"); |
@@ -1,461 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.de_UntagResourceCommand = exports.de_TagResourceCommand = exports.de_RotateTunnelAccessTokenCommand = exports.de_OpenTunnelCommand = exports.de_ListTunnelsCommand = exports.de_ListTagsForResourceCommand = exports.de_DescribeTunnelCommand = exports.de_CloseTunnelCommand = exports.se_UntagResourceCommand = exports.se_TagResourceCommand = exports.se_RotateTunnelAccessTokenCommand = exports.se_OpenTunnelCommand = exports.se_ListTunnelsCommand = exports.se_ListTagsForResourceCommand = exports.se_DescribeTunnelCommand = exports.se_CloseTunnelCommand = void 0; | ||
| const protocol_http_1 = require("@smithy/protocol-http"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| const IoTSecureTunnelingServiceException_1 = require("../models/IoTSecureTunnelingServiceException"); | ||
| const models_0_1 = require("../models/models_0"); | ||
| const se_CloseTunnelCommand = async (input, context) => { | ||
| const headers = sharedHeaders("CloseTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_CloseTunnelCommand = se_CloseTunnelCommand; | ||
| const se_DescribeTunnelCommand = async (input, context) => { | ||
| const headers = sharedHeaders("DescribeTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_DescribeTunnelCommand = se_DescribeTunnelCommand; | ||
| const se_ListTagsForResourceCommand = async (input, context) => { | ||
| const headers = sharedHeaders("ListTagsForResource"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_ListTagsForResourceCommand = se_ListTagsForResourceCommand; | ||
| const se_ListTunnelsCommand = async (input, context) => { | ||
| const headers = sharedHeaders("ListTunnels"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_ListTunnelsCommand = se_ListTunnelsCommand; | ||
| const se_OpenTunnelCommand = async (input, context) => { | ||
| const headers = sharedHeaders("OpenTunnel"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_OpenTunnelCommand = se_OpenTunnelCommand; | ||
| const se_RotateTunnelAccessTokenCommand = async (input, context) => { | ||
| const headers = sharedHeaders("RotateTunnelAccessToken"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_RotateTunnelAccessTokenCommand = se_RotateTunnelAccessTokenCommand; | ||
| const se_TagResourceCommand = async (input, context) => { | ||
| const headers = sharedHeaders("TagResource"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_TagResourceCommand = se_TagResourceCommand; | ||
| const se_UntagResourceCommand = async (input, context) => { | ||
| const headers = sharedHeaders("UntagResource"); | ||
| let body; | ||
| body = JSON.stringify((0, smithy_client_1._json)(input)); | ||
| return buildHttpRpcRequest(context, headers, "/", undefined, body); | ||
| }; | ||
| exports.se_UntagResourceCommand = se_UntagResourceCommand; | ||
| const de_CloseTunnelCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_CloseTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_CloseTunnelCommand = de_CloseTunnelCommand; | ||
| const de_CloseTunnelCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_DescribeTunnelCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_DescribeTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = de_DescribeTunnelResponse(data, context); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_DescribeTunnelCommand = de_DescribeTunnelCommand; | ||
| const de_DescribeTunnelCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_ListTagsForResourceCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_ListTagsForResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_ListTagsForResourceCommand = de_ListTagsForResourceCommand; | ||
| const de_ListTagsForResourceCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_ListTunnelsCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_ListTunnelsCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = de_ListTunnelsResponse(data, context); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_ListTunnelsCommand = de_ListTunnelsCommand; | ||
| const de_ListTunnelsCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| }; | ||
| const de_OpenTunnelCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_OpenTunnelCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_OpenTunnelCommand = de_OpenTunnelCommand; | ||
| const de_OpenTunnelCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "LimitExceededException": | ||
| case "com.amazonaws.iotsecuretunneling#LimitExceededException": | ||
| throw await de_LimitExceededExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_RotateTunnelAccessTokenCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_RotateTunnelAccessTokenCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_RotateTunnelAccessTokenCommand = de_RotateTunnelAccessTokenCommand; | ||
| const de_RotateTunnelAccessTokenCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_TagResourceCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_TagResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_TagResourceCommand = de_TagResourceCommand; | ||
| const de_TagResourceCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_UntagResourceCommand = async (output, context) => { | ||
| if (output.statusCode >= 300) { | ||
| return de_UntagResourceCommandError(output, context); | ||
| } | ||
| const data = await parseBody(output.body, context); | ||
| let contents = {}; | ||
| contents = (0, smithy_client_1._json)(data); | ||
| const response = { | ||
| $metadata: deserializeMetadata(output), | ||
| ...contents, | ||
| }; | ||
| return response; | ||
| }; | ||
| exports.de_UntagResourceCommand = de_UntagResourceCommand; | ||
| const de_UntagResourceCommandError = async (output, context) => { | ||
| const parsedOutput = { | ||
| ...output, | ||
| body: await parseErrorBody(output.body, context), | ||
| }; | ||
| const errorCode = loadRestJsonErrorCode(output, parsedOutput.body); | ||
| switch (errorCode) { | ||
| case "ResourceNotFoundException": | ||
| case "com.amazonaws.iotsecuretunneling#ResourceNotFoundException": | ||
| throw await de_ResourceNotFoundExceptionRes(parsedOutput, context); | ||
| default: | ||
| const parsedBody = parsedOutput.body; | ||
| return throwDefaultError({ | ||
| output, | ||
| parsedBody, | ||
| errorCode, | ||
| }); | ||
| } | ||
| }; | ||
| const de_LimitExceededExceptionRes = async (parsedOutput, context) => { | ||
| const body = parsedOutput.body; | ||
| const deserialized = (0, smithy_client_1._json)(body); | ||
| const exception = new models_0_1.LimitExceededException({ | ||
| $metadata: deserializeMetadata(parsedOutput), | ||
| ...deserialized, | ||
| }); | ||
| return (0, smithy_client_1.decorateServiceException)(exception, body); | ||
| }; | ||
| const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => { | ||
| const body = parsedOutput.body; | ||
| const deserialized = (0, smithy_client_1._json)(body); | ||
| const exception = new models_0_1.ResourceNotFoundException({ | ||
| $metadata: deserializeMetadata(parsedOutput), | ||
| ...deserialized, | ||
| }); | ||
| return (0, smithy_client_1.decorateServiceException)(exception, body); | ||
| }; | ||
| const de_ConnectionState = (output, context) => { | ||
| return (0, smithy_client_1.take)(output, { | ||
| lastUpdatedAt: (_) => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(_))), | ||
| status: smithy_client_1.expectString, | ||
| }); | ||
| }; | ||
| const de_DescribeTunnelResponse = (output, context) => { | ||
| return (0, smithy_client_1.take)(output, { | ||
| tunnel: (_) => de_Tunnel(_, context), | ||
| }); | ||
| }; | ||
| const de_ListTunnelsResponse = (output, context) => { | ||
| return (0, smithy_client_1.take)(output, { | ||
| nextToken: smithy_client_1.expectString, | ||
| tunnelSummaries: (_) => de_TunnelSummaryList(_, context), | ||
| }); | ||
| }; | ||
| const de_Tunnel = (output, context) => { | ||
| return (0, smithy_client_1.take)(output, { | ||
| createdAt: (_) => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(_))), | ||
| description: smithy_client_1.expectString, | ||
| destinationConfig: smithy_client_1._json, | ||
| destinationConnectionState: (_) => de_ConnectionState(_, context), | ||
| lastUpdatedAt: (_) => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(_))), | ||
| sourceConnectionState: (_) => de_ConnectionState(_, context), | ||
| status: smithy_client_1.expectString, | ||
| tags: smithy_client_1._json, | ||
| timeoutConfig: smithy_client_1._json, | ||
| tunnelArn: smithy_client_1.expectString, | ||
| tunnelId: smithy_client_1.expectString, | ||
| }); | ||
| }; | ||
| const de_TunnelSummary = (output, context) => { | ||
| return (0, smithy_client_1.take)(output, { | ||
| createdAt: (_) => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(_))), | ||
| description: smithy_client_1.expectString, | ||
| lastUpdatedAt: (_) => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(_))), | ||
| status: smithy_client_1.expectString, | ||
| tunnelArn: smithy_client_1.expectString, | ||
| tunnelId: smithy_client_1.expectString, | ||
| }); | ||
| }; | ||
| const de_TunnelSummaryList = (output, context) => { | ||
| const retVal = (output || []) | ||
| .filter((e) => e != null) | ||
| .map((entry) => { | ||
| return de_TunnelSummary(entry, context); | ||
| }); | ||
| 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 collectBodyString = (streamBody, context) => (0, smithy_client_1.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)); | ||
| const throwDefaultError = (0, smithy_client_1.withBaseException)(IoTSecureTunnelingServiceException_1.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 (resolvedHostname !== undefined) { | ||
| contents.hostname = resolvedHostname; | ||
| } | ||
| if (body !== undefined) { | ||
| contents.body = body; | ||
| } | ||
| return new protocol_http_1.HttpRequest(contents); | ||
| }; | ||
| function sharedHeaders(operation) { | ||
| return { | ||
| "content-type": "application/x-amz-json-1.1", | ||
| "x-amz-target": `IoTSecuredTunneling.${operation}`, | ||
| }; | ||
| } | ||
| const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { | ||
| if (encoded.length) { | ||
| return JSON.parse(encoded); | ||
| } | ||
| return {}; | ||
| }); | ||
| const parseErrorBody = async (errorBody, context) => { | ||
| const value = await parseBody(errorBody, context); | ||
| value.message = value.message ?? value.Message; | ||
| return value; | ||
| }; | ||
| const loadRestJsonErrorCode = (output, data) => { | ||
| const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()); | ||
| const sanitizeErrorCode = (rawValue) => { | ||
| let cleanValue = rawValue; | ||
| if (typeof cleanValue === "number") { | ||
| cleanValue = cleanValue.toString(); | ||
| } | ||
| if (cleanValue.indexOf(",") >= 0) { | ||
| cleanValue = cleanValue.split(",")[0]; | ||
| } | ||
| if (cleanValue.indexOf(":") >= 0) { | ||
| cleanValue = cleanValue.split(":")[0]; | ||
| } | ||
| if (cleanValue.indexOf("#") >= 0) { | ||
| cleanValue = cleanValue.split("#")[1]; | ||
| } | ||
| return cleanValue; | ||
| }; | ||
| const headerKey = findKey(output.headers, "x-amzn-errortype"); | ||
| if (headerKey !== undefined) { | ||
| return sanitizeErrorCode(output.headers[headerKey]); | ||
| } | ||
| if (data.code !== undefined) { | ||
| return sanitizeErrorCode(data.code); | ||
| } | ||
| if (data["__type"] !== undefined) { | ||
| return sanitizeErrorCode(data["__type"]); | ||
| } | ||
| }; | ||
| module.exports = require("../index.js"); |
@@ -1,22 +0,1 @@ | ||
| "use strict"; | ||
| Object.defineProperty(exports, "__esModule", { value: true }); | ||
| exports.resolveRuntimeExtensions = void 0; | ||
| const region_config_resolver_1 = require("@aws-sdk/region-config-resolver"); | ||
| const protocol_http_1 = require("@smithy/protocol-http"); | ||
| const smithy_client_1 = require("@smithy/smithy-client"); | ||
| const asPartial = (t) => t; | ||
| const resolveRuntimeExtensions = (runtimeConfig, extensions) => { | ||
| const extensionConfiguration = { | ||
| ...asPartial((0, region_config_resolver_1.getAwsRegionExtensionConfiguration)(runtimeConfig)), | ||
| ...asPartial((0, smithy_client_1.getDefaultExtensionConfiguration)(runtimeConfig)), | ||
| ...asPartial((0, protocol_http_1.getHttpHandlerExtensionConfiguration)(runtimeConfig)), | ||
| }; | ||
| extensions.forEach((extension) => extension.configure(extensionConfiguration)); | ||
| return { | ||
| ...runtimeConfig, | ||
| ...(0, region_config_resolver_1.resolveAwsRegionExtensionConfiguration)(extensionConfiguration), | ||
| ...(0, smithy_client_1.resolveDefaultRuntimeConfig)(extensionConfiguration), | ||
| ...(0, protocol_http_1.resolveHttpHandlerRuntimeConfig)(extensionConfiguration), | ||
| }; | ||
| }; | ||
| exports.resolveRuntimeExtensions = resolveRuntimeExtensions; | ||
| module.exports = require("./index.js"); |
| { | ||
| "name": "@aws-sdk/client-iotsecuretunneling", | ||
| "description": "AWS SDK for JavaScript Iotsecuretunneling Client for Node.js, Browser and React Native", | ||
| "version": "3.490.0", | ||
| "version": "3.495.0", | ||
| "scripts": { | ||
| "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'", | ||
| "build:cjs": "tsc -p tsconfig.cjs.json", | ||
| "build:cjs": "node ../../scripts/compilation/inline client-iotsecuretunneling", | ||
| "build:es": "tsc -p tsconfig.es.json", | ||
@@ -23,43 +23,43 @@ "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build", | ||
| "@aws-crypto/sha256-js": "3.0.0", | ||
| "@aws-sdk/client-sts": "3.490.0", | ||
| "@aws-sdk/core": "3.490.0", | ||
| "@aws-sdk/credential-provider-node": "3.490.0", | ||
| "@aws-sdk/middleware-host-header": "3.489.0", | ||
| "@aws-sdk/middleware-logger": "3.489.0", | ||
| "@aws-sdk/middleware-recursion-detection": "3.489.0", | ||
| "@aws-sdk/middleware-signing": "3.489.0", | ||
| "@aws-sdk/middleware-user-agent": "3.489.0", | ||
| "@aws-sdk/region-config-resolver": "3.489.0", | ||
| "@aws-sdk/types": "3.489.0", | ||
| "@aws-sdk/util-endpoints": "3.489.0", | ||
| "@aws-sdk/util-user-agent-browser": "3.489.0", | ||
| "@aws-sdk/util-user-agent-node": "3.489.0", | ||
| "@smithy/config-resolver": "^2.0.23", | ||
| "@smithy/core": "^1.2.2", | ||
| "@smithy/fetch-http-handler": "^2.3.2", | ||
| "@smithy/hash-node": "^2.0.18", | ||
| "@smithy/invalid-dependency": "^2.0.16", | ||
| "@smithy/middleware-content-length": "^2.0.18", | ||
| "@smithy/middleware-endpoint": "^2.3.0", | ||
| "@smithy/middleware-retry": "^2.0.26", | ||
| "@smithy/middleware-serde": "^2.0.16", | ||
| "@smithy/middleware-stack": "^2.0.10", | ||
| "@smithy/node-config-provider": "^2.1.9", | ||
| "@smithy/node-http-handler": "^2.2.2", | ||
| "@smithy/protocol-http": "^3.0.12", | ||
| "@smithy/smithy-client": "^2.2.1", | ||
| "@smithy/types": "^2.8.0", | ||
| "@smithy/url-parser": "^2.0.16", | ||
| "@smithy/util-base64": "^2.0.1", | ||
| "@smithy/util-body-length-browser": "^2.0.1", | ||
| "@smithy/util-body-length-node": "^2.1.0", | ||
| "@smithy/util-defaults-mode-browser": "^2.0.24", | ||
| "@smithy/util-defaults-mode-node": "^2.0.32", | ||
| "@smithy/util-endpoints": "^1.0.8", | ||
| "@smithy/util-retry": "^2.0.9", | ||
| "@smithy/util-utf8": "^2.0.2", | ||
| "@aws-sdk/client-sts": "3.495.0", | ||
| "@aws-sdk/core": "3.495.0", | ||
| "@aws-sdk/credential-provider-node": "3.495.0", | ||
| "@aws-sdk/middleware-host-header": "3.495.0", | ||
| "@aws-sdk/middleware-logger": "3.495.0", | ||
| "@aws-sdk/middleware-recursion-detection": "3.495.0", | ||
| "@aws-sdk/middleware-signing": "3.495.0", | ||
| "@aws-sdk/middleware-user-agent": "3.495.0", | ||
| "@aws-sdk/region-config-resolver": "3.495.0", | ||
| "@aws-sdk/types": "3.495.0", | ||
| "@aws-sdk/util-endpoints": "3.495.0", | ||
| "@aws-sdk/util-user-agent-browser": "3.495.0", | ||
| "@aws-sdk/util-user-agent-node": "3.495.0", | ||
| "@smithy/config-resolver": "^2.1.0", | ||
| "@smithy/core": "^1.3.0", | ||
| "@smithy/fetch-http-handler": "^2.4.0", | ||
| "@smithy/hash-node": "^2.1.0", | ||
| "@smithy/invalid-dependency": "^2.1.0", | ||
| "@smithy/middleware-content-length": "^2.1.0", | ||
| "@smithy/middleware-endpoint": "^2.4.0", | ||
| "@smithy/middleware-retry": "^2.1.0", | ||
| "@smithy/middleware-serde": "^2.1.0", | ||
| "@smithy/middleware-stack": "^2.1.0", | ||
| "@smithy/node-config-provider": "^2.2.0", | ||
| "@smithy/node-http-handler": "^2.3.0", | ||
| "@smithy/protocol-http": "^3.1.0", | ||
| "@smithy/smithy-client": "^2.3.0", | ||
| "@smithy/types": "^2.9.0", | ||
| "@smithy/url-parser": "^2.1.0", | ||
| "@smithy/util-base64": "^2.1.0", | ||
| "@smithy/util-body-length-browser": "^2.1.0", | ||
| "@smithy/util-body-length-node": "^2.2.0", | ||
| "@smithy/util-defaults-mode-browser": "^2.1.0", | ||
| "@smithy/util-defaults-mode-node": "^2.1.0", | ||
| "@smithy/util-endpoints": "^1.1.0", | ||
| "@smithy/util-retry": "^2.1.0", | ||
| "@smithy/util-utf8": "^2.1.0", | ||
| "tslib": "^2.5.0" | ||
| }, | ||
| "devDependencies": { | ||
| "@smithy/service-client-documentation-generator": "^2.0.0", | ||
| "@smithy/service-client-documentation-generator": "^2.1.0", | ||
| "@tsconfig/node14": "1.0.3", | ||
@@ -66,0 +66,0 @@ "@types/node": "^14.14.31", |
No alert changes
Worsened metrics
- Total package byte prevSize
- decreased by-2.47%
225467
- Lines of code
- decreased by-2.73%
4741
Dependency changes
+ Added@aws-sdk/client-sso@3.495.0(transitive)
+ Added@aws-sdk/client-sts@3.495.0(transitive)
+ Added@aws-sdk/core@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-env@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-ini@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-node@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-process@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-sso@3.495.0(transitive)
+ Added@aws-sdk/credential-provider-web-identity@3.495.0(transitive)
+ Added@aws-sdk/middleware-host-header@3.495.0(transitive)
+ Added@aws-sdk/middleware-logger@3.495.0(transitive)
+ Added@aws-sdk/middleware-recursion-detection@3.495.0(transitive)
+ Added@aws-sdk/middleware-signing@3.495.0(transitive)
+ Added@aws-sdk/middleware-user-agent@3.495.0(transitive)
+ Added@aws-sdk/region-config-resolver@3.495.0(transitive)
+ Added@aws-sdk/token-providers@3.495.0(transitive)
+ Added@aws-sdk/types@3.495.0(transitive)
+ Added@aws-sdk/util-endpoints@3.495.0(transitive)
+ Added@aws-sdk/util-user-agent-browser@3.495.0(transitive)
+ Added@aws-sdk/util-user-agent-node@3.495.0(transitive)
- Removed@aws-sdk/client-sso@3.490.0(transitive)
- Removed@aws-sdk/client-sts@3.490.0(transitive)
- Removed@aws-sdk/core@3.490.0(transitive)
- Removed@aws-sdk/credential-provider-env@3.489.0(transitive)
- Removed@aws-sdk/credential-provider-ini@3.490.0(transitive)
- Removed@aws-sdk/credential-provider-node@3.490.0(transitive)
- Removed@aws-sdk/credential-provider-process@3.489.0(transitive)
- Removed@aws-sdk/credential-provider-sso@3.490.0(transitive)
- Removed@aws-sdk/credential-provider-web-identity@3.489.0(transitive)
- Removed@aws-sdk/middleware-host-header@3.489.0(transitive)
- Removed@aws-sdk/middleware-logger@3.489.0(transitive)
- Removed@aws-sdk/middleware-recursion-detection@3.489.0(transitive)
- Removed@aws-sdk/middleware-signing@3.489.0(transitive)
- Removed@aws-sdk/middleware-user-agent@3.489.0(transitive)
- Removed@aws-sdk/region-config-resolver@3.489.0(transitive)
- Removed@aws-sdk/token-providers@3.489.0(transitive)
- Removed@aws-sdk/types@3.489.0(transitive)
- Removed@aws-sdk/util-endpoints@3.489.0(transitive)
- Removed@aws-sdk/util-user-agent-browser@3.489.0(transitive)
- Removed@aws-sdk/util-user-agent-node@3.489.0(transitive)
Updated@aws-sdk/client-sts@3.495.0
Updated@aws-sdk/core@3.495.0
Updated@aws-sdk/types@3.495.0
Updated@smithy/core@^1.3.0
Updated@smithy/hash-node@^2.1.0
Updated@smithy/protocol-http@^3.1.0
Updated@smithy/smithy-client@^2.3.0
Updated@smithy/types@^2.9.0
Updated@smithy/url-parser@^2.1.0
Updated@smithy/util-base64@^2.1.0
Updated@smithy/util-retry@^2.1.0
Updated@smithy/util-utf8@^2.1.0