@azure/arm-storsimple1200series 2.1.1-alpha.20250718.1 → 2.1.1-alpha.20250730.1

package/dist/browser/models/mappers.js

@@ -1822,205 +1822,244 @@ 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",
                 readOnly: true,
                 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"
                 }
-            } })
+            }
+        }
     }
 };
 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 BackupElement = {
     type: {
         name: "Composite",
         className: "BackupElement",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { sizeInBytes: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            sizeInBytes: {
                 serializedName: "properties.sizeInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, endpointName: {
+            },
+            endpointName: {
                 serializedName: "properties.endpointName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, dataPolicy: {
+            },
+            dataPolicy: {
                 serializedName: "properties.dataPolicy",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Invalid", "Local", "Tiered", "Cloud"]
                 }
-            } })
+            }
+        }
     }
 };
 export const Backup = {
     type: {
         name: "Composite",
         className: "Backup",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { targetId: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            targetId: {
                 serializedName: "properties.targetId",
                 type: {
                     name: "String"
                 }
-            }, targetType: {
+            },
+            targetType: {
                 serializedName: "properties.targetType",
                 type: {
                     name: "String"
                 }
-            }, sizeInBytes: {
+            },
+            sizeInBytes: {
                 serializedName: "properties.sizeInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, createdTime: {
+            },
+            createdTime: {
                 serializedName: "properties.createdTime",
                 type: {
                     name: "DateTime"
                 }
-            }, expirationTime: {
+            },
+            expirationTime: {
                 serializedName: "properties.expirationTime",
                 type: {
                     name: "DateTime"
                 }
-            }, initiatedBy: {
+            },
+            initiatedBy: {
                 serializedName: "properties.initiatedBy",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Manual", "Scheduled"]
                 }
-            }, deviceId: {
+            },
+            deviceId: {
                 serializedName: "properties.deviceId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, elements: {
+            },
+            elements: {
                 serializedName: "properties.elements",
                 required: true,
                 type: {
@@ -2032,14 +2071,17 @@ export const Backup = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const UploadCertificateResponse = {
     type: {
         name: "Composite",
         className: "UploadCertificateResponse",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { authType: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            authType: {
                 serializedName: "properties.authType",
                 type: {
                     name: "Enum",
@@ -2049,97 +2091,114 @@ export const UploadCertificateResponse = {
                         "AzureActiveDirectory"
                     ]
                 }
-            }, certificate: {
+            },
+            certificate: {
                 serializedName: "properties.certificate",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, resourceId: {
+            },
+            resourceId: {
                 serializedName: "properties.resourceId",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, aadAuthority: {
+            },
+            aadAuthority: {
                 serializedName: "properties.aadAuthority",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, aadTenantId: {
+            },
+            aadTenantId: {
                 serializedName: "properties.aadTenantId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, servicePrincipalClientId: {
+            },
+            servicePrincipalClientId: {
                 serializedName: "properties.servicePrincipalClientId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, servicePrincipalObjectId: {
+            },
+            servicePrincipalObjectId: {
                 serializedName: "properties.servicePrincipalObjectId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, azureManagementEndpointAudience: {
+            },
+            azureManagementEndpointAudience: {
                 serializedName: "properties.azureManagementEndpointAudience",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, subject: {
+            },
+            subject: {
                 serializedName: "properties.subject",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, validFrom: {
+            },
+            validFrom: {
                 serializedName: "properties.validFrom",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, validTo: {
+            },
+            validTo: {
                 serializedName: "properties.validTo",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            }, thumbprint: {
+            },
+            thumbprint: {
                 serializedName: "properties.thumbprint",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, friendlyName: {
+            },
+            friendlyName: {
                 serializedName: "properties.friendlyName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, issuer: {
+            },
+            issuer: {
                 serializedName: "properties.issuer",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const Device = {
     type: {
         name: "Composite",
         className: "Device",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { activationTime: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            activationTime: {
                 serializedName: "properties.activationTime",
                 type: {
                     name: "DateTime"
                 }
-            }, allowedDeviceOperations: {
+            },
+            allowedDeviceOperations: {
                 serializedName: "properties.allowedDeviceOperations",
                 type: {
                     name: "Sequence",
@@ -2159,12 +2218,14 @@ export const Device = {
                         }
                     }
                 }
-            }, culture: {
+            },
+            culture: {
                 serializedName: "properties.culture",
                 type: {
                     name: "String"
                 }
-            }, deviceCapabilities: {
+            },
+            deviceCapabilities: {
                 serializedName: "properties.deviceCapabilities",
                 type: {
                     name: "Sequence",
@@ -2175,38 +2236,45 @@ export const Device = {
                         }
                     }
                 }
-            }, deviceDescription: {
+            },
+            deviceDescription: {
                 serializedName: "properties.deviceDescription",
                 type: {
                     name: "String"
                 }
-            }, domainName: {
+            },
+            domainName: {
                 serializedName: "properties.domainName",
                 type: {
                     name: "String"
                 }
-            }, deviceSoftwareVersion: {
+            },
+            deviceSoftwareVersion: {
                 serializedName: "properties.deviceSoftwareVersion",
                 type: {
                     name: "String"
                 }
-            }, friendlySoftwareName: {
+            },
+            friendlySoftwareName: {
                 serializedName: "properties.friendlySoftwareName",
                 type: {
                     name: "String"
                 }
-            }, deviceConfigurationStatus: {
+            },
+            deviceConfigurationStatus: {
                 serializedName: "properties.deviceConfigurationStatus",
                 type: {
                     name: "Enum",
                     allowedValues: ["Complete", "Pending"]
                 }
-            }, modelDescription: {
+            },
+            modelDescription: {
                 serializedName: "properties.modelDescription",
                 type: {
                     name: "String"
                 }
-            }, status: {
+            },
+            status: {
                 serializedName: "properties.status",
                 type: {
                     name: "Enum",
@@ -2224,7 +2292,8 @@ export const Device = {
                         "Deactivating"
                     ]
                 }
-            }, typePropertiesType: {
+            },
+            typePropertiesType: {
                 serializedName: "properties.type",
                 type: {
                     name: "Enum",
@@ -2237,40 +2306,47 @@ export const Device = {
                         "Series9000PhysicalAppliance"
                     ]
                 }
-            }, details: {
+            },
+            details: {
                 serializedName: "properties.details",
                 type: {
                     name: "Composite",
                     className: "DeviceDetails"
                 }
-            } })
+            }
+        }
     }
 };
 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"]
                 }
-            }, notificationToServiceOwners: {
+            },
+            notificationToServiceOwners: {
                 serializedName: "properties.notificationToServiceOwners",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, alertNotificationCulture: {
+            },
+            alertNotificationCulture: {
                 serializedName: "properties.alertNotificationCulture",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, additionalRecipientEmailList: {
+            },
+            additionalRecipientEmailList: {
                 serializedName: "properties.additionalRecipientEmailList",
                 type: {
                     name: "Sequence",
@@ -2280,83 +2356,98 @@ export const AlertSettings = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const FileShare = {
     type: {
         name: "Composite",
         className: "FileShare",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { description: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            description: {
                 serializedName: "properties.description",
                 type: {
                     name: "String"
                 }
-            }, shareStatus: {
+            },
+            shareStatus: {
                 serializedName: "properties.shareStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Online", "Offline"]
                 }
-            }, dataPolicy: {
+            },
+            dataPolicy: {
                 serializedName: "properties.dataPolicy",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Invalid", "Local", "Tiered", "Cloud"]
                 }
-            }, adminUser: {
+            },
+            adminUser: {
                 serializedName: "properties.adminUser",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, provisionedCapacityInBytes: {
+            },
+            provisionedCapacityInBytes: {
                 serializedName: "properties.provisionedCapacityInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, usedCapacityInBytes: {
+            },
+            usedCapacityInBytes: {
                 serializedName: "properties.usedCapacityInBytes",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, localUsedCapacityInBytes: {
+            },
+            localUsedCapacityInBytes: {
                 serializedName: "properties.localUsedCapacityInBytes",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, monitoringStatus: {
+            },
+            monitoringStatus: {
                 serializedName: "properties.monitoringStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            } })
+            }
+        }
     }
 };
 export const IscsiDisk = {
     type: {
         name: "Composite",
         className: "IscsiDisk",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { description: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            description: {
                 serializedName: "properties.description",
                 type: {
                     name: "String"
                 }
-            }, diskStatus: {
+            },
+            diskStatus: {
                 serializedName: "properties.diskStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Online", "Offline"]
                 }
-            }, accessControlRecords: {
+            },
+            accessControlRecords: {
                 serializedName: "properties.accessControlRecords",
                 required: true,
                 type: {
@@ -2367,136 +2458,163 @@ export const IscsiDisk = {
                         }
                     }
                 }
-            }, dataPolicy: {
+            },
+            dataPolicy: {
                 serializedName: "properties.dataPolicy",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Invalid", "Local", "Tiered", "Cloud"]
                 }
-            }, provisionedCapacityInBytes: {
+            },
+            provisionedCapacityInBytes: {
                 serializedName: "properties.provisionedCapacityInBytes",
                 required: true,
                 type: {
                     name: "Number"
                 }
-            }, usedCapacityInBytes: {
+            },
+            usedCapacityInBytes: {
                 serializedName: "properties.usedCapacityInBytes",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, localUsedCapacityInBytes: {
+            },
+            localUsedCapacityInBytes: {
                 serializedName: "properties.localUsedCapacityInBytes",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, monitoringStatus: {
+            },
+            monitoringStatus: {
                 serializedName: "properties.monitoringStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            } })
+            }
+        }
     }
 };
 export const BackupScheduleGroup = {
     type: {
         name: "Composite",
         className: "BackupScheduleGroup",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { startTime: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            startTime: {
                 serializedName: "properties.startTime",
                 type: {
                     name: "Composite",
                     className: "Time"
                 }
-            } })
+            }
+        }
     }
 };
 export const ChapSettings = {
     type: {
         name: "Composite",
         className: "ChapSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { password: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            password: {
                 serializedName: "properties.password",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            } })
+            }
+        }
     }
 };
 export const FileServer = {
     type: {
         name: "Composite",
         className: "FileServer",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { domainName: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            domainName: {
                 serializedName: "properties.domainName",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, storageDomainId: {
+            },
+            storageDomainId: {
                 serializedName: "properties.storageDomainId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, backupScheduleGroupId: {
+            },
+            backupScheduleGroupId: {
                 serializedName: "properties.backupScheduleGroupId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, description: {
+            },
+            description: {
                 serializedName: "properties.description",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const IscsiServer = {
     type: {
         name: "Composite",
         className: "IscsiServer",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { storageDomainId: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            storageDomainId: {
                 serializedName: "properties.storageDomainId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, backupScheduleGroupId: {
+            },
+            backupScheduleGroupId: {
                 serializedName: "properties.backupScheduleGroupId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, description: {
+            },
+            description: {
                 serializedName: "properties.description",
                 type: {
                     name: "String"
                 }
-            }, chapId: {
+            },
+            chapId: {
                 serializedName: "properties.chapId",
                 type: {
                     name: "String"
                 }
-            }, reverseChapId: {
+            },
+            reverseChapId: {
                 serializedName: "properties.reverseChapId",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 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: {
@@ -2511,29 +2629,34 @@ export const Job = {
                         "Scheduled"
                     ]
                 }
-            }, 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",
@@ -2545,22 +2668,26 @@ export const Job = {
                         "InstallUpdates"
                     ]
                 }
-            }, targetId: {
+            },
+            targetId: {
                 serializedName: "properties.targetId",
                 type: {
                     name: "String"
                 }
-            }, entityId: {
+            },
+            entityId: {
                 serializedName: "properties.entityId",
                 type: {
                     name: "String"
                 }
-            }, entityType: {
+            },
+            entityType: {
                 serializedName: "properties.entityType",
                 type: {
                     name: "String"
                 }
-            }, jobStages: {
+            },
+            jobStages: {
                 serializedName: "properties.jobStages",
                 type: {
                     name: "Sequence",
@@ -2571,69 +2698,82 @@ export const Job = {
                         }
                     }
                 }
-            }, deviceId: {
+            },
+            deviceId: {
                 serializedName: "properties.deviceId",
                 type: {
                     name: "String"
                 }
-            }, isCancellable: {
+            },
+            isCancellable: {
                 serializedName: "properties.isCancellable",
                 type: {
                     name: "Boolean"
                 }
-            }, stats: {
+            },
+            stats: {
                 serializedName: "properties.stats",
                 type: {
                     name: "Composite",
                     className: "JobStats"
                 }
-            }, targetType: {
+            },
+            targetType: {
                 serializedName: "properties.targetType",
                 type: {
                     name: "Enum",
                     allowedValues: ["FileServer", "DiskServer"]
                 }
-            }, sourceDeviceId: {
+            },
+            sourceDeviceId: {
                 serializedName: "properties.sourceDeviceId",
                 type: {
                     name: "String"
                 }
-            }, backupPointInTime: {
+            },
+            backupPointInTime: {
                 serializedName: "properties.backupPointInTime",
                 type: {
                     name: "DateTime"
                 }
-            }, downloadProgress: {
+            },
+            downloadProgress: {
                 serializedName: "properties.downloadProgress",
                 type: {
                     name: "Composite",
                     className: "UpdateDownloadProgress"
                 }
-            }, installProgress: {
+            },
+            installProgress: {
                 serializedName: "properties.installProgress",
                 type: {
                     name: "Composite",
                     className: "UpdateInstallProgress"
                 }
-            } })
+            }
+        }
     }
 };
 export const NetworkSettings = {
     type: {
         name: "Composite",
         className: "NetworkSettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { primaryDnsServer: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            primaryDnsServer: {
                 serializedName: "properties.primaryDnsServer",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, secondaryDnsServer: {
+            },
+            secondaryDnsServer: {
                 serializedName: "properties.secondaryDnsServer",
                 type: {
                     name: "String"
                 }
-            }, nodeNetworks: {
+            },
+            nodeNetworks: {
                 serializedName: "properties.nodeNetworks",
                 required: true,
                 type: {
@@ -2645,243 +2785,292 @@ export const NetworkSettings = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const SecuritySettings = {
     type: {
         name: "Composite",
         className: "SecuritySettings",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { deviceAdminPassword: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            deviceAdminPassword: {
                 serializedName: "properties.deviceAdminPassword",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            } })
+            }
+        }
     }
 };
 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",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, secondaryTimeServer: {
+            },
+            secondaryTimeServer: {
                 serializedName: "properties.secondaryTimeServer",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const Updates = {
     type: {
         name: "Composite",
         className: "Updates",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { deviceVersion: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            deviceVersion: {
                 serializedName: "properties.deviceVersion",
                 type: {
                     name: "String"
                 }
-            }, deviceLastScannedTime: {
+            },
+            deviceLastScannedTime: {
                 serializedName: "properties.deviceLastScannedTime",
                 type: {
                     name: "DateTime"
                 }
-            }, regularUpdatesAvailable: {
+            },
+            regularUpdatesAvailable: {
                 serializedName: "properties.regularUpdatesAvailable",
                 type: {
                     name: "Boolean"
                 }
-            }, rebootRequiredForInstall: {
+            },
+            rebootRequiredForInstall: {
                 serializedName: "properties.rebootRequiredForInstall",
                 type: {
                     name: "Boolean"
                 }
-            }, totalItemsPendingForDownload: {
+            },
+            totalItemsPendingForDownload: {
                 serializedName: "properties.totalItemsPendingForDownload",
                 type: {
                     name: "Number"
                 }
-            }, totalItemsPendingForInstall: {
+            },
+            totalItemsPendingForInstall: {
                 serializedName: "properties.totalItemsPendingForInstall",
                 type: {
                     name: "Number"
                 }
-            }, status: {
+            },
+            status: {
                 serializedName: "properties.status",
                 type: {
                     name: "Enum",
                     allowedValues: ["Idle", "Scanning", "Downloading", "Installing"]
                 }
-            }, lastCompletedScanTime: {
+            },
+            lastCompletedScanTime: {
                 serializedName: "properties.lastCompletedScanTime",
                 type: {
                     name: "DateTime"
                 }
-            }, lastCompletedDownloadJobTime: {
+            },
+            lastCompletedDownloadJobTime: {
                 serializedName: "properties.lastCompletedDownloadJobTime",
                 type: {
                     name: "DateTime"
                 }
-            }, lastCompletedInstallJobTime: {
+            },
+            lastCompletedInstallJobTime: {
                 serializedName: "properties.lastCompletedInstallJobTime",
                 type: {
                     name: "DateTime"
                 }
-            }, inProgressDownloadJobId: {
+            },
+            inProgressDownloadJobId: {
                 serializedName: "properties.inProgressDownloadJobId",
                 type: {
                     name: "String"
                 }
-            }, inProgressInstallJobId: {
+            },
+            inProgressInstallJobId: {
                 serializedName: "properties.inProgressInstallJobId",
                 type: {
                     name: "String"
                 }
-            }, inProgressScanStartedTime: {
+            },
+            inProgressScanStartedTime: {
                 serializedName: "properties.inProgressScanStartedTime",
                 type: {
                     name: "DateTime"
                 }
-            }, inProgressDownloadJobStartedTime: {
+            },
+            inProgressDownloadJobStartedTime: {
                 serializedName: "properties.inProgressDownloadJobStartedTime",
                 type: {
                     name: "DateTime"
                 }
-            }, inProgressInstallJobStartedTime: {
+            },
+            inProgressInstallJobStartedTime: {
                 serializedName: "properties.inProgressInstallJobStartedTime",
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 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",
                 required: true,
                 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",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const StorageAccountCredential = {
     type: {
         name: "Composite",
         className: "StorageAccountCredential",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { cloudType: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            cloudType: {
                 serializedName: "properties.cloudType",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Azure", "S3", "S3_RRS", "OpenStack", "HP"]
                 }
-            }, endPoint: {
+            },
+            endPoint: {
                 serializedName: "properties.endPoint",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, login: {
+            },
+            login: {
                 serializedName: "properties.login",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, location: {
+            },
+            location: {
                 serializedName: "properties.location",
                 type: {
                     name: "String"
                 }
-            }, enableSSL: {
+            },
+            enableSSL: {
                 serializedName: "properties.enableSSL",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, accessKey: {
+            },
+            accessKey: {
                 serializedName: "properties.accessKey",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            } })
+            }
+        }
     }
 };
 export const StorageDomain = {
     type: {
         name: "Composite",
         className: "StorageDomain",
-        modelProperties: Object.assign(Object.assign({}, BaseModel.type.modelProperties), { storageAccountCredentialIds: {
+        modelProperties: {
+            ...BaseModel.type.modelProperties,
+            storageAccountCredentialIds: {
                 serializedName: "properties.storageAccountCredentialIds",
                 required: true,
                 type: {
@@ -2892,20 +3081,23 @@ export const StorageDomain = {
                         }
                     }
                 }
-            }, encryptionKey: {
+            },
+            encryptionKey: {
                 serializedName: "properties.encryptionKey",
                 type: {
                     name: "Composite",
                     className: "AsymmetricEncryptedSecret"
                 }
-            }, encryptionStatus: {
+            },
+            encryptionStatus: {
                 serializedName: "properties.encryptionStatus",
                 required: true,
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            } })
+            }
+        }
     }
 };
 //# sourceMappingURL=mappers.js.map