@aws-sdk/client-fsx 3.43.0 → 3.47.0

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

@@ -29,15 +29,14 @@ export interface ActiveDirectoryError extends __SmithyException, $MetadataBearer
     
     Message?: string;
 }
-export declare namespace ActiveDirectoryError {
-    
-    const filterSensitiveLog: (obj: ActiveDirectoryError) => any;
-}
 export declare enum AdministrativeActionType {
     FILE_SYSTEM_ALIAS_ASSOCIATION = "FILE_SYSTEM_ALIAS_ASSOCIATION",
     FILE_SYSTEM_ALIAS_DISASSOCIATION = "FILE_SYSTEM_ALIAS_DISASSOCIATION",
     FILE_SYSTEM_UPDATE = "FILE_SYSTEM_UPDATE",
-    STORAGE_OPTIMIZATION = "STORAGE_OPTIMIZATION"
+    RELEASE_NFS_V3_LOCKS = "RELEASE_NFS_V3_LOCKS",
+    SNAPSHOT_UPDATE = "SNAPSHOT_UPDATE",
+    STORAGE_OPTIMIZATION = "STORAGE_OPTIMIZATION",
+    VOLUME_UPDATE = "VOLUME_UPDATE"
 }
 
 export interface AdministrativeActionFailureDetails {
@@ -67,6 +66,7 @@ export declare namespace FileSystemFailureDetails {
 export declare enum FileSystemType {
     LUSTRE = "LUSTRE",
     ONTAP = "ONTAP",
+    OPENZFS = "OPENZFS",
     WINDOWS = "WINDOWS"
 }
 export declare enum FileSystemLifecycle {
@@ -84,6 +84,7 @@ export declare enum DataCompressionType {
 export declare enum AutoImportPolicyType {
     NEW = "NEW",
     NEW_CHANGED = "NEW_CHANGED",
+    NEW_CHANGED_DELETED = "NEW_CHANGED_DELETED",
     NONE = "NONE"
 }
 
@@ -99,6 +100,7 @@ export declare enum DataRepositoryLifecycle {
     AVAILABLE = "AVAILABLE",
     CREATING = "CREATING",
     DELETING = "DELETING",
+    FAILED = "FAILED",
     MISCONFIGURED = "MISCONFIGURED",
     UPDATING = "UPDATING"
 }
@@ -123,6 +125,7 @@ export declare namespace DataRepositoryConfiguration {
 }
 export declare enum LustreDeploymentType {
     PERSISTENT_1 = "PERSISTENT_1",
+    PERSISTENT_2 = "PERSISTENT_2",
     SCRATCH_1 = "SCRATCH_1",
     SCRATCH_2 = "SCRATCH_2"
 }
@@ -130,6 +133,23 @@ export declare enum DriveCacheType {
     NONE = "NONE",
     READ = "READ"
 }
+export declare enum LustreAccessAuditLogLevel {
+    DISABLED = "DISABLED",
+    ERROR_ONLY = "ERROR_ONLY",
+    WARN_ERROR = "WARN_ERROR",
+    WARN_ONLY = "WARN_ONLY"
+}
+
+export interface LustreLogConfiguration {
+    
+    Level: LustreAccessAuditLogLevel | string | undefined;
+    
+    Destination?: string;
+}
+export declare namespace LustreLogConfiguration {
+    
+    const filterSensitiveLog: (obj: LustreLogConfiguration) => any;
+}
 
 export interface LustreFileSystemConfiguration {
     
@@ -152,6 +172,8 @@ export interface LustreFileSystemConfiguration {
     DriveCacheType?: DriveCacheType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogConfiguration;
 }
 export declare namespace LustreFileSystemConfiguration {
     
@@ -224,6 +246,34 @@ export declare namespace OntapFileSystemConfiguration {
     
     const filterSensitiveLog: (obj: OntapFileSystemConfiguration) => any;
 }
+export declare enum OpenZFSDeploymentType {
+    SINGLE_AZ_1 = "SINGLE_AZ_1"
+}
+
+export interface OpenZFSFileSystemConfiguration {
+    
+    AutomaticBackupRetentionDays?: number;
+    
+    CopyTagsToBackups?: boolean;
+    
+    CopyTagsToVolumes?: boolean;
+    
+    DailyAutomaticBackupStartTime?: string;
+    
+    DeploymentType?: OpenZFSDeploymentType | string;
+    
+    ThroughputCapacity?: number;
+    
+    WeeklyMaintenanceStartTime?: string;
+    
+    DiskIopsConfiguration?: DiskIopsConfiguration;
+    
+    RootVolumeId?: string;
+}
+export declare namespace OpenZFSFileSystemConfiguration {
+    
+    const filterSensitiveLog: (obj: OpenZFSFileSystemConfiguration) => any;
+}
 export declare enum StorageType {
     HDD = "HDD",
     SSD = "SSD"
@@ -337,7 +387,14 @@ export declare namespace WindowsFileSystemConfiguration {
     
     const filterSensitiveLog: (obj: WindowsFileSystemConfiguration) => any;
 }
+export declare enum SnapshotLifecycle {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    PENDING = "PENDING"
+}
 export declare enum VolumeLifecycle {
+    AVAILABLE = "AVAILABLE",
     CREATED = "CREATED",
     CREATING = "CREATING",
     DELETING = "DELETING",
@@ -413,35 +470,92 @@ export declare namespace OntapVolumeConfiguration {
     
     const filterSensitiveLog: (obj: OntapVolumeConfiguration) => any;
 }
-export declare enum VolumeType {
-    ONTAP = "ONTAP"
+export declare enum OpenZFSDataCompressionType {
+    NONE = "NONE",
+    ZSTD = "ZSTD"
 }
 
-export interface Volume {
+export interface OpenZFSClientConfiguration {
     
-    CreationTime?: Date;
+    Clients: string | undefined;
     
-    FileSystemId?: string;
+    Options: string[] | undefined;
+}
+export declare namespace OpenZFSClientConfiguration {
     
-    Lifecycle?: VolumeLifecycle | string;
+    const filterSensitiveLog: (obj: OpenZFSClientConfiguration) => any;
+}
+
+export interface OpenZFSNfsExport {
     
-    Name?: string;
+    ClientConfigurations: OpenZFSClientConfiguration[] | undefined;
+}
+export declare namespace OpenZFSNfsExport {
     
-    OntapConfiguration?: OntapVolumeConfiguration;
+    const filterSensitiveLog: (obj: OpenZFSNfsExport) => any;
+}
+export declare enum OpenZFSCopyStrategy {
+    CLONE = "CLONE",
+    FULL_COPY = "FULL_COPY"
+}
+
+export interface OpenZFSOriginSnapshotConfiguration {
     
-    ResourceARN?: string;
+    SnapshotARN?: string;
     
-    Tags?: Tag[];
+    CopyStrategy?: OpenZFSCopyStrategy | string;
+}
+export declare namespace OpenZFSOriginSnapshotConfiguration {
     
-    VolumeId?: string;
+    const filterSensitiveLog: (obj: OpenZFSOriginSnapshotConfiguration) => any;
+}
+export declare enum OpenZFSQuotaType {
+    GROUP = "GROUP",
+    USER = "USER"
+}
+
+export interface OpenZFSUserOrGroupQuota {
     
-    VolumeType?: VolumeType | string;
+    Type: OpenZFSQuotaType | string | undefined;
     
-    LifecycleTransitionReason?: LifecycleTransitionReason;
+    Id: number | undefined;
+    
+    StorageCapacityQuotaGiB: number | undefined;
 }
-export declare namespace Volume {
+export declare namespace OpenZFSUserOrGroupQuota {
     
-    const filterSensitiveLog: (obj: Volume) => any;
+    const filterSensitiveLog: (obj: OpenZFSUserOrGroupQuota) => any;
+}
+
+export interface OpenZFSVolumeConfiguration {
+    
+    ParentVolumeId?: string;
+    
+    VolumePath?: string;
+    
+    StorageCapacityReservationGiB?: number;
+    
+    StorageCapacityQuotaGiB?: number;
+    
+    DataCompressionType?: OpenZFSDataCompressionType | string;
+    
+    CopyTagsToSnapshots?: boolean;
+    
+    OriginSnapshot?: OpenZFSOriginSnapshotConfiguration;
+    
+    ReadOnly?: boolean;
+    
+    NfsExports?: OpenZFSNfsExport[];
+    
+    UserAndGroupQuotas?: OpenZFSUserOrGroupQuota[];
+}
+export declare namespace OpenZFSVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: OpenZFSVolumeConfiguration) => any;
+}
+export declare enum VolumeType {
+    ONTAP = "ONTAP",
+    OPENZFS = "OPENZFS"
 }
 
 export interface AssociateFileSystemAliasesRequest {
@@ -472,10 +586,6 @@ export interface BadRequest extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace BadRequest {
-    
-    const filterSensitiveLog: (obj: BadRequest) => any;
-}
 
 export interface FileSystemNotFound extends __SmithyException, $MetadataBearer {
     name: "FileSystemNotFound";
@@ -483,10 +593,6 @@ export interface FileSystemNotFound extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace FileSystemNotFound {
-    
-    const filterSensitiveLog: (obj: FileSystemNotFound) => any;
-}
 
 export interface InternalServerError extends __SmithyException, $MetadataBearer {
     name: "InternalServerError";
@@ -494,9 +600,28 @@ export interface InternalServerError extends __SmithyException, $MetadataBearer
     
     Message?: string;
 }
-export declare namespace InternalServerError {
+export declare enum EventType {
+    CHANGED = "CHANGED",
+    DELETED = "DELETED",
+    NEW = "NEW"
+}
+
+export interface AutoExportPolicy {
+    
+    Events?: (EventType | string)[];
+}
+export declare namespace AutoExportPolicy {
+    
+    const filterSensitiveLog: (obj: AutoExportPolicy) => any;
+}
+
+export interface AutoImportPolicy {
+    
+    Events?: (EventType | string)[];
+}
+export declare namespace AutoImportPolicy {
     
-    const filterSensitiveLog: (obj: InternalServerError) => any;
+    const filterSensitiveLog: (obj: AutoImportPolicy) => any;
 }
 
 export interface CancelDataRepositoryTaskRequest {
@@ -532,10 +657,6 @@ export interface DataRepositoryTaskEnded extends __SmithyException, $MetadataBea
     
     Message?: string;
 }
-export declare namespace DataRepositoryTaskEnded {
-    
-    const filterSensitiveLog: (obj: DataRepositoryTaskEnded) => any;
-}
 
 export interface DataRepositoryTaskNotFound extends __SmithyException, $MetadataBearer {
     name: "DataRepositoryTaskNotFound";
@@ -543,10 +664,6 @@ export interface DataRepositoryTaskNotFound extends __SmithyException, $Metadata
     
     Message?: string;
 }
-export declare namespace DataRepositoryTaskNotFound {
-    
-    const filterSensitiveLog: (obj: DataRepositoryTaskNotFound) => any;
-}
 
 export interface UnsupportedOperation extends __SmithyException, $MetadataBearer {
     name: "UnsupportedOperation";
@@ -554,10 +671,6 @@ export interface UnsupportedOperation extends __SmithyException, $MetadataBearer
     
     Message?: string;
 }
-export declare namespace UnsupportedOperation {
-    
-    const filterSensitiveLog: (obj: UnsupportedOperation) => any;
-}
 
 export interface BackupNotFound extends __SmithyException, $MetadataBearer {
     name: "BackupNotFound";
@@ -565,10 +678,6 @@ export interface BackupNotFound extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace BackupNotFound {
-    
-    const filterSensitiveLog: (obj: BackupNotFound) => any;
-}
 export interface CopyBackupRequest {
     
     ClientRequestToken?: string;
@@ -623,10 +732,6 @@ export interface IncompatibleParameterError extends __SmithyException, $Metadata
     
     Message?: string;
 }
-export declare namespace IncompatibleParameterError {
-    
-    const filterSensitiveLog: (obj: IncompatibleParameterError) => any;
-}
 
 export interface IncompatibleRegionForMultiAZ extends __SmithyException, $MetadataBearer {
     name: "IncompatibleRegionForMultiAZ";
@@ -634,10 +739,6 @@ export interface IncompatibleRegionForMultiAZ extends __SmithyException, $Metada
     
     Message?: string;
 }
-export declare namespace IncompatibleRegionForMultiAZ {
-    
-    const filterSensitiveLog: (obj: IncompatibleRegionForMultiAZ) => any;
-}
 
 export interface InvalidDestinationKmsKey extends __SmithyException, $MetadataBearer {
     name: "InvalidDestinationKmsKey";
@@ -645,10 +746,6 @@ export interface InvalidDestinationKmsKey extends __SmithyException, $MetadataBe
     
     Message?: string;
 }
-export declare namespace InvalidDestinationKmsKey {
-    
-    const filterSensitiveLog: (obj: InvalidDestinationKmsKey) => any;
-}
 
 export interface InvalidRegion extends __SmithyException, $MetadataBearer {
     name: "InvalidRegion";
@@ -656,10 +753,6 @@ export interface InvalidRegion extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace InvalidRegion {
-    
-    const filterSensitiveLog: (obj: InvalidRegion) => any;
-}
 
 export interface InvalidSourceKmsKey extends __SmithyException, $MetadataBearer {
     name: "InvalidSourceKmsKey";
@@ -667,10 +760,6 @@ export interface InvalidSourceKmsKey extends __SmithyException, $MetadataBearer
     
     Message?: string;
 }
-export declare namespace InvalidSourceKmsKey {
-    
-    const filterSensitiveLog: (obj: InvalidSourceKmsKey) => any;
-}
 export declare enum ServiceLimit {
     FILE_SYSTEM_COUNT = "FILE_SYSTEM_COUNT",
     STORAGE_VIRTUAL_MACHINES_PER_FILE_SYSTEM = "STORAGE_VIRTUAL_MACHINES_PER_FILE_SYSTEM",
@@ -691,10 +780,6 @@ export interface ServiceLimitExceeded extends __SmithyException, $MetadataBearer
     
     Message?: string;
 }
-export declare namespace ServiceLimitExceeded {
-    
-    const filterSensitiveLog: (obj: ServiceLimitExceeded) => any;
-}
 
 export interface SourceBackupUnavailable extends __SmithyException, $MetadataBearer {
     name: "SourceBackupUnavailable";
@@ -704,10 +789,6 @@ export interface SourceBackupUnavailable extends __SmithyException, $MetadataBea
     
     BackupId?: string;
 }
-export declare namespace SourceBackupUnavailable {
-    
-    const filterSensitiveLog: (obj: SourceBackupUnavailable) => any;
-}
 
 export interface BackupInProgress extends __SmithyException, $MetadataBearer {
     name: "BackupInProgress";
@@ -715,10 +796,6 @@ export interface BackupInProgress extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace BackupInProgress {
-    
-    const filterSensitiveLog: (obj: BackupInProgress) => any;
-}
 
 export interface CreateBackupRequest {
     
@@ -741,9 +818,77 @@ export interface VolumeNotFound extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace VolumeNotFound {
+
+export interface S3DataRepositoryConfiguration {
+    
+    AutoImportPolicy?: AutoImportPolicy;
+    
+    AutoExportPolicy?: AutoExportPolicy;
+}
+export declare namespace S3DataRepositoryConfiguration {
+    
+    const filterSensitiveLog: (obj: S3DataRepositoryConfiguration) => any;
+}
+export interface CreateDataRepositoryAssociationRequest {
+    
+    FileSystemId: string | undefined;
+    
+    FileSystemPath: string | undefined;
+    
+    DataRepositoryPath: string | undefined;
+    
+    BatchImportMetaDataOnCreate?: boolean;
+    
+    ImportedFileChunkSize?: number;
+    
+    S3?: S3DataRepositoryConfiguration;
+    
+    ClientRequestToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDataRepositoryAssociationRequest {
+    
+    const filterSensitiveLog: (obj: CreateDataRepositoryAssociationRequest) => any;
+}
+
+export interface DataRepositoryAssociation {
+    
+    AssociationId?: string;
+    
+    ResourceARN?: string;
+    
+    FileSystemId?: string;
+    
+    Lifecycle?: DataRepositoryLifecycle | string;
+    
+    FailureDetails?: DataRepositoryFailureDetails;
+    
+    FileSystemPath?: string;
+    
+    DataRepositoryPath?: string;
+    
+    BatchImportMetaDataOnCreate?: boolean;
+    
+    ImportedFileChunkSize?: number;
+    
+    S3?: S3DataRepositoryConfiguration;
+    
+    Tags?: Tag[];
+    
+    CreationTime?: Date;
+}
+export declare namespace DataRepositoryAssociation {
+    
+    const filterSensitiveLog: (obj: DataRepositoryAssociation) => any;
+}
+export interface CreateDataRepositoryAssociationResponse {
     
-    const filterSensitiveLog: (obj: VolumeNotFound) => any;
+    Association?: DataRepositoryAssociation;
+}
+export declare namespace CreateDataRepositoryAssociationResponse {
+    
+    const filterSensitiveLog: (obj: CreateDataRepositoryAssociationResponse) => any;
 }
 export declare enum ReportFormat {
     REPORT_CSV_20191124 = "REPORT_CSV_20191124"
@@ -767,7 +912,8 @@ export declare namespace CompletionReport {
     const filterSensitiveLog: (obj: CompletionReport) => any;
 }
 export declare enum DataRepositoryTaskType {
-    EXPORT = "EXPORT_TO_REPOSITORY"
+    EXPORT = "EXPORT_TO_REPOSITORY",
+    IMPORT = "IMPORT_METADATA_FROM_REPOSITORY"
 }
 export interface CreateDataRepositoryTaskRequest {
     
@@ -859,9 +1005,16 @@ export interface DataRepositoryTaskExecuting extends __SmithyException, $Metadat
     
     Message?: string;
 }
-export declare namespace DataRepositoryTaskExecuting {
+
+export interface LustreLogCreateConfiguration {
+    
+    Level: LustreAccessAuditLogLevel | string | undefined;
+    
+    Destination?: string;
+}
+export declare namespace LustreLogCreateConfiguration {
     
-    const filterSensitiveLog: (obj: DataRepositoryTaskExecuting) => any;
+    const filterSensitiveLog: (obj: LustreLogCreateConfiguration) => any;
 }
 
 export interface CreateFileSystemLustreConfiguration {
@@ -889,6 +1042,8 @@ export interface CreateFileSystemLustreConfiguration {
     DriveCacheType?: DriveCacheType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogCreateConfiguration;
 }
 export declare namespace CreateFileSystemLustreConfiguration {
     
@@ -922,6 +1077,48 @@ export declare namespace CreateFileSystemOntapConfiguration {
     const filterSensitiveLog: (obj: CreateFileSystemOntapConfiguration) => any;
 }
 
+export interface OpenZFSCreateRootVolumeConfiguration {
+    
+    DataCompressionType?: OpenZFSDataCompressionType | string;
+    
+    NfsExports?: OpenZFSNfsExport[];
+    
+    UserAndGroupQuotas?: OpenZFSUserOrGroupQuota[];
+    
+    CopyTagsToSnapshots?: boolean;
+    
+    ReadOnly?: boolean;
+}
+export declare namespace OpenZFSCreateRootVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: OpenZFSCreateRootVolumeConfiguration) => any;
+}
+
+export interface CreateFileSystemOpenZFSConfiguration {
+    
+    AutomaticBackupRetentionDays?: number;
+    
+    CopyTagsToBackups?: boolean;
+    
+    CopyTagsToVolumes?: boolean;
+    
+    DailyAutomaticBackupStartTime?: string;
+    
+    DeploymentType: OpenZFSDeploymentType | string | undefined;
+    
+    ThroughputCapacity: number | undefined;
+    
+    WeeklyMaintenanceStartTime?: string;
+    
+    DiskIopsConfiguration?: DiskIopsConfiguration;
+    
+    RootVolumeConfiguration?: OpenZFSCreateRootVolumeConfiguration;
+}
+export declare namespace CreateFileSystemOpenZFSConfiguration {
+    
+    const filterSensitiveLog: (obj: CreateFileSystemOpenZFSConfiguration) => any;
+}
+
 export interface WindowsAuditLogCreateConfiguration {
     
     FileAccessAuditLogLevel: WindowsAccessAuditLogLevel | string | undefined;
@@ -1008,6 +1205,8 @@ export interface CreateFileSystemRequest {
     OntapConfiguration?: CreateFileSystemOntapConfiguration;
     
     FileSystemTypeVersion?: string;
+    
+    OpenZFSConfiguration?: CreateFileSystemOpenZFSConfiguration;
 }
 export declare namespace CreateFileSystemRequest {
     
@@ -1020,10 +1219,6 @@ export interface InvalidExportPath extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace InvalidExportPath {
-    
-    const filterSensitiveLog: (obj: InvalidExportPath) => any;
-}
 
 export interface InvalidImportPath extends __SmithyException, $MetadataBearer {
     name: "InvalidImportPath";
@@ -1031,10 +1226,6 @@ export interface InvalidImportPath extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace InvalidImportPath {
-    
-    const filterSensitiveLog: (obj: InvalidImportPath) => any;
-}
 
 export interface InvalidNetworkSettings extends __SmithyException, $MetadataBearer {
     name: "InvalidNetworkSettings";
@@ -1048,10 +1239,6 @@ export interface InvalidNetworkSettings extends __SmithyException, $MetadataBear
     
     InvalidRouteTableId?: string;
 }
-export declare namespace InvalidNetworkSettings {
-    
-    const filterSensitiveLog: (obj: InvalidNetworkSettings) => any;
-}
 
 export interface InvalidPerUnitStorageThroughput extends __SmithyException, $MetadataBearer {
     name: "InvalidPerUnitStorageThroughput";
@@ -1059,10 +1246,6 @@ export interface InvalidPerUnitStorageThroughput extends __SmithyException, $Met
     
     Message?: string;
 }
-export declare namespace InvalidPerUnitStorageThroughput {
-    
-    const filterSensitiveLog: (obj: InvalidPerUnitStorageThroughput) => any;
-}
 
 export interface MissingFileSystemConfiguration extends __SmithyException, $MetadataBearer {
     name: "MissingFileSystemConfiguration";
@@ -1070,10 +1253,6 @@ export interface MissingFileSystemConfiguration extends __SmithyException, $Meta
     
     Message?: string;
 }
-export declare namespace MissingFileSystemConfiguration {
-    
-    const filterSensitiveLog: (obj: MissingFileSystemConfiguration) => any;
-}
 
 export interface CreateFileSystemFromBackupRequest {
     
@@ -1096,11 +1275,27 @@ export interface CreateFileSystemFromBackupRequest {
     KmsKeyId?: string;
     
     FileSystemTypeVersion?: string;
+    
+    OpenZFSConfiguration?: CreateFileSystemOpenZFSConfiguration;
 }
 export declare namespace CreateFileSystemFromBackupRequest {
     
     const filterSensitiveLog: (obj: CreateFileSystemFromBackupRequest) => any;
 }
+export interface CreateSnapshotRequest {
+    
+    ClientRequestToken?: string;
+    
+    Name: string | undefined;
+    
+    VolumeId: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotRequest) => any;
+}
 
 export interface CreateSvmActiveDirectoryConfiguration {
     
@@ -1248,6 +1443,42 @@ export declare namespace CreateOntapVolumeConfiguration {
     
     const filterSensitiveLog: (obj: CreateOntapVolumeConfiguration) => any;
 }
+
+export interface CreateOpenZFSOriginSnapshotConfiguration {
+    
+    SnapshotARN: string | undefined;
+    
+    CopyStrategy: OpenZFSCopyStrategy | string | undefined;
+}
+export declare namespace CreateOpenZFSOriginSnapshotConfiguration {
+    
+    const filterSensitiveLog: (obj: CreateOpenZFSOriginSnapshotConfiguration) => any;
+}
+
+export interface CreateOpenZFSVolumeConfiguration {
+    
+    ParentVolumeId: string | undefined;
+    
+    StorageCapacityReservationGiB?: number;
+    
+    StorageCapacityQuotaGiB?: number;
+    
+    DataCompressionType?: OpenZFSDataCompressionType | string;
+    
+    CopyTagsToSnapshots?: boolean;
+    
+    OriginSnapshot?: CreateOpenZFSOriginSnapshotConfiguration;
+    
+    ReadOnly?: boolean;
+    
+    NfsExports?: OpenZFSNfsExport[];
+    
+    UserAndGroupQuotas?: OpenZFSUserOrGroupQuota[];
+}
+export declare namespace CreateOpenZFSVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: CreateOpenZFSVolumeConfiguration) => any;
+}
 export interface CreateVolumeRequest {
     
     ClientRequestToken?: string;
@@ -1259,19 +1490,13 @@ export interface CreateVolumeRequest {
     OntapConfiguration?: CreateOntapVolumeConfiguration;
     
     Tags?: Tag[];
+    
+    OpenZFSConfiguration?: CreateOpenZFSVolumeConfiguration;
 }
 export declare namespace CreateVolumeRequest {
     
     const filterSensitiveLog: (obj: CreateVolumeRequest) => any;
 }
-export interface CreateVolumeResponse {
-    
-    Volume?: Volume;
-}
-export declare namespace CreateVolumeResponse {
-    
-    const filterSensitiveLog: (obj: CreateVolumeResponse) => any;
-}
 
 export interface MissingVolumeConfiguration extends __SmithyException, $MetadataBearer {
     name: "MissingVolumeConfiguration";
@@ -1279,10 +1504,6 @@ export interface MissingVolumeConfiguration extends __SmithyException, $Metadata
     
     Message?: string;
 }
-export declare namespace MissingVolumeConfiguration {
-    
-    const filterSensitiveLog: (obj: MissingVolumeConfiguration) => any;
-}
 
 export interface StorageVirtualMachineNotFound extends __SmithyException, $MetadataBearer {
     name: "StorageVirtualMachineNotFound";
@@ -1290,10 +1511,6 @@ export interface StorageVirtualMachineNotFound extends __SmithyException, $Metad
     
     Message?: string;
 }
-export declare namespace StorageVirtualMachineNotFound {
-    
-    const filterSensitiveLog: (obj: StorageVirtualMachineNotFound) => any;
-}
 export interface CreateVolumeFromBackupRequest {
     
     BackupId: string | undefined;
@@ -1310,14 +1527,6 @@ export declare namespace CreateVolumeFromBackupRequest {
     
     const filterSensitiveLog: (obj: CreateVolumeFromBackupRequest) => any;
 }
-export interface CreateVolumeFromBackupResponse {
-    
-    Volume?: Volume;
-}
-export declare namespace CreateVolumeFromBackupResponse {
-    
-    const filterSensitiveLog: (obj: CreateVolumeFromBackupResponse) => any;
-}
 
 export interface BackupBeingCopied extends __SmithyException, $MetadataBearer {
     name: "BackupBeingCopied";
@@ -1327,10 +1536,6 @@ export interface BackupBeingCopied extends __SmithyException, $MetadataBearer {
     
     BackupId?: string;
 }
-export declare namespace BackupBeingCopied {
-    
-    const filterSensitiveLog: (obj: BackupBeingCopied) => any;
-}
 
 export interface BackupRestoring extends __SmithyException, $MetadataBearer {
     name: "BackupRestoring";
@@ -1340,10 +1545,6 @@ export interface BackupRestoring extends __SmithyException, $MetadataBearer {
     
     FileSystemId?: string;
 }
-export declare namespace BackupRestoring {
-    
-    const filterSensitiveLog: (obj: BackupRestoring) => any;
-}
 
 export interface DeleteBackupRequest {
     
@@ -1367,6 +1568,37 @@ export declare namespace DeleteBackupResponse {
     const filterSensitiveLog: (obj: DeleteBackupResponse) => any;
 }
 
+export interface DataRepositoryAssociationNotFound extends __SmithyException, $MetadataBearer {
+    name: "DataRepositoryAssociationNotFound";
+    $fault: "client";
+    
+    Message?: string;
+}
+export interface DeleteDataRepositoryAssociationRequest {
+    
+    AssociationId: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    DeleteDataInFileSystem: boolean | undefined;
+}
+export declare namespace DeleteDataRepositoryAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDataRepositoryAssociationRequest) => any;
+}
+export interface DeleteDataRepositoryAssociationResponse {
+    
+    AssociationId?: string;
+    
+    Lifecycle?: DataRepositoryLifecycle | string;
+    
+    DeleteDataInFileSystem?: boolean;
+}
+export declare namespace DeleteDataRepositoryAssociationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDataRepositoryAssociationResponse) => any;
+}
+
 export interface DeleteFileSystemLustreConfiguration {
     
     SkipFinalBackup?: boolean;
@@ -1378,6 +1610,17 @@ export declare namespace DeleteFileSystemLustreConfiguration {
     const filterSensitiveLog: (obj: DeleteFileSystemLustreConfiguration) => any;
 }
 
+export interface DeleteFileSystemOpenZFSConfiguration {
+    
+    SkipFinalBackup?: boolean;
+    
+    FinalBackupTags?: Tag[];
+}
+export declare namespace DeleteFileSystemOpenZFSConfiguration {
+    
+    const filterSensitiveLog: (obj: DeleteFileSystemOpenZFSConfiguration) => any;
+}
+
 export interface DeleteFileSystemWindowsConfiguration {
     
     SkipFinalBackup?: boolean;
@@ -1398,6 +1641,8 @@ export interface DeleteFileSystemRequest {
     WindowsConfiguration?: DeleteFileSystemWindowsConfiguration;
     
     LustreConfiguration?: DeleteFileSystemLustreConfiguration;
+    
+    OpenZFSConfiguration?: DeleteFileSystemOpenZFSConfiguration;
 }
 export declare namespace DeleteFileSystemRequest {
     
@@ -1415,6 +1660,17 @@ export declare namespace DeleteFileSystemLustreResponse {
     const filterSensitiveLog: (obj: DeleteFileSystemLustreResponse) => any;
 }
 
+export interface DeleteFileSystemOpenZFSResponse {
+    
+    FinalBackupId?: string;
+    
+    FinalBackupTags?: Tag[];
+}
+export declare namespace DeleteFileSystemOpenZFSResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFileSystemOpenZFSResponse) => any;
+}
+
 export interface DeleteFileSystemWindowsResponse {
     
     FinalBackupId?: string;
@@ -1435,11 +1691,40 @@ export interface DeleteFileSystemResponse {
     WindowsResponse?: DeleteFileSystemWindowsResponse;
     
     LustreResponse?: DeleteFileSystemLustreResponse;
+    
+    OpenZFSResponse?: DeleteFileSystemOpenZFSResponse;
 }
 export declare namespace DeleteFileSystemResponse {
     
     const filterSensitiveLog: (obj: DeleteFileSystemResponse) => any;
 }
+export interface DeleteSnapshotRequest {
+    
+    ClientRequestToken?: string;
+    
+    SnapshotId: string | undefined;
+}
+export declare namespace DeleteSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotRequest) => any;
+}
+export interface DeleteSnapshotResponse {
+    
+    SnapshotId?: string;
+    
+    Lifecycle?: SnapshotLifecycle | string;
+}
+export declare namespace DeleteSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSnapshotResponse) => any;
+}
+
+export interface SnapshotNotFound extends __SmithyException, $MetadataBearer {
+    name: "SnapshotNotFound";
+    $fault: "client";
+    
+    Message?: string;
+}
 export interface DeleteStorageVirtualMachineRequest {
     
     ClientRequestToken?: string;
@@ -1471,6 +1756,18 @@ export declare namespace DeleteVolumeOntapConfiguration {
     
     const filterSensitiveLog: (obj: DeleteVolumeOntapConfiguration) => any;
 }
+export declare enum DeleteOpenZFSVolumeOption {
+    DELETE_CHILD_VOLUMES_AND_SNAPSHOTS = "DELETE_CHILD_VOLUMES_AND_SNAPSHOTS"
+}
+
+export interface DeleteVolumeOpenZFSConfiguration {
+    
+    Options?: (DeleteOpenZFSVolumeOption | string)[];
+}
+export declare namespace DeleteVolumeOpenZFSConfiguration {
+    
+    const filterSensitiveLog: (obj: DeleteVolumeOpenZFSConfiguration) => any;
+}
 export interface DeleteVolumeRequest {
     
     ClientRequestToken?: string;
@@ -1478,6 +1775,8 @@ export interface DeleteVolumeRequest {
     VolumeId: string | undefined;
     
     OntapConfiguration?: DeleteVolumeOntapConfiguration;
+    
+    OpenZFSConfiguration?: DeleteVolumeOpenZFSConfiguration;
 }
 export declare namespace DeleteVolumeRequest {
     
@@ -1508,6 +1807,7 @@ export declare namespace DeleteVolumeResponse {
 }
 export declare enum FilterName {
     BACKUP_TYPE = "backup-type",
+    DATA_REPOSITORY_TYPE = "data-repository-type",
     FILE_SYSTEM_ID = "file-system-id",
     FILE_SYSTEM_TYPE = "file-system-type",
     VOLUME_ID = "volume-id"
@@ -1538,7 +1838,39 @@ export declare namespace DescribeBackupsRequest {
     
     const filterSensitiveLog: (obj: DescribeBackupsRequest) => any;
 }
+export interface DescribeDataRepositoryAssociationsRequest {
+    
+    AssociationIds?: string[];
+    
+    Filters?: Filter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDataRepositoryAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDataRepositoryAssociationsRequest) => any;
+}
+export interface DescribeDataRepositoryAssociationsResponse {
+    
+    Associations?: DataRepositoryAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDataRepositoryAssociationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDataRepositoryAssociationsResponse) => any;
+}
+
+export interface InvalidDataRepositoryType extends __SmithyException, $MetadataBearer {
+    name: "InvalidDataRepositoryType";
+    $fault: "client";
+    
+    Message?: string;
+}
 export declare enum DataRepositoryTaskFilterName {
+    DATA_REPO_ASSOCIATION_ID = "data-repository-association-id",
     FILE_SYSTEM_ID = "file-system-id",
     TASK_LIFECYCLE = "task-lifecycle"
 }
@@ -1616,6 +1948,35 @@ export declare namespace DescribeFileSystemsRequest {
     
     const filterSensitiveLog: (obj: DescribeFileSystemsRequest) => any;
 }
+export declare enum SnapshotFilterName {
+    FILE_SYSTEM_ID = "file-system-id",
+    VOLUME_ID = "volume-id"
+}
+
+export interface SnapshotFilter {
+    
+    Name?: SnapshotFilterName | string;
+    
+    Values?: string[];
+}
+export declare namespace SnapshotFilter {
+    
+    const filterSensitiveLog: (obj: SnapshotFilter) => any;
+}
+export interface DescribeSnapshotsRequest {
+    
+    SnapshotIds?: string[];
+    
+    Filters?: SnapshotFilter[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSnapshotsRequest) => any;
+}
 export declare enum StorageVirtualMachineFilterName {
     FILE_SYSTEM_ID = "file-system-id"
 }
@@ -1683,16 +2044,6 @@ export declare namespace DescribeVolumesRequest {
     
     const filterSensitiveLog: (obj: DescribeVolumesRequest) => any;
 }
-export interface DescribeVolumesResponse {
-    
-    Volumes?: Volume[];
-    
-    NextToken?: string;
-}
-export declare namespace DescribeVolumesResponse {
-    
-    const filterSensitiveLog: (obj: DescribeVolumesResponse) => any;
-}
 
 export interface DisassociateFileSystemAliasesRequest {
     
@@ -1748,10 +2099,6 @@ export interface NotServiceResourceError extends __SmithyException, $MetadataBea
     
     Message?: string;
 }
-export declare namespace NotServiceResourceError {
-    
-    const filterSensitiveLog: (obj: NotServiceResourceError) => any;
-}
 
 export interface ResourceDoesNotSupportTagging extends __SmithyException, $MetadataBearer {
     name: "ResourceDoesNotSupportTagging";
@@ -1761,10 +2108,6 @@ export interface ResourceDoesNotSupportTagging extends __SmithyException, $Metad
     
     Message?: string;
 }
-export declare namespace ResourceDoesNotSupportTagging {
-    
-    const filterSensitiveLog: (obj: ResourceDoesNotSupportTagging) => any;
-}
 
 export interface ResourceNotFound extends __SmithyException, $MetadataBearer {
     name: "ResourceNotFound";
@@ -1774,9 +2117,43 @@ export interface ResourceNotFound extends __SmithyException, $MetadataBearer {
     
     Message?: string;
 }
-export declare namespace ResourceNotFound {
+export interface ReleaseFileSystemNfsV3LocksRequest {
     
-    const filterSensitiveLog: (obj: ResourceNotFound) => any;
+    FileSystemId: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace ReleaseFileSystemNfsV3LocksRequest {
+    
+    const filterSensitiveLog: (obj: ReleaseFileSystemNfsV3LocksRequest) => any;
+}
+export declare enum RestoreOpenZFSVolumeOption {
+    DELETE_CLONED_VOLUMES = "DELETE_CLONED_VOLUMES",
+    DELETE_INTERMEDIATE_SNAPSHOTS = "DELETE_INTERMEDIATE_SNAPSHOTS"
+}
+export interface RestoreVolumeFromSnapshotRequest {
+    
+    ClientRequestToken?: string;
+    
+    VolumeId: string | undefined;
+    
+    SnapshotId: string | undefined;
+    
+    Options?: (RestoreOpenZFSVolumeOption | string)[];
+}
+export declare namespace RestoreVolumeFromSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: RestoreVolumeFromSnapshotRequest) => any;
+}
+export interface RestoreVolumeFromSnapshotResponse {
+    
+    VolumeId?: string;
+    
+    Lifecycle?: VolumeLifecycle | string;
+}
+export declare namespace RestoreVolumeFromSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: RestoreVolumeFromSnapshotResponse) => any;
 }
 
 export interface TagResourceRequest {
@@ -1814,6 +2191,28 @@ export declare namespace UntagResourceResponse {
     
     const filterSensitiveLog: (obj: UntagResourceResponse) => any;
 }
+export interface UpdateDataRepositoryAssociationRequest {
+    
+    AssociationId: string | undefined;
+    
+    ClientRequestToken?: string;
+    
+    ImportedFileChunkSize?: number;
+    
+    S3?: S3DataRepositoryConfiguration;
+}
+export declare namespace UpdateDataRepositoryAssociationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDataRepositoryAssociationRequest) => any;
+}
+export interface UpdateDataRepositoryAssociationResponse {
+    
+    Association?: DataRepositoryAssociation;
+}
+export declare namespace UpdateDataRepositoryAssociationResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDataRepositoryAssociationResponse) => any;
+}
 
 export interface UpdateFileSystemLustreConfiguration {
     
@@ -1826,6 +2225,8 @@ export interface UpdateFileSystemLustreConfiguration {
     AutoImportPolicy?: AutoImportPolicyType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogCreateConfiguration;
 }
 export declare namespace UpdateFileSystemLustreConfiguration {
     
@@ -1847,6 +2248,27 @@ export declare namespace UpdateFileSystemOntapConfiguration {
     const filterSensitiveLog: (obj: UpdateFileSystemOntapConfiguration) => any;
 }
 
+export interface UpdateFileSystemOpenZFSConfiguration {
+    
+    AutomaticBackupRetentionDays?: number;
+    
+    CopyTagsToBackups?: boolean;
+    
+    CopyTagsToVolumes?: boolean;
+    
+    DailyAutomaticBackupStartTime?: string;
+    
+    ThroughputCapacity?: number;
+    
+    WeeklyMaintenanceStartTime?: string;
+    
+    DiskIopsConfiguration?: DiskIopsConfiguration;
+}
+export declare namespace UpdateFileSystemOpenZFSConfiguration {
+    
+    const filterSensitiveLog: (obj: UpdateFileSystemOpenZFSConfiguration) => any;
+}
+
 export interface SelfManagedActiveDirectoryConfigurationUpdates {
     
     UserName?: string;
@@ -1892,11 +2314,25 @@ export interface UpdateFileSystemRequest {
     LustreConfiguration?: UpdateFileSystemLustreConfiguration;
     
     OntapConfiguration?: UpdateFileSystemOntapConfiguration;
+    
+    OpenZFSConfiguration?: UpdateFileSystemOpenZFSConfiguration;
 }
 export declare namespace UpdateFileSystemRequest {
     
     const filterSensitiveLog: (obj: UpdateFileSystemRequest) => any;
 }
+export interface UpdateSnapshotRequest {
+    
+    ClientRequestToken?: string;
+    
+    Name: string | undefined;
+    
+    SnapshotId: string | undefined;
+}
+export declare namespace UpdateSnapshotRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSnapshotRequest) => any;
+}
 
 export interface UpdateSvmActiveDirectoryConfiguration {
     
@@ -1945,6 +2381,25 @@ export declare namespace UpdateOntapVolumeConfiguration {
     
     const filterSensitiveLog: (obj: UpdateOntapVolumeConfiguration) => any;
 }
+
+export interface UpdateOpenZFSVolumeConfiguration {
+    
+    StorageCapacityReservationGiB?: number;
+    
+    StorageCapacityQuotaGiB?: number;
+    
+    DataCompressionType?: OpenZFSDataCompressionType | string;
+    
+    NfsExports?: OpenZFSNfsExport[];
+    
+    UserAndGroupQuotas?: OpenZFSUserOrGroupQuota[];
+    
+    ReadOnly?: boolean;
+}
+export declare namespace UpdateOpenZFSVolumeConfiguration {
+    
+    const filterSensitiveLog: (obj: UpdateOpenZFSVolumeConfiguration) => any;
+}
 export interface UpdateVolumeRequest {
     
     ClientRequestToken?: string;
@@ -1952,18 +2407,14 @@ export interface UpdateVolumeRequest {
     VolumeId: string | undefined;
     
     OntapConfiguration?: UpdateOntapVolumeConfiguration;
-}
-export declare namespace UpdateVolumeRequest {
     
-    const filterSensitiveLog: (obj: UpdateVolumeRequest) => any;
-}
-export interface UpdateVolumeResponse {
+    Name?: string;
     
-    Volume?: Volume;
+    OpenZFSConfiguration?: UpdateOpenZFSVolumeConfiguration;
 }
-export declare namespace UpdateVolumeResponse {
+export declare namespace UpdateVolumeRequest {
     
-    const filterSensitiveLog: (obj: UpdateVolumeResponse) => any;
+    const filterSensitiveLog: (obj: UpdateVolumeRequest) => any;
 }
 
 export interface AdministrativeAction {
@@ -1981,6 +2432,8 @@ export interface AdministrativeAction {
     FailureDetails?: AdministrativeActionFailureDetails;
     
     TargetVolumeValues?: Volume;
+    
+    TargetSnapshotValues?: Snapshot;
 }
 export declare namespace AdministrativeAction {
     
@@ -2028,49 +2481,66 @@ export interface FileSystem {
     OntapConfiguration?: OntapFileSystemConfiguration;
     
     FileSystemTypeVersion?: string;
+    
+    OpenZFSConfiguration?: OpenZFSFileSystemConfiguration;
 }
 export declare namespace FileSystem {
     
     const filterSensitiveLog: (obj: FileSystem) => any;
 }
 
-export interface Backup {
+export interface Snapshot {
     
-    BackupId: string | undefined;
+    ResourceARN?: string;
     
-    Lifecycle: BackupLifecycle | string | undefined;
+    SnapshotId?: string;
     
-    FailureDetails?: BackupFailureDetails;
+    Name?: string;
     
-    Type: BackupType | string | undefined;
+    VolumeId?: string;
     
-    ProgressPercent?: number;
+    CreationTime?: Date;
     
-    CreationTime: Date | undefined;
+    Lifecycle?: SnapshotLifecycle | string;
     
-    KmsKeyId?: string;
+    Tags?: Tag[];
     
-    ResourceARN?: string;
+    AdministrativeActions?: AdministrativeAction[];
+}
+export declare namespace Snapshot {
     
-    Tags?: Tag[];
+    const filterSensitiveLog: (obj: Snapshot) => any;
+}
+
+export interface Volume {
     
-    FileSystem: FileSystem | undefined;
+    CreationTime?: Date;
     
-    DirectoryInformation?: ActiveDirectoryBackupAttributes;
+    FileSystemId?: string;
     
-    OwnerId?: string;
+    Lifecycle?: VolumeLifecycle | string;
     
-    SourceBackupId?: string;
+    Name?: string;
     
-    SourceBackupRegion?: string;
+    OntapConfiguration?: OntapVolumeConfiguration;
     
-    ResourceType?: ResourceType | string;
+    ResourceARN?: string;
     
-    Volume?: Volume;
+    Tags?: Tag[];
+    
+    VolumeId?: string;
+    
+    VolumeType?: VolumeType | string;
+    
+    LifecycleTransitionReason?: LifecycleTransitionReason;
+    
+    AdministrativeActions?: AdministrativeAction[];
+    
+    OpenZFSConfiguration?: OpenZFSVolumeConfiguration;
 }
-export declare namespace Backup {
+export declare namespace Volume {
     
-    const filterSensitiveLog: (obj: Backup) => any;
+    const filterSensitiveLog: (obj: Volume) => any;
 }
 
 export interface CreateFileSystemFromBackupResponse {
@@ -2090,6 +2560,38 @@ export declare namespace CreateFileSystemResponse {
     
     const filterSensitiveLog: (obj: CreateFileSystemResponse) => any;
 }
+export interface CreateSnapshotResponse {
+    
+    Snapshot?: Snapshot;
+}
+export declare namespace CreateSnapshotResponse {
+    
+    const filterSensitiveLog: (obj: CreateSnapshotResponse) => any;
+}
+export interface CreateVolumeFromBackupResponse {
+    
+    Volume?: Volume;
+}
+export declare namespace CreateVolumeFromBackupResponse {
+    
+    const filterSensitiveLog: (obj: CreateVolumeFromBackupResponse) => any;
+}
+export interface CreateVolumeResponse {
+    
+    Volume?: Volume;
+}
+export declare namespace CreateVolumeResponse {
+    
+    const filterSensitiveLog: (obj: CreateVolumeResponse) => any;
+}
+export interface ReleaseFileSystemNfsV3LocksResponse {
+    
+    FileSystem?: FileSystem;
+}
+export declare namespace ReleaseFileSystemNfsV3LocksResponse {
+    
+    const filterSensitiveLog: (obj: ReleaseFileSystemNfsV3LocksResponse) => any;
+}
 
 export interface UpdateFileSystemResponse {
     
@@ -2099,22 +2601,21 @@ export declare namespace UpdateFileSystemResponse {
     
     const filterSensitiveLog: (obj: UpdateFileSystemResponse) => any;
 }
-export interface CopyBackupResponse {
+export interface UpdateSnapshotResponse {
     
-    Backup?: Backup;
+    Snapshot?: Snapshot;
 }
-export declare namespace CopyBackupResponse {
+export declare namespace UpdateSnapshotResponse {
     
-    const filterSensitiveLog: (obj: CopyBackupResponse) => any;
+    const filterSensitiveLog: (obj: UpdateSnapshotResponse) => any;
 }
-
-export interface CreateBackupResponse {
+export interface UpdateVolumeResponse {
     
-    Backup?: Backup;
+    Volume?: Volume;
 }
-export declare namespace CreateBackupResponse {
+export declare namespace UpdateVolumeResponse {
     
-    const filterSensitiveLog: (obj: CreateBackupResponse) => any;
+    const filterSensitiveLog: (obj: UpdateVolumeResponse) => any;
 }
 
 export interface DescribeFileSystemsResponse {
@@ -2127,6 +2628,82 @@ export declare namespace DescribeFileSystemsResponse {
     
     const filterSensitiveLog: (obj: DescribeFileSystemsResponse) => any;
 }
+export interface DescribeSnapshotsResponse {
+    
+    Snapshots?: Snapshot[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeSnapshotsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSnapshotsResponse) => any;
+}
+export interface DescribeVolumesResponse {
+    
+    Volumes?: Volume[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeVolumesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeVolumesResponse) => any;
+}
+
+export interface Backup {
+    
+    BackupId: string | undefined;
+    
+    Lifecycle: BackupLifecycle | string | undefined;
+    
+    FailureDetails?: BackupFailureDetails;
+    
+    Type: BackupType | string | undefined;
+    
+    ProgressPercent?: number;
+    
+    CreationTime: Date | undefined;
+    
+    KmsKeyId?: string;
+    
+    ResourceARN?: string;
+    
+    Tags?: Tag[];
+    
+    FileSystem: FileSystem | undefined;
+    
+    DirectoryInformation?: ActiveDirectoryBackupAttributes;
+    
+    OwnerId?: string;
+    
+    SourceBackupId?: string;
+    
+    SourceBackupRegion?: string;
+    
+    ResourceType?: ResourceType | string;
+    
+    Volume?: Volume;
+}
+export declare namespace Backup {
+    
+    const filterSensitiveLog: (obj: Backup) => any;
+}
+export interface CopyBackupResponse {
+    
+    Backup?: Backup;
+}
+export declare namespace CopyBackupResponse {
+    
+    const filterSensitiveLog: (obj: CopyBackupResponse) => any;
+}
+
+export interface CreateBackupResponse {
+    
+    Backup?: Backup;
+}
+export declare namespace CreateBackupResponse {
+    
+    const filterSensitiveLog: (obj: CreateBackupResponse) => any;
+}
 
 export interface DescribeBackupsResponse {