@azure/arm-mysql 5.1.1-alpha.20250618.1 → 5.1.1-alpha.20250718.2

package/dist/browser/models/mappers.js

@@ -1409,19 +1409,23 @@ export const ServerPropertiesForDefaultCreate = {
         className: "ServerPropertiesForDefaultCreate",
         uberParent: "ServerPropertiesForCreate",
         polymorphicDiscriminator: ServerPropertiesForCreate.type.polymorphicDiscriminator,
-        modelProperties: Object.assign(Object.assign({}, ServerPropertiesForCreate.type.modelProperties), { administratorLogin: {
+        modelProperties: {
+            ...ServerPropertiesForCreate.type.modelProperties,
+            administratorLogin: {
                 serializedName: "administratorLogin",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, administratorLoginPassword: {
+            },
+            administratorLoginPassword: {
                 serializedName: "administratorLoginPassword",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerPropertiesForRestore = {
@@ -1431,19 +1435,23 @@ export const ServerPropertiesForRestore = {
         className: "ServerPropertiesForRestore",
         uberParent: "ServerPropertiesForCreate",
         polymorphicDiscriminator: ServerPropertiesForCreate.type.polymorphicDiscriminator,
-        modelProperties: Object.assign(Object.assign({}, ServerPropertiesForCreate.type.modelProperties), { sourceServerId: {
+        modelProperties: {
+            ...ServerPropertiesForCreate.type.modelProperties,
+            sourceServerId: {
                 serializedName: "sourceServerId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            }, restorePointInTime: {
+            },
+            restorePointInTime: {
                 serializedName: "restorePointInTime",
                 required: true,
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerPropertiesForGeoRestore = {
@@ -1453,13 +1461,16 @@ export const ServerPropertiesForGeoRestore = {
         className: "ServerPropertiesForGeoRestore",
         uberParent: "ServerPropertiesForCreate",
         polymorphicDiscriminator: ServerPropertiesForCreate.type.polymorphicDiscriminator,
-        modelProperties: Object.assign(Object.assign({}, ServerPropertiesForCreate.type.modelProperties), { sourceServerId: {
+        modelProperties: {
+            ...ServerPropertiesForCreate.type.modelProperties,
+            sourceServerId: {
                 serializedName: "sourceServerId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerPropertiesForReplica = {
@@ -1469,121 +1480,146 @@ export const ServerPropertiesForReplica = {
         className: "ServerPropertiesForReplica",
         uberParent: "ServerPropertiesForCreate",
         polymorphicDiscriminator: ServerPropertiesForCreate.type.polymorphicDiscriminator,
-        modelProperties: Object.assign(Object.assign({}, ServerPropertiesForCreate.type.modelProperties), { sourceServerId: {
+        modelProperties: {
+            ...ServerPropertiesForCreate.type.modelProperties,
+            sourceServerId: {
                 serializedName: "sourceServerId",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const TrackedResource = {
     type: {
         name: "Composite",
         className: "TrackedResource",
-        modelProperties: Object.assign(Object.assign({}, Resource.type.modelProperties), { tags: {
+        modelProperties: {
+            ...Resource.type.modelProperties,
+            tags: {
                 serializedName: "tags",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "String" } }
                 }
-            }, location: {
+            },
+            location: {
                 serializedName: "location",
                 required: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const ProxyResource = {
     type: {
         name: "Composite",
         className: "ProxyResource",
-        modelProperties: Object.assign({}, Resource.type.modelProperties)
+        modelProperties: {
+            ...Resource.type.modelProperties
+        }
     }
 };
 export const Server = {
     type: {
         name: "Composite",
         className: "Server",
-        modelProperties: Object.assign(Object.assign({}, TrackedResource.type.modelProperties), { identity: {
+        modelProperties: {
+            ...TrackedResource.type.modelProperties,
+            identity: {
                 serializedName: "identity",
                 type: {
                     name: "Composite",
                     className: "ResourceIdentity"
                 }
-            }, sku: {
+            },
+            sku: {
                 serializedName: "sku",
                 type: {
                     name: "Composite",
                     className: "Sku"
                 }
-            }, administratorLogin: {
+            },
+            administratorLogin: {
                 serializedName: "properties.administratorLogin",
                 type: {
                     name: "String"
                 }
-            }, version: {
+            },
+            version: {
                 serializedName: "properties.version",
                 type: {
                     name: "String"
                 }
-            }, sslEnforcement: {
+            },
+            sslEnforcement: {
                 serializedName: "properties.sslEnforcement",
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, minimalTlsVersion: {
+            },
+            minimalTlsVersion: {
                 serializedName: "properties.minimalTlsVersion",
                 type: {
                     name: "String"
                 }
-            }, byokEnforcement: {
+            },
+            byokEnforcement: {
                 serializedName: "properties.byokEnforcement",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, infrastructureEncryption: {
+            },
+            infrastructureEncryption: {
                 serializedName: "properties.infrastructureEncryption",
                 type: {
                     name: "String"
                 }
-            }, userVisibleState: {
+            },
+            userVisibleState: {
                 serializedName: "properties.userVisibleState",
                 type: {
                     name: "String"
                 }
-            }, fullyQualifiedDomainName: {
+            },
+            fullyQualifiedDomainName: {
                 serializedName: "properties.fullyQualifiedDomainName",
                 type: {
                     name: "String"
                 }
-            }, earliestRestoreDate: {
+            },
+            earliestRestoreDate: {
                 serializedName: "properties.earliestRestoreDate",
                 type: {
                     name: "DateTime"
                 }
-            }, storageProfile: {
+            },
+            storageProfile: {
                 serializedName: "properties.storageProfile",
                 type: {
                     name: "Composite",
                     className: "StorageProfile"
                 }
-            }, replicationRole: {
+            },
+            replicationRole: {
                 serializedName: "properties.replicationRole",
                 type: {
                     name: "String"
                 }
-            }, masterServerId: {
+            },
+            masterServerId: {
                 serializedName: "properties.masterServerId",
                 type: {
                     name: "String"
                 }
-            }, replicaCapacity: {
+            },
+            replicaCapacity: {
                 constraints: {
                     InclusiveMinimum: 0
                 },
@@ -1591,12 +1627,14 @@ export const Server = {
                 type: {
                     name: "Number"
                 }
-            }, publicNetworkAccess: {
+            },
+            publicNetworkAccess: {
                 serializedName: "properties.publicNetworkAccess",
                 type: {
                     name: "String"
                 }
-            }, privateEndpointConnections: {
+            },
+            privateEndpointConnections: {
                 serializedName: "properties.privateEndpointConnections",
                 readOnly: true,
                 type: {
@@ -1608,14 +1646,17 @@ export const Server = {
                         }
                     }
                 }
-            } })
+            }
+        }
     }
 };
 export const FirewallRule = {
     type: {
         name: "Composite",
         className: "FirewallRule",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { startIpAddress: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            startIpAddress: {
                 constraints: {
                     Pattern: new RegExp("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$")
                 },
@@ -1624,7 +1665,8 @@ export const FirewallRule = {
                 type: {
                     name: "String"
                 }
-            }, endIpAddress: {
+            },
+            endIpAddress: {
                 constraints: {
                     Pattern: new RegExp("^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$")
                 },
@@ -1633,207 +1675,249 @@ export const FirewallRule = {
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const VirtualNetworkRule = {
     type: {
         name: "Composite",
         className: "VirtualNetworkRule",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { virtualNetworkSubnetId: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            virtualNetworkSubnetId: {
                 serializedName: "properties.virtualNetworkSubnetId",
                 type: {
                     name: "String"
                 }
-            }, ignoreMissingVnetServiceEndpoint: {
+            },
+            ignoreMissingVnetServiceEndpoint: {
                 serializedName: "properties.ignoreMissingVnetServiceEndpoint",
                 type: {
                     name: "Boolean"
                 }
-            }, state: {
+            },
+            state: {
                 serializedName: "properties.state",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const Database = {
     type: {
         name: "Composite",
         className: "Database",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { charset: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            charset: {
                 serializedName: "properties.charset",
                 type: {
                     name: "String"
                 }
-            }, collation: {
+            },
+            collation: {
                 serializedName: "properties.collation",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const Configuration = {
     type: {
         name: "Composite",
         className: "Configuration",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { value: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            value: {
                 serializedName: "properties.value",
                 type: {
                     name: "String"
                 }
-            }, description: {
+            },
+            description: {
                 serializedName: "properties.description",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, defaultValue: {
+            },
+            defaultValue: {
                 serializedName: "properties.defaultValue",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, dataType: {
+            },
+            dataType: {
                 serializedName: "properties.dataType",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, allowedValues: {
+            },
+            allowedValues: {
                 serializedName: "properties.allowedValues",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, source: {
+            },
+            source: {
                 serializedName: "properties.source",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const LogFile = {
     type: {
         name: "Composite",
         className: "LogFile",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { sizeInKB: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            sizeInKB: {
                 serializedName: "properties.sizeInKB",
                 type: {
                     name: "Number"
                 }
-            }, createdTime: {
+            },
+            createdTime: {
                 serializedName: "properties.createdTime",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            }, lastModifiedTime: {
+            },
+            lastModifiedTime: {
                 serializedName: "properties.lastModifiedTime",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            }, typePropertiesType: {
+            },
+            typePropertiesType: {
                 serializedName: "properties.type",
                 type: {
                     name: "String"
                 }
-            }, url: {
+            },
+            url: {
                 serializedName: "properties.url",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerAdministratorResource = {
     type: {
         name: "Composite",
         className: "ServerAdministratorResource",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { administratorType: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            administratorType: {
                 defaultValue: "ActiveDirectory",
                 isConstant: true,
                 serializedName: "properties.administratorType",
                 type: {
                     name: "String"
                 }
-            }, login: {
+            },
+            login: {
                 serializedName: "properties.login",
                 type: {
                     name: "String"
                 }
-            }, sid: {
+            },
+            sid: {
                 serializedName: "properties.sid",
                 type: {
                     name: "Uuid"
                 }
-            }, tenantId: {
+            },
+            tenantId: {
                 serializedName: "properties.tenantId",
                 type: {
                     name: "Uuid"
                 }
-            } })
+            }
+        }
     }
 };
 export const RecoverableServerResource = {
     type: {
         name: "Composite",
         className: "RecoverableServerResource",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { lastAvailableBackupDateTime: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            lastAvailableBackupDateTime: {
                 serializedName: "properties.lastAvailableBackupDateTime",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, serviceLevelObjective: {
+            },
+            serviceLevelObjective: {
                 serializedName: "properties.serviceLevelObjective",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, edition: {
+            },
+            edition: {
                 serializedName: "properties.edition",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, vCore: {
+            },
+            vCore: {
                 serializedName: "properties.vCore",
                 readOnly: true,
                 type: {
                     name: "Number"
                 }
-            }, hardwareGeneration: {
+            },
+            hardwareGeneration: {
                 serializedName: "properties.hardwareGeneration",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, version: {
+            },
+            version: {
                 serializedName: "properties.version",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerSecurityAlertPolicy = {
     type: {
         name: "Composite",
         className: "ServerSecurityAlertPolicy",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { state: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            state: {
                 serializedName: "properties.state",
                 type: {
                     name: "Enum",
                     allowedValues: ["Enabled", "Disabled"]
                 }
-            }, disabledAlerts: {
+            },
+            disabledAlerts: {
                 serializedName: "properties.disabledAlerts",
                 type: {
                     name: "Sequence",
@@ -1843,7 +1927,8 @@ export const ServerSecurityAlertPolicy = {
                         }
                     }
                 }
-            }, emailAddresses: {
+            },
+            emailAddresses: {
                 serializedName: "properties.emailAddresses",
                 type: {
                     name: "Sequence",
@@ -1853,71 +1938,86 @@ export const ServerSecurityAlertPolicy = {
                         }
                     }
                 }
-            }, emailAccountAdmins: {
+            },
+            emailAccountAdmins: {
                 serializedName: "properties.emailAccountAdmins",
                 type: {
                     name: "Boolean"
                 }
-            }, storageEndpoint: {
+            },
+            storageEndpoint: {
                 serializedName: "properties.storageEndpoint",
                 type: {
                     name: "String"
                 }
-            }, storageAccountAccessKey: {
+            },
+            storageAccountAccessKey: {
                 serializedName: "properties.storageAccountAccessKey",
                 type: {
                     name: "String"
                 }
-            }, retentionDays: {
+            },
+            retentionDays: {
                 serializedName: "properties.retentionDays",
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 export const QueryText = {
     type: {
         name: "Composite",
         className: "QueryText",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { queryId: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            queryId: {
                 serializedName: "properties.queryId",
                 type: {
                     name: "String"
                 }
-            }, queryText: {
+            },
+            queryText: {
                 serializedName: "properties.queryText",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const QueryStatistic = {
     type: {
         name: "Composite",
         className: "QueryStatistic",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { queryId: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            queryId: {
                 serializedName: "properties.queryId",
                 type: {
                     name: "String"
                 }
-            }, startTime: {
+            },
+            startTime: {
                 serializedName: "properties.startTime",
                 type: {
                     name: "DateTime"
                 }
-            }, endTime: {
+            },
+            endTime: {
                 serializedName: "properties.endTime",
                 type: {
                     name: "DateTime"
                 }
-            }, aggregationFunction: {
+            },
+            aggregationFunction: {
                 serializedName: "properties.aggregationFunction",
                 type: {
                     name: "String"
                 }
-            }, databaseNames: {
+            },
+            databaseNames: {
                 serializedName: "properties.databaseNames",
                 type: {
                     name: "Sequence",
@@ -1927,212 +2027,256 @@ export const QueryStatistic = {
                         }
                     }
                 }
-            }, queryExecutionCount: {
+            },
+            queryExecutionCount: {
                 serializedName: "properties.queryExecutionCount",
                 type: {
                     name: "Number"
                 }
-            }, metricName: {
+            },
+            metricName: {
                 serializedName: "properties.metricName",
                 type: {
                     name: "String"
                 }
-            }, metricDisplayName: {
+            },
+            metricDisplayName: {
                 serializedName: "properties.metricDisplayName",
                 type: {
                     name: "String"
                 }
-            }, metricValue: {
+            },
+            metricValue: {
                 serializedName: "properties.metricValue",
                 type: {
                     name: "Number"
                 }
-            }, metricValueUnit: {
+            },
+            metricValueUnit: {
                 serializedName: "properties.metricValueUnit",
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const WaitStatistic = {
     type: {
         name: "Composite",
         className: "WaitStatistic",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { startTime: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            startTime: {
                 serializedName: "properties.startTime",
                 type: {
                     name: "DateTime"
                 }
-            }, endTime: {
+            },
+            endTime: {
                 serializedName: "properties.endTime",
                 type: {
                     name: "DateTime"
                 }
-            }, eventName: {
+            },
+            eventName: {
                 serializedName: "properties.eventName",
                 type: {
                     name: "String"
                 }
-            }, eventTypeName: {
+            },
+            eventTypeName: {
                 serializedName: "properties.eventTypeName",
                 type: {
                     name: "String"
                 }
-            }, queryId: {
+            },
+            queryId: {
                 serializedName: "properties.queryId",
                 type: {
                     name: "Number"
                 }
-            }, databaseName: {
+            },
+            databaseName: {
                 serializedName: "properties.databaseName",
                 type: {
                     name: "String"
                 }
-            }, userId: {
+            },
+            userId: {
                 serializedName: "properties.userId",
                 type: {
                     name: "Number"
                 }
-            }, count: {
+            },
+            count: {
                 serializedName: "properties.count",
                 type: {
                     name: "Number"
                 }
-            }, totalTimeInMs: {
+            },
+            totalTimeInMs: {
                 serializedName: "properties.totalTimeInMs",
                 type: {
                     name: "Number"
                 }
-            } })
+            }
+        }
     }
 };
 export const Advisor = {
     type: {
         name: "Composite",
         className: "Advisor",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { properties: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            properties: {
                 serializedName: "properties",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "any" } }
                 }
-            } })
+            }
+        }
     }
 };
 export const RecommendationAction = {
     type: {
         name: "Composite",
         className: "RecommendationAction",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { advisorName: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            advisorName: {
                 serializedName: "properties.advisorName",
                 type: {
                     name: "String"
                 }
-            }, sessionId: {
+            },
+            sessionId: {
                 serializedName: "properties.sessionId",
                 type: {
                     name: "String"
                 }
-            }, actionId: {
+            },
+            actionId: {
                 serializedName: "properties.actionId",
                 type: {
                     name: "Number"
                 }
-            }, createdTime: {
+            },
+            createdTime: {
                 serializedName: "properties.createdTime",
                 type: {
                     name: "DateTime"
                 }
-            }, expirationTime: {
+            },
+            expirationTime: {
                 serializedName: "properties.expirationTime",
                 type: {
                     name: "DateTime"
                 }
-            }, reason: {
+            },
+            reason: {
                 serializedName: "properties.reason",
                 type: {
                     name: "String"
                 }
-            }, recommendationType: {
+            },
+            recommendationType: {
                 serializedName: "properties.recommendationType",
                 type: {
                     name: "String"
                 }
-            }, details: {
+            },
+            details: {
                 serializedName: "properties.details",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "String" } }
                 }
-            } })
+            }
+        }
     }
 };
 export const PrivateEndpointConnection = {
     type: {
         name: "Composite",
         className: "PrivateEndpointConnection",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { privateEndpoint: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            privateEndpoint: {
                 serializedName: "properties.privateEndpoint",
                 type: {
                     name: "Composite",
                     className: "PrivateEndpointProperty"
                 }
-            }, privateLinkServiceConnectionState: {
+            },
+            privateLinkServiceConnectionState: {
                 serializedName: "properties.privateLinkServiceConnectionState",
                 type: {
                     name: "Composite",
                     className: "PrivateLinkServiceConnectionStateProperty"
                 }
-            }, provisioningState: {
+            },
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            } })
+            }
+        }
     }
 };
 export const PrivateLinkResource = {
     type: {
         name: "Composite",
         className: "PrivateLinkResource",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { properties: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            properties: {
                 serializedName: "properties",
                 type: {
                     name: "Composite",
                     className: "PrivateLinkResourceProperties"
                 }
-            } })
+            }
+        }
     }
 };
 export const ServerKey = {
     type: {
         name: "Composite",
         className: "ServerKey",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { kind: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            kind: {
                 serializedName: "kind",
                 readOnly: true,
                 type: {
                     name: "String"
                 }
-            }, serverKeyType: {
+            },
+            serverKeyType: {
                 serializedName: "properties.serverKeyType",
                 type: {
                     name: "String"
                 }
-            }, uri: {
+            },
+            uri: {
                 serializedName: "properties.uri",
                 type: {
                     name: "String"
                 }
-            }, creationDate: {
+            },
+            creationDate: {
                 serializedName: "properties.creationDate",
                 readOnly: true,
                 type: {
                     name: "DateTime"
                 }
-            } })
+            }
+        }
     }
 };
 export let discriminators = {