@aws-sdk/client-proton 3.183.0 → 3.185.0

package/dist-es/commands/ListComponentOutputsCommand.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 { ListComponentOutputsInputFilterSensitiveLog, ListComponentOutputsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListComponentOutputsCommand, serializeAws_json1_0ListComponentOutputsCommand, } from "../protocols/Aws_json1_0";
-export class ListComponentOutputsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListComponentOutputsCommand = (function (_super) {
+    __extends(ListComponentOutputsCommand, _super);
+    function ListComponentOutputsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListComponentOutputsCommand.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 = "ProtonClient";
-        const commandName = "ListComponentOutputsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentOutputsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListComponentOutputsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListComponentOutputsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListComponentOutputsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListComponentOutputsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListComponentOutputsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListComponentOutputsCommand(output, context);
-    }
-}
+    };
+    return ListComponentOutputsCommand;
+}($Command));
+export { ListComponentOutputsCommand };

package/dist-es/commands/ListComponentProvisionedResourcesCommand.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 { ListComponentProvisionedResourcesInputFilterSensitiveLog, ListComponentProvisionedResourcesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListComponentProvisionedResourcesCommand, serializeAws_json1_0ListComponentProvisionedResourcesCommand, } from "../protocols/Aws_json1_0";
-export class ListComponentProvisionedResourcesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListComponentProvisionedResourcesCommand = (function (_super) {
+    __extends(ListComponentProvisionedResourcesCommand, _super);
+    function ListComponentProvisionedResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListComponentProvisionedResourcesCommand.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 = "ProtonClient";
-        const commandName = "ListComponentProvisionedResourcesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentProvisionedResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListComponentProvisionedResourcesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListComponentProvisionedResourcesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListComponentProvisionedResourcesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListComponentProvisionedResourcesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListComponentProvisionedResourcesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListComponentProvisionedResourcesCommand(output, context);
-    }
-}
+    };
+    return ListComponentProvisionedResourcesCommand;
+}($Command));
+export { ListComponentProvisionedResourcesCommand };

package/dist-es/commands/ListComponentsCommand.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 { ListComponentsInputFilterSensitiveLog, ListComponentsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListComponentsCommand, serializeAws_json1_0ListComponentsCommand, } from "../protocols/Aws_json1_0";
-export class ListComponentsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListComponentsCommand = (function (_super) {
+    __extends(ListComponentsCommand, _super);
+    function ListComponentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListComponentsCommand.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 = "ProtonClient";
-        const commandName = "ListComponentsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListComponentsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListComponentsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListComponentsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListComponentsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListComponentsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListComponentsCommand(output, context);
-    }
-}
+    };
+    return ListComponentsCommand;
+}($Command));
+export { ListComponentsCommand };

package/dist-es/commands/ListEnvironmentAccountConnectionsCommand.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 { ListEnvironmentAccountConnectionsInputFilterSensitiveLog, ListEnvironmentAccountConnectionsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentAccountConnectionsCommand, serializeAws_json1_0ListEnvironmentAccountConnectionsCommand, } from "../protocols/Aws_json1_0";
-export class ListEnvironmentAccountConnectionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentAccountConnectionsCommand = (function (_super) {
+    __extends(ListEnvironmentAccountConnectionsCommand, _super);
+    function ListEnvironmentAccountConnectionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentAccountConnectionsCommand.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 = "ProtonClient";
-        const commandName = "ListEnvironmentAccountConnectionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentAccountConnectionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentAccountConnectionsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentAccountConnectionsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListEnvironmentAccountConnectionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListEnvironmentAccountConnectionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentAccountConnectionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentAccountConnectionsCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentAccountConnectionsCommand;
+}($Command));
+export { ListEnvironmentAccountConnectionsCommand };

package/dist-es/commands/ListEnvironmentOutputsCommand.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 { ListEnvironmentOutputsInputFilterSensitiveLog, ListEnvironmentOutputsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentOutputsCommand, serializeAws_json1_0ListEnvironmentOutputsCommand, } from "../protocols/Aws_json1_0";
-export class ListEnvironmentOutputsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentOutputsCommand = (function (_super) {
+    __extends(ListEnvironmentOutputsCommand, _super);
+    function ListEnvironmentOutputsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentOutputsCommand.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 = "ProtonClient";
-        const commandName = "ListEnvironmentOutputsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentOutputsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentOutputsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentOutputsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListEnvironmentOutputsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListEnvironmentOutputsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentOutputsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentOutputsCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentOutputsCommand;
+}($Command));
+export { ListEnvironmentOutputsCommand };

package/dist-es/commands/ListEnvironmentProvisionedResourcesCommand.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 { ListEnvironmentProvisionedResourcesInputFilterSensitiveLog, ListEnvironmentProvisionedResourcesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentProvisionedResourcesCommand, serializeAws_json1_0ListEnvironmentProvisionedResourcesCommand, } from "../protocols/Aws_json1_0";
-export class ListEnvironmentProvisionedResourcesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentProvisionedResourcesCommand = (function (_super) {
+    __extends(ListEnvironmentProvisionedResourcesCommand, _super);
+    function ListEnvironmentProvisionedResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentProvisionedResourcesCommand.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 = "ProtonClient";
-        const commandName = "ListEnvironmentProvisionedResourcesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentProvisionedResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentProvisionedResourcesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentProvisionedResourcesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListEnvironmentProvisionedResourcesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListEnvironmentProvisionedResourcesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentProvisionedResourcesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentProvisionedResourcesCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentProvisionedResourcesCommand;
+}($Command));
+export { ListEnvironmentProvisionedResourcesCommand };

package/dist-es/commands/ListEnvironmentTemplateVersionsCommand.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 { ListEnvironmentTemplateVersionsInputFilterSensitiveLog, ListEnvironmentTemplateVersionsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentTemplateVersionsCommand, serializeAws_json1_0ListEnvironmentTemplateVersionsCommand, } from "../protocols/Aws_json1_0";
-export class ListEnvironmentTemplateVersionsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentTemplateVersionsCommand = (function (_super) {
+    __extends(ListEnvironmentTemplateVersionsCommand, _super);
+    function ListEnvironmentTemplateVersionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentTemplateVersionsCommand.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 = "ProtonClient";
-        const commandName = "ListEnvironmentTemplateVersionsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentTemplateVersionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentTemplateVersionsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentTemplateVersionsOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListEnvironmentTemplateVersionsCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListEnvironmentTemplateVersionsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentTemplateVersionsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentTemplateVersionsCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentTemplateVersionsCommand;
+}($Command));
+export { ListEnvironmentTemplateVersionsCommand };

package/dist-es/commands/ListEnvironmentTemplatesCommand.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 { ListEnvironmentTemplatesInputFilterSensitiveLog, ListEnvironmentTemplatesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentTemplatesCommand, serializeAws_json1_0ListEnvironmentTemplatesCommand, } from "../protocols/Aws_json1_0";
-export class ListEnvironmentTemplatesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListEnvironmentTemplatesCommand = (function (_super) {
+    __extends(ListEnvironmentTemplatesCommand, _super);
+    function ListEnvironmentTemplatesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListEnvironmentTemplatesCommand.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 = "ProtonClient";
-        const commandName = "ListEnvironmentTemplatesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentTemplatesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentTemplatesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentTemplatesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListEnvironmentTemplatesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListEnvironmentTemplatesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentTemplatesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentTemplatesCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentTemplatesCommand;
+}($Command));
+export { ListEnvironmentTemplatesCommand };

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 { ListEnvironmentsInputFilterSensitiveLog, ListEnvironmentsOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListEnvironmentsCommand, serializeAws_json1_0ListEnvironmentsCommand, } from "../protocols/Aws_json1_0";
-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 = "ProtonClient";
-        const commandName = "ListEnvironmentsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListEnvironmentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListEnvironmentsInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListEnvironmentsOutputFilterSensitiveLog,
         };
-        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_json1_0ListEnvironmentsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListEnvironmentsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListEnvironmentsCommand(output, context);
-    }
-}
+    };
+    return ListEnvironmentsCommand;
+}($Command));
+export { ListEnvironmentsCommand };

package/dist-es/commands/ListRepositoriesCommand.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 { ListRepositoriesInputFilterSensitiveLog, ListRepositoriesOutputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0ListRepositoriesCommand, serializeAws_json1_0ListRepositoriesCommand, } from "../protocols/Aws_json1_0";
-export class ListRepositoriesCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ListRepositoriesCommand = (function (_super) {
+    __extends(ListRepositoriesCommand, _super);
+    function ListRepositoriesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ListRepositoriesCommand.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 = "ProtonClient";
-        const commandName = "ListRepositoriesCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListRepositoriesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ListRepositoriesInputFilterSensitiveLog,
             outputFilterSensitiveLog: ListRepositoriesOutputFilterSensitiveLog,
         };
-        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);
+    };
+    ListRepositoriesCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0ListRepositoriesCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ListRepositoriesCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0ListRepositoriesCommand(output, context);
-    }
-}
+    };
+    return ListRepositoriesCommand;
+}($Command));
+export { ListRepositoriesCommand };