@aws-sdk/client-efs 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3994 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EFSServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./EFSClient"), exports);
-tslib_1.__exportStar(require("./EFS"), 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 EFSServiceException_1 = require("./models/EFSServiceException");
-Object.defineProperty(exports, "EFSServiceException", { enumerable: true, get: function () { return EFSServiceException_1.EFSServiceException; } });
+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, {
+  AccessPointAlreadyExists: () => AccessPointAlreadyExists,
+  AccessPointLimitExceeded: () => AccessPointLimitExceeded,
+  AccessPointNotFound: () => AccessPointNotFound,
+  AvailabilityZonesMismatch: () => AvailabilityZonesMismatch,
+  BadRequest: () => BadRequest,
+  ConflictException: () => ConflictException,
+  CreateAccessPointCommand: () => CreateAccessPointCommand,
+  CreateFileSystemCommand: () => CreateFileSystemCommand,
+  CreateMountTargetCommand: () => CreateMountTargetCommand,
+  CreateReplicationConfigurationCommand: () => CreateReplicationConfigurationCommand,
+  CreateTagsCommand: () => CreateTagsCommand,
+  DeleteAccessPointCommand: () => DeleteAccessPointCommand,
+  DeleteFileSystemCommand: () => DeleteFileSystemCommand,
+  DeleteFileSystemPolicyCommand: () => DeleteFileSystemPolicyCommand,
+  DeleteMountTargetCommand: () => DeleteMountTargetCommand,
+  DeleteReplicationConfigurationCommand: () => DeleteReplicationConfigurationCommand,
+  DeleteTagsCommand: () => DeleteTagsCommand,
+  DependencyTimeout: () => DependencyTimeout,
+  DescribeAccessPointsCommand: () => DescribeAccessPointsCommand,
+  DescribeAccountPreferencesCommand: () => DescribeAccountPreferencesCommand,
+  DescribeBackupPolicyCommand: () => DescribeBackupPolicyCommand,
+  DescribeFileSystemPolicyCommand: () => DescribeFileSystemPolicyCommand,
+  DescribeFileSystemsCommand: () => DescribeFileSystemsCommand,
+  DescribeLifecycleConfigurationCommand: () => DescribeLifecycleConfigurationCommand,
+  DescribeMountTargetSecurityGroupsCommand: () => DescribeMountTargetSecurityGroupsCommand,
+  DescribeMountTargetsCommand: () => DescribeMountTargetsCommand,
+  DescribeReplicationConfigurationsCommand: () => DescribeReplicationConfigurationsCommand,
+  DescribeTagsCommand: () => DescribeTagsCommand,
+  EFS: () => EFS,
+  EFSClient: () => EFSClient,
+  EFSServiceException: () => EFSServiceException,
+  FileSystemAlreadyExists: () => FileSystemAlreadyExists,
+  FileSystemInUse: () => FileSystemInUse,
+  FileSystemLimitExceeded: () => FileSystemLimitExceeded,
+  FileSystemNotFound: () => FileSystemNotFound,
+  IncorrectFileSystemLifeCycleState: () => IncorrectFileSystemLifeCycleState,
+  IncorrectMountTargetState: () => IncorrectMountTargetState,
+  InsufficientThroughputCapacity: () => InsufficientThroughputCapacity,
+  InternalServerError: () => InternalServerError,
+  InvalidPolicyException: () => InvalidPolicyException,
+  IpAddressInUse: () => IpAddressInUse,
+  LifeCycleState: () => LifeCycleState,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ModifyMountTargetSecurityGroupsCommand: () => ModifyMountTargetSecurityGroupsCommand,
+  MountTargetConflict: () => MountTargetConflict,
+  MountTargetNotFound: () => MountTargetNotFound,
+  NetworkInterfaceLimitExceeded: () => NetworkInterfaceLimitExceeded,
+  NoFreeAddressesInSubnet: () => NoFreeAddressesInSubnet,
+  PerformanceMode: () => PerformanceMode,
+  PolicyNotFound: () => PolicyNotFound,
+  PutAccountPreferencesCommand: () => PutAccountPreferencesCommand,
+  PutBackupPolicyCommand: () => PutBackupPolicyCommand,
+  PutFileSystemPolicyCommand: () => PutFileSystemPolicyCommand,
+  PutLifecycleConfigurationCommand: () => PutLifecycleConfigurationCommand,
+  ReplicationAlreadyExists: () => ReplicationAlreadyExists,
+  ReplicationNotFound: () => ReplicationNotFound,
+  ReplicationOverwriteProtection: () => ReplicationOverwriteProtection,
+  ReplicationStatus: () => ReplicationStatus,
+  Resource: () => Resource,
+  ResourceIdType: () => ResourceIdType,
+  SecurityGroupLimitExceeded: () => SecurityGroupLimitExceeded,
+  SecurityGroupNotFound: () => SecurityGroupNotFound,
+  Status: () => Status,
+  SubnetNotFound: () => SubnetNotFound,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  ThroughputLimitExceeded: () => ThroughputLimitExceeded,
+  ThroughputMode: () => ThroughputMode,
+  TooManyRequests: () => TooManyRequests,
+  TransitionToArchiveRules: () => TransitionToArchiveRules,
+  TransitionToIARules: () => TransitionToIARules,
+  TransitionToPrimaryStorageClassRules: () => TransitionToPrimaryStorageClassRules,
+  UnsupportedAvailabilityZone: () => UnsupportedAvailabilityZone,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateFileSystemCommand: () => UpdateFileSystemCommand,
+  UpdateFileSystemProtectionCommand: () => UpdateFileSystemProtectionCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeAccessPoints: () => paginateDescribeAccessPoints,
+  paginateDescribeFileSystems: () => paginateDescribeFileSystems,
+  paginateDescribeMountTargets: () => paginateDescribeMountTargets,
+  paginateDescribeReplicationConfigurations: () => paginateDescribeReplicationConfigurations,
+  paginateDescribeTags: () => paginateDescribeTags,
+  paginateListTagsForResource: () => paginateListTagsForResource
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/EFSClient.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: "elasticfilesystem"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/EFSClient.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/EFSClient.ts
+var _EFSClient = class _EFSClient 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(_EFSClient, "EFSClient");
+var EFSClient = _EFSClient;
+
+// src/EFS.ts
+
+
+// src/commands/CreateAccessPointCommand.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");
+
+var import_uuid = require("uuid");
+
+// src/models/EFSServiceException.ts
+
+var _EFSServiceException = class _EFSServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _EFSServiceException.prototype);
+  }
+};
+__name(_EFSServiceException, "EFSServiceException");
+var EFSServiceException = _EFSServiceException;
+
+// src/models/models_0.ts
+var _AccessPointAlreadyExists = class _AccessPointAlreadyExists extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessPointAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessPointAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessPointAlreadyExists.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+    this.AccessPointId = opts.AccessPointId;
+  }
+};
+__name(_AccessPointAlreadyExists, "AccessPointAlreadyExists");
+var AccessPointAlreadyExists = _AccessPointAlreadyExists;
+var LifeCycleState = {
+  AVAILABLE: "available",
+  CREATING: "creating",
+  DELETED: "deleted",
+  DELETING: "deleting",
+  ERROR: "error",
+  UPDATING: "updating"
+};
+var _AccessPointLimitExceeded = class _AccessPointLimitExceeded extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessPointLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessPointLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessPointLimitExceeded.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessPointLimitExceeded, "AccessPointLimitExceeded");
+var AccessPointLimitExceeded = _AccessPointLimitExceeded;
+var _AccessPointNotFound = class _AccessPointNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessPointNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessPointNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessPointNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessPointNotFound, "AccessPointNotFound");
+var AccessPointNotFound = _AccessPointNotFound;
+var _AvailabilityZonesMismatch = class _AvailabilityZonesMismatch extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AvailabilityZonesMismatch",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AvailabilityZonesMismatch";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AvailabilityZonesMismatch.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_AvailabilityZonesMismatch, "AvailabilityZonesMismatch");
+var AvailabilityZonesMismatch = _AvailabilityZonesMismatch;
+var Status = {
+  DISABLED: "DISABLED",
+  DISABLING: "DISABLING",
+  ENABLED: "ENABLED",
+  ENABLING: "ENABLING"
+};
+var _BadRequest = class _BadRequest extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequest",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequest";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequest.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_BadRequest, "BadRequest");
+var BadRequest = _BadRequest;
+var _ConflictException = class _ConflictException extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _FileSystemNotFound = class _FileSystemNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FileSystemNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FileSystemNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FileSystemNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_FileSystemNotFound, "FileSystemNotFound");
+var FileSystemNotFound = _FileSystemNotFound;
+var _IncorrectFileSystemLifeCycleState = class _IncorrectFileSystemLifeCycleState extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IncorrectFileSystemLifeCycleState",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IncorrectFileSystemLifeCycleState";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IncorrectFileSystemLifeCycleState.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_IncorrectFileSystemLifeCycleState, "IncorrectFileSystemLifeCycleState");
+var IncorrectFileSystemLifeCycleState = _IncorrectFileSystemLifeCycleState;
+var _InternalServerError = class _InternalServerError extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerError.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+var _ThrottlingException = class _ThrottlingException extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var PerformanceMode = {
+  GENERAL_PURPOSE: "generalPurpose",
+  MAX_IO: "maxIO"
+};
+var ThroughputMode = {
+  BURSTING: "bursting",
+  ELASTIC: "elastic",
+  PROVISIONED: "provisioned"
+};
+var _FileSystemAlreadyExists = class _FileSystemAlreadyExists extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FileSystemAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FileSystemAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FileSystemAlreadyExists.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+    this.FileSystemId = opts.FileSystemId;
+  }
+};
+__name(_FileSystemAlreadyExists, "FileSystemAlreadyExists");
+var FileSystemAlreadyExists = _FileSystemAlreadyExists;
+var ReplicationOverwriteProtection = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED",
+  REPLICATING: "REPLICATING"
+};
+var _FileSystemLimitExceeded = class _FileSystemLimitExceeded extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FileSystemLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FileSystemLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FileSystemLimitExceeded.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_FileSystemLimitExceeded, "FileSystemLimitExceeded");
+var FileSystemLimitExceeded = _FileSystemLimitExceeded;
+var _InsufficientThroughputCapacity = class _InsufficientThroughputCapacity extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InsufficientThroughputCapacity",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InsufficientThroughputCapacity";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InsufficientThroughputCapacity.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_InsufficientThroughputCapacity, "InsufficientThroughputCapacity");
+var InsufficientThroughputCapacity = _InsufficientThroughputCapacity;
+var _ThroughputLimitExceeded = class _ThroughputLimitExceeded extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThroughputLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThroughputLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThroughputLimitExceeded.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ThroughputLimitExceeded, "ThroughputLimitExceeded");
+var ThroughputLimitExceeded = _ThroughputLimitExceeded;
+var _UnsupportedAvailabilityZone = class _UnsupportedAvailabilityZone extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedAvailabilityZone",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedAvailabilityZone";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedAvailabilityZone.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_UnsupportedAvailabilityZone, "UnsupportedAvailabilityZone");
+var UnsupportedAvailabilityZone = _UnsupportedAvailabilityZone;
+var _IpAddressInUse = class _IpAddressInUse extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IpAddressInUse",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IpAddressInUse";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IpAddressInUse.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_IpAddressInUse, "IpAddressInUse");
+var IpAddressInUse = _IpAddressInUse;
+var _MountTargetConflict = class _MountTargetConflict extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MountTargetConflict",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MountTargetConflict";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MountTargetConflict.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_MountTargetConflict, "MountTargetConflict");
+var MountTargetConflict = _MountTargetConflict;
+var _NetworkInterfaceLimitExceeded = class _NetworkInterfaceLimitExceeded extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NetworkInterfaceLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NetworkInterfaceLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NetworkInterfaceLimitExceeded.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_NetworkInterfaceLimitExceeded, "NetworkInterfaceLimitExceeded");
+var NetworkInterfaceLimitExceeded = _NetworkInterfaceLimitExceeded;
+var _NoFreeAddressesInSubnet = class _NoFreeAddressesInSubnet extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NoFreeAddressesInSubnet",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NoFreeAddressesInSubnet";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NoFreeAddressesInSubnet.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_NoFreeAddressesInSubnet, "NoFreeAddressesInSubnet");
+var NoFreeAddressesInSubnet = _NoFreeAddressesInSubnet;
+var _SecurityGroupLimitExceeded = class _SecurityGroupLimitExceeded extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SecurityGroupLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SecurityGroupLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SecurityGroupLimitExceeded.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_SecurityGroupLimitExceeded, "SecurityGroupLimitExceeded");
+var SecurityGroupLimitExceeded = _SecurityGroupLimitExceeded;
+var _SecurityGroupNotFound = class _SecurityGroupNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SecurityGroupNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SecurityGroupNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SecurityGroupNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_SecurityGroupNotFound, "SecurityGroupNotFound");
+var SecurityGroupNotFound = _SecurityGroupNotFound;
+var _SubnetNotFound = class _SubnetNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_SubnetNotFound, "SubnetNotFound");
+var SubnetNotFound = _SubnetNotFound;
+var ReplicationStatus = {
+  DELETING: "DELETING",
+  ENABLED: "ENABLED",
+  ENABLING: "ENABLING",
+  ERROR: "ERROR",
+  PAUSED: "PAUSED",
+  PAUSING: "PAUSING"
+};
+var _ReplicationNotFound = class _ReplicationNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ReplicationNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ReplicationNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ReplicationNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ReplicationNotFound, "ReplicationNotFound");
+var ReplicationNotFound = _ReplicationNotFound;
+var _ValidationException = class _ValidationException extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _FileSystemInUse = class _FileSystemInUse extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "FileSystemInUse",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "FileSystemInUse";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _FileSystemInUse.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_FileSystemInUse, "FileSystemInUse");
+var FileSystemInUse = _FileSystemInUse;
+var _DependencyTimeout = class _DependencyTimeout extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DependencyTimeout",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "DependencyTimeout";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _DependencyTimeout.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_DependencyTimeout, "DependencyTimeout");
+var DependencyTimeout = _DependencyTimeout;
+var _MountTargetNotFound = class _MountTargetNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MountTargetNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MountTargetNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MountTargetNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_MountTargetNotFound, "MountTargetNotFound");
+var MountTargetNotFound = _MountTargetNotFound;
+var ResourceIdType = {
+  LongId: "LONG_ID",
+  ShortId: "SHORT_ID"
+};
+var Resource = {
+  FileSystem: "FILE_SYSTEM",
+  MountTarget: "MOUNT_TARGET"
+};
+var _PolicyNotFound = class _PolicyNotFound extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicyNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicyNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicyNotFound.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_PolicyNotFound, "PolicyNotFound");
+var PolicyNotFound = _PolicyNotFound;
+var TransitionToArchiveRules = {
+  AFTER_14_DAYS: "AFTER_14_DAYS",
+  AFTER_180_DAYS: "AFTER_180_DAYS",
+  AFTER_1_DAY: "AFTER_1_DAY",
+  AFTER_270_DAYS: "AFTER_270_DAYS",
+  AFTER_30_DAYS: "AFTER_30_DAYS",
+  AFTER_365_DAYS: "AFTER_365_DAYS",
+  AFTER_60_DAYS: "AFTER_60_DAYS",
+  AFTER_7_DAYS: "AFTER_7_DAYS",
+  AFTER_90_DAYS: "AFTER_90_DAYS"
+};
+var TransitionToIARules = {
+  AFTER_14_DAYS: "AFTER_14_DAYS",
+  AFTER_180_DAYS: "AFTER_180_DAYS",
+  AFTER_1_DAY: "AFTER_1_DAY",
+  AFTER_270_DAYS: "AFTER_270_DAYS",
+  AFTER_30_DAYS: "AFTER_30_DAYS",
+  AFTER_365_DAYS: "AFTER_365_DAYS",
+  AFTER_60_DAYS: "AFTER_60_DAYS",
+  AFTER_7_DAYS: "AFTER_7_DAYS",
+  AFTER_90_DAYS: "AFTER_90_DAYS"
+};
+var TransitionToPrimaryStorageClassRules = {
+  AFTER_1_ACCESS: "AFTER_1_ACCESS"
+};
+var _IncorrectMountTargetState = class _IncorrectMountTargetState extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IncorrectMountTargetState",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IncorrectMountTargetState";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IncorrectMountTargetState.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_IncorrectMountTargetState, "IncorrectMountTargetState");
+var IncorrectMountTargetState = _IncorrectMountTargetState;
+var _InvalidPolicyException = class _InvalidPolicyException extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidPolicyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidPolicyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidPolicyException.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidPolicyException, "InvalidPolicyException");
+var InvalidPolicyException = _InvalidPolicyException;
+var _TooManyRequests = class _TooManyRequests extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequests",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequests";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyRequests.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyRequests, "TooManyRequests");
+var TooManyRequests = _TooManyRequests;
+var _ReplicationAlreadyExists = class _ReplicationAlreadyExists extends EFSServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ReplicationAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ReplicationAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ReplicationAlreadyExists.prototype);
+    this.ErrorCode = opts.ErrorCode;
+    this.Message = opts.Message;
+  }
+};
+__name(_ReplicationAlreadyExists, "ReplicationAlreadyExists");
+var ReplicationAlreadyExists = _ReplicationAlreadyExists;
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateAccessPointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/access-points");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      FileSystemId: [],
+      PosixUser: (_) => (0, import_smithy_client._json)(_),
+      RootDirectory: (_) => (0, import_smithy_client._json)(_),
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateAccessPointCommand");
+var se_CreateFileSystemCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      AvailabilityZoneName: [],
+      Backup: [],
+      CreationToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      Encrypted: [],
+      KmsKeyId: [],
+      PerformanceMode: [],
+      ProvisionedThroughputInMibps: (_) => (0, import_smithy_client.serializeFloat)(_),
+      Tags: (_) => (0, import_smithy_client._json)(_),
+      ThroughputMode: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateFileSystemCommand");
+var se_CreateMountTargetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/mount-targets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      FileSystemId: [],
+      IpAddress: [],
+      SecurityGroups: (_) => (0, import_smithy_client._json)(_),
+      SubnetId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateMountTargetCommand");
+var se_CreateReplicationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{SourceFileSystemId}/replication-configuration");
+  b.p("SourceFileSystemId", () => input.SourceFileSystemId, "{SourceFileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Destinations: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateReplicationConfigurationCommand");
+var se_CreateTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/create-tags/{FileSystemId}");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", 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_CreateTagsCommand");
+var se_DeleteAccessPointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/access-points/{AccessPointId}");
+  b.p("AccessPointId", () => input.AccessPointId, "{AccessPointId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteAccessPointCommand");
+var se_DeleteFileSystemCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{FileSystemId}");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteFileSystemCommand");
+var se_DeleteFileSystemPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/policy");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteFileSystemPolicyCommand");
+var se_DeleteMountTargetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/mount-targets/{MountTargetId}");
+  b.p("MountTargetId", () => input.MountTargetId, "{MountTargetId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteMountTargetCommand");
+var se_DeleteReplicationConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{SourceFileSystemId}/replication-configuration");
+  b.p("SourceFileSystemId", () => input.SourceFileSystemId, "{SourceFileSystemId}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteReplicationConfigurationCommand");
+var se_DeleteTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/delete-tags/{FileSystemId}");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      TagKeys: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTagsCommand");
+var se_DescribeAccessPointsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/access-points");
+  const query = (0, import_smithy_client.map)({
+    [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_NT]: [, input[_NT]],
+    [_API]: [, input[_API]],
+    [_FSI]: [, input[_FSI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeAccessPointsCommand");
+var se_DescribeAccountPreferencesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/account-preferences");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: []
+    })
+  );
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeAccountPreferencesCommand");
+var se_DescribeBackupPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/backup-policy");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeBackupPolicyCommand");
+var se_DescribeFileSystemPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/policy");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeFileSystemPolicyCommand");
+var se_DescribeFileSystemsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems");
+  const query = (0, import_smithy_client.map)({
+    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
+    [_M]: [, input[_M]],
+    [_CT]: [, input[_CT]],
+    [_FSI]: [, input[_FSI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeFileSystemsCommand");
+var se_DescribeLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/lifecycle-configuration");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeLifecycleConfigurationCommand");
+var se_DescribeMountTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/mount-targets");
+  const query = (0, import_smithy_client.map)({
+    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
+    [_M]: [, input[_M]],
+    [_FSI]: [, input[_FSI]],
+    [_MTI]: [, input[_MTI]],
+    [_API]: [, input[_API]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeMountTargetsCommand");
+var se_DescribeMountTargetSecurityGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/mount-targets/{MountTargetId}/security-groups");
+  b.p("MountTargetId", () => input.MountTargetId, "{MountTargetId}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_DescribeMountTargetSecurityGroupsCommand");
+var se_DescribeReplicationConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/file-systems/replication-configurations");
+  const query = (0, import_smithy_client.map)({
+    [_FSI]: [, input[_FSI]],
+    [_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_DescribeReplicationConfigurationsCommand");
+var se_DescribeTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/tags/{FileSystemId}");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_MI]: [() => input.MaxItems !== void 0, () => input[_MI].toString()],
+    [_M]: [, input[_M]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeTagsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/2015-02-01/resource-tags/{ResourceId}");
+  b.p("ResourceId", () => input.ResourceId, "{ResourceId}", false);
+  const query = (0, import_smithy_client.map)({
+    [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_NT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ModifyMountTargetSecurityGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/mount-targets/{MountTargetId}/security-groups");
+  b.p("MountTargetId", () => input.MountTargetId, "{MountTargetId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      SecurityGroups: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_ModifyMountTargetSecurityGroupsCommand");
+var se_PutAccountPreferencesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/account-preferences");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ResourceIdType: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutAccountPreferencesCommand");
+var se_PutBackupPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/backup-policy");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      BackupPolicy: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutBackupPolicyCommand");
+var se_PutFileSystemPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/policy");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      BypassPolicyLockoutSafetyCheck: [],
+      Policy: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutFileSystemPolicyCommand");
+var se_PutLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/lifecycle-configuration");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      LifecyclePolicies: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_PutLifecycleConfigurationCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/resource-tags/{ResourceId}");
+  b.p("ResourceId", () => input.ResourceId, "{ResourceId}", 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("/2015-02-01/resource-tags/{ResourceId}");
+  b.p("ResourceId", () => input.ResourceId, "{ResourceId}", 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_UpdateFileSystemCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{FileSystemId}");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ProvisionedThroughputInMibps: (_) => (0, import_smithy_client.serializeFloat)(_),
+      ThroughputMode: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFileSystemCommand");
+var se_UpdateFileSystemProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/2015-02-01/file-systems/{FileSystemId}/protection");
+  b.p("FileSystemId", () => input.FileSystemId, "{FileSystemId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ReplicationOverwriteProtection: []
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateFileSystemProtectionCommand");
+var de_CreateAccessPointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateAccessPointCommandError(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, {
+    AccessPointArn: import_smithy_client.expectString,
+    AccessPointId: import_smithy_client.expectString,
+    ClientToken: import_smithy_client.expectString,
+    FileSystemId: import_smithy_client.expectString,
+    LifeCycleState: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    OwnerId: import_smithy_client.expectString,
+    PosixUser: import_smithy_client._json,
+    RootDirectory: import_smithy_client._json,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateAccessPointCommand");
+var de_CreateAccessPointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessPointAlreadyExists":
+    case "com.amazonaws.efs#AccessPointAlreadyExists":
+      throw await de_AccessPointAlreadyExistsRes(parsedOutput, context);
+    case "AccessPointLimitExceeded":
+    case "com.amazonaws.efs#AccessPointLimitExceeded":
+      throw await de_AccessPointLimitExceededRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.efs#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateAccessPointCommandError");
+var de_CreateFileSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateFileSystemCommandError(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, {
+    AvailabilityZoneId: import_smithy_client.expectString,
+    AvailabilityZoneName: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationToken: import_smithy_client.expectString,
+    Encrypted: import_smithy_client.expectBoolean,
+    FileSystemArn: import_smithy_client.expectString,
+    FileSystemId: import_smithy_client.expectString,
+    FileSystemProtection: import_smithy_client._json,
+    KmsKeyId: import_smithy_client.expectString,
+    LifeCycleState: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    NumberOfMountTargets: import_smithy_client.expectInt32,
+    OwnerId: import_smithy_client.expectString,
+    PerformanceMode: import_smithy_client.expectString,
+    ProvisionedThroughputInMibps: import_smithy_client.limitedParseDouble,
+    SizeInBytes: (_) => de_FileSystemSize(_, context),
+    Tags: import_smithy_client._json,
+    ThroughputMode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateFileSystemCommand");
+var de_CreateFileSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemAlreadyExists":
+    case "com.amazonaws.efs#FileSystemAlreadyExists":
+      throw await de_FileSystemAlreadyExistsRes(parsedOutput, context);
+    case "FileSystemLimitExceeded":
+    case "com.amazonaws.efs#FileSystemLimitExceeded":
+      throw await de_FileSystemLimitExceededRes(parsedOutput, context);
+    case "InsufficientThroughputCapacity":
+    case "com.amazonaws.efs#InsufficientThroughputCapacity":
+      throw await de_InsufficientThroughputCapacityRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThroughputLimitExceeded":
+    case "com.amazonaws.efs#ThroughputLimitExceeded":
+      throw await de_ThroughputLimitExceededRes(parsedOutput, context);
+    case "UnsupportedAvailabilityZone":
+    case "com.amazonaws.efs#UnsupportedAvailabilityZone":
+      throw await de_UnsupportedAvailabilityZoneRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateFileSystemCommandError");
+var de_CreateMountTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateMountTargetCommandError(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, {
+    AvailabilityZoneId: import_smithy_client.expectString,
+    AvailabilityZoneName: import_smithy_client.expectString,
+    FileSystemId: import_smithy_client.expectString,
+    IpAddress: import_smithy_client.expectString,
+    LifeCycleState: import_smithy_client.expectString,
+    MountTargetId: import_smithy_client.expectString,
+    NetworkInterfaceId: import_smithy_client.expectString,
+    OwnerId: import_smithy_client.expectString,
+    SubnetId: import_smithy_client.expectString,
+    VpcId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateMountTargetCommand");
+var de_CreateMountTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AvailabilityZonesMismatch":
+    case "com.amazonaws.efs#AvailabilityZonesMismatch":
+      throw await de_AvailabilityZonesMismatchRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "IpAddressInUse":
+    case "com.amazonaws.efs#IpAddressInUse":
+      throw await de_IpAddressInUseRes(parsedOutput, context);
+    case "MountTargetConflict":
+    case "com.amazonaws.efs#MountTargetConflict":
+      throw await de_MountTargetConflictRes(parsedOutput, context);
+    case "NetworkInterfaceLimitExceeded":
+    case "com.amazonaws.efs#NetworkInterfaceLimitExceeded":
+      throw await de_NetworkInterfaceLimitExceededRes(parsedOutput, context);
+    case "NoFreeAddressesInSubnet":
+    case "com.amazonaws.efs#NoFreeAddressesInSubnet":
+      throw await de_NoFreeAddressesInSubnetRes(parsedOutput, context);
+    case "SecurityGroupLimitExceeded":
+    case "com.amazonaws.efs#SecurityGroupLimitExceeded":
+      throw await de_SecurityGroupLimitExceededRes(parsedOutput, context);
+    case "SecurityGroupNotFound":
+    case "com.amazonaws.efs#SecurityGroupNotFound":
+      throw await de_SecurityGroupNotFoundRes(parsedOutput, context);
+    case "SubnetNotFound":
+    case "com.amazonaws.efs#SubnetNotFound":
+      throw await de_SubnetNotFoundRes(parsedOutput, context);
+    case "UnsupportedAvailabilityZone":
+    case "com.amazonaws.efs#UnsupportedAvailabilityZone":
+      throw await de_UnsupportedAvailabilityZoneRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateMountTargetCommandError");
+var de_CreateReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateReplicationConfigurationCommandError(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, {
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Destinations: (_) => de_Destinations(_, context),
+    OriginalSourceFileSystemArn: import_smithy_client.expectString,
+    SourceFileSystemArn: import_smithy_client.expectString,
+    SourceFileSystemId: import_smithy_client.expectString,
+    SourceFileSystemRegion: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateReplicationConfigurationCommand");
+var de_CreateReplicationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.efs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "FileSystemLimitExceeded":
+    case "com.amazonaws.efs#FileSystemLimitExceeded":
+      throw await de_FileSystemLimitExceededRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InsufficientThroughputCapacity":
+    case "com.amazonaws.efs#InsufficientThroughputCapacity":
+      throw await de_InsufficientThroughputCapacityRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ReplicationNotFound":
+    case "com.amazonaws.efs#ReplicationNotFound":
+      throw await de_ReplicationNotFoundRes(parsedOutput, context);
+    case "ThroughputLimitExceeded":
+    case "com.amazonaws.efs#ThroughputLimitExceeded":
+      throw await de_ThroughputLimitExceededRes(parsedOutput, context);
+    case "UnsupportedAvailabilityZone":
+    case "com.amazonaws.efs#UnsupportedAvailabilityZone":
+      throw await de_UnsupportedAvailabilityZoneRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.efs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateReplicationConfigurationCommandError");
+var de_CreateTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CreateTagsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_CreateTagsCommand");
+var de_CreateTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTagsCommandError");
+var de_DeleteAccessPointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteAccessPointCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteAccessPointCommand");
+var de_DeleteAccessPointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteAccessPointCommandError");
+var de_DeleteFileSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteFileSystemCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteFileSystemCommand");
+var de_DeleteFileSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemInUse":
+    case "com.amazonaws.efs#FileSystemInUse":
+      throw await de_FileSystemInUseRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteFileSystemCommandError");
+var de_DeleteFileSystemPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteFileSystemPolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteFileSystemPolicyCommand");
+var de_DeleteFileSystemPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteFileSystemPolicyCommandError");
+var de_DeleteMountTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteMountTargetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteMountTargetCommand");
+var de_DeleteMountTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "DependencyTimeout":
+    case "com.amazonaws.efs#DependencyTimeout":
+      throw await de_DependencyTimeoutRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "MountTargetNotFound":
+    case "com.amazonaws.efs#MountTargetNotFound":
+      throw await de_MountTargetNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMountTargetCommandError");
+var de_DeleteReplicationConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteReplicationConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteReplicationConfigurationCommand");
+var de_DeleteReplicationConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ReplicationNotFound":
+    case "com.amazonaws.efs#ReplicationNotFound":
+      throw await de_ReplicationNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteReplicationConfigurationCommandError");
+var de_DeleteTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteTagsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTagsCommand");
+var de_DeleteTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTagsCommandError");
+var de_DescribeAccessPointsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeAccessPointsCommandError(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, {
+    AccessPoints: import_smithy_client._json,
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeAccessPointsCommand");
+var de_DescribeAccessPointsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAccessPointsCommandError");
+var de_DescribeAccountPreferencesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeAccountPreferencesCommandError(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,
+    ResourceIdPreference: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeAccountPreferencesCommand");
+var de_DescribeAccountPreferencesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAccountPreferencesCommandError");
+var de_DescribeBackupPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeBackupPolicyCommandError(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, {
+    BackupPolicy: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeBackupPolicyCommand");
+var de_DescribeBackupPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "PolicyNotFound":
+    case "com.amazonaws.efs#PolicyNotFound":
+      throw await de_PolicyNotFoundRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.efs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeBackupPolicyCommandError");
+var de_DescribeFileSystemPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeFileSystemPolicyCommandError(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, {
+    FileSystemId: import_smithy_client.expectString,
+    Policy: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeFileSystemPolicyCommand");
+var de_DescribeFileSystemPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "PolicyNotFound":
+    case "com.amazonaws.efs#PolicyNotFound":
+      throw await de_PolicyNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeFileSystemPolicyCommandError");
+var de_DescribeFileSystemsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeFileSystemsCommandError(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, {
+    FileSystems: (_) => de_FileSystemDescriptions(_, context),
+    Marker: import_smithy_client.expectString,
+    NextMarker: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeFileSystemsCommand");
+var de_DescribeFileSystemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeFileSystemsCommandError");
+var de_DescribeLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeLifecycleConfigurationCommandError(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, {
+    LifecyclePolicies: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeLifecycleConfigurationCommand");
+var de_DescribeLifecycleConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLifecycleConfigurationCommandError");
+var de_DescribeMountTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeMountTargetsCommandError(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, {
+    Marker: import_smithy_client.expectString,
+    MountTargets: import_smithy_client._json,
+    NextMarker: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeMountTargetsCommand");
+var de_DescribeMountTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "MountTargetNotFound":
+    case "com.amazonaws.efs#MountTargetNotFound":
+      throw await de_MountTargetNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeMountTargetsCommandError");
+var de_DescribeMountTargetSecurityGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeMountTargetSecurityGroupsCommandError(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, {
+    SecurityGroups: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeMountTargetSecurityGroupsCommand");
+var de_DescribeMountTargetSecurityGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "IncorrectMountTargetState":
+    case "com.amazonaws.efs#IncorrectMountTargetState":
+      throw await de_IncorrectMountTargetStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "MountTargetNotFound":
+    case "com.amazonaws.efs#MountTargetNotFound":
+      throw await de_MountTargetNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeMountTargetSecurityGroupsCommandError");
+var de_DescribeReplicationConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeReplicationConfigurationsCommandError(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,
+    Replications: (_) => de_ReplicationConfigurationDescriptions(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeReplicationConfigurationsCommand");
+var de_DescribeReplicationConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ReplicationNotFound":
+    case "com.amazonaws.efs#ReplicationNotFound":
+      throw await de_ReplicationNotFoundRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.efs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeReplicationConfigurationsCommandError");
+var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeTagsCommandError(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, {
+    Marker: import_smithy_client.expectString,
+    NextMarker: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_DescribeTagsCommand");
+var de_DescribeTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTagsCommandError");
+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, {
+    NextToken: import_smithy_client.expectString,
+    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 "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ModifyMountTargetSecurityGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_ModifyMountTargetSecurityGroupsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_ModifyMountTargetSecurityGroupsCommand");
+var de_ModifyMountTargetSecurityGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "IncorrectMountTargetState":
+    case "com.amazonaws.efs#IncorrectMountTargetState":
+      throw await de_IncorrectMountTargetStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "MountTargetNotFound":
+    case "com.amazonaws.efs#MountTargetNotFound":
+      throw await de_MountTargetNotFoundRes(parsedOutput, context);
+    case "SecurityGroupLimitExceeded":
+    case "com.amazonaws.efs#SecurityGroupLimitExceeded":
+      throw await de_SecurityGroupLimitExceededRes(parsedOutput, context);
+    case "SecurityGroupNotFound":
+    case "com.amazonaws.efs#SecurityGroupNotFound":
+      throw await de_SecurityGroupNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ModifyMountTargetSecurityGroupsCommandError");
+var de_PutAccountPreferencesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutAccountPreferencesCommandError(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, {
+    ResourceIdPreference: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutAccountPreferencesCommand");
+var de_PutAccountPreferencesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutAccountPreferencesCommandError");
+var de_PutBackupPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutBackupPolicyCommandError(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, {
+    BackupPolicy: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutBackupPolicyCommand");
+var de_PutBackupPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.efs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutBackupPolicyCommandError");
+var de_PutFileSystemPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutFileSystemPolicyCommandError(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, {
+    FileSystemId: import_smithy_client.expectString,
+    Policy: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutFileSystemPolicyCommand");
+var de_PutFileSystemPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidPolicyException":
+    case "com.amazonaws.efs#InvalidPolicyException":
+      throw await de_InvalidPolicyExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutFileSystemPolicyCommandError");
+var de_PutLifecycleConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutLifecycleConfigurationCommandError(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, {
+    LifecyclePolicies: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutLifecycleConfigurationCommand");
+var de_PutLifecycleConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutLifecycleConfigurationCommandError");
+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 "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(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 "AccessPointNotFound":
+    case "com.amazonaws.efs#AccessPointNotFound":
+      throw await de_AccessPointNotFoundRes(parsedOutput, context);
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateFileSystemCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_UpdateFileSystemCommandError(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, {
+    AvailabilityZoneId: import_smithy_client.expectString,
+    AvailabilityZoneName: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationToken: import_smithy_client.expectString,
+    Encrypted: import_smithy_client.expectBoolean,
+    FileSystemArn: import_smithy_client.expectString,
+    FileSystemId: import_smithy_client.expectString,
+    FileSystemProtection: import_smithy_client._json,
+    KmsKeyId: import_smithy_client.expectString,
+    LifeCycleState: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    NumberOfMountTargets: import_smithy_client.expectInt32,
+    OwnerId: import_smithy_client.expectString,
+    PerformanceMode: import_smithy_client.expectString,
+    ProvisionedThroughputInMibps: import_smithy_client.limitedParseDouble,
+    SizeInBytes: (_) => de_FileSystemSize(_, context),
+    Tags: import_smithy_client._json,
+    ThroughputMode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateFileSystemCommand");
+var de_UpdateFileSystemCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InsufficientThroughputCapacity":
+    case "com.amazonaws.efs#InsufficientThroughputCapacity":
+      throw await de_InsufficientThroughputCapacityRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThroughputLimitExceeded":
+    case "com.amazonaws.efs#ThroughputLimitExceeded":
+      throw await de_ThroughputLimitExceededRes(parsedOutput, context);
+    case "TooManyRequests":
+    case "com.amazonaws.efs#TooManyRequests":
+      throw await de_TooManyRequestsRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFileSystemCommandError");
+var de_UpdateFileSystemProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateFileSystemProtectionCommandError(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, {
+    ReplicationOverwriteProtection: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateFileSystemProtectionCommand");
+var de_UpdateFileSystemProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequest":
+    case "com.amazonaws.efs#BadRequest":
+      throw await de_BadRequestRes(parsedOutput, context);
+    case "FileSystemNotFound":
+    case "com.amazonaws.efs#FileSystemNotFound":
+      throw await de_FileSystemNotFoundRes(parsedOutput, context);
+    case "IncorrectFileSystemLifeCycleState":
+    case "com.amazonaws.efs#IncorrectFileSystemLifeCycleState":
+      throw await de_IncorrectFileSystemLifeCycleStateRes(parsedOutput, context);
+    case "InsufficientThroughputCapacity":
+    case "com.amazonaws.efs#InsufficientThroughputCapacity":
+      throw await de_InsufficientThroughputCapacityRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.efs#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ReplicationAlreadyExists":
+    case "com.amazonaws.efs#ReplicationAlreadyExists":
+      throw await de_ReplicationAlreadyExistsRes(parsedOutput, context);
+    case "ThroughputLimitExceeded":
+    case "com.amazonaws.efs#ThroughputLimitExceeded":
+      throw await de_ThroughputLimitExceededRes(parsedOutput, context);
+    case "TooManyRequests":
+    case "com.amazonaws.efs#TooManyRequests":
+      throw await de_TooManyRequestsRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFileSystemProtectionCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(EFSServiceException);
+var de_AccessPointAlreadyExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    AccessPointId: import_smithy_client.expectString,
+    ErrorCode: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessPointAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessPointAlreadyExistsRes");
+var de_AccessPointLimitExceededRes = /* @__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 AccessPointLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessPointLimitExceededRes");
+var de_AccessPointNotFoundRes = /* @__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 AccessPointNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessPointNotFoundRes");
+var de_AvailabilityZonesMismatchRes = /* @__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 AvailabilityZonesMismatch({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AvailabilityZonesMismatchRes");
+var de_BadRequestRes = /* @__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 BadRequest({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestRes");
+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, {
+    ErrorCode: import_smithy_client.expectString,
+    Message: 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_DependencyTimeoutRes = /* @__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 DependencyTimeout({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_DependencyTimeoutRes");
+var de_FileSystemAlreadyExistsRes = /* @__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,
+    FileSystemId: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new FileSystemAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_FileSystemAlreadyExistsRes");
+var de_FileSystemInUseRes = /* @__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 FileSystemInUse({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_FileSystemInUseRes");
+var de_FileSystemLimitExceededRes = /* @__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 FileSystemLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_FileSystemLimitExceededRes");
+var de_FileSystemNotFoundRes = /* @__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 FileSystemNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_FileSystemNotFoundRes");
+var de_IncorrectFileSystemLifeCycleStateRes = /* @__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 IncorrectFileSystemLifeCycleState({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_IncorrectFileSystemLifeCycleStateRes");
+var de_IncorrectMountTargetStateRes = /* @__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 IncorrectMountTargetState({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_IncorrectMountTargetStateRes");
+var de_InsufficientThroughputCapacityRes = /* @__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 InsufficientThroughputCapacity({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InsufficientThroughputCapacityRes");
+var de_InternalServerErrorRes = /* @__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 InternalServerError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerErrorRes");
+var de_InvalidPolicyExceptionRes = /* @__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 InvalidPolicyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InvalidPolicyExceptionRes");
+var de_IpAddressInUseRes = /* @__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 IpAddressInUse({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_IpAddressInUseRes");
+var de_MountTargetConflictRes = /* @__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 MountTargetConflict({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MountTargetConflictRes");
+var de_MountTargetNotFoundRes = /* @__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 MountTargetNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_MountTargetNotFoundRes");
+var de_NetworkInterfaceLimitExceededRes = /* @__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 NetworkInterfaceLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NetworkInterfaceLimitExceededRes");
+var de_NoFreeAddressesInSubnetRes = /* @__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 NoFreeAddressesInSubnet({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NoFreeAddressesInSubnetRes");
+var de_PolicyNotFoundRes = /* @__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 PolicyNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PolicyNotFoundRes");
+var de_ReplicationAlreadyExistsRes = /* @__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 ReplicationAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ReplicationAlreadyExistsRes");
+var de_ReplicationNotFoundRes = /* @__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 ReplicationNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ReplicationNotFoundRes");
+var de_SecurityGroupLimitExceededRes = /* @__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 SecurityGroupLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SecurityGroupLimitExceededRes");
+var de_SecurityGroupNotFoundRes = /* @__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 SecurityGroupNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SecurityGroupNotFoundRes");
+var de_SubnetNotFoundRes = /* @__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 SubnetNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_SubnetNotFoundRes");
+var de_ThrottlingExceptionRes = /* @__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 ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ThroughputLimitExceededRes = /* @__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 ThroughputLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThroughputLimitExceededRes");
+var de_TooManyRequestsRes = /* @__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 TooManyRequests({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsRes");
+var de_UnsupportedAvailabilityZoneRes = /* @__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 UnsupportedAvailabilityZone({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_UnsupportedAvailabilityZoneRes");
+var de_ValidationExceptionRes = /* @__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 ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var de_Destination = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FileSystemId: import_smithy_client.expectString,
+    LastReplicatedTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Region: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString
+  });
+}, "de_Destination");
+var de_Destinations = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Destination(entry, context);
+  });
+  return retVal;
+}, "de_Destinations");
+var de_FileSystemDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AvailabilityZoneId: import_smithy_client.expectString,
+    AvailabilityZoneName: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreationToken: import_smithy_client.expectString,
+    Encrypted: import_smithy_client.expectBoolean,
+    FileSystemArn: import_smithy_client.expectString,
+    FileSystemId: import_smithy_client.expectString,
+    FileSystemProtection: import_smithy_client._json,
+    KmsKeyId: import_smithy_client.expectString,
+    LifeCycleState: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    NumberOfMountTargets: import_smithy_client.expectInt32,
+    OwnerId: import_smithy_client.expectString,
+    PerformanceMode: import_smithy_client.expectString,
+    ProvisionedThroughputInMibps: import_smithy_client.limitedParseDouble,
+    SizeInBytes: (_) => de_FileSystemSize(_, context),
+    Tags: import_smithy_client._json,
+    ThroughputMode: import_smithy_client.expectString
+  });
+}, "de_FileSystemDescription");
+var de_FileSystemDescriptions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FileSystemDescription(entry, context);
+  });
+  return retVal;
+}, "de_FileSystemDescriptions");
+var de_FileSystemSize = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Value: import_smithy_client.expectLong,
+    ValueInArchive: import_smithy_client.expectLong,
+    ValueInIA: import_smithy_client.expectLong,
+    ValueInStandard: import_smithy_client.expectLong
+  });
+}, "de_FileSystemSize");
+var de_ReplicationConfigurationDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Destinations: (_) => de_Destinations(_, context),
+    OriginalSourceFileSystemArn: import_smithy_client.expectString,
+    SourceFileSystemArn: import_smithy_client.expectString,
+    SourceFileSystemId: import_smithy_client.expectString,
+    SourceFileSystemRegion: import_smithy_client.expectString
+  });
+}, "de_ReplicationConfigurationDescription");
+var de_ReplicationConfigurationDescriptions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ReplicationConfigurationDescription(entry, context);
+  });
+  return retVal;
+}, "de_ReplicationConfigurationDescriptions");
+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 _API = "AccessPointId";
+var _CT = "CreationToken";
+var _FSI = "FileSystemId";
+var _M = "Marker";
+var _MI = "MaxItems";
+var _MR = "MaxResults";
+var _MTI = "MountTargetId";
+var _NT = "NextToken";
+var _TK = "TagKeys";
+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/CreateAccessPointCommand.ts
+var _CreateAccessPointCommand = class _CreateAccessPointCommand 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("MagnolioAPIService_v20150201", "CreateAccessPoint", {}).n("EFSClient", "CreateAccessPointCommand").f(void 0, void 0).ser(se_CreateAccessPointCommand).de(de_CreateAccessPointCommand).build() {
+};
+__name(_CreateAccessPointCommand, "CreateAccessPointCommand");
+var CreateAccessPointCommand = _CreateAccessPointCommand;
+
+// src/commands/CreateFileSystemCommand.ts
+
+
+
+
+var _CreateFileSystemCommand = class _CreateFileSystemCommand 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("MagnolioAPIService_v20150201", "CreateFileSystem", {}).n("EFSClient", "CreateFileSystemCommand").f(void 0, void 0).ser(se_CreateFileSystemCommand).de(de_CreateFileSystemCommand).build() {
+};
+__name(_CreateFileSystemCommand, "CreateFileSystemCommand");
+var CreateFileSystemCommand = _CreateFileSystemCommand;
+
+// src/commands/CreateMountTargetCommand.ts
+
+
+
+
+var _CreateMountTargetCommand = class _CreateMountTargetCommand 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("MagnolioAPIService_v20150201", "CreateMountTarget", {}).n("EFSClient", "CreateMountTargetCommand").f(void 0, void 0).ser(se_CreateMountTargetCommand).de(de_CreateMountTargetCommand).build() {
+};
+__name(_CreateMountTargetCommand, "CreateMountTargetCommand");
+var CreateMountTargetCommand = _CreateMountTargetCommand;
+
+// src/commands/CreateReplicationConfigurationCommand.ts
+
+
+
+
+var _CreateReplicationConfigurationCommand = class _CreateReplicationConfigurationCommand 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("MagnolioAPIService_v20150201", "CreateReplicationConfiguration", {}).n("EFSClient", "CreateReplicationConfigurationCommand").f(void 0, void 0).ser(se_CreateReplicationConfigurationCommand).de(de_CreateReplicationConfigurationCommand).build() {
+};
+__name(_CreateReplicationConfigurationCommand, "CreateReplicationConfigurationCommand");
+var CreateReplicationConfigurationCommand = _CreateReplicationConfigurationCommand;
+
+// src/commands/CreateTagsCommand.ts
+
+
+
+
+var _CreateTagsCommand = class _CreateTagsCommand 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("MagnolioAPIService_v20150201", "CreateTags", {}).n("EFSClient", "CreateTagsCommand").f(void 0, void 0).ser(se_CreateTagsCommand).de(de_CreateTagsCommand).build() {
+};
+__name(_CreateTagsCommand, "CreateTagsCommand");
+var CreateTagsCommand = _CreateTagsCommand;
+
+// src/commands/DeleteAccessPointCommand.ts
+
+
+
+
+var _DeleteAccessPointCommand = class _DeleteAccessPointCommand 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("MagnolioAPIService_v20150201", "DeleteAccessPoint", {}).n("EFSClient", "DeleteAccessPointCommand").f(void 0, void 0).ser(se_DeleteAccessPointCommand).de(de_DeleteAccessPointCommand).build() {
+};
+__name(_DeleteAccessPointCommand, "DeleteAccessPointCommand");
+var DeleteAccessPointCommand = _DeleteAccessPointCommand;
+
+// src/commands/DeleteFileSystemCommand.ts
+
+
+
+
+var _DeleteFileSystemCommand = class _DeleteFileSystemCommand 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("MagnolioAPIService_v20150201", "DeleteFileSystem", {}).n("EFSClient", "DeleteFileSystemCommand").f(void 0, void 0).ser(se_DeleteFileSystemCommand).de(de_DeleteFileSystemCommand).build() {
+};
+__name(_DeleteFileSystemCommand, "DeleteFileSystemCommand");
+var DeleteFileSystemCommand = _DeleteFileSystemCommand;
+
+// src/commands/DeleteFileSystemPolicyCommand.ts
+
+
+
+
+var _DeleteFileSystemPolicyCommand = class _DeleteFileSystemPolicyCommand 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("MagnolioAPIService_v20150201", "DeleteFileSystemPolicy", {}).n("EFSClient", "DeleteFileSystemPolicyCommand").f(void 0, void 0).ser(se_DeleteFileSystemPolicyCommand).de(de_DeleteFileSystemPolicyCommand).build() {
+};
+__name(_DeleteFileSystemPolicyCommand, "DeleteFileSystemPolicyCommand");
+var DeleteFileSystemPolicyCommand = _DeleteFileSystemPolicyCommand;
+
+// src/commands/DeleteMountTargetCommand.ts
+
+
+
+
+var _DeleteMountTargetCommand = class _DeleteMountTargetCommand 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("MagnolioAPIService_v20150201", "DeleteMountTarget", {}).n("EFSClient", "DeleteMountTargetCommand").f(void 0, void 0).ser(se_DeleteMountTargetCommand).de(de_DeleteMountTargetCommand).build() {
+};
+__name(_DeleteMountTargetCommand, "DeleteMountTargetCommand");
+var DeleteMountTargetCommand = _DeleteMountTargetCommand;
+
+// src/commands/DeleteReplicationConfigurationCommand.ts
+
+
+
+
+var _DeleteReplicationConfigurationCommand = class _DeleteReplicationConfigurationCommand 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("MagnolioAPIService_v20150201", "DeleteReplicationConfiguration", {}).n("EFSClient", "DeleteReplicationConfigurationCommand").f(void 0, void 0).ser(se_DeleteReplicationConfigurationCommand).de(de_DeleteReplicationConfigurationCommand).build() {
+};
+__name(_DeleteReplicationConfigurationCommand, "DeleteReplicationConfigurationCommand");
+var DeleteReplicationConfigurationCommand = _DeleteReplicationConfigurationCommand;
+
+// src/commands/DeleteTagsCommand.ts
+
+
+
+
+var _DeleteTagsCommand = class _DeleteTagsCommand 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("MagnolioAPIService_v20150201", "DeleteTags", {}).n("EFSClient", "DeleteTagsCommand").f(void 0, void 0).ser(se_DeleteTagsCommand).de(de_DeleteTagsCommand).build() {
+};
+__name(_DeleteTagsCommand, "DeleteTagsCommand");
+var DeleteTagsCommand = _DeleteTagsCommand;
+
+// src/commands/DescribeAccessPointsCommand.ts
+
+
+
+
+var _DescribeAccessPointsCommand = class _DescribeAccessPointsCommand 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("MagnolioAPIService_v20150201", "DescribeAccessPoints", {}).n("EFSClient", "DescribeAccessPointsCommand").f(void 0, void 0).ser(se_DescribeAccessPointsCommand).de(de_DescribeAccessPointsCommand).build() {
+};
+__name(_DescribeAccessPointsCommand, "DescribeAccessPointsCommand");
+var DescribeAccessPointsCommand = _DescribeAccessPointsCommand;
+
+// src/commands/DescribeAccountPreferencesCommand.ts
+
+
+
+
+var _DescribeAccountPreferencesCommand = class _DescribeAccountPreferencesCommand 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("MagnolioAPIService_v20150201", "DescribeAccountPreferences", {}).n("EFSClient", "DescribeAccountPreferencesCommand").f(void 0, void 0).ser(se_DescribeAccountPreferencesCommand).de(de_DescribeAccountPreferencesCommand).build() {
+};
+__name(_DescribeAccountPreferencesCommand, "DescribeAccountPreferencesCommand");
+var DescribeAccountPreferencesCommand = _DescribeAccountPreferencesCommand;
+
+// src/commands/DescribeBackupPolicyCommand.ts
+
+
+
+
+var _DescribeBackupPolicyCommand = class _DescribeBackupPolicyCommand 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("MagnolioAPIService_v20150201", "DescribeBackupPolicy", {}).n("EFSClient", "DescribeBackupPolicyCommand").f(void 0, void 0).ser(se_DescribeBackupPolicyCommand).de(de_DescribeBackupPolicyCommand).build() {
+};
+__name(_DescribeBackupPolicyCommand, "DescribeBackupPolicyCommand");
+var DescribeBackupPolicyCommand = _DescribeBackupPolicyCommand;
+
+// src/commands/DescribeFileSystemPolicyCommand.ts
+
+
+
+
+var _DescribeFileSystemPolicyCommand = class _DescribeFileSystemPolicyCommand 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("MagnolioAPIService_v20150201", "DescribeFileSystemPolicy", {}).n("EFSClient", "DescribeFileSystemPolicyCommand").f(void 0, void 0).ser(se_DescribeFileSystemPolicyCommand).de(de_DescribeFileSystemPolicyCommand).build() {
+};
+__name(_DescribeFileSystemPolicyCommand, "DescribeFileSystemPolicyCommand");
+var DescribeFileSystemPolicyCommand = _DescribeFileSystemPolicyCommand;
+
+// src/commands/DescribeFileSystemsCommand.ts
+
+
+
+
+var _DescribeFileSystemsCommand = class _DescribeFileSystemsCommand 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("MagnolioAPIService_v20150201", "DescribeFileSystems", {}).n("EFSClient", "DescribeFileSystemsCommand").f(void 0, void 0).ser(se_DescribeFileSystemsCommand).de(de_DescribeFileSystemsCommand).build() {
+};
+__name(_DescribeFileSystemsCommand, "DescribeFileSystemsCommand");
+var DescribeFileSystemsCommand = _DescribeFileSystemsCommand;
+
+// src/commands/DescribeLifecycleConfigurationCommand.ts
+
+
+
+
+var _DescribeLifecycleConfigurationCommand = class _DescribeLifecycleConfigurationCommand 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("MagnolioAPIService_v20150201", "DescribeLifecycleConfiguration", {}).n("EFSClient", "DescribeLifecycleConfigurationCommand").f(void 0, void 0).ser(se_DescribeLifecycleConfigurationCommand).de(de_DescribeLifecycleConfigurationCommand).build() {
+};
+__name(_DescribeLifecycleConfigurationCommand, "DescribeLifecycleConfigurationCommand");
+var DescribeLifecycleConfigurationCommand = _DescribeLifecycleConfigurationCommand;
+
+// src/commands/DescribeMountTargetsCommand.ts
+
+
+
+
+var _DescribeMountTargetsCommand = class _DescribeMountTargetsCommand 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("MagnolioAPIService_v20150201", "DescribeMountTargets", {}).n("EFSClient", "DescribeMountTargetsCommand").f(void 0, void 0).ser(se_DescribeMountTargetsCommand).de(de_DescribeMountTargetsCommand).build() {
+};
+__name(_DescribeMountTargetsCommand, "DescribeMountTargetsCommand");
+var DescribeMountTargetsCommand = _DescribeMountTargetsCommand;
+
+// src/commands/DescribeMountTargetSecurityGroupsCommand.ts
+
+
+
+
+var _DescribeMountTargetSecurityGroupsCommand = class _DescribeMountTargetSecurityGroupsCommand 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("MagnolioAPIService_v20150201", "DescribeMountTargetSecurityGroups", {}).n("EFSClient", "DescribeMountTargetSecurityGroupsCommand").f(void 0, void 0).ser(se_DescribeMountTargetSecurityGroupsCommand).de(de_DescribeMountTargetSecurityGroupsCommand).build() {
+};
+__name(_DescribeMountTargetSecurityGroupsCommand, "DescribeMountTargetSecurityGroupsCommand");
+var DescribeMountTargetSecurityGroupsCommand = _DescribeMountTargetSecurityGroupsCommand;
+
+// src/commands/DescribeReplicationConfigurationsCommand.ts
+
+
+
+
+var _DescribeReplicationConfigurationsCommand = class _DescribeReplicationConfigurationsCommand 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("MagnolioAPIService_v20150201", "DescribeReplicationConfigurations", {}).n("EFSClient", "DescribeReplicationConfigurationsCommand").f(void 0, void 0).ser(se_DescribeReplicationConfigurationsCommand).de(de_DescribeReplicationConfigurationsCommand).build() {
+};
+__name(_DescribeReplicationConfigurationsCommand, "DescribeReplicationConfigurationsCommand");
+var DescribeReplicationConfigurationsCommand = _DescribeReplicationConfigurationsCommand;
+
+// src/commands/DescribeTagsCommand.ts
+
+
+
+
+var _DescribeTagsCommand = class _DescribeTagsCommand 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("MagnolioAPIService_v20150201", "DescribeTags", {}).n("EFSClient", "DescribeTagsCommand").f(void 0, void 0).ser(se_DescribeTagsCommand).de(de_DescribeTagsCommand).build() {
+};
+__name(_DescribeTagsCommand, "DescribeTagsCommand");
+var DescribeTagsCommand = _DescribeTagsCommand;
+
+// 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("MagnolioAPIService_v20150201", "ListTagsForResource", {}).n("EFSClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ModifyMountTargetSecurityGroupsCommand.ts
+
+
+
+
+var _ModifyMountTargetSecurityGroupsCommand = class _ModifyMountTargetSecurityGroupsCommand 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("MagnolioAPIService_v20150201", "ModifyMountTargetSecurityGroups", {}).n("EFSClient", "ModifyMountTargetSecurityGroupsCommand").f(void 0, void 0).ser(se_ModifyMountTargetSecurityGroupsCommand).de(de_ModifyMountTargetSecurityGroupsCommand).build() {
+};
+__name(_ModifyMountTargetSecurityGroupsCommand, "ModifyMountTargetSecurityGroupsCommand");
+var ModifyMountTargetSecurityGroupsCommand = _ModifyMountTargetSecurityGroupsCommand;
+
+// src/commands/PutAccountPreferencesCommand.ts
+
+
+
+
+var _PutAccountPreferencesCommand = class _PutAccountPreferencesCommand 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("MagnolioAPIService_v20150201", "PutAccountPreferences", {}).n("EFSClient", "PutAccountPreferencesCommand").f(void 0, void 0).ser(se_PutAccountPreferencesCommand).de(de_PutAccountPreferencesCommand).build() {
+};
+__name(_PutAccountPreferencesCommand, "PutAccountPreferencesCommand");
+var PutAccountPreferencesCommand = _PutAccountPreferencesCommand;
+
+// src/commands/PutBackupPolicyCommand.ts
+
+
+
+
+var _PutBackupPolicyCommand = class _PutBackupPolicyCommand 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("MagnolioAPIService_v20150201", "PutBackupPolicy", {}).n("EFSClient", "PutBackupPolicyCommand").f(void 0, void 0).ser(se_PutBackupPolicyCommand).de(de_PutBackupPolicyCommand).build() {
+};
+__name(_PutBackupPolicyCommand, "PutBackupPolicyCommand");
+var PutBackupPolicyCommand = _PutBackupPolicyCommand;
+
+// src/commands/PutFileSystemPolicyCommand.ts
+
+
+
+
+var _PutFileSystemPolicyCommand = class _PutFileSystemPolicyCommand 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("MagnolioAPIService_v20150201", "PutFileSystemPolicy", {}).n("EFSClient", "PutFileSystemPolicyCommand").f(void 0, void 0).ser(se_PutFileSystemPolicyCommand).de(de_PutFileSystemPolicyCommand).build() {
+};
+__name(_PutFileSystemPolicyCommand, "PutFileSystemPolicyCommand");
+var PutFileSystemPolicyCommand = _PutFileSystemPolicyCommand;
+
+// src/commands/PutLifecycleConfigurationCommand.ts
+
+
+
+
+var _PutLifecycleConfigurationCommand = class _PutLifecycleConfigurationCommand 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("MagnolioAPIService_v20150201", "PutLifecycleConfiguration", {}).n("EFSClient", "PutLifecycleConfigurationCommand").f(void 0, void 0).ser(se_PutLifecycleConfigurationCommand).de(de_PutLifecycleConfigurationCommand).build() {
+};
+__name(_PutLifecycleConfigurationCommand, "PutLifecycleConfigurationCommand");
+var PutLifecycleConfigurationCommand = _PutLifecycleConfigurationCommand;
+
+// 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("MagnolioAPIService_v20150201", "TagResource", {}).n("EFSClient", "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("MagnolioAPIService_v20150201", "UntagResource", {}).n("EFSClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateFileSystemCommand.ts
+
+
+
+
+var _UpdateFileSystemCommand = class _UpdateFileSystemCommand 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("MagnolioAPIService_v20150201", "UpdateFileSystem", {}).n("EFSClient", "UpdateFileSystemCommand").f(void 0, void 0).ser(se_UpdateFileSystemCommand).de(de_UpdateFileSystemCommand).build() {
+};
+__name(_UpdateFileSystemCommand, "UpdateFileSystemCommand");
+var UpdateFileSystemCommand = _UpdateFileSystemCommand;
+
+// src/commands/UpdateFileSystemProtectionCommand.ts
+
+
+
+
+var _UpdateFileSystemProtectionCommand = class _UpdateFileSystemProtectionCommand 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("MagnolioAPIService_v20150201", "UpdateFileSystemProtection", {}).n("EFSClient", "UpdateFileSystemProtectionCommand").f(void 0, void 0).ser(se_UpdateFileSystemProtectionCommand).de(de_UpdateFileSystemProtectionCommand).build() {
+};
+__name(_UpdateFileSystemProtectionCommand, "UpdateFileSystemProtectionCommand");
+var UpdateFileSystemProtectionCommand = _UpdateFileSystemProtectionCommand;
+
+// src/EFS.ts
+var commands = {
+  CreateAccessPointCommand,
+  CreateFileSystemCommand,
+  CreateMountTargetCommand,
+  CreateReplicationConfigurationCommand,
+  CreateTagsCommand,
+  DeleteAccessPointCommand,
+  DeleteFileSystemCommand,
+  DeleteFileSystemPolicyCommand,
+  DeleteMountTargetCommand,
+  DeleteReplicationConfigurationCommand,
+  DeleteTagsCommand,
+  DescribeAccessPointsCommand,
+  DescribeAccountPreferencesCommand,
+  DescribeBackupPolicyCommand,
+  DescribeFileSystemPolicyCommand,
+  DescribeFileSystemsCommand,
+  DescribeLifecycleConfigurationCommand,
+  DescribeMountTargetsCommand,
+  DescribeMountTargetSecurityGroupsCommand,
+  DescribeReplicationConfigurationsCommand,
+  DescribeTagsCommand,
+  ListTagsForResourceCommand,
+  ModifyMountTargetSecurityGroupsCommand,
+  PutAccountPreferencesCommand,
+  PutBackupPolicyCommand,
+  PutFileSystemPolicyCommand,
+  PutLifecycleConfigurationCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateFileSystemCommand,
+  UpdateFileSystemProtectionCommand
+};
+var _EFS = class _EFS extends EFSClient {
+};
+__name(_EFS, "EFS");
+var EFS = _EFS;
+(0, import_smithy_client.createAggregatedClient)(commands, EFS);
+
+// src/pagination/DescribeAccessPointsPaginator.ts
+
+var paginateDescribeAccessPoints = (0, import_core.createPaginator)(EFSClient, DescribeAccessPointsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeFileSystemsPaginator.ts
+
+var paginateDescribeFileSystems = (0, import_core.createPaginator)(EFSClient, DescribeFileSystemsCommand, "Marker", "NextMarker", "MaxItems");
+
+// src/pagination/DescribeMountTargetsPaginator.ts
+
+var paginateDescribeMountTargets = (0, import_core.createPaginator)(EFSClient, DescribeMountTargetsCommand, "Marker", "NextMarker", "MaxItems");
+
+// src/pagination/DescribeReplicationConfigurationsPaginator.ts
+
+var paginateDescribeReplicationConfigurations = (0, import_core.createPaginator)(EFSClient, DescribeReplicationConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/DescribeTagsPaginator.ts
+
+var paginateDescribeTags = (0, import_core.createPaginator)(EFSClient, DescribeTagsCommand, "Marker", "NextMarker", "MaxItems");
+
+// src/pagination/ListTagsForResourcePaginator.ts
+
+var paginateListTagsForResource = (0, import_core.createPaginator)(EFSClient, ListTagsForResourceCommand, "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 = {
+  AccessPointAlreadyExists,
+  AccessPointLimitExceeded,
+  AccessPointNotFound,
+  AvailabilityZonesMismatch,
+  BadRequest,
+  ConflictException,
+  CreateAccessPointCommand,
+  CreateFileSystemCommand,
+  CreateMountTargetCommand,
+  CreateReplicationConfigurationCommand,
+  CreateTagsCommand,
+  DeleteAccessPointCommand,
+  DeleteFileSystemCommand,
+  DeleteFileSystemPolicyCommand,
+  DeleteMountTargetCommand,
+  DeleteReplicationConfigurationCommand,
+  DeleteTagsCommand,
+  DependencyTimeout,
+  DescribeAccessPointsCommand,
+  DescribeAccountPreferencesCommand,
+  DescribeBackupPolicyCommand,
+  DescribeFileSystemPolicyCommand,
+  DescribeFileSystemsCommand,
+  DescribeLifecycleConfigurationCommand,
+  DescribeMountTargetSecurityGroupsCommand,
+  DescribeMountTargetsCommand,
+  DescribeReplicationConfigurationsCommand,
+  DescribeTagsCommand,
+  EFS,
+  EFSClient,
+  EFSServiceException,
+  FileSystemAlreadyExists,
+  FileSystemInUse,
+  FileSystemLimitExceeded,
+  FileSystemNotFound,
+  IncorrectFileSystemLifeCycleState,
+  IncorrectMountTargetState,
+  InsufficientThroughputCapacity,
+  InternalServerError,
+  InvalidPolicyException,
+  IpAddressInUse,
+  LifeCycleState,
+  ListTagsForResourceCommand,
+  ModifyMountTargetSecurityGroupsCommand,
+  MountTargetConflict,
+  MountTargetNotFound,
+  NetworkInterfaceLimitExceeded,
+  NoFreeAddressesInSubnet,
+  PerformanceMode,
+  PolicyNotFound,
+  PutAccountPreferencesCommand,
+  PutBackupPolicyCommand,
+  PutFileSystemPolicyCommand,
+  PutLifecycleConfigurationCommand,
+  ReplicationAlreadyExists,
+  ReplicationNotFound,
+  ReplicationOverwriteProtection,
+  ReplicationStatus,
+  Resource,
+  ResourceIdType,
+  SecurityGroupLimitExceeded,
+  SecurityGroupNotFound,
+  Status,
+  SubnetNotFound,
+  TagResourceCommand,
+  ThrottlingException,
+  ThroughputLimitExceeded,
+  ThroughputMode,
+  TooManyRequests,
+  TransitionToArchiveRules,
+  TransitionToIARules,
+  TransitionToPrimaryStorageClassRules,
+  UnsupportedAvailabilityZone,
+  UntagResourceCommand,
+  UpdateFileSystemCommand,
+  UpdateFileSystemProtectionCommand,
+  ValidationException,
+  __Client,
+  paginateDescribeAccessPoints,
+  paginateDescribeFileSystems,
+  paginateDescribeMountTargets,
+  paginateDescribeReplicationConfigurations,
+  paginateDescribeTags,
+  paginateListTagsForResource
+});