@aws-sdk/client-guardduty 3.34.0 → 3.37.0

package/dist-types/commands/GetInvitationsCountCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetInvitationsCountRequest, GetInvitationsCountResponse } from "../models/models_0";
+export interface GetInvitationsCountCommandInput extends GetInvitationsCountRequest {
+}
+export interface GetInvitationsCountCommandOutput extends GetInvitationsCountResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns the count of all GuardDuty membership invitations that were sent to the current
+ *       member account except the currently accepted invitation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetInvitationsCountCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetInvitationsCountCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetInvitationsCountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetInvitationsCountCommandInput} for command's `input` shape.
+ * @see {@link GetInvitationsCountCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetInvitationsCountCommand extends $Command<GetInvitationsCountCommandInput, GetInvitationsCountCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetInvitationsCountCommandInput;
+    constructor(input: GetInvitationsCountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetInvitationsCountCommandInput, GetInvitationsCountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetMasterAccountCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetMasterAccountRequest, GetMasterAccountResponse } from "../models/models_0";
+export interface GetMasterAccountCommandInput extends GetMasterAccountRequest {
+}
+export interface GetMasterAccountCommandOutput extends GetMasterAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides the details for the GuardDuty administrator account associated with the current
+ *       GuardDuty member account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetMasterAccountCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetMasterAccountCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetMasterAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMasterAccountCommandInput} for command's `input` shape.
+ * @see {@link GetMasterAccountCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMasterAccountCommand extends $Command<GetMasterAccountCommandInput, GetMasterAccountCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetMasterAccountCommandInput;
+    constructor(input: GetMasterAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMasterAccountCommandInput, GetMasterAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetMemberDetectorsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetMemberDetectorsRequest, GetMemberDetectorsResponse } from "../models/models_0";
+export interface GetMemberDetectorsCommandInput extends GetMemberDetectorsRequest {
+}
+export interface GetMemberDetectorsCommandOutput extends GetMemberDetectorsResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes which data sources are enabled for the member account's detector.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetMemberDetectorsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetMemberDetectorsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetMemberDetectorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMemberDetectorsCommandInput} for command's `input` shape.
+ * @see {@link GetMemberDetectorsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMemberDetectorsCommand extends $Command<GetMemberDetectorsCommandInput, GetMemberDetectorsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetMemberDetectorsCommandInput;
+    constructor(input: GetMemberDetectorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMemberDetectorsCommandInput, GetMemberDetectorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetMembersCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetMembersRequest, GetMembersResponse } from "../models/models_0";
+export interface GetMembersCommandInput extends GetMembersRequest {
+}
+export interface GetMembersCommandOutput extends GetMembersResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves GuardDuty member accounts (of the current GuardDuty administrator account) specified by
+ *       the account IDs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetMembersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetMembersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetMembersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetMembersCommandInput} for command's `input` shape.
+ * @see {@link GetMembersCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetMembersCommand extends $Command<GetMembersCommandInput, GetMembersCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetMembersCommandInput;
+    constructor(input: GetMembersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMembersCommandInput, GetMembersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetThreatIntelSetCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetThreatIntelSetRequest, GetThreatIntelSetResponse } from "../models/models_0";
+export interface GetThreatIntelSetCommandInput extends GetThreatIntelSetRequest {
+}
+export interface GetThreatIntelSetCommandOutput extends GetThreatIntelSetResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the ThreatIntelSet that is specified by the ThreatIntelSet ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetThreatIntelSetCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetThreatIntelSetCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetThreatIntelSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetThreatIntelSetCommandInput} for command's `input` shape.
+ * @see {@link GetThreatIntelSetCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetThreatIntelSetCommand extends $Command<GetThreatIntelSetCommandInput, GetThreatIntelSetCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetThreatIntelSetCommandInput;
+    constructor(input: GetThreatIntelSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetThreatIntelSetCommandInput, GetThreatIntelSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetUsageStatisticsCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { GetUsageStatisticsRequest, GetUsageStatisticsResponse } from "../models/models_0";
+export interface GetUsageStatisticsCommandInput extends GetUsageStatisticsRequest {
+}
+export interface GetUsageStatisticsCommandOutput extends GetUsageStatisticsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists Amazon GuardDuty usage statistics over the last 30 days for the specified detector
+ *       ID. For newly enabled detectors or data sources the cost returned will include only the usage
+ *       so far under 30 days, this may differ from the cost metrics in the console, which projects
+ *       usage over 30 days to provide a monthly cost estimate. For more information see <a href="https://docs.aws.amazon.com/guardduty/latest/ug/monitoring_costs.html#usage-calculations">Understanding How Usage Costs are Calculated</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, GetUsageStatisticsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, GetUsageStatisticsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new GetUsageStatisticsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUsageStatisticsCommandInput} for command's `input` shape.
+ * @see {@link GetUsageStatisticsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUsageStatisticsCommand extends $Command<GetUsageStatisticsCommandInput, GetUsageStatisticsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: GetUsageStatisticsCommandInput;
+    constructor(input: GetUsageStatisticsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUsageStatisticsCommandInput, GetUsageStatisticsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/InviteMembersCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { InviteMembersRequest, InviteMembersResponse } from "../models/models_0";
+export interface InviteMembersCommandInput extends InviteMembersRequest {
+}
+export interface InviteMembersCommandOutput extends InviteMembersResponse, __MetadataBearer {
+}
+/**
+ * <p>Invites other AWS accounts (created as members of the current AWS account by
+ *       CreateMembers) to enable GuardDuty, and allow the current AWS account to view and manage these
+ *       accounts' findings on their behalf as the GuardDuty administrator account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, InviteMembersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, InviteMembersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new InviteMembersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link InviteMembersCommandInput} for command's `input` shape.
+ * @see {@link InviteMembersCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class InviteMembersCommand extends $Command<InviteMembersCommandInput, InviteMembersCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: InviteMembersCommandInput;
+    constructor(input: InviteMembersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InviteMembersCommandInput, InviteMembersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDetectorsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListDetectorsRequest, ListDetectorsResponse } from "../models/models_0";
+export interface ListDetectorsCommandInput extends ListDetectorsRequest {
+}
+export interface ListDetectorsCommandOutput extends ListDetectorsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists detectorIds of all the existing Amazon GuardDuty detector resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListDetectorsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListDetectorsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListDetectorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDetectorsCommandInput} for command's `input` shape.
+ * @see {@link ListDetectorsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDetectorsCommand extends $Command<ListDetectorsCommandInput, ListDetectorsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListDetectorsCommandInput;
+    constructor(input: ListDetectorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDetectorsCommandInput, ListDetectorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListFiltersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListFiltersRequest, ListFiltersResponse } from "../models/models_0";
+export interface ListFiltersCommandInput extends ListFiltersRequest {
+}
+export interface ListFiltersCommandOutput extends ListFiltersResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a paginated list of the current filters.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListFiltersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListFiltersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListFiltersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFiltersCommandInput} for command's `input` shape.
+ * @see {@link ListFiltersCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListFiltersCommand extends $Command<ListFiltersCommandInput, ListFiltersCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListFiltersCommandInput;
+    constructor(input: ListFiltersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFiltersCommandInput, ListFiltersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListFindingsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListFindingsRequest, ListFindingsResponse } from "../models/models_0";
+export interface ListFindingsCommandInput extends ListFindingsRequest {
+}
+export interface ListFindingsCommandOutput extends ListFindingsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists Amazon GuardDuty findings for the specified detector ID.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListFindingsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListFindingsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListFindingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFindingsCommandInput} for command's `input` shape.
+ * @see {@link ListFindingsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListFindingsCommand extends $Command<ListFindingsCommandInput, ListFindingsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListFindingsCommandInput;
+    constructor(input: ListFindingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFindingsCommandInput, ListFindingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListIPSetsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListIPSetsRequest, ListIPSetsResponse } from "../models/models_0";
+export interface ListIPSetsCommandInput extends ListIPSetsRequest {
+}
+export interface ListIPSetsCommandOutput extends ListIPSetsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the IPSets of the GuardDuty service specified by the detector ID. If you use this
+ *       operation from a member account, the IPSets returned are the IPSets from the associated administrator
+ *       account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListIPSetsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListIPSetsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListIPSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIPSetsCommandInput} for command's `input` shape.
+ * @see {@link ListIPSetsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListIPSetsCommand extends $Command<ListIPSetsCommandInput, ListIPSetsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListIPSetsCommandInput;
+    constructor(input: ListIPSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIPSetsCommandInput, ListIPSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListInvitationsCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListInvitationsRequest, ListInvitationsResponse } from "../models/models_0";
+export interface ListInvitationsCommandInput extends ListInvitationsRequest {
+}
+export interface ListInvitationsCommandOutput extends ListInvitationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all GuardDuty membership invitations that were sent to the current AWS
+ *       account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListInvitationsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListInvitationsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListInvitationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListInvitationsCommandInput} for command's `input` shape.
+ * @see {@link ListInvitationsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListInvitationsCommand extends $Command<ListInvitationsCommandInput, ListInvitationsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListInvitationsCommandInput;
+    constructor(input: ListInvitationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListInvitationsCommandInput, ListInvitationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListMembersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListMembersRequest, ListMembersResponse } from "../models/models_0";
+export interface ListMembersCommandInput extends ListMembersRequest {
+}
+export interface ListMembersCommandOutput extends ListMembersResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists details about all member accounts for the current GuardDuty administrator account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListMembersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListMembersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListMembersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListMembersCommandInput} for command's `input` shape.
+ * @see {@link ListMembersCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListMembersCommand extends $Command<ListMembersCommandInput, ListMembersCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListMembersCommandInput;
+    constructor(input: ListMembersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListMembersCommandInput, ListMembersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListOrganizationAdminAccountsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListOrganizationAdminAccountsRequest, ListOrganizationAdminAccountsResponse } from "../models/models_0";
+export interface ListOrganizationAdminAccountsCommandInput extends ListOrganizationAdminAccountsRequest {
+}
+export interface ListOrganizationAdminAccountsCommandOutput extends ListOrganizationAdminAccountsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the accounts configured as GuardDuty delegated administrators.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListOrganizationAdminAccountsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListOrganizationAdminAccountsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListOrganizationAdminAccountsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListOrganizationAdminAccountsCommandInput} for command's `input` shape.
+ * @see {@link ListOrganizationAdminAccountsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListOrganizationAdminAccountsCommand extends $Command<ListOrganizationAdminAccountsCommandInput, ListOrganizationAdminAccountsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListOrganizationAdminAccountsCommandInput;
+    constructor(input: ListOrganizationAdminAccountsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListOrganizationAdminAccountsCommandInput, ListOrganizationAdminAccountsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListPublishingDestinationsCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListPublishingDestinationsRequest, ListPublishingDestinationsResponse } from "../models/models_0";
+export interface ListPublishingDestinationsCommandInput extends ListPublishingDestinationsRequest {
+}
+export interface ListPublishingDestinationsCommandOutput extends ListPublishingDestinationsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of publishing destinations associated with the specified
+ *         <code>dectectorId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListPublishingDestinationsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListPublishingDestinationsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListPublishingDestinationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListPublishingDestinationsCommandInput} for command's `input` shape.
+ * @see {@link ListPublishingDestinationsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListPublishingDestinationsCommand extends $Command<ListPublishingDestinationsCommandInput, ListPublishingDestinationsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListPublishingDestinationsCommandInput;
+    constructor(input: ListPublishingDestinationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListPublishingDestinationsCommandInput, ListPublishingDestinationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists tags for a resource. Tagging is currently supported for detectors, finding filters,
+ *       IP sets, and threat intel sets, with a limit of 50 tags per resource. When invoked, this
+ *       operation returns all assigned tags for a given resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListTagsForResourceCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListTagsForResourceCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListThreatIntelSetsCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
+import { ListThreatIntelSetsRequest, ListThreatIntelSetsResponse } from "../models/models_0";
+export interface ListThreatIntelSetsCommandInput extends ListThreatIntelSetsRequest {
+}
+export interface ListThreatIntelSetsCommandOutput extends ListThreatIntelSetsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the ThreatIntelSets of the GuardDuty service specified by the detector ID. If you
+ *       use this operation from a member account, the ThreatIntelSets associated with the administrator
+ *       account are returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GuardDutyClient, ListThreatIntelSetsCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
+ * // const { GuardDutyClient, ListThreatIntelSetsCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
+ * const client = new GuardDutyClient(config);
+ * const command = new ListThreatIntelSetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListThreatIntelSetsCommandInput} for command's `input` shape.
+ * @see {@link ListThreatIntelSetsCommandOutput} for command's `response` shape.
+ * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListThreatIntelSetsCommand extends $Command<ListThreatIntelSetsCommandInput, ListThreatIntelSetsCommandOutput, GuardDutyClientResolvedConfig> {
+    readonly input: ListThreatIntelSetsCommandInput;
+    constructor(input: ListThreatIntelSetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListThreatIntelSetsCommandInput, ListThreatIntelSetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}