@aws-sdk/client-securitylake 3.341.0 → 3.342.0

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

@@ -0,0 +1,110 @@
+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 { CreateSubscriberNotificationRequest, CreateSubscriberNotificationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link CreateSubscriberNotificationCommand}.
+ */
+export interface CreateSubscriberNotificationCommandInput extends CreateSubscriberNotificationRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CreateSubscriberNotificationCommand}.
+ */
+export interface CreateSubscriberNotificationCommandOutput extends CreateSubscriberNotificationResponse, __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, CreateSubscriberNotificationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateSubscriberNotificationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const input = { // CreateSubscriberNotificationRequest
+ *   subscriberId: "STRING_VALUE", // required
+ *   configuration: { // NotificationConfiguration Union: only one key present
+ *     sqsNotificationConfiguration: {},
+ *     httpsNotificationConfiguration: { // HttpsNotificationConfiguration
+ *       endpoint: "STRING_VALUE", // required
+ *       authorizationApiKeyName: "STRING_VALUE",
+ *       authorizationApiKeyValue: "STRING_VALUE",
+ *       httpMethod: "POST" || "PUT",
+ *       targetRoleArn: "STRING_VALUE", // required
+ *     },
+ *   },
+ * };
+ * const command = new CreateSubscriberNotificationCommand(input);
+ * const response = await client.send(command);
+ * // { // CreateSubscriberNotificationResponse
+ * //   subscriberEndpoint: "STRING_VALUE",
+ * // };
+ *
+ * ```
+ *
+ * @param CreateSubscriberNotificationCommandInput - {@link CreateSubscriberNotificationCommandInput}
+ * @returns {@link CreateSubscriberNotificationCommandOutput}
+ * @see {@link CreateSubscriberNotificationCommandInput} for command's `input` shape.
+ * @see {@link CreateSubscriberNotificationCommandOutput} 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 BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</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 ThrottlingException} (client fault)
+ *  <p>The limit on the number of requests per second was exceeded.</p>
+ *
+ * @throws {@link SecurityLakeServiceException}
+ * <p>Base exception class for all service exceptions from SecurityLake service.</p>
+ *
+ */
+export declare class CreateSubscriberNotificationCommand extends $Command<CreateSubscriberNotificationCommandInput, CreateSubscriberNotificationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateSubscriberNotificationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: CreateSubscriberNotificationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriberNotificationCommandInput, CreateSubscriberNotificationCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -23,21 +23,13 @@ export interface DeleteAwsLogSourceCommandOutput extends DeleteAwsLogSourceRespo
 }
 /**
  * @public
- * <p>Removes a natively supported Amazon Web Service as an Amazon Security Lake source. When
- *          you remove the source, Security Lake stops collecting data from that source, and subscribers
- *          can no longer consume new data from the source. Subscribers can still consume data that
- *          Security Lake collected from the source before disablement.</p>
+ * <p>Removes a natively supported Amazon Web Service as an Amazon Security Lake source. You
+ *          can remove a source for one or more Regions. When you remove the source, Security Lake stops
+ *          collecting data from that source in the specified Regions and accounts, and subscribers can
+ *          no longer consume new data from the source. However, subscribers can still consume data
+ *          that Security Lake collected from the source before removal.</p>
  *          <p>You can choose any source type in any Amazon Web Services Region for either accounts that
- *          are part of a trusted organization or standalone accounts. At least one of the three
- *          dimensions is a mandatory input to this API. However, you can supply any combination of the
- *          three dimensions to this API. </p>
- *          <p>By default, a dimension refers to the entire set. This is overridden when you supply any
- *          one of the inputs. For instance, when you do not specify members, the API disables all
- *          Security Lake member accounts for sources. Similarly, when you do not specify Regions,
- *          Security Lake is disabled for all the Regions where Security Lake is available as a service.</p>
- *          <p>When you don't provide a dimension, Security Lake  assumes that the missing dimension refers
- *          to the entire set. For example, if you don't provide specific accounts, the API applies to
- *          the entire set of accounts in your organization.</p>
+ *          are part of a trusted organization or standalone accounts. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -45,32 +37,23 @@ export interface DeleteAwsLogSourceCommandOutput extends DeleteAwsLogSourceRespo
  * // const { SecurityLakeClient, DeleteAwsLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
  * const client = new SecurityLakeClient(config);
  * const input = { // DeleteAwsLogSourceRequest
- *   inputOrder: [ // DimensionSet // required
- *     "STRING_VALUE",
- *   ],
- *   disableAllDimensions: { // AllDimensionsMap
- *     "<keys>": { // TwoDimensionsMap
- *       "<keys>": [ // ValueSet
+ *   sources: [ // AwsLogSourceConfigurationList // required
+ *     { // AwsLogSourceConfiguration
+ *       accounts: [ // AccountList
+ *         "STRING_VALUE",
+ *       ],
+ *       regions: [ // RegionList // required
  *         "STRING_VALUE",
  *       ],
+ *       sourceName: "ROUTE53" || "VPC_FLOW" || "SH_FINDINGS" || "CLOUD_TRAIL_MGMT" || "LAMBDA_EXECUTION" || "S3_DATA", // required
+ *       sourceVersion: "STRING_VALUE",
  *     },
- *   },
- *   disableTwoDimensions: {
- *     "<keys>": [
- *       "STRING_VALUE",
- *     ],
- *   },
- *   disableSingleDimension: [ // InputSet
- *     "STRING_VALUE",
  *   ],
  * };
  * const command = new DeleteAwsLogSourceCommand(input);
  * const response = await client.send(command);
  * // { // DeleteAwsLogSourceResponse
- * //   processing: [ // AccountList
- * //     "STRING_VALUE",
- * //   ],
- * //   failed: [
+ * //   failed: [ // AccountList
  * //     "STRING_VALUE",
  * //   ],
  * // };
@@ -89,17 +72,24 @@ export interface DeleteAwsLogSourceCommandOutput extends DeleteAwsLogSourceRespo
  *          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 BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</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>
+ *          troubleshooting, perform the operation again.</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 ThrottlingException} (client fault)
+ *  <p>The limit on the number of requests per second was exceeded.</p>
  *
  * @throws {@link SecurityLakeServiceException}
  * <p>Base exception class for all service exceptions from SecurityLake service.</p>

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

@@ -23,7 +23,8 @@ export interface DeleteCustomLogSourceCommandOutput extends DeleteCustomLogSourc
 }
 /**
  * @public
- * <p>Removes a custom log source from Amazon Security Lake.</p>
+ * <p>Removes a custom log source from Amazon Security Lake, to stop sending data from the custom
+ *          source to Security Lake.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -31,13 +32,12 @@ export interface DeleteCustomLogSourceCommandOutput extends DeleteCustomLogSourc
  * // const { SecurityLakeClient, DeleteCustomLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
  * const client = new SecurityLakeClient(config);
  * const input = { // DeleteCustomLogSourceRequest
- *   customSourceName: "STRING_VALUE", // required
+ *   sourceName: "STRING_VALUE", // required
+ *   sourceVersion: "STRING_VALUE",
  * };
  * const command = new DeleteCustomLogSourceCommand(input);
  * const response = await client.send(command);
- * // { // DeleteCustomLogSourceResponse
- * //   customDataLocation: "STRING_VALUE", // required
- * // };
+ * // {};
  *
  * ```
  *
@@ -53,27 +53,24 @@ export interface DeleteCustomLogSourceCommandOutput extends DeleteCustomLogSourc
  *          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 BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</p>
  *
- * @throws {@link BucketNotFoundException} (client fault)
- *  <p>Amazon Security Lake  generally returns 404 errors if the requested object is missing from the
- *          bucket.</p>
- *
- * @throws {@link ConflictSourceNamesException} (client fault)
- *  <p>There was a conflict when you attempted to modify a Security Lake source name. </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>
+ *          troubleshooting, perform the operation again.</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 ThrottlingException} (client fault)
+ *  <p>The limit on the number of requests per second was exceeded.</p>
  *
  * @throws {@link SecurityLakeServiceException}
  * <p>Base exception class for all service exceptions from SecurityLake service.</p>

package/dist-types/commands/{DeleteDatalakeCommand.d.ts → DeleteDataLakeCommand.d.ts}

@@ -1,7 +1,7 @@
 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 { DeleteDatalakeRequest, DeleteDatalakeResponse } from "../models/models_0";
+import { DeleteDataLakeRequest, DeleteDataLakeResponse } from "../models/models_0";
 import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
 /**
  * @public
@@ -10,44 +10,48 @@ export { __MetadataBearer, $Command };
 /**
  * @public
  *
- * The input for {@link DeleteDatalakeCommand}.
+ * The input for {@link DeleteDataLakeCommand}.
  */
-export interface DeleteDatalakeCommandInput extends DeleteDatalakeRequest {
+export interface DeleteDataLakeCommandInput extends DeleteDataLakeRequest {
 }
 /**
  * @public
  *
- * The output of {@link DeleteDatalakeCommand}.
+ * The output of {@link DeleteDataLakeCommand}.
  */
-export interface DeleteDatalakeCommandOutput extends DeleteDatalakeResponse, __MetadataBearer {
+export interface DeleteDataLakeCommandOutput extends DeleteDataLakeResponse, __MetadataBearer {
 }
 /**
  * @public
- * <p>When you delete Amazon Security Lake from your account, Security Lake is disabled in all Amazon Web Services Regions. Also, this API automatically takes steps to remove the account from
- *          Security Lake . </p>
- *          <p>This operation disables security data collection from sources, deletes data stored, and
- *          stops making data accessible to subscribers. Security Lake also deletes 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. The <code>DeleteDatalake</code>
- *          operation does not delete the Amazon S3 bucket, which is owned by your Amazon Web Services account. For more information, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/disable-security-lake.html">Amazon Security Lake User
+ * <p>When you disable Amazon Security Lake from your account, Security Lake is disabled in all Amazon Web Services Regions and it stops collecting data from your sources. Also, this API
+ *          automatically takes steps to remove the account from Security Lake. However, Security Lake retains
+ *          all of your existing settings and the resources that it created in your Amazon Web Services
+ *          account in the current Amazon Web Services Region.</p>
+ *          <p>The <code>DeleteDataLake</code> operation does not delete the data that is stored in
+ *          your Amazon S3 bucket, which is owned by your Amazon Web Services account. For more
+ *          information, see the <a href="https://docs.aws.amazon.com/security-lake/latest/userguide/disable-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, DeleteDatalakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
- * // const { SecurityLakeClient, DeleteDatalakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * import { SecurityLakeClient, DeleteDataLakeCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDataLakeCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
  * const client = new SecurityLakeClient(config);
- * const input = {};
- * const command = new DeleteDatalakeCommand(input);
+ * const input = { // DeleteDataLakeRequest
+ *   regions: [ // RegionList // required
+ *     "STRING_VALUE",
+ *   ],
+ * };
+ * const command = new DeleteDataLakeCommand(input);
  * const response = await client.send(command);
  * // {};
  *
  * ```
  *
- * @param DeleteDatalakeCommandInput - {@link DeleteDatalakeCommandInput}
- * @returns {@link DeleteDatalakeCommandOutput}
- * @see {@link DeleteDatalakeCommandInput} for command's `input` shape.
- * @see {@link DeleteDatalakeCommandOutput} for command's `response` shape.
+ * @param DeleteDataLakeCommandInput - {@link DeleteDataLakeCommandInput}
+ * @returns {@link DeleteDataLakeCommandOutput}
+ * @see {@link DeleteDataLakeCommandInput} for command's `input` shape.
+ * @see {@link DeleteDataLakeCommandOutput} for command's `response` shape.
  * @see {@link SecurityLakeClientResolvedConfig | config} for SecurityLakeClient's `config` shape.
  *
  * @throws {@link AccessDeniedException} (client fault)
@@ -56,6 +60,9 @@ export interface DeleteDatalakeCommandOutput extends DeleteDatalakeResponse, __M
  *          Amazon Web Services action. An implicit denial occurs when there is no applicable Deny statement and also
  *          no applicable Allow statement.</p>
  *
+ * @throws {@link BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</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
@@ -64,36 +71,29 @@ export interface DeleteDatalakeCommandOutput extends DeleteDatalakeResponse, __M
  *
  * @throws {@link InternalServerException} (server fault)
  *  <p>Internal service exceptions are sometimes caused by transient issues. Before you start
- *          troubleshooting, perform the operation again. </p>
+ *          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>
+ *  <p>The limit on the number of requests per second was exceeded.</p>
  *
  * @throws {@link SecurityLakeServiceException}
  * <p>Base exception class for all service exceptions from SecurityLake service.</p>
  *
  */
-export declare class DeleteDatalakeCommand extends $Command<DeleteDatalakeCommandInput, DeleteDatalakeCommandOutput, SecurityLakeClientResolvedConfig> {
-    readonly input: DeleteDatalakeCommandInput;
+export declare class DeleteDataLakeCommand extends $Command<DeleteDataLakeCommandInput, DeleteDataLakeCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDataLakeCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
     /**
      * @public
      */
-    constructor(input: DeleteDatalakeCommandInput);
+    constructor(input: DeleteDataLakeCommandInput);
     /**
      * @internal
      */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatalakeCommandInput, DeleteDatalakeCommandOutput>;
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataLakeCommandInput, DeleteDataLakeCommandOutput>;
     /**
      * @internal
      */

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

@@ -0,0 +1,95 @@
+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 { DeleteDataLakeExceptionSubscriptionRequest, DeleteDataLakeExceptionSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link DeleteDataLakeExceptionSubscriptionCommand}.
+ */
+export interface DeleteDataLakeExceptionSubscriptionCommandInput extends DeleteDataLakeExceptionSubscriptionRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link DeleteDataLakeExceptionSubscriptionCommand}.
+ */
+export interface DeleteDataLakeExceptionSubscriptionCommandOutput extends DeleteDataLakeExceptionSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Deletes 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, DeleteDataLakeExceptionSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDataLakeExceptionSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const input = {};
+ * const command = new DeleteDataLakeExceptionSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param DeleteDataLakeExceptionSubscriptionCommandInput - {@link DeleteDataLakeExceptionSubscriptionCommandInput}
+ * @returns {@link DeleteDataLakeExceptionSubscriptionCommandOutput}
+ * @see {@link DeleteDataLakeExceptionSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link DeleteDataLakeExceptionSubscriptionCommandOutput} 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 BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</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 ThrottlingException} (client fault)
+ *  <p>The limit on the number of requests per second was exceeded.</p>
+ *
+ * @throws {@link SecurityLakeServiceException}
+ * <p>Base exception class for all service exceptions from SecurityLake service.</p>
+ *
+ */
+export declare class DeleteDataLakeExceptionSubscriptionCommand extends $Command<DeleteDataLakeExceptionSubscriptionCommandInput, DeleteDataLakeExceptionSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDataLakeExceptionSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: DeleteDataLakeExceptionSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataLakeExceptionSubscriptionCommandInput, DeleteDataLakeExceptionSubscriptionCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,110 @@
+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 { DeleteDataLakeOrganizationConfigurationRequest, DeleteDataLakeOrganizationConfigurationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link DeleteDataLakeOrganizationConfigurationCommand}.
+ */
+export interface DeleteDataLakeOrganizationConfigurationCommandInput extends DeleteDataLakeOrganizationConfigurationRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link DeleteDataLakeOrganizationConfigurationCommand}.
+ */
+export interface DeleteDataLakeOrganizationConfigurationCommandOutput extends DeleteDataLakeOrganizationConfigurationResponse, __MetadataBearer {
+}
+/**
+ * @public
+ * <p>Removes automatic the enablement of configuration settings for new member accounts (but
+ *          retains the settings for the delegated administrator) from Amazon Security Lake. You must run this
+ *          API using the 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, DeleteDataLakeOrganizationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, DeleteDataLakeOrganizationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const input = { // DeleteDataLakeOrganizationConfigurationRequest
+ *   autoEnableNewAccount: [ // DataLakeAutoEnableNewAccountConfigurationList // required
+ *     { // DataLakeAutoEnableNewAccountConfiguration
+ *       region: "STRING_VALUE", // required
+ *       sources: [ // AwsLogSourceResourceList // required
+ *         { // AwsLogSourceResource
+ *           sourceName: "ROUTE53" || "VPC_FLOW" || "SH_FINDINGS" || "CLOUD_TRAIL_MGMT" || "LAMBDA_EXECUTION" || "S3_DATA",
+ *           sourceVersion: "STRING_VALUE",
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * };
+ * const command = new DeleteDataLakeOrganizationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param DeleteDataLakeOrganizationConfigurationCommandInput - {@link DeleteDataLakeOrganizationConfigurationCommandInput}
+ * @returns {@link DeleteDataLakeOrganizationConfigurationCommandOutput}
+ * @see {@link DeleteDataLakeOrganizationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link DeleteDataLakeOrganizationConfigurationCommandOutput} 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 BadRequestException} (client fault)
+ *  <p>The request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</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 ThrottlingException} (client fault)
+ *  <p>The limit on the number of requests per second was exceeded.</p>
+ *
+ * @throws {@link SecurityLakeServiceException}
+ * <p>Base exception class for all service exceptions from SecurityLake service.</p>
+ *
+ */
+export declare class DeleteDataLakeOrganizationConfigurationCommand extends $Command<DeleteDataLakeOrganizationConfigurationCommandInput, DeleteDataLakeOrganizationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: DeleteDataLakeOrganizationConfigurationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: DeleteDataLakeOrganizationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataLakeOrganizationConfigurationCommandInput, DeleteDataLakeOrganizationConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}