@aws-sdk/client-backup 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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