@azure/arm-azurestackhci 3.1.1-alpha.20231017.1 → 4.0.0-beta.1

package/src/operations/{clusters.ts → virtualHardDisksOperations.ts}

@@ -8,44 +8,46 @@
 
 import { PagedAsyncIterableIterator, PageSettings } from "@azure/core-paging";
 import { setContinuationToken } from "../pagingHelper";
-import { Clusters } from "../operationsInterfaces";
+import { VirtualHardDisksOperations } from "../operationsInterfaces";
 import * as coreClient from "@azure/core-client";
 import * as Mappers from "../models/mappers";
 import * as Parameters from "../models/parameters";
 import { AzureStackHCIClient } from "../azureStackHCIClient";
-import { PollerLike, PollOperationState, LroEngine } from "@azure/core-lro";
-import { LroImpl } from "../lroImpl";
 import {
-  Cluster,
-  ClustersListBySubscriptionNextOptionalParams,
-  ClustersListBySubscriptionOptionalParams,
-  ClustersListBySubscriptionResponse,
-  ClustersListByResourceGroupNextOptionalParams,
-  ClustersListByResourceGroupOptionalParams,
-  ClustersListByResourceGroupResponse,
-  ClustersGetOptionalParams,
-  ClustersGetResponse,
-  ClustersCreateOptionalParams,
-  ClustersCreateResponse,
-  ClusterPatch,
-  ClustersUpdateOptionalParams,
-  ClustersUpdateResponse,
-  ClustersDeleteOptionalParams,
-  UploadCertificateRequest,
-  ClustersUploadCertificateOptionalParams,
-  ClustersCreateIdentityOptionalParams,
-  ClustersCreateIdentityResponse,
-  ClustersListBySubscriptionNextResponse,
-  ClustersListByResourceGroupNextResponse
+  SimplePollerLike,
+  OperationState,
+  createHttpPoller
+} from "@azure/core-lro";
+import { createLroSpec } from "../lroImpl";
+import {
+  VirtualHardDisks,
+  VirtualHardDisksListNextOptionalParams,
+  VirtualHardDisksListOptionalParams,
+  VirtualHardDisksListResponse,
+  VirtualHardDisksListAllNextOptionalParams,
+  VirtualHardDisksListAllOptionalParams,
+  VirtualHardDisksListAllResponse,
+  VirtualHardDisksGetOptionalParams,
+  VirtualHardDisksGetResponse,
+  VirtualHardDisksCreateOrUpdateOptionalParams,
+  VirtualHardDisksCreateOrUpdateResponse,
+  VirtualHardDisksDeleteOptionalParams,
+  VirtualHardDisksDeleteResponse,
+  VirtualHardDisksUpdateRequest,
+  VirtualHardDisksUpdateOptionalParams,
+  VirtualHardDisksUpdateResponse,
+  VirtualHardDisksListNextResponse,
+  VirtualHardDisksListAllNextResponse
 } from "../models";
 
 /// <reference lib="esnext.asynciterable" />
-/** Class containing Clusters operations. */
-export class ClustersImpl implements Clusters {
+/** Class containing VirtualHardDisksOperations operations. */
+export class VirtualHardDisksOperationsImpl
+  implements VirtualHardDisksOperations {
   private readonly client: AzureStackHCIClient;
 
   /**
-   * Initialize a new instance of the class Clusters class.
+   * Initialize a new instance of the class VirtualHardDisksOperations class.
    * @param client Reference to the service client
    */
   constructor(client: AzureStackHCIClient) {
@@ -53,13 +55,16 @@ export class ClustersImpl implements Clusters {
   }
 
   /**
-   * List all HCI clusters in a subscription.
+   * Lists all of the virtual hard disks in the specified resource group. Use the nextLink property in
+   * the response to get the next page of virtual hard disks.
+   * @param resourceGroupName The name of the resource group. The name is case insensitive.
    * @param options The options parameters.
    */
-  public listBySubscription(
-    options?: ClustersListBySubscriptionOptionalParams
-  ): PagedAsyncIterableIterator<Cluster> {
-    const iter = this.listBySubscriptionPagingAll(options);
+  public list(
+    resourceGroupName: string,
+    options?: VirtualHardDisksListOptionalParams
+  ): PagedAsyncIterableIterator<VirtualHardDisks> {
+    const iter = this.listPagingAll(resourceGroupName, options);
     return {
       next() {
         return iter.next();
@@ -71,26 +76,31 @@ export class ClustersImpl implements Clusters {
         if (settings?.maxPageSize) {
           throw new Error("maxPageSize is not supported by this operation.");
         }
-        return this.listBySubscriptionPagingPage(options, settings);
+        return this.listPagingPage(resourceGroupName, options, settings);
       }
     };
   }
 
-  private async *listBySubscriptionPagingPage(
-    options?: ClustersListBySubscriptionOptionalParams,
+  private async *listPagingPage(
+    resourceGroupName: string,
+    options?: VirtualHardDisksListOptionalParams,
     settings?: PageSettings
-  ): AsyncIterableIterator<Cluster[]> {
-    let result: ClustersListBySubscriptionResponse;
+  ): AsyncIterableIterator<VirtualHardDisks[]> {
+    let result: VirtualHardDisksListResponse;
     let continuationToken = settings?.continuationToken;
     if (!continuationToken) {
-      result = await this._listBySubscription(options);
+      result = await this._list(resourceGroupName, options);
       let page = result.value || [];
       continuationToken = result.nextLink;
       setContinuationToken(page, continuationToken);
       yield page;
     }
     while (continuationToken) {
-      result = await this._listBySubscriptionNext(continuationToken, options);
+      result = await this._listNext(
+        resourceGroupName,
+        continuationToken,
+        options
+      );
       continuationToken = result.nextLink;
       let page = result.value || [];
       setContinuationToken(page, continuationToken);
@@ -98,24 +108,24 @@ export class ClustersImpl implements Clusters {
     }
   }
 
-  private async *listBySubscriptionPagingAll(
-    options?: ClustersListBySubscriptionOptionalParams
-  ): AsyncIterableIterator<Cluster> {
-    for await (const page of this.listBySubscriptionPagingPage(options)) {
+  private async *listPagingAll(
+    resourceGroupName: string,
+    options?: VirtualHardDisksListOptionalParams
+  ): AsyncIterableIterator<VirtualHardDisks> {
+    for await (const page of this.listPagingPage(resourceGroupName, options)) {
       yield* page;
     }
   }
 
   /**
-   * List all HCI clusters in a resource group.
-   * @param resourceGroupName The name of the resource group. The name is case insensitive.
+   * Lists all of the virtual hard disks in the specified subscription. Use the nextLink property in the
+   * response to get the next page of virtual hard disks.
    * @param options The options parameters.
    */
-  public listByResourceGroup(
-    resourceGroupName: string,
-    options?: ClustersListByResourceGroupOptionalParams
-  ): PagedAsyncIterableIterator<Cluster> {
-    const iter = this.listByResourceGroupPagingAll(resourceGroupName, options);
+  public listAll(
+    options?: VirtualHardDisksListAllOptionalParams
+  ): PagedAsyncIterableIterator<VirtualHardDisks> {
+    const iter = this.listAllPagingAll(options);
     return {
       next() {
         return iter.next();
@@ -127,35 +137,26 @@ export class ClustersImpl implements Clusters {
         if (settings?.maxPageSize) {
           throw new Error("maxPageSize is not supported by this operation.");
         }
-        return this.listByResourceGroupPagingPage(
-          resourceGroupName,
-          options,
-          settings
-        );
+        return this.listAllPagingPage(options, settings);
       }
     };
   }
 
-  private async *listByResourceGroupPagingPage(
-    resourceGroupName: string,
-    options?: ClustersListByResourceGroupOptionalParams,
+  private async *listAllPagingPage(
+    options?: VirtualHardDisksListAllOptionalParams,
     settings?: PageSettings
-  ): AsyncIterableIterator<Cluster[]> {
-    let result: ClustersListByResourceGroupResponse;
+  ): AsyncIterableIterator<VirtualHardDisks[]> {
+    let result: VirtualHardDisksListAllResponse;
     let continuationToken = settings?.continuationToken;
     if (!continuationToken) {
-      result = await this._listByResourceGroup(resourceGroupName, options);
+      result = await this._listAll(options);
       let page = result.value || [];
       continuationToken = result.nextLink;
       setContinuationToken(page, continuationToken);
       yield page;
     }
     while (continuationToken) {
-      result = await this._listByResourceGroupNext(
-        resourceGroupName,
-        continuationToken,
-        options
-      );
+      result = await this._listAllNext(continuationToken, options);
       continuationToken = result.nextLink;
       let page = result.value || [];
       setContinuationToken(page, continuationToken);
@@ -163,119 +164,57 @@ export class ClustersImpl implements Clusters {
     }
   }
 
-  private async *listByResourceGroupPagingAll(
-    resourceGroupName: string,
-    options?: ClustersListByResourceGroupOptionalParams
-  ): AsyncIterableIterator<Cluster> {
-    for await (const page of this.listByResourceGroupPagingPage(
-      resourceGroupName,
-      options
-    )) {
+  private async *listAllPagingAll(
+    options?: VirtualHardDisksListAllOptionalParams
+  ): AsyncIterableIterator<VirtualHardDisks> {
+    for await (const page of this.listAllPagingPage(options)) {
       yield* page;
     }
   }
 
   /**
-   * List all HCI clusters in a subscription.
-   * @param options The options parameters.
-   */
-  private _listBySubscription(
-    options?: ClustersListBySubscriptionOptionalParams
-  ): Promise<ClustersListBySubscriptionResponse> {
-    return this.client.sendOperationRequest(
-      { options },
-      listBySubscriptionOperationSpec
-    );
-  }
-
-  /**
-   * List all HCI clusters in a resource group.
-   * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param options The options parameters.
-   */
-  private _listByResourceGroup(
-    resourceGroupName: string,
-    options?: ClustersListByResourceGroupOptionalParams
-  ): Promise<ClustersListByResourceGroupResponse> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, options },
-      listByResourceGroupOperationSpec
-    );
-  }
-
-  /**
-   * Get HCI cluster.
+   * Gets a virtual hard disk
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
+   * @param virtualHardDiskName Name of the virtual hard disk
    * @param options The options parameters.
    */
   get(
     resourceGroupName: string,
-    clusterName: string,
-    options?: ClustersGetOptionalParams
-  ): Promise<ClustersGetResponse> {
+    virtualHardDiskName: string,
+    options?: VirtualHardDisksGetOptionalParams
+  ): Promise<VirtualHardDisksGetResponse> {
     return this.client.sendOperationRequest(
-      { resourceGroupName, clusterName, options },
+      { resourceGroupName, virtualHardDiskName, options },
       getOperationSpec
     );
   }
 
   /**
-   * Create an HCI cluster.
+   * The operation to create or update a virtual hard disk. Please note some properties can be set only
+   * during virtual hard disk creation.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
-   * @param cluster Details of the HCI cluster.
+   * @param virtualHardDiskName Name of the virtual hard disk
+   * @param virtualHardDisks The virtual hard disk resource definition.
    * @param options The options parameters.
    */
-  create(
+  async beginCreateOrUpdate(
     resourceGroupName: string,
-    clusterName: string,
-    cluster: Cluster,
-    options?: ClustersCreateOptionalParams
-  ): Promise<ClustersCreateResponse> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, clusterName, cluster, options },
-      createOperationSpec
-    );
-  }
-
-  /**
-   * Update an HCI cluster.
-   * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
-   * @param cluster Details of the HCI cluster.
-   * @param options The options parameters.
-   */
-  update(
-    resourceGroupName: string,
-    clusterName: string,
-    cluster: ClusterPatch,
-    options?: ClustersUpdateOptionalParams
-  ): Promise<ClustersUpdateResponse> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, clusterName, cluster, options },
-      updateOperationSpec
-    );
-  }
-
-  /**
-   * Delete an HCI cluster.
-   * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
-   * @param options The options parameters.
-   */
-  async beginDelete(
-    resourceGroupName: string,
-    clusterName: string,
-    options?: ClustersDeleteOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
+    virtualHardDiskName: string,
+    virtualHardDisks: VirtualHardDisks,
+    options?: VirtualHardDisksCreateOrUpdateOptionalParams
+  ): Promise<
+    SimplePollerLike<
+      OperationState<VirtualHardDisksCreateOrUpdateResponse>,
+      VirtualHardDisksCreateOrUpdateResponse
+    >
+  > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<void> => {
+    ): Promise<VirtualHardDisksCreateOrUpdateResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -308,58 +247,74 @@ export class ClustersImpl implements Clusters {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, clusterName, options },
-      deleteOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
-      intervalInMs: options?.updateIntervalInMs
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        virtualHardDiskName,
+        virtualHardDisks,
+        options
+      },
+      spec: createOrUpdateOperationSpec
+    });
+    const poller = await createHttpPoller<
+      VirtualHardDisksCreateOrUpdateResponse,
+      OperationState<VirtualHardDisksCreateOrUpdateResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
+      intervalInMs: options?.updateIntervalInMs,
+      resourceLocationConfig: "azure-async-operation"
     });
     await poller.poll();
     return poller;
   }
 
   /**
-   * Delete an HCI cluster.
+   * The operation to create or update a virtual hard disk. Please note some properties can be set only
+   * during virtual hard disk creation.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
+   * @param virtualHardDiskName Name of the virtual hard disk
+   * @param virtualHardDisks The virtual hard disk resource definition.
    * @param options The options parameters.
    */
-  async beginDeleteAndWait(
+  async beginCreateOrUpdateAndWait(
     resourceGroupName: string,
-    clusterName: string,
-    options?: ClustersDeleteOptionalParams
-  ): Promise<void> {
-    const poller = await this.beginDelete(
+    virtualHardDiskName: string,
+    virtualHardDisks: VirtualHardDisks,
+    options?: VirtualHardDisksCreateOrUpdateOptionalParams
+  ): Promise<VirtualHardDisksCreateOrUpdateResponse> {
+    const poller = await this.beginCreateOrUpdate(
       resourceGroupName,
-      clusterName,
+      virtualHardDiskName,
+      virtualHardDisks,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * Upload certificate.
+   * The operation to delete a virtual hard disk.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
-   * @param uploadCertificateRequest Upload certificate request.
+   * @param virtualHardDiskName Name of the virtual hard disk
    * @param options The options parameters.
    */
-  async beginUploadCertificate(
+  async beginDelete(
     resourceGroupName: string,
-    clusterName: string,
-    uploadCertificateRequest: UploadCertificateRequest,
-    options?: ClustersUploadCertificateOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
+    virtualHardDiskName: string,
+    options?: VirtualHardDisksDeleteOptionalParams
+  ): Promise<
+    SimplePollerLike<
+      OperationState<VirtualHardDisksDeleteResponse>,
+      VirtualHardDisksDeleteResponse
+    >
+  > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<void> => {
+    ): Promise<VirtualHardDisksDeleteResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -392,65 +347,67 @@ export class ClustersImpl implements Clusters {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, clusterName, uploadCertificateRequest, options },
-      uploadCertificateOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, virtualHardDiskName, options },
+      spec: deleteOperationSpec
+    });
+    const poller = await createHttpPoller<
+      VirtualHardDisksDeleteResponse,
+      OperationState<VirtualHardDisksDeleteResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs,
-      lroResourceLocationConfig: "azure-async-operation"
+      resourceLocationConfig: "azure-async-operation"
     });
     await poller.poll();
     return poller;
   }
 
   /**
-   * Upload certificate.
+   * The operation to delete a virtual hard disk.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
-   * @param uploadCertificateRequest Upload certificate request.
+   * @param virtualHardDiskName Name of the virtual hard disk
    * @param options The options parameters.
    */
-  async beginUploadCertificateAndWait(
+  async beginDeleteAndWait(
     resourceGroupName: string,
-    clusterName: string,
-    uploadCertificateRequest: UploadCertificateRequest,
-    options?: ClustersUploadCertificateOptionalParams
-  ): Promise<void> {
-    const poller = await this.beginUploadCertificate(
+    virtualHardDiskName: string,
+    options?: VirtualHardDisksDeleteOptionalParams
+  ): Promise<VirtualHardDisksDeleteResponse> {
+    const poller = await this.beginDelete(
       resourceGroupName,
-      clusterName,
-      uploadCertificateRequest,
+      virtualHardDiskName,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * Create cluster identity.
+   * The operation to update a virtual hard disk.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
+   * @param virtualHardDiskName Name of the virtual hard disk
+   * @param virtualHardDisks The virtual hard disk resource patch definition.
    * @param options The options parameters.
    */
-  async beginCreateIdentity(
+  async beginUpdate(
     resourceGroupName: string,
-    clusterName: string,
-    options?: ClustersCreateIdentityOptionalParams
+    virtualHardDiskName: string,
+    virtualHardDisks: VirtualHardDisksUpdateRequest,
+    options?: VirtualHardDisksUpdateOptionalParams
   ): Promise<
-    PollerLike<
-      PollOperationState<ClustersCreateIdentityResponse>,
-      ClustersCreateIdentityResponse
+    SimplePollerLike<
+      OperationState<VirtualHardDisksUpdateResponse>,
+      VirtualHardDisksUpdateResponse
     >
   > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<ClustersCreateIdentityResponse> => {
+    ): Promise<VirtualHardDisksUpdateResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -483,98 +440,119 @@ export class ClustersImpl implements Clusters {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, clusterName, options },
-      createIdentityOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        virtualHardDiskName,
+        virtualHardDisks,
+        options
+      },
+      spec: updateOperationSpec
+    });
+    const poller = await createHttpPoller<
+      VirtualHardDisksUpdateResponse,
+      OperationState<VirtualHardDisksUpdateResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs,
-      lroResourceLocationConfig: "azure-async-operation"
+      resourceLocationConfig: "azure-async-operation"
     });
     await poller.poll();
     return poller;
   }
 
   /**
-   * Create cluster identity.
+   * The operation to update a virtual hard disk.
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param clusterName The name of the cluster.
+   * @param virtualHardDiskName Name of the virtual hard disk
+   * @param virtualHardDisks The virtual hard disk resource patch definition.
    * @param options The options parameters.
    */
-  async beginCreateIdentityAndWait(
+  async beginUpdateAndWait(
     resourceGroupName: string,
-    clusterName: string,
-    options?: ClustersCreateIdentityOptionalParams
-  ): Promise<ClustersCreateIdentityResponse> {
-    const poller = await this.beginCreateIdentity(
+    virtualHardDiskName: string,
+    virtualHardDisks: VirtualHardDisksUpdateRequest,
+    options?: VirtualHardDisksUpdateOptionalParams
+  ): Promise<VirtualHardDisksUpdateResponse> {
+    const poller = await this.beginUpdate(
       resourceGroupName,
-      clusterName,
+      virtualHardDiskName,
+      virtualHardDisks,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * ListBySubscriptionNext
-   * @param nextLink The nextLink from the previous successful call to the ListBySubscription method.
+   * Lists all of the virtual hard disks in the specified resource group. Use the nextLink property in
+   * the response to get the next page of virtual hard disks.
+   * @param resourceGroupName The name of the resource group. The name is case insensitive.
    * @param options The options parameters.
    */
-  private _listBySubscriptionNext(
-    nextLink: string,
-    options?: ClustersListBySubscriptionNextOptionalParams
-  ): Promise<ClustersListBySubscriptionNextResponse> {
+  private _list(
+    resourceGroupName: string,
+    options?: VirtualHardDisksListOptionalParams
+  ): Promise<VirtualHardDisksListResponse> {
     return this.client.sendOperationRequest(
-      { nextLink, options },
-      listBySubscriptionNextOperationSpec
+      { resourceGroupName, options },
+      listOperationSpec
     );
   }
 
   /**
-   * ListByResourceGroupNext
+   * Lists all of the virtual hard disks in the specified subscription. Use the nextLink property in the
+   * response to get the next page of virtual hard disks.
+   * @param options The options parameters.
+   */
+  private _listAll(
+    options?: VirtualHardDisksListAllOptionalParams
+  ): Promise<VirtualHardDisksListAllResponse> {
+    return this.client.sendOperationRequest({ options }, listAllOperationSpec);
+  }
+
+  /**
+   * ListNext
    * @param resourceGroupName The name of the resource group. The name is case insensitive.
-   * @param nextLink The nextLink from the previous successful call to the ListByResourceGroup method.
+   * @param nextLink The nextLink from the previous successful call to the List method.
    * @param options The options parameters.
    */
-  private _listByResourceGroupNext(
+  private _listNext(
     resourceGroupName: string,
     nextLink: string,
-    options?: ClustersListByResourceGroupNextOptionalParams
-  ): Promise<ClustersListByResourceGroupNextResponse> {
+    options?: VirtualHardDisksListNextOptionalParams
+  ): Promise<VirtualHardDisksListNextResponse> {
     return this.client.sendOperationRequest(
       { resourceGroupName, nextLink, options },
-      listByResourceGroupNextOperationSpec
+      listNextOperationSpec
+    );
+  }
+
+  /**
+   * ListAllNext
+   * @param nextLink The nextLink from the previous successful call to the ListAll method.
+   * @param options The options parameters.
+   */
+  private _listAllNext(
+    nextLink: string,
+    options?: VirtualHardDisksListAllNextOptionalParams
+  ): Promise<VirtualHardDisksListAllNextResponse> {
+    return this.client.sendOperationRequest(
+      { nextLink, options },
+      listAllNextOperationSpec
     );
   }
 }
 // Operation Specifications
 const serializer = coreClient.createSerializer(Mappers, /* isXml */ false);
 
-const listBySubscriptionOperationSpec: coreClient.OperationSpec = {
-  path:
-    "/subscriptions/{subscriptionId}/providers/Microsoft.AzureStackHCI/clusters",
-  httpMethod: "GET",
-  responses: {
-    200: {
-      bodyMapper: Mappers.ClusterList
-    },
-    default: {
-      bodyMapper: Mappers.ErrorResponse
-    }
-  },
-  queryParameters: [Parameters.apiVersion],
-  urlParameters: [Parameters.$host, Parameters.subscriptionId],
-  headerParameters: [Parameters.accept],
-  serializer
-};
-const listByResourceGroupOperationSpec: coreClient.OperationSpec = {
+const getOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/virtualHardDisks/{virtualHardDiskName}",
   httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ClusterList
+      bodyMapper: Mappers.VirtualHardDisks
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
@@ -584,90 +562,117 @@ const listByResourceGroupOperationSpec: coreClient.OperationSpec = {
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
-    Parameters.resourceGroupName
+    Parameters.resourceGroupName,
+    Parameters.virtualHardDiskName
   ],
   headerParameters: [Parameters.accept],
   serializer
 };
-const getOperationSpec: coreClient.OperationSpec = {
+const createOrUpdateOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}",
-  httpMethod: "GET",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/virtualHardDisks/{virtualHardDiskName}",
+  httpMethod: "PUT",
   responses: {
     200: {
-      bodyMapper: Mappers.Cluster
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    201: {
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    202: {
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    204: {
+      bodyMapper: Mappers.VirtualHardDisks
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
+  requestBody: Parameters.virtualHardDisks,
   queryParameters: [Parameters.apiVersion],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
-    Parameters.clusterName
+    Parameters.virtualHardDiskName
   ],
-  headerParameters: [Parameters.accept],
+  headerParameters: [Parameters.accept, Parameters.contentType],
+  mediaType: "json",
   serializer
 };
-const createOperationSpec: coreClient.OperationSpec = {
+const deleteOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}",
-  httpMethod: "PUT",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/virtualHardDisks/{virtualHardDiskName}",
+  httpMethod: "DELETE",
   responses: {
     200: {
-      bodyMapper: Mappers.Cluster
+      headersMapper: Mappers.VirtualHardDisksDeleteHeaders
+    },
+    201: {
+      headersMapper: Mappers.VirtualHardDisksDeleteHeaders
+    },
+    202: {
+      headersMapper: Mappers.VirtualHardDisksDeleteHeaders
+    },
+    204: {
+      headersMapper: Mappers.VirtualHardDisksDeleteHeaders
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
-  requestBody: Parameters.cluster,
   queryParameters: [Parameters.apiVersion],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
-    Parameters.clusterName
+    Parameters.virtualHardDiskName
   ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
-  mediaType: "json",
+  headerParameters: [Parameters.accept],
   serializer
 };
 const updateOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/virtualHardDisks/{virtualHardDiskName}",
   httpMethod: "PATCH",
   responses: {
     200: {
-      bodyMapper: Mappers.Cluster
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    201: {
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    202: {
+      bodyMapper: Mappers.VirtualHardDisks
+    },
+    204: {
+      bodyMapper: Mappers.VirtualHardDisks
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
-  requestBody: Parameters.cluster1,
+  requestBody: Parameters.virtualHardDisks1,
   queryParameters: [Parameters.apiVersion],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
-    Parameters.clusterName
+    Parameters.virtualHardDiskName
   ],
   headerParameters: [Parameters.accept, Parameters.contentType],
   mediaType: "json",
   serializer
 };
-const deleteOperationSpec: coreClient.OperationSpec = {
+const listOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}",
-  httpMethod: "DELETE",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/virtualHardDisks",
+  httpMethod: "GET",
   responses: {
-    200: {},
-    201: {},
-    202: {},
-    204: {},
+    200: {
+      bodyMapper: Mappers.VirtualHardDisksListResult
+    },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
@@ -676,104 +681,62 @@ const deleteOperationSpec: coreClient.OperationSpec = {
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
-    Parameters.resourceGroupName,
-    Parameters.clusterName
+    Parameters.resourceGroupName
   ],
   headerParameters: [Parameters.accept],
   serializer
 };
-const uploadCertificateOperationSpec: coreClient.OperationSpec = {
-  path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}/uploadCertificate",
-  httpMethod: "POST",
-  responses: {
-    200: {},
-    201: {},
-    202: {},
-    204: {},
-    default: {
-      bodyMapper: Mappers.ErrorResponse
-    }
-  },
-  requestBody: Parameters.uploadCertificateRequest,
-  queryParameters: [Parameters.apiVersion],
-  urlParameters: [
-    Parameters.$host,
-    Parameters.subscriptionId,
-    Parameters.resourceGroupName,
-    Parameters.clusterName
-  ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
-  mediaType: "json",
-  serializer
-};
-const createIdentityOperationSpec: coreClient.OperationSpec = {
+const listAllOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.AzureStackHCI/clusters/{clusterName}/createClusterIdentity",
-  httpMethod: "POST",
+    "/subscriptions/{subscriptionId}/providers/Microsoft.AzureStackHCI/virtualHardDisks",
+  httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ClusterIdentityResponse
-    },
-    201: {
-      bodyMapper: Mappers.ClusterIdentityResponse
-    },
-    202: {
-      bodyMapper: Mappers.ClusterIdentityResponse
-    },
-    204: {
-      bodyMapper: Mappers.ClusterIdentityResponse
+      bodyMapper: Mappers.VirtualHardDisksListResult
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
   queryParameters: [Parameters.apiVersion],
-  urlParameters: [
-    Parameters.$host,
-    Parameters.subscriptionId,
-    Parameters.resourceGroupName,
-    Parameters.clusterName
-  ],
+  urlParameters: [Parameters.$host, Parameters.subscriptionId],
   headerParameters: [Parameters.accept],
   serializer
 };
-const listBySubscriptionNextOperationSpec: coreClient.OperationSpec = {
+const listNextOperationSpec: coreClient.OperationSpec = {
   path: "{nextLink}",
   httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ClusterList
+      bodyMapper: Mappers.VirtualHardDisksListResult
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
-  queryParameters: [Parameters.apiVersion],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
+    Parameters.resourceGroupName,
     Parameters.nextLink
   ],
   headerParameters: [Parameters.accept],
   serializer
 };
-const listByResourceGroupNextOperationSpec: coreClient.OperationSpec = {
+const listAllNextOperationSpec: coreClient.OperationSpec = {
   path: "{nextLink}",
   httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ClusterList
+      bodyMapper: Mappers.VirtualHardDisksListResult
     },
     default: {
       bodyMapper: Mappers.ErrorResponse
     }
   },
-  queryParameters: [Parameters.apiVersion],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
-    Parameters.resourceGroupName,
     Parameters.nextLink
   ],
   headerParameters: [Parameters.accept],