@azure/arm-kusto 6.2.0 → 7.0.0

package/src/models/mappers.ts

@@ -6,14 +6,150 @@
  * 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 AzureSku: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AzureSku",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      capacity: {
+        serializedName: "capacity",
+        type: {
+          name: "Number"
+        }
+      },
+      tier: {
+        serializedName: "tier",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const SystemData: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SystemData",
+    modelProperties: {
+      createdBy: {
+        serializedName: "createdBy",
+        type: {
+          name: "String"
+        }
+      },
+      createdByType: {
+        serializedName: "createdByType",
+        type: {
+          name: "String"
+        }
+      },
+      createdAt: {
+        serializedName: "createdAt",
+        type: {
+          name: "DateTime"
+        }
+      },
+      lastModifiedBy: {
+        serializedName: "lastModifiedBy",
+        type: {
+          name: "String"
+        }
+      },
+      lastModifiedByType: {
+        serializedName: "lastModifiedByType",
+        type: {
+          name: "String"
+        }
+      },
+      lastModifiedAt: {
+        serializedName: "lastModifiedAt",
+        type: {
+          name: "DateTime"
+        }
+      }
+    }
+  }
+};
+
+export const Identity: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Identity",
+    modelProperties: {
+      principalId: {
+        serializedName: "principalId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      tenantId: {
+        serializedName: "tenantId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      type: {
+        serializedName: "type",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      userAssignedIdentities: {
+        serializedName: "userAssignedIdentities",
+        type: {
+          name: "Dictionary",
+          value: {
+            type: {
+              name: "Composite",
+              className:
+                "ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className:
+      "ComponentsSgqdofSchemasIdentityPropertiesUserassignedidentitiesAdditionalproperties",
+    modelProperties: {
+      principalId: {
+        serializedName: "principalId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      clientId: {
+        serializedName: "clientId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
 
-export const TrustedExternalTenant: msRest.CompositeMapper = {
-  serializedName: "TrustedExternalTenant",
+export const TrustedExternalTenant: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "TrustedExternalTenant",
@@ -28,36 +164,35 @@ export const TrustedExternalTenant: msRest.CompositeMapper = {
   }
 };
 
-export const OptimizedAutoscale: msRest.CompositeMapper = {
-  serializedName: "OptimizedAutoscale",
+export const OptimizedAutoscale: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "OptimizedAutoscale",
     modelProperties: {
       version: {
-        required: true,
         serializedName: "version",
+        required: true,
         type: {
           name: "Number"
         }
       },
       isEnabled: {
-        required: true,
         serializedName: "isEnabled",
+        required: true,
         type: {
           name: "Boolean"
         }
       },
       minimum: {
-        required: true,
         serializedName: "minimum",
+        required: true,
         type: {
           name: "Number"
         }
       },
       maximum: {
-        required: true,
         serializedName: "maximum",
+        required: true,
         type: {
           name: "Number"
         }
@@ -66,29 +201,28 @@ export const OptimizedAutoscale: msRest.CompositeMapper = {
   }
 };
 
-export const VirtualNetworkConfiguration: msRest.CompositeMapper = {
-  serializedName: "VirtualNetworkConfiguration",
+export const VirtualNetworkConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "VirtualNetworkConfiguration",
     modelProperties: {
       subnetId: {
-        required: true,
         serializedName: "subnetId",
+        required: true,
         type: {
           name: "String"
         }
       },
       enginePublicIpId: {
-        required: true,
         serializedName: "enginePublicIpId",
+        required: true,
         type: {
           name: "String"
         }
       },
       dataManagementPublicIpId: {
-        required: true,
         serializedName: "dataManagementPublicIpId",
+        required: true,
         type: {
           name: "String"
         }
@@ -97,14 +231,12 @@ export const VirtualNetworkConfiguration: msRest.CompositeMapper = {
   }
 };
 
-export const KeyVaultProperties: msRest.CompositeMapper = {
-  serializedName: "KeyVaultProperties",
+export const KeyVaultProperties: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "KeyVaultProperties",
     modelProperties: {
       keyName: {
-        required: true,
         serializedName: "keyName",
         type: {
           name: "String"
@@ -117,7 +249,6 @@ export const KeyVaultProperties: msRest.CompositeMapper = {
         }
       },
       keyVaultUri: {
-        required: true,
         serializedName: "keyVaultUri",
         type: {
           name: "String"
@@ -133,8 +264,28 @@ export const KeyVaultProperties: msRest.CompositeMapper = {
   }
 };
 
-export const LanguageExtension: msRest.CompositeMapper = {
-  serializedName: "LanguageExtension",
+export const LanguageExtensionsList: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "LanguageExtensionsList",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "LanguageExtension"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const LanguageExtension: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
     className: "LanguageExtension",
@@ -149,28 +300,13 @@ export const LanguageExtension: msRest.CompositeMapper = {
   }
 };
 
-export const AzureSku: msRest.CompositeMapper = {
-  serializedName: "AzureSku",
+export const AcceptedAudiences: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AzureSku",
+    className: "AcceptedAudiences",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      capacity: {
-        serializedName: "capacity",
-        type: {
-          name: "Number"
-        }
-      },
-      tier: {
-        required: true,
-        serializedName: "tier",
+      value: {
+        serializedName: "value",
         type: {
           name: "String"
         }
@@ -179,94 +315,83 @@ export const AzureSku: msRest.CompositeMapper = {
   }
 };
 
-export const AzureCapacity: msRest.CompositeMapper = {
-  serializedName: "AzureCapacity",
+export const Resource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AzureCapacity",
+    className: "Resource",
     modelProperties: {
-      scaleType: {
-        required: true,
-        serializedName: "scaleType",
+      id: {
+        serializedName: "id",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      minimum: {
-        required: true,
-        serializedName: "minimum",
-        type: {
-          name: "Number"
-        }
-      },
-      maximum: {
-        required: true,
-        serializedName: "maximum",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      default: {
-        required: true,
-        serializedName: "default",
+      type: {
+        serializedName: "type",
+        readOnly: true,
         type: {
-          name: "Number"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const AzureResourceSku: msRest.CompositeMapper = {
-  serializedName: "AzureResourceSku",
+export const CloudError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AzureResourceSku",
+    className: "CloudError",
     modelProperties: {
-      resourceType: {
-        serializedName: "resourceType",
-        type: {
-          name: "String"
-        }
-      },
-      sku: {
-        serializedName: "sku",
-        type: {
-          name: "Composite",
-          className: "AzureSku"
-        }
-      },
-      capacity: {
-        serializedName: "capacity",
+      error: {
+        serializedName: "error",
         type: {
           name: "Composite",
-          className: "AzureCapacity"
+          className: "CloudErrorBody"
         }
       }
     }
   }
 };
 
-export const SkuLocationInfoItem: msRest.CompositeMapper = {
-  serializedName: "SkuLocationInfoItem",
+export const CloudErrorBody: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SkuLocationInfoItem",
+    className: "CloudErrorBody",
     modelProperties: {
-      location: {
-        required: true,
-        serializedName: "location",
+      code: {
+        serializedName: "code",
         type: {
           name: "String"
         }
       },
-      zones: {
-        serializedName: "zones",
+      message: {
+        serializedName: "message",
+        type: {
+          name: "String"
+        }
+      },
+      target: {
+        serializedName: "target",
+        type: {
+          name: "String"
+        }
+      },
+      details: {
+        serializedName: "details",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "CloudErrorBody"
             }
           }
         }
@@ -275,66 +400,97 @@ export const SkuLocationInfoItem: msRest.CompositeMapper = {
   }
 };
 
-export const SkuDescription: msRest.CompositeMapper = {
-  serializedName: "SkuDescription",
+export const ClusterPrincipalAssignmentCheckNameRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SkuDescription",
+    className: "ClusterPrincipalAssignmentCheckNameRequest",
     modelProperties: {
-      resourceType: {
-        readOnly: true,
-        serializedName: "resourceType",
+      name: {
+        serializedName: "name",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      type: {
+        defaultValue: "Microsoft.Kusto/clusters/principalAssignments",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
+      }
+    }
+  }
+};
+
+export const CheckNameResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "CheckNameResult",
+    modelProperties: {
+      nameAvailable: {
+        serializedName: "nameAvailable",
+        type: {
+          name: "Boolean"
+        }
       },
       name: {
-        readOnly: true,
         serializedName: "name",
         type: {
           name: "String"
         }
       },
-      tier: {
-        readOnly: true,
-        serializedName: "tier",
+      message: {
+        serializedName: "message",
         type: {
           name: "String"
         }
       },
-      locations: {
-        readOnly: true,
-        serializedName: "locations",
+      reason: {
+        serializedName: "reason",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "String"
         }
-      },
-      locationInfo: {
-        readOnly: true,
-        serializedName: "locationInfo",
+      }
+    }
+  }
+};
+
+export const ClusterPrincipalAssignmentListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ClusterPrincipalAssignmentListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "SkuLocationInfoItem"
+              className: "ClusterPrincipalAssignment"
             }
           }
         }
-      },
-      restrictions: {
-        readOnly: true,
-        serializedName: "restrictions",
+      }
+    }
+  }
+};
+
+export const FollowerDatabaseListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "FollowerDatabaseListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Object"
+              name: "Composite",
+              className: "FollowerDatabaseDefinition"
             }
           }
         }
@@ -343,30 +499,43 @@ export const SkuDescription: msRest.CompositeMapper = {
   }
 };
 
-export const DatabaseStatistics: msRest.CompositeMapper = {
-  serializedName: "DatabaseStatistics",
+export const FollowerDatabaseDefinition: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DatabaseStatistics",
+    className: "FollowerDatabaseDefinition",
     modelProperties: {
-      size: {
-        serializedName: "size",
+      clusterResourceId: {
+        serializedName: "clusterResourceId",
+        required: true,
         type: {
-          name: "Number"
+          name: "String"
+        }
+      },
+      attachedDatabaseConfigurationName: {
+        serializedName: "attachedDatabaseConfigurationName",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      databaseName: {
+        serializedName: "databaseName",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const TableLevelSharingProperties: msRest.CompositeMapper = {
-  serializedName: "TableLevelSharingProperties",
+export const DiagnoseVirtualNetworkResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "TableLevelSharingProperties",
+    className: "DiagnoseVirtualNetworkResult",
     modelProperties: {
-      tablesToInclude: {
-        serializedName: "tablesToInclude",
+      findings: {
+        serializedName: "findings",
         type: {
           name: "Sequence",
           element: {
@@ -375,31 +544,83 @@ export const TableLevelSharingProperties: msRest.CompositeMapper = {
             }
           }
         }
-      },
-      tablesToExclude: {
-        serializedName: "tablesToExclude",
+      }
+    }
+  }
+};
+
+export const ClusterListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ClusterListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "Cluster"
             }
           }
         }
-      },
-      externalTablesToInclude: {
-        serializedName: "externalTablesToInclude",
+      }
+    }
+  }
+};
+
+export const SkuDescriptionList: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SkuDescriptionList",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "SkuDescription"
             }
           }
         }
+      }
+    }
+  }
+};
+
+export const SkuDescription: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "SkuDescription",
+    modelProperties: {
+      resourceType: {
+        serializedName: "resourceType",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
       },
-      externalTablesToExclude: {
-        serializedName: "externalTablesToExclude",
+      name: {
+        serializedName: "name",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      tier: {
+        serializedName: "tier",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      locations: {
+        serializedName: "locations",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
@@ -409,24 +630,28 @@ export const TableLevelSharingProperties: msRest.CompositeMapper = {
           }
         }
       },
-      materializedViewsToInclude: {
-        serializedName: "materializedViewsToInclude",
+      locationInfo: {
+        serializedName: "locationInfo",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "SkuLocationInfoItem"
             }
           }
         }
       },
-      materializedViewsToExclude: {
-        serializedName: "materializedViewsToExclude",
+      restrictions: {
+        serializedName: "restrictions",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Dictionary",
+              value: { type: { name: "any" } }
             }
           }
         }
@@ -435,125 +660,100 @@ export const TableLevelSharingProperties: msRest.CompositeMapper = {
   }
 };
 
-export const IdentityUserAssignedIdentitiesValue: msRest.CompositeMapper = {
-  serializedName: "Identity_userAssignedIdentitiesValue",
+export const SkuLocationInfoItem: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "IdentityUserAssignedIdentitiesValue",
+    className: "SkuLocationInfoItem",
     modelProperties: {
-      principalId: {
-        readOnly: true,
-        serializedName: "principalId",
+      location: {
+        serializedName: "location",
+        required: true,
         type: {
           name: "String"
         }
       },
-      clientId: {
-        readOnly: true,
-        serializedName: "clientId",
+      zones: {
+        serializedName: "zones",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const Identity: msRest.CompositeMapper = {
-  serializedName: "Identity",
+export const ClusterCheckNameRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Identity",
+    className: "ClusterCheckNameRequest",
     modelProperties: {
-      principalId: {
-        readOnly: true,
-        serializedName: "principalId",
-        type: {
-          name: "String"
-        }
-      },
-      tenantId: {
-        readOnly: true,
-        serializedName: "tenantId",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
       type: {
-        required: true,
+        defaultValue: "Microsoft.Kusto/clusters",
+        isConstant: true,
         serializedName: "type",
         type: {
           name: "String"
         }
-      },
-      userAssignedIdentities: {
-        serializedName: "userAssignedIdentities",
-        type: {
-          name: "Dictionary",
-          value: {
-            type: {
-              name: "Composite",
-              className: "IdentityUserAssignedIdentitiesValue"
-            }
-          }
-        }
       }
     }
   }
 };
 
-export const Resource: msRest.CompositeMapper = {
-  serializedName: "Resource",
+export const CheckNameRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Resource",
+    className: "CheckNameRequest",
     modelProperties: {
-      id: {
-        readOnly: true,
-        serializedName: "id",
-        type: {
-          name: "String"
-        }
-      },
       name: {
-        readOnly: true,
         serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
       type: {
-        readOnly: true,
         serializedName: "type",
+        required: true,
         type: {
-          name: "String"
-        }
-      }
+          name: "Enum",
+          allowedValues: [
+            "Microsoft.Kusto/clusters/databases",
+            "Microsoft.Kusto/clusters/attachedDatabaseConfigurations"
+          ]
+        }
+      }
     }
   }
 };
 
-export const TrackedResource: msRest.CompositeMapper = {
-  serializedName: "TrackedResource",
+export const AttachedDatabaseConfigurationsCheckNameRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "TrackedResource",
+    className: "AttachedDatabaseConfigurationsCheckNameRequest",
     modelProperties: {
-      ...Resource.type.modelProperties,
-      tags: {
-        serializedName: "tags",
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "Dictionary",
-          value: {
-            type: {
-              name: "String"
-            }
-          }
+          name: "String"
         }
       },
-      location: {
-        required: true,
-        serializedName: "location",
+      type: {
+        defaultValue: "Microsoft.Kusto/clusters/attachedDatabaseConfigurations",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
@@ -562,152 +762,251 @@ export const TrackedResource: msRest.CompositeMapper = {
   }
 };
 
-export const Cluster: msRest.CompositeMapper = {
-  serializedName: "Cluster",
+export const ManagedPrivateEndpointsCheckNameRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "Cluster",
+    className: "ManagedPrivateEndpointsCheckNameRequest",
     modelProperties: {
-      ...TrackedResource.type.modelProperties,
-      sku: {
+      name: {
+        serializedName: "name",
         required: true,
-        serializedName: "sku",
         type: {
-          name: "Composite",
-          className: "AzureSku"
+          name: "String"
         }
       },
-      zones: {
-        serializedName: "zones",
+      type: {
+        defaultValue: "Microsoft.Kusto/clusters/managedPrivateEndpoints",
+        isConstant: true,
+        serializedName: "type",
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+
+export const ListResourceSkusResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ListResourceSkusResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "AzureResourceSku"
             }
           }
         }
+      }
+    }
+  }
+};
+
+export const AzureResourceSku: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AzureResourceSku",
+    modelProperties: {
+      resourceType: {
+        serializedName: "resourceType",
+        type: {
+          name: "String"
+        }
       },
-      identity: {
-        serializedName: "identity",
+      sku: {
+        serializedName: "sku",
         type: {
           name: "Composite",
-          className: "Identity"
+          className: "AzureSku"
         }
       },
-      state: {
-        readOnly: true,
-        serializedName: "properties.state",
+      capacity: {
+        serializedName: "capacity",
+        type: {
+          name: "Composite",
+          className: "AzureCapacity"
+        }
+      }
+    }
+  }
+};
+
+export const AzureCapacity: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "AzureCapacity",
+    modelProperties: {
+      scaleType: {
+        serializedName: "scaleType",
+        required: true,
         type: {
           name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      minimum: {
+        serializedName: "minimum",
+        required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      uri: {
-        readOnly: true,
-        serializedName: "properties.uri",
+      maximum: {
+        serializedName: "maximum",
+        required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      dataIngestionUri: {
-        readOnly: true,
-        serializedName: "properties.dataIngestionUri",
+      default: {
+        serializedName: "default",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+
+export const DatabaseListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DatabaseListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Database"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const DatabasePrincipalAssignmentCheckNameRequest: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DatabasePrincipalAssignmentCheckNameRequest",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      stateReason: {
-        readOnly: true,
-        serializedName: "properties.stateReason",
+      type: {
+        defaultValue: "Microsoft.Kusto/clusters/databases/principalAssignments",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
-      },
-      trustedExternalTenants: {
-        serializedName: "properties.trustedExternalTenants",
+      }
+    }
+  }
+};
+
+export const DatabasePrincipalAssignmentListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DatabasePrincipalAssignmentListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "TrustedExternalTenant"
+              className: "DatabasePrincipalAssignment"
             }
           }
         }
-      },
-      optimizedAutoscale: {
-        serializedName: "properties.optimizedAutoscale",
+      }
+    }
+  }
+};
+
+export const DatabasePrincipalListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DatabasePrincipalListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
-          name: "Composite",
-          className: "OptimizedAutoscale"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DatabasePrincipal"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+export const DatabasePrincipal: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DatabasePrincipal",
+    modelProperties: {
+      role: {
+        serializedName: "role",
+        required: true,
+        type: {
+          name: "String"
         }
       },
-      enableDiskEncryption: {
-        serializedName: "properties.enableDiskEncryption",
-        defaultValue: false,
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      enableStreamingIngest: {
-        serializedName: "properties.enableStreamingIngest",
-        defaultValue: false,
+      type: {
+        serializedName: "type",
+        required: true,
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      virtualNetworkConfiguration: {
-        serializedName: "properties.virtualNetworkConfiguration",
+      fqn: {
+        serializedName: "fqn",
         type: {
-          name: "Composite",
-          className: "VirtualNetworkConfiguration"
+          name: "String"
         }
       },
-      keyVaultProperties: {
-        serializedName: "properties.keyVaultProperties",
+      email: {
+        serializedName: "email",
         type: {
-          name: "Composite",
-          className: "KeyVaultProperties"
+          name: "String"
         }
       },
-      enablePurge: {
-        serializedName: "properties.enablePurge",
-        defaultValue: false,
+      appId: {
+        serializedName: "appId",
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      languageExtensions: {
+      tenantName: {
+        serializedName: "tenantName",
         readOnly: true,
-        serializedName: "properties.languageExtensions",
-        type: {
-          name: "Composite",
-          className: "LanguageExtensionsList"
-        }
-      },
-      enableDoubleEncryption: {
-        serializedName: "properties.enableDoubleEncryption",
-        defaultValue: false,
-        type: {
-          name: "Boolean"
-        }
-      },
-      engineType: {
-        serializedName: "properties.engineType",
-        defaultValue: "V3",
-        type: {
-          name: "String"
-        }
-      },
-      etag: {
-        readOnly: true,
-        serializedName: "etag",
         type: {
           name: "String"
         }
@@ -716,205 +1015,287 @@ export const Cluster: msRest.CompositeMapper = {
   }
 };
 
-export const ClusterUpdate: msRest.CompositeMapper = {
-  serializedName: "ClusterUpdate",
+export const DatabasePrincipalListRequest: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ClusterUpdate",
+    className: "DatabasePrincipalListRequest",
     modelProperties: {
-      ...Resource.type.modelProperties,
-      tags: {
-        serializedName: "tags",
+      value: {
+        serializedName: "value",
         type: {
-          name: "Dictionary",
-          value: {
+          name: "Sequence",
+          element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "DatabasePrincipal"
             }
           }
         }
-      },
-      location: {
-        serializedName: "location",
+      }
+    }
+  }
+};
+
+export const ScriptListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ScriptListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Script"
+            }
+          }
         }
-      },
-      sku: {
-        serializedName: "sku",
+      }
+    }
+  }
+};
+
+export const ManagedPrivateEndpointListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ManagedPrivateEndpointListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
-          name: "Composite",
-          className: "AzureSku"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ManagedPrivateEndpoint"
+            }
+          }
         }
-      },
-      identity: {
-        serializedName: "identity",
+      }
+    }
+  }
+};
+
+export const PrivateEndpointConnectionListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateEndpointConnectionListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
-          name: "Composite",
-          className: "Identity"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "PrivateEndpointConnection"
+            }
+          }
         }
-      },
-      state: {
+      }
+    }
+  }
+};
+
+export const PrivateEndpointProperty: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateEndpointProperty",
+    modelProperties: {
+      id: {
+        serializedName: "id",
         readOnly: true,
-        serializedName: "properties.state",
-        type: {
-          name: "String"
-        }
-      },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
         type: {
           name: "String"
         }
-      },
-      uri: {
-        readOnly: true,
-        serializedName: "properties.uri",
+      }
+    }
+  }
+};
+
+export const PrivateLinkServiceConnectionStateProperty: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateLinkServiceConnectionStateProperty",
+    modelProperties: {
+      status: {
+        serializedName: "status",
         type: {
           name: "String"
         }
       },
-      dataIngestionUri: {
-        readOnly: true,
-        serializedName: "properties.dataIngestionUri",
+      description: {
+        serializedName: "description",
         type: {
           name: "String"
         }
       },
-      stateReason: {
+      actionsRequired: {
+        serializedName: "actionsRequired",
         readOnly: true,
-        serializedName: "properties.stateReason",
         type: {
           name: "String"
         }
-      },
-      trustedExternalTenants: {
-        serializedName: "properties.trustedExternalTenants",
+      }
+    }
+  }
+};
+
+export const PrivateLinkResourceListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "PrivateLinkResourceListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "TrustedExternalTenant"
+              className: "PrivateLinkResource"
             }
           }
         }
-      },
-      optimizedAutoscale: {
-        serializedName: "properties.optimizedAutoscale",
-        type: {
-          name: "Composite",
-          className: "OptimizedAutoscale"
-        }
-      },
-      enableDiskEncryption: {
-        serializedName: "properties.enableDiskEncryption",
-        defaultValue: false,
-        type: {
-          name: "Boolean"
-        }
-      },
-      enableStreamingIngest: {
-        serializedName: "properties.enableStreamingIngest",
-        defaultValue: false,
-        type: {
-          name: "Boolean"
-        }
-      },
-      virtualNetworkConfiguration: {
-        serializedName: "properties.virtualNetworkConfiguration",
-        type: {
-          name: "Composite",
-          className: "VirtualNetworkConfiguration"
-        }
-      },
-      keyVaultProperties: {
-        serializedName: "properties.keyVaultProperties",
-        type: {
-          name: "Composite",
-          className: "KeyVaultProperties"
-        }
-      },
-      enablePurge: {
-        serializedName: "properties.enablePurge",
-        defaultValue: false,
+      }
+    }
+  }
+};
+
+export const OutboundNetworkDependenciesEndpointListResult: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "OutboundNetworkDependenciesEndpointListResult",
+    modelProperties: {
+      value: {
+        serializedName: "value",
+        required: true,
         type: {
-          name: "Boolean"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "OutboundNetworkDependenciesEndpoint"
+            }
+          }
         }
       },
-      languageExtensions: {
+      nextLink: {
+        serializedName: "nextLink",
         readOnly: true,
-        serializedName: "properties.languageExtensions",
         type: {
-          name: "Composite",
-          className: "LanguageExtensionsList"
+          name: "String"
         }
-      },
-      enableDoubleEncryption: {
-        serializedName: "properties.enableDoubleEncryption",
-        defaultValue: false,
+      }
+    }
+  }
+};
+
+export const EndpointDependency: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "EndpointDependency",
+    modelProperties: {
+      domainName: {
+        serializedName: "domainName",
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      engineType: {
-        serializedName: "properties.engineType",
-        defaultValue: "V3",
+      endpointDetails: {
+        serializedName: "endpointDetails",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "EndpointDetail"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const ProxyResource: msRest.CompositeMapper = {
-  serializedName: "ProxyResource",
+export const EndpointDetail: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ProxyResource",
+    className: "EndpointDetail",
     modelProperties: {
-      ...Resource.type.modelProperties
+      port: {
+        serializedName: "port",
+        type: {
+          name: "Number"
+        }
+      }
     }
   }
 };
 
-export const AttachedDatabaseConfiguration: msRest.CompositeMapper = {
-  serializedName: "AttachedDatabaseConfiguration",
+export const AttachedDatabaseConfigurationListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AttachedDatabaseConfiguration",
+    className: "AttachedDatabaseConfigurationListResult",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      location: {
-        serializedName: "location",
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "AttachedDatabaseConfiguration"
+            }
+          }
         }
-      },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      }
+    }
+  }
+};
+
+export const TableLevelSharingProperties: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "TableLevelSharingProperties",
+    modelProperties: {
+      tablesToInclude: {
+        serializedName: "tablesToInclude",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      databaseName: {
-        required: true,
-        serializedName: "properties.databaseName",
+      tablesToExclude: {
+        serializedName: "tablesToExclude",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      clusterResourceId: {
-        required: true,
-        serializedName: "properties.clusterResourceId",
+      externalTablesToInclude: {
+        serializedName: "externalTablesToInclude",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      attachedDatabaseNames: {
-        readOnly: true,
-        serializedName: "properties.attachedDatabaseNames",
+      externalTablesToExclude: {
+        serializedName: "externalTablesToExclude",
         type: {
           name: "Sequence",
           element: {
@@ -924,206 +1305,151 @@ export const AttachedDatabaseConfiguration: msRest.CompositeMapper = {
           }
         }
       },
-      defaultPrincipalsModificationKind: {
-        required: true,
-        serializedName: "properties.defaultPrincipalsModificationKind",
+      materializedViewsToInclude: {
+        serializedName: "materializedViewsToInclude",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      tableLevelSharingProperties: {
-        serializedName: "properties.tableLevelSharingProperties",
+      materializedViewsToExclude: {
+        serializedName: "materializedViewsToExclude",
         type: {
-          name: "Composite",
-          className: "TableLevelSharingProperties"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const Database: msRest.CompositeMapper = {
-  serializedName: "Database",
+export const DataConnectionListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    polymorphicDiscriminator: {
-      serializedName: "kind",
-      clientName: "kind"
-    },
-    uberParent: "Database",
-    className: "Database",
+    className: "DataConnectionListResult",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      location: {
-        serializedName: "location",
-        type: {
-          name: "String"
-        }
-      },
-      kind: {
-        required: true,
-        serializedName: "kind",
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataConnection"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const ReadWriteDatabase: msRest.CompositeMapper = {
-  serializedName: "ReadWrite",
+export const DataConnectionValidation: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    polymorphicDiscriminator: Database.type.polymorphicDiscriminator,
-    uberParent: "Database",
-    className: "ReadWriteDatabase",
+    className: "DataConnectionValidation",
     modelProperties: {
-      ...Database.type.modelProperties,
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      dataConnectionName: {
+        serializedName: "dataConnectionName",
         type: {
           name: "String"
         }
       },
-      softDeletePeriod: {
-        serializedName: "properties.softDeletePeriod",
-        type: {
-          name: "TimeSpan"
-        }
-      },
-      hotCachePeriod: {
-        serializedName: "properties.hotCachePeriod",
-        type: {
-          name: "TimeSpan"
-        }
-      },
-      statistics: {
-        serializedName: "properties.statistics",
+      properties: {
+        serializedName: "properties",
         type: {
           name: "Composite",
-          className: "DatabaseStatistics"
-        }
-      },
-      isFollowed: {
-        readOnly: true,
-        serializedName: "properties.isFollowed",
-        type: {
-          name: "Boolean"
+          className: "DataConnection"
         }
       }
     }
   }
 };
 
-export const ReadOnlyFollowingDatabase: msRest.CompositeMapper = {
-  serializedName: "ReadOnlyFollowing",
+export const DataConnectionValidationListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    polymorphicDiscriminator: Database.type.polymorphicDiscriminator,
-    uberParent: "Database",
-    className: "ReadOnlyFollowingDatabase",
+    className: "DataConnectionValidationListResult",
     modelProperties: {
-      ...Database.type.modelProperties,
-      provisioningState: {
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "String"
-        }
-      },
-      softDeletePeriod: {
-        readOnly: true,
-        serializedName: "properties.softDeletePeriod",
-        type: {
-          name: "TimeSpan"
-        }
-      },
-      hotCachePeriod: {
-        serializedName: "properties.hotCachePeriod",
-        type: {
-          name: "TimeSpan"
-        }
-      },
-      statistics: {
-        serializedName: "properties.statistics",
-        type: {
-          name: "Composite",
-          className: "DatabaseStatistics"
-        }
-      },
-      leaderClusterResourceId: {
-        readOnly: true,
-        serializedName: "properties.leaderClusterResourceId",
-        type: {
-          name: "String"
-        }
-      },
-      attachedDatabaseConfigurationName: {
-        readOnly: true,
-        serializedName: "properties.attachedDatabaseConfigurationName",
-        type: {
-          name: "String"
-        }
-      },
-      principalsModificationKind: {
-        readOnly: true,
-        serializedName: "properties.principalsModificationKind",
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "DataConnectionValidationResult"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const DatabasePrincipal: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipal",
+export const DataConnectionValidationResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DatabasePrincipal",
+    className: "DataConnectionValidationResult",
     modelProperties: {
-      role: {
-        required: true,
-        serializedName: "role",
+      errorMessage: {
+        serializedName: "errorMessage",
         type: {
           name: "String"
         }
-      },
+      }
+    }
+  }
+};
+
+export const DataConnectionCheckNameRequest: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "DataConnectionCheckNameRequest",
+    modelProperties: {
       name: {
-        required: true,
         serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
       type: {
-        required: true,
+        defaultValue: "Microsoft.Kusto/clusters/databases/dataConnections",
+        isConstant: true,
         serializedName: "type",
         type: {
           name: "String"
         }
-      },
-      fqn: {
-        serializedName: "fqn",
-        type: {
-          name: "String"
-        }
-      },
-      email: {
-        serializedName: "email",
-        type: {
-          name: "String"
-        }
-      },
-      appId: {
-        serializedName: "appId",
+      }
+    }
+  }
+};
+
+export const ScriptCheckNameRequest: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "ScriptCheckNameRequest",
+    modelProperties: {
+      name: {
+        serializedName: "name",
+        required: true,
         type: {
           name: "String"
         }
       },
-      tenantName: {
-        readOnly: true,
-        serializedName: "tenantName",
+      type: {
+        defaultValue: "Microsoft.Kusto/clusters/databases/scripts",
+        isConstant: true,
+        serializedName: "type",
         type: {
           name: "String"
         }
@@ -1132,114 +1458,93 @@ export const DatabasePrincipal: msRest.CompositeMapper = {
   }
 };
 
-export const DatabasePrincipalAssignment: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipalAssignment",
+export const OperationListResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DatabasePrincipalAssignment",
+    className: "OperationListResult",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      principalId: {
-        required: true,
-        serializedName: "properties.principalId",
-        type: {
-          name: "String"
-        }
-      },
-      role: {
-        required: true,
-        serializedName: "properties.role",
+      value: {
+        serializedName: "value",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Operation"
+            }
+          }
         }
       },
-      tenantId: {
-        serializedName: "properties.tenantId",
+      nextLink: {
+        serializedName: "nextLink",
         type: {
           name: "String"
         }
-      },
-      principalType: {
-        required: true,
-        serializedName: "properties.principalType",
+      }
+    }
+  }
+};
+
+export const Operation: coreClient.CompositeMapper = {
+  type: {
+    name: "Composite",
+    className: "Operation",
+    modelProperties: {
+      name: {
+        serializedName: "name",
         type: {
           name: "String"
         }
       },
-      tenantName: {
-        readOnly: true,
-        serializedName: "properties.tenantName",
+      display: {
+        serializedName: "display",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "OperationDisplay"
         }
       },
-      principalName: {
-        readOnly: true,
-        serializedName: "properties.principalName",
+      origin: {
+        serializedName: "origin",
         type: {
           name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      properties: {
+        serializedName: "properties",
         type: {
-          name: "String"
+          name: "Dictionary",
+          value: { type: { name: "any" } }
         }
       }
     }
   }
 };
 
-export const ClusterPrincipalAssignment: msRest.CompositeMapper = {
-  serializedName: "ClusterPrincipalAssignment",
+export const OperationDisplay: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ClusterPrincipalAssignment",
+    className: "OperationDisplay",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      principalId: {
-        required: true,
-        serializedName: "properties.principalId",
-        type: {
-          name: "String"
-        }
-      },
-      role: {
-        required: true,
-        serializedName: "properties.role",
-        type: {
-          name: "String"
-        }
-      },
-      tenantId: {
-        serializedName: "properties.tenantId",
-        type: {
-          name: "String"
-        }
-      },
-      principalType: {
-        required: true,
-        serializedName: "properties.principalType",
+      provider: {
+        serializedName: "provider",
         type: {
           name: "String"
         }
       },
-      tenantName: {
-        readOnly: true,
-        serializedName: "properties.tenantName",
+      operation: {
+        serializedName: "operation",
         type: {
           name: "String"
         }
       },
-      principalName: {
-        readOnly: true,
-        serializedName: "properties.principalName",
+      resource: {
+        serializedName: "resource",
         type: {
           name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      description: {
+        serializedName: "description",
         type: {
           name: "String"
         }
@@ -1248,156 +1553,113 @@ export const ClusterPrincipalAssignment: msRest.CompositeMapper = {
   }
 };
 
-export const SystemData: msRest.CompositeMapper = {
-  serializedName: "systemData",
+export const OperationResult: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SystemData",
+    className: "OperationResult",
     modelProperties: {
-      createdBy: {
-        serializedName: "createdBy",
+      id: {
+        serializedName: "id",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      createdByType: {
-        serializedName: "createdByType",
+      name: {
+        serializedName: "name",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      createdAt: {
-        serializedName: "createdAt",
-        type: {
-          name: "DateTime"
-        }
-      },
-      lastModifiedBy: {
-        serializedName: "lastModifiedBy",
+      status: {
+        serializedName: "status",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      lastModifiedByType: {
-        serializedName: "lastModifiedByType",
+      startTime: {
+        serializedName: "startTime",
         type: {
-          name: "String"
+          name: "DateTime"
         }
       },
-      lastModifiedAt: {
-        serializedName: "lastModifiedAt",
+      endTime: {
+        serializedName: "endTime",
         type: {
           name: "DateTime"
         }
-      }
-    }
-  }
-};
-
-export const Script: msRest.CompositeMapper = {
-  serializedName: "Script",
-  type: {
-    name: "Composite",
-    className: "Script",
-    modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      scriptUrl: {
-        required: true,
-        serializedName: "properties.scriptUrl",
-        type: {
-          name: "String"
-        }
       },
-      scriptUrlSasToken: {
-        required: true,
-        serializedName: "properties.scriptUrlSasToken",
+      percentComplete: {
+        constraints: {
+          InclusiveMaximum: 100,
+          InclusiveMinimum: 0
+        },
+        serializedName: "percentComplete",
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      forceUpdateTag: {
-        serializedName: "properties.forceUpdateTag",
+      code: {
+        serializedName: "error.code",
         type: {
           name: "String"
         }
       },
-      continueOnErrors: {
-        serializedName: "properties.continueOnErrors",
-        defaultValue: false,
+      message: {
+        serializedName: "error.message",
         type: {
-          name: "Boolean"
+          name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      operationKind: {
+        serializedName: "properties.operationKind",
         type: {
           name: "String"
         }
       },
-      systemData: {
-        readOnly: true,
-        serializedName: "systemData",
+      operationState: {
+        serializedName: "properties.operationState",
         type: {
-          name: "Composite",
-          className: "SystemData"
+          name: "String"
         }
       }
     }
   }
 };
 
-export const FollowerDatabaseDefinition: msRest.CompositeMapper = {
-  serializedName: "FollowerDatabaseDefinition",
+export const DatabaseStatistics: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "FollowerDatabaseDefinition",
+    className: "DatabaseStatistics",
     modelProperties: {
-      clusterResourceId: {
-        required: true,
-        serializedName: "clusterResourceId",
-        type: {
-          name: "String"
-        }
-      },
-      attachedDatabaseConfigurationName: {
-        required: true,
-        serializedName: "attachedDatabaseConfigurationName",
-        type: {
-          name: "String"
-        }
-      },
-      databaseName: {
-        readOnly: true,
-        serializedName: "databaseName",
+      size: {
+        serializedName: "size",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
   }
 };
 
-export const DataConnection: msRest.CompositeMapper = {
-  serializedName: "DataConnection",
+export const TrackedResource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    polymorphicDiscriminator: {
-      serializedName: "kind",
-      clientName: "kind"
-    },
-    uberParent: "DataConnection",
-    className: "DataConnection",
+    className: "TrackedResource",
     modelProperties: {
-      ...ProxyResource.type.modelProperties,
-      location: {
-        serializedName: "location",
+      ...Resource.type.modelProperties,
+      tags: {
+        serializedName: "tags",
         type: {
-          name: "String"
+          name: "Dictionary",
+          value: { type: { name: "String" } }
         }
       },
-      kind: {
+      location: {
+        serializedName: "location",
         required: true,
-        serializedName: "kind",
         type: {
           name: "String"
         }
@@ -1406,206 +1668,151 @@ export const DataConnection: msRest.CompositeMapper = {
   }
 };
 
-export const DataConnectionValidationResult: msRest.CompositeMapper = {
-  serializedName: "DataConnectionValidationResult",
+export const ClusterUpdate: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DataConnectionValidationResult",
+    className: "ClusterUpdate",
     modelProperties: {
-      errorMessage: {
-        serializedName: "errorMessage",
+      ...Resource.type.modelProperties,
+      tags: {
+        serializedName: "tags",
+        type: {
+          name: "Dictionary",
+          value: { type: { name: "String" } }
+        }
+      },
+      location: {
+        serializedName: "location",
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const DatabasePrincipalListRequest: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipalListRequest",
-  type: {
-    name: "Composite",
-    className: "DatabasePrincipalListRequest",
-    modelProperties: {
-      value: {
-        serializedName: "value",
+      },
+      sku: {
+        serializedName: "sku",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "DatabasePrincipal"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const DiagnoseVirtualNetworkResult: msRest.CompositeMapper = {
-  serializedName: "DiagnoseVirtualNetworkResult",
-  type: {
-    name: "Composite",
-    className: "DiagnoseVirtualNetworkResult",
-    modelProperties: {
-      findings: {
-        serializedName: "findings",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "String"
-            }
-          }
-        }
-      }
-    }
-  }
-};
-
-export const DataConnectionValidation: msRest.CompositeMapper = {
-  serializedName: "DataConnectionValidation",
-  type: {
-    name: "Composite",
-    className: "DataConnectionValidation",
-    modelProperties: {
-      dataConnectionName: {
-        serializedName: "dataConnectionName",
-        type: {
-          name: "String"
+          name: "Composite",
+          className: "AzureSku"
         }
       },
-      properties: {
-        serializedName: "properties",
+      identity: {
+        serializedName: "identity",
         type: {
           name: "Composite",
-          className: "DataConnection"
+          className: "Identity"
         }
-      }
-    }
-  }
-};
-
-export const EventHubDataConnection: msRest.CompositeMapper = {
-  serializedName: "EventHub",
-  type: {
-    name: "Composite",
-    polymorphicDiscriminator: DataConnection.type.polymorphicDiscriminator,
-    uberParent: "DataConnection",
-    className: "EventHubDataConnection",
-    modelProperties: {
-      ...DataConnection.type.modelProperties,
-      eventHubResourceId: {
-        required: true,
-        serializedName: "properties.eventHubResourceId",
+      },
+      state: {
+        serializedName: "properties.state",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      consumerGroup: {
-        required: true,
-        serializedName: "properties.consumerGroup",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      tableName: {
-        serializedName: "properties.tableName",
+      uri: {
+        serializedName: "properties.uri",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      mappingRuleName: {
-        serializedName: "properties.mappingRuleName",
+      dataIngestionUri: {
+        serializedName: "properties.dataIngestionUri",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      dataFormat: {
-        serializedName: "properties.dataFormat",
+      stateReason: {
+        serializedName: "properties.stateReason",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      eventSystemProperties: {
-        serializedName: "properties.eventSystemProperties",
+      trustedExternalTenants: {
+        serializedName: "properties.trustedExternalTenants",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "String"
+              name: "Composite",
+              className: "TrustedExternalTenant"
             }
           }
         }
       },
-      compression: {
-        serializedName: "properties.compression",
-        defaultValue: "None",
+      optimizedAutoscale: {
+        serializedName: "properties.optimizedAutoscale",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "OptimizedAutoscale"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
+      enableDiskEncryption: {
+        defaultValue: false,
+        serializedName: "properties.enableDiskEncryption",
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      managedIdentityResourceId: {
-        serializedName: "properties.managedIdentityResourceId",
+      enableStreamingIngest: {
+        defaultValue: false,
+        serializedName: "properties.enableStreamingIngest",
         type: {
-          name: "String"
+          name: "Boolean"
         }
-      }
-    }
-  }
-};
-
-export const IotHubDataConnection: msRest.CompositeMapper = {
-  serializedName: "IotHub",
-  type: {
-    name: "Composite",
-    polymorphicDiscriminator: DataConnection.type.polymorphicDiscriminator,
-    uberParent: "DataConnection",
-    className: "IotHubDataConnection",
-    modelProperties: {
-      ...DataConnection.type.modelProperties,
-      iotHubResourceId: {
-        required: true,
-        serializedName: "properties.iotHubResourceId",
+      },
+      virtualNetworkConfiguration: {
+        serializedName: "properties.virtualNetworkConfiguration",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "VirtualNetworkConfiguration"
         }
       },
-      consumerGroup: {
-        required: true,
-        serializedName: "properties.consumerGroup",
+      keyVaultProperties: {
+        serializedName: "properties.keyVaultProperties",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "KeyVaultProperties"
         }
       },
-      tableName: {
-        serializedName: "properties.tableName",
+      enablePurge: {
+        defaultValue: false,
+        serializedName: "properties.enablePurge",
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      mappingRuleName: {
-        serializedName: "properties.mappingRuleName",
+      languageExtensions: {
+        serializedName: "properties.languageExtensions",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "LanguageExtensionsList"
         }
       },
-      dataFormat: {
-        serializedName: "properties.dataFormat",
+      enableDoubleEncryption: {
+        defaultValue: false,
+        serializedName: "properties.enableDoubleEncryption",
+        type: {
+          name: "Boolean"
+        }
+      },
+      publicNetworkAccess: {
+        defaultValue: "Enabled",
+        serializedName: "properties.publicNetworkAccess",
         type: {
           name: "String"
         }
       },
-      eventSystemProperties: {
-        serializedName: "properties.eventSystemProperties",
+      allowedIpRangeList: {
+        serializedName: "properties.allowedIpRangeList",
         type: {
           name: "Sequence",
           element: {
@@ -1615,107 +1822,45 @@ export const IotHubDataConnection: msRest.CompositeMapper = {
           }
         }
       },
-      sharedAccessPolicyName: {
-        required: true,
-        serializedName: "properties.sharedAccessPolicyName",
-        type: {
-          name: "String"
-        }
-      },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const EventGridDataConnection: msRest.CompositeMapper = {
-  serializedName: "EventGrid",
-  type: {
-    name: "Composite",
-    polymorphicDiscriminator: DataConnection.type.polymorphicDiscriminator,
-    uberParent: "DataConnection",
-    className: "EventGridDataConnection",
-    modelProperties: {
-      ...DataConnection.type.modelProperties,
-      storageAccountResourceId: {
-        required: true,
-        serializedName: "properties.storageAccountResourceId",
-        type: {
-          name: "String"
-        }
-      },
-      eventHubResourceId: {
-        required: true,
-        serializedName: "properties.eventHubResourceId",
-        type: {
-          name: "String"
-        }
-      },
-      consumerGroup: {
-        required: true,
-        serializedName: "properties.consumerGroup",
-        type: {
-          name: "String"
-        }
-      },
-      tableName: {
-        serializedName: "properties.tableName",
-        type: {
-          name: "String"
-        }
-      },
-      mappingRuleName: {
-        serializedName: "properties.mappingRuleName",
+      engineType: {
+        defaultValue: "V3",
+        serializedName: "properties.engineType",
         type: {
           name: "String"
         }
       },
-      dataFormat: {
-        serializedName: "properties.dataFormat",
+      acceptedAudiences: {
+        serializedName: "properties.acceptedAudiences",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "AcceptedAudiences"
+            }
+          }
         }
       },
-      ignoreFirstRecord: {
-        serializedName: "properties.ignoreFirstRecord",
+      enableAutoStop: {
+        defaultValue: true,
+        serializedName: "properties.enableAutoStop",
         type: {
           name: "Boolean"
         }
       },
-      blobStorageEventType: {
-        serializedName: "properties.blobStorageEventType",
+      restrictOutboundNetworkAccess: {
+        serializedName: "properties.restrictOutboundNetworkAccess",
         type: {
           name: "String"
         }
       },
-      provisioningState: {
-        serializedName: "properties.provisioningState",
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
-export const DataConnectionValidationListResult: msRest.CompositeMapper = {
-  serializedName: "DataConnectionValidationListResult",
-  type: {
-    name: "Composite",
-    className: "DataConnectionValidationListResult",
-    modelProperties: {
-      value: {
-        serializedName: "value",
+      allowedFqdnList: {
+        serializedName: "properties.allowedFqdnList",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "DataConnectionValidationResult"
+              name: "String"
             }
           }
         }
@@ -1724,353 +1869,324 @@ export const DataConnectionValidationListResult: msRest.CompositeMapper = {
   }
 };
 
-export const ClusterCheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "ClusterCheckNameRequest",
+export const ProxyResource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ClusterCheckNameRequest",
+    className: "ProxyResource",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
-        type: {
-          name: "String"
-        }
-      },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: "Microsoft.Kusto/clusters",
-        type: {
-          name: "String"
-        }
-      }
+      ...Resource.type.modelProperties
     }
   }
 };
 
-export const CheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "CheckNameRequest",
+export const PrivateLinkResource: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "CheckNameRequest",
+    className: "PrivateLinkResource",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      ...Resource.type.modelProperties,
+      systemData: {
+        serializedName: "systemData",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "SystemData"
         }
       },
-      type: {
-        required: true,
-        serializedName: "type",
+      groupId: {
+        serializedName: "properties.groupId",
+        readOnly: true,
         type: {
-          name: "Enum",
-          allowedValues: [
-            "Microsoft.Kusto/clusters/databases",
-            "Microsoft.Kusto/clusters/attachedDatabaseConfigurations"
-          ]
+          name: "String"
         }
-      }
-    }
-  }
-};
-
-export const ClusterPrincipalAssignmentCheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "ClusterPrincipalAssignmentCheckNameRequest",
-  type: {
-    name: "Composite",
-    className: "ClusterPrincipalAssignmentCheckNameRequest",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      requiredMembers: {
+        serializedName: "properties.requiredMembers",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: "Microsoft.Kusto/clusters/principalAssignments",
+      requiredZoneNames: {
+        serializedName: "properties.requiredZoneNames",
+        readOnly: true,
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const DataConnectionCheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "DataConnectionCheckNameRequest",
+export const Cluster: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DataConnectionCheckNameRequest",
+    className: "Cluster",
     modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      ...TrackedResource.type.modelProperties,
+      sku: {
+        serializedName: "sku",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "AzureSku"
         }
       },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: "Microsoft.Kusto/clusters/databases/dataConnections",
+      systemData: {
+        serializedName: "systemData",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "SystemData"
         }
-      }
-    }
-  }
-};
-
-export const ScriptCheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "ScriptCheckNameRequest",
-  type: {
-    name: "Composite",
-    className: "ScriptCheckNameRequest",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      zones: {
+        serializedName: "zones",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: "Microsoft.Kusto/clusters/databases/scripts",
+      identity: {
+        serializedName: "identity",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "Identity"
         }
-      }
-    }
-  }
-};
-
-export const DatabasePrincipalAssignmentCheckNameRequest: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipalAssignmentCheckNameRequest",
-  type: {
-    name: "Composite",
-    className: "DatabasePrincipalAssignmentCheckNameRequest",
-    modelProperties: {
-      name: {
-        required: true,
-        serializedName: "name",
+      },
+      etag: {
+        serializedName: "etag",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      type: {
-        required: true,
-        isConstant: true,
-        serializedName: "type",
-        defaultValue: "Microsoft.Kusto/clusters/databases/principalAssignments",
+      state: {
+        serializedName: "properties.state",
+        readOnly: true,
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const CheckNameResult: msRest.CompositeMapper = {
-  serializedName: "CheckNameResult",
-  type: {
-    name: "Composite",
-    className: "CheckNameResult",
-    modelProperties: {
-      nameAvailable: {
-        serializedName: "nameAvailable",
-        type: {
-          name: "Boolean"
-        }
       },
-      name: {
-        serializedName: "name",
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      message: {
-        serializedName: "message",
+      uri: {
+        serializedName: "properties.uri",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      reason: {
-        serializedName: "reason",
+      dataIngestionUri: {
+        serializedName: "properties.dataIngestionUri",
+        readOnly: true,
         type: {
           name: "String"
         }
-      }
-    }
-  }
-};
-
-export const OperationDisplay: msRest.CompositeMapper = {
-  serializedName: "Operation_display",
-  type: {
-    name: "Composite",
-    className: "OperationDisplay",
-    modelProperties: {
-      provider: {
-        serializedName: "provider",
+      },
+      stateReason: {
+        serializedName: "properties.stateReason",
+        readOnly: true,
         type: {
           name: "String"
         }
       },
-      operation: {
-        serializedName: "operation",
+      trustedExternalTenants: {
+        serializedName: "properties.trustedExternalTenants",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "TrustedExternalTenant"
+            }
+          }
         }
       },
-      resource: {
-        serializedName: "resource",
+      optimizedAutoscale: {
+        serializedName: "properties.optimizedAutoscale",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "OptimizedAutoscale"
         }
       },
-      description: {
-        serializedName: "description",
+      enableDiskEncryption: {
+        defaultValue: false,
+        serializedName: "properties.enableDiskEncryption",
         type: {
-          name: "String"
+          name: "Boolean"
         }
-      }
-    }
-  }
-};
-
-export const Operation: msRest.CompositeMapper = {
-  serializedName: "Operation",
-  type: {
-    name: "Composite",
-    className: "Operation",
-    modelProperties: {
-      name: {
-        serializedName: "name",
+      },
+      enableStreamingIngest: {
+        defaultValue: false,
+        serializedName: "properties.enableStreamingIngest",
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      display: {
-        serializedName: "display",
+      virtualNetworkConfiguration: {
+        serializedName: "properties.virtualNetworkConfiguration",
         type: {
           name: "Composite",
-          className: "OperationDisplay"
+          className: "VirtualNetworkConfiguration"
         }
       },
-      origin: {
-        serializedName: "origin",
+      keyVaultProperties: {
+        serializedName: "properties.keyVaultProperties",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "KeyVaultProperties"
         }
       },
-      properties: {
-        serializedName: "properties",
+      enablePurge: {
+        defaultValue: false,
+        serializedName: "properties.enablePurge",
         type: {
-          name: "Object"
-        }
-      }
-    }
-  }
-};
-
-export const OperationResult: msRest.CompositeMapper = {
-  serializedName: "OperationResult",
-  type: {
-    name: "Composite",
-    className: "OperationResult",
-    modelProperties: {
-      id: {
-        readOnly: true,
-        serializedName: "id",
-        type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      name: {
-        readOnly: true,
-        serializedName: "name",
+      languageExtensions: {
+        serializedName: "properties.languageExtensions",
         type: {
-          name: "String"
+          name: "Composite",
+          className: "LanguageExtensionsList"
         }
       },
-      status: {
-        serializedName: "status",
+      enableDoubleEncryption: {
+        defaultValue: false,
+        serializedName: "properties.enableDoubleEncryption",
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      startTime: {
-        serializedName: "startTime",
+      publicNetworkAccess: {
+        defaultValue: "Enabled",
+        serializedName: "properties.publicNetworkAccess",
         type: {
-          name: "DateTime"
+          name: "String"
         }
       },
-      endTime: {
-        serializedName: "endTime",
+      allowedIpRangeList: {
+        serializedName: "properties.allowedIpRangeList",
         type: {
-          name: "DateTime"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       },
-      percentComplete: {
-        serializedName: "percentComplete",
-        constraints: {
-          InclusiveMaximum: 100,
-          InclusiveMinimum: 0
-        },
+      engineType: {
+        defaultValue: "V3",
+        serializedName: "properties.engineType",
         type: {
-          name: "Number"
+          name: "String"
         }
       },
-      operationKind: {
-        serializedName: "properties.operationKind",
+      acceptedAudiences: {
+        serializedName: "properties.acceptedAudiences",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "AcceptedAudiences"
+            }
+          }
         }
       },
-      operationState: {
-        serializedName: "properties.operationState",
+      enableAutoStop: {
+        defaultValue: true,
+        serializedName: "properties.enableAutoStop",
         type: {
-          name: "String"
+          name: "Boolean"
         }
       },
-      code: {
-        serializedName: "error.code",
+      restrictOutboundNetworkAccess: {
+        serializedName: "properties.restrictOutboundNetworkAccess",
         type: {
           name: "String"
         }
       },
-      message: {
-        serializedName: "error.message",
+      allowedFqdnList: {
+        serializedName: "properties.allowedFqdnList",
         type: {
-          name: "String"
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
         }
       }
     }
   }
 };
 
-export const AzureEntityResource: msRest.CompositeMapper = {
-  serializedName: "AzureEntityResource",
+export const ClusterPrincipalAssignment: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "AzureEntityResource",
+    className: "ClusterPrincipalAssignment",
     modelProperties: {
-      ...Resource.type.modelProperties,
-      etag: {
+      ...ProxyResource.type.modelProperties,
+      principalId: {
+        serializedName: "properties.principalId",
+        type: {
+          name: "String"
+        }
+      },
+      role: {
+        serializedName: "properties.role",
+        type: {
+          name: "String"
+        }
+      },
+      tenantId: {
+        serializedName: "properties.tenantId",
+        type: {
+          name: "String"
+        }
+      },
+      principalType: {
+        serializedName: "properties.principalType",
+        type: {
+          name: "String"
+        }
+      },
+      tenantName: {
+        serializedName: "properties.tenantName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      principalName: {
+        serializedName: "properties.principalName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
         readOnly: true,
-        serializedName: "etag",
         type: {
           name: "String"
         }
@@ -2079,291 +2195,671 @@ export const AzureEntityResource: msRest.CompositeMapper = {
   }
 };
 
-export const FollowerDatabaseListResult: msRest.CompositeMapper = {
-  serializedName: "FollowerDatabaseListResult",
+export const Database: coreClient.CompositeMapper = {
+  serializedName: "Database",
   type: {
     name: "Composite",
-    className: "FollowerDatabaseListResult",
+    className: "Database",
+    uberParent: "Resource",
+    polymorphicDiscriminator: {
+      serializedName: "kind",
+      clientName: "kind"
+    },
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      location: {
+        serializedName: "location",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "FollowerDatabaseDefinition"
-            }
-          }
+          name: "String"
+        }
+      },
+      kind: {
+        serializedName: "kind",
+        required: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ClusterListResult: msRest.CompositeMapper = {
-  serializedName: "ClusterListResult",
+export const DatabasePrincipalAssignment: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ClusterListResult",
+    className: "DatabasePrincipalAssignment",
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      principalId: {
+        serializedName: "properties.principalId",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Cluster"
-            }
-          }
+          name: "String"
+        }
+      },
+      role: {
+        serializedName: "properties.role",
+        type: {
+          name: "String"
+        }
+      },
+      tenantId: {
+        serializedName: "properties.tenantId",
+        type: {
+          name: "String"
+        }
+      },
+      principalType: {
+        serializedName: "properties.principalType",
+        type: {
+          name: "String"
+        }
+      },
+      tenantName: {
+        serializedName: "properties.tenantName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      principalName: {
+        serializedName: "properties.principalName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const SkuDescriptionList: msRest.CompositeMapper = {
-  serializedName: "SkuDescriptionList",
+export const Script: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "SkuDescriptionList",
+    className: "Script",
     modelProperties: {
-      value: {
+      ...ProxyResource.type.modelProperties,
+      systemData: {
+        serializedName: "systemData",
+        type: {
+          name: "Composite",
+          className: "SystemData"
+        }
+      },
+      scriptUrl: {
+        serializedName: "properties.scriptUrl",
+        type: {
+          name: "String"
+        }
+      },
+      scriptUrlSasToken: {
+        serializedName: "properties.scriptUrlSasToken",
+        type: {
+          name: "String"
+        }
+      },
+      forceUpdateTag: {
+        serializedName: "properties.forceUpdateTag",
+        type: {
+          name: "String"
+        }
+      },
+      continueOnErrors: {
+        defaultValue: false,
+        serializedName: "properties.continueOnErrors",
+        type: {
+          name: "Boolean"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
         readOnly: true,
-        serializedName: "",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "SkuDescription"
-            }
-          }
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ListResourceSkusResult: msRest.CompositeMapper = {
-  serializedName: "ListResourceSkusResult",
+export const ManagedPrivateEndpoint: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ListResourceSkusResult",
+    className: "ManagedPrivateEndpoint",
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      systemData: {
+        serializedName: "systemData",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "AzureResourceSku"
-            }
-          }
+          name: "Composite",
+          className: "SystemData"
+        }
+      },
+      privateLinkResourceId: {
+        serializedName: "properties.privateLinkResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      privateLinkResourceRegion: {
+        serializedName: "properties.privateLinkResourceRegion",
+        type: {
+          name: "String"
+        }
+      },
+      groupId: {
+        serializedName: "properties.groupId",
+        type: {
+          name: "String"
+        }
+      },
+      requestMessage: {
+        serializedName: "properties.requestMessage",
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const LanguageExtensionsList: msRest.CompositeMapper = {
-  serializedName: "LanguageExtensionsList",
+export const PrivateEndpointConnection: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "LanguageExtensionsList",
+    className: "PrivateEndpointConnection",
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      systemData: {
+        serializedName: "systemData",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "LanguageExtension"
-            }
-          }
+          name: "Composite",
+          className: "SystemData"
+        }
+      },
+      privateEndpoint: {
+        serializedName: "properties.privateEndpoint",
+        type: {
+          name: "Composite",
+          className: "PrivateEndpointProperty"
+        }
+      },
+      privateLinkServiceConnectionState: {
+        serializedName: "properties.privateLinkServiceConnectionState",
+        type: {
+          name: "Composite",
+          className: "PrivateLinkServiceConnectionStateProperty"
+        }
+      },
+      groupId: {
+        serializedName: "properties.groupId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const ClusterPrincipalAssignmentListResult: msRest.CompositeMapper = {
-  serializedName: "ClusterPrincipalAssignmentListResult",
+export const OutboundNetworkDependenciesEndpoint: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "ClusterPrincipalAssignmentListResult",
+    className: "OutboundNetworkDependenciesEndpoint",
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      etag: {
+        serializedName: "etag",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      category: {
+        serializedName: "properties.category",
+        type: {
+          name: "String"
+        }
+      },
+      endpoints: {
+        serializedName: "properties.endpoints",
         type: {
           name: "Sequence",
           element: {
             type: {
               name: "Composite",
-              className: "ClusterPrincipalAssignment"
+              className: "EndpointDependency"
             }
           }
         }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
       }
     }
   }
 };
 
-export const DatabaseListResult: msRest.CompositeMapper = {
-  serializedName: "DatabaseListResult",
+export const AttachedDatabaseConfiguration: coreClient.CompositeMapper = {
   type: {
     name: "Composite",
-    className: "DatabaseListResult",
+    className: "AttachedDatabaseConfiguration",
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      location: {
+        serializedName: "location",
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      databaseName: {
+        serializedName: "properties.databaseName",
+        type: {
+          name: "String"
+        }
+      },
+      clusterResourceId: {
+        serializedName: "properties.clusterResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      attachedDatabaseNames: {
+        serializedName: "properties.attachedDatabaseNames",
+        readOnly: true,
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "Database"
+              name: "String"
             }
           }
         }
+      },
+      defaultPrincipalsModificationKind: {
+        serializedName: "properties.defaultPrincipalsModificationKind",
+        type: {
+          name: "String"
+        }
+      },
+      tableLevelSharingProperties: {
+        serializedName: "properties.tableLevelSharingProperties",
+        type: {
+          name: "Composite",
+          className: "TableLevelSharingProperties"
+        }
       }
     }
   }
 };
 
-export const DatabasePrincipalListResult: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipalListResult",
+export const DataConnection: coreClient.CompositeMapper = {
+  serializedName: "DataConnection",
   type: {
     name: "Composite",
-    className: "DatabasePrincipalListResult",
+    className: "DataConnection",
+    uberParent: "Resource",
+    polymorphicDiscriminator: {
+      serializedName: "kind",
+      clientName: "kind"
+    },
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...ProxyResource.type.modelProperties,
+      location: {
+        serializedName: "location",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "DatabasePrincipal"
-            }
-          }
+          name: "String"
+        }
+      },
+      kind: {
+        serializedName: "kind",
+        required: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const DatabasePrincipalAssignmentListResult: msRest.CompositeMapper = {
-  serializedName: "DatabasePrincipalAssignmentListResult",
+export const ReadWriteDatabase: coreClient.CompositeMapper = {
+  serializedName: "ReadWrite",
   type: {
     name: "Composite",
-    className: "DatabasePrincipalAssignmentListResult",
+    className: "ReadWriteDatabase",
+    uberParent: "Resource",
+    polymorphicDiscriminator: Resource.type.polymorphicDiscriminator,
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...Database.type.modelProperties,
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "DatabasePrincipalAssignment"
-            }
-          }
+          name: "String"
+        }
+      },
+      softDeletePeriod: {
+        serializedName: "properties.softDeletePeriod",
+        type: {
+          name: "TimeSpan"
+        }
+      },
+      hotCachePeriod: {
+        serializedName: "properties.hotCachePeriod",
+        type: {
+          name: "TimeSpan"
+        }
+      },
+      statistics: {
+        serializedName: "properties.statistics",
+        type: {
+          name: "Composite",
+          className: "DatabaseStatistics"
+        }
+      },
+      isFollowed: {
+        serializedName: "properties.isFollowed",
+        readOnly: true,
+        type: {
+          name: "Boolean"
         }
       }
     }
   }
 };
 
-export const ScriptListResult: msRest.CompositeMapper = {
-  serializedName: "ScriptListResult",
+export const ReadOnlyFollowingDatabase: coreClient.CompositeMapper = {
+  serializedName: "ReadOnlyFollowing",
   type: {
     name: "Composite",
-    className: "ScriptListResult",
+    className: "ReadOnlyFollowingDatabase",
+    uberParent: "Resource",
+    polymorphicDiscriminator: Resource.type.polymorphicDiscriminator,
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...Database.type.modelProperties,
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Script"
-            }
-          }
+          name: "String"
+        }
+      },
+      softDeletePeriod: {
+        serializedName: "properties.softDeletePeriod",
+        readOnly: true,
+        type: {
+          name: "TimeSpan"
+        }
+      },
+      hotCachePeriod: {
+        serializedName: "properties.hotCachePeriod",
+        type: {
+          name: "TimeSpan"
+        }
+      },
+      statistics: {
+        serializedName: "properties.statistics",
+        type: {
+          name: "Composite",
+          className: "DatabaseStatistics"
+        }
+      },
+      leaderClusterResourceId: {
+        serializedName: "properties.leaderClusterResourceId",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      attachedDatabaseConfigurationName: {
+        serializedName: "properties.attachedDatabaseConfigurationName",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      principalsModificationKind: {
+        serializedName: "properties.principalsModificationKind",
+        readOnly: true,
+        type: {
+          name: "String"
         }
       }
     }
   }
 };
 
-export const AttachedDatabaseConfigurationListResult: msRest.CompositeMapper = {
-  serializedName: "AttachedDatabaseConfigurationListResult",
+export const EventHubDataConnection: coreClient.CompositeMapper = {
+  serializedName: "EventHub",
   type: {
     name: "Composite",
-    className: "AttachedDatabaseConfigurationListResult",
+    className: "EventHubDataConnection",
+    uberParent: "Resource",
+    polymorphicDiscriminator: Resource.type.polymorphicDiscriminator,
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...DataConnection.type.modelProperties,
+      eventHubResourceId: {
+        serializedName: "properties.eventHubResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      consumerGroup: {
+        serializedName: "properties.consumerGroup",
+        type: {
+          name: "String"
+        }
+      },
+      tableName: {
+        serializedName: "properties.tableName",
+        type: {
+          name: "String"
+        }
+      },
+      mappingRuleName: {
+        serializedName: "properties.mappingRuleName",
+        type: {
+          name: "String"
+        }
+      },
+      dataFormat: {
+        serializedName: "properties.dataFormat",
+        type: {
+          name: "String"
+        }
+      },
+      eventSystemProperties: {
+        serializedName: "properties.eventSystemProperties",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "AttachedDatabaseConfiguration"
+              name: "String"
             }
           }
         }
+      },
+      compression: {
+        defaultValue: "None",
+        serializedName: "properties.compression",
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
+      },
+      managedIdentityResourceId: {
+        serializedName: "properties.managedIdentityResourceId",
+        type: {
+          name: "String"
+        }
       }
     }
   }
 };
 
-export const DataConnectionListResult: msRest.CompositeMapper = {
-  serializedName: "DataConnectionListResult",
+export const IotHubDataConnection: coreClient.CompositeMapper = {
+  serializedName: "IotHub",
   type: {
     name: "Composite",
-    className: "DataConnectionListResult",
+    className: "IotHubDataConnection",
+    uberParent: "Resource",
+    polymorphicDiscriminator: Resource.type.polymorphicDiscriminator,
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...DataConnection.type.modelProperties,
+      iotHubResourceId: {
+        serializedName: "properties.iotHubResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      consumerGroup: {
+        serializedName: "properties.consumerGroup",
+        type: {
+          name: "String"
+        }
+      },
+      tableName: {
+        serializedName: "properties.tableName",
+        type: {
+          name: "String"
+        }
+      },
+      mappingRuleName: {
+        serializedName: "properties.mappingRuleName",
+        type: {
+          name: "String"
+        }
+      },
+      dataFormat: {
+        serializedName: "properties.dataFormat",
+        type: {
+          name: "String"
+        }
+      },
+      eventSystemProperties: {
+        serializedName: "properties.eventSystemProperties",
         type: {
           name: "Sequence",
           element: {
             type: {
-              name: "Composite",
-              className: "DataConnection"
+              name: "String"
             }
           }
         }
+      },
+      sharedAccessPolicyName: {
+        serializedName: "properties.sharedAccessPolicyName",
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
+        type: {
+          name: "String"
+        }
       }
     }
   }
 };
 
-export const OperationListResult: msRest.CompositeMapper = {
-  serializedName: "OperationListResult",
+export const EventGridDataConnection: coreClient.CompositeMapper = {
+  serializedName: "EventGrid",
   type: {
     name: "Composite",
-    className: "OperationListResult",
+    className: "EventGridDataConnection",
+    uberParent: "Resource",
+    polymorphicDiscriminator: Resource.type.polymorphicDiscriminator,
     modelProperties: {
-      value: {
-        serializedName: "",
+      ...DataConnection.type.modelProperties,
+      storageAccountResourceId: {
+        serializedName: "properties.storageAccountResourceId",
         type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Composite",
-              className: "Operation"
-            }
-          }
+          name: "String"
         }
       },
-      nextLink: {
-        serializedName: "nextLink",
+      eventHubResourceId: {
+        serializedName: "properties.eventHubResourceId",
+        type: {
+          name: "String"
+        }
+      },
+      consumerGroup: {
+        serializedName: "properties.consumerGroup",
+        type: {
+          name: "String"
+        }
+      },
+      tableName: {
+        serializedName: "properties.tableName",
+        type: {
+          name: "String"
+        }
+      },
+      mappingRuleName: {
+        serializedName: "properties.mappingRuleName",
+        type: {
+          name: "String"
+        }
+      },
+      dataFormat: {
+        serializedName: "properties.dataFormat",
+        type: {
+          name: "String"
+        }
+      },
+      ignoreFirstRecord: {
+        serializedName: "properties.ignoreFirstRecord",
+        type: {
+          name: "Boolean"
+        }
+      },
+      blobStorageEventType: {
+        serializedName: "properties.blobStorageEventType",
+        type: {
+          name: "String"
+        }
+      },
+      provisioningState: {
+        serializedName: "properties.provisioningState",
+        readOnly: true,
         type: {
           name: "String"
         }
@@ -2372,12 +2868,12 @@ export const OperationListResult: msRest.CompositeMapper = {
   }
 };
 
-export const discriminators = {
-  Database: Database,
-  "Database.ReadWrite": ReadWriteDatabase,
-  "Database.ReadOnlyFollowing": ReadOnlyFollowingDatabase,
-  DataConnection: DataConnection,
-  "DataConnection.EventHub": EventHubDataConnection,
-  "DataConnection.IotHub": IotHubDataConnection,
-  "DataConnection.EventGrid": EventGridDataConnection
+export let discriminators = {
+  "Resource.Database": Database,
+  "Resource.DataConnection": DataConnection,
+  "Resource.ReadWrite": ReadWriteDatabase,
+  "Resource.ReadOnlyFollowing": ReadOnlyFollowingDatabase,
+  "Resource.EventHub": EventHubDataConnection,
+  "Resource.IotHub": IotHubDataConnection,
+  "Resource.EventGrid": EventGridDataConnection
 };