@aws-sdk/client-glacier 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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