@aws-sdk/client-guardduty 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/StartMonitoringMembersCommand.d.ts

@@ -1,37 +0,0 @@
-import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
-import { StartMonitoringMembersRequest, StartMonitoringMembersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StartMonitoringMembersCommandInput extends StartMonitoringMembersRequest {
-}
-export interface StartMonitoringMembersCommandOutput extends StartMonitoringMembersResponse, __MetadataBearer {
-}
-/**
- * <p>Turns on GuardDuty monitoring of the specified member accounts. Use this operation to
- *       restart monitoring of accounts that you stopped monitoring with the
- *         <code>StopMonitoringMembers</code> operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GuardDutyClient, StartMonitoringMembersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
- * // const { GuardDutyClient, StartMonitoringMembersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
- * const client = new GuardDutyClient(config);
- * const command = new StartMonitoringMembersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartMonitoringMembersCommandInput} for command's `input` shape.
- * @see {@link StartMonitoringMembersCommandOutput} for command's `response` shape.
- * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StartMonitoringMembersCommand extends $Command<StartMonitoringMembersCommandInput, StartMonitoringMembersCommandOutput, GuardDutyClientResolvedConfig> {
-    readonly input: StartMonitoringMembersCommandInput;
-    constructor(input: StartMonitoringMembersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartMonitoringMembersCommandInput, StartMonitoringMembersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/StopMonitoringMembersCommand.d.ts

@@ -1,37 +0,0 @@
-import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
-import { StopMonitoringMembersRequest, StopMonitoringMembersResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface StopMonitoringMembersCommandInput extends StopMonitoringMembersRequest {
-}
-export interface StopMonitoringMembersCommandOutput extends StopMonitoringMembersResponse, __MetadataBearer {
-}
-/**
- * <p>Stops GuardDuty monitoring for the specified member accounts. Use the
- *         <code>StartMonitoringMembers</code> operation to restart monitoring for those
- *       accounts.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GuardDutyClient, StopMonitoringMembersCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
- * // const { GuardDutyClient, StopMonitoringMembersCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
- * const client = new GuardDutyClient(config);
- * const command = new StopMonitoringMembersCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StopMonitoringMembersCommandInput} for command's `input` shape.
- * @see {@link StopMonitoringMembersCommandOutput} for command's `response` shape.
- * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class StopMonitoringMembersCommand extends $Command<StopMonitoringMembersCommandInput, StopMonitoringMembersCommandOutput, GuardDutyClientResolvedConfig> {
-    readonly input: StopMonitoringMembersCommandInput;
-    constructor(input: StopMonitoringMembersCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopMonitoringMembersCommandInput, StopMonitoringMembersCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/TagResourceCommand.d.ts

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

package/dist/types/ts3.4/commands/UnarchiveFindingsCommand.d.ts

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

package/dist/types/ts3.4/commands/UntagResourceCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateDetectorCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateFilterCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateFindingsFeedbackCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateIPSetCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateMemberDetectorsCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateOrganizationConfigurationCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdatePublishingDestinationCommand.d.ts

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

package/dist/types/ts3.4/commands/UpdateThreatIntelSetCommand.d.ts

@@ -1,35 +0,0 @@
-import { GuardDutyClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GuardDutyClient";
-import { UpdateThreatIntelSetRequest, UpdateThreatIntelSetResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface UpdateThreatIntelSetCommandInput extends UpdateThreatIntelSetRequest {
-}
-export interface UpdateThreatIntelSetCommandOutput extends UpdateThreatIntelSetResponse, __MetadataBearer {
-}
-/**
- * <p>Updates the ThreatIntelSet 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, UpdateThreatIntelSetCommand } from "@aws-sdk/client-guardduty"; // ES Modules import
- * // const { GuardDutyClient, UpdateThreatIntelSetCommand } = require("@aws-sdk/client-guardduty"); // CommonJS import
- * const client = new GuardDutyClient(config);
- * const command = new UpdateThreatIntelSetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateThreatIntelSetCommandInput} for command's `input` shape.
- * @see {@link UpdateThreatIntelSetCommandOutput} for command's `response` shape.
- * @see {@link GuardDutyClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateThreatIntelSetCommand extends $Command<UpdateThreatIntelSetCommandInput, UpdateThreatIntelSetCommandOutput, GuardDutyClientResolvedConfig> {
-    readonly input: UpdateThreatIntelSetCommandInput;
-    constructor(input: UpdateThreatIntelSetCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GuardDutyClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateThreatIntelSetCommandInput, UpdateThreatIntelSetCommandOutput>;
-    private serialize;
-    private deserialize;
-}