@aws-sdk/client-efs 3.934.0 → 3.935.0

package/dist-types/models/errors.d.ts

@@ -0,0 +1,905 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { EFSServiceException as __BaseException } from "./EFSServiceException";
+/**
+ * <p>Returned if the access point that you are trying to create already exists, with the
+ *             creation token you provided in the request.</p>
+ * @public
+ */
+export declare class AccessPointAlreadyExists extends __BaseException {
+    readonly name: "AccessPointAlreadyExists";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    AccessPointId: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessPointAlreadyExists, __BaseException>);
+}
+/**
+ * <p>Returned if the Amazon Web Services account has already created the maximum number of access points
+ *             allowed per file system. For more informaton, see <a href="https://docs.aws.amazon.com/efs/latest/ug/limits.html#limits-efs-resources-per-account-per-region">https://docs.aws.amazon.com/efs/latest/ug/limits.html#limits-efs-resources-per-account-per-region</a>.</p>
+ * @public
+ */
+export declare class AccessPointLimitExceeded extends __BaseException {
+    readonly name: "AccessPointLimitExceeded";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessPointLimitExceeded, __BaseException>);
+}
+/**
+ * <p>Returned if the specified <code>AccessPointId</code> value doesn't exist in the
+ *             requester's Amazon Web Services account.</p>
+ * @public
+ */
+export declare class AccessPointNotFound extends __BaseException {
+    readonly name: "AccessPointNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessPointNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if the Availability Zone that was specified for a mount target is
+ *             different from the Availability Zone that was specified for One Zone storage.
+ *             For more information, see <a href="https://docs.aws.amazon.com/efs/latest/ug/availability-durability.html">Regional and One Zone storage redundancy</a>.</p>
+ * @public
+ */
+export declare class AvailabilityZonesMismatch extends __BaseException {
+    readonly name: "AvailabilityZonesMismatch";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AvailabilityZonesMismatch, __BaseException>);
+}
+/**
+ * <p>Returned if the request is malformed or contains an error such as an invalid
+ *             parameter value or a missing required parameter.</p>
+ * @public
+ */
+export declare class BadRequest extends __BaseException {
+    readonly name: "BadRequest";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<BadRequest, __BaseException>);
+}
+/**
+ * <p>Returned if the source file system in a replication is encrypted but the destination file system is unencrypted.</p>
+ * @public
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+/**
+ * <p>Returned if the specified <code>FileSystemId</code> value doesn't exist in the
+ *             requester's Amazon Web Services account.</p>
+ * @public
+ */
+export declare class FileSystemNotFound extends __BaseException {
+    readonly name: "FileSystemNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<FileSystemNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if the file system's lifecycle state is not "available".</p>
+ * @public
+ */
+export declare class IncorrectFileSystemLifeCycleState extends __BaseException {
+    readonly name: "IncorrectFileSystemLifeCycleState";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IncorrectFileSystemLifeCycleState, __BaseException>);
+}
+/**
+ * <p>Returned if an error occurred on the server side.</p>
+ * @public
+ */
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+/**
+ * <p>Returned when the <code>CreateAccessPoint</code> API action is called too quickly and
+ *             the number of Access Points on the file system is nearing the
+ *             <a href="https://docs.aws.amazon.com/efs/latest/ug/limits.html#limits-efs-resources-per-account-per-region">limit of 120</a>.</p>
+ * @public
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * <p>Returned if the file system you are trying to create already exists, with the
+ *             creation token you provided.</p>
+ * @public
+ */
+export declare class FileSystemAlreadyExists extends __BaseException {
+    readonly name: "FileSystemAlreadyExists";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    FileSystemId: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<FileSystemAlreadyExists, __BaseException>);
+}
+/**
+ * <p>Returned if the Amazon Web Services account has already created the maximum number of file systems
+ *             allowed per account.</p>
+ * @public
+ */
+export declare class FileSystemLimitExceeded extends __BaseException {
+    readonly name: "FileSystemLimitExceeded";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<FileSystemLimitExceeded, __BaseException>);
+}
+/**
+ * <p>Returned if there's not enough capacity to provision additional throughput. This value
+ *             might be returned when you try to create a file system in provisioned throughput mode,
+ *             when you attempt to increase the provisioned throughput of an existing file system, or
+ *             when you attempt to change an existing file system from Bursting Throughput to
+ *             Provisioned Throughput mode. Try again later.</p>
+ * @public
+ */
+export declare class InsufficientThroughputCapacity extends __BaseException {
+    readonly name: "InsufficientThroughputCapacity";
+    readonly $fault: "server";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InsufficientThroughputCapacity, __BaseException>);
+}
+/**
+ * <p>Returned if the throughput mode or amount of provisioned throughput can't be changed
+ *             because the throughput limit of 1024 MiB/s has been reached.</p>
+ * @public
+ */
+export declare class ThroughputLimitExceeded extends __BaseException {
+    readonly name: "ThroughputLimitExceeded";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThroughputLimitExceeded, __BaseException>);
+}
+/**
+ * <p>Returned if the requested Amazon EFS functionality is not available in the specified Availability Zone.</p>
+ * @public
+ */
+export declare class UnsupportedAvailabilityZone extends __BaseException {
+    readonly name: "UnsupportedAvailabilityZone";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<UnsupportedAvailabilityZone, __BaseException>);
+}
+/**
+ * <p>Returned if the request specified an <code>IpAddress</code> that is already in use
+ *             in the subnet.</p>
+ * @public
+ */
+export declare class IpAddressInUse extends __BaseException {
+    readonly name: "IpAddressInUse";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IpAddressInUse, __BaseException>);
+}
+/**
+ * <p>Returned if the mount target would violate one of the specified restrictions based
+ *             on the file system's existing mount targets.</p>
+ * @public
+ */
+export declare class MountTargetConflict extends __BaseException {
+    readonly name: "MountTargetConflict";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MountTargetConflict, __BaseException>);
+}
+/**
+ * <p>The calling account has reached the limit for elastic network interfaces for the
+ *             specific Amazon Web Services Region. Either delete some network interfaces or request
+ *             that the account quota be raised. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon VPC Quotas</a>
+ *             in the <i>Amazon VPC User Guide</i> (see the <b>Network
+ *                 interfaces per Region</b> entry in the <b>Network
+ *                 interfaces</b> table). </p>
+ * @public
+ */
+export declare class NetworkInterfaceLimitExceeded extends __BaseException {
+    readonly name: "NetworkInterfaceLimitExceeded";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NetworkInterfaceLimitExceeded, __BaseException>);
+}
+/**
+ * <p>Returned if <code>IpAddress</code> was not specified in the request and there are
+ *             no free IP addresses in the subnet.</p>
+ * @public
+ */
+export declare class NoFreeAddressesInSubnet extends __BaseException {
+    readonly name: "NoFreeAddressesInSubnet";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<NoFreeAddressesInSubnet, __BaseException>);
+}
+/**
+ * <p>Returned if the number of <code>SecurityGroups</code> specified in the request is
+ *             greater than the limit, which is based on account quota.  Either delete some security groups
+ *             or request that the account quota be raised. For more information, see <a href="https://docs.aws.amazon.com/vpc/latest/userguide/amazon-vpc-limits.html">Amazon VPC Quotas</a>
+ *             in the <i>Amazon VPC User Guide</i> (see the <b>Security Groups</b>
+ *             table).
+ *         </p>
+ * @public
+ */
+export declare class SecurityGroupLimitExceeded extends __BaseException {
+    readonly name: "SecurityGroupLimitExceeded";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SecurityGroupLimitExceeded, __BaseException>);
+}
+/**
+ * <p>Returned if one of the specified security groups doesn't exist in the subnet's
+ *             virtual private cloud (VPC).</p>
+ * @public
+ */
+export declare class SecurityGroupNotFound extends __BaseException {
+    readonly name: "SecurityGroupNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SecurityGroupNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if there is no subnet with ID <code>SubnetId</code> provided in the
+ *             request.</p>
+ * @public
+ */
+export declare class SubnetNotFound extends __BaseException {
+    readonly name: "SubnetNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SubnetNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if the specified file system does not have a replication
+ *             configuration.</p>
+ * @public
+ */
+export declare class ReplicationNotFound extends __BaseException {
+    readonly name: "ReplicationNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>ReplicationNotFound</p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if the Backup service is not available in the Amazon Web Services Region in which the request was made.</p>
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+/**
+ * <p>Returned if a file system has mount targets.</p>
+ * @public
+ */
+export declare class FileSystemInUse extends __BaseException {
+    readonly name: "FileSystemInUse";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<FileSystemInUse, __BaseException>);
+}
+/**
+ * <p>The service timed out trying to fulfill the request, and the client should try the
+ *             call again.</p>
+ * @public
+ */
+export declare class DependencyTimeout extends __BaseException {
+    readonly name: "DependencyTimeout";
+    readonly $fault: "server";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DependencyTimeout, __BaseException>);
+}
+/**
+ * <p>Returned if there is no mount target with the specified ID found in the
+ *             caller's Amazon Web Services account.</p>
+ * @public
+ */
+export declare class MountTargetNotFound extends __BaseException {
+    readonly name: "MountTargetNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MountTargetNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if <code>no backup</code> is specified for a One Zone EFS file system.</p>
+ * @public
+ */
+export declare class PolicyNotFound extends __BaseException {
+    readonly name: "PolicyNotFound";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<PolicyNotFound, __BaseException>);
+}
+/**
+ * <p>Returned if the mount target is not in the correct state for the
+ *             operation.</p>
+ * @public
+ */
+export declare class IncorrectMountTargetState extends __BaseException {
+    readonly name: "IncorrectMountTargetState";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<IncorrectMountTargetState, __BaseException>);
+}
+/**
+ * <p>Returned if the <code>FileSystemPolicy</code> is malformed or contains an error such
+ *             as a parameter value that is not valid or a missing required parameter. Returned in the
+ *             case of a policy lockout safety check error.</p>
+ * @public
+ */
+export declare class InvalidPolicyException extends __BaseException {
+    readonly name: "InvalidPolicyException";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidPolicyException, __BaseException>);
+}
+/**
+ * <p>Returned if you don’t wait at least 24 hours before either changing the throughput mode, or
+ *             decreasing the Provisioned Throughput value.</p>
+ * @public
+ */
+export declare class TooManyRequests extends __BaseException {
+    readonly name: "TooManyRequests";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<TooManyRequests, __BaseException>);
+}
+/**
+ * <p>Returned if the file system is already included in a replication configuration.></p>
+ * @public
+ */
+export declare class ReplicationAlreadyExists extends __BaseException {
+    readonly name: "ReplicationAlreadyExists";
+    readonly $fault: "client";
+    /**
+     * <p>The error code is a string that uniquely identifies an error condition.
+     *         It is meant to be read and understood by programs that detect and handle errors by type. </p>
+     * @public
+     */
+    ErrorCode?: string | undefined;
+    /**
+     * <p>The error message contains a generic description of the error
+     *         condition in English. It is intended for a human audience. Simple programs display the message directly
+     *         to the end user if they encounter an error condition they don't know how or don't care to handle.
+     *         Sophisticated programs with more exhaustive error handling and proper internationalization are
+     *         more likely to ignore the error message.</p>
+     * @public
+     */
+    Message?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ReplicationAlreadyExists, __BaseException>);
+}