@aws-sdk/client-securitylake 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3067 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecurityLakeServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SecurityLakeClient"), exports);
-tslib_1.__exportStar(require("./SecurityLake"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SecurityLakeServiceException_1 = require("./models/SecurityLakeServiceException");
-Object.defineProperty(exports, "SecurityLakeServiceException", { enumerable: true, get: function () { return SecurityLakeServiceException_1.SecurityLakeServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  AccessType: () => AccessType,
+  AwsLogSourceName: () => AwsLogSourceName,
+  BadRequestException: () => BadRequestException,
+  ConflictException: () => ConflictException,
+  CreateAwsLogSourceCommand: () => CreateAwsLogSourceCommand,
+  CreateCustomLogSourceCommand: () => CreateCustomLogSourceCommand,
+  CreateDataLakeCommand: () => CreateDataLakeCommand,
+  CreateDataLakeExceptionSubscriptionCommand: () => CreateDataLakeExceptionSubscriptionCommand,
+  CreateDataLakeOrganizationConfigurationCommand: () => CreateDataLakeOrganizationConfigurationCommand,
+  CreateSubscriberCommand: () => CreateSubscriberCommand,
+  CreateSubscriberNotificationCommand: () => CreateSubscriberNotificationCommand,
+  DataLakeStatus: () => DataLakeStatus,
+  DeleteAwsLogSourceCommand: () => DeleteAwsLogSourceCommand,
+  DeleteCustomLogSourceCommand: () => DeleteCustomLogSourceCommand,
+  DeleteDataLakeCommand: () => DeleteDataLakeCommand,
+  DeleteDataLakeExceptionSubscriptionCommand: () => DeleteDataLakeExceptionSubscriptionCommand,
+  DeleteDataLakeOrganizationConfigurationCommand: () => DeleteDataLakeOrganizationConfigurationCommand,
+  DeleteSubscriberCommand: () => DeleteSubscriberCommand,
+  DeleteSubscriberNotificationCommand: () => DeleteSubscriberNotificationCommand,
+  DeregisterDataLakeDelegatedAdministratorCommand: () => DeregisterDataLakeDelegatedAdministratorCommand,
+  GetDataLakeExceptionSubscriptionCommand: () => GetDataLakeExceptionSubscriptionCommand,
+  GetDataLakeOrganizationConfigurationCommand: () => GetDataLakeOrganizationConfigurationCommand,
+  GetDataLakeSourcesCommand: () => GetDataLakeSourcesCommand,
+  GetSubscriberCommand: () => GetSubscriberCommand,
+  HttpMethod: () => HttpMethod,
+  InternalServerException: () => InternalServerException,
+  ListDataLakeExceptionsCommand: () => ListDataLakeExceptionsCommand,
+  ListDataLakesCommand: () => ListDataLakesCommand,
+  ListLogSourcesCommand: () => ListLogSourcesCommand,
+  ListSubscribersCommand: () => ListSubscribersCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LogSourceResource: () => LogSourceResource,
+  NotificationConfiguration: () => NotificationConfiguration,
+  RegisterDataLakeDelegatedAdministratorCommand: () => RegisterDataLakeDelegatedAdministratorCommand,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SecurityLake: () => SecurityLake,
+  SecurityLakeClient: () => SecurityLakeClient,
+  SecurityLakeServiceException: () => SecurityLakeServiceException,
+  SourceCollectionStatus: () => SourceCollectionStatus,
+  SubscriberStatus: () => SubscriberStatus,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateDataLakeCommand: () => UpdateDataLakeCommand,
+  UpdateDataLakeExceptionSubscriptionCommand: () => UpdateDataLakeExceptionSubscriptionCommand,
+  UpdateSubscriberCommand: () => UpdateSubscriberCommand,
+  UpdateSubscriberNotificationCommand: () => UpdateSubscriberNotificationCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateGetDataLakeSources: () => paginateGetDataLakeSources,
+  paginateListDataLakeExceptions: () => paginateListDataLakeExceptions,
+  paginateListLogSources: () => paginateListLogSources,
+  paginateListSubscribers: () => paginateListSubscribers
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SecurityLakeClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "securitylake"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SecurityLakeClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/SecurityLakeClient.ts
+var _SecurityLakeClient = class _SecurityLakeClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_SecurityLakeClient, "SecurityLakeClient");
+var SecurityLakeClient = _SecurityLakeClient;
+
+// src/SecurityLake.ts
+
+
+// src/commands/CreateAwsLogSourceCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+
+// src/models/SecurityLakeServiceException.ts
+
+var _SecurityLakeServiceException = class _SecurityLakeServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SecurityLakeServiceException.prototype);
+  }
+};
+__name(_SecurityLakeServiceException, "SecurityLakeServiceException");
+var SecurityLakeServiceException = _SecurityLakeServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.errorCode = opts.errorCode;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var AccessType = {
+  LAKEFORMATION: "LAKEFORMATION",
+  S3: "S3"
+};
+var AwsLogSourceName = {
+  CLOUD_TRAIL_MGMT: "CLOUD_TRAIL_MGMT",
+  LAMBDA_EXECUTION: "LAMBDA_EXECUTION",
+  ROUTE53: "ROUTE53",
+  S3_DATA: "S3_DATA",
+  SH_FINDINGS: "SH_FINDINGS",
+  VPC_FLOW: "VPC_FLOW"
+};
+var _BadRequestException = class _BadRequestException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var _ConflictException = class _ConflictException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.resourceName = opts.resourceName;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.resourceName = opts.resourceName;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends SecurityLakeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    this.$retryable = {
+      throttling: true
+    };
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+    this.retryAfterSeconds = opts.retryAfterSeconds;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var DataLakeStatus = {
+  COMPLETED: "COMPLETED",
+  FAILED: "FAILED",
+  INITIALIZED: "INITIALIZED",
+  PENDING: "PENDING"
+};
+var LogSourceResource;
+((LogSourceResource3) => {
+  LogSourceResource3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.awsLogSource !== void 0)
+      return visitor.awsLogSource(value.awsLogSource);
+    if (value.customLogSource !== void 0)
+      return visitor.customLogSource(value.customLogSource);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(LogSourceResource || (LogSourceResource = {}));
+var SubscriberStatus = {
+  ACTIVE: "ACTIVE",
+  DEACTIVATED: "DEACTIVATED",
+  PENDING: "PENDING",
+  READY: "READY"
+};
+var HttpMethod = {
+  POST: "POST",
+  PUT: "PUT"
+};
+var NotificationConfiguration;
+((NotificationConfiguration3) => {
+  NotificationConfiguration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.sqsNotificationConfiguration !== void 0)
+      return visitor.sqsNotificationConfiguration(value.sqsNotificationConfiguration);
+    if (value.httpsNotificationConfiguration !== void 0)
+      return visitor.httpsNotificationConfiguration(value.httpsNotificationConfiguration);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(NotificationConfiguration || (NotificationConfiguration = {}));
+var SourceCollectionStatus = {
+  COLLECTING: "COLLECTING",
+  MISCONFIGURED: "MISCONFIGURED",
+  NOT_COLLECTING: "NOT_COLLECTING"
+};
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateAwsLogSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/logsources/aws");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      sources: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateAwsLogSourceCommand");
+var se_CreateCustomLogSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/logsources/custom");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      configuration: (_) => (0, import_smithy_client._json)(_),
+      eventClasses: (_) => (0, import_smithy_client._json)(_),
+      sourceName: [],
+      sourceVersion: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCustomLogSourceCommand");
+var se_CreateDataLakeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      configurations: (_) => (0, import_smithy_client._json)(_),
+      metaStoreManagerRoleArn: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateDataLakeCommand");
+var se_CreateDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/exceptions/subscription");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      exceptionTimeToLive: [],
+      notificationEndpoint: [],
+      subscriptionProtocol: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateDataLakeExceptionSubscriptionCommand");
+var se_CreateDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/organization/configuration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      autoEnableNewAccount: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateDataLakeOrganizationConfigurationCommand");
+var se_CreateSubscriberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/subscribers");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accessTypes: (_) => (0, import_smithy_client._json)(_),
+      sources: (_) => (0, import_smithy_client._json)(_),
+      subscriberDescription: [],
+      subscriberIdentity: (_) => (0, import_smithy_client._json)(_),
+      subscriberName: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSubscriberCommand");
+var se_CreateSubscriberNotificationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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(
+    (0, import_smithy_client.take)(input, {
+      configuration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSubscriberNotificationCommand");
+var se_DeleteAwsLogSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/logsources/aws/delete");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      sources: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteAwsLogSourceCommand");
+var se_DeleteCustomLogSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/datalake/logsources/custom/{sourceName}");
+  b.p("sourceName", () => input.sourceName, "{sourceName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_sV]: [, input[_sV]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteCustomLogSourceCommand");
+var se_DeleteDataLakeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/delete");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      regions: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteDataLakeCommand");
+var se_DeleteDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/exceptions/subscription");
+  let body;
+  body = "";
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteDataLakeExceptionSubscriptionCommand");
+var se_DeleteDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/organization/configuration/delete");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      autoEnableNewAccount: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteDataLakeOrganizationConfigurationCommand");
+var se_DeleteSubscriberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_DeleteSubscriberCommand");
+var se_DeleteSubscriberNotificationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_DeleteSubscriberNotificationCommand");
+var se_DeregisterDataLakeDelegatedAdministratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/delegate");
+  let body;
+  body = "";
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeregisterDataLakeDelegatedAdministratorCommand");
+var se_GetDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/exceptions/subscription");
+  let body;
+  body = "";
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetDataLakeExceptionSubscriptionCommand");
+var se_GetDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/organization/configuration");
+  let body;
+  body = "";
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetDataLakeOrganizationConfigurationCommand");
+var se_GetDataLakeSourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/sources");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accounts: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetDataLakeSourcesCommand");
+var se_GetSubscriberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_GetSubscriberCommand");
+var se_ListDataLakeExceptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/exceptions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: [],
+      regions: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListDataLakeExceptionsCommand");
+var se_ListDataLakesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/datalakes");
+  const query = (0, import_smithy_client.map)({
+    [_r]: [() => input.regions !== void 0, () => (input[_r] || []).map((_entry) => _entry)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListDataLakesCommand");
+var se_ListLogSourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/logsources/list");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accounts: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: [],
+      regions: (_) => (0, import_smithy_client._json)(_),
+      sources: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListLogSourcesCommand");
+var se_ListSubscribersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/subscribers");
+  const query = (0, import_smithy_client.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();
+}, "se_ListSubscribersCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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();
+}, "se_ListTagsForResourceCommand");
+var se_RegisterDataLakeDelegatedAdministratorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/delegate");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      accountId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_RegisterDataLakeDelegatedAdministratorCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v1/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateDataLakeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      configurations: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateDataLakeCommand");
+var se_UpdateDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v1/datalake/exceptions/subscription");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      exceptionTimeToLive: [],
+      notificationEndpoint: [],
+      subscriptionProtocol: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateDataLakeExceptionSubscriptionCommand");
+var se_UpdateSubscriberCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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(
+    (0, import_smithy_client.take)(input, {
+      sources: (_) => (0, import_smithy_client._json)(_),
+      subscriberDescription: [],
+      subscriberIdentity: (_) => (0, import_smithy_client._json)(_),
+      subscriberName: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateSubscriberCommand");
+var se_UpdateSubscriberNotificationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_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(
+    (0, import_smithy_client.take)(input, {
+      configuration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateSubscriberNotificationCommand");
+var de_CreateAwsLogSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateAwsLogSourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    failed: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateAwsLogSourceCommand");
+var de_CreateAwsLogSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAwsLogSourceCommandError");
+var de_CreateCustomLogSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateCustomLogSourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    source: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCustomLogSourceCommand");
+var de_CreateCustomLogSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCustomLogSourceCommandError");
+var de_CreateDataLakeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateDataLakeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    dataLakes: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateDataLakeCommand");
+var de_CreateDataLakeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataLakeCommandError");
+var de_CreateDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateDataLakeExceptionSubscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateDataLakeExceptionSubscriptionCommand");
+var de_CreateDataLakeExceptionSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataLakeExceptionSubscriptionCommandError");
+var de_CreateDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateDataLakeOrganizationConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateDataLakeOrganizationConfigurationCommand");
+var de_CreateDataLakeOrganizationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataLakeOrganizationConfigurationCommandError");
+var de_CreateSubscriberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateSubscriberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    subscriber: (_) => de_SubscriberResource(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSubscriberCommand");
+var de_CreateSubscriberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSubscriberCommandError");
+var de_CreateSubscriberNotificationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateSubscriberNotificationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    subscriberEndpoint: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSubscriberNotificationCommand");
+var de_CreateSubscriberNotificationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSubscriberNotificationCommandError");
+var de_DeleteAwsLogSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteAwsLogSourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    failed: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DeleteAwsLogSourceCommand");
+var de_DeleteAwsLogSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAwsLogSourceCommandError");
+var de_DeleteCustomLogSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteCustomLogSourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCustomLogSourceCommand");
+var de_DeleteCustomLogSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteCustomLogSourceCommandError");
+var de_DeleteDataLakeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteDataLakeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteDataLakeCommand");
+var de_DeleteDataLakeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDataLakeCommandError");
+var de_DeleteDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteDataLakeExceptionSubscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteDataLakeExceptionSubscriptionCommand");
+var de_DeleteDataLakeExceptionSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDataLakeExceptionSubscriptionCommandError");
+var de_DeleteDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteDataLakeOrganizationConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteDataLakeOrganizationConfigurationCommand");
+var de_DeleteDataLakeOrganizationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDataLakeOrganizationConfigurationCommandError");
+var de_DeleteSubscriberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteSubscriberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSubscriberCommand");
+var de_DeleteSubscriberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSubscriberCommandError");
+var de_DeleteSubscriberNotificationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteSubscriberNotificationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSubscriberNotificationCommand");
+var de_DeleteSubscriberNotificationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSubscriberNotificationCommandError");
+var de_DeregisterDataLakeDelegatedAdministratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeregisterDataLakeDelegatedAdministratorCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeregisterDataLakeDelegatedAdministratorCommand");
+var de_DeregisterDataLakeDelegatedAdministratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeregisterDataLakeDelegatedAdministratorCommandError");
+var de_GetDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDataLakeExceptionSubscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionTimeToLive: import_smithy_client.expectLong,
+    notificationEndpoint: import_smithy_client.expectString,
+    subscriptionProtocol: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDataLakeExceptionSubscriptionCommand");
+var de_GetDataLakeExceptionSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDataLakeExceptionSubscriptionCommandError");
+var de_GetDataLakeOrganizationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDataLakeOrganizationConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    autoEnableNewAccount: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDataLakeOrganizationConfigurationCommand");
+var de_GetDataLakeOrganizationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDataLakeOrganizationConfigurationCommandError");
+var de_GetDataLakeSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetDataLakeSourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    dataLakeArn: import_smithy_client.expectString,
+    dataLakeSources: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetDataLakeSourcesCommand");
+var de_GetDataLakeSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDataLakeSourcesCommandError");
+var de_GetSubscriberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetSubscriberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    subscriber: (_) => de_SubscriberResource(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetSubscriberCommand");
+var de_GetSubscriberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetSubscriberCommandError");
+var de_ListDataLakeExceptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListDataLakeExceptionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptions: (_) => de_DataLakeExceptionList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListDataLakeExceptionsCommand");
+var de_ListDataLakeExceptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDataLakeExceptionsCommandError");
+var de_ListDataLakesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListDataLakesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    dataLakes: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListDataLakesCommand");
+var de_ListDataLakesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDataLakesCommandError");
+var de_ListLogSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListLogSourcesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    sources: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListLogSourcesCommand");
+var de_ListLogSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListLogSourcesCommandError");
+var de_ListSubscribersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListSubscribersCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    subscribers: (_) => de_SubscriberResourceList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSubscribersCommand");
+var de_ListSubscribersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListSubscribersCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_RegisterDataLakeDelegatedAdministratorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_RegisterDataLakeDelegatedAdministratorCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_RegisterDataLakeDelegatedAdministratorCommand");
+var de_RegisterDataLakeDelegatedAdministratorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterDataLakeDelegatedAdministratorCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateDataLakeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateDataLakeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    dataLakes: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateDataLakeCommand");
+var de_UpdateDataLakeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDataLakeCommandError");
+var de_UpdateDataLakeExceptionSubscriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateDataLakeExceptionSubscriptionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateDataLakeExceptionSubscriptionCommand");
+var de_UpdateDataLakeExceptionSubscriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDataLakeExceptionSubscriptionCommandError");
+var de_UpdateSubscriberCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateSubscriberCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    subscriber: (_) => de_SubscriberResource(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateSubscriberCommand");
+var de_UpdateSubscriberCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSubscriberCommandError");
+var de_UpdateSubscriberNotificationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateSubscriberNotificationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    subscriberEndpoint: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateSubscriberNotificationCommand");
+var de_UpdateSubscriberNotificationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.securitylake#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "BadRequestException":
+    case "com.amazonaws.securitylake#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.securitylake#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.securitylake#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.securitylake#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.securitylake#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSubscriberNotificationCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SecurityLakeServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    errorCode: import_smithy_client.expectString,
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceName: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceName: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({
+    [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => (0, import_smithy_client.strictParseInt32)(parsedOutput.headers[_ra])]
+  });
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    quotaCode: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_DataLakeException = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    exception: import_smithy_client.expectString,
+    region: import_smithy_client.expectString,
+    remediation: import_smithy_client.expectString,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_DataLakeException");
+var de_DataLakeExceptionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_DataLakeException(entry, context);
+  });
+  return retVal;
+}, "de_DataLakeExceptionList");
+var de_SubscriberResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    accessTypes: import_smithy_client._json,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    resourceShareArn: import_smithy_client.expectString,
+    resourceShareName: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    s3BucketArn: import_smithy_client.expectString,
+    sources: import_smithy_client._json,
+    subscriberArn: import_smithy_client.expectString,
+    subscriberDescription: import_smithy_client.expectString,
+    subscriberEndpoint: import_smithy_client.expectString,
+    subscriberId: import_smithy_client.expectString,
+    subscriberIdentity: import_smithy_client._json,
+    subscriberName: import_smithy_client.expectString,
+    subscriberStatus: import_smithy_client.expectString,
+    updatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_SubscriberResource");
+var de_SubscriberResourceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SubscriberResource(entry, context);
+  });
+  return retVal;
+}, "de_SubscriberResourceList");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _mR = "maxResults";
+var _nT = "nextToken";
+var _r = "regions";
+var _rAS = "retryAfterSeconds";
+var _ra = "retry-after";
+var _sV = "sourceVersion";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateAwsLogSourceCommand.ts
+var _CreateAwsLogSourceCommand = class _CreateAwsLogSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateAwsLogSource", {}).n("SecurityLakeClient", "CreateAwsLogSourceCommand").f(void 0, void 0).ser(se_CreateAwsLogSourceCommand).de(de_CreateAwsLogSourceCommand).build() {
+};
+__name(_CreateAwsLogSourceCommand, "CreateAwsLogSourceCommand");
+var CreateAwsLogSourceCommand = _CreateAwsLogSourceCommand;
+
+// src/commands/CreateCustomLogSourceCommand.ts
+
+
+
+
+var _CreateCustomLogSourceCommand = class _CreateCustomLogSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateCustomLogSource", {}).n("SecurityLakeClient", "CreateCustomLogSourceCommand").f(void 0, void 0).ser(se_CreateCustomLogSourceCommand).de(de_CreateCustomLogSourceCommand).build() {
+};
+__name(_CreateCustomLogSourceCommand, "CreateCustomLogSourceCommand");
+var CreateCustomLogSourceCommand = _CreateCustomLogSourceCommand;
+
+// src/commands/CreateDataLakeCommand.ts
+
+
+
+
+var _CreateDataLakeCommand = class _CreateDataLakeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateDataLake", {}).n("SecurityLakeClient", "CreateDataLakeCommand").f(void 0, void 0).ser(se_CreateDataLakeCommand).de(de_CreateDataLakeCommand).build() {
+};
+__name(_CreateDataLakeCommand, "CreateDataLakeCommand");
+var CreateDataLakeCommand = _CreateDataLakeCommand;
+
+// src/commands/CreateDataLakeExceptionSubscriptionCommand.ts
+
+
+
+
+var _CreateDataLakeExceptionSubscriptionCommand = class _CreateDataLakeExceptionSubscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateDataLakeExceptionSubscription", {}).n("SecurityLakeClient", "CreateDataLakeExceptionSubscriptionCommand").f(void 0, void 0).ser(se_CreateDataLakeExceptionSubscriptionCommand).de(de_CreateDataLakeExceptionSubscriptionCommand).build() {
+};
+__name(_CreateDataLakeExceptionSubscriptionCommand, "CreateDataLakeExceptionSubscriptionCommand");
+var CreateDataLakeExceptionSubscriptionCommand = _CreateDataLakeExceptionSubscriptionCommand;
+
+// src/commands/CreateDataLakeOrganizationConfigurationCommand.ts
+
+
+
+
+var _CreateDataLakeOrganizationConfigurationCommand = class _CreateDataLakeOrganizationConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateDataLakeOrganizationConfiguration", {}).n("SecurityLakeClient", "CreateDataLakeOrganizationConfigurationCommand").f(void 0, void 0).ser(se_CreateDataLakeOrganizationConfigurationCommand).de(de_CreateDataLakeOrganizationConfigurationCommand).build() {
+};
+__name(_CreateDataLakeOrganizationConfigurationCommand, "CreateDataLakeOrganizationConfigurationCommand");
+var CreateDataLakeOrganizationConfigurationCommand = _CreateDataLakeOrganizationConfigurationCommand;
+
+// src/commands/CreateSubscriberCommand.ts
+
+
+
+
+var _CreateSubscriberCommand = class _CreateSubscriberCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateSubscriber", {}).n("SecurityLakeClient", "CreateSubscriberCommand").f(void 0, void 0).ser(se_CreateSubscriberCommand).de(de_CreateSubscriberCommand).build() {
+};
+__name(_CreateSubscriberCommand, "CreateSubscriberCommand");
+var CreateSubscriberCommand = _CreateSubscriberCommand;
+
+// src/commands/CreateSubscriberNotificationCommand.ts
+
+
+
+
+var _CreateSubscriberNotificationCommand = class _CreateSubscriberNotificationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "CreateSubscriberNotification", {}).n("SecurityLakeClient", "CreateSubscriberNotificationCommand").f(void 0, void 0).ser(se_CreateSubscriberNotificationCommand).de(de_CreateSubscriberNotificationCommand).build() {
+};
+__name(_CreateSubscriberNotificationCommand, "CreateSubscriberNotificationCommand");
+var CreateSubscriberNotificationCommand = _CreateSubscriberNotificationCommand;
+
+// src/commands/DeleteAwsLogSourceCommand.ts
+
+
+
+
+var _DeleteAwsLogSourceCommand = class _DeleteAwsLogSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteAwsLogSource", {}).n("SecurityLakeClient", "DeleteAwsLogSourceCommand").f(void 0, void 0).ser(se_DeleteAwsLogSourceCommand).de(de_DeleteAwsLogSourceCommand).build() {
+};
+__name(_DeleteAwsLogSourceCommand, "DeleteAwsLogSourceCommand");
+var DeleteAwsLogSourceCommand = _DeleteAwsLogSourceCommand;
+
+// src/commands/DeleteCustomLogSourceCommand.ts
+
+
+
+
+var _DeleteCustomLogSourceCommand = class _DeleteCustomLogSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteCustomLogSource", {}).n("SecurityLakeClient", "DeleteCustomLogSourceCommand").f(void 0, void 0).ser(se_DeleteCustomLogSourceCommand).de(de_DeleteCustomLogSourceCommand).build() {
+};
+__name(_DeleteCustomLogSourceCommand, "DeleteCustomLogSourceCommand");
+var DeleteCustomLogSourceCommand = _DeleteCustomLogSourceCommand;
+
+// src/commands/DeleteDataLakeCommand.ts
+
+
+
+
+var _DeleteDataLakeCommand = class _DeleteDataLakeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteDataLake", {}).n("SecurityLakeClient", "DeleteDataLakeCommand").f(void 0, void 0).ser(se_DeleteDataLakeCommand).de(de_DeleteDataLakeCommand).build() {
+};
+__name(_DeleteDataLakeCommand, "DeleteDataLakeCommand");
+var DeleteDataLakeCommand = _DeleteDataLakeCommand;
+
+// src/commands/DeleteDataLakeExceptionSubscriptionCommand.ts
+
+
+
+
+var _DeleteDataLakeExceptionSubscriptionCommand = class _DeleteDataLakeExceptionSubscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteDataLakeExceptionSubscription", {}).n("SecurityLakeClient", "DeleteDataLakeExceptionSubscriptionCommand").f(void 0, void 0).ser(se_DeleteDataLakeExceptionSubscriptionCommand).de(de_DeleteDataLakeExceptionSubscriptionCommand).build() {
+};
+__name(_DeleteDataLakeExceptionSubscriptionCommand, "DeleteDataLakeExceptionSubscriptionCommand");
+var DeleteDataLakeExceptionSubscriptionCommand = _DeleteDataLakeExceptionSubscriptionCommand;
+
+// src/commands/DeleteDataLakeOrganizationConfigurationCommand.ts
+
+
+
+
+var _DeleteDataLakeOrganizationConfigurationCommand = class _DeleteDataLakeOrganizationConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteDataLakeOrganizationConfiguration", {}).n("SecurityLakeClient", "DeleteDataLakeOrganizationConfigurationCommand").f(void 0, void 0).ser(se_DeleteDataLakeOrganizationConfigurationCommand).de(de_DeleteDataLakeOrganizationConfigurationCommand).build() {
+};
+__name(_DeleteDataLakeOrganizationConfigurationCommand, "DeleteDataLakeOrganizationConfigurationCommand");
+var DeleteDataLakeOrganizationConfigurationCommand = _DeleteDataLakeOrganizationConfigurationCommand;
+
+// src/commands/DeleteSubscriberCommand.ts
+
+
+
+
+var _DeleteSubscriberCommand = class _DeleteSubscriberCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteSubscriber", {}).n("SecurityLakeClient", "DeleteSubscriberCommand").f(void 0, void 0).ser(se_DeleteSubscriberCommand).de(de_DeleteSubscriberCommand).build() {
+};
+__name(_DeleteSubscriberCommand, "DeleteSubscriberCommand");
+var DeleteSubscriberCommand = _DeleteSubscriberCommand;
+
+// src/commands/DeleteSubscriberNotificationCommand.ts
+
+
+
+
+var _DeleteSubscriberNotificationCommand = class _DeleteSubscriberNotificationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeleteSubscriberNotification", {}).n("SecurityLakeClient", "DeleteSubscriberNotificationCommand").f(void 0, void 0).ser(se_DeleteSubscriberNotificationCommand).de(de_DeleteSubscriberNotificationCommand).build() {
+};
+__name(_DeleteSubscriberNotificationCommand, "DeleteSubscriberNotificationCommand");
+var DeleteSubscriberNotificationCommand = _DeleteSubscriberNotificationCommand;
+
+// src/commands/DeregisterDataLakeDelegatedAdministratorCommand.ts
+
+
+
+
+var _DeregisterDataLakeDelegatedAdministratorCommand = class _DeregisterDataLakeDelegatedAdministratorCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "DeregisterDataLakeDelegatedAdministrator", {}).n("SecurityLakeClient", "DeregisterDataLakeDelegatedAdministratorCommand").f(void 0, void 0).ser(se_DeregisterDataLakeDelegatedAdministratorCommand).de(de_DeregisterDataLakeDelegatedAdministratorCommand).build() {
+};
+__name(_DeregisterDataLakeDelegatedAdministratorCommand, "DeregisterDataLakeDelegatedAdministratorCommand");
+var DeregisterDataLakeDelegatedAdministratorCommand = _DeregisterDataLakeDelegatedAdministratorCommand;
+
+// src/commands/GetDataLakeExceptionSubscriptionCommand.ts
+
+
+
+
+var _GetDataLakeExceptionSubscriptionCommand = class _GetDataLakeExceptionSubscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "GetDataLakeExceptionSubscription", {}).n("SecurityLakeClient", "GetDataLakeExceptionSubscriptionCommand").f(void 0, void 0).ser(se_GetDataLakeExceptionSubscriptionCommand).de(de_GetDataLakeExceptionSubscriptionCommand).build() {
+};
+__name(_GetDataLakeExceptionSubscriptionCommand, "GetDataLakeExceptionSubscriptionCommand");
+var GetDataLakeExceptionSubscriptionCommand = _GetDataLakeExceptionSubscriptionCommand;
+
+// src/commands/GetDataLakeOrganizationConfigurationCommand.ts
+
+
+
+
+var _GetDataLakeOrganizationConfigurationCommand = class _GetDataLakeOrganizationConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "GetDataLakeOrganizationConfiguration", {}).n("SecurityLakeClient", "GetDataLakeOrganizationConfigurationCommand").f(void 0, void 0).ser(se_GetDataLakeOrganizationConfigurationCommand).de(de_GetDataLakeOrganizationConfigurationCommand).build() {
+};
+__name(_GetDataLakeOrganizationConfigurationCommand, "GetDataLakeOrganizationConfigurationCommand");
+var GetDataLakeOrganizationConfigurationCommand = _GetDataLakeOrganizationConfigurationCommand;
+
+// src/commands/GetDataLakeSourcesCommand.ts
+
+
+
+
+var _GetDataLakeSourcesCommand = class _GetDataLakeSourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "GetDataLakeSources", {}).n("SecurityLakeClient", "GetDataLakeSourcesCommand").f(void 0, void 0).ser(se_GetDataLakeSourcesCommand).de(de_GetDataLakeSourcesCommand).build() {
+};
+__name(_GetDataLakeSourcesCommand, "GetDataLakeSourcesCommand");
+var GetDataLakeSourcesCommand = _GetDataLakeSourcesCommand;
+
+// src/commands/GetSubscriberCommand.ts
+
+
+
+
+var _GetSubscriberCommand = class _GetSubscriberCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "GetSubscriber", {}).n("SecurityLakeClient", "GetSubscriberCommand").f(void 0, void 0).ser(se_GetSubscriberCommand).de(de_GetSubscriberCommand).build() {
+};
+__name(_GetSubscriberCommand, "GetSubscriberCommand");
+var GetSubscriberCommand = _GetSubscriberCommand;
+
+// src/commands/ListDataLakeExceptionsCommand.ts
+
+
+
+
+var _ListDataLakeExceptionsCommand = class _ListDataLakeExceptionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "ListDataLakeExceptions", {}).n("SecurityLakeClient", "ListDataLakeExceptionsCommand").f(void 0, void 0).ser(se_ListDataLakeExceptionsCommand).de(de_ListDataLakeExceptionsCommand).build() {
+};
+__name(_ListDataLakeExceptionsCommand, "ListDataLakeExceptionsCommand");
+var ListDataLakeExceptionsCommand = _ListDataLakeExceptionsCommand;
+
+// src/commands/ListDataLakesCommand.ts
+
+
+
+
+var _ListDataLakesCommand = class _ListDataLakesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "ListDataLakes", {}).n("SecurityLakeClient", "ListDataLakesCommand").f(void 0, void 0).ser(se_ListDataLakesCommand).de(de_ListDataLakesCommand).build() {
+};
+__name(_ListDataLakesCommand, "ListDataLakesCommand");
+var ListDataLakesCommand = _ListDataLakesCommand;
+
+// src/commands/ListLogSourcesCommand.ts
+
+
+
+
+var _ListLogSourcesCommand = class _ListLogSourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "ListLogSources", {}).n("SecurityLakeClient", "ListLogSourcesCommand").f(void 0, void 0).ser(se_ListLogSourcesCommand).de(de_ListLogSourcesCommand).build() {
+};
+__name(_ListLogSourcesCommand, "ListLogSourcesCommand");
+var ListLogSourcesCommand = _ListLogSourcesCommand;
+
+// src/commands/ListSubscribersCommand.ts
+
+
+
+
+var _ListSubscribersCommand = class _ListSubscribersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "ListSubscribers", {}).n("SecurityLakeClient", "ListSubscribersCommand").f(void 0, void 0).ser(se_ListSubscribersCommand).de(de_ListSubscribersCommand).build() {
+};
+__name(_ListSubscribersCommand, "ListSubscribersCommand");
+var ListSubscribersCommand = _ListSubscribersCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "ListTagsForResource", {}).n("SecurityLakeClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/RegisterDataLakeDelegatedAdministratorCommand.ts
+
+
+
+
+var _RegisterDataLakeDelegatedAdministratorCommand = class _RegisterDataLakeDelegatedAdministratorCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "RegisterDataLakeDelegatedAdministrator", {}).n("SecurityLakeClient", "RegisterDataLakeDelegatedAdministratorCommand").f(void 0, void 0).ser(se_RegisterDataLakeDelegatedAdministratorCommand).de(de_RegisterDataLakeDelegatedAdministratorCommand).build() {
+};
+__name(_RegisterDataLakeDelegatedAdministratorCommand, "RegisterDataLakeDelegatedAdministratorCommand");
+var RegisterDataLakeDelegatedAdministratorCommand = _RegisterDataLakeDelegatedAdministratorCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "TagResource", {}).n("SecurityLakeClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "UntagResource", {}).n("SecurityLakeClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateDataLakeCommand.ts
+
+
+
+
+var _UpdateDataLakeCommand = class _UpdateDataLakeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "UpdateDataLake", {}).n("SecurityLakeClient", "UpdateDataLakeCommand").f(void 0, void 0).ser(se_UpdateDataLakeCommand).de(de_UpdateDataLakeCommand).build() {
+};
+__name(_UpdateDataLakeCommand, "UpdateDataLakeCommand");
+var UpdateDataLakeCommand = _UpdateDataLakeCommand;
+
+// src/commands/UpdateDataLakeExceptionSubscriptionCommand.ts
+
+
+
+
+var _UpdateDataLakeExceptionSubscriptionCommand = class _UpdateDataLakeExceptionSubscriptionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "UpdateDataLakeExceptionSubscription", {}).n("SecurityLakeClient", "UpdateDataLakeExceptionSubscriptionCommand").f(void 0, void 0).ser(se_UpdateDataLakeExceptionSubscriptionCommand).de(de_UpdateDataLakeExceptionSubscriptionCommand).build() {
+};
+__name(_UpdateDataLakeExceptionSubscriptionCommand, "UpdateDataLakeExceptionSubscriptionCommand");
+var UpdateDataLakeExceptionSubscriptionCommand = _UpdateDataLakeExceptionSubscriptionCommand;
+
+// src/commands/UpdateSubscriberCommand.ts
+
+
+
+
+var _UpdateSubscriberCommand = class _UpdateSubscriberCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "UpdateSubscriber", {}).n("SecurityLakeClient", "UpdateSubscriberCommand").f(void 0, void 0).ser(se_UpdateSubscriberCommand).de(de_UpdateSubscriberCommand).build() {
+};
+__name(_UpdateSubscriberCommand, "UpdateSubscriberCommand");
+var UpdateSubscriberCommand = _UpdateSubscriberCommand;
+
+// src/commands/UpdateSubscriberNotificationCommand.ts
+
+
+
+
+var _UpdateSubscriberNotificationCommand = class _UpdateSubscriberNotificationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SecurityLake", "UpdateSubscriberNotification", {}).n("SecurityLakeClient", "UpdateSubscriberNotificationCommand").f(void 0, void 0).ser(se_UpdateSubscriberNotificationCommand).de(de_UpdateSubscriberNotificationCommand).build() {
+};
+__name(_UpdateSubscriberNotificationCommand, "UpdateSubscriberNotificationCommand");
+var UpdateSubscriberNotificationCommand = _UpdateSubscriberNotificationCommand;
+
+// src/SecurityLake.ts
+var commands = {
+  CreateAwsLogSourceCommand,
+  CreateCustomLogSourceCommand,
+  CreateDataLakeCommand,
+  CreateDataLakeExceptionSubscriptionCommand,
+  CreateDataLakeOrganizationConfigurationCommand,
+  CreateSubscriberCommand,
+  CreateSubscriberNotificationCommand,
+  DeleteAwsLogSourceCommand,
+  DeleteCustomLogSourceCommand,
+  DeleteDataLakeCommand,
+  DeleteDataLakeExceptionSubscriptionCommand,
+  DeleteDataLakeOrganizationConfigurationCommand,
+  DeleteSubscriberCommand,
+  DeleteSubscriberNotificationCommand,
+  DeregisterDataLakeDelegatedAdministratorCommand,
+  GetDataLakeExceptionSubscriptionCommand,
+  GetDataLakeOrganizationConfigurationCommand,
+  GetDataLakeSourcesCommand,
+  GetSubscriberCommand,
+  ListDataLakeExceptionsCommand,
+  ListDataLakesCommand,
+  ListLogSourcesCommand,
+  ListSubscribersCommand,
+  ListTagsForResourceCommand,
+  RegisterDataLakeDelegatedAdministratorCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateDataLakeCommand,
+  UpdateDataLakeExceptionSubscriptionCommand,
+  UpdateSubscriberCommand,
+  UpdateSubscriberNotificationCommand
+};
+var _SecurityLake = class _SecurityLake extends SecurityLakeClient {
+};
+__name(_SecurityLake, "SecurityLake");
+var SecurityLake = _SecurityLake;
+(0, import_smithy_client.createAggregatedClient)(commands, SecurityLake);
+
+// src/pagination/GetDataLakeSourcesPaginator.ts
+
+var paginateGetDataLakeSources = (0, import_core.createPaginator)(SecurityLakeClient, GetDataLakeSourcesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListDataLakeExceptionsPaginator.ts
+
+var paginateListDataLakeExceptions = (0, import_core.createPaginator)(SecurityLakeClient, ListDataLakeExceptionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListLogSourcesPaginator.ts
+
+var paginateListLogSources = (0, import_core.createPaginator)(SecurityLakeClient, ListLogSourcesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListSubscribersPaginator.ts
+
+var paginateListSubscribers = (0, import_core.createPaginator)(SecurityLakeClient, ListSubscribersCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  AccessType,
+  AwsLogSourceName,
+  BadRequestException,
+  ConflictException,
+  CreateAwsLogSourceCommand,
+  CreateCustomLogSourceCommand,
+  CreateDataLakeCommand,
+  CreateDataLakeExceptionSubscriptionCommand,
+  CreateDataLakeOrganizationConfigurationCommand,
+  CreateSubscriberCommand,
+  CreateSubscriberNotificationCommand,
+  DataLakeStatus,
+  DeleteAwsLogSourceCommand,
+  DeleteCustomLogSourceCommand,
+  DeleteDataLakeCommand,
+  DeleteDataLakeExceptionSubscriptionCommand,
+  DeleteDataLakeOrganizationConfigurationCommand,
+  DeleteSubscriberCommand,
+  DeleteSubscriberNotificationCommand,
+  DeregisterDataLakeDelegatedAdministratorCommand,
+  GetDataLakeExceptionSubscriptionCommand,
+  GetDataLakeOrganizationConfigurationCommand,
+  GetDataLakeSourcesCommand,
+  GetSubscriberCommand,
+  HttpMethod,
+  InternalServerException,
+  ListDataLakeExceptionsCommand,
+  ListDataLakesCommand,
+  ListLogSourcesCommand,
+  ListSubscribersCommand,
+  ListTagsForResourceCommand,
+  LogSourceResource,
+  NotificationConfiguration,
+  RegisterDataLakeDelegatedAdministratorCommand,
+  ResourceNotFoundException,
+  SecurityLake,
+  SecurityLakeClient,
+  SecurityLakeServiceException,
+  SourceCollectionStatus,
+  SubscriberStatus,
+  TagResourceCommand,
+  ThrottlingException,
+  UntagResourceCommand,
+  UpdateDataLakeCommand,
+  UpdateDataLakeExceptionSubscriptionCommand,
+  UpdateSubscriberCommand,
+  UpdateSubscriberNotificationCommand,
+  __Client,
+  paginateGetDataLakeSources,
+  paginateListDataLakeExceptions,
+  paginateListLogSources,
+  paginateListSubscribers
+});