@aws-sdk/client-greengrass 3.186.0 → 3.190.0

package/dist-es/commands/GetLoggerDefinitionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetLoggerDefinitionRequestFilterSensitiveLog, GetLoggerDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetLoggerDefinitionCommand, serializeAws_restJson1GetLoggerDefinitionCommand, } from "../protocols/Aws_restJson1";
-var GetLoggerDefinitionCommand = (function (_super) {
-    __extends(GetLoggerDefinitionCommand, _super);
-    function GetLoggerDefinitionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetLoggerDefinitionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetLoggerDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetLoggerDefinitionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetLoggerDefinitionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetLoggerDefinitionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetLoggerDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLoggerDefinitionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetLoggerDefinitionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetLoggerDefinitionCommand(input, context);
-    };
-    GetLoggerDefinitionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetLoggerDefinitionCommand(output, context);
-    };
-    return GetLoggerDefinitionCommand;
-}($Command));
-export { GetLoggerDefinitionCommand };
+    }
+}

package/dist-es/commands/GetLoggerDefinitionVersionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetLoggerDefinitionVersionRequestFilterSensitiveLog, GetLoggerDefinitionVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetLoggerDefinitionVersionCommand, serializeAws_restJson1GetLoggerDefinitionVersionCommand, } from "../protocols/Aws_restJson1";
-var GetLoggerDefinitionVersionCommand = (function (_super) {
-    __extends(GetLoggerDefinitionVersionCommand, _super);
-    function GetLoggerDefinitionVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetLoggerDefinitionVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetLoggerDefinitionVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetLoggerDefinitionVersionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetLoggerDefinitionVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetLoggerDefinitionVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetLoggerDefinitionVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetLoggerDefinitionVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetLoggerDefinitionVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetLoggerDefinitionVersionCommand(input, context);
-    };
-    GetLoggerDefinitionVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetLoggerDefinitionVersionCommand(output, context);
-    };
-    return GetLoggerDefinitionVersionCommand;
-}($Command));
-export { GetLoggerDefinitionVersionCommand };
+    }
+}

package/dist-es/commands/GetResourceDefinitionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetResourceDefinitionRequestFilterSensitiveLog, GetResourceDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetResourceDefinitionCommand, serializeAws_restJson1GetResourceDefinitionCommand, } from "../protocols/Aws_restJson1";
-var GetResourceDefinitionCommand = (function (_super) {
-    __extends(GetResourceDefinitionCommand, _super);
-    function GetResourceDefinitionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetResourceDefinitionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetResourceDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetResourceDefinitionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetResourceDefinitionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetResourceDefinitionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetResourceDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetResourceDefinitionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetResourceDefinitionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetResourceDefinitionCommand(input, context);
-    };
-    GetResourceDefinitionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetResourceDefinitionCommand(output, context);
-    };
-    return GetResourceDefinitionCommand;
-}($Command));
-export { GetResourceDefinitionCommand };
+    }
+}

package/dist-es/commands/GetResourceDefinitionVersionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetResourceDefinitionVersionRequestFilterSensitiveLog, GetResourceDefinitionVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetResourceDefinitionVersionCommand, serializeAws_restJson1GetResourceDefinitionVersionCommand, } from "../protocols/Aws_restJson1";
-var GetResourceDefinitionVersionCommand = (function (_super) {
-    __extends(GetResourceDefinitionVersionCommand, _super);
-    function GetResourceDefinitionVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetResourceDefinitionVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetResourceDefinitionVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetResourceDefinitionVersionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetResourceDefinitionVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetResourceDefinitionVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetResourceDefinitionVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetResourceDefinitionVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetResourceDefinitionVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetResourceDefinitionVersionCommand(input, context);
-    };
-    GetResourceDefinitionVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetResourceDefinitionVersionCommand(output, context);
-    };
-    return GetResourceDefinitionVersionCommand;
-}($Command));
-export { GetResourceDefinitionVersionCommand };
+    }
+}

package/dist-es/commands/GetServiceRoleForAccountCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetServiceRoleForAccountRequestFilterSensitiveLog, GetServiceRoleForAccountResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetServiceRoleForAccountCommand, serializeAws_restJson1GetServiceRoleForAccountCommand, } from "../protocols/Aws_restJson1";
-var GetServiceRoleForAccountCommand = (function (_super) {
-    __extends(GetServiceRoleForAccountCommand, _super);
-    function GetServiceRoleForAccountCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetServiceRoleForAccountCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetServiceRoleForAccountCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetServiceRoleForAccountCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetServiceRoleForAccountCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetServiceRoleForAccountCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetServiceRoleForAccountRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetServiceRoleForAccountResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetServiceRoleForAccountCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetServiceRoleForAccountCommand(input, context);
-    };
-    GetServiceRoleForAccountCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetServiceRoleForAccountCommand(output, context);
-    };
-    return GetServiceRoleForAccountCommand;
-}($Command));
-export { GetServiceRoleForAccountCommand };
+    }
+}

package/dist-es/commands/GetSubscriptionDefinitionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetSubscriptionDefinitionRequestFilterSensitiveLog, GetSubscriptionDefinitionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetSubscriptionDefinitionCommand, serializeAws_restJson1GetSubscriptionDefinitionCommand, } from "../protocols/Aws_restJson1";
-var GetSubscriptionDefinitionCommand = (function (_super) {
-    __extends(GetSubscriptionDefinitionCommand, _super);
-    function GetSubscriptionDefinitionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetSubscriptionDefinitionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetSubscriptionDefinitionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetSubscriptionDefinitionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSubscriptionDefinitionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetSubscriptionDefinitionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetSubscriptionDefinitionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetSubscriptionDefinitionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetSubscriptionDefinitionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetSubscriptionDefinitionCommand(input, context);
-    };
-    GetSubscriptionDefinitionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetSubscriptionDefinitionCommand(output, context);
-    };
-    return GetSubscriptionDefinitionCommand;
-}($Command));
-export { GetSubscriptionDefinitionCommand };
+    }
+}

package/dist-es/commands/GetSubscriptionDefinitionVersionCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetSubscriptionDefinitionVersionRequestFilterSensitiveLog, GetSubscriptionDefinitionVersionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetSubscriptionDefinitionVersionCommand, serializeAws_restJson1GetSubscriptionDefinitionVersionCommand, } from "../protocols/Aws_restJson1";
-var GetSubscriptionDefinitionVersionCommand = (function (_super) {
-    __extends(GetSubscriptionDefinitionVersionCommand, _super);
-    function GetSubscriptionDefinitionVersionCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetSubscriptionDefinitionVersionCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetSubscriptionDefinitionVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetSubscriptionDefinitionVersionCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSubscriptionDefinitionVersionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetSubscriptionDefinitionVersionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetSubscriptionDefinitionVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetSubscriptionDefinitionVersionResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetSubscriptionDefinitionVersionCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetSubscriptionDefinitionVersionCommand(input, context);
-    };
-    GetSubscriptionDefinitionVersionCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetSubscriptionDefinitionVersionCommand(output, context);
-    };
-    return GetSubscriptionDefinitionVersionCommand;
-}($Command));
-export { GetSubscriptionDefinitionVersionCommand };
+    }
+}

package/dist-es/commands/GetThingRuntimeConfigurationCommand.js

@@ -1,39 +1,42 @@
-import { __extends } from "tslib";
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetThingRuntimeConfigurationRequestFilterSensitiveLog, GetThingRuntimeConfigurationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetThingRuntimeConfigurationCommand, serializeAws_restJson1GetThingRuntimeConfigurationCommand, } from "../protocols/Aws_restJson1";
-var GetThingRuntimeConfigurationCommand = (function (_super) {
-    __extends(GetThingRuntimeConfigurationCommand, _super);
-    function GetThingRuntimeConfigurationCommand(input) {
-        var _this = _super.call(this) || this;
-        _this.input = input;
-        return _this;
+export class GetThingRuntimeConfigurationCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
     }
-    GetThingRuntimeConfigurationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "Endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        var stack = clientStack.concat(this.middlewareStack);
-        var logger = configuration.logger;
-        var clientName = "GreengrassClient";
-        var commandName = "GetThingRuntimeConfigurationCommand";
-        var handlerExecutionContext = {
-            logger: logger,
-            clientName: clientName,
-            commandName: commandName,
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetThingRuntimeConfigurationCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "GreengrassClient";
+        const commandName = "GetThingRuntimeConfigurationCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
             inputFilterSensitiveLog: GetThingRuntimeConfigurationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GetThingRuntimeConfigurationResponseFilterSensitiveLog,
         };
-        var requestHandler = configuration.requestHandler;
-        return stack.resolve(function (request) {
-            return requestHandler.handle(request.request, options || {});
-        }, handlerExecutionContext);
-    };
-    GetThingRuntimeConfigurationCommand.prototype.serialize = function (input, context) {
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
         return serializeAws_restJson1GetThingRuntimeConfigurationCommand(input, context);
-    };
-    GetThingRuntimeConfigurationCommand.prototype.deserialize = function (output, context) {
+    }
+    deserialize(output, context) {
         return deserializeAws_restJson1GetThingRuntimeConfigurationCommand(output, context);
-    };
-    return GetThingRuntimeConfigurationCommand;
-}($Command));
-export { GetThingRuntimeConfigurationCommand };
+    }
+}