@aws-sdk/client-fsx 3.40.0 → 3.44.0

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

@@ -37,7 +37,10 @@ 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 +70,7 @@ export declare namespace FileSystemFailureDetails {
 export declare enum FileSystemType {
     LUSTRE = "LUSTRE",
     ONTAP = "ONTAP",
+    OPENZFS = "OPENZFS",
     WINDOWS = "WINDOWS"
 }
 export declare enum FileSystemLifecycle {
@@ -84,6 +88,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 +104,7 @@ export declare enum DataRepositoryLifecycle {
     AVAILABLE = "AVAILABLE",
     CREATING = "CREATING",
     DELETING = "DELETING",
+    FAILED = "FAILED",
     MISCONFIGURED = "MISCONFIGURED",
     UPDATING = "UPDATING"
 }
@@ -123,6 +129,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 +137,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 +176,8 @@ export interface LustreFileSystemConfiguration {
     DriveCacheType?: DriveCacheType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogConfiguration;
 }
 export declare namespace LustreFileSystemConfiguration {
     
@@ -224,6 +250,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 +391,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 +474,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 {
@@ -498,6 +616,29 @@ export declare namespace InternalServerError {
     
     const filterSensitiveLog: (obj: InternalServerError) => any;
 }
+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: AutoImportPolicy) => any;
+}
 
 export interface CancelDataRepositoryTaskRequest {
     
@@ -745,6 +886,78 @@ export declare namespace VolumeNotFound {
     
     const filterSensitiveLog: (obj: VolumeNotFound) => any;
 }
+
+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 {
+    
+    Association?: DataRepositoryAssociation;
+}
+export declare namespace CreateDataRepositoryAssociationResponse {
+    
+    const filterSensitiveLog: (obj: CreateDataRepositoryAssociationResponse) => any;
+}
 export declare enum ReportFormat {
     REPORT_CSV_20191124 = "REPORT_CSV_20191124"
 }
@@ -767,7 +980,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 {
     
@@ -864,6 +1078,17 @@ export declare namespace DataRepositoryTaskExecuting {
     const filterSensitiveLog: (obj: DataRepositoryTaskExecuting) => any;
 }
 
+export interface LustreLogCreateConfiguration {
+    
+    Level: LustreAccessAuditLogLevel | string | undefined;
+    
+    Destination?: string;
+}
+export declare namespace LustreLogCreateConfiguration {
+    
+    const filterSensitiveLog: (obj: LustreLogCreateConfiguration) => any;
+}
+
 export interface CreateFileSystemLustreConfiguration {
     
     WeeklyMaintenanceStartTime?: string;
@@ -889,6 +1114,8 @@ export interface CreateFileSystemLustreConfiguration {
     DriveCacheType?: DriveCacheType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogCreateConfiguration;
 }
 export declare namespace CreateFileSystemLustreConfiguration {
     
@@ -922,6 +1149,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 +1277,8 @@ export interface CreateFileSystemRequest {
     OntapConfiguration?: CreateFileSystemOntapConfiguration;
     
     FileSystemTypeVersion?: string;
+    
+    OpenZFSConfiguration?: CreateFileSystemOpenZFSConfiguration;
 }
 export declare namespace CreateFileSystemRequest {
     
@@ -1096,11 +1367,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 +1535,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 +1582,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";
@@ -1310,14 +1627,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";
@@ -1367,6 +1676,41 @@ export declare namespace DeleteBackupResponse {
     const filterSensitiveLog: (obj: DeleteBackupResponse) => any;
 }
 
+export interface DataRepositoryAssociationNotFound extends __SmithyException, $MetadataBearer {
+    name: "DataRepositoryAssociationNotFound";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace DataRepositoryAssociationNotFound {
+    
+    const filterSensitiveLog: (obj: DataRepositoryAssociationNotFound) => any;
+}
+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 +1722,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 +1753,8 @@ export interface DeleteFileSystemRequest {
     WindowsConfiguration?: DeleteFileSystemWindowsConfiguration;
     
     LustreConfiguration?: DeleteFileSystemLustreConfiguration;
+    
+    OpenZFSConfiguration?: DeleteFileSystemOpenZFSConfiguration;
 }
 export declare namespace DeleteFileSystemRequest {
     
@@ -1415,13 +1772,24 @@ export declare namespace DeleteFileSystemLustreResponse {
     const filterSensitiveLog: (obj: DeleteFileSystemLustreResponse) => any;
 }
 
-export interface DeleteFileSystemWindowsResponse {
+export interface DeleteFileSystemOpenZFSResponse {
     
     FinalBackupId?: string;
     
     FinalBackupTags?: Tag[];
 }
-export declare namespace DeleteFileSystemWindowsResponse {
+export declare namespace DeleteFileSystemOpenZFSResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFileSystemOpenZFSResponse) => any;
+}
+
+export interface DeleteFileSystemWindowsResponse {
+    
+    FinalBackupId?: string;
+    
+    FinalBackupTags?: Tag[];
+}
+export declare namespace DeleteFileSystemWindowsResponse {
     
     const filterSensitiveLog: (obj: DeleteFileSystemWindowsResponse) => any;
 }
@@ -1435,11 +1803,44 @@ 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 declare namespace SnapshotNotFound {
+    
+    const filterSensitiveLog: (obj: SnapshotNotFound) => any;
+}
 export interface DeleteStorageVirtualMachineRequest {
     
     ClientRequestToken?: string;
@@ -1471,6 +1872,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 +1891,8 @@ export interface DeleteVolumeRequest {
     VolumeId: string | undefined;
     
     OntapConfiguration?: DeleteVolumeOntapConfiguration;
+    
+    OpenZFSConfiguration?: DeleteVolumeOpenZFSConfiguration;
 }
 export declare namespace DeleteVolumeRequest {
     
@@ -1508,6 +1923,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 +1954,43 @@ 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 namespace InvalidDataRepositoryType {
+    
+    const filterSensitiveLog: (obj: InvalidDataRepositoryType) => any;
+}
 export declare enum DataRepositoryTaskFilterName {
+    DATA_REPO_ASSOCIATION_ID = "data-repository-association-id",
     FILE_SYSTEM_ID = "file-system-id",
     TASK_LIFECYCLE = "task-lifecycle"
 }
@@ -1616,6 +2068,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 +2164,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 {
     
@@ -1778,6 +2249,44 @@ export declare namespace ResourceNotFound {
     
     const filterSensitiveLog: (obj: ResourceNotFound) => any;
 }
+export interface ReleaseFileSystemNfsV3LocksRequest {
+    
+    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 +2323,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 +2357,8 @@ export interface UpdateFileSystemLustreConfiguration {
     AutoImportPolicy?: AutoImportPolicyType | string;
     
     DataCompressionType?: DataCompressionType | string;
+    
+    LogConfiguration?: LustreLogCreateConfiguration;
 }
 export declare namespace UpdateFileSystemLustreConfiguration {
     
@@ -1847,6 +2380,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 +2446,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 +2513,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 +2539,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 +2564,8 @@ export interface AdministrativeAction {
     FailureDetails?: AdministrativeActionFailureDetails;
     
     TargetVolumeValues?: Volume;
+    
+    TargetSnapshotValues?: Snapshot;
 }
 export declare namespace AdministrativeAction {
     
@@ -2028,49 +2613,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 +2692,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 +2733,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 +2760,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 {