@azure/arm-storsimple8000series 2.1.1-alpha.20250619.1 → 2.1.1-alpha.20250718.2

package/dist/browser/models/mappers.js

@@ -2728,145 +2728,173 @@ export const Manager = {
     type: {
         name: "Composite",
         className: "Manager",
-        modelProperties: Object.assign(Object.assign({}, Resource.type.modelProperties), { etag: {
+        modelProperties: {
+            ...Resource.type.modelProperties,
+            etag: {
                 serializedName: "etag",
                 type: {
                     name: "String"
                 }
-            }, cisIntrinsicSettings: {
+            },
+            cisIntrinsicSettings: {
                 serializedName: "properties.cisIntrinsicSettings",
                 type: {
                     name: "Composite",
                     className: "ManagerIntrinsicSettings"
                 }
-            }, sku: {
+            },
+            sku: {
                 serializedName: "properties.sku",
                 type: {
                     name: "Composite",
                     className: "ManagerSku"
                 }
-            }, provisioningState: {
+            },
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const AccessControlRecord = {
     type: {
         name: "Composite",
         className: "AccessControlRecord",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { initiatorName: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            initiatorName: {
                 serializedName: "properties.initiatorName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, volumeCount: {
+            },
+            volumeCount: {
                 serializedName: "properties.volumeCount",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 export const Alert = {
     type: {
         name: "Composite",
         className: "Alert",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { title: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            title: {
                 serializedName: "properties.title",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, scope: {
+            },
+            scope: {
                 serializedName: "properties.scope",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Resource", "Device"]
                 }
-            }, alertType: {
+            },
+            alertType: {
                 serializedName: "properties.alertType",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, appearedAtTime: {
+            },
+            appearedAtTime: {
                 serializedName: "properties.appearedAtTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, appearedAtSourceTime: {
+            },
+            appearedAtSourceTime: {
                 serializedName: "properties.appearedAtSourceTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, clearedAtTime: {
+            },
+            clearedAtTime: {
                 serializedName: "properties.clearedAtTime",
                 type: {
                     name: "DateTime"
                 }
-            }, clearedAtSourceTime: {
+            },
+            clearedAtSourceTime: {
                 serializedName: "properties.clearedAtSourceTime",
                 type: {
                     name: "DateTime"
                 }
-            }, source: {
+            },
+            source: {
                 serializedName: "properties.source",
                 type: {
                     name: "Composite",
                     className: "AlertSource"
                 }
-            }, recommendation: {
+            },
+            recommendation: {
                 serializedName: "properties.recommendation",
                 type: {
                     name: "String"
                 }
-            }, resolutionReason: {
+            },
+            resolutionReason: {
                 serializedName: "properties.resolutionReason",
                 type: {
                     name: "String"
                 }
-            }, severity: {
+            },
+            severity: {
                 serializedName: "properties.severity",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Informational", "Warning", "Critical"]
                 }
-            }, status: {
+            },
+            status: {
                 serializedName: "properties.status",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Active", "Cleared"]
                 }
-            }, errorDetails: {
+            },
+            errorDetails: {
                 serializedName: "properties.errorDetails",
                 type: {
                     name: "Composite",
                     className: "AlertErrorDetails"
                 }
-            }, detailedInformation: {
+            },
+            detailedInformation: {
                 serializedName: "properties.detailedInformation",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "String" } }
                 }
-            } })
+            }
+        }
     }
 };
 export const BandwidthSetting = {
     type: {
         name: "Composite",
         className: "BandwidthSetting",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { schedules: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            schedules: {
                 serializedName: "properties.schedules",
                 required: true,
                 type: {
@@ -2878,38 +2906,45 @@ export const BandwidthSetting = {
                         }
                     }
                 }
-            }, volumeCount: {
+            },
+            volumeCount: {
                 serializedName: "properties.volumeCount",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 export const CloudApplianceConfiguration = {
     type: {
         name: "Composite",
         className: "CloudApplianceConfiguration",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { modelNumber: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            modelNumber: {
                 serializedName: "properties.modelNumber",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, cloudPlatform: {
+            },
+            cloudPlatform: {
                 serializedName: "properties.cloudPlatform",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, acsConfiguration: {
+            },
+            acsConfiguration: {
                 serializedName: "properties.acsConfiguration",
                 type: {
                     name: "Composite",
                     className: "AcsConfiguration"
                 }
-            }, supportedStorageAccountTypes: {
+            },
+            supportedStorageAccountTypes: {
                 serializedName: "properties.supportedStorageAccountTypes",
                 required: true,
                 type: {
@@ -2920,7 +2955,8 @@ export const CloudApplianceConfiguration = {
                         }
                     }
                 }
-            }, supportedRegions: {
+            },
+            supportedRegions: {
                 serializedName: "properties.supportedRegions",
                 required: true,
                 type: {
@@ -2931,7 +2967,8 @@ export const CloudApplianceConfiguration = {
                         }
                     }
                 }
-            }, supportedVmTypes: {
+            },
+            supportedVmTypes: {
                 serializedName: "properties.supportedVmTypes",
                 required: true,
                 type: {
@@ -2942,7 +2979,8 @@ export const CloudApplianceConfiguration = {
                         }
                     }
                 }
-            }, supportedVmImages: {
+            },
+            supportedVmImages: {
                 serializedName: "properties.supportedVmImages",
                 required: true,
                 type: {
@@ -2954,105 +2992,124 @@ export const CloudApplianceConfiguration = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const ConfigureDeviceRequest = {
     type: {
         name: "Composite",
         className: "ConfigureDeviceRequest",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { friendlyName: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            friendlyName: {
                 serializedName: "properties.friendlyName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, currentDeviceName: {
+            },
+            currentDeviceName: {
                 serializedName: "properties.currentDeviceName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, timeZone: {
+            },
+            timeZone: {
                 serializedName: "properties.timeZone",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, dnsSettings: {
+            },
+            dnsSettings: {
                 serializedName: "properties.dnsSettings",
                 type: {
                     name: "Composite",
                     className: "SecondaryDNSSettings"
                 }
-            }, networkInterfaceData0Settings: {
+            },
+            networkInterfaceData0Settings: {
                 serializedName: "properties.networkInterfaceData0Settings",
                 type: {
                     name: "Composite",
                     className: "NetworkInterfaceData0Settings"
                 }
-            } })
+            }
+        }
     }
 };
 export const Device = {
     type: {
         name: "Composite",
         className: "Device",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { friendlyName: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            friendlyName: {
                 serializedName: "properties.friendlyName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, activationTime: {
+            },
+            activationTime: {
                 serializedName: "properties.activationTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, culture: {
+            },
+            culture: {
                 serializedName: "properties.culture",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, deviceDescription: {
+            },
+            deviceDescription: {
                 serializedName: "properties.deviceDescription",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, deviceSoftwareVersion: {
+            },
+            deviceSoftwareVersion: {
                 serializedName: "properties.deviceSoftwareVersion",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, friendlySoftwareName: {
+            },
+            friendlySoftwareName: {
                 serializedName: "properties.friendlySoftwareName",
                 type: {
                     name: "String"
                 }
-            }, deviceConfigurationStatus: {
+            },
+            deviceConfigurationStatus: {
                 serializedName: "properties.deviceConfigurationStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Complete", "Pending"]
                 }
-            }, targetIqn: {
+            },
+            targetIqn: {
                 serializedName: "properties.targetIqn",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, modelDescription: {
+            },
+            modelDescription: {
                 serializedName: "properties.modelDescription",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, status: {
+            },
+            status: {
                 serializedName: "properties.status",
                 required: true,
                 type: {
@@ -3071,13 +3128,15 @@ export const Device = {
                         "ReadyToSetup"
                     ]
                 }
-            }, serialNumber: {
+            },
+            serialNumber: {
                 serializedName: "properties.serialNumber",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, deviceType: {
+            },
+            deviceType: {
                 serializedName: "properties.deviceType",
                 required: true,
                 type: {
@@ -3088,114 +3147,135 @@ export const Device = {
                         "Series8000PhysicalAppliance"
                     ]
                 }
-            }, activeController: {
+            },
+            activeController: {
                 serializedName: "properties.activeController",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Unknown", "None", "Controller0", "Controller1"]
                 }
-            }, friendlySoftwareVersion: {
+            },
+            friendlySoftwareVersion: {
                 serializedName: "properties.friendlySoftwareVersion",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, availableLocalStorageInBytes: {
+            },
+            availableLocalStorageInBytes: {
                 serializedName: "properties.availableLocalStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, availableTieredStorageInBytes: {
+            },
+            availableTieredStorageInBytes: {
                 serializedName: "properties.availableTieredStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, provisionedTieredStorageInBytes: {
+            },
+            provisionedTieredStorageInBytes: {
                 serializedName: "properties.provisionedTieredStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, provisionedLocalStorageInBytes: {
+            },
+            provisionedLocalStorageInBytes: {
                 serializedName: "properties.provisionedLocalStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, provisionedVolumeSizeInBytes: {
+            },
+            provisionedVolumeSizeInBytes: {
                 serializedName: "properties.provisionedVolumeSizeInBytes",
                 type: {
                     name: "Number"
                 }
-            }, usingStorageInBytes: {
+            },
+            usingStorageInBytes: {
                 serializedName: "properties.usingStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, totalTieredStorageInBytes: {
+            },
+            totalTieredStorageInBytes: {
                 serializedName: "properties.totalTieredStorageInBytes",
                 type: {
                     name: "Number"
                 }
-            }, agentGroupVersion: {
+            },
+            agentGroupVersion: {
                 serializedName: "properties.agentGroupVersion",
                 type: {
                     name: "Number"
                 }
-            }, networkInterfaceCardCount: {
+            },
+            networkInterfaceCardCount: {
                 serializedName: "properties.networkInterfaceCardCount",
                 type: {
                     name: "Number"
                 }
-            }, deviceLocation: {
+            },
+            deviceLocation: {
                 serializedName: "properties.deviceLocation",
                 type: {
                     name: "String"
                 }
-            }, virtualMachineApiType: {
+            },
+            virtualMachineApiType: {
                 serializedName: "properties.virtualMachineApiType",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Classic", "Arm"]
                 }
-            }, details: {
+            },
+            details: {
                 serializedName: "properties.details",
                 type: {
                     name: "Composite",
                     className: "DeviceDetails"
                 }
-            }, rolloverDetails: {
+            },
+            rolloverDetails: {
                 serializedName: "properties.rolloverDetails",
                 type: {
                     name: "Composite",
                     className: "DeviceRolloverDetails"
                 }
-            } })
+            }
+        }
     }
 };
 export const AlertSettings = {
     type: {
         name: "Composite",
         className: "AlertSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { emailNotification: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            emailNotification: {
                 serializedName: "properties.emailNotification",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, alertNotificationCulture: {
+            },
+            alertNotificationCulture: {
                 serializedName: "properties.alertNotificationCulture",
                 type: {
                     name: "String"
                 }
-            }, notificationToServiceOwners: {
+            },
+            notificationToServiceOwners: {
                 serializedName: "properties.notificationToServiceOwners",
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, additionalRecipientEmailList: {
+            },
+            additionalRecipientEmailList: {
                 serializedName: "properties.additionalRecipientEmailList",
                 type: {
                     name: "Sequence",
@@ -3205,14 +3285,17 @@ export const AlertSettings = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const BackupPolicy = {
     type: {
         name: "Composite",
         className: "BackupPolicy",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { volumeIds: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            volumeIds: {
                 serializedName: "properties.volumeIds",
                 required: true,
                 type: {
@@ -3223,131 +3306,154 @@ export const BackupPolicy = {
                         }
                     }
                 }
-            }, nextBackupTime: {
+            },
+            nextBackupTime: {
                 serializedName: "properties.nextBackupTime",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            }, lastBackupTime: {
+            },
+            lastBackupTime: {
                 serializedName: "properties.lastBackupTime",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            }, schedulesCount: {
+            },
+            schedulesCount: {
                 serializedName: "properties.schedulesCount",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, scheduledBackupStatus: {
+            },
+            scheduledBackupStatus: {
                 serializedName: "properties.scheduledBackupStatus",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Disabled", "Enabled"]
                 }
-            }, backupPolicyCreationType: {
+            },
+            backupPolicyCreationType: {
                 serializedName: "properties.backupPolicyCreationType",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["BySaaS", "BySSM"]
                 }
-            }, ssmHostName: {
+            },
+            ssmHostName: {
                 serializedName: "properties.ssmHostName",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const BackupSchedule = {
     type: {
         name: "Composite",
         className: "BackupSchedule",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { scheduleRecurrence: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            scheduleRecurrence: {
                 serializedName: "properties.scheduleRecurrence",
                 type: {
                     name: "Composite",
                     className: "ScheduleRecurrence"
                 }
-            }, backupType: {
+            },
+            backupType: {
                 serializedName: "properties.backupType",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["LocalSnapshot", "CloudSnapshot"]
                 }
-            }, retentionCount: {
+            },
+            retentionCount: {
                 serializedName: "properties.retentionCount",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, startTime: {
+            },
+            startTime: {
                 serializedName: "properties.startTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, scheduleStatus: {
+            },
+            scheduleStatus: {
                 serializedName: "properties.scheduleStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, lastSuccessfulRun: {
+            },
+            lastSuccessfulRun: {
                 serializedName: "properties.lastSuccessfulRun",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 export const Backup = {
     type: {
         name: "Composite",
         className: "Backup",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { createdOn: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            createdOn: {
                 serializedName: "properties.createdOn",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, sizeInBytes: {
+            },
+            sizeInBytes: {
                 serializedName: "properties.sizeInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, backupType: {
+            },
+            backupType: {
                 serializedName: "properties.backupType",
                 type: {
                     name: "Enum",
                     allowedValues: ["LocalSnapshot", "CloudSnapshot"]
                 }
-            }, backupJobCreationType: {
+            },
+            backupJobCreationType: {
                 serializedName: "properties.backupJobCreationType",
                 type: {
                     name: "Enum",
                     allowedValues: ["Adhoc", "BySchedule", "BySSM"]
                 }
-            }, backupPolicyId: {
+            },
+            backupPolicyId: {
                 serializedName: "properties.backupPolicyId",
                 type: {
                     name: "String"
                 }
-            }, ssmHostName: {
+            },
+            ssmHostName: {
                 serializedName: "properties.ssmHostName",
                 type: {
                     name: "String"
                 }
-            }, elements: {
+            },
+            elements: {
                 serializedName: "properties.elements",
                 required: true,
                 type: {
@@ -3359,26 +3465,31 @@ export const Backup = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const HardwareComponentGroup = {
     type: {
         name: "Composite",
         className: "HardwareComponentGroup",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { displayName: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            displayName: {
                 serializedName: "properties.displayName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, lastUpdatedTime: {
+            },
+            lastUpdatedTime: {
                 serializedName: "properties.lastUpdatedTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, components: {
+            },
+            components: {
                 serializedName: "properties.components",
                 required: true,
                 type: {
@@ -3390,28 +3501,33 @@ export const HardwareComponentGroup = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const ControllerPowerStateChangeRequest = {
     type: {
         name: "Composite",
         className: "ControllerPowerStateChangeRequest",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { action: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            action: {
                 serializedName: "properties.action",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Start", "Restart", "Shutdown"]
                 }
-            }, activeController: {
+            },
+            activeController: {
                 serializedName: "properties.activeController",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Unknown", "None", "Controller0", "Controller1"]
                 }
-            }, controller0State: {
+            },
+            controller0State: {
                 serializedName: "properties.controller0State",
                 required: true,
                 type: {
@@ -3425,7 +3541,8 @@ export const ControllerPowerStateChangeRequest = {
                         "Failure"
                     ]
                 }
-            }, controller1State: {
+            },
+            controller1State: {
                 serializedName: "properties.controller1State",
                 required: true,
                 type: {
@@ -3439,43 +3556,51 @@ export const ControllerPowerStateChangeRequest = {
                         "Failure"
                     ]
                 }
-            } })
+            }
+        }
     }
 };
 export const Job = {
     type: {
         name: "Composite",
         className: "Job",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { status: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            status: {
                 serializedName: "status",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Running", "Succeeded", "Failed", "Canceled"]
                 }
-            }, startTime: {
+            },
+            startTime: {
                 serializedName: "startTime",
                 type: {
                     name: "DateTime"
                 }
-            }, endTime: {
+            },
+            endTime: {
                 serializedName: "endTime",
                 type: {
                     name: "DateTime"
                 }
-            }, percentComplete: {
+            },
+            percentComplete: {
                 serializedName: "percentComplete",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, error: {
+            },
+            error: {
                 serializedName: "error",
                 type: {
                     name: "Composite",
                     className: "JobErrorDetails"
                 }
-            }, jobType: {
+            },
+            jobType: {
                 serializedName: "properties.jobType",
                 type: {
                     name: "Enum",
@@ -3492,23 +3617,27 @@ export const Job = {
                         "CreateCloudAppliance"
                     ]
                 }
-            }, dataStats: {
+            },
+            dataStats: {
                 serializedName: "properties.dataStats",
                 type: {
                     name: "Composite",
                     className: "DataStatistics"
                 }
-            }, entityLabel: {
+            },
+            entityLabel: {
                 serializedName: "properties.entityLabel",
                 type: {
                     name: "String"
                 }
-            }, entityType: {
+            },
+            entityType: {
                 serializedName: "properties.entityType",
                 type: {
                     name: "String"
                 }
-            }, jobStages: {
+            },
+            jobStages: {
                 serializedName: "properties.jobStages",
                 type: {
                     name: "Sequence",
@@ -3519,95 +3648,114 @@ export const Job = {
                         }
                     }
                 }
-            }, deviceId: {
+            },
+            deviceId: {
                 serializedName: "properties.deviceId",
                 type: {
                     name: "String"
                 }
-            }, isCancellable: {
+            },
+            isCancellable: {
                 serializedName: "properties.isCancellable",
                 type: {
                     name: "Boolean"
                 }
-            }, backupType: {
+            },
+            backupType: {
                 serializedName: "properties.backupType",
                 type: {
                     name: "Enum",
                     allowedValues: ["LocalSnapshot", "CloudSnapshot"]
                 }
-            }, sourceDeviceId: {
+            },
+            sourceDeviceId: {
                 serializedName: "properties.sourceDeviceId",
                 type: {
                     name: "String"
                 }
-            }, backupPointInTime: {
+            },
+            backupPointInTime: {
                 serializedName: "properties.backupPointInTime",
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 export const NetworkSettings = {
     type: {
         name: "Composite",
         className: "NetworkSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { dnsSettings: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            dnsSettings: {
                 serializedName: "properties.dnsSettings",
                 type: {
                     name: "Composite",
                     className: "DNSSettings"
                 }
-            }, networkAdapters: {
+            },
+            networkAdapters: {
                 serializedName: "properties.networkAdapters",
                 type: {
                     name: "Composite",
                     className: "NetworkAdapterList"
                 }
-            }, webproxySettings: {
+            },
+            webproxySettings: {
                 serializedName: "properties.webproxySettings",
                 type: {
                     name: "Composite",
                     className: "WebproxySettings"
                 }
-            } })
+            }
+        }
     }
 };
 export const SecuritySettings = {
     type: {
         name: "Composite",
         className: "SecuritySettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { remoteManagementSettings: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            remoteManagementSettings: {
                 serializedName: "properties.remoteManagementSettings",
                 type: {
                     name: "Composite",
                     className: "RemoteManagementSettings"
                 }
-            }, chapSettings: {
+            },
+            chapSettings: {
                 serializedName: "properties.chapSettings",
                 type: {
                     name: "Composite",
                     className: "ChapSettings"
                 }
-            } })
+            }
+        }
     }
 };
 export const TimeSettings = {
     type: {
         name: "Composite",
         className: "TimeSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { timeZone: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            timeZone: {
                 serializedName: "properties.timeZone",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, primaryTimeServer: {
+            },
+            primaryTimeServer: {
                 serializedName: "properties.primaryTimeServer",
                 type: {
                     name: "String"
                 }
-            }, secondaryTimeServer: {
+            },
+            secondaryTimeServer: {
                 serializedName: "properties.secondaryTimeServer",
                 type: {
                     name: "Sequence",
@@ -3617,115 +3765,137 @@ export const TimeSettings = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const Updates = {
     type: {
         name: "Composite",
         className: "Updates",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { regularUpdatesAvailable: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            regularUpdatesAvailable: {
                 serializedName: "properties.regularUpdatesAvailable",
                 type: {
                     name: "Boolean"
                 }
-            }, maintenanceModeUpdatesAvailable: {
+            },
+            maintenanceModeUpdatesAvailable: {
                 serializedName: "properties.maintenanceModeUpdatesAvailable",
                 type: {
                     name: "Boolean"
                 }
-            }, isUpdateInProgress: {
+            },
+            isUpdateInProgress: {
                 serializedName: "properties.isUpdateInProgress",
                 type: {
                     name: "Boolean"
                 }
-            }, lastUpdatedTime: {
+            },
+            lastUpdatedTime: {
                 serializedName: "properties.lastUpdatedTime",
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 export const VolumeContainer = {
     type: {
         name: "Composite",
         className: "VolumeContainer",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { encryptionKey: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            encryptionKey: {
                 serializedName: "properties.encryptionKey",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            }, encryptionStatus: {
+            },
+            encryptionStatus: {
                 serializedName: "properties.encryptionStatus",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, volumeCount: {
+            },
+            volumeCount: {
                 serializedName: "properties.volumeCount",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, storageAccountCredentialId: {
+            },
+            storageAccountCredentialId: {
                 serializedName: "properties.storageAccountCredentialId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, ownerShipStatus: {
+            },
+            ownerShipStatus: {
                 serializedName: "properties.ownerShipStatus",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Owned", "NotOwned"]
                 }
-            }, bandWidthRateInMbps: {
+            },
+            bandWidthRateInMbps: {
                 serializedName: "properties.bandWidthRateInMbps",
                 type: {
                     name: "Number"
                 }
-            }, bandwidthSettingId: {
+            },
+            bandwidthSettingId: {
                 serializedName: "properties.bandwidthSettingId",
                 type: {
                     name: "String"
                 }
-            }, totalCloudStorageUsageInBytes: {
+            },
+            totalCloudStorageUsageInBytes: {
                 serializedName: "properties.totalCloudStorageUsageInBytes",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 export const Volume = {
     type: {
         name: "Composite",
         className: "Volume",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { sizeInBytes: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            sizeInBytes: {
                 serializedName: "properties.sizeInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, volumeType: {
+            },
+            volumeType: {
                 serializedName: "properties.volumeType",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Tiered", "Archival", "LocallyPinned"]
                 }
-            }, volumeContainerId: {
+            },
+            volumeContainerId: {
                 serializedName: "properties.volumeContainerId",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, accessControlRecordIds: {
+            },
+            accessControlRecordIds: {
                 serializedName: "properties.accessControlRecordIds",
                 required: true,
                 type: {
@@ -3736,35 +3906,40 @@ export const Volume = {
                         }
                     }
                 }
-            }, volumeStatus: {
+            },
+            volumeStatus: {
                 serializedName: "properties.volumeStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Online", "Offline"]
                 }
-            }, operationStatus: {
+            },
+            operationStatus: {
                 serializedName: "properties.operationStatus",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["None", "Updating", "Deleting", "Restoring"]
                 }
-            }, backupStatus: {
+            },
+            backupStatus: {
                 serializedName: "properties.backupStatus",
                 readOnly: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, monitoringStatus: {
+            },
+            monitoringStatus: {
                 serializedName: "properties.monitoringStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, backupPolicyIds: {
+            },
+            backupPolicyIds: {
                 serializedName: "properties.backupPolicyIds",
                 readOnly: true,
                 type: {
@@ -3775,102 +3950,122 @@ export const Volume = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const EncryptionSettings = {
     type: {
         name: "Composite",
         className: "EncryptionSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { encryptionStatus: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            encryptionStatus: {
                 serializedName: "properties.encryptionStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, keyRolloverStatus: {
+            },
+            keyRolloverStatus: {
                 serializedName: "properties.keyRolloverStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Required", "NotRequired"]
                 }
-            } })
+            }
+        }
     }
 };
 export const ManagerExtendedInfo = {
     type: {
         name: "Composite",
         className: "ManagerExtendedInfo",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { etag: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            etag: {
                 serializedName: "etag",
                 type: {
                     name: "String"
                 }
-            }, version: {
+            },
+            version: {
                 serializedName: "properties.version",
                 type: {
                     name: "String"
                 }
-            }, integrityKey: {
+            },
+            integrityKey: {
                 serializedName: "properties.integrityKey",
                 type: {
                     name: "String"
                 }
-            }, encryptionKey: {
+            },
+            encryptionKey: {
                 serializedName: "properties.encryptionKey",
                 type: {
                     name: "String"
                 }
-            }, encryptionKeyThumbprint: {
+            },
+            encryptionKeyThumbprint: {
                 serializedName: "properties.encryptionKeyThumbprint",
                 type: {
                     name: "String"
                 }
-            }, portalCertificateThumbprint: {
+            },
+            portalCertificateThumbprint: {
                 serializedName: "properties.portalCertificateThumbprint",
                 type: {
                     name: "String"
                 }
-            }, algorithm: {
+            },
+            algorithm: {
                 serializedName: "properties.algorithm",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const StorageAccountCredential = {
     type: {
         name: "Composite",
         className: "StorageAccountCredential",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { endPoint: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            endPoint: {
                 serializedName: "properties.endPoint",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, sslStatus: {
+            },
+            sslStatus: {
                 serializedName: "properties.sslStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, accessKey: {
+            },
+            accessKey: {
                 serializedName: "properties.accessKey",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            }, volumesCount: {
+            },
+            volumesCount: {
                 serializedName: "properties.volumesCount",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 //# sourceMappingURL=mappers.js.map