@aws-sdk/client-securitylake 3.338.0 → 3.342.0

package/dist-es/commands/{GetDatalakeCommand.js → ListDataLakesCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_GetDatalakeCommand, se_GetDatalakeCommand } from "../protocols/Aws_restJson1";
+import { de_ListDataLakesCommand, se_ListDataLakesCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class GetDatalakeCommand extends $Command {
+export class ListDataLakesCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class GetDatalakeCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, GetDatalakeCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDataLakesCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "GetDatalakeCommand";
+        const commandName = "ListDataLakesCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class GetDatalakeCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_GetDatalakeCommand(input, context);
+        return se_ListDataLakesCommand(input, context);
     }
     deserialize(output, context) {
-        return de_GetDatalakeCommand(output, context);
+        return de_ListDataLakesCommand(output, context);
     }
 }

package/dist-es/commands/RegisterDataLakeDelegatedAdministratorCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { de_RegisterDataLakeDelegatedAdministratorCommand, se_RegisterDataLakeDelegatedAdministratorCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class RegisterDataLakeDelegatedAdministratorCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, RegisterDataLakeDelegatedAdministratorCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "SecurityLakeClient";
+        const commandName = "RegisterDataLakeDelegatedAdministratorCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_RegisterDataLakeDelegatedAdministratorCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_RegisterDataLakeDelegatedAdministratorCommand(output, context);
+    }
+}

package/dist-es/commands/{DeleteDatalakeCommand.js → UpdateDataLakeCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_DeleteDatalakeCommand, se_DeleteDatalakeCommand } from "../protocols/Aws_restJson1";
+import { de_UpdateDataLakeCommand, se_UpdateDataLakeCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class DeleteDatalakeCommand extends $Command {
+export class UpdateDataLakeCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class DeleteDatalakeCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDatalakeCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateDataLakeCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "DeleteDatalakeCommand";
+        const commandName = "UpdateDataLakeCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class DeleteDatalakeCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_DeleteDatalakeCommand(input, context);
+        return se_UpdateDataLakeCommand(input, context);
     }
     deserialize(output, context) {
-        return de_DeleteDatalakeCommand(output, context);
+        return de_UpdateDataLakeCommand(output, context);
     }
 }

package/dist-es/commands/{CreateDatalakeAutoEnableCommand.js → UpdateDataLakeExceptionSubscriptionCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_CreateDatalakeAutoEnableCommand, se_CreateDatalakeAutoEnableCommand } from "../protocols/Aws_restJson1";
+import { de_UpdateDataLakeExceptionSubscriptionCommand, se_UpdateDataLakeExceptionSubscriptionCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class CreateDatalakeAutoEnableCommand extends $Command {
+export class UpdateDataLakeExceptionSubscriptionCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class CreateDatalakeAutoEnableCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDatalakeAutoEnableCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateDataLakeExceptionSubscriptionCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "CreateDatalakeAutoEnableCommand";
+        const commandName = "UpdateDataLakeExceptionSubscriptionCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class CreateDatalakeAutoEnableCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_CreateDatalakeAutoEnableCommand(input, context);
+        return se_UpdateDataLakeExceptionSubscriptionCommand(input, context);
     }
     deserialize(output, context) {
-        return de_CreateDatalakeAutoEnableCommand(output, context);
+        return de_UpdateDataLakeExceptionSubscriptionCommand(output, context);
     }
 }

package/dist-es/commands/{GetDatalakeExceptionsExpiryCommand.js → UpdateSubscriberNotificationCommand.js}

@@ -1,9 +1,9 @@
 import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { de_GetDatalakeExceptionsExpiryCommand, se_GetDatalakeExceptionsExpiryCommand, } from "../protocols/Aws_restJson1";
+import { de_UpdateSubscriberNotificationCommand, se_UpdateSubscriberNotificationCommand, } from "../protocols/Aws_restJson1";
 export { $Command };
-export class GetDatalakeExceptionsExpiryCommand extends $Command {
+export class UpdateSubscriberNotificationCommand extends $Command {
     static getEndpointParameterInstructions() {
         return {
             UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
@@ -18,11 +18,11 @@ export class GetDatalakeExceptionsExpiryCommand extends $Command {
     }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, GetDatalakeExceptionsExpiryCommand.getEndpointParameterInstructions()));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateSubscriberNotificationCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "SecurityLakeClient";
-        const commandName = "GetDatalakeExceptionsExpiryCommand";
+        const commandName = "UpdateSubscriberNotificationCommand";
         const handlerExecutionContext = {
             logger,
             clientName,
@@ -34,9 +34,9 @@ export class GetDatalakeExceptionsExpiryCommand extends $Command {
         return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
     }
     serialize(input, context) {
-        return se_GetDatalakeExceptionsExpiryCommand(input, context);
+        return se_UpdateSubscriberNotificationCommand(input, context);
     }
     deserialize(output, context) {
-        return de_GetDatalakeExceptionsExpiryCommand(output, context);
+        return de_UpdateSubscriberNotificationCommand(output, context);
     }
 }

package/dist-es/commands/index.js

@@ -1,30 +1,28 @@
 export * from "./CreateAwsLogSourceCommand";
 export * from "./CreateCustomLogSourceCommand";
-export * from "./CreateDatalakeAutoEnableCommand";
-export * from "./CreateDatalakeCommand";
-export * from "./CreateDatalakeDelegatedAdminCommand";
-export * from "./CreateDatalakeExceptionsSubscriptionCommand";
+export * from "./CreateDataLakeCommand";
+export * from "./CreateDataLakeExceptionSubscriptionCommand";
+export * from "./CreateDataLakeOrganizationConfigurationCommand";
 export * from "./CreateSubscriberCommand";
-export * from "./CreateSubscriptionNotificationConfigurationCommand";
+export * from "./CreateSubscriberNotificationCommand";
 export * from "./DeleteAwsLogSourceCommand";
 export * from "./DeleteCustomLogSourceCommand";
-export * from "./DeleteDatalakeAutoEnableCommand";
-export * from "./DeleteDatalakeCommand";
-export * from "./DeleteDatalakeDelegatedAdminCommand";
-export * from "./DeleteDatalakeExceptionsSubscriptionCommand";
+export * from "./DeleteDataLakeCommand";
+export * from "./DeleteDataLakeExceptionSubscriptionCommand";
+export * from "./DeleteDataLakeOrganizationConfigurationCommand";
 export * from "./DeleteSubscriberCommand";
-export * from "./DeleteSubscriptionNotificationConfigurationCommand";
-export * from "./GetDatalakeAutoEnableCommand";
-export * from "./GetDatalakeCommand";
-export * from "./GetDatalakeExceptionsExpiryCommand";
-export * from "./GetDatalakeExceptionsSubscriptionCommand";
-export * from "./GetDatalakeStatusCommand";
+export * from "./DeleteSubscriberNotificationCommand";
+export * from "./DeregisterDataLakeDelegatedAdministratorCommand";
+export * from "./GetDataLakeExceptionSubscriptionCommand";
+export * from "./GetDataLakeOrganizationConfigurationCommand";
+export * from "./GetDataLakeSourcesCommand";
 export * from "./GetSubscriberCommand";
-export * from "./ListDatalakeExceptionsCommand";
+export * from "./ListDataLakeExceptionsCommand";
+export * from "./ListDataLakesCommand";
 export * from "./ListLogSourcesCommand";
 export * from "./ListSubscribersCommand";
-export * from "./UpdateDatalakeCommand";
-export * from "./UpdateDatalakeExceptionsExpiryCommand";
-export * from "./UpdateDatalakeExceptionsSubscriptionCommand";
+export * from "./RegisterDataLakeDelegatedAdministratorCommand";
+export * from "./UpdateDataLakeCommand";
+export * from "./UpdateDataLakeExceptionSubscriptionCommand";
 export * from "./UpdateSubscriberCommand";
-export * from "./UpdateSubscriptionNotificationConfigurationCommand";
+export * from "./UpdateSubscriberNotificationCommand";

package/dist-es/models/models_0.js

@@ -16,96 +16,24 @@ export const AccessType = {
     LAKEFORMATION: "LAKEFORMATION",
     S3: "S3",
 };
-export class AccountNotFoundException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "AccountNotFoundException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "AccountNotFoundException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, AccountNotFoundException.prototype);
-    }
-}
-export const OcsfEventClass = {
-    ACCESS_ACTIVITY: "ACCESS_ACTIVITY",
-    ACCOUNT_CHANGE: "ACCOUNT_CHANGE",
-    AUTHENTICATION: "AUTHENTICATION",
-    AUTHORIZATION: "AUTHORIZATION",
-    CLOUD_API: "CLOUD_API",
-    CLOUD_STORAGE: "CLOUD_STORAGE",
-    CONFIG_STATE: "CONFIG_STATE",
-    CONTAINER_LIFECYCLE: "CONTAINER_LIFECYCLE",
-    DATABASE_LIFECYCLE: "DATABASE_LIFECYCLE",
-    DHCP_ACTIVITY: "DHCP_ACTIVITY",
-    DNS_ACTIVITY: "DNS_ACTIVITY",
-    ENTITY_MANAGEMENT_AUDIT: "ENTITY_MANAGEMENT_AUDIT",
-    FILE_ACTIVITY: "FILE_ACTIVITY",
-    FTP_ACTIVITY: "FTP_ACTIVITY",
-    HTTP_ACTIVITY: "HTTP_ACTIVITY",
-    INVENTORY_INFO: "INVENTORY_INFO",
-    KERNEL_ACTIVITY: "KERNEL_ACTIVITY",
-    KERNEL_EXTENSION: "KERNEL_EXTENSION",
-    MEMORY_ACTIVITY: "MEMORY_ACTIVITY",
-    MODULE_ACTIVITY: "MODULE_ACTIVITY",
-    NETWORK_ACTIVITY: "NETWORK_ACTIVITY",
-    PROCESS_ACTIVITY: "PROCESS_ACTIVITY",
-    RDP_ACTIVITY: "RDP_ACTIVITY",
-    REGISTRY_KEY_ACTIVITY: "REGISTRY_KEY_ACTIVITY",
-    REGISTRY_VALUE_ACTIVITY: "REGISTRY_VALUE_ACTIVITY",
-    RESOURCE_ACTIVITY: "RESOURCE_ACTIVITY",
-    RFB_ACTIVITY: "RFB_ACTIVITY",
-    SCHEDULED_JOB_ACTIVITY: "SCHEDULED_JOB_ACTIVITY",
-    SECURITY_FINDING: "SECURITY_FINDING",
-    SMB_ACTIVITY: "SMB_ACTIVITY",
-    SMTP_ACTIVITY: "SMTP_ACTIVITY",
-    SSH_ACTIVITY: "SSH_ACTIVITY",
-    VIRTUAL_MACHINE_ACTIVITY: "VIRTUAL_MACHINE_ACTIVITY",
-};
-export const SourceStatus = {
-    ACTIVE: "ACTIVE",
-    DEACTIVATED: "DEACTIVATED",
-    PENDING: "PENDING",
-};
-export const Region = {
-    AP_NORTHEAST_1: "ap-northeast-1",
-    AP_SOUTHEAST_2: "ap-southeast-2",
-    EU_CENTRAL_1: "eu-central-1",
-    EU_WEST_1: "eu-west-1",
-    US_EAST_1: "us-east-1",
-    US_EAST_2: "us-east-2",
-    US_WEST_2: "us-west-2",
-};
-export const AwsLogSourceType = {
-    CLOUD_TRAIL: "CLOUD_TRAIL",
+export const AwsLogSourceName = {
+    CLOUD_TRAIL_MGMT: "CLOUD_TRAIL_MGMT",
+    LAMBDA_EXECUTION: "LAMBDA_EXECUTION",
     ROUTE53: "ROUTE53",
+    S3_DATA: "S3_DATA",
     SH_FINDINGS: "SH_FINDINGS",
     VPC_FLOW: "VPC_FLOW",
 };
-export class BucketNotFoundException extends __BaseException {
+export class BadRequestException extends __BaseException {
     constructor(opts) {
         super({
-            name: "BucketNotFoundException",
+            name: "BadRequestException",
             $fault: "client",
             ...opts,
         });
-        this.name = "BucketNotFoundException";
+        this.name = "BadRequestException";
         this.$fault = "client";
-        Object.setPrototypeOf(this, BucketNotFoundException.prototype);
-    }
-}
-export class ConcurrentModificationException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ConcurrentModificationException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ConcurrentModificationException";
-        this.$fault = "client";
-        this.$retryable = {};
-        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+        Object.setPrototypeOf(this, BadRequestException.prototype);
     }
 }
 export class ConflictException extends __BaseException {
@@ -118,39 +46,10 @@ export class ConflictException extends __BaseException {
         this.name = "ConflictException";
         this.$fault = "client";
         Object.setPrototypeOf(this, ConflictException.prototype);
-        this.resourceId = opts.resourceId;
+        this.resourceName = opts.resourceName;
         this.resourceType = opts.resourceType;
     }
 }
-export class ConflictSourceNamesException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ConflictSourceNamesException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ConflictSourceNamesException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ConflictSourceNamesException.prototype);
-    }
-}
-export class ConflictSubscriptionException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ConflictSubscriptionException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ConflictSubscriptionException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ConflictSubscriptionException.prototype);
-    }
-}
-export const Dimension = {
-    MEMBER: "MEMBER",
-    REGION: "REGION",
-    SOURCE_TYPE: "SOURCE_TYPE",
-};
 export class InternalServerException extends __BaseException {
     constructor(opts) {
         super({
@@ -162,7 +61,6 @@ export class InternalServerException extends __BaseException {
         this.$fault = "server";
         this.$retryable = {};
         Object.setPrototypeOf(this, InternalServerException.prototype);
-        this.retryAfterSeconds = opts.retryAfterSeconds;
     }
 }
 export class ResourceNotFoundException extends __BaseException {
@@ -175,67 +73,10 @@ export class ResourceNotFoundException extends __BaseException {
         this.name = "ResourceNotFoundException";
         this.$fault = "client";
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
-        this.resourceId = opts.resourceId;
+        this.resourceName = opts.resourceName;
         this.resourceType = opts.resourceType;
     }
 }
-export class S3Exception extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "S3Exception",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "S3Exception";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, S3Exception.prototype);
-    }
-}
-export const ValidationExceptionReason = {
-    CANNOT_PARSE: "cannotParse",
-    FIELD_VALIDATION_FAILED: "fieldValidationFailed",
-    OTHER: "other",
-    UNKNOWN_OPERATION: "unknownOperation",
-};
-export class ValidationException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ValidationException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ValidationException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ValidationException.prototype);
-        this.reason = opts.reason;
-        this.fieldList = opts.fieldList;
-    }
-}
-export const StorageClass = {
-    DEEP_ARCHIVE: "DEEP_ARCHIVE",
-    EXPIRE: "EXPIRE",
-    GLACIER: "GLACIER",
-    GLACIER_IR: "GLACIER_IR",
-    INTELLIGENT_TIERING: "INTELLIGENT_TIERING",
-    ONEZONE_IA: "ONEZONE_IA",
-    STANDARD_IA: "STANDARD_IA",
-};
-export class ServiceQuotaExceededException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "ServiceQuotaExceededException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "ServiceQuotaExceededException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
-        this.resourceId = opts.resourceId;
-        this.resourceType = opts.resourceType;
-        this.serviceCode = opts.serviceCode;
-        this.quotaCode = opts.quotaCode;
-    }
-}
 export class ThrottlingException extends __BaseException {
     constructor(opts) {
         super({
@@ -254,68 +95,44 @@ export class ThrottlingException extends __BaseException {
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
 }
-export const SubscriptionProtocolType = {
-    APP: "APP",
-    EMAIL: "EMAIL",
-    EMAIL_JSON: "EMAIL_JSON",
-    FIREHOSE: "FIREHOSE",
-    HTTP: "HTTP",
-    HTTPS: "HTTPS",
-    LAMBDA: "LAMBDA",
-    SMS: "SMS",
-    SQS: "SQS",
-};
-export var SourceType;
-(function (SourceType) {
-    SourceType.visit = (value, visitor) => {
-        if (value.awsSourceType !== undefined)
-            return visitor.awsSourceType(value.awsSourceType);
-        if (value.customSourceType !== undefined)
-            return visitor.customSourceType(value.customSourceType);
-        return visitor._(value.$unknown[0], value.$unknown[1]);
-    };
-})(SourceType || (SourceType = {}));
-export class InvalidInputException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "InvalidInputException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "InvalidInputException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, InvalidInputException.prototype);
-    }
-}
-export const HttpsMethod = {
-    POST: "POST",
-    PUT: "PUT",
-};
-export const EndpointProtocol = {
-    HTTPS: "HTTPS",
-    SQS: "SQS",
-};
-export class EventBridgeException extends __BaseException {
-    constructor(opts) {
-        super({
-            name: "EventBridgeException",
-            $fault: "client",
-            ...opts,
-        });
-        this.name = "EventBridgeException";
-        this.$fault = "client";
-        Object.setPrototypeOf(this, EventBridgeException.prototype);
-    }
-}
-export const SettingsStatus = {
+export const DataLakeStatus = {
     COMPLETED: "COMPLETED",
     FAILED: "FAILED",
     INITIALIZED: "INITIALIZED",
     PENDING: "PENDING",
 };
-export const SubscriptionStatus = {
+export var LogSourceResource;
+(function (LogSourceResource) {
+    LogSourceResource.visit = (value, visitor) => {
+        if (value.awsLogSource !== undefined)
+            return visitor.awsLogSource(value.awsLogSource);
+        if (value.customLogSource !== undefined)
+            return visitor.customLogSource(value.customLogSource);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(LogSourceResource || (LogSourceResource = {}));
+export const SubscriberStatus = {
     ACTIVE: "ACTIVE",
     DEACTIVATED: "DEACTIVATED",
     PENDING: "PENDING",
     READY: "READY",
 };
+export const HttpMethod = {
+    POST: "POST",
+    PUT: "PUT",
+};
+export var NotificationConfiguration;
+(function (NotificationConfiguration) {
+    NotificationConfiguration.visit = (value, visitor) => {
+        if (value.sqsNotificationConfiguration !== undefined)
+            return visitor.sqsNotificationConfiguration(value.sqsNotificationConfiguration);
+        if (value.httpsNotificationConfiguration !== undefined)
+            return visitor.httpsNotificationConfiguration(value.httpsNotificationConfiguration);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(NotificationConfiguration || (NotificationConfiguration = {}));
+export const SourceCollectionStatus = {
+    COLLECTING: "COLLECTING",
+    MISCONFIGURED: "MISCONFIGURED",
+    NOT_COLLECTING: "NOT_COLLECTING",
+};

package/dist-es/pagination/{GetDatalakeStatusPaginator.js → GetDataLakeSourcesPaginator.js}

@@ -1,15 +1,15 @@
-import { GetDatalakeStatusCommand, } from "../commands/GetDatalakeStatusCommand";
+import { GetDataLakeSourcesCommand, } from "../commands/GetDataLakeSourcesCommand";
 import { SecurityLakeClient } from "../SecurityLakeClient";
 const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new GetDatalakeStatusCommand(input), ...args);
+    return await client.send(new GetDataLakeSourcesCommand(input), ...args);
 };
-export async function* paginateGetDatalakeStatus(config, input, ...additionalArguments) {
+export async function* paginateGetDataLakeSources(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        input["maxAccountResults"] = config.pageSize;
+        input["maxResults"] = config.pageSize;
         if (config.client instanceof SecurityLakeClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }

package/dist-es/pagination/{ListDatalakeExceptionsPaginator.js → ListDataLakeExceptionsPaginator.js}

@@ -1,15 +1,15 @@
-import { ListDatalakeExceptionsCommand, } from "../commands/ListDatalakeExceptionsCommand";
+import { ListDataLakeExceptionsCommand, } from "../commands/ListDataLakeExceptionsCommand";
 import { SecurityLakeClient } from "../SecurityLakeClient";
 const makePagedClientRequest = async (client, input, ...args) => {
-    return await client.send(new ListDatalakeExceptionsCommand(input), ...args);
+    return await client.send(new ListDataLakeExceptionsCommand(input), ...args);
 };
-export async function* paginateListDatalakeExceptions(config, input, ...additionalArguments) {
+export async function* paginateListDataLakeExceptions(config, input, ...additionalArguments) {
     let token = config.startingToken || undefined;
     let hasNext = true;
     let page;
     while (hasNext) {
         input.nextToken = token;
-        input["maxFailures"] = config.pageSize;
+        input["maxResults"] = config.pageSize;
         if (config.client instanceof SecurityLakeClient) {
             page = await makePagedClientRequest(config.client, input, ...additionalArguments);
         }

package/dist-es/pagination/index.js

@@ -1,5 +1,5 @@
-export * from "./GetDatalakeStatusPaginator";
+export * from "./GetDataLakeSourcesPaginator";
 export * from "./Interfaces";
-export * from "./ListDatalakeExceptionsPaginator";
+export * from "./ListDataLakeExceptionsPaginator";
 export * from "./ListLogSourcesPaginator";
 export * from "./ListSubscribersPaginator";