Chilkat Online Tools

DescribeBackups C# Example

Amazon FSx

// This example requires the Chilkat API to have been previously unlocked.
// See Global Unlock Sample for sample code.

Chilkat.Rest rest = new Chilkat.Rest();
bool success;

Chilkat.AuthAws authAws = new Chilkat.AuthAws();
authAws.AccessKey = "AWS_ACCESS_KEY";
authAws.SecretKey = "AWS_SECRET_KEY";

// Don't forget to change the region to your particular region. (Also make the same change in the call to Connect below.)
authAws.Region = "us-west-2";
authAws.ServiceName = "fsx";
// SetAuthAws causes Chilkat to automatically add the following headers: Authorization, X-Amz-Date
rest.SetAuthAws(authAws);

// URL: https://fsx.us-west-2.amazonaws.com/
// Use the same region as specified above.
success = rest.Connect("fsx.us-west-2.amazonaws.com",443,true,true);
if (success != true) {
    Debug.WriteLine("ConnectFailReason: " + Convert.ToString(rest.ConnectFailReason));
    Debug.WriteLine(rest.LastErrorText);
    return;
}

// The following code creates the JSON request body.
// The JSON created by this code is shown below.

// Use this online tool to generate code from sample JSON:
// Generate Code to Create JSON

Chilkat.JsonObject json = new Chilkat.JsonObject();
json.UpdateString("BackupIds[0]","string");
json.UpdateString("Filters[0].Name","string");
json.UpdateString("Filters[0].Values[0]","string");
json.UpdateInt("MaxResults",123);
json.UpdateString("NextToken","string");

// The JSON request body created by the above code:

// {
//   "BackupIds": [
//     "string"
//   ],
//   "Filters": [
//     {
//       "Name": "string",
//       "Values": [
//         "string"
//       ]
//     }
//   ],
//   "MaxResults": number,
//   "NextToken": "string"
// }

rest.AddHeader("Content-Type","application/x-amz-json-1.1");
rest.AddHeader("X-Amz-Target","AWSSimbaAPIService_v20180301.DescribeBackups");

Chilkat.StringBuilder sbRequestBody = new Chilkat.StringBuilder();
json.EmitSb(sbRequestBody);
Chilkat.StringBuilder sbResponseBody = new Chilkat.StringBuilder();
success = rest.FullRequestSb("POST","/",sbRequestBody,sbResponseBody);
if (success != true) {
    Debug.WriteLine(rest.LastErrorText);
    return;
}

int respStatusCode = rest.ResponseStatusCode;
Debug.WriteLine("response status code = " + Convert.ToString(respStatusCode));
if (respStatusCode != 200) {
    Debug.WriteLine("Response Header:");
    Debug.WriteLine(rest.ResponseHeader);
    Debug.WriteLine("Response Body:");
    Debug.WriteLine(sbResponseBody.GetAsString());
    return;
}

Chilkat.JsonObject jResp = new Chilkat.JsonObject();
jResp.LoadSb(sbResponseBody);

// The following code parses the JSON response.
// A sample JSON response is shown below the sample code.

// Use this online tool to generate parsing code from sample JSON:
// Generate Parsing Code from JSON

string BackupId;
int CreationTime;
string ActiveDirectoryId;
string DomainName;
string ResourceARN;
string Message;
int FileSystemCreationTime;
string DNSName;
string FailureDetailsMessage;
string FileSystemId;
string FileSystemType;
string FileSystemTypeVersion;
string KmsKeyId;
string Lifecycle;
int AutomaticBackupRetentionDays;
int CopyTagsToBackups;
string DailyAutomaticBackupStartTime;
string DataCompressionType;
string AutoImportPolicy;
string ExportPath;
int ImportedFileChunkSize;
string ImportPath;
string DataRepositoryConfigurationLifecycle;
string DeploymentType;
string DriveCacheType;
string Destination;
string Level;
string MountName;
int PerUnitStorageThroughput;
string WeeklyMaintenanceStartTime;
int OntapConfigurationAutomaticBackupRetentionDays;
string OntapConfigurationDailyAutomaticBackupStartTime;
string OntapConfigurationDeploymentType;
int Iops;
string Mode;
string EndpointIpAddressRange;
string InterclusterDNSName;
string ManagementDNSName;
string PreferredSubnetId;
int ThroughputCapacity;
string OntapConfigurationWeeklyMaintenanceStartTime;
int OpenZFSConfigurationAutomaticBackupRetentionDays;
int OpenZFSConfigurationCopyTagsToBackups;
int CopyTagsToVolumes;
string OpenZFSConfigurationDailyAutomaticBackupStartTime;
string OpenZFSConfigurationDeploymentType;
int DiskIopsConfigurationIops;
string DiskIopsConfigurationMode;
string RootVolumeId;
int OpenZFSConfigurationThroughputCapacity;
string OpenZFSConfigurationWeeklyMaintenanceStartTime;
string OwnerId;
string FileSystemResourceARN;
int StorageCapacity;
string StorageType;
string VpcId;
string WindowsConfigurationActiveDirectoryId;
string AuditLogDestination;
string FileAccessAuditLogLevel;
string FileShareAccessAuditLogLevel;
int WindowsConfigurationAutomaticBackupRetentionDays;
int WindowsConfigurationCopyTagsToBackups;
string WindowsConfigurationDailyAutomaticBackupStartTime;
string WindowsConfigurationDeploymentType;
string PreferredFileServerIp;
string WindowsConfigurationPreferredSubnetId;
string RemoteAdministrationEndpoint;
string SelfManagedActiveDirectoryConfigurationDomainName;
string FileSystemAdministratorsGroup;
string OrganizationalUnitDistinguishedName;
string UserName;
int WindowsConfigurationThroughputCapacity;
string WindowsConfigurationWeeklyMaintenanceStartTime;
int ProgressPercent;
string ResourceType;
string SourceBackupId;
string SourceBackupRegion;
string v_Type;
int VolumeCreationTime;
string VolumeFileSystemId;
string VolumeLifecycle;
string LifecycleTransitionReasonMessage;
string Name;
string FlexCacheEndpointType;
string JunctionPath;
string OntapVolumeType;
string SecurityStyle;
int SizeInMegabytes;
int StorageEfficiencyEnabled;
string StorageVirtualMachineId;
int StorageVirtualMachineRoot;
int CoolingPeriod;
string TieringPolicyName;
string UUID;
int CopyTagsToSnapshots;
string OpenZFSConfigurationDataCompressionType;
string CopyStrategy;
string SnapshotARN;
string ParentVolumeId;
int ReadOnly;
int RecordSizeKiB;
int StorageCapacityQuotaGiB;
int StorageCapacityReservationGiB;
string VolumePath;
string VolumeResourceARN;
string VolumeId;
string VolumeType;
int j;
int count_j;
string AdministrativeActionType;
int RequestTime;
string Status;
string TargetFileSystemValues;
int TargetSnapshotValuesCreationTime;
string TargetSnapshotValuesLifecycle;
string TargetSnapshotValuesName;
string TargetSnapshotValuesResourceARN;
string SnapshotId;
string TargetSnapshotValuesVolumeId;
int TargetVolumeValuesCreationTime;
string TargetVolumeValuesFileSystemId;
string TargetVolumeValuesLifecycle;
string TargetVolumeValuesName;
string OntapConfigurationFlexCacheEndpointType;
string OntapConfigurationJunctionPath;
string OntapConfigurationOntapVolumeType;
string OntapConfigurationSecurityStyle;
int OntapConfigurationSizeInMegabytes;
int OntapConfigurationStorageEfficiencyEnabled;
string OntapConfigurationStorageVirtualMachineId;
int OntapConfigurationStorageVirtualMachineRoot;
int TieringPolicyCoolingPeriod;
string OntapConfigurationUUID;
int OpenZFSConfigurationCopyTagsToSnapshots;
string OriginSnapshotCopyStrategy;
string OriginSnapshotSnapshotARN;
string OpenZFSConfigurationParentVolumeId;
int OpenZFSConfigurationReadOnly;
int OpenZFSConfigurationRecordSizeKiB;
int OpenZFSConfigurationStorageCapacityQuotaGiB;
int OpenZFSConfigurationStorageCapacityReservationGiB;
string OpenZFSConfigurationVolumePath;
string TargetVolumeValuesResourceARN;
string TargetVolumeValuesVolumeId;
string TargetVolumeValuesVolumeType;
int k;
int count_k;
string strVal;
string Key;
string Value;
Chilkat.JsonObject json1 = null;
int i1;
int count_i1;
string Clients;
int j1;
int count_j1;
int Id;
int TargetFileSystemValuesCreationTime;
string TargetFileSystemValuesDNSName;
string TargetFileSystemValuesFileSystemId;
string TargetFileSystemValuesFileSystemType;
string TargetFileSystemValuesFileSystemTypeVersion;
string TargetFileSystemValuesKmsKeyId;
string TargetFileSystemValuesLifecycle;
int LustreConfigurationAutomaticBackupRetentionDays;
int LustreConfigurationCopyTagsToBackups;
string LustreConfigurationDailyAutomaticBackupStartTime;
string LustreConfigurationDataCompressionType;
string DataRepositoryConfigurationAutoImportPolicy;
string DataRepositoryConfigurationExportPath;
int DataRepositoryConfigurationImportedFileChunkSize;
string DataRepositoryConfigurationImportPath;
string LustreConfigurationDeploymentType;
string LustreConfigurationDriveCacheType;
string LogConfigurationDestination;
string LogConfigurationLevel;
string LustreConfigurationMountName;
int LustreConfigurationPerUnitStorageThroughput;
string LustreConfigurationWeeklyMaintenanceStartTime;
string OntapConfigurationEndpointIpAddressRange;
string OntapConfigurationPreferredSubnetId;
int OntapConfigurationThroughputCapacity;
int OpenZFSConfigurationCopyTagsToVolumes;
string OpenZFSConfigurationRootVolumeId;
string TargetFileSystemValuesOwnerId;
string TargetFileSystemValuesResourceARN;
int TargetFileSystemValuesStorageCapacity;
string TargetFileSystemValuesStorageType;
string TargetFileSystemValuesVpcId;
string AuditLogConfigurationAuditLogDestination;
string AuditLogConfigurationFileAccessAuditLogLevel;
string AuditLogConfigurationFileShareAccessAuditLogLevel;
string WindowsConfigurationPreferredFileServerIp;
string WindowsConfigurationRemoteAdministrationEndpoint;
string SelfManagedActiveDirectoryConfigurationFileSystemAdministratorsGroup;
string SelfManagedActiveDirectoryConfigurationOrganizationalUnitDistinguishedName;
string SelfManagedActiveDirectoryConfigurationUserName;
string TargetSnapshotValuesSnapshotId;
string TargetVolumeValues;

string NextToken = jResp.StringOf("NextToken");
int i = 0;
int count_i = jResp.SizeOfArray("Backups");
while (i < count_i) {
    jResp.I = i;
    BackupId = jResp.StringOf("Backups[i].BackupId");
    CreationTime = jResp.IntOf("Backups[i].CreationTime");
    ActiveDirectoryId = jResp.StringOf("Backups[i].DirectoryInformation.ActiveDirectoryId");
    DomainName = jResp.StringOf("Backups[i].DirectoryInformation.DomainName");
    ResourceARN = jResp.StringOf("Backups[i].DirectoryInformation.ResourceARN");
    Message = jResp.StringOf("Backups[i].FailureDetails.Message");
    FileSystemCreationTime = jResp.IntOf("Backups[i].FileSystem.CreationTime");
    DNSName = jResp.StringOf("Backups[i].FileSystem.DNSName");
    FailureDetailsMessage = jResp.StringOf("Backups[i].FileSystem.FailureDetails.Message");
    FileSystemId = jResp.StringOf("Backups[i].FileSystem.FileSystemId");
    FileSystemType = jResp.StringOf("Backups[i].FileSystem.FileSystemType");
    FileSystemTypeVersion = jResp.StringOf("Backups[i].FileSystem.FileSystemTypeVersion");
    KmsKeyId = jResp.StringOf("Backups[i].FileSystem.KmsKeyId");
    Lifecycle = jResp.StringOf("Backups[i].FileSystem.Lifecycle");
    AutomaticBackupRetentionDays = jResp.IntOf("Backups[i].FileSystem.LustreConfiguration.AutomaticBackupRetentionDays");
    CopyTagsToBackups = jResp.IntOf("Backups[i].FileSystem.LustreConfiguration.CopyTagsToBackups");
    DailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DailyAutomaticBackupStartTime");
    DataCompressionType = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataCompressionType");
    AutoImportPolicy = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.AutoImportPolicy");
    ExportPath = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.ExportPath");
    FailureDetailsMessage = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.FailureDetails.Message");
    ImportedFileChunkSize = jResp.IntOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.ImportedFileChunkSize");
    ImportPath = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.ImportPath");
    DataRepositoryConfigurationLifecycle = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DataRepositoryConfiguration.Lifecycle");
    DeploymentType = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DeploymentType");
    DriveCacheType = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.DriveCacheType");
    Destination = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.LogConfiguration.Destination");
    Level = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.LogConfiguration.Level");
    MountName = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.MountName");
    PerUnitStorageThroughput = jResp.IntOf("Backups[i].FileSystem.LustreConfiguration.PerUnitStorageThroughput");
    WeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].FileSystem.LustreConfiguration.WeeklyMaintenanceStartTime");
    OntapConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].FileSystem.OntapConfiguration.AutomaticBackupRetentionDays");
    OntapConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.DailyAutomaticBackupStartTime");
    OntapConfigurationDeploymentType = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.DeploymentType");
    Iops = jResp.IntOf("Backups[i].FileSystem.OntapConfiguration.DiskIopsConfiguration.Iops");
    Mode = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.DiskIopsConfiguration.Mode");
    EndpointIpAddressRange = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.EndpointIpAddressRange");
    InterclusterDNSName = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.Endpoints.Intercluster.DNSName");
    ManagementDNSName = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.Endpoints.Management.DNSName");
    PreferredSubnetId = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.PreferredSubnetId");
    ThroughputCapacity = jResp.IntOf("Backups[i].FileSystem.OntapConfiguration.ThroughputCapacity");
    OntapConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.WeeklyMaintenanceStartTime");
    OpenZFSConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].FileSystem.OpenZFSConfiguration.AutomaticBackupRetentionDays");
    OpenZFSConfigurationCopyTagsToBackups = jResp.IntOf("Backups[i].FileSystem.OpenZFSConfiguration.CopyTagsToBackups");
    CopyTagsToVolumes = jResp.IntOf("Backups[i].FileSystem.OpenZFSConfiguration.CopyTagsToVolumes");
    OpenZFSConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].FileSystem.OpenZFSConfiguration.DailyAutomaticBackupStartTime");
    OpenZFSConfigurationDeploymentType = jResp.StringOf("Backups[i].FileSystem.OpenZFSConfiguration.DeploymentType");
    DiskIopsConfigurationIops = jResp.IntOf("Backups[i].FileSystem.OpenZFSConfiguration.DiskIopsConfiguration.Iops");
    DiskIopsConfigurationMode = jResp.StringOf("Backups[i].FileSystem.OpenZFSConfiguration.DiskIopsConfiguration.Mode");
    RootVolumeId = jResp.StringOf("Backups[i].FileSystem.OpenZFSConfiguration.RootVolumeId");
    OpenZFSConfigurationThroughputCapacity = jResp.IntOf("Backups[i].FileSystem.OpenZFSConfiguration.ThroughputCapacity");
    OpenZFSConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].FileSystem.OpenZFSConfiguration.WeeklyMaintenanceStartTime");
    OwnerId = jResp.StringOf("Backups[i].FileSystem.OwnerId");
    FileSystemResourceARN = jResp.StringOf("Backups[i].FileSystem.ResourceARN");
    StorageCapacity = jResp.IntOf("Backups[i].FileSystem.StorageCapacity");
    StorageType = jResp.StringOf("Backups[i].FileSystem.StorageType");
    VpcId = jResp.StringOf("Backups[i].FileSystem.VpcId");
    WindowsConfigurationActiveDirectoryId = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.ActiveDirectoryId");
    AuditLogDestination = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.AuditLogConfiguration.AuditLogDestination");
    FileAccessAuditLogLevel = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.AuditLogConfiguration.FileAccessAuditLogLevel");
    FileShareAccessAuditLogLevel = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.AuditLogConfiguration.FileShareAccessAuditLogLevel");
    WindowsConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].FileSystem.WindowsConfiguration.AutomaticBackupRetentionDays");
    WindowsConfigurationCopyTagsToBackups = jResp.IntOf("Backups[i].FileSystem.WindowsConfiguration.CopyTagsToBackups");
    WindowsConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.DailyAutomaticBackupStartTime");
    WindowsConfigurationDeploymentType = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.DeploymentType");
    PreferredFileServerIp = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.PreferredFileServerIp");
    WindowsConfigurationPreferredSubnetId = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.PreferredSubnetId");
    RemoteAdministrationEndpoint = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.RemoteAdministrationEndpoint");
    SelfManagedActiveDirectoryConfigurationDomainName = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DomainName");
    FileSystemAdministratorsGroup = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.FileSystemAdministratorsGroup");
    OrganizationalUnitDistinguishedName = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.OrganizationalUnitDistinguishedName");
    UserName = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.UserName");
    WindowsConfigurationThroughputCapacity = jResp.IntOf("Backups[i].FileSystem.WindowsConfiguration.ThroughputCapacity");
    WindowsConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.WeeklyMaintenanceStartTime");
    KmsKeyId = jResp.StringOf("Backups[i].KmsKeyId");
    Lifecycle = jResp.StringOf("Backups[i].Lifecycle");
    OwnerId = jResp.StringOf("Backups[i].OwnerId");
    ProgressPercent = jResp.IntOf("Backups[i].ProgressPercent");
    ResourceARN = jResp.StringOf("Backups[i].ResourceARN");
    ResourceType = jResp.StringOf("Backups[i].ResourceType");
    SourceBackupId = jResp.StringOf("Backups[i].SourceBackupId");
    SourceBackupRegion = jResp.StringOf("Backups[i].SourceBackupRegion");
    v_Type = jResp.StringOf("Backups[i].Type");
    VolumeCreationTime = jResp.IntOf("Backups[i].Volume.CreationTime");
    VolumeFileSystemId = jResp.StringOf("Backups[i].Volume.FileSystemId");
    VolumeLifecycle = jResp.StringOf("Backups[i].Volume.Lifecycle");
    LifecycleTransitionReasonMessage = jResp.StringOf("Backups[i].Volume.LifecycleTransitionReason.Message");
    Name = jResp.StringOf("Backups[i].Volume.Name");
    FlexCacheEndpointType = jResp.StringOf("Backups[i].Volume.OntapConfiguration.FlexCacheEndpointType");
    JunctionPath = jResp.StringOf("Backups[i].Volume.OntapConfiguration.JunctionPath");
    OntapVolumeType = jResp.StringOf("Backups[i].Volume.OntapConfiguration.OntapVolumeType");
    SecurityStyle = jResp.StringOf("Backups[i].Volume.OntapConfiguration.SecurityStyle");
    SizeInMegabytes = jResp.IntOf("Backups[i].Volume.OntapConfiguration.SizeInMegabytes");
    StorageEfficiencyEnabled = jResp.IntOf("Backups[i].Volume.OntapConfiguration.StorageEfficiencyEnabled");
    StorageVirtualMachineId = jResp.StringOf("Backups[i].Volume.OntapConfiguration.StorageVirtualMachineId");
    StorageVirtualMachineRoot = jResp.IntOf("Backups[i].Volume.OntapConfiguration.StorageVirtualMachineRoot");
    CoolingPeriod = jResp.IntOf("Backups[i].Volume.OntapConfiguration.TieringPolicy.CoolingPeriod");
    TieringPolicyName = jResp.StringOf("Backups[i].Volume.OntapConfiguration.TieringPolicy.Name");
    UUID = jResp.StringOf("Backups[i].Volume.OntapConfiguration.UUID");
    CopyTagsToSnapshots = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.CopyTagsToSnapshots");
    OpenZFSConfigurationDataCompressionType = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.DataCompressionType");
    CopyStrategy = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.OriginSnapshot.CopyStrategy");
    SnapshotARN = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.OriginSnapshot.SnapshotARN");
    ParentVolumeId = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.ParentVolumeId");
    ReadOnly = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.ReadOnly");
    RecordSizeKiB = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.RecordSizeKiB");
    StorageCapacityQuotaGiB = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.StorageCapacityQuotaGiB");
    StorageCapacityReservationGiB = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.StorageCapacityReservationGiB");
    VolumePath = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.VolumePath");
    VolumeResourceARN = jResp.StringOf("Backups[i].Volume.ResourceARN");
    VolumeId = jResp.StringOf("Backups[i].Volume.VolumeId");
    VolumeType = jResp.StringOf("Backups[i].Volume.VolumeType");
    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions");
    while (j < count_j) {
        jResp.J = j;
        AdministrativeActionType = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].AdministrativeActionType");
        FailureDetailsMessage = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].FailureDetails.Message");
        ProgressPercent = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].ProgressPercent");
        RequestTime = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].RequestTime");
        Status = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].Status");
        TargetFileSystemValues = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetFileSystemValues");
        TargetSnapshotValuesCreationTime = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.CreationTime");
        TargetSnapshotValuesLifecycle = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.Lifecycle");
        LifecycleTransitionReasonMessage = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.LifecycleTransitionReason.Message");
        TargetSnapshotValuesName = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.Name");
        TargetSnapshotValuesResourceARN = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.ResourceARN");
        SnapshotId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.SnapshotId");
        TargetSnapshotValuesVolumeId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.VolumeId");
        TargetVolumeValuesCreationTime = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.CreationTime");
        TargetVolumeValuesFileSystemId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.FileSystemId");
        TargetVolumeValuesLifecycle = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.Lifecycle");
        LifecycleTransitionReasonMessage = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.LifecycleTransitionReason.Message");
        TargetVolumeValuesName = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.Name");
        OntapConfigurationFlexCacheEndpointType = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.FlexCacheEndpointType");
        OntapConfigurationJunctionPath = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.JunctionPath");
        OntapConfigurationOntapVolumeType = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.OntapVolumeType");
        OntapConfigurationSecurityStyle = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.SecurityStyle");
        OntapConfigurationSizeInMegabytes = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.SizeInMegabytes");
        OntapConfigurationStorageEfficiencyEnabled = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.StorageEfficiencyEnabled");
        OntapConfigurationStorageVirtualMachineId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.StorageVirtualMachineId");
        OntapConfigurationStorageVirtualMachineRoot = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.StorageVirtualMachineRoot");
        TieringPolicyCoolingPeriod = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.TieringPolicy.CoolingPeriod");
        TieringPolicyName = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.TieringPolicy.Name");
        OntapConfigurationUUID = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OntapConfiguration.UUID");
        OpenZFSConfigurationCopyTagsToSnapshots = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.CopyTagsToSnapshots");
        OpenZFSConfigurationDataCompressionType = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.DataCompressionType");
        OriginSnapshotCopyStrategy = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.OriginSnapshot.CopyStrategy");
        OriginSnapshotSnapshotARN = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.OriginSnapshot.SnapshotARN");
        OpenZFSConfigurationParentVolumeId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.ParentVolumeId");
        OpenZFSConfigurationReadOnly = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.ReadOnly");
        OpenZFSConfigurationRecordSizeKiB = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.RecordSizeKiB");
        OpenZFSConfigurationStorageCapacityQuotaGiB = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.StorageCapacityQuotaGiB");
        OpenZFSConfigurationStorageCapacityReservationGiB = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.StorageCapacityReservationGiB");
        OpenZFSConfigurationVolumePath = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.VolumePath");
        TargetVolumeValuesResourceARN = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.ResourceARN");
        TargetVolumeValuesVolumeId = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.VolumeId");
        TargetVolumeValuesVolumeType = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.VolumeType");
        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.AdministrativeActions");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.AdministrativeActions[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.Tags");
        while (k < count_k) {
            jResp.K = k;
            Key = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.Tags[k].Key");
            Value = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetSnapshotValues.Tags[k].Value");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.AdministrativeActions");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.AdministrativeActions[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.NfsExports");
        while (k < count_k) {
            jResp.K = k;

            json1 = jResp.ObjectOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.NfsExports[k]");
            i1 = 0;
            count_i1 = json1.SizeOfArray("ClientConfigurations");
            while (i1 < count_i1) {
                json1.I = i1;
                Clients = json1.StringOf("ClientConfigurations[i].Clients");
                j1 = 0;
                count_j1 = json1.SizeOfArray("ClientConfigurations[i].Options");
                while (j1 < count_j1) {
                    json1.J = j1;
                    strVal = json1.StringOf("ClientConfigurations[i].Options[j]");
                    j1 = j1 + 1;
                }

                i1 = i1 + 1;
            }

            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.UserAndGroupQuotas");
        while (k < count_k) {
            jResp.K = k;
            Id = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.UserAndGroupQuotas[k].Id");
            StorageCapacityQuotaGiB = jResp.IntOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.UserAndGroupQuotas[k].StorageCapacityQuotaGiB");
            v_Type = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.OpenZFSConfiguration.UserAndGroupQuotas[k].Type");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.Tags");
        while (k < count_k) {
            jResp.K = k;
            Key = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.Tags[k].Key");
            Value = jResp.StringOf("Backups[i].FileSystem.AdministrativeActions[j].TargetVolumeValues.Tags[k].Value");
            k = k + 1;
        }

        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.NetworkInterfaceIds");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.NetworkInterfaceIds[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.OntapConfiguration.Endpoints.Intercluster.IpAddresses");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.Endpoints.Intercluster.IpAddresses[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.OntapConfiguration.Endpoints.Management.IpAddresses");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.Endpoints.Management.IpAddresses[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.OntapConfiguration.RouteTableIds");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.OntapConfiguration.RouteTableIds[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.SubnetIds");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.SubnetIds[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.Tags");
    while (j < count_j) {
        jResp.J = j;
        Key = jResp.StringOf("Backups[i].FileSystem.Tags[j].Key");
        Value = jResp.StringOf("Backups[i].FileSystem.Tags[j].Value");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.WindowsConfiguration.Aliases");
    while (j < count_j) {
        jResp.J = j;
        Lifecycle = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.Aliases[j].Lifecycle");
        Name = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.Aliases[j].Name");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.WindowsConfiguration.MaintenanceOperationsInProgress");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.MaintenanceOperationsInProgress[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DnsIps");
    while (j < count_j) {
        jResp.J = j;
        strVal = jResp.StringOf("Backups[i].FileSystem.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DnsIps[j]");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].Tags");
    while (j < count_j) {
        jResp.J = j;
        Key = jResp.StringOf("Backups[i].Tags[j].Key");
        Value = jResp.StringOf("Backups[i].Tags[j].Value");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions");
    while (j < count_j) {
        jResp.J = j;
        AdministrativeActionType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].AdministrativeActionType");
        FailureDetailsMessage = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].FailureDetails.Message");
        ProgressPercent = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].ProgressPercent");
        RequestTime = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].RequestTime");
        Status = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].Status");
        TargetFileSystemValuesCreationTime = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.CreationTime");
        TargetFileSystemValuesDNSName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.DNSName");
        FailureDetailsMessage = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.FailureDetails.Message");
        TargetFileSystemValuesFileSystemId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.FileSystemId");
        TargetFileSystemValuesFileSystemType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.FileSystemType");
        TargetFileSystemValuesFileSystemTypeVersion = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.FileSystemTypeVersion");
        TargetFileSystemValuesKmsKeyId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.KmsKeyId");
        TargetFileSystemValuesLifecycle = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.Lifecycle");
        LustreConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.AutomaticBackupRetentionDays");
        LustreConfigurationCopyTagsToBackups = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.CopyTagsToBackups");
        LustreConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DailyAutomaticBackupStartTime");
        LustreConfigurationDataCompressionType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataCompressionType");
        DataRepositoryConfigurationAutoImportPolicy = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.AutoImportPolicy");
        DataRepositoryConfigurationExportPath = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.ExportPath");
        FailureDetailsMessage = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.FailureDetails.Message");
        DataRepositoryConfigurationImportedFileChunkSize = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.ImportedFileChunkSize");
        DataRepositoryConfigurationImportPath = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.ImportPath");
        DataRepositoryConfigurationLifecycle = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DataRepositoryConfiguration.Lifecycle");
        LustreConfigurationDeploymentType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DeploymentType");
        LustreConfigurationDriveCacheType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.DriveCacheType");
        LogConfigurationDestination = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.LogConfiguration.Destination");
        LogConfigurationLevel = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.LogConfiguration.Level");
        LustreConfigurationMountName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.MountName");
        LustreConfigurationPerUnitStorageThroughput = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.PerUnitStorageThroughput");
        LustreConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.LustreConfiguration.WeeklyMaintenanceStartTime");
        OntapConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.AutomaticBackupRetentionDays");
        OntapConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.DailyAutomaticBackupStartTime");
        OntapConfigurationDeploymentType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.DeploymentType");
        DiskIopsConfigurationIops = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.DiskIopsConfiguration.Iops");
        DiskIopsConfigurationMode = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.DiskIopsConfiguration.Mode");
        OntapConfigurationEndpointIpAddressRange = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.EndpointIpAddressRange");
        InterclusterDNSName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Intercluster.DNSName");
        ManagementDNSName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Management.DNSName");
        OntapConfigurationPreferredSubnetId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.PreferredSubnetId");
        OntapConfigurationThroughputCapacity = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.ThroughputCapacity");
        OntapConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.WeeklyMaintenanceStartTime");
        OpenZFSConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.AutomaticBackupRetentionDays");
        OpenZFSConfigurationCopyTagsToBackups = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.CopyTagsToBackups");
        OpenZFSConfigurationCopyTagsToVolumes = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.CopyTagsToVolumes");
        OpenZFSConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.DailyAutomaticBackupStartTime");
        OpenZFSConfigurationDeploymentType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.DeploymentType");
        DiskIopsConfigurationIops = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.DiskIopsConfiguration.Iops");
        DiskIopsConfigurationMode = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.DiskIopsConfiguration.Mode");
        OpenZFSConfigurationRootVolumeId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.RootVolumeId");
        OpenZFSConfigurationThroughputCapacity = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.ThroughputCapacity");
        OpenZFSConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OpenZFSConfiguration.WeeklyMaintenanceStartTime");
        TargetFileSystemValuesOwnerId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OwnerId");
        TargetFileSystemValuesResourceARN = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.ResourceARN");
        TargetFileSystemValuesStorageCapacity = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.StorageCapacity");
        TargetFileSystemValuesStorageType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.StorageType");
        TargetFileSystemValuesVpcId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.VpcId");
        WindowsConfigurationActiveDirectoryId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.ActiveDirectoryId");
        AuditLogConfigurationAuditLogDestination = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.AuditLogConfiguration.AuditLogDestination");
        AuditLogConfigurationFileAccessAuditLogLevel = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.AuditLogConfiguration.FileAccessAuditLogLevel");
        AuditLogConfigurationFileShareAccessAuditLogLevel = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.AuditLogConfiguration.FileShareAccessAuditLogLevel");
        WindowsConfigurationAutomaticBackupRetentionDays = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.AutomaticBackupRetentionDays");
        WindowsConfigurationCopyTagsToBackups = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.CopyTagsToBackups");
        WindowsConfigurationDailyAutomaticBackupStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.DailyAutomaticBackupStartTime");
        WindowsConfigurationDeploymentType = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.DeploymentType");
        WindowsConfigurationPreferredFileServerIp = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.PreferredFileServerIp");
        WindowsConfigurationPreferredSubnetId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.PreferredSubnetId");
        WindowsConfigurationRemoteAdministrationEndpoint = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.RemoteAdministrationEndpoint");
        SelfManagedActiveDirectoryConfigurationDomainName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DomainName");
        SelfManagedActiveDirectoryConfigurationFileSystemAdministratorsGroup = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.FileSystemAdministratorsGroup");
        SelfManagedActiveDirectoryConfigurationOrganizationalUnitDistinguishedName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.OrganizationalUnitDistinguishedName");
        SelfManagedActiveDirectoryConfigurationUserName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.UserName");
        WindowsConfigurationThroughputCapacity = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.ThroughputCapacity");
        WindowsConfigurationWeeklyMaintenanceStartTime = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.WeeklyMaintenanceStartTime");
        TargetSnapshotValuesCreationTime = jResp.IntOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.CreationTime");
        TargetSnapshotValuesLifecycle = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.Lifecycle");
        LifecycleTransitionReasonMessage = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.LifecycleTransitionReason.Message");
        TargetSnapshotValuesName = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.Name");
        TargetSnapshotValuesResourceARN = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.ResourceARN");
        TargetSnapshotValuesSnapshotId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.SnapshotId");
        TargetSnapshotValuesVolumeId = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.VolumeId");
        TargetVolumeValues = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetVolumeValues");
        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.AdministrativeActions");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.AdministrativeActions[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.NetworkInterfaceIds");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.NetworkInterfaceIds[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Intercluster.IpAddresses");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Intercluster.IpAddresses[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Management.IpAddresses");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.Endpoints.Management.IpAddresses[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.RouteTableIds");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.OntapConfiguration.RouteTableIds[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.SubnetIds");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.SubnetIds[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.Tags");
        while (k < count_k) {
            jResp.K = k;
            Key = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.Tags[k].Key");
            Value = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.Tags[k].Value");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.Aliases");
        while (k < count_k) {
            jResp.K = k;
            Lifecycle = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.Aliases[k].Lifecycle");
            Name = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.Aliases[k].Name");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.MaintenanceOperationsInProgress");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.MaintenanceOperationsInProgress[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DnsIps");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetFileSystemValues.WindowsConfiguration.SelfManagedActiveDirectoryConfiguration.DnsIps[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.AdministrativeActions");
        while (k < count_k) {
            jResp.K = k;
            strVal = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.AdministrativeActions[k]");
            k = k + 1;
        }

        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.Tags");
        while (k < count_k) {
            jResp.K = k;
            Key = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.Tags[k].Key");
            Value = jResp.StringOf("Backups[i].Volume.AdministrativeActions[j].TargetSnapshotValues.Tags[k].Value");
            k = k + 1;
        }

        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].Volume.OpenZFSConfiguration.NfsExports");
    while (j < count_j) {
        jResp.J = j;
        k = 0;
        count_k = jResp.SizeOfArray("Backups[i].Volume.OpenZFSConfiguration.NfsExports[j].ClientConfigurations");
        while (k < count_k) {
            jResp.K = k;
            Clients = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.NfsExports[j].ClientConfigurations[k].Clients");

            json1 = jResp.ObjectOf("Backups[i].Volume.OpenZFSConfiguration.NfsExports[j].ClientConfigurations[k]");
            i1 = 0;
            count_i1 = json1.SizeOfArray("Options");
            while (i1 < count_i1) {
                json1.I = i1;
                strVal = json1.StringOf("Options[i]");
                i1 = i1 + 1;
            }

            k = k + 1;
        }

        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].Volume.OpenZFSConfiguration.UserAndGroupQuotas");
    while (j < count_j) {
        jResp.J = j;
        Id = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.UserAndGroupQuotas[j].Id");
        StorageCapacityQuotaGiB = jResp.IntOf("Backups[i].Volume.OpenZFSConfiguration.UserAndGroupQuotas[j].StorageCapacityQuotaGiB");
        v_Type = jResp.StringOf("Backups[i].Volume.OpenZFSConfiguration.UserAndGroupQuotas[j].Type");
        j = j + 1;
    }

    j = 0;
    count_j = jResp.SizeOfArray("Backups[i].Volume.Tags");
    while (j < count_j) {
        jResp.J = j;
        Key = jResp.StringOf("Backups[i].Volume.Tags[j].Key");
        Value = jResp.StringOf("Backups[i].Volume.Tags[j].Value");
        j = j + 1;
    }

    i = i + 1;
}

// A sample JSON response body parsed by the above code:

// {
//   "Backups": [
//     {
//       "BackupId": "string",
//       "CreationTime": number,
//       "DirectoryInformation": {
//         "ActiveDirectoryId": "string",
//         "DomainName": "string",
//         "ResourceARN": "string"
//       },
//       "FailureDetails": {
//         "Message": "string"
//       },
//       "FileSystem": {
//         "AdministrativeActions": [
//           {
//             "AdministrativeActionType": "string",
//             "FailureDetails": {
//               "Message": "string"
//             },
//             "ProgressPercent": number,
//             "RequestTime": number,
//             "Status": "string",
//             "TargetFileSystemValues": "FileSystem",
//             "TargetSnapshotValues": {
//               "AdministrativeActions": [
//                 "AdministrativeAction"
//               ],
//               "CreationTime": number,
//               "Lifecycle": "string",
//               "LifecycleTransitionReason": {
//                 "Message": "string"
//               },
//               "Name": "string",
//               "ResourceARN": "string",
//               "SnapshotId": "string",
//               "Tags": [
//                 {
//                   "Key": "string",
//                   "Value": "string"
//                 }
//               ],
//               "VolumeId": "string"
//             },
//             "TargetVolumeValues": {
//               "AdministrativeActions": [
//                 "AdministrativeAction"
//               ],
//               "CreationTime": number,
//               "FileSystemId": "string",
//               "Lifecycle": "string",
//               "LifecycleTransitionReason": {
//                 "Message": "string"
//               },
//               "Name": "string",
//               "OntapConfiguration": {
//                 "FlexCacheEndpointType": "string",
//                 "JunctionPath": "string",
//                 "OntapVolumeType": "string",
//                 "SecurityStyle": "string",
//                 "SizeInMegabytes": number,
//                 "StorageEfficiencyEnabled": boolean,
//                 "StorageVirtualMachineId": "string",
//                 "StorageVirtualMachineRoot": boolean,
//                 "TieringPolicy": {
//                   "CoolingPeriod": number,
//                   "Name": "string"
//                 },
//                 "UUID": "string"
//               },
//               "OpenZFSConfiguration": {
//                 "CopyTagsToSnapshots": boolean,
//                 "DataCompressionType": "string",
//                 "NfsExports": [
//                   {
//                     "ClientConfigurations": [
//                       {
//                         "Clients": "string",
//                         "Options": [
//                           "string"
//                         ]
//                       }
//                     ]
//                   }
//                 ],
//                 "OriginSnapshot": {
//                   "CopyStrategy": "string",
//                   "SnapshotARN": "string"
//                 },
//                 "ParentVolumeId": "string",
//                 "ReadOnly": boolean,
//                 "RecordSizeKiB": number,
//                 "StorageCapacityQuotaGiB": number,
//                 "StorageCapacityReservationGiB": number,
//                 "UserAndGroupQuotas": [
//                   {
//                     "Id": number,
//                     "StorageCapacityQuotaGiB": number,
//                     "Type": "string"
//                   }
//                 ],
//                 "VolumePath": "string"
//               },
//               "ResourceARN": "string",
//               "Tags": [
//                 {
//                   "Key": "string",
//                   "Value": "string"
//                 }
//               ],
//               "VolumeId": "string",
//               "VolumeType": "string"
//             }
//           }
//         ],
//         "CreationTime": number,
//         "DNSName": "string",
//         "FailureDetails": {
//           "Message": "string"
//         },
//         "FileSystemId": "string",
//         "FileSystemType": "string",
//         "FileSystemTypeVersion": "string",
//         "KmsKeyId": "string",
//         "Lifecycle": "string",
//         "LustreConfiguration": {
//           "AutomaticBackupRetentionDays": number,
//           "CopyTagsToBackups": boolean,
//           "DailyAutomaticBackupStartTime": "string",
//           "DataCompressionType": "string",
//           "DataRepositoryConfiguration": {
//             "AutoImportPolicy": "string",
//             "ExportPath": "string",
//             "FailureDetails": {
//               "Message": "string"
//             },
//             "ImportedFileChunkSize": number,
//             "ImportPath": "string",
//             "Lifecycle": "string"
//           },
//           "DeploymentType": "string",
//           "DriveCacheType": "string",
//           "LogConfiguration": {
//             "Destination": "string",
//             "Level": "string"
//           },
//           "MountName": "string",
//           "PerUnitStorageThroughput": number,
//           "WeeklyMaintenanceStartTime": "string"
//         },
//         "NetworkInterfaceIds": [
//           "string"
//         ],
//         "OntapConfiguration": {
//           "AutomaticBackupRetentionDays": number,
//           "DailyAutomaticBackupStartTime": "string",
//           "DeploymentType": "string",
//           "DiskIopsConfiguration": {
//             "Iops": number,
//             "Mode": "string"
//           },
//           "EndpointIpAddressRange": "string",
//           "Endpoints": {
//             "Intercluster": {
//               "DNSName": "string",
//               "IpAddresses": [
//                 "string"
//               ]
//             },
//             "Management": {
//               "DNSName": "string",
//               "IpAddresses": [
//                 "string"
//               ]
//             }
//           },
//           "PreferredSubnetId": "string",
//           "RouteTableIds": [
//             "string"
//           ],
//           "ThroughputCapacity": number,
//           "WeeklyMaintenanceStartTime": "string"
//         },
//         "OpenZFSConfiguration": {
//           "AutomaticBackupRetentionDays": number,
//           "CopyTagsToBackups": boolean,
//           "CopyTagsToVolumes": boolean,
//           "DailyAutomaticBackupStartTime": "string",
//           "DeploymentType": "string",
//           "DiskIopsConfiguration": {
//             "Iops": number,
//             "Mode": "string"
//           },
//           "RootVolumeId": "string",
//           "ThroughputCapacity": number,
//           "WeeklyMaintenanceStartTime": "string"
//         },
//         "OwnerId": "string",
//         "ResourceARN": "string",
//         "StorageCapacity": number,
//         "StorageType": "string",
//         "SubnetIds": [
//           "string"
//         ],
//         "Tags": [
//           {
//             "Key": "string",
//             "Value": "string"
//           }
//         ],
//         "VpcId": "string",
//         "WindowsConfiguration": {
//           "ActiveDirectoryId": "string",
//           "Aliases": [
//             {
//               "Lifecycle": "string",
//               "Name": "string"
//             }
//           ],
//           "AuditLogConfiguration": {
//             "AuditLogDestination": "string",
//             "FileAccessAuditLogLevel": "string",
//             "FileShareAccessAuditLogLevel": "string"
//           },
//           "AutomaticBackupRetentionDays": number,
//           "CopyTagsToBackups": boolean,
//           "DailyAutomaticBackupStartTime": "string",
//           "DeploymentType": "string",
//           "MaintenanceOperationsInProgress": [
//             "string"
//           ],
//           "PreferredFileServerIp": "string",
//           "PreferredSubnetId": "string",
//           "RemoteAdministrationEndpoint": "string",
//           "SelfManagedActiveDirectoryConfiguration": {
//             "DnsIps": [
//               "string"
//             ],
//             "DomainName": "string",
//             "FileSystemAdministratorsGroup": "string",
//             "OrganizationalUnitDistinguishedName": "string",
//             "UserName": "string"
//           },
//           "ThroughputCapacity": number,
//           "WeeklyMaintenanceStartTime": "string"
//         }
//       },
//       "KmsKeyId": "string",
//       "Lifecycle": "string",
//       "OwnerId": "string",
//       "ProgressPercent": number,
//       "ResourceARN": "string",
//       "ResourceType": "string",
//       "SourceBackupId": "string",
//       "SourceBackupRegion": "string",
//       "Tags": [
//         {
//           "Key": "string",
//           "Value": "string"
//         }
//       ],
//       "Type": "string",
//       "Volume": {
//         "AdministrativeActions": [
//           {
//             "AdministrativeActionType": "string",
//             "FailureDetails": {
//               "Message": "string"
//             },
//             "ProgressPercent": number,
//             "RequestTime": number,
//             "Status": "string",
//             "TargetFileSystemValues": {
//               "AdministrativeActions": [
//                 "AdministrativeAction"
//               ],
//               "CreationTime": number,
//               "DNSName": "string",
//               "FailureDetails": {
//                 "Message": "string"
//               },
//               "FileSystemId": "string",
//               "FileSystemType": "string",
//               "FileSystemTypeVersion": "string",
//               "KmsKeyId": "string",
//               "Lifecycle": "string",
//               "LustreConfiguration": {
//                 "AutomaticBackupRetentionDays": number,
//                 "CopyTagsToBackups": boolean,
//                 "DailyAutomaticBackupStartTime": "string",
//                 "DataCompressionType": "string",
//                 "DataRepositoryConfiguration": {
//                   "AutoImportPolicy": "string",
//                   "ExportPath": "string",
//                   "FailureDetails": {
//                     "Message": "string"
//                   },
//                   "ImportedFileChunkSize": number,
//                   "ImportPath": "string",
//                   "Lifecycle": "string"
//                 },
//                 "DeploymentType": "string",
//                 "DriveCacheType": "string",
//                 "LogConfiguration": {
//                   "Destination": "string",
//                   "Level": "string"
//                 },
//                 "MountName": "string",
//                 "PerUnitStorageThroughput": number,
//                 "WeeklyMaintenanceStartTime": "string"
//               },
//               "NetworkInterfaceIds": [
//                 "string"
//               ],
//               "OntapConfiguration": {
//                 "AutomaticBackupRetentionDays": number,
//                 "DailyAutomaticBackupStartTime": "string",
//                 "DeploymentType": "string",
//                 "DiskIopsConfiguration": {
//                   "Iops": number,
//                   "Mode": "string"
//                 },
//                 "EndpointIpAddressRange": "string",
//                 "Endpoints": {
//                   "Intercluster": {
//                     "DNSName": "string",
//                     "IpAddresses": [
//                       "string"
//                     ]
//                   },
//                   "Management": {
//                     "DNSName": "string",
//                     "IpAddresses": [
//                       "string"
//                     ]
//                   }
//                 },
//                 "PreferredSubnetId": "string",
//                 "RouteTableIds": [
//                   "string"
//                 ],
//                 "ThroughputCapacity": number,
//                 "WeeklyMaintenanceStartTime": "string"
//               },
//               "OpenZFSConfiguration": {
//                 "AutomaticBackupRetentionDays": number,
//                 "CopyTagsToBackups": boolean,
//                 "CopyTagsToVolumes": boolean,
//                 "DailyAutomaticBackupStartTime": "string",
//                 "DeploymentType": "string",
//                 "DiskIopsConfiguration": {
//                   "Iops": number,
//                   "Mode": "string"
//                 },
//                 "RootVolumeId": "string",
//                 "ThroughputCapacity": number,
//                 "WeeklyMaintenanceStartTime": "string"
//               },
//               "OwnerId": "string",
//               "ResourceARN": "string",
//               "StorageCapacity": number,
//               "StorageType": "string",
//               "SubnetIds": [
//                 "string"
//               ],
//               "Tags": [
//                 {
//                   "Key": "string",
//                   "Value": "string"
//                 }
//               ],
//               "VpcId": "string",
//               "WindowsConfiguration": {
//                 "ActiveDirectoryId": "string",
//                 "Aliases": [
//                   {
//                     "Lifecycle": "string",
//                     "Name": "string"
//                   }
//                 ],
//                 "AuditLogConfiguration": {
//                   "AuditLogDestination": "string",
//                   "FileAccessAuditLogLevel": "string",
//                   "FileShareAccessAuditLogLevel": "string"
//                 },
//                 "AutomaticBackupRetentionDays": number,
//                 "CopyTagsToBackups": boolean,
//                 "DailyAutomaticBackupStartTime": "string",
//                 "DeploymentType": "string",
//                 "MaintenanceOperationsInProgress": [
//                   "string"
//                 ],
//                 "PreferredFileServerIp": "string",
//                 "PreferredSubnetId": "string",
//                 "RemoteAdministrationEndpoint": "string",
//                 "SelfManagedActiveDirectoryConfiguration": {
//                   "DnsIps": [
//                     "string"
//                   ],
//                   "DomainName": "string",
//                   "FileSystemAdministratorsGroup": "string",
//                   "OrganizationalUnitDistinguishedName": "string",
//                   "UserName": "string"
//                 },
//                 "ThroughputCapacity": number,
//                 "WeeklyMaintenanceStartTime": "string"
//               }
//             },
//             "TargetSnapshotValues": {
//               "AdministrativeActions": [
//                 "AdministrativeAction"
//               ],
//               "CreationTime": number,
//               "Lifecycle": "string",
//               "LifecycleTransitionReason": {
//                 "Message": "string"
//               },
//               "Name": "string",
//               "ResourceARN": "string",
//               "SnapshotId": "string",
//               "Tags": [
//                 {
//                   "Key": "string",
//                   "Value": "string"
//                 }
//               ],
//               "VolumeId": "string"
//             },
//             "TargetVolumeValues": "Volume"
//           }
//         ],
//         "CreationTime": number,
//         "FileSystemId": "string",
//         "Lifecycle": "string",
//         "LifecycleTransitionReason": {
//           "Message": "string"
//         },
//         "Name": "string",
//         "OntapConfiguration": {
//           "FlexCacheEndpointType": "string",
//           "JunctionPath": "string",
//           "OntapVolumeType": "string",
//           "SecurityStyle": "string",
//           "SizeInMegabytes": number,
//           "StorageEfficiencyEnabled": boolean,
//           "StorageVirtualMachineId": "string",
//           "StorageVirtualMachineRoot": boolean,
//           "TieringPolicy": {
//             "CoolingPeriod": number,
//             "Name": "string"
//           },
//           "UUID": "string"
//         },
//         "OpenZFSConfiguration": {
//           "CopyTagsToSnapshots": boolean,
//           "DataCompressionType": "string",
//           "NfsExports": [
//             {
//               "ClientConfigurations": [
//                 {
//                   "Clients": "string",
//                   "Options": [
//                     "string"
//                   ]
//                 }
//               ]
//             }
//           ],
//           "OriginSnapshot": {
//             "CopyStrategy": "string",
//             "SnapshotARN": "string"
//           },
//           "ParentVolumeId": "string",
//           "ReadOnly": boolean,
//           "RecordSizeKiB": number,
//           "StorageCapacityQuotaGiB": number,
//           "StorageCapacityReservationGiB": number,
//           "UserAndGroupQuotas": [
//             {
//               "Id": number,
//               "StorageCapacityQuotaGiB": number,
//               "Type": "string"
//             }
//           ],
//           "VolumePath": "string"
//         },
//         "ResourceARN": "string",
//         "Tags": [
//           {
//             "Key": "string",
//             "Value": "string"
//           }
//         ],
//         "VolumeId": "string",
//         "VolumeType": "string"
//       }
//     }
//   ],
//   "NextToken": "string"
// }