@aws-sdk/client-guardduty 3.34.0 → 3.37.0

package/dist-es/GuardDutyClient.js

@@ -0,0 +1,37 @@
+import { __extends } from "tslib";
+import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-resolver";
+import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
+import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
+import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { Client as __Client, } from "@aws-sdk/smithy-client";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+var GuardDutyClient = (function (_super) {
+    __extends(GuardDutyClient, _super);
+    function GuardDutyClient(configuration) {
+        var _this = this;
+        var _config_0 = __getRuntimeConfig(configuration);
+        var _config_1 = resolveRegionConfig(_config_0);
+        var _config_2 = resolveEndpointsConfig(_config_1);
+        var _config_3 = resolveRetryConfig(_config_2);
+        var _config_4 = resolveHostHeaderConfig(_config_3);
+        var _config_5 = resolveAwsAuthConfig(_config_4);
+        var _config_6 = resolveUserAgentConfig(_config_5);
+        _this = _super.call(this, _config_6) || this;
+        _this.config = _config_6;
+        _this.middlewareStack.use(getRetryPlugin(_this.config));
+        _this.middlewareStack.use(getContentLengthPlugin(_this.config));
+        _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
+        _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
+        _this.middlewareStack.use(getUserAgentPlugin(_this.config));
+        return _this;
+    }
+    GuardDutyClient.prototype.destroy = function () {
+        _super.prototype.destroy.call(this);
+    };
+    return GuardDutyClient;
+}(__Client));
+export { GuardDutyClient };

package/dist-es/commands/AcceptInvitationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AcceptInvitationRequest, AcceptInvitationResponse } from "../models/models_0";
+import { deserializeAws_restJson1AcceptInvitationCommand, serializeAws_restJson1AcceptInvitationCommand, } from "../protocols/Aws_restJson1";
+var AcceptInvitationCommand = (function (_super) {
+    __extends(AcceptInvitationCommand, _super);
+    function AcceptInvitationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    AcceptInvitationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "AcceptInvitationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: AcceptInvitationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: AcceptInvitationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    AcceptInvitationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1AcceptInvitationCommand(input, context);
+    };
+    AcceptInvitationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1AcceptInvitationCommand(output, context);
+    };
+    return AcceptInvitationCommand;
+}($Command));
+export { AcceptInvitationCommand };

package/dist-es/commands/ArchiveFindingsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ArchiveFindingsRequest, ArchiveFindingsResponse } from "../models/models_0";
+import { deserializeAws_restJson1ArchiveFindingsCommand, serializeAws_restJson1ArchiveFindingsCommand, } from "../protocols/Aws_restJson1";
+var ArchiveFindingsCommand = (function (_super) {
+    __extends(ArchiveFindingsCommand, _super);
+    function ArchiveFindingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ArchiveFindingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "ArchiveFindingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ArchiveFindingsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: ArchiveFindingsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ArchiveFindingsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ArchiveFindingsCommand(input, context);
+    };
+    ArchiveFindingsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ArchiveFindingsCommand(output, context);
+    };
+    return ArchiveFindingsCommand;
+}($Command));
+export { ArchiveFindingsCommand };

package/dist-es/commands/CreateDetectorCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateDetectorRequest, CreateDetectorResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateDetectorCommand, serializeAws_restJson1CreateDetectorCommand, } from "../protocols/Aws_restJson1";
+var CreateDetectorCommand = (function (_super) {
+    __extends(CreateDetectorCommand, _super);
+    function CreateDetectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateDetectorCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateDetectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateDetectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateDetectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateDetectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateDetectorCommand(input, context);
+    };
+    CreateDetectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateDetectorCommand(output, context);
+    };
+    return CreateDetectorCommand;
+}($Command));
+export { CreateDetectorCommand };

package/dist-es/commands/CreateFilterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateFilterRequest, CreateFilterResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateFilterCommand, serializeAws_restJson1CreateFilterCommand, } from "../protocols/Aws_restJson1";
+var CreateFilterCommand = (function (_super) {
+    __extends(CreateFilterCommand, _super);
+    function CreateFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateFilterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateFilterRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateFilterResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateFilterCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateFilterCommand(input, context);
+    };
+    CreateFilterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateFilterCommand(output, context);
+    };
+    return CreateFilterCommand;
+}($Command));
+export { CreateFilterCommand };

package/dist-es/commands/CreateIPSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateIPSetRequest, CreateIPSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateIPSetCommand, serializeAws_restJson1CreateIPSetCommand, } from "../protocols/Aws_restJson1";
+var CreateIPSetCommand = (function (_super) {
+    __extends(CreateIPSetCommand, _super);
+    function CreateIPSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateIPSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateIPSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateIPSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateIPSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateIPSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateIPSetCommand(input, context);
+    };
+    CreateIPSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateIPSetCommand(output, context);
+    };
+    return CreateIPSetCommand;
+}($Command));
+export { CreateIPSetCommand };

package/dist-es/commands/CreateMembersCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMembersRequest, CreateMembersResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateMembersCommand, serializeAws_restJson1CreateMembersCommand, } from "../protocols/Aws_restJson1";
+var CreateMembersCommand = (function (_super) {
+    __extends(CreateMembersCommand, _super);
+    function CreateMembersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMembersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateMembersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMembersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateMembersResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMembersCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateMembersCommand(input, context);
+    };
+    CreateMembersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateMembersCommand(output, context);
+    };
+    return CreateMembersCommand;
+}($Command));
+export { CreateMembersCommand };

package/dist-es/commands/CreatePublishingDestinationCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreatePublishingDestinationRequest, CreatePublishingDestinationResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreatePublishingDestinationCommand, serializeAws_restJson1CreatePublishingDestinationCommand, } from "../protocols/Aws_restJson1";
+var CreatePublishingDestinationCommand = (function (_super) {
+    __extends(CreatePublishingDestinationCommand, _super);
+    function CreatePublishingDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreatePublishingDestinationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreatePublishingDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreatePublishingDestinationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreatePublishingDestinationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreatePublishingDestinationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreatePublishingDestinationCommand(input, context);
+    };
+    CreatePublishingDestinationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreatePublishingDestinationCommand(output, context);
+    };
+    return CreatePublishingDestinationCommand;
+}($Command));
+export { CreatePublishingDestinationCommand };

package/dist-es/commands/CreateSampleFindingsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSampleFindingsRequest, CreateSampleFindingsResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateSampleFindingsCommand, serializeAws_restJson1CreateSampleFindingsCommand, } from "../protocols/Aws_restJson1";
+var CreateSampleFindingsCommand = (function (_super) {
+    __extends(CreateSampleFindingsCommand, _super);
+    function CreateSampleFindingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateSampleFindingsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateSampleFindingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateSampleFindingsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateSampleFindingsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateSampleFindingsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateSampleFindingsCommand(input, context);
+    };
+    CreateSampleFindingsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateSampleFindingsCommand(output, context);
+    };
+    return CreateSampleFindingsCommand;
+}($Command));
+export { CreateSampleFindingsCommand };

package/dist-es/commands/CreateThreatIntelSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateThreatIntelSetRequest, CreateThreatIntelSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1CreateThreatIntelSetCommand, serializeAws_restJson1CreateThreatIntelSetCommand, } from "../protocols/Aws_restJson1";
+var CreateThreatIntelSetCommand = (function (_super) {
+    __extends(CreateThreatIntelSetCommand, _super);
+    function CreateThreatIntelSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateThreatIntelSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "CreateThreatIntelSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateThreatIntelSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateThreatIntelSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateThreatIntelSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateThreatIntelSetCommand(input, context);
+    };
+    CreateThreatIntelSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateThreatIntelSetCommand(output, context);
+    };
+    return CreateThreatIntelSetCommand;
+}($Command));
+export { CreateThreatIntelSetCommand };

package/dist-es/commands/DeclineInvitationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeclineInvitationsRequest, DeclineInvitationsResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeclineInvitationsCommand, serializeAws_restJson1DeclineInvitationsCommand, } from "../protocols/Aws_restJson1";
+var DeclineInvitationsCommand = (function (_super) {
+    __extends(DeclineInvitationsCommand, _super);
+    function DeclineInvitationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeclineInvitationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeclineInvitationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeclineInvitationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeclineInvitationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeclineInvitationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeclineInvitationsCommand(input, context);
+    };
+    DeclineInvitationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeclineInvitationsCommand(output, context);
+    };
+    return DeclineInvitationsCommand;
+}($Command));
+export { DeclineInvitationsCommand };

package/dist-es/commands/DeleteDetectorCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteDetectorRequest, DeleteDetectorResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDetectorCommand, serializeAws_restJson1DeleteDetectorCommand, } from "../protocols/Aws_restJson1";
+var DeleteDetectorCommand = (function (_super) {
+    __extends(DeleteDetectorCommand, _super);
+    function DeleteDetectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteDetectorCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeleteDetectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteDetectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDetectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteDetectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteDetectorCommand(input, context);
+    };
+    DeleteDetectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteDetectorCommand(output, context);
+    };
+    return DeleteDetectorCommand;
+}($Command));
+export { DeleteDetectorCommand };

package/dist-es/commands/DeleteFilterCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteFilterRequest, DeleteFilterResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteFilterCommand, serializeAws_restJson1DeleteFilterCommand, } from "../protocols/Aws_restJson1";
+var DeleteFilterCommand = (function (_super) {
+    __extends(DeleteFilterCommand, _super);
+    function DeleteFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteFilterCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeleteFilterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteFilterRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteFilterResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteFilterCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteFilterCommand(input, context);
+    };
+    DeleteFilterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteFilterCommand(output, context);
+    };
+    return DeleteFilterCommand;
+}($Command));
+export { DeleteFilterCommand };

package/dist-es/commands/DeleteIPSetCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteIPSetRequest, DeleteIPSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteIPSetCommand, serializeAws_restJson1DeleteIPSetCommand, } from "../protocols/Aws_restJson1";
+var DeleteIPSetCommand = (function (_super) {
+    __extends(DeleteIPSetCommand, _super);
+    function DeleteIPSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteIPSetCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeleteIPSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteIPSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteIPSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteIPSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteIPSetCommand(input, context);
+    };
+    DeleteIPSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteIPSetCommand(output, context);
+    };
+    return DeleteIPSetCommand;
+}($Command));
+export { DeleteIPSetCommand };

package/dist-es/commands/DeleteInvitationsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteInvitationsRequest, DeleteInvitationsResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteInvitationsCommand, serializeAws_restJson1DeleteInvitationsCommand, } from "../protocols/Aws_restJson1";
+var DeleteInvitationsCommand = (function (_super) {
+    __extends(DeleteInvitationsCommand, _super);
+    function DeleteInvitationsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteInvitationsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeleteInvitationsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteInvitationsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteInvitationsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteInvitationsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteInvitationsCommand(input, context);
+    };
+    DeleteInvitationsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteInvitationsCommand(output, context);
+    };
+    return DeleteInvitationsCommand;
+}($Command));
+export { DeleteInvitationsCommand };

package/dist-es/commands/DeleteMembersCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteMembersRequest, DeleteMembersResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteMembersCommand, serializeAws_restJson1DeleteMembersCommand, } from "../protocols/Aws_restJson1";
+var DeleteMembersCommand = (function (_super) {
+    __extends(DeleteMembersCommand, _super);
+    function DeleteMembersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteMembersCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GuardDutyClient";
+        var commandName = "DeleteMembersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteMembersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteMembersResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteMembersCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteMembersCommand(input, context);
+    };
+    DeleteMembersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteMembersCommand(output, context);
+    };
+    return DeleteMembersCommand;
+}($Command));
+export { DeleteMembersCommand };