@aws-sdk/client-efs 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1062 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { EFSServiceException as __BaseException } from "./EFSServiceException";
+
+export declare class AccessPointAlreadyExists extends __BaseException {
+    readonly name: "AccessPointAlreadyExists";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    AccessPointId: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<AccessPointAlreadyExists, __BaseException>);
+}
+export declare enum LifeCycleState {
+    AVAILABLE = "available",
+    CREATING = "creating",
+    DELETED = "deleted",
+    DELETING = "deleting",
+    ERROR = "error",
+    UPDATING = "updating"
+}
+
+export interface PosixUser {
+    
+    Uid: number | undefined;
+    
+    Gid: number | undefined;
+    
+    SecondaryGids?: number[];
+}
+export declare namespace PosixUser {
+    
+    const filterSensitiveLog: (obj: PosixUser) => any;
+}
+
+export interface CreationInfo {
+    
+    OwnerUid: number | undefined;
+    
+    OwnerGid: number | undefined;
+    
+    Permissions: string | undefined;
+}
+export declare namespace CreationInfo {
+    
+    const filterSensitiveLog: (obj: CreationInfo) => any;
+}
+
+export interface RootDirectory {
+    
+    Path?: string;
+    
+    CreationInfo?: CreationInfo;
+}
+export declare namespace RootDirectory {
+    
+    const filterSensitiveLog: (obj: RootDirectory) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface AccessPointDescription {
+    
+    ClientToken?: string;
+    
+    Name?: string;
+    
+    Tags?: Tag[];
+    
+    AccessPointId?: string;
+    
+    AccessPointArn?: string;
+    
+    FileSystemId?: string;
+    
+    PosixUser?: PosixUser;
+    
+    RootDirectory?: RootDirectory;
+    
+    OwnerId?: string;
+    
+    LifeCycleState?: LifeCycleState | string;
+}
+export declare namespace AccessPointDescription {
+    
+    const filterSensitiveLog: (obj: AccessPointDescription) => any;
+}
+
+export declare class AccessPointLimitExceeded extends __BaseException {
+    readonly name: "AccessPointLimitExceeded";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessPointLimitExceeded, __BaseException>);
+}
+
+export declare class AccessPointNotFound extends __BaseException {
+    readonly name: "AccessPointNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessPointNotFound, __BaseException>);
+}
+
+export declare class AvailabilityZonesMismatch extends __BaseException {
+    readonly name: "AvailabilityZonesMismatch";
+    readonly $fault: "client";
+    
+    ErrorCode?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AvailabilityZonesMismatch, __BaseException>);
+}
+export declare enum Status {
+    DISABLED = "DISABLED",
+    DISABLING = "DISABLING",
+    ENABLED = "ENABLED",
+    ENABLING = "ENABLING"
+}
+
+export interface BackupPolicy {
+    
+    Status: Status | string | undefined;
+}
+export declare namespace BackupPolicy {
+    
+    const filterSensitiveLog: (obj: BackupPolicy) => any;
+}
+export interface BackupPolicyDescription {
+    
+    BackupPolicy?: BackupPolicy;
+}
+export declare namespace BackupPolicyDescription {
+    
+    const filterSensitiveLog: (obj: BackupPolicyDescription) => any;
+}
+
+export declare class BadRequest extends __BaseException {
+    readonly name: "BadRequest";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BadRequest, __BaseException>);
+}
+export interface CreateAccessPointRequest {
+    
+    ClientToken?: string;
+    
+    Tags?: Tag[];
+    
+    FileSystemId: string | undefined;
+    
+    PosixUser?: PosixUser;
+    
+    RootDirectory?: RootDirectory;
+}
+export declare namespace CreateAccessPointRequest {
+    
+    const filterSensitiveLog: (obj: CreateAccessPointRequest) => any;
+}
+
+export declare class FileSystemNotFound extends __BaseException {
+    readonly name: "FileSystemNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FileSystemNotFound, __BaseException>);
+}
+
+export declare class IncorrectFileSystemLifeCycleState extends __BaseException {
+    readonly name: "IncorrectFileSystemLifeCycleState";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IncorrectFileSystemLifeCycleState, __BaseException>);
+}
+
+export declare class InternalServerError extends __BaseException {
+    readonly name: "InternalServerError";
+    readonly $fault: "server";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerError, __BaseException>);
+}
+export declare enum PerformanceMode {
+    GENERAL_PURPOSE = "generalPurpose",
+    MAX_IO = "maxIO"
+}
+export declare enum ThroughputMode {
+    BURSTING = "bursting",
+    PROVISIONED = "provisioned"
+}
+export interface CreateFileSystemRequest {
+    
+    CreationToken?: string;
+    
+    PerformanceMode?: PerformanceMode | string;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    ThroughputMode?: ThroughputMode | string;
+    
+    ProvisionedThroughputInMibps?: number;
+    
+    AvailabilityZoneName?: string;
+    
+    Backup?: boolean;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateFileSystemRequest {
+    
+    const filterSensitiveLog: (obj: CreateFileSystemRequest) => any;
+}
+
+export declare class FileSystemAlreadyExists extends __BaseException {
+    readonly name: "FileSystemAlreadyExists";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    FileSystemId: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<FileSystemAlreadyExists, __BaseException>);
+}
+
+export interface FileSystemSize {
+    
+    Value: number | undefined;
+    
+    Timestamp?: Date;
+    
+    ValueInIA?: number;
+    
+    ValueInStandard?: number;
+}
+export declare namespace FileSystemSize {
+    
+    const filterSensitiveLog: (obj: FileSystemSize) => any;
+}
+
+export interface FileSystemDescription {
+    
+    OwnerId: string | undefined;
+    
+    CreationToken: string | undefined;
+    
+    FileSystemId: string | undefined;
+    
+    FileSystemArn?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LifeCycleState: LifeCycleState | string | undefined;
+    
+    Name?: string;
+    
+    NumberOfMountTargets: number | undefined;
+    
+    SizeInBytes: FileSystemSize | undefined;
+    
+    PerformanceMode: PerformanceMode | string | undefined;
+    
+    Encrypted?: boolean;
+    
+    KmsKeyId?: string;
+    
+    ThroughputMode?: ThroughputMode | string;
+    
+    ProvisionedThroughputInMibps?: number;
+    
+    AvailabilityZoneName?: string;
+    
+    AvailabilityZoneId?: string;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace FileSystemDescription {
+    
+    const filterSensitiveLog: (obj: FileSystemDescription) => any;
+}
+
+export declare class FileSystemLimitExceeded extends __BaseException {
+    readonly name: "FileSystemLimitExceeded";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FileSystemLimitExceeded, __BaseException>);
+}
+
+export declare class InsufficientThroughputCapacity extends __BaseException {
+    readonly name: "InsufficientThroughputCapacity";
+    readonly $fault: "server";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InsufficientThroughputCapacity, __BaseException>);
+}
+
+export declare class ThroughputLimitExceeded extends __BaseException {
+    readonly name: "ThroughputLimitExceeded";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ThroughputLimitExceeded, __BaseException>);
+}
+
+export declare class UnsupportedAvailabilityZone extends __BaseException {
+    readonly name: "UnsupportedAvailabilityZone";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedAvailabilityZone, __BaseException>);
+}
+
+export interface CreateMountTargetRequest {
+    
+    FileSystemId: string | undefined;
+    
+    SubnetId: string | undefined;
+    
+    IpAddress?: string;
+    
+    SecurityGroups?: string[];
+}
+export declare namespace CreateMountTargetRequest {
+    
+    const filterSensitiveLog: (obj: CreateMountTargetRequest) => any;
+}
+
+export declare class IpAddressInUse extends __BaseException {
+    readonly name: "IpAddressInUse";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IpAddressInUse, __BaseException>);
+}
+
+export declare class MountTargetConflict extends __BaseException {
+    readonly name: "MountTargetConflict";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MountTargetConflict, __BaseException>);
+}
+
+export interface MountTargetDescription {
+    
+    OwnerId?: string;
+    
+    MountTargetId: string | undefined;
+    
+    FileSystemId: string | undefined;
+    
+    SubnetId: string | undefined;
+    
+    LifeCycleState: LifeCycleState | string | undefined;
+    
+    IpAddress?: string;
+    
+    NetworkInterfaceId?: string;
+    
+    AvailabilityZoneId?: string;
+    
+    AvailabilityZoneName?: string;
+    
+    VpcId?: string;
+}
+export declare namespace MountTargetDescription {
+    
+    const filterSensitiveLog: (obj: MountTargetDescription) => any;
+}
+
+export declare class NetworkInterfaceLimitExceeded extends __BaseException {
+    readonly name: "NetworkInterfaceLimitExceeded";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NetworkInterfaceLimitExceeded, __BaseException>);
+}
+
+export declare class NoFreeAddressesInSubnet extends __BaseException {
+    readonly name: "NoFreeAddressesInSubnet";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NoFreeAddressesInSubnet, __BaseException>);
+}
+
+export declare class SecurityGroupLimitExceeded extends __BaseException {
+    readonly name: "SecurityGroupLimitExceeded";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SecurityGroupLimitExceeded, __BaseException>);
+}
+
+export declare class SecurityGroupNotFound extends __BaseException {
+    readonly name: "SecurityGroupNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SecurityGroupNotFound, __BaseException>);
+}
+
+export declare class SubnetNotFound extends __BaseException {
+    readonly name: "SubnetNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SubnetNotFound, __BaseException>);
+}
+
+export interface DestinationToCreate {
+    
+    Region?: string;
+    
+    AvailabilityZoneName?: string;
+    
+    KmsKeyId?: string;
+}
+export declare namespace DestinationToCreate {
+    
+    const filterSensitiveLog: (obj: DestinationToCreate) => any;
+}
+export interface CreateReplicationConfigurationRequest {
+    
+    SourceFileSystemId: string | undefined;
+    
+    Destinations: DestinationToCreate[] | undefined;
+}
+export declare namespace CreateReplicationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateReplicationConfigurationRequest) => any;
+}
+export declare enum ReplicationStatus {
+    DELETING = "DELETING",
+    ENABLED = "ENABLED",
+    ENABLING = "ENABLING",
+    ERROR = "ERROR"
+}
+
+export interface Destination {
+    
+    Status: ReplicationStatus | string | undefined;
+    
+    FileSystemId: string | undefined;
+    
+    Region: string | undefined;
+    
+    LastReplicatedTimestamp?: Date;
+}
+export declare namespace Destination {
+    
+    const filterSensitiveLog: (obj: Destination) => any;
+}
+export interface ReplicationConfigurationDescription {
+    
+    SourceFileSystemId: string | undefined;
+    
+    SourceFileSystemRegion: string | undefined;
+    
+    SourceFileSystemArn: string | undefined;
+    
+    OriginalSourceFileSystemArn: string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    Destinations: Destination[] | undefined;
+}
+export declare namespace ReplicationConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: ReplicationConfigurationDescription) => any;
+}
+
+export declare class ReplicationNotFound extends __BaseException {
+    readonly name: "ReplicationNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ReplicationNotFound, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface CreateTagsRequest {
+    
+    FileSystemId: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace CreateTagsRequest {
+    
+    const filterSensitiveLog: (obj: CreateTagsRequest) => any;
+}
+export interface DeleteAccessPointRequest {
+    
+    AccessPointId: string | undefined;
+}
+export declare namespace DeleteAccessPointRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAccessPointRequest) => any;
+}
+
+export interface DeleteFileSystemRequest {
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DeleteFileSystemRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFileSystemRequest) => any;
+}
+
+export declare class FileSystemInUse extends __BaseException {
+    readonly name: "FileSystemInUse";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FileSystemInUse, __BaseException>);
+}
+export interface DeleteFileSystemPolicyRequest {
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DeleteFileSystemPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFileSystemPolicyRequest) => any;
+}
+
+export interface DeleteMountTargetRequest {
+    
+    MountTargetId: string | undefined;
+}
+export declare namespace DeleteMountTargetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMountTargetRequest) => any;
+}
+
+export declare class DependencyTimeout extends __BaseException {
+    readonly name: "DependencyTimeout";
+    readonly $fault: "server";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DependencyTimeout, __BaseException>);
+}
+
+export declare class MountTargetNotFound extends __BaseException {
+    readonly name: "MountTargetNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<MountTargetNotFound, __BaseException>);
+}
+export interface DeleteReplicationConfigurationRequest {
+    
+    SourceFileSystemId: string | undefined;
+}
+export declare namespace DeleteReplicationConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteReplicationConfigurationRequest) => any;
+}
+
+export interface DeleteTagsRequest {
+    
+    FileSystemId: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace DeleteTagsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTagsRequest) => any;
+}
+export interface DescribeAccessPointsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    AccessPointId?: string;
+    
+    FileSystemId?: string;
+}
+export declare namespace DescribeAccessPointsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccessPointsRequest) => any;
+}
+export interface DescribeAccessPointsResponse {
+    
+    AccessPoints?: AccessPointDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccessPointsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAccessPointsResponse) => any;
+}
+export interface DescribeAccountPreferencesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeAccountPreferencesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccountPreferencesRequest) => any;
+}
+export declare enum ResourceIdType {
+    LongId = "LONG_ID",
+    ShortId = "SHORT_ID"
+}
+export declare enum Resource {
+    FileSystem = "FILE_SYSTEM",
+    MountTarget = "MOUNT_TARGET"
+}
+
+export interface ResourceIdPreference {
+    
+    ResourceIdType?: ResourceIdType | string;
+    
+    Resources?: (Resource | string)[];
+}
+export declare namespace ResourceIdPreference {
+    
+    const filterSensitiveLog: (obj: ResourceIdPreference) => any;
+}
+export interface DescribeAccountPreferencesResponse {
+    
+    ResourceIdPreference?: ResourceIdPreference;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccountPreferencesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAccountPreferencesResponse) => any;
+}
+export interface DescribeBackupPolicyRequest {
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DescribeBackupPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DescribeBackupPolicyRequest) => any;
+}
+
+export declare class PolicyNotFound extends __BaseException {
+    readonly name: "PolicyNotFound";
+    readonly $fault: "client";
+    
+    ErrorCode?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<PolicyNotFound, __BaseException>);
+}
+export interface DescribeFileSystemPolicyRequest {
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DescribeFileSystemPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFileSystemPolicyRequest) => any;
+}
+export interface FileSystemPolicyDescription {
+    
+    FileSystemId?: string;
+    
+    Policy?: string;
+}
+export declare namespace FileSystemPolicyDescription {
+    
+    const filterSensitiveLog: (obj: FileSystemPolicyDescription) => any;
+}
+
+export interface DescribeFileSystemsRequest {
+    
+    MaxItems?: number;
+    
+    Marker?: string;
+    
+    CreationToken?: string;
+    
+    FileSystemId?: string;
+}
+export declare namespace DescribeFileSystemsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFileSystemsRequest) => any;
+}
+export interface DescribeFileSystemsResponse {
+    
+    Marker?: string;
+    
+    FileSystems?: FileSystemDescription[];
+    
+    NextMarker?: string;
+}
+export declare namespace DescribeFileSystemsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFileSystemsResponse) => any;
+}
+export interface DescribeLifecycleConfigurationRequest {
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DescribeLifecycleConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeLifecycleConfigurationRequest) => any;
+}
+export declare enum TransitionToIARules {
+    AFTER_14_DAYS = "AFTER_14_DAYS",
+    AFTER_30_DAYS = "AFTER_30_DAYS",
+    AFTER_60_DAYS = "AFTER_60_DAYS",
+    AFTER_7_DAYS = "AFTER_7_DAYS",
+    AFTER_90_DAYS = "AFTER_90_DAYS"
+}
+export declare enum TransitionToPrimaryStorageClassRules {
+    AFTER_1_ACCESS = "AFTER_1_ACCESS"
+}
+
+export interface LifecyclePolicy {
+    
+    TransitionToIA?: TransitionToIARules | string;
+    
+    TransitionToPrimaryStorageClass?: TransitionToPrimaryStorageClassRules | string;
+}
+export declare namespace LifecyclePolicy {
+    
+    const filterSensitiveLog: (obj: LifecyclePolicy) => any;
+}
+export interface LifecycleConfigurationDescription {
+    
+    LifecyclePolicies?: LifecyclePolicy[];
+}
+export declare namespace LifecycleConfigurationDescription {
+    
+    const filterSensitiveLog: (obj: LifecycleConfigurationDescription) => any;
+}
+
+export interface DescribeMountTargetsRequest {
+    
+    MaxItems?: number;
+    
+    Marker?: string;
+    
+    FileSystemId?: string;
+    
+    MountTargetId?: string;
+    
+    AccessPointId?: string;
+}
+export declare namespace DescribeMountTargetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMountTargetsRequest) => any;
+}
+
+export interface DescribeMountTargetsResponse {
+    
+    Marker?: string;
+    
+    MountTargets?: MountTargetDescription[];
+    
+    NextMarker?: string;
+}
+export declare namespace DescribeMountTargetsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMountTargetsResponse) => any;
+}
+
+export interface DescribeMountTargetSecurityGroupsRequest {
+    
+    MountTargetId: string | undefined;
+}
+export declare namespace DescribeMountTargetSecurityGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMountTargetSecurityGroupsRequest) => any;
+}
+export interface DescribeMountTargetSecurityGroupsResponse {
+    
+    SecurityGroups: string[] | undefined;
+}
+export declare namespace DescribeMountTargetSecurityGroupsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMountTargetSecurityGroupsResponse) => any;
+}
+
+export declare class IncorrectMountTargetState extends __BaseException {
+    readonly name: "IncorrectMountTargetState";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IncorrectMountTargetState, __BaseException>);
+}
+export interface DescribeReplicationConfigurationsRequest {
+    
+    FileSystemId?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeReplicationConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeReplicationConfigurationsRequest) => any;
+}
+export interface DescribeReplicationConfigurationsResponse {
+    
+    Replications?: ReplicationConfigurationDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeReplicationConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeReplicationConfigurationsResponse) => any;
+}
+
+export interface DescribeTagsRequest {
+    
+    MaxItems?: number;
+    
+    Marker?: string;
+    
+    FileSystemId: string | undefined;
+}
+export declare namespace DescribeTagsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTagsRequest) => any;
+}
+
+export interface DescribeTagsResponse {
+    
+    Marker?: string;
+    
+    Tags: Tag[] | undefined;
+    
+    NextMarker?: string;
+}
+export declare namespace DescribeTagsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeTagsResponse) => any;
+}
+
+export declare class InvalidPolicyException extends __BaseException {
+    readonly name: "InvalidPolicyException";
+    readonly $fault: "client";
+    
+    ErrorCode?: string;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidPolicyException, __BaseException>);
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface ModifyMountTargetSecurityGroupsRequest {
+    
+    MountTargetId: string | undefined;
+    
+    SecurityGroups?: string[];
+}
+export declare namespace ModifyMountTargetSecurityGroupsRequest {
+    
+    const filterSensitiveLog: (obj: ModifyMountTargetSecurityGroupsRequest) => any;
+}
+export interface PutAccountPreferencesRequest {
+    
+    ResourceIdType: ResourceIdType | string | undefined;
+}
+export declare namespace PutAccountPreferencesRequest {
+    
+    const filterSensitiveLog: (obj: PutAccountPreferencesRequest) => any;
+}
+export interface PutAccountPreferencesResponse {
+    
+    ResourceIdPreference?: ResourceIdPreference;
+}
+export declare namespace PutAccountPreferencesResponse {
+    
+    const filterSensitiveLog: (obj: PutAccountPreferencesResponse) => any;
+}
+export interface PutBackupPolicyRequest {
+    
+    FileSystemId: string | undefined;
+    
+    BackupPolicy: BackupPolicy | undefined;
+}
+export declare namespace PutBackupPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutBackupPolicyRequest) => any;
+}
+export interface PutFileSystemPolicyRequest {
+    
+    FileSystemId: string | undefined;
+    
+    Policy: string | undefined;
+    
+    BypassPolicyLockoutSafetyCheck?: boolean;
+}
+export declare namespace PutFileSystemPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutFileSystemPolicyRequest) => any;
+}
+export interface PutLifecycleConfigurationRequest {
+    
+    FileSystemId: string | undefined;
+    
+    LifecyclePolicies: LifecyclePolicy[] | undefined;
+}
+export declare namespace PutLifecycleConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: PutLifecycleConfigurationRequest) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceId: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+
+export declare class TooManyRequests extends __BaseException {
+    readonly name: "TooManyRequests";
+    readonly $fault: "client";
+    
+    ErrorCode: string | undefined;
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyRequests, __BaseException>);
+}
+export interface UpdateFileSystemRequest {
+    
+    FileSystemId: string | undefined;
+    
+    ThroughputMode?: ThroughputMode | string;
+    
+    ProvisionedThroughputInMibps?: number;
+}
+export declare namespace UpdateFileSystemRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFileSystemRequest) => any;
+}