@azure/arm-batch 6.0.0 → 7.0.0-alpha.20211122.1

package/src/models/mappers.ts

@@ -6,50 +6,105 @@
  * Changes may cause incorrect behavior and will be lost if the code is regenerated.
  */
 
-import { CloudErrorMapper, BaseResourceMapper } from "@azure/ms-rest-azure-js";
-import * as msRest from "@azure/ms-rest-js";
+import * as coreClient from "@azure/core-client";
 
-export const CloudError = CloudErrorMapper;
-export const BaseResource = BaseResourceMapper;
-
-export const ComputeNodeIdentityReference: msRest.CompositeMapper = {
-  serializedName: "ComputeNodeIdentityReference",
+export const BatchAccountCreateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ComputeNodeIdentityReference",
+    className: "BatchAccountCreateParameters",
     modelProperties: {
-      resourceId: {
-        serializedName: "resourceId",
+      location: {
+        serializedName: "location",
+        required: true,
         type: {
           name: "String"
         }
+      },
+      tags: {
+        serializedName: "tags",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
+      },
+      identity: {
+        serializedName: "identity",
+        type: {
+          name: "Composite",
+          className: "BatchAccountIdentity"
+        }
+      },
+      autoStorage: {
+        serializedName: "properties.autoStorage",
+        type: {
+          name: "Composite",
+          className: "AutoStorageBaseProperties"
+        }
+      },
+      poolAllocationMode: {
+        serializedName: "properties.poolAllocationMode",
+        type: {
+          name: "Enum",
+          allowedValues: ["BatchService", "UserSubscription"]
+        }
+      },
+      keyVaultReference: {
+        serializedName: "properties.keyVaultReference",
+        type: {
+          name: "Composite",
+          className: "KeyVaultReference"
+        }
+      },
+      publicNetworkAccess: {
+        defaultValue: "Enabled",
+        serializedName: "properties.publicNetworkAccess",
+        type: {
+          name: "Enum",
+          allowedValues: ["Enabled", "Disabled"]
+        }
+      },
+      encryption: {
+        serializedName: "properties.encryption",
+        type: {
+          name: "Composite",
+          className: "EncryptionProperties"
+        }
+      },
+      allowedAuthenticationModes: {
+        serializedName: "properties.allowedAuthenticationModes",
+        nullable: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Enum",
+              allowedValues: ["SharedKey", "AAD", "TaskAuthenticationToken"]
+            }
+          }
+        }
       }
     }
   }
 };
 
-export const AutoStorageBaseProperties: msRest.CompositeMapper = {
-  serializedName: "AutoStorageBaseProperties",
+export const AutoStorageBaseProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "AutoStorageBaseProperties",
     modelProperties: {
       storageAccountId: {
-        required: true,
         serializedName: "storageAccountId",
+        required: true,
         type: {
           name: "String"
         }
       },
       authenticationMode: {
+        defaultValue: "StorageKeys",
         serializedName: "authenticationMode",
-        defaultValue: 'StorageKeys',
         type: {
           name: "Enum",
-          allowedValues: [
-            "StorageKeys",
-            "BatchAccountManagedIdentity"
-          ]
+          allowedValues: ["StorageKeys", "BatchAccountManagedIdentity"]
         }
       },
       nodeIdentityReference: {
@@ -63,14 +118,13 @@ export const AutoStorageBaseProperties: msRest.CompositeMapper = {
   }
 };
 
-export const KeyVaultProperties: msRest.CompositeMapper = {
-  serializedName: "KeyVaultProperties",
+export const ComputeNodeIdentityReference: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "KeyVaultProperties",
+    className: "ComputeNodeIdentityReference",
     modelProperties: {
-      keyIdentifier: {
-        serializedName: "keyIdentifier",
+      resourceId: {
+        serializedName: "resourceId",
         type: {
           name: "String"
         }
@@ -79,73 +133,59 @@ export const KeyVaultProperties: msRest.CompositeMapper = {
   }
 };
 
-export const EncryptionProperties: msRest.CompositeMapper = {
-  serializedName: "EncryptionProperties",
+export const KeyVaultReference: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "EncryptionProperties",
+    className: "KeyVaultReference",
     modelProperties: {
-      keySource: {
-        serializedName: "keySource",
+      id: {
+        serializedName: "id",
+        required: true,
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Microsoft.Batch",
-            "Microsoft.KeyVault"
-          ]
+          name: "String"
         }
       },
-      keyVaultProperties: {
-        serializedName: "keyVaultProperties",
+      url: {
+        serializedName: "url",
+        required: true,
         type: {
-          name: "Composite",
-          className: "KeyVaultProperties"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const KeyVaultReference: msRest.CompositeMapper = {
-  serializedName: "KeyVaultReference",
+export const EncryptionProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "KeyVaultReference",
+    className: "EncryptionProperties",
     modelProperties: {
-      id: {
-        required: true,
-        serializedName: "id",
+      keySource: {
+        serializedName: "keySource",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Microsoft.Batch", "Microsoft.KeyVault"]
         }
       },
-      url: {
-        required: true,
-        serializedName: "url",
+      keyVaultProperties: {
+        serializedName: "keyVaultProperties",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "KeyVaultProperties"
         }
       }
     }
   }
 };
 
-export const UserAssignedIdentities: msRest.CompositeMapper = {
-  serializedName: "UserAssignedIdentities",
+export const KeyVaultProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "UserAssignedIdentities",
+    className: "KeyVaultProperties",
     modelProperties: {
-      principalId: {
-        readOnly: true,
-        serializedName: "principalId",
-        type: {
-          name: "String"
-        }
-      },
-      clientId: {
-        readOnly: true,
-        serializedName: "clientId",
+      keyIdentifier: {
+        serializedName: "keyIdentifier",
         type: {
           name: "String"
         }
@@ -154,36 +194,31 @@ export const UserAssignedIdentities: msRest.CompositeMapper = {
   }
 };
 
-export const BatchAccountIdentity: msRest.CompositeMapper = {
-  serializedName: "BatchAccountIdentity",
+export const BatchAccountIdentity: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountIdentity",
     modelProperties: {
       principalId: {
-        readOnly: true,
         serializedName: "principalId",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       tenantId: {
-        readOnly: true,
         serializedName: "tenantId",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       type: {
-        required: true,
         serializedName: "type",
+        required: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "SystemAssigned",
-            "UserAssigned",
-            "None"
-          ]
+          allowedValues: ["SystemAssigned", "UserAssigned", "None"]
         }
       },
       userAssignedIdentities: {
@@ -191,164 +226,45 @@ export const BatchAccountIdentity: msRest.CompositeMapper = {
         type: {
           name: "Dictionary",
           value: {
-            type: {
-              name: "Composite",
-              className: "UserAssignedIdentities"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const BatchAccountCreateParameters: msRest.CompositeMapper = {
-  serializedName: "BatchAccountCreateParameters",
-  type: {
-    name: "Composite",
-    className: "BatchAccountCreateParameters",
-    modelProperties: {
-      location: {
-        required: true,
-        serializedName: "location",
-        type: {
-          name: "String"
-        }
-      },
-      tags: {
-        serializedName: "tags",
-        type: {
-          name: "Dictionary",
-          value: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      },
-      autoStorage: {
-        serializedName: "properties.autoStorage",
-        type: {
-          name: "Composite",
-          className: "AutoStorageBaseProperties"
-        }
-      },
-      poolAllocationMode: {
-        serializedName: "properties.poolAllocationMode",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "BatchService",
-            "UserSubscription"
-          ]
-        }
-      },
-      keyVaultReference: {
-        serializedName: "properties.keyVaultReference",
-        type: {
-          name: "Composite",
-          className: "KeyVaultReference"
-        }
-      },
-      publicNetworkAccess: {
-        serializedName: "properties.publicNetworkAccess",
-        defaultValue: 'Enabled',
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
-        }
-      },
-      encryption: {
-        serializedName: "properties.encryption",
-        type: {
-          name: "Composite",
-          className: "EncryptionProperties"
-        }
-      },
-      allowedAuthenticationModes: {
-        nullable: true,
-        serializedName: "properties.allowedAuthenticationModes",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Enum",
-              allowedValues: [
-                "SharedKey",
-                "AAD",
-                "TaskAuthenticationToken"
-              ]
-            }
+            type: { name: "Composite", className: "UserAssignedIdentities" }
           }
         }
-      },
-      identity: {
-        serializedName: "identity",
-        type: {
-          name: "Composite",
-          className: "BatchAccountIdentity"
-        }
-      }
-    }
-  }
-};
-
-export const AutoStorageProperties: msRest.CompositeMapper = {
-  serializedName: "AutoStorageProperties",
-  type: {
-    name: "Composite",
-    className: "AutoStorageProperties",
-    modelProperties: {
-      ...AutoStorageBaseProperties.type.modelProperties,
-      lastKeySync: {
-        required: true,
-        serializedName: "lastKeySync",
-        type: {
-          name: "DateTime"
-        }
       }
     }
   }
 };
 
-export const VirtualMachineFamilyCoreQuota: msRest.CompositeMapper = {
-  serializedName: "VirtualMachineFamilyCoreQuota",
+export const UserAssignedIdentities: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "VirtualMachineFamilyCoreQuota",
+    className: "UserAssignedIdentities",
     modelProperties: {
-      name: {
-        nullable: false,
+      principalId: {
+        serializedName: "principalId",
         readOnly: true,
-        serializedName: "name",
         type: {
           name: "String"
         }
       },
-      coreQuota: {
-        nullable: false,
+      clientId: {
+        serializedName: "clientId",
         readOnly: true,
-        serializedName: "coreQuota",
         type: {
-          name: "Number"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const PrivateEndpoint: msRest.CompositeMapper = {
-  serializedName: "PrivateEndpoint",
+export const PrivateEndpoint: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PrivateEndpoint",
     modelProperties: {
       id: {
-        readOnly: true,
         serializedName: "id",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -357,23 +273,17 @@ export const PrivateEndpoint: msRest.CompositeMapper = {
   }
 };
 
-export const PrivateLinkServiceConnectionState: msRest.CompositeMapper = {
-  serializedName: "PrivateLinkServiceConnectionState",
+export const PrivateLinkServiceConnectionState: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PrivateLinkServiceConnectionState",
     modelProperties: {
       status: {
-        required: true,
         serializedName: "status",
+        required: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "Approved",
-            "Pending",
-            "Rejected",
-            "Disconnected"
-          ]
+          allowedValues: ["Approved", "Pending", "Rejected", "Disconnected"]
         }
       },
       description: {
@@ -383,8 +293,8 @@ export const PrivateLinkServiceConnectionState: msRest.CompositeMapper = {
         }
       },
       actionRequired: {
-        readOnly: true,
         serializedName: "actionRequired",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -393,36 +303,35 @@ export const PrivateLinkServiceConnectionState: msRest.CompositeMapper = {
   }
 };
 
-export const ProxyResource: msRest.CompositeMapper = {
-  serializedName: "ProxyResource",
+export const ProxyResource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "ProxyResource",
     modelProperties: {
       id: {
-        readOnly: true,
         serializedName: "id",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       name: {
-        readOnly: true,
         serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       type: {
-        readOnly: true,
         serializedName: "type",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       etag: {
-        readOnly: true,
         serializedName: "etag",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -431,270 +340,130 @@ export const ProxyResource: msRest.CompositeMapper = {
   }
 };
 
-export const PrivateEndpointConnection: msRest.CompositeMapper = {
-  serializedName: "PrivateEndpointConnection",
+export const VirtualMachineFamilyCoreQuota: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "PrivateEndpointConnection",
+    className: "VirtualMachineFamilyCoreQuota",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      provisioningState: {
-        nullable: false,
+      name: {
+        serializedName: "name",
         readOnly: true,
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Succeeded",
-            "Updating",
-            "Failed"
-          ]
-        }
-      },
-      privateEndpoint: {
-        serializedName: "properties.privateEndpoint",
         type: {
-          name: "Composite",
-          className: "PrivateEndpoint"
+          name: "String"
         }
       },
-      privateLinkServiceConnectionState: {
-        serializedName: "properties.privateLinkServiceConnectionState",
+      coreQuota: {
+        serializedName: "coreQuota",
+        readOnly: true,
         type: {
-          name: "Composite",
-          className: "PrivateLinkServiceConnectionState"
+          name: "Number"
         }
       }
     }
   }
 };
 
-export const Resource: msRest.CompositeMapper = {
-  serializedName: "Resource",
+export const Resource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "Resource",
     modelProperties: {
       id: {
-        readOnly: true,
         serializedName: "id",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       name: {
-        readOnly: true,
         serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       type: {
-        readOnly: true,
         serializedName: "type",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       location: {
-        readOnly: true,
         serializedName: "location",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       tags: {
-        readOnly: true,
         serializedName: "tags",
+        readOnly: true,
         type: {
           name: "Dictionary",
-          value: {
-            type: {
-              name: "String"
-            }
-          }
+          value: { type: { name: "String" } }
         }
       }
     }
   }
 };
 
-export const BatchAccount: msRest.CompositeMapper = {
-  serializedName: "BatchAccount",
+export const CloudError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "BatchAccount",
+    className: "CloudError",
     modelProperties: {
-      ...Resource.type.modelProperties,
-      accountEndpoint: {
-        readOnly: true,
-        serializedName: "properties.accountEndpoint",
-        type: {
-          name: "String"
-        }
-      },
-      provisioningState: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Invalid",
-            "Creating",
-            "Deleting",
-            "Succeeded",
-            "Failed",
-            "Cancelled"
-          ]
-        }
-      },
-      poolAllocationMode: {
-        readOnly: true,
-        serializedName: "properties.poolAllocationMode",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "BatchService",
-            "UserSubscription"
-          ]
-        }
-      },
-      keyVaultReference: {
-        readOnly: true,
-        serializedName: "properties.keyVaultReference",
-        type: {
-          name: "Composite",
-          className: "KeyVaultReference"
-        }
-      },
-      publicNetworkAccess: {
-        readOnly: true,
-        serializedName: "properties.publicNetworkAccess",
-        defaultValue: 'Enabled',
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
-        }
-      },
-      privateEndpointConnections: {
-        nullable: true,
-        readOnly: true,
-        serializedName: "properties.privateEndpointConnections",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "PrivateEndpointConnection"
-            }
-          }
-        }
-      },
-      autoStorage: {
-        readOnly: true,
-        serializedName: "properties.autoStorage",
+      error: {
+        serializedName: "error",
         type: {
           name: "Composite",
-          className: "AutoStorageProperties"
+          className: "CloudErrorBody"
         }
-      },
-      encryption: {
-        readOnly: true,
-        serializedName: "properties.encryption",
+      }
+    }
+  }
+};
+
+export const CloudErrorBody: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "CloudErrorBody",
+    modelProperties: {
+      code: {
+        serializedName: "code",
         type: {
-          name: "Composite",
-          className: "EncryptionProperties"
+          name: "String"
         }
       },
-      dedicatedCoreQuota: {
-        nullable: true,
-        readOnly: true,
-        serializedName: "properties.dedicatedCoreQuota",
+      message: {
+        serializedName: "message",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      lowPriorityCoreQuota: {
-        nullable: true,
-        readOnly: true,
-        serializedName: "properties.lowPriorityCoreQuota",
+      target: {
+        serializedName: "target",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      dedicatedCoreQuotaPerVMFamily: {
-        nullable: true,
-        readOnly: true,
-        serializedName: "properties.dedicatedCoreQuotaPerVMFamily",
+      details: {
+        serializedName: "details",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "VirtualMachineFamilyCoreQuota"
-            }
-          }
-        }
-      },
-      dedicatedCoreQuotaPerVMFamilyEnforced: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.dedicatedCoreQuotaPerVMFamilyEnforced",
-        type: {
-          name: "Boolean"
-        }
-      },
-      poolQuota: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.poolQuota",
-        type: {
-          name: "Number"
-        }
-      },
-      activeJobAndJobScheduleQuota: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.activeJobAndJobScheduleQuota",
-        type: {
-          name: "Number"
-        }
-      },
-      allowedAuthenticationModes: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.allowedAuthenticationModes",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Enum",
-              allowedValues: [
-                "SharedKey",
-                "AAD",
-                "TaskAuthenticationToken"
-              ]
+              className: "CloudErrorBody"
             }
           }
         }
-      },
-      identity: {
-        serializedName: "identity",
-        type: {
-          name: "Composite",
-          className: "BatchAccountIdentity"
-        }
       }
     }
   }
 };
 
-export const BatchAccountUpdateParameters: msRest.CompositeMapper = {
-  serializedName: "BatchAccountUpdateParameters",
+export const BatchAccountUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountUpdateParameters",
@@ -703,11 +472,14 @@ export const BatchAccountUpdateParameters: msRest.CompositeMapper = {
         serializedName: "tags",
         type: {
           name: "Dictionary",
-          value: {
-            type: {
-              name: "String"
-            }
-          }
+          value: { type: { name: "String" } }
+        }
+      },
+      identity: {
+        serializedName: "identity",
+        type: {
+          name: "Composite",
+          className: "BatchAccountIdentity"
         }
       },
       autoStorage: {
@@ -725,77 +497,88 @@ export const BatchAccountUpdateParameters: msRest.CompositeMapper = {
         }
       },
       allowedAuthenticationModes: {
-        nullable: true,
         serializedName: "properties.allowedAuthenticationModes",
+        nullable: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Enum",
-              allowedValues: [
-                "SharedKey",
-                "AAD",
-                "TaskAuthenticationToken"
-              ]
+              allowedValues: ["SharedKey", "AAD", "TaskAuthenticationToken"]
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const BatchAccountListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "BatchAccountListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "BatchAccount"
             }
           }
         }
       },
-      identity: {
-        serializedName: "identity",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
-          name: "Composite",
-          className: "BatchAccountIdentity"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const BatchAccountRegenerateKeyParameters: msRest.CompositeMapper = {
-  serializedName: "BatchAccountRegenerateKeyParameters",
+export const BatchAccountRegenerateKeyParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountRegenerateKeyParameters",
     modelProperties: {
       keyName: {
-        required: true,
         serializedName: "keyName",
+        required: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "Primary",
-            "Secondary"
-          ]
+          allowedValues: ["Primary", "Secondary"]
         }
       }
     }
   }
 };
 
-export const BatchAccountKeys: msRest.CompositeMapper = {
-  serializedName: "BatchAccountKeys",
+export const BatchAccountKeys: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountKeys",
     modelProperties: {
       accountName: {
-        readOnly: true,
         serializedName: "accountName",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       primary: {
-        readOnly: true,
         serializedName: "primary",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       secondary: {
-        readOnly: true,
         serializedName: "secondary",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -804,15 +587,14 @@ export const BatchAccountKeys: msRest.CompositeMapper = {
   }
 };
 
-export const ActivateApplicationPackageParameters: msRest.CompositeMapper = {
-  serializedName: "ActivateApplicationPackageParameters",
+export const ActivateApplicationPackageParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "ActivateApplicationPackageParameters",
     modelProperties: {
       format: {
-        required: true,
         serializedName: "format",
+        required: true,
         type: {
           name: "String"
         }
@@ -821,27 +603,25 @@ export const ActivateApplicationPackageParameters: msRest.CompositeMapper = {
   }
 };
 
-export const Application: msRest.CompositeMapper = {
-  serializedName: "Application",
+export const ListApplicationsResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Application",
+    className: "ListApplicationsResult",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      displayName: {
-        serializedName: "properties.displayName",
-        type: {
-          name: "String"
-        }
-      },
-      allowUpdates: {
-        serializedName: "properties.allowUpdates",
+      value: {
+        serializedName: "value",
         type: {
-          name: "Boolean"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Application"
+            }
+          }
         }
       },
-      defaultVersion: {
-        serializedName: "properties.defaultVersion",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -850,65 +630,41 @@ export const Application: msRest.CompositeMapper = {
   }
 };
 
-export const ApplicationPackage: msRest.CompositeMapper = {
-  serializedName: "ApplicationPackage",
+export const ListApplicationPackagesResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ApplicationPackage",
+    className: "ListApplicationPackagesResult",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      state: {
-        readOnly: true,
-        serializedName: "properties.state",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Pending",
-            "Active"
-          ]
-        }
-      },
-      format: {
-        readOnly: true,
-        serializedName: "properties.format",
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ApplicationPackage"
+            }
+          }
         }
       },
-      storageUrl: {
-        readOnly: true,
-        serializedName: "properties.storageUrl",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
-      },
-      storageUrlExpiry: {
-        readOnly: true,
-        serializedName: "properties.storageUrlExpiry",
-        type: {
-          name: "DateTime"
-        }
-      },
-      lastActivationTime: {
-        readOnly: true,
-        serializedName: "properties.lastActivationTime",
-        type: {
-          name: "DateTime"
-        }
       }
     }
   }
 };
 
-export const BatchLocationQuota: msRest.CompositeMapper = {
-  serializedName: "BatchLocationQuota",
+export const BatchLocationQuota: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchLocationQuota",
     modelProperties: {
       accountQuota: {
-        readOnly: true,
         serializedName: "accountQuota",
+        readOnly: true,
         type: {
           name: "Number"
         }
@@ -917,73 +673,63 @@ export const BatchLocationQuota: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateBaseProperties: msRest.CompositeMapper = {
-  serializedName: "CertificateBaseProperties",
+export const SupportedSkusResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CertificateBaseProperties",
+    className: "SupportedSkusResult",
     modelProperties: {
-      thumbprintAlgorithm: {
-        serializedName: "thumbprintAlgorithm",
+      value: {
+        serializedName: "value",
+        required: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "SupportedSku"
+            }
+          }
         }
       },
-      thumbprint: {
-        serializedName: "thumbprint",
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
         type: {
           name: "String"
         }
-      },
-      format: {
-        nullable: false,
-        serializedName: "format",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Pfx",
-            "Cer"
-          ]
-        }
       }
     }
   }
 };
 
-export const DeleteCertificateError: msRest.CompositeMapper = {
-  serializedName: "DeleteCertificateError",
+export const SupportedSku: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DeleteCertificateError",
+    className: "SupportedSku",
     modelProperties: {
-      code: {
-        required: true,
-        serializedName: "code",
-        type: {
-          name: "String"
-        }
-      },
-      message: {
-        required: true,
-        serializedName: "message",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      target: {
-        serializedName: "target",
+      familyName: {
+        serializedName: "familyName",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      details: {
-        serializedName: "details",
+      capabilities: {
+        serializedName: "capabilities",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "DeleteCertificateError"
+              className: "SkuCapability"
             }
           }
         }
@@ -992,134 +738,122 @@ export const DeleteCertificateError: msRest.CompositeMapper = {
   }
 };
 
-export const Certificate: msRest.CompositeMapper = {
-  serializedName: "Certificate",
+export const SkuCapability: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Certificate",
+    className: "SkuCapability",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      thumbprintAlgorithm: {
-        serializedName: "properties.thumbprintAlgorithm",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      thumbprint: {
-        serializedName: "properties.thumbprint",
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
           name: "String"
         }
-      },
-      format: {
-        nullable: false,
-        serializedName: "properties.format",
+      }
+    }
+  }
+};
+
+export const OperationListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OperationListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Pfx",
-            "Cer"
-          ]
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Operation"
+            }
+          }
         }
       },
-      provisioningState: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.provisioningState",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Succeeded",
-            "Deleting",
-            "Failed"
-          ]
+          name: "String"
         }
-      },
-      provisioningStateTransitionTime: {
-        readOnly: true,
-        serializedName: "properties.provisioningStateTransitionTime",
+      }
+    }
+  }
+};
+
+export const Operation: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Operation",
+    modelProperties: {
+      name: {
+        serializedName: "name",
         type: {
-          name: "DateTime"
+          name: "String"
         }
       },
-      previousProvisioningState: {
-        nullable: false,
-        readOnly: true,
-        serializedName: "properties.previousProvisioningState",
+      isDataAction: {
+        serializedName: "isDataAction",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Succeeded",
-            "Deleting",
-            "Failed"
-          ]
+          name: "Boolean"
         }
       },
-      previousProvisioningStateTransitionTime: {
-        readOnly: true,
-        serializedName: "properties.previousProvisioningStateTransitionTime",
+      display: {
+        serializedName: "display",
         type: {
-          name: "DateTime"
+          name: "Composite",
+          className: "OperationDisplay"
         }
       },
-      publicData: {
-        readOnly: true,
-        serializedName: "properties.publicData",
+      origin: {
+        serializedName: "origin",
         type: {
           name: "String"
         }
       },
-      deleteCertificateError: {
-        readOnly: true,
-        serializedName: "properties.deleteCertificateError",
+      properties: {
+        serializedName: "properties",
         type: {
-          name: "Composite",
-          className: "DeleteCertificateError"
+          name: "Dictionary",
+          value: { type: { name: "any" } }
         }
       }
     }
   }
 };
 
-export const CertificateCreateOrUpdateParameters: msRest.CompositeMapper = {
-  serializedName: "CertificateCreateOrUpdateParameters",
+export const OperationDisplay: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CertificateCreateOrUpdateParameters",
+    className: "OperationDisplay",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      thumbprintAlgorithm: {
-        serializedName: "properties.thumbprintAlgorithm",
+      provider: {
+        serializedName: "provider",
         type: {
           name: "String"
         }
       },
-      thumbprint: {
-        serializedName: "properties.thumbprint",
+      operation: {
+        serializedName: "operation",
         type: {
           name: "String"
         }
       },
-      format: {
-        nullable: false,
-        serializedName: "properties.format",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Pfx",
-            "Cer"
-          ]
-        }
-      },
-      data: {
-        required: true,
-        serializedName: "properties.data",
+      resource: {
+        serializedName: "resource",
         type: {
           name: "String"
         }
       },
-      password: {
-        serializedName: "properties.password",
+      description: {
+        serializedName: "description",
         type: {
           name: "String"
         }
@@ -1128,63 +862,22 @@ export const CertificateCreateOrUpdateParameters: msRest.CompositeMapper = {
   }
 };
 
-export const PrivateLinkResource: msRest.CompositeMapper = {
-  serializedName: "PrivateLinkResource",
+export const CheckNameAvailabilityParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "PrivateLinkResource",
+    className: "CheckNameAvailabilityParameters",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      groupId: {
-        readOnly: true,
-        serializedName: "properties.groupId",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      requiredMembers: {
-        readOnly: true,
-        serializedName: "properties.requiredMembers",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      },
-      requiredZoneNames: {
-        readOnly: true,
-        serializedName: "properties.requiredZoneNames",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const CloudServiceConfiguration: msRest.CompositeMapper = {
-  serializedName: "CloudServiceConfiguration",
-  type: {
-    name: "Composite",
-    className: "CloudServiceConfiguration",
-    modelProperties: {
-      osFamily: {
-        required: true,
-        serializedName: "osFamily",
-        type: {
-          name: "String"
-        }
-      },
-      osVersion: {
-        serializedName: "osVersion",
+      type: {
+        defaultValue: "Microsoft.Batch/batchAccounts",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
@@ -1193,38 +886,29 @@ export const CloudServiceConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const ImageReference: msRest.CompositeMapper = {
-  serializedName: "ImageReference",
+export const CheckNameAvailabilityResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ImageReference",
+    className: "CheckNameAvailabilityResult",
     modelProperties: {
-      publisher: {
-        serializedName: "publisher",
-        type: {
-          name: "String"
-        }
-      },
-      offer: {
-        serializedName: "offer",
-        type: {
-          name: "String"
-        }
-      },
-      sku: {
-        serializedName: "sku",
+      nameAvailable: {
+        serializedName: "nameAvailable",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      version: {
-        serializedName: "version",
+      reason: {
+        serializedName: "reason",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Invalid", "AlreadyExists"]
         }
       },
-      id: {
-        serializedName: "id",
+      message: {
+        serializedName: "message",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -1233,299 +917,234 @@ export const ImageReference: msRest.CompositeMapper = {
   }
 };
 
-export const WindowsConfiguration: msRest.CompositeMapper = {
-  serializedName: "WindowsConfiguration",
+export const ListCertificatesResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "WindowsConfiguration",
+    className: "ListCertificatesResult",
     modelProperties: {
-      enableAutomaticUpdates: {
-        serializedName: "enableAutomaticUpdates",
+      value: {
+        serializedName: "value",
         type: {
-          name: "Boolean"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Certificate"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const DataDisk: msRest.CompositeMapper = {
-  serializedName: "DataDisk",
+export const DeleteCertificateError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DataDisk",
+    className: "DeleteCertificateError",
     modelProperties: {
-      lun: {
+      code: {
+        serializedName: "code",
         required: true,
-        serializedName: "lun",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      caching: {
-        serializedName: "caching",
+      message: {
+        serializedName: "message",
+        required: true,
         type: {
-          name: "Enum",
-          allowedValues: [
-            "None",
-            "ReadOnly",
-            "ReadWrite"
-          ]
+          name: "String"
         }
       },
-      diskSizeGB: {
-        required: true,
-        serializedName: "diskSizeGB",
+      target: {
+        serializedName: "target",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      storageAccountType: {
-        serializedName: "storageAccountType",
+      details: {
+        serializedName: "details",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Standard_LRS",
-            "Premium_LRS"
-          ]
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DeleteCertificateError"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const ContainerRegistry: msRest.CompositeMapper = {
-  serializedName: "ContainerRegistry",
+export const CertificateBaseProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ContainerRegistry",
+    className: "CertificateBaseProperties",
     modelProperties: {
-      userName: {
-        serializedName: "username",
-        type: {
-          name: "String"
-        }
-      },
-      password: {
-        serializedName: "password",
+      thumbprintAlgorithm: {
+        serializedName: "thumbprintAlgorithm",
         type: {
           name: "String"
         }
       },
-      registryServer: {
-        serializedName: "registryServer",
+      thumbprint: {
+        serializedName: "thumbprint",
         type: {
           name: "String"
         }
       },
-      identityReference: {
-        serializedName: "identityReference",
+      format: {
+        serializedName: "format",
         type: {
-          name: "Composite",
-          className: "ComputeNodeIdentityReference"
+          name: "Enum",
+          allowedValues: ["Pfx", "Cer"]
         }
       }
     }
   }
 };
 
-export const ContainerConfiguration: msRest.CompositeMapper = {
-  serializedName: "ContainerConfiguration",
+export const ListPrivateLinkResourcesResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ContainerConfiguration",
+    className: "ListPrivateLinkResourcesResult",
     modelProperties: {
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: 'DockerCompatible',
-        type: {
-          name: "String"
-        }
-      },
-      containerImageNames: {
-        serializedName: "containerImageNames",
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "PrivateLinkResource"
             }
           }
         }
       },
-      containerRegistries: {
-        serializedName: "containerRegistries",
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const ListPrivateEndpointConnectionsResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ListPrivateEndpointConnectionsResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "ContainerRegistry"
+              className: "PrivateEndpointConnection"
             }
           }
         }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
+        }
       }
     }
   }
 };
 
-export const DiskEncryptionConfiguration: msRest.CompositeMapper = {
-  serializedName: "DiskEncryptionConfiguration",
+export const ListPoolsResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DiskEncryptionConfiguration",
+    className: "ListPoolsResult",
     modelProperties: {
-      targets: {
-        serializedName: "targets",
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Enum",
-              allowedValues: [
-                "OsDisk",
-                "TemporaryDisk"
-              ]
+              name: "Composite",
+              className: "Pool"
             }
           }
         }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
+        }
       }
     }
   }
 };
 
-export const NodePlacementConfiguration: msRest.CompositeMapper = {
-  serializedName: "NodePlacementConfiguration",
+export const DeploymentConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "NodePlacementConfiguration",
+    className: "DeploymentConfiguration",
     modelProperties: {
-      policy: {
-        serializedName: "policy",
+      cloudServiceConfiguration: {
+        serializedName: "cloudServiceConfiguration",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Regional",
-            "Zonal"
-          ]
+          name: "Composite",
+          className: "CloudServiceConfiguration"
+        }
+      },
+      virtualMachineConfiguration: {
+        serializedName: "virtualMachineConfiguration",
+        type: {
+          name: "Composite",
+          className: "VirtualMachineConfiguration"
         }
       }
     }
   }
 };
 
-export const VMExtension: msRest.CompositeMapper = {
-  serializedName: "VMExtension",
+export const CloudServiceConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "VMExtension",
+    className: "CloudServiceConfiguration",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      publisher: {
+      osFamily: {
+        serializedName: "osFamily",
         required: true,
-        serializedName: "publisher",
         type: {
           name: "String"
         }
       },
-      type: {
-        required: true,
-        serializedName: "type",
+      osVersion: {
+        serializedName: "osVersion",
         type: {
           name: "String"
         }
-      },
-      typeHandlerVersion: {
-        serializedName: "typeHandlerVersion",
-        type: {
-          name: "String"
-        }
-      },
-      autoUpgradeMinorVersion: {
-        serializedName: "autoUpgradeMinorVersion",
-        type: {
-          name: "Boolean"
-        }
-      },
-      settings: {
-        serializedName: "settings",
-        type: {
-          name: "Object"
-        }
-      },
-      protectedSettings: {
-        serializedName: "protectedSettings",
-        type: {
-          name: "Object"
-        }
-      },
-      provisionAfterExtensions: {
-        serializedName: "provisionAfterExtensions",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const DiffDiskSettings: msRest.CompositeMapper = {
-  serializedName: "DiffDiskSettings",
-  type: {
-    name: "Composite",
-    className: "DiffDiskSettings",
-    modelProperties: {
-      placement: {
-        serializedName: "placement",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "CacheDisk"
-          ]
-        }
-      }
-    }
-  }
-};
-
-export const OSDisk: msRest.CompositeMapper = {
-  serializedName: "OSDisk",
-  type: {
-    name: "Composite",
-    className: "OSDisk",
-    modelProperties: {
-      ephemeralOSDiskSettings: {
-        serializedName: "ephemeralOSDiskSettings",
-        type: {
-          name: "Composite",
-          className: "DiffDiskSettings"
-        }
       }
     }
   }
 };
 
-export const VirtualMachineConfiguration: msRest.CompositeMapper = {
-  serializedName: "VirtualMachineConfiguration",
+export const VirtualMachineConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "VirtualMachineConfiguration",
     modelProperties: {
       imageReference: {
-        required: true,
         serializedName: "imageReference",
         type: {
           name: "Composite",
@@ -1533,8 +1152,8 @@ export const VirtualMachineConfiguration: msRest.CompositeMapper = {
         }
       },
       nodeAgentSkuId: {
-        required: true,
         serializedName: "nodeAgentSkuId",
+        required: true,
         type: {
           name: "String"
         }
@@ -1608,145 +1227,129 @@ export const VirtualMachineConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const DeploymentConfiguration: msRest.CompositeMapper = {
-  serializedName: "DeploymentConfiguration",
+export const ImageReference: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DeploymentConfiguration",
+    className: "ImageReference",
     modelProperties: {
-      cloudServiceConfiguration: {
-        serializedName: "cloudServiceConfiguration",
+      publisher: {
+        serializedName: "publisher",
         type: {
-          name: "Composite",
-          className: "CloudServiceConfiguration"
+          name: "String"
         }
       },
-      virtualMachineConfiguration: {
-        serializedName: "virtualMachineConfiguration",
-        type: {
-          name: "Composite",
-          className: "VirtualMachineConfiguration"
-        }
-      }
-    }
-  }
-};
-
-export const FixedScaleSettings: msRest.CompositeMapper = {
-  serializedName: "FixedScaleSettings",
-  type: {
-    name: "Composite",
-    className: "FixedScaleSettings",
-    modelProperties: {
-      resizeTimeout: {
-        serializedName: "resizeTimeout",
+      offer: {
+        serializedName: "offer",
         type: {
-          name: "TimeSpan"
+          name: "String"
         }
       },
-      targetDedicatedNodes: {
-        serializedName: "targetDedicatedNodes",
+      sku: {
+        serializedName: "sku",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      targetLowPriorityNodes: {
-        serializedName: "targetLowPriorityNodes",
+      version: {
+        serializedName: "version",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      nodeDeallocationOption: {
-        serializedName: "nodeDeallocationOption",
+      id: {
+        serializedName: "id",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Requeue",
-            "Terminate",
-            "TaskCompletion",
-            "RetainedData"
-          ]
+          name: "String"
         }
       }
     }
   }
 };
 
-export const AutoScaleSettings: msRest.CompositeMapper = {
-  serializedName: "AutoScaleSettings",
+export const WindowsConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AutoScaleSettings",
+    className: "WindowsConfiguration",
     modelProperties: {
-      formula: {
-        required: true,
-        serializedName: "formula",
-        type: {
-          name: "String"
-        }
-      },
-      evaluationInterval: {
-        serializedName: "evaluationInterval",
+      enableAutomaticUpdates: {
+        serializedName: "enableAutomaticUpdates",
         type: {
-          name: "TimeSpan"
+          name: "Boolean"
         }
       }
     }
   }
 };
 
-export const ScaleSettings: msRest.CompositeMapper = {
-  serializedName: "ScaleSettings",
+export const DataDisk: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ScaleSettings",
+    className: "DataDisk",
     modelProperties: {
-      fixedScale: {
-        serializedName: "fixedScale",
+      lun: {
+        serializedName: "lun",
+        required: true,
         type: {
-          name: "Composite",
-          className: "FixedScaleSettings"
+          name: "Number"
         }
       },
-      autoScale: {
-        serializedName: "autoScale",
+      caching: {
+        serializedName: "caching",
         type: {
-          name: "Composite",
-          className: "AutoScaleSettings"
+          name: "Enum",
+          allowedValues: ["None", "ReadOnly", "ReadWrite"]
+        }
+      },
+      diskSizeGB: {
+        serializedName: "diskSizeGB",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      storageAccountType: {
+        serializedName: "storageAccountType",
+        type: {
+          name: "Enum",
+          allowedValues: ["Standard_LRS", "Premium_LRS"]
         }
       }
     }
   }
 };
 
-export const AutoScaleRunError: msRest.CompositeMapper = {
-  serializedName: "AutoScaleRunError",
+export const ContainerConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AutoScaleRunError",
+    className: "ContainerConfiguration",
     modelProperties: {
-      code: {
-        required: true,
-        serializedName: "code",
+      type: {
+        defaultValue: "DockerCompatible",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
       },
-      message: {
-        required: true,
-        serializedName: "message",
+      containerImageNames: {
+        serializedName: "containerImageNames",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      details: {
-        serializedName: "details",
+      containerRegistries: {
+        serializedName: "containerRegistries",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "AutoScaleRunError"
+              className: "ContainerRegistry"
             }
           }
         }
@@ -1755,74 +1358,53 @@ export const AutoScaleRunError: msRest.CompositeMapper = {
   }
 };
 
-export const AutoScaleRun: msRest.CompositeMapper = {
-  serializedName: "AutoScaleRun",
+export const ContainerRegistry: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AutoScaleRun",
+    className: "ContainerRegistry",
     modelProperties: {
-      evaluationTime: {
-        required: true,
-        serializedName: "evaluationTime",
+      userName: {
+        serializedName: "username",
         type: {
-          name: "DateTime"
+          name: "String"
         }
       },
-      results: {
-        serializedName: "results",
+      password: {
+        serializedName: "password",
         type: {
           name: "String"
         }
       },
-      error: {
-        serializedName: "error",
+      registryServer: {
+        serializedName: "registryServer",
+        type: {
+          name: "String"
+        }
+      },
+      identityReference: {
+        serializedName: "identityReference",
         type: {
           name: "Composite",
-          className: "AutoScaleRunError"
+          className: "ComputeNodeIdentityReference"
         }
       }
     }
   }
 };
 
-export const NetworkSecurityGroupRule: msRest.CompositeMapper = {
-  serializedName: "NetworkSecurityGroupRule",
+export const DiskEncryptionConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "NetworkSecurityGroupRule",
+    className: "DiskEncryptionConfiguration",
     modelProperties: {
-      priority: {
-        required: true,
-        serializedName: "priority",
-        type: {
-          name: "Number"
-        }
-      },
-      access: {
-        required: true,
-        serializedName: "access",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Allow",
-            "Deny"
-          ]
-        }
-      },
-      sourceAddressPrefix: {
-        required: true,
-        serializedName: "sourceAddressPrefix",
-        type: {
-          name: "String"
-        }
-      },
-      sourcePortRanges: {
-        serializedName: "sourcePortRanges",
+      targets: {
+        serializedName: "targets",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Enum",
+              allowedValues: ["OsDisk", "TemporaryDisk"]
             }
           }
         }
@@ -1831,59 +1413,81 @@ export const NetworkSecurityGroupRule: msRest.CompositeMapper = {
   }
 };
 
-export const InboundNatPool: msRest.CompositeMapper = {
-  serializedName: "InboundNatPool",
+export const NodePlacementConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "InboundNatPool",
+    className: "NodePlacementConfiguration",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      policy: {
+        serializedName: "policy",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Regional", "Zonal"]
         }
-      },
-      protocol: {
-        required: true,
-        serializedName: "protocol",
+      }
+    }
+  }
+};
+
+export const VMExtension: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "VMExtension",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "Enum",
-          allowedValues: [
-            "TCP",
-            "UDP"
-          ]
+          name: "String"
         }
       },
-      backendPort: {
+      publisher: {
+        serializedName: "publisher",
         required: true,
-        serializedName: "backendPort",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      frontendPortRangeStart: {
+      type: {
+        serializedName: "type",
         required: true,
-        serializedName: "frontendPortRangeStart",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      frontendPortRangeEnd: {
-        required: true,
-        serializedName: "frontendPortRangeEnd",
+      typeHandlerVersion: {
+        serializedName: "typeHandlerVersion",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      networkSecurityGroupRules: {
-        serializedName: "networkSecurityGroupRules",
+      autoUpgradeMinorVersion: {
+        serializedName: "autoUpgradeMinorVersion",
+        type: {
+          name: "Boolean"
+        }
+      },
+      settings: {
+        serializedName: "settings",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "any" } }
+        }
+      },
+      protectedSettings: {
+        serializedName: "protectedSettings",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "any" } }
+        }
+      },
+      provisionAfterExtensions: {
+        serializedName: "provisionAfterExtensions",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "NetworkSecurityGroupRule"
+              name: "String"
             }
           }
         }
@@ -1892,403 +1496,492 @@ export const InboundNatPool: msRest.CompositeMapper = {
   }
 };
 
-export const PoolEndpointConfiguration: msRest.CompositeMapper = {
-  serializedName: "PoolEndpointConfiguration",
+export const OSDisk: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "PoolEndpointConfiguration",
+    className: "OSDisk",
     modelProperties: {
-      inboundNatPools: {
-        required: true,
-        serializedName: "inboundNatPools",
+      ephemeralOSDiskSettings: {
+        serializedName: "ephemeralOSDiskSettings",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "InboundNatPool"
-            }
-          }
+          name: "Composite",
+          className: "DiffDiskSettings"
         }
       }
     }
   }
 };
 
-export const PublicIPAddressConfiguration: msRest.CompositeMapper = {
-  serializedName: "PublicIPAddressConfiguration",
+export const DiffDiskSettings: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "PublicIPAddressConfiguration",
+    className: "DiffDiskSettings",
     modelProperties: {
-      provision: {
-        serializedName: "provision",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "BatchManaged",
-            "UserManaged",
-            "NoPublicIPAddresses"
-          ]
-        }
-      },
-      ipAddressIds: {
-        serializedName: "ipAddressIds",
+      placement: {
+        defaultValue: "CacheDisk",
+        isConstant: true,
+        serializedName: "placement",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const NetworkConfiguration: msRest.CompositeMapper = {
-  serializedName: "NetworkConfiguration",
+export const ScaleSettings: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "NetworkConfiguration",
+    className: "ScaleSettings",
     modelProperties: {
-      subnetId: {
-        serializedName: "subnetId",
-        type: {
-          name: "String"
-        }
-      },
-      endpointConfiguration: {
-        serializedName: "endpointConfiguration",
+      fixedScale: {
+        serializedName: "fixedScale",
         type: {
           name: "Composite",
-          className: "PoolEndpointConfiguration"
+          className: "FixedScaleSettings"
         }
       },
-      publicIPAddressConfiguration: {
-        serializedName: "publicIPAddressConfiguration",
+      autoScale: {
+        serializedName: "autoScale",
         type: {
           name: "Composite",
-          className: "PublicIPAddressConfiguration"
+          className: "AutoScaleSettings"
         }
       }
     }
   }
 };
 
-export const TaskSchedulingPolicy: msRest.CompositeMapper = {
-  serializedName: "TaskSchedulingPolicy",
+export const FixedScaleSettings: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "TaskSchedulingPolicy",
+    className: "FixedScaleSettings",
     modelProperties: {
-      nodeFillType: {
-        required: true,
-        serializedName: "nodeFillType",
+      resizeTimeout: {
+        serializedName: "resizeTimeout",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Spread",
-            "Pack"
-          ]
+          name: "TimeSpan"
         }
-      }
-    }
-  }
-};
-
-export const LinuxUserConfiguration: msRest.CompositeMapper = {
-  serializedName: "LinuxUserConfiguration",
-  type: {
-    name: "Composite",
-    className: "LinuxUserConfiguration",
-    modelProperties: {
-      uid: {
-        serializedName: "uid",
+      },
+      targetDedicatedNodes: {
+        serializedName: "targetDedicatedNodes",
         type: {
           name: "Number"
         }
       },
-      gid: {
-        serializedName: "gid",
+      targetLowPriorityNodes: {
+        serializedName: "targetLowPriorityNodes",
         type: {
           name: "Number"
         }
       },
-      sshPrivateKey: {
-        serializedName: "sshPrivateKey",
+      nodeDeallocationOption: {
+        serializedName: "nodeDeallocationOption",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: [
+            "Requeue",
+            "Terminate",
+            "TaskCompletion",
+            "RetainedData"
+          ]
         }
       }
     }
   }
 };
 
-export const WindowsUserConfiguration: msRest.CompositeMapper = {
-  serializedName: "WindowsUserConfiguration",
+export const AutoScaleSettings: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "WindowsUserConfiguration",
+    className: "AutoScaleSettings",
     modelProperties: {
-      loginMode: {
-        serializedName: "loginMode",
+      formula: {
+        serializedName: "formula",
+        required: true,
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Batch",
-            "Interactive"
-          ]
+          name: "String"
+        }
+      },
+      evaluationInterval: {
+        serializedName: "evaluationInterval",
+        type: {
+          name: "TimeSpan"
         }
       }
     }
   }
 };
 
-export const UserAccount: msRest.CompositeMapper = {
-  serializedName: "UserAccount",
+export const AutoScaleRun: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "UserAccount",
+    className: "AutoScaleRun",
     modelProperties: {
-      name: {
+      evaluationTime: {
+        serializedName: "evaluationTime",
         required: true,
-        serializedName: "name",
         type: {
-          name: "String"
+          name: "DateTime"
         }
       },
-      password: {
-        required: true,
-        serializedName: "password",
+      results: {
+        serializedName: "results",
         type: {
           name: "String"
         }
       },
-      elevationLevel: {
-        serializedName: "elevationLevel",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "NonAdmin",
-            "Admin"
-          ]
-        }
-      },
-      linuxUserConfiguration: {
-        serializedName: "linuxUserConfiguration",
-        type: {
-          name: "Composite",
-          className: "LinuxUserConfiguration"
-        }
-      },
-      windowsUserConfiguration: {
-        serializedName: "windowsUserConfiguration",
+      error: {
+        serializedName: "error",
         type: {
           name: "Composite",
-          className: "WindowsUserConfiguration"
+          className: "AutoScaleRunError"
         }
       }
     }
   }
 };
 
-export const MetadataItem: msRest.CompositeMapper = {
-  serializedName: "MetadataItem",
+export const AutoScaleRunError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "MetadataItem",
+    className: "AutoScaleRunError",
     modelProperties: {
-      name: {
+      code: {
+        serializedName: "code",
         required: true,
-        serializedName: "name",
         type: {
           name: "String"
         }
       },
-      value: {
+      message: {
+        serializedName: "message",
         required: true,
-        serializedName: "value",
         type: {
           name: "String"
         }
+      },
+      details: {
+        serializedName: "details",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "AutoScaleRunError"
+            }
+          }
+        }
       }
     }
   }
 };
 
-export const ResourceFile: msRest.CompositeMapper = {
-  serializedName: "ResourceFile",
+export const NetworkConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ResourceFile",
+    className: "NetworkConfiguration",
     modelProperties: {
-      autoStorageContainerName: {
-        serializedName: "autoStorageContainerName",
+      subnetId: {
+        serializedName: "subnetId",
         type: {
           name: "String"
         }
       },
-      storageContainerUrl: {
-        serializedName: "storageContainerUrl",
+      endpointConfiguration: {
+        serializedName: "endpointConfiguration",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "PoolEndpointConfiguration"
         }
       },
-      httpUrl: {
-        serializedName: "httpUrl",
+      publicIPAddressConfiguration: {
+        serializedName: "publicIPAddressConfiguration",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "PublicIPAddressConfiguration"
         }
-      },
-      blobPrefix: {
-        serializedName: "blobPrefix",
+      }
+    }
+  }
+};
+
+export const PoolEndpointConfiguration: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PoolEndpointConfiguration",
+    modelProperties: {
+      inboundNatPools: {
+        serializedName: "inboundNatPools",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "InboundNatPool"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const InboundNatPool: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "InboundNatPool",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      filePath: {
-        serializedName: "filePath",
+      protocol: {
+        serializedName: "protocol",
+        required: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["TCP", "UDP"]
         }
       },
-      fileMode: {
-        serializedName: "fileMode",
+      backendPort: {
+        serializedName: "backendPort",
+        required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      identityReference: {
-        serializedName: "identityReference",
+      frontendPortRangeStart: {
+        serializedName: "frontendPortRangeStart",
+        required: true,
         type: {
-          name: "Composite",
-          className: "ComputeNodeIdentityReference"
+          name: "Number"
+        }
+      },
+      frontendPortRangeEnd: {
+        serializedName: "frontendPortRangeEnd",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      networkSecurityGroupRules: {
+        serializedName: "networkSecurityGroupRules",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "NetworkSecurityGroupRule"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const EnvironmentSetting: msRest.CompositeMapper = {
-  serializedName: "EnvironmentSetting",
+export const NetworkSecurityGroupRule: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "EnvironmentSetting",
+    className: "NetworkSecurityGroupRule",
     modelProperties: {
-      name: {
+      priority: {
+        serializedName: "priority",
         required: true,
-        serializedName: "name",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      value: {
-        serializedName: "value",
+      access: {
+        serializedName: "access",
+        required: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["Allow", "Deny"]
+        }
+      },
+      sourceAddressPrefix: {
+        serializedName: "sourceAddressPrefix",
+        required: true,
         type: {
           name: "String"
         }
+      },
+      sourcePortRanges: {
+        serializedName: "sourcePortRanges",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
+        }
       }
     }
   }
 };
 
-export const AutoUserSpecification: msRest.CompositeMapper = {
-  serializedName: "AutoUserSpecification",
+export const PublicIPAddressConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AutoUserSpecification",
+    className: "PublicIPAddressConfiguration",
     modelProperties: {
-      scope: {
-        serializedName: "scope",
+      provision: {
+        serializedName: "provision",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Task",
-            "Pool"
-          ]
+          allowedValues: ["BatchManaged", "UserManaged", "NoPublicIPAddresses"]
         }
       },
-      elevationLevel: {
-        serializedName: "elevationLevel",
+      ipAddressIds: {
+        serializedName: "ipAddressIds",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const TaskSchedulingPolicy: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "TaskSchedulingPolicy",
+    modelProperties: {
+      nodeFillType: {
+        serializedName: "nodeFillType",
+        required: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "NonAdmin",
-            "Admin"
-          ]
+          allowedValues: ["Spread", "Pack"]
         }
       }
     }
   }
 };
 
-export const UserIdentity: msRest.CompositeMapper = {
-  serializedName: "UserIdentity",
+export const UserAccount: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "UserIdentity",
+    className: "UserAccount",
     modelProperties: {
-      userName: {
-        serializedName: "userName",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      autoUser: {
-        serializedName: "autoUser",
+      password: {
+        serializedName: "password",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      elevationLevel: {
+        serializedName: "elevationLevel",
+        type: {
+          name: "Enum",
+          allowedValues: ["NonAdmin", "Admin"]
+        }
+      },
+      linuxUserConfiguration: {
+        serializedName: "linuxUserConfiguration",
         type: {
           name: "Composite",
-          className: "AutoUserSpecification"
+          className: "LinuxUserConfiguration"
+        }
+      },
+      windowsUserConfiguration: {
+        serializedName: "windowsUserConfiguration",
+        type: {
+          name: "Composite",
+          className: "WindowsUserConfiguration"
         }
       }
     }
   }
 };
 
-export const TaskContainerSettings: msRest.CompositeMapper = {
-  serializedName: "TaskContainerSettings",
+export const LinuxUserConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "TaskContainerSettings",
+    className: "LinuxUserConfiguration",
     modelProperties: {
-      containerRunOptions: {
-        serializedName: "containerRunOptions",
+      uid: {
+        serializedName: "uid",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      imageName: {
-        required: true,
-        serializedName: "imageName",
+      gid: {
+        serializedName: "gid",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      registry: {
-        serializedName: "registry",
+      sshPrivateKey: {
+        serializedName: "sshPrivateKey",
         type: {
-          name: "Composite",
-          className: "ContainerRegistry"
+          name: "String"
         }
-      },
-      workingDirectory: {
-        serializedName: "workingDirectory",
+      }
+    }
+  }
+};
+
+export const WindowsUserConfiguration: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "WindowsUserConfiguration",
+    modelProperties: {
+      loginMode: {
+        serializedName: "loginMode",
         type: {
           name: "Enum",
-          allowedValues: [
-            "TaskWorkingDirectory",
-            "ContainerImageDefault"
-          ]
+          allowedValues: ["Batch", "Interactive"]
+        }
+      }
+    }
+  }
+};
+
+export const MetadataItem: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "MetadataItem",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      value: {
+        serializedName: "value",
+        required: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const StartTask: msRest.CompositeMapper = {
-  serializedName: "StartTask",
+export const StartTask: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "StartTask",
@@ -2353,70 +2046,72 @@ export const StartTask: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateReference: msRest.CompositeMapper = {
-  serializedName: "CertificateReference",
+export const ResourceFile: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CertificateReference",
+    className: "ResourceFile",
     modelProperties: {
-      id: {
-        required: true,
-        serializedName: "id",
+      autoStorageContainerName: {
+        serializedName: "autoStorageContainerName",
         type: {
           name: "String"
         }
       },
-      storeLocation: {
-        serializedName: "storeLocation",
+      storageContainerUrl: {
+        serializedName: "storageContainerUrl",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "CurrentUser",
-            "LocalMachine"
-          ]
+          name: "String"
         }
       },
-      storeName: {
-        serializedName: "storeName",
+      httpUrl: {
+        serializedName: "httpUrl",
         type: {
           name: "String"
         }
       },
-      visibility: {
-        serializedName: "visibility",
+      blobPrefix: {
+        serializedName: "blobPrefix",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Enum",
-              allowedValues: [
-                "StartTask",
-                "Task",
-                "RemoteUser"
-              ]
-            }
-          }
+          name: "String"
+        }
+      },
+      filePath: {
+        serializedName: "filePath",
+        type: {
+          name: "String"
+        }
+      },
+      fileMode: {
+        serializedName: "fileMode",
+        type: {
+          name: "String"
+        }
+      },
+      identityReference: {
+        serializedName: "identityReference",
+        type: {
+          name: "Composite",
+          className: "ComputeNodeIdentityReference"
         }
       }
     }
   }
 };
 
-export const ApplicationPackageReference: msRest.CompositeMapper = {
-  serializedName: "ApplicationPackageReference",
+export const EnvironmentSetting: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ApplicationPackageReference",
+    className: "EnvironmentSetting",
     modelProperties: {
-      id: {
+      name: {
+        serializedName: "name",
         required: true,
-        serializedName: "id",
         type: {
           name: "String"
         }
       },
-      version: {
-        serializedName: "version",
+      value: {
+        serializedName: "value",
         type: {
           name: "String"
         }
@@ -2425,34 +2120,120 @@ export const ApplicationPackageReference: msRest.CompositeMapper = {
   }
 };
 
-export const ResizeError: msRest.CompositeMapper = {
-  serializedName: "ResizeError",
+export const UserIdentity: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ResizeError",
+    className: "UserIdentity",
     modelProperties: {
-      code: {
+      userName: {
+        serializedName: "userName",
+        type: {
+          name: "String"
+        }
+      },
+      autoUser: {
+        serializedName: "autoUser",
+        type: {
+          name: "Composite",
+          className: "AutoUserSpecification"
+        }
+      }
+    }
+  }
+};
+
+export const AutoUserSpecification: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AutoUserSpecification",
+    modelProperties: {
+      scope: {
+        serializedName: "scope",
+        type: {
+          name: "Enum",
+          allowedValues: ["Task", "Pool"]
+        }
+      },
+      elevationLevel: {
+        serializedName: "elevationLevel",
+        type: {
+          name: "Enum",
+          allowedValues: ["NonAdmin", "Admin"]
+        }
+      }
+    }
+  }
+};
+
+export const TaskContainerSettings: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "TaskContainerSettings",
+    modelProperties: {
+      containerRunOptions: {
+        serializedName: "containerRunOptions",
+        type: {
+          name: "String"
+        }
+      },
+      imageName: {
+        serializedName: "imageName",
         required: true,
-        serializedName: "code",
         type: {
           name: "String"
         }
       },
-      message: {
+      registry: {
+        serializedName: "registry",
+        type: {
+          name: "Composite",
+          className: "ContainerRegistry"
+        }
+      },
+      workingDirectory: {
+        serializedName: "workingDirectory",
+        type: {
+          name: "Enum",
+          allowedValues: ["TaskWorkingDirectory", "ContainerImageDefault"]
+        }
+      }
+    }
+  }
+};
+
+export const CertificateReference: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "CertificateReference",
+    modelProperties: {
+      id: {
+        serializedName: "id",
         required: true,
-        serializedName: "message",
         type: {
           name: "String"
         }
       },
-      details: {
-        serializedName: "details",
+      storeLocation: {
+        serializedName: "storeLocation",
+        type: {
+          name: "Enum",
+          allowedValues: ["CurrentUser", "LocalMachine"]
+        }
+      },
+      storeName: {
+        serializedName: "storeName",
+        type: {
+          name: "String"
+        }
+      },
+      visibility: {
+        serializedName: "visibility",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "ResizeError"
+              name: "Enum",
+              allowedValues: ["StartTask", "Task", "RemoteUser"]
             }
           }
         }
@@ -2461,8 +2242,29 @@ export const ResizeError: msRest.CompositeMapper = {
   }
 };
 
-export const ResizeOperationStatus: msRest.CompositeMapper = {
-  serializedName: "ResizeOperationStatus",
+export const ApplicationPackageReference: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ApplicationPackageReference",
+    modelProperties: {
+      id: {
+        serializedName: "id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      version: {
+        serializedName: "version",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const ResizeOperationStatus: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "ResizeOperationStatus",
@@ -2519,22 +2321,93 @@ export const ResizeOperationStatus: msRest.CompositeMapper = {
   }
 };
 
-export const AzureBlobFileSystemConfiguration: msRest.CompositeMapper = {
-  serializedName: "AzureBlobFileSystemConfiguration",
+export const ResizeError: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ResizeError",
+    modelProperties: {
+      code: {
+        serializedName: "code",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      message: {
+        serializedName: "message",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      details: {
+        serializedName: "details",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ResizeError"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const MountConfiguration: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "MountConfiguration",
+    modelProperties: {
+      azureBlobFileSystemConfiguration: {
+        serializedName: "azureBlobFileSystemConfiguration",
+        type: {
+          name: "Composite",
+          className: "AzureBlobFileSystemConfiguration"
+        }
+      },
+      nfsMountConfiguration: {
+        serializedName: "nfsMountConfiguration",
+        type: {
+          name: "Composite",
+          className: "NFSMountConfiguration"
+        }
+      },
+      cifsMountConfiguration: {
+        serializedName: "cifsMountConfiguration",
+        type: {
+          name: "Composite",
+          className: "CifsMountConfiguration"
+        }
+      },
+      azureFileShareConfiguration: {
+        serializedName: "azureFileShareConfiguration",
+        type: {
+          name: "Composite",
+          className: "AzureFileShareConfiguration"
+        }
+      }
+    }
+  }
+};
+
+export const AzureBlobFileSystemConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "AzureBlobFileSystemConfiguration",
     modelProperties: {
       accountName: {
-        required: true,
         serializedName: "accountName",
+        required: true,
         type: {
           name: "String"
         }
       },
       containerName: {
-        required: true,
         serializedName: "containerName",
+        required: true,
         type: {
           name: "String"
         }
@@ -2558,8 +2431,8 @@ export const AzureBlobFileSystemConfiguration: msRest.CompositeMapper = {
         }
       },
       relativeMountPath: {
-        required: true,
         serializedName: "relativeMountPath",
+        required: true,
         type: {
           name: "String"
         }
@@ -2575,22 +2448,21 @@ export const AzureBlobFileSystemConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const NFSMountConfiguration: msRest.CompositeMapper = {
-  serializedName: "NFSMountConfiguration",
+export const NFSMountConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "NFSMountConfiguration",
     modelProperties: {
       source: {
-        required: true,
         serializedName: "source",
+        required: true,
         type: {
           name: "String"
         }
       },
       relativeMountPath: {
-        required: true,
         serializedName: "relativeMountPath",
+        required: true,
         type: {
           name: "String"
         }
@@ -2605,29 +2477,28 @@ export const NFSMountConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const CIFSMountConfiguration: msRest.CompositeMapper = {
-  serializedName: "CIFSMountConfiguration",
+export const CifsMountConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CIFSMountConfiguration",
+    className: "CifsMountConfiguration",
     modelProperties: {
       username: {
-        required: true,
         serializedName: "username",
+        required: true,
         type: {
           name: "String"
         }
       },
       source: {
-        required: true,
         serializedName: "source",
+        required: true,
         type: {
           name: "String"
         }
       },
       relativeMountPath: {
-        required: true,
         serializedName: "relativeMountPath",
+        required: true,
         type: {
           name: "String"
         }
@@ -2639,8 +2510,8 @@ export const CIFSMountConfiguration: msRest.CompositeMapper = {
         }
       },
       password: {
-        required: true,
         serializedName: "password",
+        required: true,
         type: {
           name: "String"
         }
@@ -2649,36 +2520,35 @@ export const CIFSMountConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const AzureFileShareConfiguration: msRest.CompositeMapper = {
-  serializedName: "AzureFileShareConfiguration",
+export const AzureFileShareConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "AzureFileShareConfiguration",
     modelProperties: {
       accountName: {
-        required: true,
         serializedName: "accountName",
+        required: true,
         type: {
           name: "String"
         }
       },
       azureFileUrl: {
-        required: true,
         serializedName: "azureFileUrl",
+        required: true,
         type: {
           name: "String"
         }
       },
       accountKey: {
-        required: true,
         serializedName: "accountKey",
+        required: true,
         type: {
           name: "String"
         }
       },
       relativeMountPath: {
-        required: true,
         serializedName: "relativeMountPath",
+        required: true,
         type: {
           name: "String"
         }
@@ -2693,69 +2563,411 @@ export const AzureFileShareConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const MountConfiguration: msRest.CompositeMapper = {
-  serializedName: "MountConfiguration",
+export const BatchPoolIdentity: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "MountConfiguration",
+    className: "BatchPoolIdentity",
     modelProperties: {
-      azureBlobFileSystemConfiguration: {
-        serializedName: "azureBlobFileSystemConfiguration",
+      type: {
+        serializedName: "type",
+        required: true,
         type: {
-          name: "Composite",
-          className: "AzureBlobFileSystemConfiguration"
+          name: "Enum",
+          allowedValues: ["UserAssigned", "None"]
         }
       },
-      nfsMountConfiguration: {
-        serializedName: "nfsMountConfiguration",
+      userAssignedIdentities: {
+        serializedName: "userAssignedIdentities",
+        type: {
+          name: "Dictionary",
+          value: {
+            type: { name: "Composite", className: "UserAssignedIdentities" }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const OutboundEnvironmentEndpointCollection: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OutboundEnvironmentEndpointCollection",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "OutboundEnvironmentEndpoint"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const OutboundEnvironmentEndpoint: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OutboundEnvironmentEndpoint",
+    modelProperties: {
+      category: {
+        serializedName: "category",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      endpoints: {
+        serializedName: "endpoints",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "EndpointDependency"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const EndpointDependency: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "EndpointDependency",
+    modelProperties: {
+      domainName: {
+        serializedName: "domainName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      description: {
+        serializedName: "description",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      endpointDetails: {
+        serializedName: "endpointDetails",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "EndpointDetail"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const EndpointDetail: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "EndpointDetail",
+    modelProperties: {
+      port: {
+        serializedName: "port",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const AutoStorageProperties: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AutoStorageProperties",
+    modelProperties: {
+      ...AutoStorageBaseProperties.type.modelProperties,
+      lastKeySync: {
+        serializedName: "lastKeySync",
+        required: true,
+        type: {
+          name: "DateTime"
+        }
+      }
+    }
+  }
+};
+
+export const PrivateEndpointConnection: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateEndpointConnection",
+    modelProperties: {
+      ...ProxyResource.type.modelProperties,
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["Succeeded", "Updating", "Failed"]
+        }
+      },
+      privateEndpoint: {
+        serializedName: "properties.privateEndpoint",
         type: {
           name: "Composite",
-          className: "NFSMountConfiguration"
+          className: "PrivateEndpoint"
         }
       },
-      cifsMountConfiguration: {
-        serializedName: "cifsMountConfiguration",
+      privateLinkServiceConnectionState: {
+        serializedName: "properties.privateLinkServiceConnectionState",
         type: {
           name: "Composite",
-          className: "CIFSMountConfiguration"
+          className: "PrivateLinkServiceConnectionState"
+        }
+      }
+    }
+  }
+};
+
+export const ApplicationPackage: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ApplicationPackage",
+    modelProperties: {
+      ...ProxyResource.type.modelProperties,
+      state: {
+        serializedName: "properties.state",
+        readOnly: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["Pending", "Active"]
         }
       },
-      azureFileShareConfiguration: {
-        serializedName: "azureFileShareConfiguration",
+      format: {
+        serializedName: "properties.format",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      storageUrl: {
+        serializedName: "properties.storageUrl",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      storageUrlExpiry: {
+        serializedName: "properties.storageUrlExpiry",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      lastActivationTime: {
+        serializedName: "properties.lastActivationTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      }
+    }
+  }
+};
+
+export const Application: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Application",
+    modelProperties: {
+      ...ProxyResource.type.modelProperties,
+      displayName: {
+        serializedName: "properties.displayName",
+        type: {
+          name: "String"
+        }
+      },
+      allowUpdates: {
+        serializedName: "properties.allowUpdates",
+        type: {
+          name: "Boolean"
+        }
+      },
+      defaultVersion: {
+        serializedName: "properties.defaultVersion",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const Certificate: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Certificate",
+    modelProperties: {
+      ...ProxyResource.type.modelProperties,
+      thumbprintAlgorithm: {
+        serializedName: "properties.thumbprintAlgorithm",
+        type: {
+          name: "String"
+        }
+      },
+      thumbprint: {
+        serializedName: "properties.thumbprint",
+        type: {
+          name: "String"
+        }
+      },
+      format: {
+        serializedName: "properties.format",
+        type: {
+          name: "Enum",
+          allowedValues: ["Pfx", "Cer"]
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["Succeeded", "Deleting", "Failed"]
+        }
+      },
+      provisioningStateTransitionTime: {
+        serializedName: "properties.provisioningStateTransitionTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      previousProvisioningState: {
+        serializedName: "properties.previousProvisioningState",
+        readOnly: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["Succeeded", "Deleting", "Failed"]
+        }
+      },
+      previousProvisioningStateTransitionTime: {
+        serializedName: "properties.previousProvisioningStateTransitionTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      publicData: {
+        serializedName: "properties.publicData",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      deleteCertificateError: {
+        serializedName: "properties.deleteCertificateError",
         type: {
           name: "Composite",
-          className: "AzureFileShareConfiguration"
+          className: "DeleteCertificateError"
         }
       }
     }
   }
 };
 
-export const BatchPoolIdentity: msRest.CompositeMapper = {
-  serializedName: "BatchPoolIdentity",
+export const CertificateCreateOrUpdateParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "BatchPoolIdentity",
+    className: "CertificateCreateOrUpdateParameters",
     modelProperties: {
-      type: {
-        required: true,
-        serializedName: "type",
+      ...ProxyResource.type.modelProperties,
+      thumbprintAlgorithm: {
+        serializedName: "properties.thumbprintAlgorithm",
+        type: {
+          name: "String"
+        }
+      },
+      thumbprint: {
+        serializedName: "properties.thumbprint",
+        type: {
+          name: "String"
+        }
+      },
+      format: {
+        serializedName: "properties.format",
         type: {
           name: "Enum",
-          allowedValues: [
-            "UserAssigned",
-            "None"
-          ]
+          allowedValues: ["Pfx", "Cer"]
         }
       },
-      userAssignedIdentities: {
-        serializedName: "userAssignedIdentities",
+      data: {
+        serializedName: "properties.data",
         type: {
-          name: "Dictionary",
-          value: {
+          name: "String"
+        }
+      },
+      password: {
+        serializedName: "properties.password",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const PrivateLinkResource: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateLinkResource",
+    modelProperties: {
+      ...ProxyResource.type.modelProperties,
+      groupId: {
+        serializedName: "properties.groupId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      requiredMembers: {
+        serializedName: "properties.requiredMembers",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
             type: {
-              name: "Composite",
-              className: "UserAssignedIdentities"
+              name: "String"
+            }
+          }
+        }
+      },
+      requiredZoneNames: {
+        serializedName: "properties.requiredZoneNames",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
             }
           }
         }
@@ -2764,13 +2976,19 @@ export const BatchPoolIdentity: msRest.CompositeMapper = {
   }
 };
 
-export const Pool: msRest.CompositeMapper = {
-  serializedName: "Pool",
+export const Pool: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "Pool",
     modelProperties: {
       ...ProxyResource.type.modelProperties,
+      identity: {
+        serializedName: "identity",
+        type: {
+          name: "Composite",
+          className: "BatchPoolIdentity"
+        }
+      },
       displayName: {
         serializedName: "properties.displayName",
         type: {
@@ -2778,52 +2996,45 @@ export const Pool: msRest.CompositeMapper = {
         }
       },
       lastModified: {
-        readOnly: true,
         serializedName: "properties.lastModified",
+        readOnly: true,
         type: {
           name: "DateTime"
         }
       },
       creationTime: {
-        readOnly: true,
         serializedName: "properties.creationTime",
+        readOnly: true,
         type: {
           name: "DateTime"
         }
       },
       provisioningState: {
-        readOnly: true,
         serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "Succeeded",
-            "Deleting"
-          ]
+          allowedValues: ["Succeeded", "Deleting"]
         }
       },
       provisioningStateTransitionTime: {
-        readOnly: true,
         serializedName: "properties.provisioningStateTransitionTime",
+        readOnly: true,
         type: {
           name: "DateTime"
         }
       },
       allocationState: {
-        readOnly: true,
         serializedName: "properties.allocationState",
+        readOnly: true,
         type: {
           name: "Enum",
-          allowedValues: [
-            "Steady",
-            "Resizing",
-            "Stopping"
-          ]
+          allowedValues: ["Steady", "Resizing", "Stopping"]
         }
       },
       allocationStateTransitionTime: {
-        readOnly: true,
         serializedName: "properties.allocationStateTransitionTime",
+        readOnly: true,
         type: {
           name: "DateTime"
         }
@@ -2842,15 +3053,15 @@ export const Pool: msRest.CompositeMapper = {
         }
       },
       currentDedicatedNodes: {
-        readOnly: true,
         serializedName: "properties.currentDedicatedNodes",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       currentLowPriorityNodes: {
-        readOnly: true,
         serializedName: "properties.currentLowPriorityNodes",
+        readOnly: true,
         type: {
           name: "Number"
         }
@@ -2863,7 +3074,6 @@ export const Pool: msRest.CompositeMapper = {
         }
       },
       autoScaleRun: {
-        readOnly: true,
         serializedName: "properties.autoScaleRun",
         type: {
           name: "Composite",
@@ -2874,10 +3084,7 @@ export const Pool: msRest.CompositeMapper = {
         serializedName: "properties.interNodeCommunication",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       networkConfiguration: {
@@ -2963,93 +3170,24 @@ export const Pool: msRest.CompositeMapper = {
             type: {
               name: "String"
             }
-          }
-        }
-      },
-      resizeOperationStatus: {
-        readOnly: true,
-        serializedName: "properties.resizeOperationStatus",
-        type: {
-          name: "Composite",
-          className: "ResizeOperationStatus"
-        }
-      },
-      mountConfiguration: {
-        serializedName: "properties.mountConfiguration",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "MountConfiguration"
-            }
-          }
-        }
-      },
-      identity: {
-        serializedName: "identity",
-        type: {
-          name: "Composite",
-          className: "BatchPoolIdentity"
-        }
-      }
-    }
-  }
-};
-
-export const SkuCapability: msRest.CompositeMapper = {
-  serializedName: "SkuCapability",
-  type: {
-    name: "Composite",
-    className: "SkuCapability",
-    modelProperties: {
-      name: {
-        readOnly: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      value: {
-        readOnly: true,
-        serializedName: "value",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const SupportedSku: msRest.CompositeMapper = {
-  serializedName: "SupportedSku",
-  type: {
-    name: "Composite",
-    className: "SupportedSku",
-    modelProperties: {
-      name: {
-        readOnly: true,
-        serializedName: "name",
-        type: {
-          name: "String"
+          }
         }
       },
-      familyName: {
-        readOnly: true,
-        serializedName: "familyName",
+      resizeOperationStatus: {
+        serializedName: "properties.resizeOperationStatus",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "ResizeOperationStatus"
         }
       },
-      capabilities: {
-        readOnly: true,
-        serializedName: "capabilities",
+      mountConfiguration: {
+        serializedName: "properties.mountConfiguration",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "SkuCapability"
+              className: "MountConfiguration"
             }
           }
         }
@@ -3058,233 +3196,245 @@ export const SupportedSku: msRest.CompositeMapper = {
   }
 };
 
-export const OperationDisplay: msRest.CompositeMapper = {
-  serializedName: "Operation_display",
+export const BatchAccount: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationDisplay",
+    className: "BatchAccount",
     modelProperties: {
-      provider: {
-        serializedName: "provider",
+      ...Resource.type.modelProperties,
+      identity: {
+        serializedName: "identity",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "BatchAccountIdentity"
         }
       },
-      operation: {
-        serializedName: "operation",
+      accountEndpoint: {
+        serializedName: "properties.accountEndpoint",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      resource: {
-        serializedName: "resource",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: [
+            "Invalid",
+            "Creating",
+            "Deleting",
+            "Succeeded",
+            "Failed",
+            "Cancelled"
+          ]
         }
       },
-      description: {
-        serializedName: "description",
+      poolAllocationMode: {
+        serializedName: "properties.poolAllocationMode",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["BatchService", "UserSubscription"]
         }
-      }
-    }
-  }
-};
-
-export const Operation: msRest.CompositeMapper = {
-  serializedName: "Operation",
-  type: {
-    name: "Composite",
-    className: "Operation",
-    modelProperties: {
-      name: {
-        serializedName: "name",
+      },
+      keyVaultReference: {
+        serializedName: "properties.keyVaultReference",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "KeyVaultReference"
         }
       },
-      isDataAction: {
-        serializedName: "isDataAction",
+      publicNetworkAccess: {
+        defaultValue: "Enabled",
+        serializedName: "properties.publicNetworkAccess",
+        readOnly: true,
+        nullable: true,
         type: {
-          name: "Boolean"
+          name: "Enum",
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
-      display: {
-        serializedName: "display",
+      privateEndpointConnections: {
+        serializedName: "properties.privateEndpointConnections",
+        readOnly: true,
+        nullable: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "PrivateEndpointConnection"
+            }
+          }
+        }
+      },
+      autoStorage: {
+        serializedName: "properties.autoStorage",
         type: {
           name: "Composite",
-          className: "OperationDisplay"
+          className: "AutoStorageProperties"
         }
       },
-      origin: {
-        serializedName: "origin",
+      encryption: {
+        serializedName: "properties.encryption",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "EncryptionProperties"
         }
       },
-      properties: {
-        serializedName: "properties",
+      dedicatedCoreQuota: {
+        serializedName: "properties.dedicatedCoreQuota",
+        readOnly: true,
+        nullable: true,
         type: {
-          name: "Object"
+          name: "Number"
         }
-      }
-    }
-  }
-};
-
-export const CheckNameAvailabilityParameters: msRest.CompositeMapper = {
-  serializedName: "CheckNameAvailabilityParameters",
-  type: {
-    name: "Composite",
-    className: "CheckNameAvailabilityParameters",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      lowPriorityCoreQuota: {
+        serializedName: "properties.lowPriorityCoreQuota",
+        readOnly: true,
+        nullable: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: 'Microsoft.Batch/batchAccounts',
+      dedicatedCoreQuotaPerVMFamily: {
+        serializedName: "properties.dedicatedCoreQuotaPerVMFamily",
+        readOnly: true,
+        nullable: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "VirtualMachineFamilyCoreQuota"
+            }
+          }
         }
-      }
-    }
-  }
-};
-
-export const CheckNameAvailabilityResult: msRest.CompositeMapper = {
-  serializedName: "CheckNameAvailabilityResult",
-  type: {
-    name: "Composite",
-    className: "CheckNameAvailabilityResult",
-    modelProperties: {
-      nameAvailable: {
+      },
+      dedicatedCoreQuotaPerVMFamilyEnforced: {
+        serializedName: "properties.dedicatedCoreQuotaPerVMFamilyEnforced",
         readOnly: true,
-        serializedName: "nameAvailable",
         type: {
           name: "Boolean"
         }
       },
-      reason: {
+      poolQuota: {
+        serializedName: "properties.poolQuota",
         readOnly: true,
-        serializedName: "reason",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Invalid",
-            "AlreadyExists"
-          ]
+          name: "Number"
         }
       },
-      message: {
+      activeJobAndJobScheduleQuota: {
+        serializedName: "properties.activeJobAndJobScheduleQuota",
         readOnly: true,
-        serializedName: "message",
         type: {
-          name: "String"
+          name: "Number"
         }
-      }
-    }
-  }
-};
-
-export const EndpointDetail: msRest.CompositeMapper = {
-  serializedName: "EndpointDetail",
-  type: {
-    name: "Composite",
-    className: "EndpointDetail",
-    modelProperties: {
-      port: {
+      },
+      allowedAuthenticationModes: {
+        serializedName: "properties.allowedAuthenticationModes",
         readOnly: true,
-        serializedName: "port",
         type: {
-          name: "Number"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Enum",
+              allowedValues: ["SharedKey", "AAD", "TaskAuthenticationToken"]
+            }
+          }
         }
       }
     }
   }
 };
 
-export const EndpointDependency: msRest.CompositeMapper = {
-  serializedName: "EndpointDependency",
+export const CertificateProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "EndpointDependency",
+    className: "CertificateProperties",
     modelProperties: {
-      domainName: {
+      ...CertificateBaseProperties.type.modelProperties,
+      provisioningState: {
+        serializedName: "provisioningState",
         readOnly: true,
-        serializedName: "domainName",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Succeeded", "Deleting", "Failed"]
         }
       },
-      description: {
+      provisioningStateTransitionTime: {
+        serializedName: "provisioningStateTransitionTime",
         readOnly: true,
-        serializedName: "description",
         type: {
-          name: "String"
+          name: "DateTime"
         }
       },
-      endpointDetails: {
+      previousProvisioningState: {
+        serializedName: "previousProvisioningState",
         readOnly: true,
-        serializedName: "endpointDetails",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "EndpointDetail"
-            }
-          }
+          name: "Enum",
+          allowedValues: ["Succeeded", "Deleting", "Failed"]
+        }
+      },
+      previousProvisioningStateTransitionTime: {
+        serializedName: "previousProvisioningStateTransitionTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      publicData: {
+        serializedName: "publicData",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      deleteCertificateError: {
+        serializedName: "deleteCertificateError",
+        type: {
+          name: "Composite",
+          className: "DeleteCertificateError"
         }
       }
     }
   }
 };
 
-export const OutboundEnvironmentEndpoint: msRest.CompositeMapper = {
-  serializedName: "OutboundEnvironmentEndpoint",
+export const CertificateCreateOrUpdateProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OutboundEnvironmentEndpoint",
+    className: "CertificateCreateOrUpdateProperties",
     modelProperties: {
-      category: {
-        readOnly: true,
-        serializedName: "category",
+      ...CertificateBaseProperties.type.modelProperties,
+      data: {
+        serializedName: "data",
+        required: true,
         type: {
           name: "String"
         }
       },
-      endpoints: {
-        readOnly: true,
-        serializedName: "endpoints",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "EndpointDependency"
-            }
-          }
+      password: {
+        serializedName: "password",
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const BatchAccountCreateHeaders: msRest.CompositeMapper = {
-  serializedName: "batchaccount-create-headers",
+export const BatchAccountCreateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountCreateHeaders",
     modelProperties: {
-      locationHeader: {
+      location: {
         serializedName: "location",
         type: {
           name: "String"
@@ -3300,8 +3450,7 @@ export const BatchAccountCreateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const BatchAccountDeleteHeaders: msRest.CompositeMapper = {
-  serializedName: "batchaccount-delete-headers",
+export const BatchAccountDeleteHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "BatchAccountDeleteHeaders",
@@ -3322,8 +3471,7 @@ export const BatchAccountDeleteHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateCreateHeaders: msRest.CompositeMapper = {
-  serializedName: "certificate-create-headers",
+export const CertificateCreateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CertificateCreateHeaders",
@@ -3338,8 +3486,7 @@ export const CertificateCreateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateUpdateHeaders: msRest.CompositeMapper = {
-  serializedName: "certificate-update-headers",
+export const CertificateUpdateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CertificateUpdateHeaders",
@@ -3354,8 +3501,7 @@ export const CertificateUpdateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateDeleteHeaders: msRest.CompositeMapper = {
-  serializedName: "certificate-delete-headers",
+export const CertificateDeleteHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CertificateDeleteHeaders",
@@ -3376,8 +3522,7 @@ export const CertificateDeleteHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateGetHeaders: msRest.CompositeMapper = {
-  serializedName: "certificate-get-headers",
+export const CertificateGetHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CertificateGetHeaders",
@@ -3392,8 +3537,7 @@ export const CertificateGetHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const CertificateCancelDeletionHeaders: msRest.CompositeMapper = {
-  serializedName: "certificate-canceldeletion-headers",
+export const CertificateCancelDeletionHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CertificateCancelDeletionHeaders",
@@ -3408,8 +3552,7 @@ export const CertificateCancelDeletionHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PrivateEndpointConnectionUpdateHeaders: msRest.CompositeMapper = {
-  serializedName: "privateendpointconnection-update-headers",
+export const PrivateEndpointConnectionUpdateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PrivateEndpointConnectionUpdateHeaders",
@@ -3430,8 +3573,7 @@ export const PrivateEndpointConnectionUpdateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolCreateHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-create-headers",
+export const PoolCreateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolCreateHeaders",
@@ -3446,8 +3588,7 @@ export const PoolCreateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolUpdateHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-update-headers",
+export const PoolUpdateHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolUpdateHeaders",
@@ -3462,8 +3603,7 @@ export const PoolUpdateHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolDeleteHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-delete-headers",
+export const PoolDeleteHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolDeleteHeaders",
@@ -3484,8 +3624,7 @@ export const PoolDeleteHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolGetHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-get-headers",
+export const PoolGetHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolGetHeaders",
@@ -3500,8 +3639,7 @@ export const PoolGetHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolDisableAutoScaleHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-disableautoscale-headers",
+export const PoolDisableAutoScaleHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolDisableAutoScaleHeaders",
@@ -3516,8 +3654,7 @@ export const PoolDisableAutoScaleHeaders: msRest.CompositeMapper = {
   }
 };
 
-export const PoolStopResizeHeaders: msRest.CompositeMapper = {
-  serializedName: "pool-stopresize-headers",
+export const PoolStopResizeHeaders: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "PoolStopResizeHeaders",
@@ -3531,286 +3668,3 @@ export const PoolStopResizeHeaders: msRest.CompositeMapper = {
     }
   }
 };
-
-export const BatchAccountListResult: msRest.CompositeMapper = {
-  serializedName: "BatchAccountListResult",
-  type: {
-    name: "Composite",
-    className: "BatchAccountListResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "BatchAccount"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const OutboundEnvironmentEndpointCollection: msRest.CompositeMapper = {
-  serializedName: "OutboundEnvironmentEndpointCollection",
-  type: {
-    name: "Composite",
-    className: "OutboundEnvironmentEndpointCollection",
-    modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "OutboundEnvironmentEndpoint"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListApplicationPackagesResult: msRest.CompositeMapper = {
-  serializedName: "ListApplicationPackagesResult",
-  type: {
-    name: "Composite",
-    className: "ListApplicationPackagesResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ApplicationPackage"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListApplicationsResult: msRest.CompositeMapper = {
-  serializedName: "ListApplicationsResult",
-  type: {
-    name: "Composite",
-    className: "ListApplicationsResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Application"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const SupportedSkusResult: msRest.CompositeMapper = {
-  serializedName: "SupportedSkusResult",
-  type: {
-    name: "Composite",
-    className: "SupportedSkusResult",
-    modelProperties: {
-      value: {
-        required: true,
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "SupportedSku"
-            }
-          }
-        }
-      },
-      nextLink: {
-        readOnly: true,
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const OperationListResult: msRest.CompositeMapper = {
-  serializedName: "OperationListResult",
-  type: {
-    name: "Composite",
-    className: "OperationListResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Operation"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListCertificatesResult: msRest.CompositeMapper = {
-  serializedName: "ListCertificatesResult",
-  type: {
-    name: "Composite",
-    className: "ListCertificatesResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Certificate"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListPrivateLinkResourcesResult: msRest.CompositeMapper = {
-  serializedName: "ListPrivateLinkResourcesResult",
-  type: {
-    name: "Composite",
-    className: "ListPrivateLinkResourcesResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "PrivateLinkResource"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListPrivateEndpointConnectionsResult: msRest.CompositeMapper = {
-  serializedName: "ListPrivateEndpointConnectionsResult",
-  type: {
-    name: "Composite",
-    className: "ListPrivateEndpointConnectionsResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "PrivateEndpointConnection"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const ListPoolsResult: msRest.CompositeMapper = {
-  serializedName: "ListPoolsResult",
-  type: {
-    name: "Composite",
-    className: "ListPoolsResult",
-    modelProperties: {
-      value: {
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Pool"
-            }
-          }
-        }
-      },
-      nextLink: {
-        serializedName: "nextLink",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};