@aws-sdk/client-directory-service 3.183.0 → 3.186.0

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

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

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

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

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

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

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

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

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

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