@aws-sdk/client-securitylake 3.220.0

package/dist-es/models/models_0.js

@@ -0,0 +1,560 @@
+import { SecurityLakeServiceException as __BaseException } from "./SecurityLakeServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export var AccessType;
+(function (AccessType) {
+    AccessType["LAKEFORMATION"] = "LAKEFORMATION";
+    AccessType["S3"] = "S3";
+})(AccessType || (AccessType = {}));
+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 var OcsfEventClass;
+(function (OcsfEventClass) {
+    OcsfEventClass["ACCESS_ACTIVITY"] = "ACCESS_ACTIVITY";
+    OcsfEventClass["ACCOUNT_CHANGE"] = "ACCOUNT_CHANGE";
+    OcsfEventClass["AUTHENTICATION"] = "AUTHENTICATION";
+    OcsfEventClass["AUTHORIZATION"] = "AUTHORIZATION";
+    OcsfEventClass["CLOUD_API"] = "CLOUD_API";
+    OcsfEventClass["CLOUD_STORAGE"] = "CLOUD_STORAGE";
+    OcsfEventClass["CONFIG_STATE"] = "CONFIG_STATE";
+    OcsfEventClass["CONTAINER_LIFECYCLE"] = "CONTAINER_LIFECYCLE";
+    OcsfEventClass["DATABASE_LIFECYCLE"] = "DATABASE_LIFECYCLE";
+    OcsfEventClass["DHCP_ACTIVITY"] = "DHCP_ACTIVITY";
+    OcsfEventClass["DNS_ACTIVITY"] = "DNS_ACTIVITY";
+    OcsfEventClass["ENTITY_MANAGEMENT_AUDIT"] = "ENTITY_MANAGEMENT_AUDIT";
+    OcsfEventClass["FILE_ACTIVITY"] = "FILE_ACTIVITY";
+    OcsfEventClass["FTP_ACTIVITY"] = "FTP_ACTIVITY";
+    OcsfEventClass["HTTP_ACTIVITY"] = "HTTP_ACTIVITY";
+    OcsfEventClass["INVENTORY_INFO"] = "INVENTORY_INFO";
+    OcsfEventClass["KERNEL_ACTIVITY"] = "KERNEL_ACTIVITY";
+    OcsfEventClass["KERNEL_EXTENSION"] = "KERNEL_EXTENSION";
+    OcsfEventClass["MEMORY_ACTIVITY"] = "MEMORY_ACTIVITY";
+    OcsfEventClass["MODULE_ACTIVITY"] = "MODULE_ACTIVITY";
+    OcsfEventClass["NETWORK_ACTIVITY"] = "NETWORK_ACTIVITY";
+    OcsfEventClass["PROCESS_ACTIVITY"] = "PROCESS_ACTIVITY";
+    OcsfEventClass["RDP_ACTIVITY"] = "RDP_ACTIVITY";
+    OcsfEventClass["REGISTRY_KEY_ACTIVITY"] = "REGISTRY_KEY_ACTIVITY";
+    OcsfEventClass["REGISTRY_VALUE_ACTIVITY"] = "REGISTRY_VALUE_ACTIVITY";
+    OcsfEventClass["RESOURCE_ACTIVITY"] = "RESOURCE_ACTIVITY";
+    OcsfEventClass["RFB_ACTIVITY"] = "RFB_ACTIVITY";
+    OcsfEventClass["SCHEDULED_JOB_ACTIVITY"] = "SCHEDULED_JOB_ACTIVITY";
+    OcsfEventClass["SECURITY_FINDING"] = "SECURITY_FINDING";
+    OcsfEventClass["SMB_ACTIVITY"] = "SMB_ACTIVITY";
+    OcsfEventClass["SMTP_ACTIVITY"] = "SMTP_ACTIVITY";
+    OcsfEventClass["SSH_ACTIVITY"] = "SSH_ACTIVITY";
+    OcsfEventClass["VIRTUAL_MACHINE_ACTIVITY"] = "VIRTUAL_MACHINE_ACTIVITY";
+})(OcsfEventClass || (OcsfEventClass = {}));
+export var SourceStatus;
+(function (SourceStatus) {
+    SourceStatus["ACTIVE"] = "ACTIVE";
+    SourceStatus["DEACTIVATED"] = "DEACTIVATED";
+    SourceStatus["PENDING"] = "PENDING";
+})(SourceStatus || (SourceStatus = {}));
+export var Region;
+(function (Region) {
+    Region["AP_NORTHEAST_1"] = "ap-northeast-1";
+    Region["AP_SOUTHEAST_2"] = "ap-southeast-2";
+    Region["EU_CENTRAL_1"] = "eu-central-1";
+    Region["EU_WEST_1"] = "eu-west-1";
+    Region["US_EAST_1"] = "us-east-1";
+    Region["US_EAST_2"] = "us-east-2";
+    Region["US_WEST_2"] = "us-west-2";
+})(Region || (Region = {}));
+export var AwsLogSourceType;
+(function (AwsLogSourceType) {
+    AwsLogSourceType["CLOUD_TRAIL"] = "CLOUD_TRAIL";
+    AwsLogSourceType["ROUTE53"] = "ROUTE53";
+    AwsLogSourceType["SH_FINDINGS"] = "SH_FINDINGS";
+    AwsLogSourceType["VPC_FLOW"] = "VPC_FLOW";
+})(AwsLogSourceType || (AwsLogSourceType = {}));
+export class BucketNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "BucketNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "BucketNotFoundException";
+        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);
+    }
+}
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.resourceId = opts.resourceId;
+        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 var Dimension;
+(function (Dimension) {
+    Dimension["MEMBER"] = "MEMBER";
+    Dimension["REGION"] = "REGION";
+    Dimension["SOURCE_TYPE"] = "SOURCE_TYPE";
+})(Dimension || (Dimension = {}));
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.resourceId = opts.resourceId;
+        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 var ValidationExceptionReason;
+(function (ValidationExceptionReason) {
+    ValidationExceptionReason["CANNOT_PARSE"] = "cannotParse";
+    ValidationExceptionReason["FIELD_VALIDATION_FAILED"] = "fieldValidationFailed";
+    ValidationExceptionReason["OTHER"] = "other";
+    ValidationExceptionReason["UNKNOWN_OPERATION"] = "unknownOperation";
+})(ValidationExceptionReason || (ValidationExceptionReason = {}));
+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 var StorageClass;
+(function (StorageClass) {
+    StorageClass["DEEP_ARCHIVE"] = "DEEP_ARCHIVE";
+    StorageClass["EXPIRE"] = "EXPIRE";
+    StorageClass["GLACIER"] = "GLACIER";
+    StorageClass["GLACIER_IR"] = "GLACIER_IR";
+    StorageClass["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING";
+    StorageClass["ONEZONE_IA"] = "ONEZONE_IA";
+    StorageClass["STANDARD_IA"] = "STANDARD_IA";
+})(StorageClass || (StorageClass = {}));
+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({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        this.$retryable = {
+            throttling: true,
+        };
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.serviceCode = opts.serviceCode;
+        this.quotaCode = opts.quotaCode;
+        this.retryAfterSeconds = opts.retryAfterSeconds;
+    }
+}
+export var SubscriptionProtocolType;
+(function (SubscriptionProtocolType) {
+    SubscriptionProtocolType["APP"] = "APP";
+    SubscriptionProtocolType["EMAIL"] = "EMAIL";
+    SubscriptionProtocolType["EMAIL_JSON"] = "EMAIL_JSON";
+    SubscriptionProtocolType["FIREHOSE"] = "FIREHOSE";
+    SubscriptionProtocolType["HTTP"] = "HTTP";
+    SubscriptionProtocolType["HTTPS"] = "HTTPS";
+    SubscriptionProtocolType["LAMBDA"] = "LAMBDA";
+    SubscriptionProtocolType["SMS"] = "SMS";
+    SubscriptionProtocolType["SQS"] = "SQS";
+})(SubscriptionProtocolType || (SubscriptionProtocolType = {}));
+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 var HttpsMethod;
+(function (HttpsMethod) {
+    HttpsMethod["POST"] = "POST";
+    HttpsMethod["PUT"] = "PUT";
+})(HttpsMethod || (HttpsMethod = {}));
+export var EndpointProtocol;
+(function (EndpointProtocol) {
+    EndpointProtocol["HTTPS"] = "HTTPS";
+    EndpointProtocol["SQS"] = "SQS";
+})(EndpointProtocol || (EndpointProtocol = {}));
+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 var SettingsStatus;
+(function (SettingsStatus) {
+    SettingsStatus["COMPLETED"] = "COMPLETED";
+    SettingsStatus["FAILED"] = "FAILED";
+    SettingsStatus["INITIALIZED"] = "INITIALIZED";
+    SettingsStatus["PENDING"] = "PENDING";
+})(SettingsStatus || (SettingsStatus = {}));
+export var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["ACTIVE"] = "ACTIVE";
+    SubscriptionStatus["DEACTIVATED"] = "DEACTIVATED";
+    SubscriptionStatus["PENDING"] = "PENDING";
+    SubscriptionStatus["READY"] = "READY";
+})(SubscriptionStatus || (SubscriptionStatus = {}));
+export const LogsStatusFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AccountSourcesFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AutoEnableNewRegionConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateAwsLogSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateAwsLogSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidationExceptionFieldFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateCustomLogSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateCustomLogSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RetentionSettingFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LakeConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeAutoEnableRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeAutoEnableResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeDelegatedAdminRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeDelegatedAdminResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SourceTypeFilterSensitiveLog = (obj) => {
+    if (obj.awsSourceType !== undefined)
+        return { awsSourceType: obj.awsSourceType };
+    if (obj.customSourceType !== undefined)
+        return { customSourceType: obj.customSourceType };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateSubscriberRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sourceTypes && { sourceTypes: obj.sourceTypes.map((item) => SourceTypeFilterSensitiveLog(item)) }),
+});
+export const CreateSubscriberResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateSubscriptionNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateSubscriptionNotificationConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteAwsLogSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteAwsLogSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteCustomLogSourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteCustomLogSourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeAutoEnableRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeAutoEnableResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeDelegatedAdminRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeDelegatedAdminResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeExceptionsSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDatalakeExceptionsSubscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSubscriberRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSubscriberResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSubscriptionNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSubscriptionNotificationConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FailuresFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FailuresResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LakeConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeAutoEnableRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeAutoEnableResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeExceptionsExpiryRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeExceptionsExpiryResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeExceptionsSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProtocolAndNotificationEndpointFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeExceptionsSubscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeStatusRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDatalakeStatusResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSubscriberRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SubscriberResourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sourceTypes && { sourceTypes: obj.sourceTypes.map((item) => SourceTypeFilterSensitiveLog(item)) }),
+});
+export const GetSubscriberResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.subscriber && { subscriber: SubscriberResourceFilterSensitiveLog(obj.subscriber) }),
+});
+export const ListDatalakeExceptionsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListDatalakeExceptionsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListLogSourcesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListLogSourcesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSubscribersRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSubscribersResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.subscribers && { subscribers: obj.subscribers.map((item) => SubscriberResourceFilterSensitiveLog(item)) }),
+});
+export const UpdateDatalakeRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDatalakeResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDatalakeExceptionsExpiryRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDatalakeExceptionsExpiryResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDatalakeExceptionsSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDatalakeExceptionsSubscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSubscriberRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.sourceTypes && { sourceTypes: obj.sourceTypes.map((item) => SourceTypeFilterSensitiveLog(item)) }),
+});
+export const UpdateSubscriberResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.subscriber && { subscriber: SubscriberResourceFilterSensitiveLog(obj.subscriber) }),
+});
+export const UpdateSubscriptionNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSubscriptionNotificationConfigurationResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/GetDatalakeStatusPaginator.js

@@ -0,0 +1,32 @@
+import { GetDatalakeStatusCommand, } from "../commands/GetDatalakeStatusCommand";
+import { SecurityLake } from "../SecurityLake";
+import { SecurityLakeClient } from "../SecurityLakeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new GetDatalakeStatusCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.getDatalakeStatus(input, ...args);
+};
+export async function* paginateGetDatalakeStatus(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxAccountResults"] = config.pageSize;
+        if (config.client instanceof SecurityLake) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof SecurityLakeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SecurityLake | SecurityLakeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/Interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist-es/pagination/ListDatalakeExceptionsPaginator.js

@@ -0,0 +1,32 @@
+import { ListDatalakeExceptionsCommand, } from "../commands/ListDatalakeExceptionsCommand";
+import { SecurityLake } from "../SecurityLake";
+import { SecurityLakeClient } from "../SecurityLakeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDatalakeExceptionsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listDatalakeExceptions(input, ...args);
+};
+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;
+        if (config.client instanceof SecurityLake) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof SecurityLakeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SecurityLake | SecurityLakeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListLogSourcesPaginator.js

@@ -0,0 +1,32 @@
+import { ListLogSourcesCommand, } from "../commands/ListLogSourcesCommand";
+import { SecurityLake } from "../SecurityLake";
+import { SecurityLakeClient } from "../SecurityLakeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListLogSourcesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listLogSources(input, ...args);
+};
+export async function* paginateListLogSources(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof SecurityLake) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof SecurityLakeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SecurityLake | SecurityLakeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSubscribersPaginator.js

@@ -0,0 +1,32 @@
+import { ListSubscribersCommand, } from "../commands/ListSubscribersCommand";
+import { SecurityLake } from "../SecurityLake";
+import { SecurityLakeClient } from "../SecurityLakeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSubscribersCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSubscribers(input, ...args);
+};
+export async function* paginateListSubscribers(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof SecurityLake) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof SecurityLakeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected SecurityLake | SecurityLakeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}