@aws-sdk/client-securitylake 3.338.0 → 3.342.0

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

@@ -28,7 +28,8 @@ export interface CreateCustomLogSourceCommandOutput extends CreateCustomLogSourc
  *          third-party custom sources. After creating the appropriate IAM role to
  *          invoke Glue crawler, use this API to add a custom source name in Security Lake. This
  *          operation creates a partition in the Amazon S3 bucket for Security Lake as the target
- *          location for log files from the custom source in addition to an associated Glue table and an Glue crawler.</p>
+ *          location for log files from the custom source. In addition, this operation also creates an
+ *          associated Glue table and an Glue crawler.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -36,19 +37,37 @@ export interface CreateCustomLogSourceCommandOutput extends CreateCustomLogSourc
  * // const { SecurityLakeClient, CreateCustomLogSourceCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
  * const client = new SecurityLakeClient(config);
  * const input = { // CreateCustomLogSourceRequest
- *   customSourceName: "STRING_VALUE", // required
- *   eventClass: "STRING_VALUE", // required
- *   glueInvocationRoleArn: "STRING_VALUE", // required
- *   logProviderAccountId: "STRING_VALUE", // required
+ *   sourceName: "STRING_VALUE", // required
+ *   sourceVersion: "STRING_VALUE",
+ *   eventClasses: [ // OcsfEventClassList
+ *     "STRING_VALUE",
+ *   ],
+ *   configuration: { // CustomLogSourceConfiguration
+ *     crawlerConfiguration: { // CustomLogSourceCrawlerConfiguration
+ *       roleArn: "STRING_VALUE", // required
+ *     },
+ *     providerIdentity: { // AwsIdentity
+ *       principal: "STRING_VALUE", // required
+ *       externalId: "STRING_VALUE", // required
+ *     },
+ *   },
  * };
  * const command = new CreateCustomLogSourceCommand(input);
  * const response = await client.send(command);
  * // { // CreateCustomLogSourceResponse
- * //   customDataLocation: "STRING_VALUE", // required
- * //   glueCrawlerName: "STRING_VALUE", // required
- * //   glueTableName: "STRING_VALUE", // required
- * //   glueDatabaseName: "STRING_VALUE", // required
- * //   logProviderAccessRoleArn: "STRING_VALUE", // required
+ * //   source: { // CustomLogSourceResource
+ * //     sourceName: "STRING_VALUE",
+ * //     sourceVersion: "STRING_VALUE",
+ * //     provider: { // CustomLogSourceProvider
+ * //       roleArn: "STRING_VALUE",
+ * //       location: "STRING_VALUE",
+ * //     },
+ * //     attributes: { // CustomLogSourceAttributes
+ * //       crawlerArn: "STRING_VALUE",
+ * //       databaseArn: "STRING_VALUE",
+ * //       tableArn: "STRING_VALUE",
+ * //     },
+ * //   },
  * // };
  *
  * ```
@@ -65,27 +84,24 @@ export interface CreateCustomLogSourceCommandOutput extends CreateCustomLogSourc
  *          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/CreateDataLakeCommand.d.ts

@@ -0,0 +1,172 @@
+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. By default, the <code>CreateDataLake</code> Security Lake in all
+ *          Regions. To specify particular Regions, 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
+ *   configurations: [ // DataLakeConfigurationList // required
+ *     { // DataLakeConfiguration
+ *       region: "STRING_VALUE", // required
+ *       encryptionConfiguration: { // DataLakeEncryptionConfiguration
+ *         kmsKeyId: "STRING_VALUE",
+ *       },
+ *       lifecycleConfiguration: { // DataLakeLifecycleConfiguration
+ *         expiration: { // DataLakeLifecycleExpiration
+ *           days: Number("int"),
+ *         },
+ *         transitions: [ // DataLakeLifecycleTransitionList
+ *           { // DataLakeLifecycleTransition
+ *             storageClass: "STRING_VALUE",
+ *             days: Number("int"),
+ *           },
+ *         ],
+ *       },
+ *       replicationConfiguration: { // DataLakeReplicationConfiguration
+ *         regions: [ // RegionList
+ *           "STRING_VALUE",
+ *         ],
+ *         roleArn: "STRING_VALUE",
+ *       },
+ *     },
+ *   ],
+ *   metaStoreManagerRoleArn: "STRING_VALUE", // required
+ * };
+ * const command = new CreateDataLakeCommand(input);
+ * const response = await client.send(command);
+ * // { // CreateDataLakeResponse
+ * //   dataLakes: [ // DataLakeResourceList
+ * //     { // DataLakeResource
+ * //       dataLakeArn: "STRING_VALUE", // required
+ * //       region: "STRING_VALUE", // required
+ * //       s3BucketArn: "STRING_VALUE",
+ * //       encryptionConfiguration: { // DataLakeEncryptionConfiguration
+ * //         kmsKeyId: "STRING_VALUE",
+ * //       },
+ * //       lifecycleConfiguration: { // DataLakeLifecycleConfiguration
+ * //         expiration: { // DataLakeLifecycleExpiration
+ * //           days: Number("int"),
+ * //         },
+ * //         transitions: [ // DataLakeLifecycleTransitionList
+ * //           { // DataLakeLifecycleTransition
+ * //             storageClass: "STRING_VALUE",
+ * //             days: Number("int"),
+ * //           },
+ * //         ],
+ * //       },
+ * //       replicationConfiguration: { // DataLakeReplicationConfiguration
+ * //         regions: [ // RegionList
+ * //           "STRING_VALUE",
+ * //         ],
+ * //         roleArn: "STRING_VALUE",
+ * //       },
+ * //       createStatus: "INITIALIZED" || "PENDING" || "COMPLETED" || "FAILED",
+ * //       updateStatus: { // DataLakeUpdateStatus
+ * //         requestId: "STRING_VALUE",
+ * //         status: "INITIALIZED" || "PENDING" || "COMPLETED" || "FAILED",
+ * //         exception: { // DataLakeUpdateException
+ * //           reason: "STRING_VALUE",
+ * //           code: "STRING_VALUE",
+ * //         },
+ * //       },
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @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 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 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/CreateDataLakeExceptionSubscriptionCommand.d.ts

@@ -0,0 +1,99 @@
+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 { CreateDataLakeExceptionSubscriptionRequest, CreateDataLakeExceptionSubscriptionResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link CreateDataLakeExceptionSubscriptionCommand}.
+ */
+export interface CreateDataLakeExceptionSubscriptionCommandInput extends CreateDataLakeExceptionSubscriptionRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CreateDataLakeExceptionSubscriptionCommand}.
+ */
+export interface CreateDataLakeExceptionSubscriptionCommandOutput extends CreateDataLakeExceptionSubscriptionResponse, __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, CreateDataLakeExceptionSubscriptionCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDataLakeExceptionSubscriptionCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const input = { // CreateDataLakeExceptionSubscriptionRequest
+ *   subscriptionProtocol: "STRING_VALUE", // required
+ *   notificationEndpoint: "STRING_VALUE", // required
+ *   exceptionTimeToLive: Number("long"),
+ * };
+ * const command = new CreateDataLakeExceptionSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param CreateDataLakeExceptionSubscriptionCommandInput - {@link CreateDataLakeExceptionSubscriptionCommandInput}
+ * @returns {@link CreateDataLakeExceptionSubscriptionCommandOutput}
+ * @see {@link CreateDataLakeExceptionSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link CreateDataLakeExceptionSubscriptionCommandOutput} 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 CreateDataLakeExceptionSubscriptionCommand extends $Command<CreateDataLakeExceptionSubscriptionCommandInput, CreateDataLakeExceptionSubscriptionCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDataLakeExceptionSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: CreateDataLakeExceptionSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataLakeExceptionSubscriptionCommandInput, CreateDataLakeExceptionSubscriptionCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -0,0 +1,108 @@
+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 { CreateDataLakeOrganizationConfigurationRequest, CreateDataLakeOrganizationConfigurationResponse } from "../models/models_0";
+import { SecurityLakeClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecurityLakeClient";
+/**
+ * @public
+ */
+export { __MetadataBearer, $Command };
+/**
+ * @public
+ *
+ * The input for {@link CreateDataLakeOrganizationConfigurationCommand}.
+ */
+export interface CreateDataLakeOrganizationConfigurationCommandInput extends CreateDataLakeOrganizationConfigurationRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link CreateDataLakeOrganizationConfigurationCommand}.
+ */
+export interface CreateDataLakeOrganizationConfigurationCommandOutput extends CreateDataLakeOrganizationConfigurationResponse, __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, CreateDataLakeOrganizationConfigurationCommand } from "@aws-sdk/client-securitylake"; // ES Modules import
+ * // const { SecurityLakeClient, CreateDataLakeOrganizationConfigurationCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
+ * const client = new SecurityLakeClient(config);
+ * const input = { // CreateDataLakeOrganizationConfigurationRequest
+ *   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 CreateDataLakeOrganizationConfigurationCommand(input);
+ * const response = await client.send(command);
+ * // {};
+ *
+ * ```
+ *
+ * @param CreateDataLakeOrganizationConfigurationCommandInput - {@link CreateDataLakeOrganizationConfigurationCommandInput}
+ * @returns {@link CreateDataLakeOrganizationConfigurationCommandOutput}
+ * @see {@link CreateDataLakeOrganizationConfigurationCommandInput} for command's `input` shape.
+ * @see {@link CreateDataLakeOrganizationConfigurationCommandOutput} 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 CreateDataLakeOrganizationConfigurationCommand extends $Command<CreateDataLakeOrganizationConfigurationCommandInput, CreateDataLakeOrganizationConfigurationCommandOutput, SecurityLakeClientResolvedConfig> {
+    readonly input: CreateDataLakeOrganizationConfigurationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
+    constructor(input: CreateDataLakeOrganizationConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecurityLakeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataLakeOrganizationConfigurationCommandInput, CreateDataLakeOrganizationConfigurationCommandOutput>;
+    /**
+     * @internal
+     */
+    private serialize;
+    /**
+     * @internal
+     */
+    private deserialize;
+}

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

@@ -32,29 +32,82 @@ export interface CreateSubscriberCommandOutput extends CreateSubscriberResponse,
  * // const { SecurityLakeClient, CreateSubscriberCommand } = require("@aws-sdk/client-securitylake"); // CommonJS import
  * const client = new SecurityLakeClient(config);
  * const input = { // CreateSubscriberRequest
- *   sourceTypes: [ // SourceTypeList // required
- *     { // SourceType Union: only one key present
- *       awsSourceType: "STRING_VALUE",
- *       customSourceType: "STRING_VALUE",
+ *   subscriberIdentity: { // AwsIdentity
+ *     principal: "STRING_VALUE", // required
+ *     externalId: "STRING_VALUE", // required
+ *   },
+ *   subscriberName: "STRING_VALUE", // required
+ *   subscriberDescription: "STRING_VALUE",
+ *   sources: [ // LogSourceResourceList // required
+ *     { // LogSourceResource Union: only one key present
+ *       awsLogSource: { // AwsLogSourceResource
+ *         sourceName: "ROUTE53" || "VPC_FLOW" || "SH_FINDINGS" || "CLOUD_TRAIL_MGMT" || "LAMBDA_EXECUTION" || "S3_DATA",
+ *         sourceVersion: "STRING_VALUE",
+ *       },
+ *       customLogSource: { // CustomLogSourceResource
+ *         sourceName: "STRING_VALUE",
+ *         sourceVersion: "STRING_VALUE",
+ *         provider: { // CustomLogSourceProvider
+ *           roleArn: "STRING_VALUE",
+ *           location: "STRING_VALUE",
+ *         },
+ *         attributes: { // CustomLogSourceAttributes
+ *           crawlerArn: "STRING_VALUE",
+ *           databaseArn: "STRING_VALUE",
+ *           tableArn: "STRING_VALUE",
+ *         },
+ *       },
  *     },
  *   ],
- *   accountId: "STRING_VALUE", // required
- *   externalId: "STRING_VALUE", // required
  *   accessTypes: [ // AccessTypeList
- *     "STRING_VALUE",
+ *     "LAKEFORMATION" || "S3",
  *   ],
- *   subscriberName: "STRING_VALUE", // required
- *   subscriberDescription: "STRING_VALUE",
  * };
  * const command = new CreateSubscriberCommand(input);
  * const response = await client.send(command);
  * // { // CreateSubscriberResponse
- * //   subscriptionId: "STRING_VALUE", // required
- * //   roleArn: "STRING_VALUE",
- * //   snsArn: "STRING_VALUE",
- * //   s3BucketArn: "STRING_VALUE",
- * //   resourceShareArn: "STRING_VALUE",
- * //   resourceShareName: "STRING_VALUE",
+ * //   subscriber: { // SubscriberResource
+ * //     subscriberId: "STRING_VALUE", // required
+ * //     subscriberArn: "STRING_VALUE", // required
+ * //     subscriberIdentity: { // AwsIdentity
+ * //       principal: "STRING_VALUE", // required
+ * //       externalId: "STRING_VALUE", // required
+ * //     },
+ * //     subscriberName: "STRING_VALUE", // required
+ * //     subscriberDescription: "STRING_VALUE",
+ * //     sources: [ // LogSourceResourceList // required
+ * //       { // LogSourceResource Union: only one key present
+ * //         awsLogSource: { // AwsLogSourceResource
+ * //           sourceName: "ROUTE53" || "VPC_FLOW" || "SH_FINDINGS" || "CLOUD_TRAIL_MGMT" || "LAMBDA_EXECUTION" || "S3_DATA",
+ * //           sourceVersion: "STRING_VALUE",
+ * //         },
+ * //         customLogSource: { // CustomLogSourceResource
+ * //           sourceName: "STRING_VALUE",
+ * //           sourceVersion: "STRING_VALUE",
+ * //           provider: { // CustomLogSourceProvider
+ * //             roleArn: "STRING_VALUE",
+ * //             location: "STRING_VALUE",
+ * //           },
+ * //           attributes: { // CustomLogSourceAttributes
+ * //             crawlerArn: "STRING_VALUE",
+ * //             databaseArn: "STRING_VALUE",
+ * //             tableArn: "STRING_VALUE",
+ * //           },
+ * //         },
+ * //       },
+ * //     ],
+ * //     accessTypes: [ // AccessTypeList
+ * //       "LAKEFORMATION" || "S3",
+ * //     ],
+ * //     roleArn: "STRING_VALUE",
+ * //     s3BucketArn: "STRING_VALUE",
+ * //     subscriberEndpoint: "STRING_VALUE",
+ * //     subscriberStatus: "ACTIVE" || "DEACTIVATED" || "PENDING" || "READY",
+ * //     resourceShareArn: "STRING_VALUE",
+ * //     resourceShareName: "STRING_VALUE",
+ * //     createdAt: new Date("TIMESTAMP"),
+ * //     updatedAt: new Date("TIMESTAMP"),
+ * //   },
  * // };
  *
  * ```
@@ -71,31 +124,24 @@ export interface CreateSubscriberCommandOutput extends CreateSubscriberResponse,
  *          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 BucketNotFoundException} (client fault)
- *  <p>Amazon Security Lake  generally returns 404 errors if the requested object is missing from the
- *          bucket.</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 ConflictSubscriptionException} (client fault)
- *  <p>A conflicting subscription exception operation is in progress. </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 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>
+ *          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>