@aws-sdk/client-guardduty 3.34.0 → 3.37.0

package/dist-es/commands/DeletePublishingDestinationCommand.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 { DeletePublishingDestinationRequest, DeletePublishingDestinationResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeletePublishingDestinationCommand, serializeAws_restJson1DeletePublishingDestinationCommand, } from "../protocols/Aws_restJson1";
+var DeletePublishingDestinationCommand = (function (_super) {
+    __extends(DeletePublishingDestinationCommand, _super);
+    function DeletePublishingDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeletePublishingDestinationCommand.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 = "DeletePublishingDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeletePublishingDestinationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeletePublishingDestinationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeletePublishingDestinationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeletePublishingDestinationCommand(input, context);
+    };
+    DeletePublishingDestinationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeletePublishingDestinationCommand(output, context);
+    };
+    return DeletePublishingDestinationCommand;
+}($Command));
+export { DeletePublishingDestinationCommand };

package/dist-es/commands/DeleteThreatIntelSetCommand.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 { DeleteThreatIntelSetRequest, DeleteThreatIntelSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1DeleteThreatIntelSetCommand, serializeAws_restJson1DeleteThreatIntelSetCommand, } from "../protocols/Aws_restJson1";
+var DeleteThreatIntelSetCommand = (function (_super) {
+    __extends(DeleteThreatIntelSetCommand, _super);
+    function DeleteThreatIntelSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteThreatIntelSetCommand.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 = "DeleteThreatIntelSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteThreatIntelSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteThreatIntelSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteThreatIntelSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteThreatIntelSetCommand(input, context);
+    };
+    DeleteThreatIntelSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteThreatIntelSetCommand(output, context);
+    };
+    return DeleteThreatIntelSetCommand;
+}($Command));
+export { DeleteThreatIntelSetCommand };

package/dist-es/commands/DescribeOrganizationConfigurationCommand.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 { DescribeOrganizationConfigurationRequest, DescribeOrganizationConfigurationResponse, } from "../models/models_0";
+import { deserializeAws_restJson1DescribeOrganizationConfigurationCommand, serializeAws_restJson1DescribeOrganizationConfigurationCommand, } from "../protocols/Aws_restJson1";
+var DescribeOrganizationConfigurationCommand = (function (_super) {
+    __extends(DescribeOrganizationConfigurationCommand, _super);
+    function DescribeOrganizationConfigurationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeOrganizationConfigurationCommand.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 = "DescribeOrganizationConfigurationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeOrganizationConfigurationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeOrganizationConfigurationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeOrganizationConfigurationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DescribeOrganizationConfigurationCommand(input, context);
+    };
+    DescribeOrganizationConfigurationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DescribeOrganizationConfigurationCommand(output, context);
+    };
+    return DescribeOrganizationConfigurationCommand;
+}($Command));
+export { DescribeOrganizationConfigurationCommand };

package/dist-es/commands/DescribePublishingDestinationCommand.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 { DescribePublishingDestinationRequest, DescribePublishingDestinationResponse } from "../models/models_0";
+import { deserializeAws_restJson1DescribePublishingDestinationCommand, serializeAws_restJson1DescribePublishingDestinationCommand, } from "../protocols/Aws_restJson1";
+var DescribePublishingDestinationCommand = (function (_super) {
+    __extends(DescribePublishingDestinationCommand, _super);
+    function DescribePublishingDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribePublishingDestinationCommand.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 = "DescribePublishingDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribePublishingDestinationRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribePublishingDestinationResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribePublishingDestinationCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DescribePublishingDestinationCommand(input, context);
+    };
+    DescribePublishingDestinationCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DescribePublishingDestinationCommand(output, context);
+    };
+    return DescribePublishingDestinationCommand;
+}($Command));
+export { DescribePublishingDestinationCommand };

package/dist-es/commands/DisableOrganizationAdminAccountCommand.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 { DisableOrganizationAdminAccountRequest, DisableOrganizationAdminAccountResponse } from "../models/models_0";
+import { deserializeAws_restJson1DisableOrganizationAdminAccountCommand, serializeAws_restJson1DisableOrganizationAdminAccountCommand, } from "../protocols/Aws_restJson1";
+var DisableOrganizationAdminAccountCommand = (function (_super) {
+    __extends(DisableOrganizationAdminAccountCommand, _super);
+    function DisableOrganizationAdminAccountCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisableOrganizationAdminAccountCommand.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 = "DisableOrganizationAdminAccountCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisableOrganizationAdminAccountRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisableOrganizationAdminAccountResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisableOrganizationAdminAccountCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DisableOrganizationAdminAccountCommand(input, context);
+    };
+    DisableOrganizationAdminAccountCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisableOrganizationAdminAccountCommand(output, context);
+    };
+    return DisableOrganizationAdminAccountCommand;
+}($Command));
+export { DisableOrganizationAdminAccountCommand };

package/dist-es/commands/DisassociateFromMasterAccountCommand.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 { DisassociateFromMasterAccountRequest, DisassociateFromMasterAccountResponse } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateFromMasterAccountCommand, serializeAws_restJson1DisassociateFromMasterAccountCommand, } from "../protocols/Aws_restJson1";
+var DisassociateFromMasterAccountCommand = (function (_super) {
+    __extends(DisassociateFromMasterAccountCommand, _super);
+    function DisassociateFromMasterAccountCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateFromMasterAccountCommand.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 = "DisassociateFromMasterAccountCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateFromMasterAccountRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateFromMasterAccountResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateFromMasterAccountCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DisassociateFromMasterAccountCommand(input, context);
+    };
+    DisassociateFromMasterAccountCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateFromMasterAccountCommand(output, context);
+    };
+    return DisassociateFromMasterAccountCommand;
+}($Command));
+export { DisassociateFromMasterAccountCommand };

package/dist-es/commands/DisassociateMembersCommand.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 { DisassociateMembersRequest, DisassociateMembersResponse } from "../models/models_0";
+import { deserializeAws_restJson1DisassociateMembersCommand, serializeAws_restJson1DisassociateMembersCommand, } from "../protocols/Aws_restJson1";
+var DisassociateMembersCommand = (function (_super) {
+    __extends(DisassociateMembersCommand, _super);
+    function DisassociateMembersCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DisassociateMembersCommand.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 = "DisassociateMembersCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DisassociateMembersRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: DisassociateMembersResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DisassociateMembersCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DisassociateMembersCommand(input, context);
+    };
+    DisassociateMembersCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DisassociateMembersCommand(output, context);
+    };
+    return DisassociateMembersCommand;
+}($Command));
+export { DisassociateMembersCommand };

package/dist-es/commands/EnableOrganizationAdminAccountCommand.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 { EnableOrganizationAdminAccountRequest, EnableOrganizationAdminAccountResponse } from "../models/models_0";
+import { deserializeAws_restJson1EnableOrganizationAdminAccountCommand, serializeAws_restJson1EnableOrganizationAdminAccountCommand, } from "../protocols/Aws_restJson1";
+var EnableOrganizationAdminAccountCommand = (function (_super) {
+    __extends(EnableOrganizationAdminAccountCommand, _super);
+    function EnableOrganizationAdminAccountCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    EnableOrganizationAdminAccountCommand.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 = "EnableOrganizationAdminAccountCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: EnableOrganizationAdminAccountRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: EnableOrganizationAdminAccountResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    EnableOrganizationAdminAccountCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1EnableOrganizationAdminAccountCommand(input, context);
+    };
+    EnableOrganizationAdminAccountCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1EnableOrganizationAdminAccountCommand(output, context);
+    };
+    return EnableOrganizationAdminAccountCommand;
+}($Command));
+export { EnableOrganizationAdminAccountCommand };

package/dist-es/commands/GetDetectorCommand.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 { GetDetectorRequest, GetDetectorResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetDetectorCommand, serializeAws_restJson1GetDetectorCommand, } from "../protocols/Aws_restJson1";
+var GetDetectorCommand = (function (_super) {
+    __extends(GetDetectorCommand, _super);
+    function GetDetectorCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetDetectorCommand.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 = "GetDetectorCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetDetectorRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetDetectorResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetDetectorCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetDetectorCommand(input, context);
+    };
+    GetDetectorCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetDetectorCommand(output, context);
+    };
+    return GetDetectorCommand;
+}($Command));
+export { GetDetectorCommand };

package/dist-es/commands/GetFilterCommand.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 { GetFilterRequest, GetFilterResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFilterCommand, serializeAws_restJson1GetFilterCommand, } from "../protocols/Aws_restJson1";
+var GetFilterCommand = (function (_super) {
+    __extends(GetFilterCommand, _super);
+    function GetFilterCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFilterCommand.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 = "GetFilterCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFilterRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFilterResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFilterCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFilterCommand(input, context);
+    };
+    GetFilterCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFilterCommand(output, context);
+    };
+    return GetFilterCommand;
+}($Command));
+export { GetFilterCommand };

package/dist-es/commands/GetFindingsCommand.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 { GetFindingsRequest, GetFindingsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFindingsCommand, serializeAws_restJson1GetFindingsCommand, } from "../protocols/Aws_restJson1";
+var GetFindingsCommand = (function (_super) {
+    __extends(GetFindingsCommand, _super);
+    function GetFindingsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFindingsCommand.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 = "GetFindingsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFindingsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFindingsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFindingsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFindingsCommand(input, context);
+    };
+    GetFindingsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFindingsCommand(output, context);
+    };
+    return GetFindingsCommand;
+}($Command));
+export { GetFindingsCommand };

package/dist-es/commands/GetFindingsStatisticsCommand.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 { GetFindingsStatisticsRequest, GetFindingsStatisticsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetFindingsStatisticsCommand, serializeAws_restJson1GetFindingsStatisticsCommand, } from "../protocols/Aws_restJson1";
+var GetFindingsStatisticsCommand = (function (_super) {
+    __extends(GetFindingsStatisticsCommand, _super);
+    function GetFindingsStatisticsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetFindingsStatisticsCommand.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 = "GetFindingsStatisticsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetFindingsStatisticsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetFindingsStatisticsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetFindingsStatisticsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetFindingsStatisticsCommand(input, context);
+    };
+    GetFindingsStatisticsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetFindingsStatisticsCommand(output, context);
+    };
+    return GetFindingsStatisticsCommand;
+}($Command));
+export { GetFindingsStatisticsCommand };

package/dist-es/commands/GetIPSetCommand.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 { GetIPSetRequest, GetIPSetResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetIPSetCommand, serializeAws_restJson1GetIPSetCommand, } from "../protocols/Aws_restJson1";
+var GetIPSetCommand = (function (_super) {
+    __extends(GetIPSetCommand, _super);
+    function GetIPSetCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetIPSetCommand.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 = "GetIPSetCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetIPSetRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetIPSetResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetIPSetCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetIPSetCommand(input, context);
+    };
+    GetIPSetCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetIPSetCommand(output, context);
+    };
+    return GetIPSetCommand;
+}($Command));
+export { GetIPSetCommand };

package/dist-es/commands/GetInvitationsCountCommand.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 { GetInvitationsCountRequest, GetInvitationsCountResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetInvitationsCountCommand, serializeAws_restJson1GetInvitationsCountCommand, } from "../protocols/Aws_restJson1";
+var GetInvitationsCountCommand = (function (_super) {
+    __extends(GetInvitationsCountCommand, _super);
+    function GetInvitationsCountCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetInvitationsCountCommand.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 = "GetInvitationsCountCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetInvitationsCountRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetInvitationsCountResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetInvitationsCountCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetInvitationsCountCommand(input, context);
+    };
+    GetInvitationsCountCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetInvitationsCountCommand(output, context);
+    };
+    return GetInvitationsCountCommand;
+}($Command));
+export { GetInvitationsCountCommand };

package/dist-es/commands/GetMasterAccountCommand.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 { GetMasterAccountRequest, GetMasterAccountResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetMasterAccountCommand, serializeAws_restJson1GetMasterAccountCommand, } from "../protocols/Aws_restJson1";
+var GetMasterAccountCommand = (function (_super) {
+    __extends(GetMasterAccountCommand, _super);
+    function GetMasterAccountCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetMasterAccountCommand.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 = "GetMasterAccountCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetMasterAccountRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetMasterAccountResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMasterAccountCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetMasterAccountCommand(input, context);
+    };
+    GetMasterAccountCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetMasterAccountCommand(output, context);
+    };
+    return GetMasterAccountCommand;
+}($Command));
+export { GetMasterAccountCommand };

package/dist-es/commands/GetMemberDetectorsCommand.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 { GetMemberDetectorsRequest, GetMemberDetectorsResponse } from "../models/models_0";
+import { deserializeAws_restJson1GetMemberDetectorsCommand, serializeAws_restJson1GetMemberDetectorsCommand, } from "../protocols/Aws_restJson1";
+var GetMemberDetectorsCommand = (function (_super) {
+    __extends(GetMemberDetectorsCommand, _super);
+    function GetMemberDetectorsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetMemberDetectorsCommand.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 = "GetMemberDetectorsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetMemberDetectorsRequest.filterSensitiveLog,
+            outputFilterSensitiveLog: GetMemberDetectorsResponse.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMemberDetectorsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetMemberDetectorsCommand(input, context);
+    };
+    GetMemberDetectorsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetMemberDetectorsCommand(output, context);
+    };
+    return GetMemberDetectorsCommand;
+}($Command));
+export { GetMemberDetectorsCommand };