@aws-sdk/client-proton 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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