@aws-sdk/client-proton 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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