@aws-sdk/client-appconfig 3.183.0 → 3.185.0

package/dist-es/commands/GetEnvironmentCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { EnvironmentFilterSensitiveLog, GetEnvironmentRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetEnvironmentCommand, serializeAws_restJson1GetEnvironmentCommand, } from "../protocols/Aws_restJson1";
-export class GetEnvironmentCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetEnvironmentCommand = (function (_super) {
+    __extends(GetEnvironmentCommand, _super);
+    function GetEnvironmentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetEnvironmentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "GetEnvironmentCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "GetEnvironmentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetEnvironmentRequestFilterSensitiveLog,
             outputFilterSensitiveLog: EnvironmentFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetEnvironmentCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetEnvironmentCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetEnvironmentCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetEnvironmentCommand(output, context);
-    }
-}
+    };
+    return GetEnvironmentCommand;
+}($Command));
+export { GetEnvironmentCommand };

package/dist-es/commands/GetExtensionAssociationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ExtensionAssociationFilterSensitiveLog, GetExtensionAssociationRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetExtensionAssociationCommand, serializeAws_restJson1GetExtensionAssociationCommand, } from "../protocols/Aws_restJson1";
-export class GetExtensionAssociationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetExtensionAssociationCommand = (function (_super) {
+    __extends(GetExtensionAssociationCommand, _super);
+    function GetExtensionAssociationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetExtensionAssociationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "GetExtensionAssociationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "GetExtensionAssociationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetExtensionAssociationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ExtensionAssociationFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetExtensionAssociationCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetExtensionAssociationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetExtensionAssociationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetExtensionAssociationCommand(output, context);
-    }
-}
+    };
+    return GetExtensionAssociationCommand;
+}($Command));
+export { GetExtensionAssociationCommand };

package/dist-es/commands/GetExtensionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ExtensionFilterSensitiveLog, GetExtensionRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetExtensionCommand, serializeAws_restJson1GetExtensionCommand, } from "../protocols/Aws_restJson1";
-export class GetExtensionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetExtensionCommand = (function (_super) {
+    __extends(GetExtensionCommand, _super);
+    function GetExtensionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetExtensionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "GetExtensionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "GetExtensionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetExtensionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ExtensionFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetExtensionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetExtensionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetExtensionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetExtensionCommand(output, context);
-    }
-}
+    };
+    return GetExtensionCommand;
+}($Command));
+export { GetExtensionCommand };

package/dist-es/commands/GetHostedConfigurationVersionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { GetHostedConfigurationVersionRequestFilterSensitiveLog, HostedConfigurationVersionFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetHostedConfigurationVersionCommand, serializeAws_restJson1GetHostedConfigurationVersionCommand, } from "../protocols/Aws_restJson1";
-export class GetHostedConfigurationVersionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetHostedConfigurationVersionCommand = (function (_super) {
+    __extends(GetHostedConfigurationVersionCommand, _super);
+    function GetHostedConfigurationVersionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetHostedConfigurationVersionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "GetHostedConfigurationVersionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "GetHostedConfigurationVersionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetHostedConfigurationVersionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: HostedConfigurationVersionFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetHostedConfigurationVersionCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetHostedConfigurationVersionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetHostedConfigurationVersionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetHostedConfigurationVersionCommand(output, context);
-    }
-}
+    };
+    return GetHostedConfigurationVersionCommand;
+}($Command));
+export { GetHostedConfigurationVersionCommand };

package/dist-es/commands/ListApplicationsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ApplicationsFilterSensitiveLog, ListApplicationsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListApplicationsCommand, serializeAws_restJson1ListApplicationsCommand, } from "../protocols/Aws_restJson1";
-export class ListApplicationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListApplicationsCommand = (function (_super) {
+    __extends(ListApplicationsCommand, _super);
+    function ListApplicationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListApplicationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListApplicationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListApplicationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListApplicationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ApplicationsFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListApplicationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListApplicationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListApplicationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListApplicationsCommand(output, context);
-    }
-}
+    };
+    return ListApplicationsCommand;
+}($Command));
+export { ListApplicationsCommand };

package/dist-es/commands/ListConfigurationProfilesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ConfigurationProfilesFilterSensitiveLog, ListConfigurationProfilesRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListConfigurationProfilesCommand, serializeAws_restJson1ListConfigurationProfilesCommand, } from "../protocols/Aws_restJson1";
-export class ListConfigurationProfilesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListConfigurationProfilesCommand = (function (_super) {
+    __extends(ListConfigurationProfilesCommand, _super);
+    function ListConfigurationProfilesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListConfigurationProfilesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListConfigurationProfilesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListConfigurationProfilesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListConfigurationProfilesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ConfigurationProfilesFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListConfigurationProfilesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListConfigurationProfilesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListConfigurationProfilesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListConfigurationProfilesCommand(output, context);
-    }
-}
+    };
+    return ListConfigurationProfilesCommand;
+}($Command));
+export { ListConfigurationProfilesCommand };

package/dist-es/commands/ListDeploymentStrategiesCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeploymentStrategiesFilterSensitiveLog, ListDeploymentStrategiesRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListDeploymentStrategiesCommand, serializeAws_restJson1ListDeploymentStrategiesCommand, } from "../protocols/Aws_restJson1";
-export class ListDeploymentStrategiesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDeploymentStrategiesCommand = (function (_super) {
+    __extends(ListDeploymentStrategiesCommand, _super);
+    function ListDeploymentStrategiesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDeploymentStrategiesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListDeploymentStrategiesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListDeploymentStrategiesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListDeploymentStrategiesRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeploymentStrategiesFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDeploymentStrategiesCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListDeploymentStrategiesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDeploymentStrategiesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListDeploymentStrategiesCommand(output, context);
-    }
-}
+    };
+    return ListDeploymentStrategiesCommand;
+}($Command));
+export { ListDeploymentStrategiesCommand };

package/dist-es/commands/ListDeploymentsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeploymentsFilterSensitiveLog, ListDeploymentsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListDeploymentsCommand, serializeAws_restJson1ListDeploymentsCommand, } from "../protocols/Aws_restJson1";
-export class ListDeploymentsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListDeploymentsCommand = (function (_super) {
+    __extends(ListDeploymentsCommand, _super);
+    function ListDeploymentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListDeploymentsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListDeploymentsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListDeploymentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListDeploymentsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeploymentsFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListDeploymentsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListDeploymentsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListDeploymentsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListDeploymentsCommand(output, context);
-    }
-}
+    };
+    return ListDeploymentsCommand;
+}($Command));
+export { ListDeploymentsCommand };

package/dist-es/commands/ListEnvironmentsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { EnvironmentsFilterSensitiveLog, ListEnvironmentsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListEnvironmentsCommand, serializeAws_restJson1ListEnvironmentsCommand, } from "../protocols/Aws_restJson1";
-export class ListEnvironmentsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentsCommand = (function (_super) {
+    __extends(ListEnvironmentsCommand, _super);
+    function ListEnvironmentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListEnvironmentsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListEnvironmentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: EnvironmentsFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListEnvironmentsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListEnvironmentsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListEnvironmentsCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentsCommand;
+}($Command));
+export { ListEnvironmentsCommand };

package/dist-es/commands/ListExtensionAssociationsCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { ExtensionAssociationsFilterSensitiveLog, ListExtensionAssociationsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ListExtensionAssociationsCommand, serializeAws_restJson1ListExtensionAssociationsCommand, } from "../protocols/Aws_restJson1";
-export class ListExtensionAssociationsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListExtensionAssociationsCommand = (function (_super) {
+    __extends(ListExtensionAssociationsCommand, _super);
+    function ListExtensionAssociationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListExtensionAssociationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "AppConfigClient";
-        const commandName = "ListExtensionAssociationsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "AppConfigClient";
+        var commandName = "ListExtensionAssociationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListExtensionAssociationsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ExtensionAssociationsFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListExtensionAssociationsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ListExtensionAssociationsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListExtensionAssociationsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ListExtensionAssociationsCommand(output, context);
-    }
-}
+    };
+    return ListExtensionAssociationsCommand;
+}($Command));
+export { ListExtensionAssociationsCommand };