@azure/arm-rediscache 8.2.1-alpha.20250618.1 → 8.2.1-alpha.20250718.2

package/dist/browser/models/mappers.js

@@ -1503,13 +1503,16 @@ export const RedisCreateProperties = {
     type: {
         name: "Composite",
         className: "RedisCreateProperties",
-        modelProperties: Object.assign(Object.assign({}, RedisCommonProperties.type.modelProperties), { sku: {
+        modelProperties: {
+            ...RedisCommonProperties.type.modelProperties,
+            sku: {
                 serializedName: "sku",
                 type: {
                     name: "Composite",
                     className: "Sku",
                 },
-            }, subnetId: {
+            },
+            subnetId: {
                 constraints: {
                     Pattern: new RegExp("^\\/subscriptions\\/[^/]*\\/resourceGroups\\/[^/]*\\/providers\\/Microsoft.(ClassicNetwork|Network)\\/virtualNetworks\\/[^/]*\\/subnets\\/[^/]*$"),
                 },
@@ -1517,7 +1520,8 @@ export const RedisCreateProperties = {
                 type: {
                     name: "String",
                 },
-            }, staticIP: {
+            },
+            staticIP: {
                 constraints: {
                     Pattern: new RegExp("^\\d+\\.\\d+\\.\\d+\\.\\d+$"),
                 },
@@ -1525,84 +1529,102 @@ export const RedisCreateProperties = {
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisUpdateProperties = {
     type: {
         name: "Composite",
         className: "RedisUpdateProperties",
-        modelProperties: Object.assign(Object.assign({}, RedisCommonProperties.type.modelProperties), { sku: {
+        modelProperties: {
+            ...RedisCommonProperties.type.modelProperties,
+            sku: {
                 serializedName: "sku",
                 type: {
                     name: "Composite",
                     className: "Sku",
                 },
-            } }),
+            },
+        },
     },
 };
 export const PrivateEndpointConnection = {
     type: {
         name: "Composite",
         className: "PrivateEndpointConnection",
-        modelProperties: Object.assign(Object.assign({}, Resource.type.modelProperties), { privateEndpoint: {
+        modelProperties: {
+            ...Resource.type.modelProperties,
+            privateEndpoint: {
                 serializedName: "properties.privateEndpoint",
                 type: {
                     name: "Composite",
                     className: "PrivateEndpoint",
                 },
-            }, privateLinkServiceConnectionState: {
+            },
+            privateLinkServiceConnectionState: {
                 serializedName: "properties.privateLinkServiceConnectionState",
                 type: {
                     name: "Composite",
                     className: "PrivateLinkServiceConnectionState",
                 },
-            }, provisioningState: {
+            },
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: 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 PrivateLinkResource = {
     type: {
         name: "Composite",
         className: "PrivateLinkResource",
-        modelProperties: Object.assign(Object.assign({}, Resource.type.modelProperties), { groupId: {
+        modelProperties: {
+            ...Resource.type.modelProperties,
+            groupId: {
                 serializedName: "properties.groupId",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, requiredMembers: {
+            },
+            requiredMembers: {
                 serializedName: "properties.requiredMembers",
                 readOnly: true,
                 type: {
@@ -1613,7 +1635,8 @@ export const PrivateLinkResource = {
                         },
                     },
                 },
-            }, requiredZoneNames: {
+            },
+            requiredZoneNames: {
                 serializedName: "properties.requiredZoneNames",
                 type: {
                     name: "Sequence",
@@ -1623,70 +1646,84 @@ export const PrivateLinkResource = {
                         },
                     },
                 },
-            } }),
+            },
+        },
     },
 };
 export const OperationStatus = {
     type: {
         name: "Composite",
         className: "OperationStatus",
-        modelProperties: Object.assign(Object.assign({}, OperationStatusResult.type.modelProperties), { properties: {
+        modelProperties: {
+            ...OperationStatusResult.type.modelProperties,
+            properties: {
                 serializedName: "properties",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "any" } },
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisLinkedServerProperties = {
     type: {
         name: "Composite",
         className: "RedisLinkedServerProperties",
-        modelProperties: Object.assign(Object.assign({}, RedisLinkedServerCreateProperties.type.modelProperties), { provisioningState: {
+        modelProperties: {
+            ...RedisLinkedServerCreateProperties.type.modelProperties,
+            provisioningState: {
                 serializedName: "provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisProperties = {
     type: {
         name: "Composite",
         className: "RedisProperties",
-        modelProperties: Object.assign(Object.assign({}, RedisCreateProperties.type.modelProperties), { provisioningState: {
+        modelProperties: {
+            ...RedisCreateProperties.type.modelProperties,
+            provisioningState: {
                 serializedName: "provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, hostName: {
+            },
+            hostName: {
                 serializedName: "hostName",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, port: {
+            },
+            port: {
                 serializedName: "port",
                 readOnly: true,
                 type: {
                     name: "Number",
                 },
-            }, sslPort: {
+            },
+            sslPort: {
                 serializedName: "sslPort",
                 readOnly: true,
                 type: {
                     name: "Number",
                 },
-            }, accessKeys: {
+            },
+            accessKeys: {
                 serializedName: "accessKeys",
                 type: {
                     name: "Composite",
                     className: "RedisAccessKeys",
                 },
-            }, linkedServers: {
+            },
+            linkedServers: {
                 serializedName: "linkedServers",
                 readOnly: true,
                 type: {
@@ -1698,7 +1735,8 @@ export const RedisProperties = {
                         },
                     },
                 },
-            }, instances: {
+            },
+            instances: {
                 serializedName: "instances",
                 readOnly: true,
                 type: {
@@ -1710,7 +1748,8 @@ export const RedisProperties = {
                         },
                     },
                 },
-            }, privateEndpointConnections: {
+            },
+            privateEndpointConnections: {
                 serializedName: "privateEndpointConnections",
                 readOnly: true,
                 type: {
@@ -1722,14 +1761,17 @@ export const RedisProperties = {
                         },
                     },
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisResource = {
     type: {
         name: "Composite",
         className: "RedisResource",
-        modelProperties: Object.assign(Object.assign({}, TrackedResource.type.modelProperties), { zones: {
+        modelProperties: {
+            ...TrackedResource.type.modelProperties,
+            zones: {
                 serializedName: "zones",
                 type: {
                     name: "Sequence",
@@ -1739,84 +1781,99 @@ export const RedisResource = {
                         },
                     },
                 },
-            }, identity: {
+            },
+            identity: {
                 serializedName: "identity",
                 type: {
                     name: "Composite",
                     className: "ManagedServiceIdentity",
                 },
-            }, redisConfiguration: {
+            },
+            redisConfiguration: {
                 serializedName: "properties.redisConfiguration",
                 type: {
                     name: "Composite",
                     className: "RedisCommonPropertiesRedisConfiguration",
                 },
-            }, redisVersion: {
+            },
+            redisVersion: {
                 serializedName: "properties.redisVersion",
                 type: {
                     name: "String",
                 },
-            }, enableNonSslPort: {
+            },
+            enableNonSslPort: {
                 defaultValue: false,
                 serializedName: "properties.enableNonSslPort",
                 type: {
                     name: "Boolean",
                 },
-            }, replicasPerMaster: {
+            },
+            replicasPerMaster: {
                 serializedName: "properties.replicasPerMaster",
                 type: {
                     name: "Number",
                 },
-            }, replicasPerPrimary: {
+            },
+            replicasPerPrimary: {
                 serializedName: "properties.replicasPerPrimary",
                 type: {
                     name: "Number",
                 },
-            }, tenantSettings: {
+            },
+            tenantSettings: {
                 serializedName: "properties.tenantSettings",
                 type: {
                     name: "Dictionary",
                     value: { type: { name: "String" } },
                 },
-            }, shardCount: {
+            },
+            shardCount: {
                 serializedName: "properties.shardCount",
                 type: {
                     name: "Number",
                 },
-            }, minimumTlsVersion: {
+            },
+            minimumTlsVersion: {
                 serializedName: "properties.minimumTlsVersion",
                 type: {
                     name: "String",
                 },
-            }, publicNetworkAccess: {
+            },
+            publicNetworkAccess: {
                 defaultValue: "Enabled",
                 serializedName: "properties.publicNetworkAccess",
                 type: {
                     name: "String",
                 },
-            }, updateChannel: {
+            },
+            updateChannel: {
                 serializedName: "properties.updateChannel",
                 type: {
                     name: "String",
                 },
-            }, disableAccessKeyAuthentication: {
+            },
+            disableAccessKeyAuthentication: {
                 defaultValue: false,
                 serializedName: "properties.disableAccessKeyAuthentication",
                 type: {
                     name: "Boolean",
                 },
-            }, zonalAllocationPolicy: {
+            },
+            zonalAllocationPolicy: {
                 serializedName: "properties.zonalAllocationPolicy",
                 type: {
                     name: "String",
                 },
-            }, sku: {
+            },
+            sku: {
                 serializedName: "properties.sku",
                 type: {
                     name: "Composite",
                     className: "Sku",
                 },
-            }, subnetId: {
+            },
+            subnetId: {
                 constraints: {
                     Pattern: new RegExp("^\\/subscriptions\\/[^/]*\\/resourceGroups\\/[^/]*\\/providers\\/Microsoft.(ClassicNetwork|Network)\\/virtualNetworks\\/[^/]*\\/subnets\\/[^/]*$"),
                 },
@@ -1824,7 +1881,8 @@ export const RedisResource = {
                 type: {
                     name: "String",
                 },
-            }, staticIP: {
+            },
+            staticIP: {
                 constraints: {
                     Pattern: new RegExp("^\\d+\\.\\d+\\.\\d+\\.\\d+$"),
                 },
@@ -1832,37 +1890,43 @@ export const RedisResource = {
                 type: {
                     name: "String",
                 },
-            }, provisioningState: {
+            },
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, hostName: {
+            },
+            hostName: {
                 serializedName: "properties.hostName",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, port: {
+            },
+            port: {
                 serializedName: "properties.port",
                 readOnly: true,
                 type: {
                     name: "Number",
                 },
-            }, sslPort: {
+            },
+            sslPort: {
                 serializedName: "properties.sslPort",
                 readOnly: true,
                 type: {
                     name: "Number",
                 },
-            }, accessKeys: {
+            },
+            accessKeys: {
                 serializedName: "properties.accessKeys",
                 type: {
                     name: "Composite",
                     className: "RedisAccessKeys",
                 },
-            }, linkedServers: {
+            },
+            linkedServers: {
                 serializedName: "properties.linkedServers",
                 readOnly: true,
                 type: {
@@ -1874,7 +1938,8 @@ export const RedisResource = {
                         },
                     },
                 },
-            }, instances: {
+            },
+            instances: {
                 serializedName: "properties.instances",
                 readOnly: true,
                 type: {
@@ -1886,7 +1951,8 @@ export const RedisResource = {
                         },
                     },
                 },
-            }, privateEndpointConnections: {
+            },
+            privateEndpointConnections: {
                 serializedName: "properties.privateEndpointConnections",
                 readOnly: true,
                 type: {
@@ -1898,39 +1964,47 @@ export const RedisResource = {
                         },
                     },
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisFirewallRule = {
     type: {
         name: "Composite",
         className: "RedisFirewallRule",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { startIP: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            startIP: {
                 serializedName: "properties.startIP",
                 required: true,
                 type: {
                     name: "String",
                 },
-            }, endIP: {
+            },
+            endIP: {
                 serializedName: "properties.endIP",
                 required: true,
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisPatchSchedule = {
     type: {
         name: "Composite",
         className: "RedisPatchSchedule",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { location: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            location: {
                 serializedName: "location",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, scheduleEntries: {
+            },
+            scheduleEntries: {
                 serializedName: "properties.scheduleEntries",
                 required: true,
                 type: {
@@ -1942,95 +2016,114 @@ export const RedisPatchSchedule = {
                         },
                     },
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisLinkedServerWithProperties = {
     type: {
         name: "Composite",
         className: "RedisLinkedServerWithProperties",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { linkedRedisCacheId: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            linkedRedisCacheId: {
                 serializedName: "properties.linkedRedisCacheId",
                 type: {
                     name: "String",
                 },
-            }, linkedRedisCacheLocation: {
+            },
+            linkedRedisCacheLocation: {
                 serializedName: "properties.linkedRedisCacheLocation",
                 type: {
                     name: "String",
                 },
-            }, serverRole: {
+            },
+            serverRole: {
                 serializedName: "properties.serverRole",
                 type: {
                     name: "Enum",
                     allowedValues: ["Primary", "Secondary"],
                 },
-            }, geoReplicatedPrimaryHostName: {
+            },
+            geoReplicatedPrimaryHostName: {
                 serializedName: "properties.geoReplicatedPrimaryHostName",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, primaryHostName: {
+            },
+            primaryHostName: {
                 serializedName: "properties.primaryHostName",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, provisioningState: {
+            },
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisCacheAccessPolicy = {
     type: {
         name: "Composite",
         className: "RedisCacheAccessPolicy",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { provisioningState: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, typePropertiesType: {
+            },
+            typePropertiesType: {
                 serializedName: "properties.type",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, permissions: {
+            },
+            permissions: {
                 serializedName: "properties.permissions",
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisCacheAccessPolicyAssignment = {
     type: {
         name: "Composite",
         className: "RedisCacheAccessPolicyAssignment",
-        modelProperties: Object.assign(Object.assign({}, ProxyResource.type.modelProperties), { provisioningState: {
+        modelProperties: {
+            ...ProxyResource.type.modelProperties,
+            provisioningState: {
                 serializedName: "properties.provisioningState",
                 readOnly: true,
                 type: {
                     name: "String",
                 },
-            }, objectId: {
+            },
+            objectId: {
                 serializedName: "properties.objectId",
                 type: {
                     name: "String",
                 },
-            }, objectIdAlias: {
+            },
+            objectIdAlias: {
                 serializedName: "properties.objectIdAlias",
                 type: {
                     name: "String",
                 },
-            }, accessPolicyName: {
+            },
+            accessPolicyName: {
                 constraints: {
                     Pattern: new RegExp("^([a-zA-Z0-9][a-zA-Z0-9- ]*[a-zA-Z0-9]|[a-zA-Z0-9])$"),
                 },
@@ -2038,14 +2131,17 @@ export const RedisCacheAccessPolicyAssignment = {
                 type: {
                     name: "String",
                 },
-            } }),
+            },
+        },
     },
 };
 export const RedisFirewallRuleCreateParameters = {
     type: {
         name: "Composite",
         className: "RedisFirewallRuleCreateParameters",
-        modelProperties: Object.assign({}, RedisFirewallRule.type.modelProperties),
+        modelProperties: {
+            ...RedisFirewallRule.type.modelProperties,
+        },
     },
 };
 export const RedisFlushCacheHeaders = {