@aws-sdk/client-securitylake 3.341.0 → 3.342.0

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

@@ -1,98 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateDatalakeAutoEnableRequest, CreateDatalakeAutoEnableResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateDatalakeAutoEnableCommand}.
- */
-export interface CreateDatalakeAutoEnableCommandInput extends CreateDatalakeAutoEnableRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateDatalakeAutoEnableCommand}.
- */
-export interface CreateDatalakeAutoEnableCommandOutput extends CreateDatalakeAutoEnableResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>Automatically enables Amazon Security Lake for new member accounts in your organization.
- *          Security Lake is not automatically enabled for any existing member accounts in your
- *          organization.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, CreateDatalakeAutoEnableCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, CreateDatalakeAutoEnableCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // CreateDatalakeAutoEnableRequest
- *   configurationForNewAccounts: [ // AutoEnableNewRegionConfigurationList // required
- *     { // AutoEnableNewRegionConfiguration
- *       region: "STRING_VALUE", // required
- *       sources: [ // AwsSourceTypeList // required
- *         "STRING_VALUE",
- *       ],
- *     },
- *   ],
- * };
- * const command = new CreateDatalakeAutoEnableCommand(input);
- * const response = await client.send(command);
- * // {};
- *
- * ```
- *
- * @param CreateDatalakeAutoEnableCommandInput - {@link CreateDatalakeAutoEnableCommandInput}
- * @returns {@link CreateDatalakeAutoEnableCommandOutput}
- * @see {@link CreateDatalakeAutoEnableCommandInput} for command's `input` shape.
- * @see {@link CreateDatalakeAutoEnableCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link AccountNotFoundException} (client fault)
- *  <p>Amazon Security Lake cannot find an Amazon Web Services account with the accountID that you
- *          specified, or the account whose credentials you used to make this request isn't a member of
- *          an organization.</p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class CreateDatalakeAutoEnableCommand extends $Command<CreateDatalakeAutoEnableCommandInput, CreateDatalakeAutoEnableCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: CreateDatalakeAutoEnableCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateDatalakeAutoEnableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeAutoEnableCommandInput, CreateDatalakeAutoEnableCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

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

@@ -1,137 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateDatalakeRequest, CreateDatalakeResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateDatalakeCommand}.
- */
-export interface CreateDatalakeCommandInput extends CreateDatalakeRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateDatalakeCommand}.
- */
-export interface CreateDatalakeCommandOutput extends CreateDatalakeResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>Initializes an Amazon Security Lake instance with the provided (or default) configuration. You
- *          can enable Security Lake in Amazon Web Services Regions with customized settings before enabling
- *          log collection in Regions. You can either use the <code>enableAll</code> parameter to
- *          specify all Regions or specify the Regions where you want to enable Security Lake. To specify
- *          particular Regions, use the <code>Regions</code> parameter and then configure these Regions
- *          using the <code>configurations</code> parameter. If you have already enabled Security Lake in a
- *          Region when you call this command, the command will update the Region if you provide new
- *          configuration parameters. If you have not already enabled Security Lake in the Region when you
- *          call this API, it will set up the data lake in the Region with the specified
- *          configurations.</p>
- *          <p>When you enable Security Lake, it starts ingesting security data after the
- *             <code>CreateAwsLogSource</code> call. This includes ingesting security data from
- *          sources, storing data, and making data accessible to subscribers. Security Lake also enables
- *          all the existing settings and resources that it stores or maintains for your Amazon Web Services account in the current Region, including security log and event data. For
- *          more information, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/what-is-security-lake.html">Amazon Security Lake User
- *             Guide</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, CreateDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, CreateDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // CreateDatalakeRequest
- *   regions: [ // RegionSet
- *     "STRING_VALUE",
- *   ],
- *   configurations: { // LakeConfigurationRequestMap
- *     "<keys>": { // LakeConfigurationRequest
- *       encryptionKey: "STRING_VALUE",
- *       retentionSettings: [ // RetentionSettingList
- *         { // RetentionSetting
- *           storageClass: "STRING_VALUE",
- *           retentionPeriod: Number("int"),
- *         },
- *       ],
- *       tagsMap: { // TagsMap
- *         "<keys>": "STRING_VALUE",
- *       },
- *       replicationDestinationRegions: [
- *         "STRING_VALUE",
- *       ],
- *       replicationRoleArn: "STRING_VALUE",
- *     },
- *   },
- *   enableAll: true || false,
- *   metaStoreManagerRoleArn: "STRING_VALUE",
- * };
- * const command = new CreateDatalakeCommand(input);
- * const response = await client.send(command);
- * // {};
- *
- * ```
- *
- * @param CreateDatalakeCommandInput - {@link CreateDatalakeCommandInput}
- * @returns {@link CreateDatalakeCommandOutput}
- * @see {@link CreateDatalakeCommandInput} for command's `input` shape.
- * @see {@link CreateDatalakeCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link ConflictException} (client fault)
- *  <p>Occurs when a conflict with a previous successful write is detected. This generally
- *          occurs when the previous write did not have time to propagate to the host serving the
- *          current request. A retry (with appropriate backoff logic) is the recommended response to
- *          this exception.</p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link ResourceNotFoundException} (client fault)
- *  <p>The resource could not be found.</p>
- *
- * @throws {@link ServiceQuotaExceededException} (client fault)
- *  <p>You have exceeded your service quota. To perform the requested action, remove some of
- *          the relevant resources, or use Service Quotas to request a service quota increase. </p>
- *
- * @throws {@link ThrottlingException} (client fault)
- *  <p>The limit on the number of requests per second was exceeded. </p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class CreateDatalakeCommand extends $Command<CreateDatalakeCommandInput, CreateDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: CreateDatalakeCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateDatalakeCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeCommandInput, CreateDatalakeCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

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

@@ -1,89 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateDatalakeDelegatedAdminRequest, CreateDatalakeDelegatedAdminResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateDatalakeDelegatedAdminCommand}.
- */
-export interface CreateDatalakeDelegatedAdminCommandInput extends CreateDatalakeDelegatedAdminRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateDatalakeDelegatedAdminCommand}.
- */
-export interface CreateDatalakeDelegatedAdminCommandOutput extends CreateDatalakeDelegatedAdminResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>Designates the Amazon Security Lake delegated administrator account for the organization. This
- *          API can only be called by the organization management account. The organization management
- *          account cannot be the delegated administrator account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, CreateDatalakeDelegatedAdminCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, CreateDatalakeDelegatedAdminCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // CreateDatalakeDelegatedAdminRequest
- *   account: "STRING_VALUE", // required
- * };
- * const command = new CreateDatalakeDelegatedAdminCommand(input);
- * const response = await client.send(command);
- * // {};
- *
- * ```
- *
- * @param CreateDatalakeDelegatedAdminCommandInput - {@link CreateDatalakeDelegatedAdminCommandInput}
- * @returns {@link CreateDatalakeDelegatedAdminCommandOutput}
- * @see {@link CreateDatalakeDelegatedAdminCommandInput} for command's `input` shape.
- * @see {@link CreateDatalakeDelegatedAdminCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link ThrottlingException} (client fault)
- *  <p>The limit on the number of requests per second was exceeded. </p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class CreateDatalakeDelegatedAdminCommand extends $Command<CreateDatalakeDelegatedAdminCommandInput, CreateDatalakeDelegatedAdminCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: CreateDatalakeDelegatedAdminCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateDatalakeDelegatedAdminCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeDelegatedAdminCommandInput, CreateDatalakeDelegatedAdminCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

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

@@ -1,91 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateDatalakeExceptionsSubscriptionRequest, CreateDatalakeExceptionsSubscriptionResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateDatalakeExceptionsSubscriptionCommand}.
- */
-export interface CreateDatalakeExceptionsSubscriptionCommandInput extends CreateDatalakeExceptionsSubscriptionRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateDatalakeExceptionsSubscriptionCommand}.
- */
-export interface CreateDatalakeExceptionsSubscriptionCommandOutput extends CreateDatalakeExceptionsSubscriptionResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>Creates the specified notification subscription in Amazon Security Lake for the organization
- *          you specify.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, CreateDatalakeExceptionsSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, CreateDatalakeExceptionsSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // CreateDatalakeExceptionsSubscriptionRequest
- *   subscriptionProtocol: "STRING_VALUE", // required
- *   notificationEndpoint: "STRING_VALUE", // required
- * };
- * const command = new CreateDatalakeExceptionsSubscriptionCommand(input);
- * const response = await client.send(command);
- * // {};
- *
- * ```
- *
- * @param CreateDatalakeExceptionsSubscriptionCommandInput - {@link CreateDatalakeExceptionsSubscriptionCommandInput}
- * @returns {@link CreateDatalakeExceptionsSubscriptionCommandOutput}
- * @see {@link CreateDatalakeExceptionsSubscriptionCommandInput} for command's `input` shape.
- * @see {@link CreateDatalakeExceptionsSubscriptionCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link AccountNotFoundException} (client fault)
- *  <p>Amazon Security Lake cannot find an Amazon Web Services account with the accountID that you
- *          specified, or the account whose credentials you used to make this request isn't a member of
- *          an organization.</p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class CreateDatalakeExceptionsSubscriptionCommand extends $Command<CreateDatalakeExceptionsSubscriptionCommandInput, CreateDatalakeExceptionsSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: CreateDatalakeExceptionsSubscriptionCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateDatalakeExceptionsSubscriptionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatalakeExceptionsSubscriptionCommandInput, CreateDatalakeExceptionsSubscriptionCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

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

@@ -1,109 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { CreateSubscriptionNotificationConfigurationRequest, CreateSubscriptionNotificationConfigurationResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link CreateSubscriptionNotificationConfigurationCommand}.
- */
-export interface CreateSubscriptionNotificationConfigurationCommandInput extends CreateSubscriptionNotificationConfigurationRequest {
-}
-/**
- * @public
- *
- * The output of {@link CreateSubscriptionNotificationConfigurationCommand}.
- */
-export interface CreateSubscriptionNotificationConfigurationCommandOutput extends CreateSubscriptionNotificationConfigurationResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>Notifies the subscriber when new data is written to the data lake for the sources that
- *          the subscriber consumes in Security Lake. You can create only one subscriber notification per
- *          subscriber.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, CreateSubscriptionNotificationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, CreateSubscriptionNotificationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // CreateSubscriptionNotificationConfigurationRequest
- *   subscriptionId: "STRING_VALUE", // required
- *   subscriptionEndpoint: "STRING_VALUE",
- *   httpsApiKeyName: "STRING_VALUE",
- *   httpsApiKeyValue: "STRING_VALUE",
- *   httpsMethod: "STRING_VALUE",
- *   createSqs: true || false,
- *   roleArn: "STRING_VALUE",
- * };
- * const command = new CreateSubscriptionNotificationConfigurationCommand(input);
- * const response = await client.send(command);
- * // { // CreateSubscriptionNotificationConfigurationResponse
- * //   queueArn: "STRING_VALUE",
- * // };
- *
- * ```
- *
- * @param CreateSubscriptionNotificationConfigurationCommandInput - {@link CreateSubscriptionNotificationConfigurationCommandInput}
- * @returns {@link CreateSubscriptionNotificationConfigurationCommandOutput}
- * @see {@link CreateSubscriptionNotificationConfigurationCommandInput} for command's `input` shape.
- * @see {@link CreateSubscriptionNotificationConfigurationCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link AccountNotFoundException} (client fault)
- *  <p>Amazon Security Lake cannot find an Amazon Web Services account with the accountID that you
- *          specified, or the account whose credentials you used to make this request isn't a member of
- *          an organization.</p>
- *
- * @throws {@link ConcurrentModificationException} (client fault)
- *  <p>More than one process tried to modify a resource at the same time. </p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link InvalidInputException} (client fault)
- *  <p>The request was rejected because a value that's not valid or is out of range was
- *          supplied for an input parameter. </p>
- *
- * @throws {@link ResourceNotFoundException} (client fault)
- *  <p>The resource could not be found.</p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class CreateSubscriptionNotificationConfigurationCommand extends $Command<CreateSubscriptionNotificationConfigurationCommandInput, CreateSubscriptionNotificationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: CreateSubscriptionNotificationConfigurationCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: CreateSubscriptionNotificationConfigurationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionNotificationConfigurationCommandInput, CreateSubscriptionNotificationConfigurationCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}

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

@@ -1,101 +0,0 @@
-import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
-import { DeleteDatalakeAutoEnableRequest, DeleteDatalakeAutoEnableResponse } from "../models/models_0";
-import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
-/**
- * @public
- */
-export { __MetadataBearer, $Command };
-/**
- * @public
- *
- * The input for {@link DeleteDatalakeAutoEnableCommand}.
- */
-export interface DeleteDatalakeAutoEnableCommandInput extends DeleteDatalakeAutoEnableRequest {
-}
-/**
- * @public
- *
- * The output of {@link DeleteDatalakeAutoEnableCommand}.
- */
-export interface DeleteDatalakeAutoEnableCommandOutput extends DeleteDatalakeAutoEnableResponse, __MetadataBearer {
-}
-/**
- * @public
- * <p>
- *             <code>DeleteDatalakeAutoEnable</code> removes automatic enablement of configuration
- *          settings for new member accounts (but keeps settings for the delegated administrator) from
- *          Amazon Security Lake.  You must run this API using credentials of the delegated administrator.
- *          When you run this API, new member accounts that are added after the organization enables
- *          Security Lake won't contribute to the data lake.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecurityLakeClient, DeleteDatalakeAutoEnableCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, DeleteDatalakeAutoEnableCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
- * const client = new SecurityLakeClient(config);
- * const input = { // DeleteDatalakeAutoEnableRequest
- *   removeFromConfigurationForNewAccounts: [ // AutoEnableNewRegionConfigurationList // required
- *     { // AutoEnableNewRegionConfiguration
- *       region: "STRING_VALUE", // required
- *       sources: [ // AwsSourceTypeList // required
- *         "STRING_VALUE",
- *       ],
- *     },
- *   ],
- * };
- * const command = new DeleteDatalakeAutoEnableCommand(input);
- * const response = await client.send(command);
- * // {};
- *
- * ```
- *
- * @param DeleteDatalakeAutoEnableCommandInput - {@link DeleteDatalakeAutoEnableCommandInput}
- * @returns {@link DeleteDatalakeAutoEnableCommandOutput}
- * @see {@link DeleteDatalakeAutoEnableCommandInput} for command's `input` shape.
- * @see {@link DeleteDatalakeAutoEnableCommandOutput} for command's `response` shape.
- * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
- *
- * @throws {@link AccessDeniedException} (client fault)
- *  <p>You do not have sufficient access to perform this action. Access denied errors appear when Amazon Security Lake explicitly or implicitly denies an authorization
- *          request. An explicit denial occurs when a policy contains a Deny statement for the specific
- *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
- *          no applicable Allow statement.</p>
- *
- * @throws {@link AccountNotFoundException} (client fault)
- *  <p>Amazon Security Lake cannot find an Amazon Web Services account with the accountID that you
- *          specified, or the account whose credentials you used to make this request isn't a member of
- *          an organization.</p>
- *
- * @throws {@link InternalServerException} (server fault)
- *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
- *
- * @throws {@link ValidationException} (client fault)
- *  <p>Your signing certificate could not be validated. </p>
- *
- * @throws {@link SecurityLakeServiceException}
- * <p>Base exception class for all service exceptions from SecurityLake service.</p>
- *
- */
-export declare class DeleteDatalakeAutoEnableCommand extends $Command<DeleteDatalakeAutoEnableCommandInput, DeleteDatalakeAutoEnableCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: DeleteDatalakeAutoEnableCommandInput;
-    static getEndpointParameterInstructions(): EndpointParameterInstructions;
-    /**
-     * @public
-     */
-    constructor(input: DeleteDatalakeAutoEnableCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeAutoEnableCommandInput, DeleteDatalakeAutoEnableCommandOutput>;
-    /**
-     * @internal
-     */
-    private serialize;
-    /**
-     * @internal
-     */
-    private deserialize;
-}