@aws-sdk/client-securitylake 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class SecurityLakeClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,14 +110,14 @@ class SecurityLakeClient extends smithyClient.Client {
     }
 }
 
-class SecurityLakeServiceException extends smithyClient.ServiceException {
+let SecurityLakeServiceException$1 = class SecurityLakeServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SecurityLakeServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends SecurityLakeServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends SecurityLakeServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     errorCode;
@@ -130,7 +130,7 @@ class AccessDeniedException extends SecurityLakeServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.errorCode = opts.errorCode;
     }
-}
+};
 const AccessType = {
     LAKEFORMATION: "LAKEFORMATION",
     S3: "S3",
@@ -145,7 +145,7 @@ const AwsLogSourceName = {
     VPC_FLOW: "VPC_FLOW",
     WAF: "WAF",
 };
-class BadRequestException extends SecurityLakeServiceException {
+let BadRequestException$1 = class BadRequestException extends SecurityLakeServiceException$1 {
     name = "BadRequestException";
     $fault = "client";
     constructor(opts) {
@@ -156,8 +156,8 @@ class BadRequestException extends SecurityLakeServiceException {
         });
         Object.setPrototypeOf(this, BadRequestException.prototype);
     }
-}
-class ConflictException extends SecurityLakeServiceException {
+};
+let ConflictException$1 = class ConflictException extends SecurityLakeServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     resourceName;
@@ -172,8 +172,8 @@ class ConflictException extends SecurityLakeServiceException {
         this.resourceName = opts.resourceName;
         this.resourceType = opts.resourceType;
     }
-}
-class InternalServerException extends SecurityLakeServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends SecurityLakeServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     $retryable = {};
@@ -185,8 +185,8 @@ class InternalServerException extends SecurityLakeServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends SecurityLakeServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends SecurityLakeServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     resourceName;
@@ -201,8 +201,8 @@ class ResourceNotFoundException extends SecurityLakeServiceException {
         this.resourceName = opts.resourceName;
         this.resourceType = opts.resourceType;
     }
-}
-class ThrottlingException extends SecurityLakeServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends SecurityLakeServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     $retryable = {
@@ -222,7 +222,7 @@ class ThrottlingException extends SecurityLakeServiceException {
         this.quotaCode = opts.quotaCode;
         this.retryAfterSeconds = opts.retryAfterSeconds;
     }
-}
+};
 const DataLakeStatus = {
     COMPLETED: "COMPLETED",
     FAILED: "FAILED",
@@ -265,980 +265,1068 @@ const SourceCollectionStatus = {
     NOT_COLLECTING: "NOT_COLLECTING",
 };
 
-const se_CreateAwsLogSourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/logsources/aws");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sources: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateCustomLogSourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/logsources/custom");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        configuration: (_) => smithyClient._json(_),
-        eventClasses: (_) => smithyClient._json(_),
-        sourceName: [],
-        sourceVersion: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataLakeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        configurations: (_) => smithyClient._json(_),
-        metaStoreManagerRoleArn: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataLakeExceptionSubscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/exceptions/subscription");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        exceptionTimeToLive: [],
-        notificationEndpoint: [],
-        subscriptionProtocol: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateDataLakeOrganizationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/organization/configuration");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        autoEnableNewAccount: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateSubscriberCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/subscribers");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        accessTypes: (_) => smithyClient._json(_),
-        sources: (_) => smithyClient._json(_),
-        subscriberDescription: [],
-        subscriberIdentity: (_) => smithyClient._json(_),
-        subscriberName: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateSubscriberNotificationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/subscribers/{subscriberId}/notification");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        configuration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteAwsLogSourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/logsources/aws/delete");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sources: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteCustomLogSourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalake/logsources/custom/{sourceName}");
-    b.p("sourceName", () => input.sourceName, "{sourceName}", false);
-    const query = smithyClient.map({
-        [_sV]: [, input[_sV]],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DeleteDataLakeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/delete");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        regions: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDataLakeExceptionSubscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalake/exceptions/subscription");
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDataLakeOrganizationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/organization/configuration/delete");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        autoEnableNewAccount: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteSubscriberCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/subscribers/{subscriberId}");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteSubscriberNotificationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/subscribers/{subscriberId}/notification");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeregisterDataLakeDelegatedAdministratorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalake/delegate");
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataLakeExceptionSubscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalake/exceptions/subscription");
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataLakeOrganizationConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalake/organization/configuration");
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetDataLakeSourcesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/sources");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        accounts: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSubscriberCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/subscribers/{subscriberId}");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListDataLakeExceptionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/exceptions");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        maxResults: [],
-        nextToken: [],
-        regions: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListDataLakesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/datalakes");
-    const query = smithyClient.map({
-        [_r]: [() => input.regions !== void 0, () => input[_r] || []],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListLogSourcesCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/logsources/list");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        accounts: (_) => smithyClient._json(_),
-        maxResults: [],
-        nextToken: [],
-        regions: (_) => smithyClient._json(_),
-        sources: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListSubscribersCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/subscribers");
-    const query = smithyClient.map({
-        [_nT]: [, input[_nT]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_RegisterDataLakeDelegatedAdministratorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/delegate");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        accountId: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateDataLakeCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        configurations: (_) => smithyClient._json(_),
-        metaStoreManagerRoleArn: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateDataLakeExceptionSubscriptionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/datalake/exceptions/subscription");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        exceptionTimeToLive: [],
-        notificationEndpoint: [],
-        subscriptionProtocol: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateSubscriberCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/subscribers/{subscriberId}");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        sources: (_) => smithyClient._json(_),
-        subscriberDescription: [],
-        subscriberIdentity: (_) => smithyClient._json(_),
-        subscriberName: [],
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateSubscriberNotificationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/subscribers/{subscriberId}/notification");
-    b.p("subscriberId", () => input.subscriberId, "{subscriberId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        configuration: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const de_CreateAwsLogSourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        failed: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateCustomLogSourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        source: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDataLakeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataLakes: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateDataLakeExceptionSubscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CreateDataLakeOrganizationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CreateSubscriberCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        subscriber: (_) => de_SubscriberResource(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateSubscriberNotificationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        subscriberEndpoint: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteAwsLogSourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        failed: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteCustomLogSourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteDataLakeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteDataLakeExceptionSubscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteDataLakeOrganizationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteSubscriberCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteSubscriberNotificationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeregisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_GetDataLakeExceptionSubscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        exceptionTimeToLive: smithyClient.expectLong,
-        notificationEndpoint: smithyClient.expectString,
-        subscriptionProtocol: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataLakeOrganizationConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        autoEnableNewAccount: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetDataLakeSourcesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataLakeArn: smithyClient.expectString,
-        dataLakeSources: smithyClient._json,
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSubscriberCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        subscriber: (_) => de_SubscriberResource(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataLakeExceptionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        exceptions: (_) => de_DataLakeExceptionList(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDataLakesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataLakes: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListLogSourcesCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        nextToken: smithyClient.expectString,
-        sources: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSubscribersCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        nextToken: smithyClient.expectString,
-        subscribers: (_) => de_SubscriberResourceList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_RegisterDataLakeDelegatedAdministratorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateDataLakeCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        dataLakes: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateDataLakeExceptionSubscriptionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateSubscriberCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        subscriber: (_) => de_SubscriberResource(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_UpdateSubscriberNotificationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        subscriberEndpoint: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.securitylake#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "BadRequestException":
-        case "com.amazonaws.securitylake#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.securitylake#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.securitylake#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.securitylake#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.securitylake#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SecurityLakeServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        errorCode: smithyClient.expectString,
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_BadRequestExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new BadRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceName: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        resourceName: smithyClient.expectString,
-        resourceType: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({
-        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => smithyClient.strictParseInt32(parsedOutput.headers[_ra])],
-    });
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-        quotaCode: smithyClient.expectString,
-        serviceCode: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DataLakeException = (output, context) => {
-    return smithyClient.take(output, {
-        exception: smithyClient.expectString,
-        region: smithyClient.expectString,
-        remediation: smithyClient.expectString,
-        timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_DataLakeExceptionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataLakeException(entry);
-    });
-    return retVal;
-};
-const de_SubscriberResource = (output, context) => {
-    return smithyClient.take(output, {
-        accessTypes: smithyClient._json,
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        resourceShareArn: smithyClient.expectString,
-        resourceShareName: smithyClient.expectString,
-        roleArn: smithyClient.expectString,
-        s3BucketArn: smithyClient.expectString,
-        sources: smithyClient._json,
-        subscriberArn: smithyClient.expectString,
-        subscriberDescription: smithyClient.expectString,
-        subscriberEndpoint: smithyClient.expectString,
-        subscriberId: smithyClient.expectString,
-        subscriberIdentity: smithyClient._json,
-        subscriberName: smithyClient.expectString,
-        subscriberStatus: smithyClient.expectString,
-        updatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_SubscriberResourceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SubscriberResource(entry);
-    });
-    return retVal;
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _ADE = "AccessDeniedException";
+const _AI = "AwsIdentity";
+const _ALSC = "AwsLogSourceConfiguration";
+const _ALSCL = "AwsLogSourceConfigurationList";
+const _ALSR = "AwsLogSourceResource";
+const _ALSRL = "AwsLogSourceResourceList";
+const _BRE = "BadRequestException";
+const _CALS = "CreateAwsLogSource";
+const _CALSR = "CreateAwsLogSourceRequest";
+const _CALSRr = "CreateAwsLogSourceResponse";
+const _CCLS = "CreateCustomLogSource";
+const _CCLSR = "CreateCustomLogSourceRequest";
+const _CCLSRr = "CreateCustomLogSourceResponse";
+const _CDL = "CreateDataLake";
+const _CDLES = "CreateDataLakeExceptionSubscription";
+const _CDLESR = "CreateDataLakeExceptionSubscriptionRequest";
+const _CDLESRr = "CreateDataLakeExceptionSubscriptionResponse";
+const _CDLOC = "CreateDataLakeOrganizationConfiguration";
+const _CDLOCR = "CreateDataLakeOrganizationConfigurationRequest";
+const _CDLOCRr = "CreateDataLakeOrganizationConfigurationResponse";
+const _CDLR = "CreateDataLakeRequest";
+const _CDLRr = "CreateDataLakeResponse";
+const _CE = "ConflictException";
+const _CLSA = "CustomLogSourceAttributes";
+const _CLSC = "CustomLogSourceConfiguration";
+const _CLSCC = "CustomLogSourceCrawlerConfiguration";
+const _CLSP = "CustomLogSourceProvider";
+const _CLSR = "CustomLogSourceResource";
+const _CS = "CreateSubscriber";
+const _CSN = "CreateSubscriberNotification";
+const _CSNR = "CreateSubscriberNotificationRequest";
+const _CSNRr = "CreateSubscriberNotificationResponse";
+const _CSR = "CreateSubscriberRequest";
+const _CSRr = "CreateSubscriberResponse";
+const _DALS = "DeleteAwsLogSource";
+const _DALSR = "DeleteAwsLogSourceRequest";
+const _DALSRe = "DeleteAwsLogSourceResponse";
+const _DCLS = "DeleteCustomLogSource";
+const _DCLSR = "DeleteCustomLogSourceRequest";
+const _DCLSRe = "DeleteCustomLogSourceResponse";
+const _DDL = "DeleteDataLake";
+const _DDLDA = "DeregisterDataLakeDelegatedAdministrator";
+const _DDLDAR = "DeregisterDataLakeDelegatedAdministratorRequest";
+const _DDLDARe = "DeregisterDataLakeDelegatedAdministratorResponse";
+const _DDLES = "DeleteDataLakeExceptionSubscription";
+const _DDLESR = "DeleteDataLakeExceptionSubscriptionRequest";
+const _DDLESRe = "DeleteDataLakeExceptionSubscriptionResponse";
+const _DDLOC = "DeleteDataLakeOrganizationConfiguration";
+const _DDLOCR = "DeleteDataLakeOrganizationConfigurationRequest";
+const _DDLOCRe = "DeleteDataLakeOrganizationConfigurationResponse";
+const _DDLR = "DeleteDataLakeRequest";
+const _DDLRe = "DeleteDataLakeResponse";
+const _DLAENAC = "DataLakeAutoEnableNewAccountConfiguration";
+const _DLAENACL = "DataLakeAutoEnableNewAccountConfigurationList";
+const _DLC = "DataLakeConfiguration";
+const _DLCL = "DataLakeConfigurationList";
+const _DLE = "DataLakeException";
+const _DLEC = "DataLakeEncryptionConfiguration";
+const _DLEL = "DataLakeExceptionList";
+const _DLLC = "DataLakeLifecycleConfiguration";
+const _DLLE = "DataLakeLifecycleExpiration";
+const _DLLT = "DataLakeLifecycleTransition";
+const _DLLTL = "DataLakeLifecycleTransitionList";
+const _DLR = "DataLakeResource";
+const _DLRC = "DataLakeReplicationConfiguration";
+const _DLRL = "DataLakeResourceList";
+const _DLS = "DataLakeSource";
+const _DLSL = "DataLakeSourceList";
+const _DLSS = "DataLakeSourceStatus";
+const _DLSSL = "DataLakeSourceStatusList";
+const _DLUE = "DataLakeUpdateException";
+const _DLUS = "DataLakeUpdateStatus";
+const _DS = "DeleteSubscriber";
+const _DSN = "DeleteSubscriberNotification";
+const _DSNR = "DeleteSubscriberNotificationRequest";
+const _DSNRe = "DeleteSubscriberNotificationResponse";
+const _DSR = "DeleteSubscriberRequest";
+const _DSRe = "DeleteSubscriberResponse";
+const _GDLES = "GetDataLakeExceptionSubscription";
+const _GDLESR = "GetDataLakeExceptionSubscriptionRequest";
+const _GDLESRe = "GetDataLakeExceptionSubscriptionResponse";
+const _GDLOC = "GetDataLakeOrganizationConfiguration";
+const _GDLOCR = "GetDataLakeOrganizationConfigurationRequest";
+const _GDLOCRe = "GetDataLakeOrganizationConfigurationResponse";
+const _GDLS = "GetDataLakeSources";
+const _GDLSR = "GetDataLakeSourcesRequest";
+const _GDLSRe = "GetDataLakeSourcesResponse";
+const _GS = "GetSubscriber";
+const _GSR = "GetSubscriberRequest";
+const _GSRe = "GetSubscriberResponse";
+const _HNC = "HttpsNotificationConfiguration";
+const _ISE = "InternalServerException";
+const _LDL = "ListDataLakes";
+const _LDLE = "ListDataLakeExceptions";
+const _LDLER = "ListDataLakeExceptionsRequest";
+const _LDLERi = "ListDataLakeExceptionsResponse";
+const _LDLR = "ListDataLakesRequest";
+const _LDLRi = "ListDataLakesResponse";
+const _LLS = "ListLogSources";
+const _LLSR = "ListLogSourcesRequest";
+const _LLSRi = "ListLogSourcesResponse";
+const _LS = "LogSource";
+const _LSL = "LogSourceList";
+const _LSR = "ListSubscribersRequest";
+const _LSRL = "LogSourceResourceList";
+const _LSRi = "ListSubscribersResponse";
+const _LSRo = "LogSourceResource";
+const _LSi = "ListSubscribers";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _NC = "NotificationConfiguration";
+const _RA = "Retry-After";
+const _RDLDA = "RegisterDataLakeDelegatedAdministrator";
+const _RDLDAR = "RegisterDataLakeDelegatedAdministratorRequest";
+const _RDLDARe = "RegisterDataLakeDelegatedAdministratorResponse";
+const _RNFE = "ResourceNotFoundException";
+const _SNC = "SqsNotificationConfiguration";
+const _SR = "SubscriberResource";
+const _SRL = "SubscriberResourceList";
+const _T = "Tag";
+const _TE = "ThrottlingException";
+const _TL = "TagList";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UDL = "UpdateDataLake";
+const _UDLES = "UpdateDataLakeExceptionSubscription";
+const _UDLESR = "UpdateDataLakeExceptionSubscriptionRequest";
+const _UDLESRp = "UpdateDataLakeExceptionSubscriptionResponse";
+const _UDLR = "UpdateDataLakeRequest";
+const _UDLRp = "UpdateDataLakeResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _US = "UpdateSubscriber";
+const _USN = "UpdateSubscriberNotification";
+const _USNR = "UpdateSubscriberNotificationRequest";
+const _USNRp = "UpdateSubscriberNotificationResponse";
+const _USR = "UpdateSubscriberRequest";
+const _USRp = "UpdateSubscriberResponse";
+const _a = "accounts";
+const _aAKN = "authorizationApiKeyName";
+const _aAKV = "authorizationApiKeyValue";
+const _aENA = "autoEnableNewAccount";
+const _aI = "accountId";
+const _aLS = "awsLogSource";
+const _aT = "accessTypes";
+const _ac = "account";
+const _at = "attributes";
+const _c = "client";
+const _cA = "crawlerArn";
+const _cAr = "createdAt";
+const _cC = "crawlerConfiguration";
+const _cLS = "customLogSource";
+const _cS = "createStatus";
+const _co = "configuration";
+const _cod = "code";
+const _con = "configurations";
+const _d = "days";
+const _dA = "databaseArn";
+const _dL = "dataLakes";
+const _dLA = "dataLakeArn";
+const _dLS = "dataLakeSources";
+const _e = "error";
+const _eC = "errorCode";
+const _eCn = "encryptionConfiguration";
+const _eCv = "eventClasses";
+const _eI = "externalId";
+const _eTTL = "exceptionTimeToLive";
+const _en = "endpoint";
+const _ex = "exception";
+const _exc = "exceptions";
+const _exp = "expiration";
+const _f = "failed";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hM = "httpMethod";
+const _hNC = "httpsNotificationConfiguration";
+const _hQ = "httpQuery";
+const _k = "key";
+const _kKI = "kmsKeyId";
+const _l = "location";
+const _lC = "lifecycleConfiguration";
+const _m = "message";
 const _mR = "maxResults";
+const _mSMRA = "metaStoreManagerRoleArn";
+const _nE = "notificationEndpoint";
 const _nT = "nextToken";
+const _p = "principal";
+const _pI = "providerIdentity";
+const _pr = "provider";
+const _qC = "quotaCode";
 const _r = "regions";
+const _rA = "roleArn";
 const _rAS = "retryAfterSeconds";
-const _ra = "retry-after";
+const _rAe = "resourceArn";
+const _rC = "replicationConfiguration";
+const _rI = "requestId";
+const _rN = "resourceName";
+const _rSA = "resourceShareArn";
+const _rSN = "resourceShareName";
+const _rT = "resourceType";
+const _re = "region";
+const _rea = "reason";
+const _rem = "remediation";
+const _res = "resource";
+const _s = "sources";
+const _sA = "subscriberArn";
+const _sBA = "s3BucketArn";
+const _sC = "storageClass";
+const _sCe = "serviceCode";
+const _sD = "subscriberDescription";
+const _sE = "subscriberEndpoint";
+const _sI = "subscriberId";
+const _sIu = "subscriberIdentity";
+const _sN = "sourceName";
+const _sNC = "sqsNotificationConfiguration";
+const _sNu = "subscriberName";
+const _sP = "subscriptionProtocol";
+const _sS = "sourceStatuses";
+const _sSu = "subscriberStatus";
 const _sV = "sourceVersion";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.securitylake";
+const _so = "source";
+const _st = "status";
+const _su = "subscriber";
+const _sub = "subscribers";
+const _t = "tags";
+const _tA = "tableArn";
 const _tK = "tagKeys";
+const _tRA = "targetRoleArn";
+const _ti = "timestamp";
+const _tr = "transitions";
+const _uA = "updatedAt";
+const _uS = "updateStatus";
+const _v = "value";
+const n0 = "com.amazonaws.securitylake";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m, _eC],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AwsIdentity = [3, n0, _AI, 0, [_p, _eI], [0, 0]];
+var AwsLogSourceConfiguration = [
+    3,
+    n0,
+    _ALSC,
+    0,
+    [_a, _r, _sN, _sV],
+    [64 | 0, 64 | 0, 0, 0],
+];
+var AwsLogSourceResource = [3, n0, _ALSR, 0, [_sN, _sV], [0, 0]];
+var BadRequestException = [
+    -3,
+    n0,
+    _BRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(BadRequestException, BadRequestException$1);
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m, _rN, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateAwsLogSourceRequest = [
+    3,
+    n0,
+    _CALSR,
+    0,
+    [_s],
+    [() => AwsLogSourceConfigurationList],
+];
+var CreateAwsLogSourceResponse = [3, n0, _CALSRr, 0, [_f], [64 | 0]];
+var CreateCustomLogSourceRequest = [
+    3,
+    n0,
+    _CCLSR,
+    0,
+    [_sN, _sV, _eCv, _co],
+    [0, 0, 64 | 0, () => CustomLogSourceConfiguration],
+];
+var CreateCustomLogSourceResponse = [
+    3,
+    n0,
+    _CCLSRr,
+    0,
+    [_so],
+    [() => CustomLogSourceResource],
+];
+var CreateDataLakeExceptionSubscriptionRequest = [
+    3,
+    n0,
+    _CDLESR,
+    0,
+    [_sP, _nE, _eTTL],
+    [0, 0, 1],
+];
+var CreateDataLakeExceptionSubscriptionResponse = [3, n0, _CDLESRr, 0, [], []];
+var CreateDataLakeOrganizationConfigurationRequest = [
+    3,
+    n0,
+    _CDLOCR,
+    0,
+    [_aENA],
+    [() => DataLakeAutoEnableNewAccountConfigurationList],
+];
+var CreateDataLakeOrganizationConfigurationResponse = [3, n0, _CDLOCRr, 0, [], []];
+var CreateDataLakeRequest = [
+    3,
+    n0,
+    _CDLR,
+    0,
+    [_con, _mSMRA, _t],
+    [() => DataLakeConfigurationList, 0, () => TagList],
+];
+var CreateDataLakeResponse = [3, n0, _CDLRr, 0, [_dL], [() => DataLakeResourceList]];
+var CreateSubscriberNotificationRequest = [
+    3,
+    n0,
+    _CSNR,
+    0,
+    [_sI, _co],
+    [[0, 1], () => NotificationConfiguration],
+];
+var CreateSubscriberNotificationResponse = [3, n0, _CSNRr, 0, [_sE], [0]];
+var CreateSubscriberRequest = [
+    3,
+    n0,
+    _CSR,
+    0,
+    [_sIu, _sNu, _sD, _s, _aT, _t],
+    [() => AwsIdentity, 0, 0, () => LogSourceResourceList, 64 | 0, () => TagList],
+];
+var CreateSubscriberResponse = [3, n0, _CSRr, 0, [_su], [() => SubscriberResource]];
+var CustomLogSourceAttributes = [3, n0, _CLSA, 0, [_cA, _dA, _tA], [0, 0, 0]];
+var CustomLogSourceConfiguration = [
+    3,
+    n0,
+    _CLSC,
+    0,
+    [_cC, _pI],
+    [() => CustomLogSourceCrawlerConfiguration, () => AwsIdentity],
+];
+var CustomLogSourceCrawlerConfiguration = [3, n0, _CLSCC, 0, [_rA], [0]];
+var CustomLogSourceProvider = [3, n0, _CLSP, 0, [_rA, _l], [0, 0]];
+var CustomLogSourceResource = [
+    3,
+    n0,
+    _CLSR,
+    0,
+    [_sN, _sV, _pr, _at],
+    [0, 0, () => CustomLogSourceProvider, () => CustomLogSourceAttributes],
+];
+var DataLakeAutoEnableNewAccountConfiguration = [
+    3,
+    n0,
+    _DLAENAC,
+    0,
+    [_re, _s],
+    [0, () => AwsLogSourceResourceList],
+];
+var DataLakeConfiguration = [
+    3,
+    n0,
+    _DLC,
+    0,
+    [_re, _eCn, _lC, _rC],
+    [
+        0,
+        () => DataLakeEncryptionConfiguration,
+        () => DataLakeLifecycleConfiguration,
+        () => DataLakeReplicationConfiguration,
+    ],
+];
+var DataLakeEncryptionConfiguration = [3, n0, _DLEC, 0, [_kKI], [0]];
+var DataLakeException = [3, n0, _DLE, 0, [_re, _ex, _rem, _ti], [0, 0, 0, 5]];
+var DataLakeLifecycleConfiguration = [
+    3,
+    n0,
+    _DLLC,
+    0,
+    [_exp, _tr],
+    [() => DataLakeLifecycleExpiration, () => DataLakeLifecycleTransitionList],
+];
+var DataLakeLifecycleExpiration = [3, n0, _DLLE, 0, [_d], [1]];
+var DataLakeLifecycleTransition = [3, n0, _DLLT, 0, [_sC, _d], [0, 1]];
+var DataLakeReplicationConfiguration = [3, n0, _DLRC, 0, [_r, _rA], [64 | 0, 0]];
+var DataLakeResource = [
+    3,
+    n0,
+    _DLR,
+    0,
+    [_dLA, _re, _sBA, _eCn, _lC, _rC, _cS, _uS],
+    [
+        0,
+        0,
+        0,
+        () => DataLakeEncryptionConfiguration,
+        () => DataLakeLifecycleConfiguration,
+        () => DataLakeReplicationConfiguration,
+        0,
+        () => DataLakeUpdateStatus,
+    ],
+];
+var DataLakeSource = [
+    3,
+    n0,
+    _DLS,
+    0,
+    [_ac, _sN, _eCv, _sS],
+    [0, 0, 64 | 0, () => DataLakeSourceStatusList],
+];
+var DataLakeSourceStatus = [3, n0, _DLSS, 0, [_res, _st], [0, 0]];
+var DataLakeUpdateException = [3, n0, _DLUE, 0, [_rea, _cod], [0, 0]];
+var DataLakeUpdateStatus = [
+    3,
+    n0,
+    _DLUS,
+    0,
+    [_rI, _st, _ex],
+    [0, 0, () => DataLakeUpdateException],
+];
+var DeleteAwsLogSourceRequest = [
+    3,
+    n0,
+    _DALSR,
+    0,
+    [_s],
+    [() => AwsLogSourceConfigurationList],
+];
+var DeleteAwsLogSourceResponse = [3, n0, _DALSRe, 0, [_f], [64 | 0]];
+var DeleteCustomLogSourceRequest = [
+    3,
+    n0,
+    _DCLSR,
+    0,
+    [_sN, _sV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _sV,
+            },
+        ],
+    ],
+];
+var DeleteCustomLogSourceResponse = [3, n0, _DCLSRe, 0, [], []];
+var DeleteDataLakeExceptionSubscriptionRequest = [3, n0, _DDLESR, 0, [], []];
+var DeleteDataLakeExceptionSubscriptionResponse = [3, n0, _DDLESRe, 0, [], []];
+var DeleteDataLakeOrganizationConfigurationRequest = [
+    3,
+    n0,
+    _DDLOCR,
+    0,
+    [_aENA],
+    [() => DataLakeAutoEnableNewAccountConfigurationList],
+];
+var DeleteDataLakeOrganizationConfigurationResponse = [3, n0, _DDLOCRe, 0, [], []];
+var DeleteDataLakeRequest = [3, n0, _DDLR, 0, [_r], [64 | 0]];
+var DeleteDataLakeResponse = [3, n0, _DDLRe, 0, [], []];
+var DeleteSubscriberNotificationRequest = [3, n0, _DSNR, 0, [_sI], [[0, 1]]];
+var DeleteSubscriberNotificationResponse = [3, n0, _DSNRe, 0, [], []];
+var DeleteSubscriberRequest = [3, n0, _DSR, 0, [_sI], [[0, 1]]];
+var DeleteSubscriberResponse = [3, n0, _DSRe, 0, [], []];
+var DeregisterDataLakeDelegatedAdministratorRequest = [3, n0, _DDLDAR, 0, [], []];
+var DeregisterDataLakeDelegatedAdministratorResponse = [3, n0, _DDLDARe, 0, [], []];
+var GetDataLakeExceptionSubscriptionRequest = [3, n0, _GDLESR, 0, [], []];
+var GetDataLakeExceptionSubscriptionResponse = [
+    3,
+    n0,
+    _GDLESRe,
+    0,
+    [_sP, _nE, _eTTL],
+    [0, 0, 1],
+];
+var GetDataLakeOrganizationConfigurationRequest = [3, n0, _GDLOCR, 0, [], []];
+var GetDataLakeOrganizationConfigurationResponse = [
+    3,
+    n0,
+    _GDLOCRe,
+    0,
+    [_aENA],
+    [() => DataLakeAutoEnableNewAccountConfigurationList],
+];
+var GetDataLakeSourcesRequest = [3, n0, _GDLSR, 0, [_a, _mR, _nT], [64 | 0, 1, 0]];
+var GetDataLakeSourcesResponse = [
+    3,
+    n0,
+    _GDLSRe,
+    0,
+    [_dLA, _dLS, _nT],
+    [0, () => DataLakeSourceList, 0],
+];
+var GetSubscriberRequest = [3, n0, _GSR, 0, [_sI], [[0, 1]]];
+var GetSubscriberResponse = [3, n0, _GSRe, 0, [_su], [() => SubscriberResource]];
+var HttpsNotificationConfiguration = [
+    3,
+    n0,
+    _HNC,
+    0,
+    [_en, _aAKN, _aAKV, _hM, _tRA],
+    [0, 0, 0, 0, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListDataLakeExceptionsRequest = [3, n0, _LDLER, 0, [_r, _mR, _nT], [64 | 0, 1, 0]];
+var ListDataLakeExceptionsResponse = [
+    3,
+    n0,
+    _LDLERi,
+    0,
+    [_exc, _nT],
+    [() => DataLakeExceptionList, 0],
+];
+var ListDataLakesRequest = [
+    3,
+    n0,
+    _LDLR,
+    0,
+    [_r],
+    [
+        [
+            64 | 0,
+            {
+                [_hQ]: _r,
+            },
+        ],
+    ],
+];
+var ListDataLakesResponse = [3, n0, _LDLRi, 0, [_dL], [() => DataLakeResourceList]];
+var ListLogSourcesRequest = [
+    3,
+    n0,
+    _LLSR,
+    0,
+    [_a, _r, _s, _mR, _nT],
+    [64 | 0, 64 | 0, () => LogSourceResourceList, 1, 0],
+];
+var ListLogSourcesResponse = [3, n0, _LLSRi, 0, [_s, _nT], [() => LogSourceList, 0]];
+var ListSubscribersRequest = [
+    3,
+    n0,
+    _LSR,
+    0,
+    [_nT, _mR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListSubscribersResponse = [
+    3,
+    n0,
+    _LSRi,
+    0,
+    [_sub, _nT],
+    [() => SubscriberResourceList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rAe], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [() => TagList]];
+var LogSource = [3, n0, _LS, 0, [_ac, _re, _s], [0, 0, () => LogSourceResourceList]];
+var RegisterDataLakeDelegatedAdministratorRequest = [3, n0, _RDLDAR, 0, [_aI], [0]];
+var RegisterDataLakeDelegatedAdministratorResponse = [3, n0, _RDLDARe, 0, [], []];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _rN, _rT],
+    [0, 0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SqsNotificationConfiguration = [3, n0, _SNC, 0, [], []];
+var SubscriberResource = [
+    3,
+    n0,
+    _SR,
+    0,
+    [_sI, _sA, _sIu, _sNu, _sD, _s, _aT, _rA, _sBA, _sE, _sSu, _rSA, _rSN, _cAr, _uA],
+    [0, 0, () => AwsIdentity, 0, 0, () => LogSourceResourceList, 64 | 0, 0, 0, 0, 0, 0, 0, 5, 5],
+];
+var Tag = [3, n0, _T, 0, [_k, _v], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rAe, _t], [[0, 1], () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m, _sCe, _qC, _rAS],
+    [
+        0,
+        0,
+        0,
+        [
+            1,
+            {
+                [_hH]: _RA,
+            },
+        ],
+    ],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rAe, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateDataLakeExceptionSubscriptionRequest = [
+    3,
+    n0,
+    _UDLESR,
+    0,
+    [_sP, _nE, _eTTL],
+    [0, 0, 1],
+];
+var UpdateDataLakeExceptionSubscriptionResponse = [3, n0, _UDLESRp, 0, [], []];
+var UpdateDataLakeRequest = [
+    3,
+    n0,
+    _UDLR,
+    0,
+    [_con, _mSMRA],
+    [() => DataLakeConfigurationList, 0],
+];
+var UpdateDataLakeResponse = [3, n0, _UDLRp, 0, [_dL], [() => DataLakeResourceList]];
+var UpdateSubscriberNotificationRequest = [
+    3,
+    n0,
+    _USNR,
+    0,
+    [_sI, _co],
+    [[0, 1], () => NotificationConfiguration],
+];
+var UpdateSubscriberNotificationResponse = [3, n0, _USNRp, 0, [_sE], [0]];
+var UpdateSubscriberRequest = [
+    3,
+    n0,
+    _USR,
+    0,
+    [_sI, _sIu, _sNu, _sD, _s],
+    [[0, 1], () => AwsIdentity, 0, 0, () => LogSourceResourceList],
+];
+var UpdateSubscriberResponse = [3, n0, _USRp, 0, [_su], [() => SubscriberResource]];
+var SecurityLakeServiceException = [-3, _sm, "SecurityLakeServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SecurityLakeServiceException, SecurityLakeServiceException$1);
+var AwsLogSourceConfigurationList = [1, n0, _ALSCL, 0, () => AwsLogSourceConfiguration];
+var AwsLogSourceResourceList = [1, n0, _ALSRL, 0, () => AwsLogSourceResource];
+var DataLakeAutoEnableNewAccountConfigurationList = [
+    1,
+    n0,
+    _DLAENACL,
+    0,
+    () => DataLakeAutoEnableNewAccountConfiguration,
+];
+var DataLakeConfigurationList = [1, n0, _DLCL, 0, () => DataLakeConfiguration];
+var DataLakeExceptionList = [1, n0, _DLEL, 0, () => DataLakeException];
+var DataLakeLifecycleTransitionList = [1, n0, _DLLTL, 0, () => DataLakeLifecycleTransition];
+var DataLakeResourceList = [1, n0, _DLRL, 0, () => DataLakeResource];
+var DataLakeSourceList = [1, n0, _DLSL, 0, () => DataLakeSource];
+var DataLakeSourceStatusList = [1, n0, _DLSSL, 0, () => DataLakeSourceStatus];
+var LogSourceList = [1, n0, _LSL, 0, () => LogSource];
+var LogSourceResourceList = [1, n0, _LSRL, 0, () => LogSourceResource];
+var SubscriberResourceList = [1, n0, _SRL, 0, () => SubscriberResource];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var LogSourceResource = [
+    3,
+    n0,
+    _LSRo,
+    0,
+    [_aLS, _cLS],
+    [() => AwsLogSourceResource, () => CustomLogSourceResource],
+];
+var NotificationConfiguration = [
+    3,
+    n0,
+    _NC,
+    0,
+    [_sNC, _hNC],
+    [() => SqsNotificationConfiguration, () => HttpsNotificationConfiguration],
+];
+var CreateAwsLogSource = [
+    9,
+    n0,
+    _CALS,
+    {
+        [_h]: ["POST", "/v1/datalake/logsources/aws", 200],
+    },
+    () => CreateAwsLogSourceRequest,
+    () => CreateAwsLogSourceResponse,
+];
+var CreateCustomLogSource = [
+    9,
+    n0,
+    _CCLS,
+    {
+        [_h]: ["POST", "/v1/datalake/logsources/custom", 200],
+    },
+    () => CreateCustomLogSourceRequest,
+    () => CreateCustomLogSourceResponse,
+];
+var CreateDataLake = [
+    9,
+    n0,
+    _CDL,
+    {
+        [_h]: ["POST", "/v1/datalake", 200],
+    },
+    () => CreateDataLakeRequest,
+    () => CreateDataLakeResponse,
+];
+var CreateDataLakeExceptionSubscription = [
+    9,
+    n0,
+    _CDLES,
+    {
+        [_h]: ["POST", "/v1/datalake/exceptions/subscription", 200],
+    },
+    () => CreateDataLakeExceptionSubscriptionRequest,
+    () => CreateDataLakeExceptionSubscriptionResponse,
+];
+var CreateDataLakeOrganizationConfiguration = [
+    9,
+    n0,
+    _CDLOC,
+    {
+        [_h]: ["POST", "/v1/datalake/organization/configuration", 200],
+    },
+    () => CreateDataLakeOrganizationConfigurationRequest,
+    () => CreateDataLakeOrganizationConfigurationResponse,
+];
+var CreateSubscriber = [
+    9,
+    n0,
+    _CS,
+    {
+        [_h]: ["POST", "/v1/subscribers", 200],
+    },
+    () => CreateSubscriberRequest,
+    () => CreateSubscriberResponse,
+];
+var CreateSubscriberNotification = [
+    9,
+    n0,
+    _CSN,
+    {
+        [_h]: ["POST", "/v1/subscribers/{subscriberId}/notification", 200],
+    },
+    () => CreateSubscriberNotificationRequest,
+    () => CreateSubscriberNotificationResponse,
+];
+var DeleteAwsLogSource = [
+    9,
+    n0,
+    _DALS,
+    {
+        [_h]: ["POST", "/v1/datalake/logsources/aws/delete", 200],
+    },
+    () => DeleteAwsLogSourceRequest,
+    () => DeleteAwsLogSourceResponse,
+];
+var DeleteCustomLogSource = [
+    9,
+    n0,
+    _DCLS,
+    {
+        [_h]: ["DELETE", "/v1/datalake/logsources/custom/{sourceName}", 200],
+    },
+    () => DeleteCustomLogSourceRequest,
+    () => DeleteCustomLogSourceResponse,
+];
+var DeleteDataLake = [
+    9,
+    n0,
+    _DDL,
+    {
+        [_h]: ["POST", "/v1/datalake/delete", 200],
+    },
+    () => DeleteDataLakeRequest,
+    () => DeleteDataLakeResponse,
+];
+var DeleteDataLakeExceptionSubscription = [
+    9,
+    n0,
+    _DDLES,
+    {
+        [_h]: ["DELETE", "/v1/datalake/exceptions/subscription", 200],
+    },
+    () => DeleteDataLakeExceptionSubscriptionRequest,
+    () => DeleteDataLakeExceptionSubscriptionResponse,
+];
+var DeleteDataLakeOrganizationConfiguration = [
+    9,
+    n0,
+    _DDLOC,
+    {
+        [_h]: ["POST", "/v1/datalake/organization/configuration/delete", 200],
+    },
+    () => DeleteDataLakeOrganizationConfigurationRequest,
+    () => DeleteDataLakeOrganizationConfigurationResponse,
+];
+var DeleteSubscriber = [
+    9,
+    n0,
+    _DS,
+    {
+        [_h]: ["DELETE", "/v1/subscribers/{subscriberId}", 200],
+    },
+    () => DeleteSubscriberRequest,
+    () => DeleteSubscriberResponse,
+];
+var DeleteSubscriberNotification = [
+    9,
+    n0,
+    _DSN,
+    {
+        [_h]: ["DELETE", "/v1/subscribers/{subscriberId}/notification", 200],
+    },
+    () => DeleteSubscriberNotificationRequest,
+    () => DeleteSubscriberNotificationResponse,
+];
+var DeregisterDataLakeDelegatedAdministrator = [
+    9,
+    n0,
+    _DDLDA,
+    {
+        [_h]: ["DELETE", "/v1/datalake/delegate", 200],
+    },
+    () => DeregisterDataLakeDelegatedAdministratorRequest,
+    () => DeregisterDataLakeDelegatedAdministratorResponse,
+];
+var GetDataLakeExceptionSubscription = [
+    9,
+    n0,
+    _GDLES,
+    {
+        [_h]: ["GET", "/v1/datalake/exceptions/subscription", 200],
+    },
+    () => GetDataLakeExceptionSubscriptionRequest,
+    () => GetDataLakeExceptionSubscriptionResponse,
+];
+var GetDataLakeOrganizationConfiguration = [
+    9,
+    n0,
+    _GDLOC,
+    {
+        [_h]: ["GET", "/v1/datalake/organization/configuration", 200],
+    },
+    () => GetDataLakeOrganizationConfigurationRequest,
+    () => GetDataLakeOrganizationConfigurationResponse,
+];
+var GetDataLakeSources = [
+    9,
+    n0,
+    _GDLS,
+    {
+        [_h]: ["POST", "/v1/datalake/sources", 200],
+    },
+    () => GetDataLakeSourcesRequest,
+    () => GetDataLakeSourcesResponse,
+];
+var GetSubscriber = [
+    9,
+    n0,
+    _GS,
+    {
+        [_h]: ["GET", "/v1/subscribers/{subscriberId}", 200],
+    },
+    () => GetSubscriberRequest,
+    () => GetSubscriberResponse,
+];
+var ListDataLakeExceptions = [
+    9,
+    n0,
+    _LDLE,
+    {
+        [_h]: ["POST", "/v1/datalake/exceptions", 200],
+    },
+    () => ListDataLakeExceptionsRequest,
+    () => ListDataLakeExceptionsResponse,
+];
+var ListDataLakes = [
+    9,
+    n0,
+    _LDL,
+    {
+        [_h]: ["GET", "/v1/datalakes", 200],
+    },
+    () => ListDataLakesRequest,
+    () => ListDataLakesResponse,
+];
+var ListLogSources = [
+    9,
+    n0,
+    _LLS,
+    {
+        [_h]: ["POST", "/v1/datalake/logsources/list", 200],
+    },
+    () => ListLogSourcesRequest,
+    () => ListLogSourcesResponse,
+];
+var ListSubscribers = [
+    9,
+    n0,
+    _LSi,
+    {
+        [_h]: ["GET", "/v1/subscribers", 200],
+    },
+    () => ListSubscribersRequest,
+    () => ListSubscribersResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/v1/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var RegisterDataLakeDelegatedAdministrator = [
+    9,
+    n0,
+    _RDLDA,
+    {
+        [_h]: ["POST", "/v1/datalake/delegate", 200],
+    },
+    () => RegisterDataLakeDelegatedAdministratorRequest,
+    () => RegisterDataLakeDelegatedAdministratorResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/v1/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/v1/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateDataLake = [
+    9,
+    n0,
+    _UDL,
+    {
+        [_h]: ["PUT", "/v1/datalake", 200],
+    },
+    () => UpdateDataLakeRequest,
+    () => UpdateDataLakeResponse,
+];
+var UpdateDataLakeExceptionSubscription = [
+    9,
+    n0,
+    _UDLES,
+    {
+        [_h]: ["PUT", "/v1/datalake/exceptions/subscription", 200],
+    },
+    () => UpdateDataLakeExceptionSubscriptionRequest,
+    () => UpdateDataLakeExceptionSubscriptionResponse,
+];
+var UpdateSubscriber = [
+    9,
+    n0,
+    _US,
+    {
+        [_h]: ["PUT", "/v1/subscribers/{subscriberId}", 200],
+    },
+    () => UpdateSubscriberRequest,
+    () => UpdateSubscriberResponse,
+];
+var UpdateSubscriberNotification = [
+    9,
+    n0,
+    _USN,
+    {
+        [_h]: ["PUT", "/v1/subscribers/{subscriberId}/notification", 200],
+    },
+    () => UpdateSubscriberNotificationRequest,
+    () => UpdateSubscriberNotificationResponse,
+];
 
 class CreateAwsLogSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateAwsLogSource", {})
     .n("SecurityLakeClient", "CreateAwsLogSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateAwsLogSourceCommand)
-    .de(de_CreateAwsLogSourceCommand)
+    .sc(CreateAwsLogSource)
     .build() {
 }
 
@@ -1246,16 +1334,11 @@ class CreateCustomLogSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateCustomLogSource", {})
     .n("SecurityLakeClient", "CreateCustomLogSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateCustomLogSourceCommand)
-    .de(de_CreateCustomLogSourceCommand)
+    .sc(CreateCustomLogSource)
     .build() {
 }
 
@@ -1263,16 +1346,11 @@ class CreateDataLakeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateDataLake", {})
     .n("SecurityLakeClient", "CreateDataLakeCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDataLakeCommand)
-    .de(de_CreateDataLakeCommand)
+    .sc(CreateDataLake)
     .build() {
 }
 
@@ -1280,16 +1358,11 @@ class CreateDataLakeExceptionSubscriptionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateDataLakeExceptionSubscription", {})
     .n("SecurityLakeClient", "CreateDataLakeExceptionSubscriptionCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDataLakeExceptionSubscriptionCommand)
-    .de(de_CreateDataLakeExceptionSubscriptionCommand)
+    .sc(CreateDataLakeExceptionSubscription)
     .build() {
 }
 
@@ -1297,16 +1370,11 @@ class CreateDataLakeOrganizationConfigurationCommand extends smithyClient.Comman
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateDataLakeOrganizationConfiguration", {})
     .n("SecurityLakeClient", "CreateDataLakeOrganizationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDataLakeOrganizationConfigurationCommand)
-    .de(de_CreateDataLakeOrganizationConfigurationCommand)
+    .sc(CreateDataLakeOrganizationConfiguration)
     .build() {
 }
 
@@ -1314,16 +1382,11 @@ class CreateSubscriberCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateSubscriber", {})
     .n("SecurityLakeClient", "CreateSubscriberCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateSubscriberCommand)
-    .de(de_CreateSubscriberCommand)
+    .sc(CreateSubscriber)
     .build() {
 }
 
@@ -1331,16 +1394,11 @@ class CreateSubscriberNotificationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "CreateSubscriberNotification", {})
     .n("SecurityLakeClient", "CreateSubscriberNotificationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateSubscriberNotificationCommand)
-    .de(de_CreateSubscriberNotificationCommand)
+    .sc(CreateSubscriberNotification)
     .build() {
 }
 
@@ -1348,16 +1406,11 @@ class DeleteAwsLogSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteAwsLogSource", {})
     .n("SecurityLakeClient", "DeleteAwsLogSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteAwsLogSourceCommand)
-    .de(de_DeleteAwsLogSourceCommand)
+    .sc(DeleteAwsLogSource)
     .build() {
 }
 
@@ -1365,16 +1418,11 @@ class DeleteCustomLogSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteCustomLogSource", {})
     .n("SecurityLakeClient", "DeleteCustomLogSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteCustomLogSourceCommand)
-    .de(de_DeleteCustomLogSourceCommand)
+    .sc(DeleteCustomLogSource)
     .build() {
 }
 
@@ -1382,16 +1430,11 @@ class DeleteDataLakeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteDataLake", {})
     .n("SecurityLakeClient", "DeleteDataLakeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataLakeCommand)
-    .de(de_DeleteDataLakeCommand)
+    .sc(DeleteDataLake)
     .build() {
 }
 
@@ -1399,16 +1442,11 @@ class DeleteDataLakeExceptionSubscriptionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteDataLakeExceptionSubscription", {})
     .n("SecurityLakeClient", "DeleteDataLakeExceptionSubscriptionCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataLakeExceptionSubscriptionCommand)
-    .de(de_DeleteDataLakeExceptionSubscriptionCommand)
+    .sc(DeleteDataLakeExceptionSubscription)
     .build() {
 }
 
@@ -1416,16 +1454,11 @@ class DeleteDataLakeOrganizationConfigurationCommand extends smithyClient.Comman
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteDataLakeOrganizationConfiguration", {})
     .n("SecurityLakeClient", "DeleteDataLakeOrganizationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataLakeOrganizationConfigurationCommand)
-    .de(de_DeleteDataLakeOrganizationConfigurationCommand)
+    .sc(DeleteDataLakeOrganizationConfiguration)
     .build() {
 }
 
@@ -1433,16 +1466,11 @@ class DeleteSubscriberCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteSubscriber", {})
     .n("SecurityLakeClient", "DeleteSubscriberCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSubscriberCommand)
-    .de(de_DeleteSubscriberCommand)
+    .sc(DeleteSubscriber)
     .build() {
 }
 
@@ -1450,16 +1478,11 @@ class DeleteSubscriberNotificationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeleteSubscriberNotification", {})
     .n("SecurityLakeClient", "DeleteSubscriberNotificationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteSubscriberNotificationCommand)
-    .de(de_DeleteSubscriberNotificationCommand)
+    .sc(DeleteSubscriberNotification)
     .build() {
 }
 
@@ -1467,16 +1490,11 @@ class DeregisterDataLakeDelegatedAdministratorCommand extends smithyClient.Comma
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "DeregisterDataLakeDelegatedAdministrator", {})
     .n("SecurityLakeClient", "DeregisterDataLakeDelegatedAdministratorCommand")
-    .f(void 0, void 0)
-    .ser(se_DeregisterDataLakeDelegatedAdministratorCommand)
-    .de(de_DeregisterDataLakeDelegatedAdministratorCommand)
+    .sc(DeregisterDataLakeDelegatedAdministrator)
     .build() {
 }
 
@@ -1484,16 +1502,11 @@ class GetDataLakeExceptionSubscriptionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "GetDataLakeExceptionSubscription", {})
     .n("SecurityLakeClient", "GetDataLakeExceptionSubscriptionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataLakeExceptionSubscriptionCommand)
-    .de(de_GetDataLakeExceptionSubscriptionCommand)
+    .sc(GetDataLakeExceptionSubscription)
     .build() {
 }
 
@@ -1501,16 +1514,11 @@ class GetDataLakeOrganizationConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "GetDataLakeOrganizationConfiguration", {})
     .n("SecurityLakeClient", "GetDataLakeOrganizationConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataLakeOrganizationConfigurationCommand)
-    .de(de_GetDataLakeOrganizationConfigurationCommand)
+    .sc(GetDataLakeOrganizationConfiguration)
     .build() {
 }
 
@@ -1518,16 +1526,11 @@ class GetDataLakeSourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "GetDataLakeSources", {})
     .n("SecurityLakeClient", "GetDataLakeSourcesCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataLakeSourcesCommand)
-    .de(de_GetDataLakeSourcesCommand)
+    .sc(GetDataLakeSources)
     .build() {
 }
 
@@ -1535,16 +1538,11 @@ class GetSubscriberCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "GetSubscriber", {})
     .n("SecurityLakeClient", "GetSubscriberCommand")
-    .f(void 0, void 0)
-    .ser(se_GetSubscriberCommand)
-    .de(de_GetSubscriberCommand)
+    .sc(GetSubscriber)
     .build() {
 }
 
@@ -1552,16 +1550,11 @@ class ListDataLakeExceptionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "ListDataLakeExceptions", {})
     .n("SecurityLakeClient", "ListDataLakeExceptionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataLakeExceptionsCommand)
-    .de(de_ListDataLakeExceptionsCommand)
+    .sc(ListDataLakeExceptions)
     .build() {
 }
 
@@ -1569,16 +1562,11 @@ class ListDataLakesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "ListDataLakes", {})
     .n("SecurityLakeClient", "ListDataLakesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDataLakesCommand)
-    .de(de_ListDataLakesCommand)
+    .sc(ListDataLakes)
     .build() {
 }
 
@@ -1586,16 +1574,11 @@ class ListLogSourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "ListLogSources", {})
     .n("SecurityLakeClient", "ListLogSourcesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListLogSourcesCommand)
-    .de(de_ListLogSourcesCommand)
+    .sc(ListLogSources)
     .build() {
 }
 
@@ -1603,16 +1586,11 @@ class ListSubscribersCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "ListSubscribers", {})
     .n("SecurityLakeClient", "ListSubscribersCommand")
-    .f(void 0, void 0)
-    .ser(se_ListSubscribersCommand)
-    .de(de_ListSubscribersCommand)
+    .sc(ListSubscribers)
     .build() {
 }
 
@@ -1620,16 +1598,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "ListTagsForResource", {})
     .n("SecurityLakeClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1637,16 +1610,11 @@ class RegisterDataLakeDelegatedAdministratorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "RegisterDataLakeDelegatedAdministrator", {})
     .n("SecurityLakeClient", "RegisterDataLakeDelegatedAdministratorCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterDataLakeDelegatedAdministratorCommand)
-    .de(de_RegisterDataLakeDelegatedAdministratorCommand)
+    .sc(RegisterDataLakeDelegatedAdministrator)
     .build() {
 }
 
@@ -1654,16 +1622,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "TagResource", {})
     .n("SecurityLakeClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1671,16 +1634,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "UntagResource", {})
     .n("SecurityLakeClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1688,16 +1646,11 @@ class UpdateDataLakeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "UpdateDataLake", {})
     .n("SecurityLakeClient", "UpdateDataLakeCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataLakeCommand)
-    .de(de_UpdateDataLakeCommand)
+    .sc(UpdateDataLake)
     .build() {
 }
 
@@ -1705,16 +1658,11 @@ class UpdateDataLakeExceptionSubscriptionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "UpdateDataLakeExceptionSubscription", {})
     .n("SecurityLakeClient", "UpdateDataLakeExceptionSubscriptionCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataLakeExceptionSubscriptionCommand)
-    .de(de_UpdateDataLakeExceptionSubscriptionCommand)
+    .sc(UpdateDataLakeExceptionSubscription)
     .build() {
 }
 
@@ -1722,16 +1670,11 @@ class UpdateSubscriberCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "UpdateSubscriber", {})
     .n("SecurityLakeClient", "UpdateSubscriberCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateSubscriberCommand)
-    .de(de_UpdateSubscriberCommand)
+    .sc(UpdateSubscriber)
     .build() {
 }
 
@@ -1739,16 +1682,11 @@ class UpdateSubscriberNotificationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SecurityLake", "UpdateSubscriberNotification", {})
     .n("SecurityLakeClient", "UpdateSubscriberNotificationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateSubscriberNotificationCommand)
-    .de(de_UpdateSubscriberNotificationCommand)
+    .sc(UpdateSubscriberNotification)
     .build() {
 }
 
@@ -1805,11 +1743,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AccessType = AccessType;
 exports.AwsLogSourceName = AwsLogSourceName;
-exports.BadRequestException = BadRequestException;
-exports.ConflictException = ConflictException;
+exports.BadRequestException = BadRequestException$1;
+exports.ConflictException = ConflictException$1;
 exports.CreateAwsLogSourceCommand = CreateAwsLogSourceCommand;
 exports.CreateCustomLogSourceCommand = CreateCustomLogSourceCommand;
 exports.CreateDataLakeCommand = CreateDataLakeCommand;
@@ -1831,21 +1769,21 @@ exports.GetDataLakeOrganizationConfigurationCommand = GetDataLakeOrganizationCon
 exports.GetDataLakeSourcesCommand = GetDataLakeSourcesCommand;
 exports.GetSubscriberCommand = GetSubscriberCommand;
 exports.HttpMethod = HttpMethod;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListDataLakeExceptionsCommand = ListDataLakeExceptionsCommand;
 exports.ListDataLakesCommand = ListDataLakesCommand;
 exports.ListLogSourcesCommand = ListLogSourcesCommand;
 exports.ListSubscribersCommand = ListSubscribersCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.RegisterDataLakeDelegatedAdministratorCommand = RegisterDataLakeDelegatedAdministratorCommand;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SecurityLake = SecurityLake;
 exports.SecurityLakeClient = SecurityLakeClient;
-exports.SecurityLakeServiceException = SecurityLakeServiceException;
+exports.SecurityLakeServiceException = SecurityLakeServiceException$1;
 exports.SourceCollectionStatus = SourceCollectionStatus;
 exports.SubscriberStatus = SubscriberStatus;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateDataLakeCommand = UpdateDataLakeCommand;
 exports.UpdateDataLakeExceptionSubscriptionCommand = UpdateDataLakeExceptionSubscriptionCommand;