@azure/arm-datalake-analytics 1.1.1 → 2.0.0-alpha.20211220.1

package/src/models/mappers.ts

@@ -6,103 +6,101 @@
  * 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 Resource: msRest.CompositeMapper = {
-  serializedName: "Resource",
+export const DataLakeAnalyticsAccountListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Resource",
+    className: "DataLakeAnalyticsAccountListResult",
     modelProperties: {
-      id: {
-        readOnly: true,
-        serializedName: "id",
-        type: {
-          name: "String"
-        }
-      },
-      name: {
+      value: {
+        serializedName: "value",
         readOnly: true,
-        serializedName: "name",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataLakeAnalyticsAccountBasic"
+            }
+          }
         }
       },
-      type: {
+      count: {
+        serializedName: "count",
         readOnly: true,
-        serializedName: "type",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      location: {
+      nextLink: {
+        serializedName: "nextLink",
         readOnly: true,
-        serializedName: "location",
         type: {
           name: "String"
         }
-      },
-      tags: {
-        readOnly: true,
-        serializedName: "tags",
-        type: {
-          name: "Dictionary",
-          value: {
-            type: {
-              name: "String"
-            }
-          }
-        }
       }
     }
   }
 };
 
-export const SubResource: msRest.CompositeMapper = {
-  serializedName: "SubResource",
+export const DataLakeAnalyticsAccountPropertiesBasic: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SubResource",
+    className: "DataLakeAnalyticsAccountPropertiesBasic",
     modelProperties: {
-      id: {
+      accountId: {
+        serializedName: "accountId",
         readOnly: true,
-        serializedName: "id",
         type: {
-          name: "String"
+          name: "Uuid"
         }
       },
-      name: {
+      provisioningState: {
+        serializedName: "provisioningState",
         readOnly: true,
-        serializedName: "name",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: [
+            "Failed",
+            "Creating",
+            "Running",
+            "Succeeded",
+            "Patching",
+            "Suspending",
+            "Resuming",
+            "Deleting",
+            "Deleted",
+            "Undeleting",
+            "Canceled"
+          ]
         }
       },
-      type: {
+      state: {
+        serializedName: "state",
         readOnly: true,
-        serializedName: "type",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Active", "Suspended"]
         }
-      }
-    }
-  }
-};
-
-export const DataLakeStoreAccountInformation: msRest.CompositeMapper = {
-  serializedName: "DataLakeStoreAccountInformation",
-  type: {
-    name: "Composite",
-    className: "DataLakeStoreAccountInformation",
-    modelProperties: {
-      ...SubResource.type.modelProperties,
-      suffix: {
+      },
+      creationTime: {
+        serializedName: "creationTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      lastModifiedTime: {
+        serializedName: "lastModifiedTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      endpoint: {
+        serializedName: "endpoint",
         readOnly: true,
-        serializedName: "properties.suffix",
         type: {
           name: "String"
         }
@@ -111,357 +109,237 @@ export const DataLakeStoreAccountInformation: msRest.CompositeMapper = {
   }
 };
 
-export const StorageAccountInformation: msRest.CompositeMapper = {
-  serializedName: "StorageAccountInformation",
+export const Resource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "StorageAccountInformation",
+    className: "Resource",
     modelProperties: {
-      ...SubResource.type.modelProperties,
-      suffix: {
+      id: {
+        serializedName: "id",
         readOnly: true,
-        serializedName: "properties.suffix",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const ComputePolicy: msRest.CompositeMapper = {
-  serializedName: "ComputePolicy",
-  type: {
-    name: "Composite",
-    className: "ComputePolicy",
-    modelProperties: {
-      ...SubResource.type.modelProperties,
-      objectId: {
+      },
+      name: {
+        serializedName: "name",
         readOnly: true,
-        serializedName: "properties.objectId",
         type: {
-          name: "Uuid"
+          name: "String"
         }
       },
-      objectType: {
+      type: {
+        serializedName: "type",
         readOnly: true,
-        serializedName: "properties.objectType",
         type: {
           name: "String"
         }
       },
-      maxDegreeOfParallelismPerJob: {
+      location: {
+        serializedName: "location",
         readOnly: true,
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      minPriorityPerJob: {
+      tags: {
+        serializedName: "tags",
         readOnly: true,
-        serializedName: "properties.minPriorityPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
         type: {
-          name: "Number"
+          name: "Dictionary",
+          value: { type: { name: "String" } }
         }
       }
     }
   }
 };
 
-export const HiveMetastore: msRest.CompositeMapper = {
-  serializedName: "HiveMetastore",
+export const ErrorResponse: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "HiveMetastore",
+    className: "ErrorResponse",
     modelProperties: {
-      ...SubResource.type.modelProperties,
-      serverUri: {
-        readOnly: true,
-        serializedName: "properties.serverUri",
+      error: {
+        serializedName: "error",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "ErrorDetail"
         }
-      },
-      databaseName: {
+      }
+    }
+  }
+};
+
+export const ErrorDetail: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ErrorDetail",
+    modelProperties: {
+      code: {
+        serializedName: "code",
         readOnly: true,
-        serializedName: "properties.databaseName",
         type: {
           name: "String"
         }
       },
-      runtimeVersion: {
+      message: {
+        serializedName: "message",
         readOnly: true,
-        serializedName: "properties.runtimeVersion",
         type: {
           name: "String"
         }
       },
-      userName: {
+      target: {
+        serializedName: "target",
         readOnly: true,
-        serializedName: "properties.userName",
         type: {
           name: "String"
         }
       },
-      password: {
+      details: {
+        serializedName: "details",
         readOnly: true,
-        serializedName: "properties.password",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ErrorDetail"
+            }
+          }
         }
       },
-      nestedResourceProvisioningState: {
+      additionalInfo: {
+        serializedName: "additionalInfo",
         readOnly: true,
-        serializedName: "properties.nestedResourceProvisioningState",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Succeeded",
-            "Canceled",
-            "Failed"
-          ]
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ErrorAdditionalInfo"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const VirtualNetworkRule: msRest.CompositeMapper = {
-  serializedName: "VirtualNetworkRule",
+export const ErrorAdditionalInfo: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "VirtualNetworkRule",
+    className: "ErrorAdditionalInfo",
     modelProperties: {
-      ...SubResource.type.modelProperties,
-      subnetId: {
+      type: {
+        serializedName: "type",
         readOnly: true,
-        serializedName: "properties.subnetId",
         type: {
           name: "String"
         }
       },
-      virtualNetworkRuleState: {
+      info: {
+        serializedName: "info",
         readOnly: true,
-        serializedName: "properties.virtualNetworkRuleState",
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Active",
-            "NetworkSourceDeleted",
-            "Failed"
-          ]
+          name: "Dictionary",
+          value: { type: { name: "any" } }
         }
       }
     }
   }
 };
 
-export const FirewallRule: msRest.CompositeMapper = {
-  serializedName: "FirewallRule",
+export const CreateDataLakeAnalyticsAccountParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FirewallRule",
+    className: "CreateDataLakeAnalyticsAccountParameters",
     modelProperties: {
-      ...SubResource.type.modelProperties,
-      startIpAddress: {
-        readOnly: true,
-        serializedName: "properties.startIpAddress",
+      location: {
+        serializedName: "location",
+        required: true,
         type: {
           name: "String"
         }
       },
-      endIpAddress: {
-        readOnly: true,
-        serializedName: "properties.endIpAddress",
+      tags: {
+        serializedName: "tags",
         type: {
-          name: "String"
+          name: "Dictionary",
+          value: { type: { name: "String" } }
         }
-      }
-    }
-  }
-};
-
-export const DataLakeAnalyticsAccount: msRest.CompositeMapper = {
-  serializedName: "DataLakeAnalyticsAccount",
-  type: {
-    name: "Composite",
-    className: "DataLakeAnalyticsAccount",
-    modelProperties: {
-      ...Resource.type.modelProperties,
-      accountId: {
-        readOnly: true,
-        serializedName: "properties.accountId",
+      },
+      defaultDataLakeStoreAccount: {
+        serializedName: "properties.defaultDataLakeStoreAccount",
+        required: true,
         type: {
-          name: "Uuid"
-        }
-      },
-      provisioningState: {
-        readOnly: true,
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Failed",
-            "Creating",
-            "Running",
-            "Succeeded",
-            "Patching",
-            "Suspending",
-            "Resuming",
-            "Deleting",
-            "Deleted",
-            "Undeleting",
-            "Canceled"
-          ]
-        }
-      },
-      state: {
-        readOnly: true,
-        serializedName: "properties.state",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Active",
-            "Suspended"
-          ]
-        }
-      },
-      creationTime: {
-        readOnly: true,
-        serializedName: "properties.creationTime",
-        type: {
-          name: "DateTime"
-        }
-      },
-      lastModifiedTime: {
-        readOnly: true,
-        serializedName: "properties.lastModifiedTime",
-        type: {
-          name: "DateTime"
-        }
-      },
-      endpoint: {
-        readOnly: true,
-        serializedName: "properties.endpoint",
-        type: {
-          name: "String"
-        }
-      },
-      defaultDataLakeStoreAccount: {
-        readOnly: true,
-        serializedName: "properties.defaultDataLakeStoreAccount",
-        type: {
-          name: "String"
+          name: "String"
         }
       },
       dataLakeStoreAccounts: {
-        readOnly: true,
         serializedName: "properties.dataLakeStoreAccounts",
+        required: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "DataLakeStoreAccountInformation"
+              className: "AddDataLakeStoreWithAccountParameters"
             }
           }
         }
       },
       storageAccounts: {
-        readOnly: true,
         serializedName: "properties.storageAccounts",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "StorageAccountInformation"
+              className: "AddStorageAccountWithAccountParameters"
             }
           }
         }
       },
       computePolicies: {
-        readOnly: true,
         serializedName: "properties.computePolicies",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "ComputePolicy"
-            }
-          }
-        }
-      },
-      hiveMetastores: {
-        readOnly: true,
-        serializedName: "properties.hiveMetastores",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "HiveMetastore"
-            }
-          }
-        }
-      },
-      virtualNetworkRules: {
-        readOnly: true,
-        serializedName: "properties.virtualNetworkRules",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "VirtualNetworkRule"
+              className: "CreateComputePolicyWithAccountParameters"
             }
           }
         }
       },
       firewallRules: {
-        readOnly: true,
         serializedName: "properties.firewallRules",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "FirewallRule"
+              className: "CreateFirewallRuleWithAccountParameters"
             }
           }
         }
       },
       firewallState: {
-        readOnly: true,
         serializedName: "properties.firewallState",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       firewallAllowAzureIps: {
-        readOnly: true,
         serializedName: "properties.firewallAllowAzureIps",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       newTier: {
-        readOnly: true,
         serializedName: "properties.newTier",
         type: {
           name: "Enum",
@@ -478,167 +356,74 @@ export const DataLakeAnalyticsAccount: msRest.CompositeMapper = {
           ]
         }
       },
-      currentTier: {
-        readOnly: true,
-        serializedName: "properties.currentTier",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Consumption",
-            "Commitment_100AUHours",
-            "Commitment_500AUHours",
-            "Commitment_1000AUHours",
-            "Commitment_5000AUHours",
-            "Commitment_10000AUHours",
-            "Commitment_50000AUHours",
-            "Commitment_100000AUHours",
-            "Commitment_500000AUHours"
-          ]
-        }
-      },
       maxJobCount: {
-        serializedName: "properties.maxJobCount",
         defaultValue: 3,
         constraints: {
           InclusiveMinimum: 1
         },
-        type: {
-          name: "Number"
-        }
-      },
-      systemMaxJobCount: {
-        readOnly: true,
-        serializedName: "properties.systemMaxJobCount",
+        serializedName: "properties.maxJobCount",
         type: {
           name: "Number"
         }
       },
       maxDegreeOfParallelism: {
-        serializedName: "properties.maxDegreeOfParallelism",
         defaultValue: 30,
         constraints: {
           InclusiveMinimum: 1
         },
-        type: {
-          name: "Number"
-        }
-      },
-      systemMaxDegreeOfParallelism: {
-        readOnly: true,
-        serializedName: "properties.systemMaxDegreeOfParallelism",
+        serializedName: "properties.maxDegreeOfParallelism",
         type: {
           name: "Number"
         }
       },
       maxDegreeOfParallelismPerJob: {
-        readOnly: true,
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        defaultValue: 32,
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
         type: {
           name: "Number"
         }
       },
       minPriorityPerJob: {
-        readOnly: true,
-        serializedName: "properties.minPriorityPerJob",
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.minPriorityPerJob",
         type: {
           name: "Number"
         }
       },
       queryStoreRetention: {
-        serializedName: "properties.queryStoreRetention",
         defaultValue: 30,
         constraints: {
           InclusiveMaximum: 180,
           InclusiveMinimum: 1
         },
+        serializedName: "properties.queryStoreRetention",
         type: {
           name: "Number"
         }
-      },
-      debugDataAccessLevel: {
-        readOnly: true,
-        serializedName: "properties.debugDataAccessLevel",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "All",
-            "Customer",
-            "None"
-          ]
-        }
       }
     }
   }
 };
 
-export const DataLakeAnalyticsAccountBasic: msRest.CompositeMapper = {
-  serializedName: "DataLakeAnalyticsAccountBasic",
+export const AddDataLakeStoreWithAccountParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DataLakeAnalyticsAccountBasic",
+    className: "AddDataLakeStoreWithAccountParameters",
     modelProperties: {
-      ...Resource.type.modelProperties,
-      accountId: {
-        readOnly: true,
-        serializedName: "properties.accountId",
-        type: {
-          name: "Uuid"
-        }
-      },
-      provisioningState: {
-        readOnly: true,
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Failed",
-            "Creating",
-            "Running",
-            "Succeeded",
-            "Patching",
-            "Suspending",
-            "Resuming",
-            "Deleting",
-            "Deleted",
-            "Undeleting",
-            "Canceled"
-          ]
-        }
-      },
-      state: {
-        readOnly: true,
-        serializedName: "properties.state",
-        type: {
-          name: "Enum",
-          allowedValues: [
-            "Active",
-            "Suspended"
-          ]
-        }
-      },
-      creationTime: {
-        readOnly: true,
-        serializedName: "properties.creationTime",
-        type: {
-          name: "DateTime"
-        }
-      },
-      lastModifiedTime: {
-        readOnly: true,
-        serializedName: "properties.lastModifiedTime",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "DateTime"
+          name: "String"
         }
       },
-      endpoint: {
-        readOnly: true,
-        serializedName: "properties.endpoint",
+      suffix: {
+        serializedName: "properties.suffix",
         type: {
           name: "String"
         }
@@ -647,33 +432,28 @@ export const DataLakeAnalyticsAccountBasic: msRest.CompositeMapper = {
   }
 };
 
-export const StorageContainer: msRest.CompositeMapper = {
-  serializedName: "StorageContainer",
+export const AddStorageAccountWithAccountParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "StorageContainer",
+    className: "AddStorageAccountWithAccountParameters",
     modelProperties: {
-      ...SubResource.type.modelProperties,
-      lastModifiedTime: {
-        readOnly: true,
-        serializedName: "properties.lastModifiedTime",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "DateTime"
+          name: "String"
         }
-      }
-    }
-  }
-};
-
-export const SasTokenInformation: msRest.CompositeMapper = {
-  serializedName: "SasTokenInformation",
-  type: {
-    name: "Composite",
-    className: "SasTokenInformation",
-    modelProperties: {
-      accessToken: {
-        readOnly: true,
-        serializedName: "accessToken",
+      },
+      accessKey: {
+        serializedName: "properties.accessKey",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      suffix: {
+        defaultValue: "azuredatalakestore.net",
+        serializedName: "properties.suffix",
         type: {
           name: "String"
         }
@@ -682,58 +462,700 @@ export const SasTokenInformation: msRest.CompositeMapper = {
   }
 };
 
-export const VirtualNetworkRuleListResult: msRest.CompositeMapper = {
-  serializedName: "VirtualNetworkRuleListResult",
+export const CreateComputePolicyWithAccountParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "VirtualNetworkRuleListResult",
+    className: "CreateComputePolicyWithAccountParameters",
     modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "value",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "VirtualNetworkRule"
+          name: "String"
+        }
+      },
+      objectId: {
+        serializedName: "properties.objectId",
+        required: true,
+        type: {
+          name: "Uuid"
+        }
+      },
+      objectType: {
+        serializedName: "properties.objectType",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const CreateFirewallRuleWithAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "CreateFirewallRuleWithAccountParameters",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      startIpAddress: {
+        serializedName: "properties.startIpAddress",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      endIpAddress: {
+        serializedName: "properties.endIpAddress",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const SubResource: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SubResource",
+    modelProperties: {
+      id: {
+        serializedName: "id",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      name: {
+        serializedName: "name",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      type: {
+        serializedName: "type",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateDataLakeAnalyticsAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateDataLakeAnalyticsAccountParameters",
+    modelProperties: {
+      tags: {
+        serializedName: "tags",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
+      },
+      dataLakeStoreAccounts: {
+        serializedName: "properties.dataLakeStoreAccounts",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "UpdateDataLakeStoreWithAccountParameters"
+            }
+          }
+        }
+      },
+      storageAccounts: {
+        serializedName: "properties.storageAccounts",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "UpdateStorageAccountWithAccountParameters"
+            }
+          }
+        }
+      },
+      computePolicies: {
+        serializedName: "properties.computePolicies",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "UpdateComputePolicyWithAccountParameters"
+            }
+          }
+        }
+      },
+      firewallRules: {
+        serializedName: "properties.firewallRules",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "UpdateFirewallRuleWithAccountParameters"
+            }
+          }
+        }
+      },
+      firewallState: {
+        serializedName: "properties.firewallState",
+        type: {
+          name: "Enum",
+          allowedValues: ["Enabled", "Disabled"]
+        }
+      },
+      firewallAllowAzureIps: {
+        serializedName: "properties.firewallAllowAzureIps",
+        type: {
+          name: "Enum",
+          allowedValues: ["Enabled", "Disabled"]
+        }
+      },
+      newTier: {
+        serializedName: "properties.newTier",
+        type: {
+          name: "Enum",
+          allowedValues: [
+            "Consumption",
+            "Commitment_100AUHours",
+            "Commitment_500AUHours",
+            "Commitment_1000AUHours",
+            "Commitment_5000AUHours",
+            "Commitment_10000AUHours",
+            "Commitment_50000AUHours",
+            "Commitment_100000AUHours",
+            "Commitment_500000AUHours"
+          ]
+        }
+      },
+      maxJobCount: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxJobCount",
+        type: {
+          name: "Number"
+        }
+      },
+      maxDegreeOfParallelism: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelism",
+        type: {
+          name: "Number"
+        }
+      },
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      queryStoreRetention: {
+        constraints: {
+          InclusiveMaximum: 180,
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.queryStoreRetention",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateDataLakeStoreWithAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateDataLakeStoreWithAccountParameters",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      suffix: {
+        serializedName: "properties.suffix",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateStorageAccountWithAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateStorageAccountWithAccountParameters",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      accessKey: {
+        serializedName: "properties.accessKey",
+        type: {
+          name: "String"
+        }
+      },
+      suffix: {
+        serializedName: "properties.suffix",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateComputePolicyWithAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateComputePolicyWithAccountParameters",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      objectId: {
+        serializedName: "properties.objectId",
+        type: {
+          name: "Uuid"
+        }
+      },
+      objectType: {
+        serializedName: "properties.objectType",
+        type: {
+          name: "String"
+        }
+      },
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateFirewallRuleWithAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateFirewallRuleWithAccountParameters",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      startIpAddress: {
+        serializedName: "properties.startIpAddress",
+        type: {
+          name: "String"
+        }
+      },
+      endIpAddress: {
+        serializedName: "properties.endIpAddress",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const DataLakeStoreAccountInformationListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DataLakeStoreAccountInformationListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataLakeStoreAccountInformation"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const AddDataLakeStoreParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AddDataLakeStoreParameters",
+    modelProperties: {
+      suffix: {
+        serializedName: "properties.suffix",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const StorageAccountInformationListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "StorageAccountInformationListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "StorageAccountInformation"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const AddStorageAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AddStorageAccountParameters",
+    modelProperties: {
+      accessKey: {
+        serializedName: "properties.accessKey",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      suffix: {
+        defaultValue: "azuredatalakestore.net",
+        serializedName: "properties.suffix",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateStorageAccountParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateStorageAccountParameters",
+    modelProperties: {
+      accessKey: {
+        serializedName: "properties.accessKey",
+        type: {
+          name: "String"
+        }
+      },
+      suffix: {
+        serializedName: "properties.suffix",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const StorageContainerListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "StorageContainerListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "StorageContainer"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const SasTokenInformationListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SasTokenInformationListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "SasTokenInformation"
+            }
+          }
+        }
+      },
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const SasTokenInformation: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SasTokenInformation",
+    modelProperties: {
+      accessToken: {
+        serializedName: "accessToken",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const ComputePolicyListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ComputePolicyListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ComputePolicy"
             }
           }
         }
       },
-      nextLink: {
-        readOnly: true,
-        serializedName: "nextLink",
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const CreateOrUpdateComputePolicyParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "CreateOrUpdateComputePolicyParameters",
+    modelProperties: {
+      objectId: {
+        serializedName: "properties.objectId",
+        required: true,
+        type: {
+          name: "Uuid"
+        }
+      },
+      objectType: {
+        serializedName: "properties.objectType",
+        required: true,
         type: {
           name: "String"
         }
+      },
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
+        type: {
+          name: "Number"
+        }
       }
     }
   }
 };
 
-export const HiveMetastoreListResult: msRest.CompositeMapper = {
-  serializedName: "HiveMetastoreListResult",
+export const UpdateComputePolicyParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "HiveMetastoreListResult",
+    className: "UpdateComputePolicyParameters",
+    modelProperties: {
+      objectId: {
+        serializedName: "properties.objectId",
+        type: {
+          name: "Uuid"
+        }
+      },
+      objectType: {
+        serializedName: "properties.objectType",
+        type: {
+          name: "String"
+        }
+      },
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
+        type: {
+          name: "Number"
+        }
+      },
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const FirewallRuleListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "FirewallRuleListResult",
     modelProperties: {
       value: {
-        readOnly: true,
         serializedName: "value",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "HiveMetastore"
+              className: "FirewallRule"
             }
           }
         }
       },
       nextLink: {
-        readOnly: true,
         serializedName: "nextLink",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -742,36 +1164,71 @@ export const HiveMetastoreListResult: msRest.CompositeMapper = {
   }
 };
 
-export const OperationDisplay: msRest.CompositeMapper = {
-  serializedName: "OperationDisplay",
+export const CreateOrUpdateFirewallRuleParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationDisplay",
+    className: "CreateOrUpdateFirewallRuleParameters",
     modelProperties: {
-      provider: {
-        readOnly: true,
-        serializedName: "provider",
+      startIpAddress: {
+        serializedName: "properties.startIpAddress",
+        required: true,
         type: {
           name: "String"
         }
       },
-      resource: {
-        readOnly: true,
-        serializedName: "resource",
+      endIpAddress: {
+        serializedName: "properties.endIpAddress",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const UpdateFirewallRuleParameters: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "UpdateFirewallRuleParameters",
+    modelProperties: {
+      startIpAddress: {
+        serializedName: "properties.startIpAddress",
         type: {
           name: "String"
         }
       },
-      operation: {
-        readOnly: true,
-        serializedName: "operation",
+      endIpAddress: {
+        serializedName: "properties.endIpAddress",
         type: {
           name: "String"
         }
+      }
+    }
+  }
+};
+
+export const OperationListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OperationListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Operation"
+            }
+          }
+        }
       },
-      description: {
+      nextLink: {
+        serializedName: "nextLink",
         readOnly: true,
-        serializedName: "description",
         type: {
           name: "String"
         }
@@ -780,20 +1237,35 @@ export const OperationDisplay: msRest.CompositeMapper = {
   }
 };
 
-export const OperationMetaMetricAvailabilitiesSpecification: msRest.CompositeMapper = {
-  serializedName: "OperationMetaMetricAvailabilitiesSpecification",
+export const Operation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationMetaMetricAvailabilitiesSpecification",
+    className: "Operation",
     modelProperties: {
-      timeGrain: {
-        serializedName: "timeGrain",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      blobDuration: {
-        serializedName: "blobDuration",
+      display: {
+        serializedName: "display",
+        type: {
+          name: "Composite",
+          className: "OperationDisplay"
+        }
+      },
+      properties: {
+        serializedName: "properties",
+        type: {
+          name: "Composite",
+          className: "OperationMetaPropertyInfo"
+        }
+      },
+      origin: {
+        serializedName: "origin",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -802,44 +1274,84 @@ export const OperationMetaMetricAvailabilitiesSpecification: msRest.CompositeMap
   }
 };
 
-export const OperationMetaMetricSpecification: msRest.CompositeMapper = {
-  serializedName: "OperationMetaMetricSpecification",
+export const OperationDisplay: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationMetaMetricSpecification",
+    className: "OperationDisplay",
     modelProperties: {
-      name: {
-        serializedName: "name",
+      provider: {
+        serializedName: "provider",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      displayName: {
-        serializedName: "displayName",
+      resource: {
+        serializedName: "resource",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      unit: {
-        serializedName: "unit",
+      operation: {
+        serializedName: "operation",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      aggregationType: {
-        serializedName: "aggregationType",
+      description: {
+        serializedName: "description",
+        readOnly: true,
         type: {
           name: "String"
         }
+      }
+    }
+  }
+};
+
+export const OperationMetaPropertyInfo: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OperationMetaPropertyInfo",
+    modelProperties: {
+      serviceSpecification: {
+        serializedName: "serviceSpecification",
+        type: {
+          name: "Composite",
+          className: "OperationMetaServiceSpecification"
+        }
+      }
+    }
+  }
+};
+
+export const OperationMetaServiceSpecification: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OperationMetaServiceSpecification",
+    modelProperties: {
+      metricSpecifications: {
+        serializedName: "metricSpecifications",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "OperationMetaMetricSpecification"
+            }
+          }
+        }
       },
-      availabilities: {
-        serializedName: "availabilities",
+      logSpecifications: {
+        serializedName: "logSpecifications",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "OperationMetaMetricAvailabilitiesSpecification"
+              className: "OperationMetaLogSpecification"
             }
           }
         }
@@ -848,11 +1360,10 @@ export const OperationMetaMetricSpecification: msRest.CompositeMapper = {
   }
 };
 
-export const OperationMetaLogSpecification: msRest.CompositeMapper = {
-  serializedName: "OperationMetaLogSpecification",
+export const OperationMetaMetricSpecification: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationMetaLogSpecification",
+    className: "OperationMetaMetricSpecification",
     modelProperties: {
       name: {
         serializedName: "name",
@@ -860,48 +1371,38 @@ export const OperationMetaLogSpecification: msRest.CompositeMapper = {
           name: "String"
         }
       },
+      displayDescription: {
+        serializedName: "displayDescription",
+        type: {
+          name: "String"
+        }
+      },
       displayName: {
         serializedName: "displayName",
         type: {
           name: "String"
         }
       },
-      blobDuration: {
-        serializedName: "blobDuration",
+      unit: {
+        serializedName: "unit",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const OperationMetaServiceSpecification: msRest.CompositeMapper = {
-  serializedName: "OperationMetaServiceSpecification",
-  type: {
-    name: "Composite",
-    className: "OperationMetaServiceSpecification",
-    modelProperties: {
-      metricSpecifications: {
-        serializedName: "metricSpecifications",
+      },
+      aggregationType: {
+        serializedName: "aggregationType",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "OperationMetaMetricSpecification"
-            }
-          }
+          name: "String"
         }
       },
-      logSpecifications: {
-        serializedName: "logSpecifications",
+      availabilities: {
+        serializedName: "availabilities",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "OperationMetaLogSpecification"
+              className: "OperationMetaMetricAvailabilitiesSpecification"
             }
           }
         }
@@ -910,85 +1411,46 @@ export const OperationMetaServiceSpecification: msRest.CompositeMapper = {
   }
 };
 
-export const OperationMetaPropertyInfo: msRest.CompositeMapper = {
-  serializedName: "OperationMetaPropertyInfo",
+export const OperationMetaMetricAvailabilitiesSpecification: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "OperationMetaPropertyInfo",
+    className: "OperationMetaMetricAvailabilitiesSpecification",
     modelProperties: {
-      serviceSpecification: {
-        serializedName: "serviceSpecification",
+      timeGrain: {
+        serializedName: "timeGrain",
         type: {
-          name: "Composite",
-          className: "OperationMetaServiceSpecification"
+          name: "String"
+        }
+      },
+      blobDuration: {
+        serializedName: "blobDuration",
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const Operation: msRest.CompositeMapper = {
-  serializedName: "Operation",
+export const OperationMetaLogSpecification: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Operation",
+    className: "OperationMetaLogSpecification",
     modelProperties: {
       name: {
-        readOnly: true,
         serializedName: "name",
         type: {
           name: "String"
         }
       },
-      display: {
-        readOnly: true,
-        serializedName: "display",
-        type: {
-          name: "Composite",
-          className: "OperationDisplay"
-        }
-      },
-      properties: {
-        readOnly: true,
-        serializedName: "properties",
-        type: {
-          name: "Composite",
-          className: "OperationMetaPropertyInfo"
-        }
-      },
-      origin: {
-        readOnly: true,
-        serializedName: "origin",
+      displayName: {
+        serializedName: "displayName",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const OperationListResult: msRest.CompositeMapper = {
-  serializedName: "OperationListResult",
-  type: {
-    name: "Composite",
-    className: "OperationListResult",
-    modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "value",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Operation"
-            }
-          }
-        }
       },
-      nextLink: {
-        readOnly: true,
-        serializedName: "nextLink",
+      blobDuration: {
+        serializedName: "blobDuration",
         type: {
           name: "String"
         }
@@ -997,43 +1459,42 @@ export const OperationListResult: msRest.CompositeMapper = {
   }
 };
 
-export const CapabilityInformation: msRest.CompositeMapper = {
-  serializedName: "CapabilityInformation",
+export const CapabilityInformation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "CapabilityInformation",
     modelProperties: {
       subscriptionId: {
-        readOnly: true,
         serializedName: "subscriptionId",
+        readOnly: true,
         type: {
           name: "Uuid"
         }
       },
       state: {
-        readOnly: true,
         serializedName: "state",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
       maxAccountCount: {
-        readOnly: true,
         serializedName: "maxAccountCount",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       accountCount: {
-        readOnly: true,
         serializedName: "accountCount",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       migrationState: {
-        readOnly: true,
         serializedName: "migrationState",
+        readOnly: true,
         type: {
           name: "Boolean"
         }
@@ -1042,29 +1503,22 @@ export const CapabilityInformation: msRest.CompositeMapper = {
   }
 };
 
-export const NameAvailabilityInformation: msRest.CompositeMapper = {
-  serializedName: "NameAvailabilityInformation",
+export const CheckNameAvailabilityParameters: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "NameAvailabilityInformation",
+    className: "CheckNameAvailabilityParameters",
     modelProperties: {
-      nameAvailable: {
-        readOnly: true,
-        serializedName: "nameAvailable",
-        type: {
-          name: "Boolean"
-        }
-      },
-      reason: {
-        readOnly: true,
-        serializedName: "reason",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      message: {
-        readOnly: true,
-        serializedName: "message",
+      type: {
+        defaultValue: "Microsoft.DataLakeAnalytics/accounts",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
@@ -1073,21 +1527,28 @@ export const NameAvailabilityInformation: msRest.CompositeMapper = {
   }
 };
 
-export const AddDataLakeStoreWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "AddDataLakeStoreWithAccountParameters",
+export const NameAvailabilityInformation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AddDataLakeStoreWithAccountParameters",
+    className: "NameAvailabilityInformation",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      nameAvailable: {
+        serializedName: "nameAvailable",
+        readOnly: true,
+        type: {
+          name: "Boolean"
+        }
+      },
+      reason: {
+        serializedName: "reason",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      suffix: {
-        serializedName: "properties.suffix",
+      message: {
+        serializedName: "message",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -1096,28 +1557,27 @@ export const AddDataLakeStoreWithAccountParameters: msRest.CompositeMapper = {
   }
 };
 
-export const AddStorageAccountWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "AddStorageAccountWithAccountParameters",
+export const VirtualNetworkRuleListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AddStorageAccountWithAccountParameters",
+    className: "VirtualNetworkRuleListResult",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      accessKey: {
-        required: true,
-        serializedName: "properties.accessKey",
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "VirtualNetworkRule"
+            }
+          }
         }
       },
-      suffix: {
-        serializedName: "properties.suffix",
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -1126,188 +1586,179 @@ export const AddStorageAccountWithAccountParameters: msRest.CompositeMapper = {
   }
 };
 
-export const CreateComputePolicyWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "CreateComputePolicyWithAccountParameters",
+export const HiveMetastoreListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CreateComputePolicyWithAccountParameters",
+    className: "HiveMetastoreListResult",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      objectId: {
-        required: true,
-        serializedName: "properties.objectId",
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
-          name: "Uuid"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "HiveMetastore"
+            }
+          }
         }
       },
-      objectType: {
-        required: true,
-        serializedName: "properties.objectType",
+      nextLink: {
+        serializedName: "nextLink",
+        readOnly: true,
         type: {
           name: "String"
         }
-      },
-      maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
-        type: {
-          name: "Number"
-        }
-      },
-      minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
-        type: {
-          name: "Number"
-        }
       }
     }
   }
 };
 
-export const CreateFirewallRuleWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "CreateFirewallRuleWithAccountParameters",
+export const DataLakeAnalyticsAccountProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CreateFirewallRuleWithAccountParameters",
+    className: "DataLakeAnalyticsAccountProperties",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      ...DataLakeAnalyticsAccountPropertiesBasic.type.modelProperties,
+      defaultDataLakeStoreAccountType: {
+        serializedName: "defaultDataLakeStoreAccountType",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      startIpAddress: {
-        required: true,
-        serializedName: "properties.startIpAddress",
+      defaultDataLakeStoreAccount: {
+        serializedName: "defaultDataLakeStoreAccount",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      endIpAddress: {
-        required: true,
-        serializedName: "properties.endIpAddress",
+      dataLakeStoreAccounts: {
+        serializedName: "dataLakeStoreAccounts",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataLakeStoreAccountInformation"
+            }
+          }
         }
-      }
-    }
-  }
-};
-
-export const CreateDataLakeAnalyticsAccountParameters: msRest.CompositeMapper = {
-  serializedName: "CreateDataLakeAnalyticsAccountParameters",
-  type: {
-    name: "Composite",
-    className: "CreateDataLakeAnalyticsAccountParameters",
-    modelProperties: {
-      location: {
-        required: true,
-        serializedName: "location",
+      },
+      publicDataLakeStoreAccounts: {
+        serializedName: "publicDataLakeStoreAccounts",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataLakeStoreAccountInformation"
+            }
+          }
         }
       },
-      tags: {
-        serializedName: "tags",
+      storageAccounts: {
+        serializedName: "storageAccounts",
+        readOnly: true,
         type: {
-          name: "Dictionary",
-          value: {
+          name: "Sequence",
+          element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "StorageAccountInformation"
             }
           }
         }
       },
-      defaultDataLakeStoreAccount: {
-        required: true,
-        serializedName: "properties.defaultDataLakeStoreAccount",
-        type: {
-          name: "String"
-        }
-      },
-      dataLakeStoreAccounts: {
-        required: true,
-        serializedName: "properties.dataLakeStoreAccounts",
+      computePolicies: {
+        serializedName: "computePolicies",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "AddDataLakeStoreWithAccountParameters"
+              className: "ComputePolicy"
             }
           }
         }
       },
-      storageAccounts: {
-        serializedName: "properties.storageAccounts",
+      hiveMetastores: {
+        serializedName: "hiveMetastores",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "AddStorageAccountWithAccountParameters"
+              className: "HiveMetastore"
             }
           }
         }
       },
-      computePolicies: {
-        serializedName: "properties.computePolicies",
+      virtualNetworkRules: {
+        serializedName: "virtualNetworkRules",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "CreateComputePolicyWithAccountParameters"
+              className: "VirtualNetworkRule"
             }
           }
         }
       },
       firewallRules: {
-        serializedName: "properties.firewallRules",
+        serializedName: "firewallRules",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "CreateFirewallRuleWithAccountParameters"
+              className: "FirewallRule"
             }
           }
         }
       },
       firewallState: {
-        serializedName: "properties.firewallState",
+        serializedName: "firewallState",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       firewallAllowAzureIps: {
-        serializedName: "properties.firewallAllowAzureIps",
+        serializedName: "firewallAllowAzureIps",
+        type: {
+          name: "Enum",
+          allowedValues: ["Enabled", "Disabled"]
+        }
+      },
+      newTier: {
+        serializedName: "newTier",
         type: {
           name: "Enum",
           allowedValues: [
-            "Enabled",
-            "Disabled"
+            "Consumption",
+            "Commitment_100AUHours",
+            "Commitment_500AUHours",
+            "Commitment_1000AUHours",
+            "Commitment_5000AUHours",
+            "Commitment_10000AUHours",
+            "Commitment_50000AUHours",
+            "Commitment_100000AUHours",
+            "Commitment_500000AUHours"
           ]
         }
       },
-      newTier: {
-        serializedName: "properties.newTier",
+      currentTier: {
+        serializedName: "currentTier",
+        readOnly: true,
         type: {
           name: "Enum",
           allowedValues: [
@@ -1324,102 +1775,160 @@ export const CreateDataLakeAnalyticsAccountParameters: msRest.CompositeMapper =
         }
       },
       maxJobCount: {
-        serializedName: "properties.maxJobCount",
         defaultValue: 3,
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "maxJobCount",
+        type: {
+          name: "Number"
+        }
+      },
+      maxActiveJobCountPerUser: {
+        serializedName: "maxActiveJobCountPerUser",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      maxQueuedJobCountPerUser: {
+        serializedName: "maxQueuedJobCountPerUser",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      maxJobRunningTimeInMin: {
+        serializedName: "maxJobRunningTimeInMin",
+        readOnly: true,
+        type: {
+          name: "Number"
+        }
+      },
+      systemMaxJobCount: {
+        serializedName: "systemMaxJobCount",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       maxDegreeOfParallelism: {
-        serializedName: "properties.maxDegreeOfParallelism",
         defaultValue: 30,
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "maxDegreeOfParallelism",
+        type: {
+          name: "Number"
+        }
+      },
+      systemMaxDegreeOfParallelism: {
+        serializedName: "systemMaxDegreeOfParallelism",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "maxDegreeOfParallelismPerJob",
         type: {
           name: "Number"
         }
       },
       minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "minPriorityPerJob",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
       queryStoreRetention: {
-        serializedName: "properties.queryStoreRetention",
         defaultValue: 30,
         constraints: {
           InclusiveMaximum: 180,
           InclusiveMinimum: 1
         },
+        serializedName: "queryStoreRetention",
         type: {
           name: "Number"
         }
+      },
+      debugDataAccessLevel: {
+        serializedName: "debugDataAccessLevel",
+        readOnly: true,
+        type: {
+          name: "Enum",
+          allowedValues: ["All", "Customer", "None"]
+        }
       }
     }
   }
 };
 
-export const UpdateDataLakeStoreWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateDataLakeStoreWithAccountParameters",
+export const DataLakeAnalyticsAccountBasic: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "UpdateDataLakeStoreWithAccountParameters",
+    className: "DataLakeAnalyticsAccountBasic",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      ...Resource.type.modelProperties,
+      accountId: {
+        serializedName: "properties.accountId",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Uuid"
         }
       },
-      suffix: {
-        serializedName: "properties.suffix",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: [
+            "Failed",
+            "Creating",
+            "Running",
+            "Succeeded",
+            "Patching",
+            "Suspending",
+            "Resuming",
+            "Deleting",
+            "Deleted",
+            "Undeleting",
+            "Canceled"
+          ]
         }
-      }
-    }
-  }
-};
-
-export const UpdateStorageAccountWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateStorageAccountWithAccountParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateStorageAccountWithAccountParameters",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      state: {
+        serializedName: "properties.state",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Active", "Suspended"]
         }
       },
-      accessKey: {
-        serializedName: "properties.accessKey",
+      creationTime: {
+        serializedName: "properties.creationTime",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "DateTime"
         }
       },
-      suffix: {
-        serializedName: "properties.suffix",
+      lastModifiedTime: {
+        serializedName: "properties.lastModifiedTime",
+        readOnly: true,
+        type: {
+          name: "DateTime"
+        }
+      },
+      endpoint: {
+        serializedName: "properties.endpoint",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -1428,143 +1937,168 @@ export const UpdateStorageAccountWithAccountParameters: msRest.CompositeMapper =
   }
 };
 
-export const UpdateComputePolicyWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateComputePolicyWithAccountParameters",
+export const DataLakeAnalyticsAccount: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "UpdateComputePolicyWithAccountParameters",
+    className: "DataLakeAnalyticsAccount",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      objectId: {
-        serializedName: "properties.objectId",
+      ...Resource.type.modelProperties,
+      accountId: {
+        serializedName: "properties.accountId",
+        readOnly: true,
         type: {
           name: "Uuid"
         }
       },
-      objectType: {
-        serializedName: "properties.objectType",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: [
+            "Failed",
+            "Creating",
+            "Running",
+            "Succeeded",
+            "Patching",
+            "Suspending",
+            "Resuming",
+            "Deleting",
+            "Deleted",
+            "Undeleting",
+            "Canceled"
+          ]
         }
       },
-      maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      state: {
+        serializedName: "properties.state",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "Enum",
+          allowedValues: ["Active", "Suspended"]
         }
       },
-      minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      creationTime: {
+        serializedName: "properties.creationTime",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "DateTime"
         }
-      }
-    }
-  }
-};
-
-export const UpdateFirewallRuleWithAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateFirewallRuleWithAccountParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateFirewallRuleWithAccountParameters",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      lastModifiedTime: {
+        serializedName: "properties.lastModifiedTime",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "DateTime"
         }
       },
-      startIpAddress: {
-        serializedName: "properties.startIpAddress",
+      endpoint: {
+        serializedName: "properties.endpoint",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      endIpAddress: {
-        serializedName: "properties.endIpAddress",
+      defaultDataLakeStoreAccountType: {
+        serializedName: "properties.defaultDataLakeStoreAccountType",
+        readOnly: true,
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const UpdateDataLakeAnalyticsAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateDataLakeAnalyticsAccountParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateDataLakeAnalyticsAccountParameters",
-    modelProperties: {
-      tags: {
-        serializedName: "tags",
+      },
+      defaultDataLakeStoreAccount: {
+        serializedName: "properties.defaultDataLakeStoreAccount",
+        readOnly: true,
         type: {
-          name: "Dictionary",
-          value: {
+          name: "String"
+        }
+      },
+      dataLakeStoreAccounts: {
+        serializedName: "properties.dataLakeStoreAccounts",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "DataLakeStoreAccountInformation"
             }
           }
         }
       },
-      dataLakeStoreAccounts: {
-        serializedName: "properties.dataLakeStoreAccounts",
+      publicDataLakeStoreAccounts: {
+        serializedName: "properties.publicDataLakeStoreAccounts",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "UpdateDataLakeStoreWithAccountParameters"
+              className: "DataLakeStoreAccountInformation"
             }
           }
         }
       },
       storageAccounts: {
         serializedName: "properties.storageAccounts",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "UpdateStorageAccountWithAccountParameters"
+              className: "StorageAccountInformation"
             }
           }
         }
       },
       computePolicies: {
         serializedName: "properties.computePolicies",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "UpdateComputePolicyWithAccountParameters"
+              className: "ComputePolicy"
+            }
+          }
+        }
+      },
+      hiveMetastores: {
+        serializedName: "properties.hiveMetastores",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "HiveMetastore"
+            }
+          }
+        }
+      },
+      virtualNetworkRules: {
+        serializedName: "properties.virtualNetworkRules",
+        readOnly: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "VirtualNetworkRule"
             }
           }
         }
       },
       firewallRules: {
         serializedName: "properties.firewallRules",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "UpdateFirewallRuleWithAccountParameters"
+              className: "FirewallRule"
             }
           }
         }
@@ -1573,20 +2107,14 @@ export const UpdateDataLakeAnalyticsAccountParameters: msRest.CompositeMapper =
         serializedName: "properties.firewallState",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       firewallAllowAzureIps: {
         serializedName: "properties.firewallAllowAzureIps",
         type: {
           name: "Enum",
-          allowedValues: [
-            "Enabled",
-            "Disabled"
-          ]
+          allowedValues: ["Enabled", "Disabled"]
         }
       },
       newTier: {
@@ -1606,263 +2134,130 @@ export const UpdateDataLakeAnalyticsAccountParameters: msRest.CompositeMapper =
           ]
         }
       },
-      maxJobCount: {
-        serializedName: "properties.maxJobCount",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      currentTier: {
+        serializedName: "properties.currentTier",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "Enum",
+          allowedValues: [
+            "Consumption",
+            "Commitment_100AUHours",
+            "Commitment_500AUHours",
+            "Commitment_1000AUHours",
+            "Commitment_5000AUHours",
+            "Commitment_10000AUHours",
+            "Commitment_50000AUHours",
+            "Commitment_100000AUHours",
+            "Commitment_500000AUHours"
+          ]
         }
       },
-      maxDegreeOfParallelism: {
-        serializedName: "properties.maxDegreeOfParallelism",
+      maxJobCount: {
+        defaultValue: 3,
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.maxJobCount",
         type: {
           name: "Number"
         }
       },
-      maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      maxActiveJobCountPerUser: {
+        serializedName: "properties.maxActiveJobCountPerUser",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
-      minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      maxQueuedJobCountPerUser: {
+        serializedName: "properties.maxQueuedJobCountPerUser",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
-      queryStoreRetention: {
-        serializedName: "properties.queryStoreRetention",
-        constraints: {
-          InclusiveMaximum: 180,
-          InclusiveMinimum: 1
-        },
+      maxJobRunningTimeInMin: {
+        serializedName: "properties.maxJobRunningTimeInMin",
+        readOnly: true,
         type: {
           name: "Number"
         }
-      }
-    }
-  }
-};
-
-export const AddDataLakeStoreParameters: msRest.CompositeMapper = {
-  serializedName: "AddDataLakeStoreParameters",
-  type: {
-    name: "Composite",
-    className: "AddDataLakeStoreParameters",
-    modelProperties: {
-      suffix: {
-        serializedName: "properties.suffix",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const AddStorageAccountParameters: msRest.CompositeMapper = {
-  serializedName: "AddStorageAccountParameters",
-  type: {
-    name: "Composite",
-    className: "AddStorageAccountParameters",
-    modelProperties: {
-      accessKey: {
-        required: true,
-        serializedName: "properties.accessKey",
-        type: {
-          name: "String"
-        }
-      },
-      suffix: {
-        serializedName: "properties.suffix",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const UpdateStorageAccountParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateStorageAccountParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateStorageAccountParameters",
-    modelProperties: {
-      accessKey: {
-        serializedName: "properties.accessKey",
-        type: {
-          name: "String"
-        }
-      },
-      suffix: {
-        serializedName: "properties.suffix",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const CreateOrUpdateComputePolicyParameters: msRest.CompositeMapper = {
-  serializedName: "CreateOrUpdateComputePolicyParameters",
-  type: {
-    name: "Composite",
-    className: "CreateOrUpdateComputePolicyParameters",
-    modelProperties: {
-      objectId: {
-        required: true,
-        serializedName: "properties.objectId",
-        type: {
-          name: "Uuid"
-        }
-      },
-      objectType: {
-        required: true,
-        serializedName: "properties.objectType",
-        type: {
-          name: "String"
-        }
       },
-      maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
-        constraints: {
-          InclusiveMinimum: 1
-        },
+      systemMaxJobCount: {
+        serializedName: "properties.systemMaxJobCount",
+        readOnly: true,
         type: {
           name: "Number"
         }
       },
-      minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
+      maxDegreeOfParallelism: {
+        defaultValue: 30,
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.maxDegreeOfParallelism",
         type: {
           name: "Number"
         }
-      }
-    }
-  }
-};
-
-export const UpdateComputePolicyParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateComputePolicyParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateComputePolicyParameters",
-    modelProperties: {
-      objectId: {
-        serializedName: "properties.objectId",
-        type: {
-          name: "Uuid"
-        }
       },
-      objectType: {
-        serializedName: "properties.objectType",
+      systemMaxDegreeOfParallelism: {
+        serializedName: "properties.systemMaxDegreeOfParallelism",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
       maxDegreeOfParallelismPerJob: {
-        serializedName: "properties.maxDegreeOfParallelismPerJob",
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
         type: {
           name: "Number"
         }
       },
       minPriorityPerJob: {
-        serializedName: "properties.minPriorityPerJob",
         constraints: {
           InclusiveMinimum: 1
         },
+        serializedName: "properties.minPriorityPerJob",
+        readOnly: true,
         type: {
           name: "Number"
         }
-      }
-    }
-  }
-};
-
-export const CreateOrUpdateFirewallRuleParameters: msRest.CompositeMapper = {
-  serializedName: "CreateOrUpdateFirewallRuleParameters",
-  type: {
-    name: "Composite",
-    className: "CreateOrUpdateFirewallRuleParameters",
-    modelProperties: {
-      startIpAddress: {
-        required: true,
-        serializedName: "properties.startIpAddress",
-        type: {
-          name: "String"
-        }
       },
-      endIpAddress: {
-        required: true,
-        serializedName: "properties.endIpAddress",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const UpdateFirewallRuleParameters: msRest.CompositeMapper = {
-  serializedName: "UpdateFirewallRuleParameters",
-  type: {
-    name: "Composite",
-    className: "UpdateFirewallRuleParameters",
-    modelProperties: {
-      startIpAddress: {
-        serializedName: "properties.startIpAddress",
+      queryStoreRetention: {
+        defaultValue: 30,
+        constraints: {
+          InclusiveMaximum: 180,
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.queryStoreRetention",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      endIpAddress: {
-        serializedName: "properties.endIpAddress",
+      debugDataAccessLevel: {
+        serializedName: "properties.debugDataAccessLevel",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["All", "Customer", "None"]
         }
       }
     }
   }
 };
 
-export const CheckNameAvailabilityParameters: msRest.CompositeMapper = {
-  serializedName: "CheckNameAvailabilityParameters",
+export const DataLakeStoreAccountInformation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CheckNameAvailabilityParameters",
+    className: "DataLakeStoreAccountInformation",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: 'Microsoft.DataLakeAnalytics/accounts',
+      ...SubResource.type.modelProperties,
+      suffix: {
+        serializedName: "properties.suffix",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -1871,276 +2266,161 @@ export const CheckNameAvailabilityParameters: msRest.CompositeMapper = {
   }
 };
 
-export const ErrorAdditionalInfo: msRest.CompositeMapper = {
-  serializedName: "ErrorAdditionalInfo",
+export const StorageAccountInformation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ErrorAdditionalInfo",
+    className: "StorageAccountInformation",
     modelProperties: {
-      type: {
+      ...SubResource.type.modelProperties,
+      suffix: {
+        serializedName: "properties.suffix",
         readOnly: true,
-        serializedName: "type",
         type: {
           name: "String"
         }
-      },
-      info: {
-        readOnly: true,
-        serializedName: "info",
-        type: {
-          name: "Object"
-        }
       }
     }
   }
 };
 
-export const ErrorDetail: msRest.CompositeMapper = {
-  serializedName: "ErrorDetail",
+export const ComputePolicy: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ErrorDetail",
+    className: "ComputePolicy",
     modelProperties: {
-      code: {
-        readOnly: true,
-        serializedName: "code",
-        type: {
-          name: "String"
-        }
-      },
-      message: {
+      ...SubResource.type.modelProperties,
+      objectId: {
+        serializedName: "properties.objectId",
         readOnly: true,
-        serializedName: "message",
         type: {
-          name: "String"
+          name: "Uuid"
         }
       },
-      target: {
+      objectType: {
+        serializedName: "properties.objectType",
         readOnly: true,
-        serializedName: "target",
         type: {
           name: "String"
         }
       },
-      details: {
+      maxDegreeOfParallelismPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.maxDegreeOfParallelismPerJob",
         readOnly: true,
-        serializedName: "details",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ErrorDetail"
-            }
-          }
+          name: "Number"
         }
       },
-      additionalInfo: {
+      minPriorityPerJob: {
+        constraints: {
+          InclusiveMinimum: 1
+        },
+        serializedName: "properties.minPriorityPerJob",
         readOnly: true,
-        serializedName: "additionalInfo",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ErrorAdditionalInfo"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const ErrorResponse: msRest.CompositeMapper = {
-  serializedName: "ErrorResponse",
-  type: {
-    name: "Composite",
-    className: "ErrorResponse",
-    modelProperties: {
-      error: {
-        serializedName: "error",
         type: {
-          name: "Composite",
-          className: "ErrorDetail"
+          name: "Number"
         }
       }
     }
   }
 };
 
-export const DataLakeAnalyticsAccountListResult: msRest.CompositeMapper = {
-  serializedName: "DataLakeAnalyticsAccountListResult",
+export const HiveMetastore: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DataLakeAnalyticsAccountListResult",
+    className: "HiveMetastore",
     modelProperties: {
-      value: {
+      ...SubResource.type.modelProperties,
+      serverUri: {
+        serializedName: "properties.serverUri",
         readOnly: true,
-        serializedName: "",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "DataLakeAnalyticsAccountBasic"
-            }
-          }
+          name: "String"
         }
       },
-      nextLink: {
+      databaseName: {
+        serializedName: "properties.databaseName",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const DataLakeStoreAccountInformationListResult: msRest.CompositeMapper = {
-  serializedName: "DataLakeStoreAccountInformationListResult",
-  type: {
-    name: "Composite",
-    className: "DataLakeStoreAccountInformationListResult",
-    modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "DataLakeStoreAccountInformation"
-            }
-          }
-        }
       },
-      nextLink: {
+      runtimeVersion: {
+        serializedName: "properties.runtimeVersion",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const StorageAccountInformationListResult: msRest.CompositeMapper = {
-  serializedName: "StorageAccountInformationListResult",
-  type: {
-    name: "Composite",
-    className: "StorageAccountInformationListResult",
-    modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "StorageAccountInformation"
-            }
-          }
-        }
       },
-      nextLink: {
+      userName: {
+        serializedName: "properties.userName",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const StorageContainerListResult: msRest.CompositeMapper = {
-  serializedName: "StorageContainerListResult",
-  type: {
-    name: "Composite",
-    className: "StorageContainerListResult",
-    modelProperties: {
-      value: {
+      },
+      password: {
+        serializedName: "properties.password",
         readOnly: true,
-        serializedName: "",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "StorageContainer"
-            }
-          }
+          name: "String"
         }
       },
-      nextLink: {
+      nestedResourceProvisioningState: {
+        serializedName: "properties.nestedResourceProvisioningState",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Succeeded", "Canceled", "Failed"]
         }
       }
     }
   }
 };
 
-export const SasTokenInformationListResult: msRest.CompositeMapper = {
-  serializedName: "SasTokenInformationListResult",
+export const VirtualNetworkRule: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SasTokenInformationListResult",
+    className: "VirtualNetworkRule",
     modelProperties: {
-      value: {
+      ...SubResource.type.modelProperties,
+      subnetId: {
+        serializedName: "properties.subnetId",
         readOnly: true,
-        serializedName: "",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "SasTokenInformation"
-            }
-          }
+          name: "String"
         }
       },
-      nextLink: {
+      virtualNetworkRuleState: {
+        serializedName: "properties.virtualNetworkRuleState",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
-          name: "String"
+          name: "Enum",
+          allowedValues: ["Active", "NetworkSourceDeleted", "Failed"]
         }
       }
     }
   }
 };
 
-export const ComputePolicyListResult: msRest.CompositeMapper = {
-  serializedName: "ComputePolicyListResult",
+export const FirewallRule: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ComputePolicyListResult",
+    className: "FirewallRule",
     modelProperties: {
-      value: {
+      ...SubResource.type.modelProperties,
+      startIpAddress: {
+        serializedName: "properties.startIpAddress",
         readOnly: true,
-        serializedName: "",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "ComputePolicy"
-            }
-          }
+          name: "String"
         }
       },
-      nextLink: {
+      endIpAddress: {
+        serializedName: "properties.endIpAddress",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
           name: "String"
         }
@@ -2149,30 +2429,17 @@ export const ComputePolicyListResult: msRest.CompositeMapper = {
   }
 };
 
-export const FirewallRuleListResult: msRest.CompositeMapper = {
-  serializedName: "FirewallRuleListResult",
+export const StorageContainer: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FirewallRuleListResult",
+    className: "StorageContainer",
     modelProperties: {
-      value: {
-        readOnly: true,
-        serializedName: "",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "FirewallRule"
-            }
-          }
-        }
-      },
-      nextLink: {
+      ...SubResource.type.modelProperties,
+      lastModifiedTime: {
+        serializedName: "properties.lastModifiedTime",
         readOnly: true,
-        serializedName: "nextLink",
         type: {
-          name: "String"
+          name: "DateTime"
         }
       }
     }