@azure/arm-sql 9.1.1-alpha.20230303.1 → 10.0.0

package/src/operations/databases.ts

@@ -13,8 +13,12 @@ import * as coreClient from "@azure/core-client";
 import * as Mappers from "../models/mappers";
 import * as Parameters from "../models/parameters";
 import { SqlManagementClient } from "../sqlManagementClient";
-import { PollerLike, PollOperationState, LroEngine } from "@azure/core-lro";
-import { LroImpl } from "../lroImpl";
+import {
+  SimplePollerLike,
+  OperationState,
+  createHttpPoller
+} from "@azure/core-lro";
+import { createLroSpec } from "../lroImpl";
 import {
   Metric,
   DatabasesListMetricsOptionalParams,
@@ -40,20 +44,20 @@ import {
   DatabaseUpdate,
   DatabasesUpdateOptionalParams,
   DatabasesUpdateResponse,
+  ExportDatabaseDefinition,
+  DatabasesExportOptionalParams,
+  DatabasesExportResponse,
   DatabasesFailoverOptionalParams,
+  ImportExistingDatabaseDefinition,
+  DatabasesImportOptionalParams,
+  DatabasesImportResponse,
+  ResourceMoveDefinition,
+  DatabasesRenameOptionalParams,
   DatabasesPauseOptionalParams,
   DatabasesPauseResponse,
   DatabasesResumeOptionalParams,
   DatabasesResumeResponse,
   DatabasesUpgradeDataWarehouseOptionalParams,
-  ResourceMoveDefinition,
-  DatabasesRenameOptionalParams,
-  ImportExistingDatabaseDefinition,
-  DatabasesImportOptionalParams,
-  DatabasesImportResponse,
-  ExportDatabaseDefinition,
-  DatabasesExportOptionalParams,
-  DatabasesExportResponse,
   DatabasesListByServerNextResponse,
   DatabasesListByElasticPoolNextResponse,
   DatabasesListInaccessibleByServerNextResponse
@@ -586,8 +590,8 @@ export class DatabasesImpl implements Databases {
     parameters: Database,
     options?: DatabasesCreateOrUpdateOptionalParams
   ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesCreateOrUpdateResponse>,
+    SimplePollerLike<
+      OperationState<DatabasesCreateOrUpdateResponse>,
       DatabasesCreateOrUpdateResponse
     >
   > {
@@ -597,7 +601,7 @@ export class DatabasesImpl implements Databases {
     ): Promise<DatabasesCreateOrUpdateResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -630,14 +634,24 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, parameters, options },
-      createOrUpdateOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
-      intervalInMs: options?.updateIntervalInMs
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        serverName,
+        databaseName,
+        parameters,
+        options
+      },
+      spec: createOrUpdateOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesCreateOrUpdateResponse,
+      OperationState<DatabasesCreateOrUpdateResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
+      intervalInMs: options?.updateIntervalInMs,
+      resourceLocationConfig: "azure-async-operation"
     });
     await poller.poll();
     return poller;
@@ -682,14 +696,14 @@ export class DatabasesImpl implements Databases {
     serverName: string,
     databaseName: string,
     options?: DatabasesDeleteOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
+  ): Promise<SimplePollerLike<OperationState<void>, void>> {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ): Promise<void> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -722,14 +736,15 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, options },
-      deleteOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
-      intervalInMs: options?.updateIntervalInMs
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, serverName, databaseName, options },
+      spec: deleteOperationSpec
+    });
+    const poller = await createHttpPoller<void, OperationState<void>>(lro, {
+      restoreFrom: options?.resumeFrom,
+      intervalInMs: options?.updateIntervalInMs,
+      resourceLocationConfig: "location"
     });
     await poller.poll();
     return poller;
@@ -774,8 +789,8 @@ export class DatabasesImpl implements Databases {
     parameters: DatabaseUpdate,
     options?: DatabasesUpdateOptionalParams
   ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesUpdateResponse>,
+    SimplePollerLike<
+      OperationState<DatabasesUpdateResponse>,
       DatabasesUpdateResponse
     >
   > {
@@ -785,7 +800,7 @@ export class DatabasesImpl implements Databases {
     ): Promise<DatabasesUpdateResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -818,14 +833,24 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, parameters, options },
-      updateOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
-      intervalInMs: options?.updateIntervalInMs
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        serverName,
+        databaseName,
+        parameters,
+        options
+      },
+      spec: updateOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesUpdateResponse,
+      OperationState<DatabasesUpdateResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
+      intervalInMs: options?.updateIntervalInMs,
+      resourceLocationConfig: "location"
     });
     await poller.poll();
     return poller;
@@ -858,46 +883,33 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Gets a list of databases in an elastic pool.
-   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
-   *                          this value from the Azure Resource Manager API or the portal.
-   * @param serverName The name of the server.
-   * @param elasticPoolName The name of the elastic pool.
-   * @param options The options parameters.
-   */
-  private _listByElasticPool(
-    resourceGroupName: string,
-    serverName: string,
-    elasticPoolName: string,
-    options?: DatabasesListByElasticPoolOptionalParams
-  ): Promise<DatabasesListByElasticPoolResponse> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, serverName, elasticPoolName, options },
-      listByElasticPoolOperationSpec
-    );
-  }
-
-  /**
-   * Failovers a database.
+   * Exports a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to failover.
+   * @param databaseName The name of the database.
+   * @param parameters The database export request parameters.
    * @param options The options parameters.
    */
-  async beginFailover(
+  async beginExport(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesFailoverOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
+    parameters: ExportDatabaseDefinition,
+    options?: DatabasesExportOptionalParams
+  ): Promise<
+    SimplePollerLike<
+      OperationState<DatabasesExportResponse>,
+      DatabasesExportResponse
+    >
+  > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<void> => {
+    ): Promise<DatabasesExportResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -930,13 +942,22 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, options },
-      failoverOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        serverName,
+        databaseName,
+        parameters,
+        options
+      },
+      spec: exportOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesExportResponse,
+      OperationState<DatabasesExportResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -944,72 +965,52 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Failovers a database.
+   * Exports a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to failover.
+   * @param databaseName The name of the database.
+   * @param parameters The database export request parameters.
    * @param options The options parameters.
    */
-  async beginFailoverAndWait(
+  async beginExportAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesFailoverOptionalParams
-  ): Promise<void> {
-    const poller = await this.beginFailover(
+    parameters: ExportDatabaseDefinition,
+    options?: DatabasesExportOptionalParams
+  ): Promise<DatabasesExportResponse> {
+    const poller = await this.beginExport(
       resourceGroupName,
       serverName,
       databaseName,
+      parameters,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * Gets a list of inaccessible databases in a logical server
-   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
-   *                          this value from the Azure Resource Manager API or the portal.
-   * @param serverName The name of the server.
-   * @param options The options parameters.
-   */
-  private _listInaccessibleByServer(
-    resourceGroupName: string,
-    serverName: string,
-    options?: DatabasesListInaccessibleByServerOptionalParams
-  ): Promise<DatabasesListInaccessibleByServerResponse> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, serverName, options },
-      listInaccessibleByServerOperationSpec
-    );
-  }
-
-  /**
-   * Pauses a database.
+   * Failovers a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be paused.
+   * @param databaseName The name of the database to failover.
    * @param options The options parameters.
    */
-  async beginPause(
+  async beginFailover(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesPauseOptionalParams
-  ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesPauseResponse>,
-      DatabasesPauseResponse
-    >
-  > {
+    options?: DatabasesFailoverOptionalParams
+  ): Promise<SimplePollerLike<OperationState<void>, void>> {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<DatabasesPauseResponse> => {
+    ): Promise<void> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -1042,13 +1043,13 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, options },
-      pauseOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, serverName, databaseName, options },
+      spec: failoverOperationSpec
+    });
+    const poller = await createHttpPoller<void, OperationState<void>>(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -1056,20 +1057,20 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Pauses a database.
+   * Failovers a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be paused.
+   * @param databaseName The name of the database to failover.
    * @param options The options parameters.
    */
-  async beginPauseAndWait(
+  async beginFailoverAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesPauseOptionalParams
-  ): Promise<DatabasesPauseResponse> {
-    const poller = await this.beginPause(
+    options?: DatabasesFailoverOptionalParams
+  ): Promise<void> {
+    const poller = await this.beginFailover(
       resourceGroupName,
       serverName,
       databaseName,
@@ -1079,31 +1080,33 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Resumes a database.
+   * Imports a bacpac into a new database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be resumed.
+   * @param databaseName The name of the database.
+   * @param parameters The database import request parameters.
    * @param options The options parameters.
    */
-  async beginResume(
+  async beginImport(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesResumeOptionalParams
+    parameters: ImportExistingDatabaseDefinition,
+    options?: DatabasesImportOptionalParams
   ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesResumeResponse>,
-      DatabasesResumeResponse
+    SimplePollerLike<
+      OperationState<DatabasesImportResponse>,
+      DatabasesImportResponse
     >
   > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<DatabasesResumeResponse> => {
+    ): Promise<DatabasesImportResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -1136,13 +1139,22 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, options },
-      resumeOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: {
+        resourceGroupName,
+        serverName,
+        databaseName,
+        parameters,
+        options
+      },
+      spec: importOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesImportResponse,
+      OperationState<DatabasesImportResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -1150,49 +1162,79 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Resumes a database.
+   * Imports a bacpac into a new database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be resumed.
+   * @param databaseName The name of the database.
+   * @param parameters The database import request parameters.
    * @param options The options parameters.
    */
-  async beginResumeAndWait(
+  async beginImportAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesResumeOptionalParams
-  ): Promise<DatabasesResumeResponse> {
-    const poller = await this.beginResume(
+    parameters: ImportExistingDatabaseDefinition,
+    options?: DatabasesImportOptionalParams
+  ): Promise<DatabasesImportResponse> {
+    const poller = await this.beginImport(
       resourceGroupName,
       serverName,
       databaseName,
+      parameters,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * Upgrades a data warehouse.
+   * Renames a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be upgraded.
+   * @param databaseName The name of the database to rename.
+   * @param parameters The resource move definition for renaming this database.
    * @param options The options parameters.
    */
-  async beginUpgradeDataWarehouse(
+  rename(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesUpgradeDataWarehouseOptionalParams
-  ): Promise<PollerLike<PollOperationState<void>, void>> {
+    parameters: ResourceMoveDefinition,
+    options?: DatabasesRenameOptionalParams
+  ): Promise<void> {
+    return this.client.sendOperationRequest(
+      { resourceGroupName, serverName, databaseName, parameters, options },
+      renameOperationSpec
+    );
+  }
+
+  /**
+   * Pauses a database.
+   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
+   *                          this value from the Azure Resource Manager API or the portal.
+   * @param serverName The name of the server.
+   * @param databaseName The name of the database to be paused.
+   * @param options The options parameters.
+   */
+  async beginPause(
+    resourceGroupName: string,
+    serverName: string,
+    databaseName: string,
+    options?: DatabasesPauseOptionalParams
+  ): Promise<
+    SimplePollerLike<
+      OperationState<DatabasesPauseResponse>,
+      DatabasesPauseResponse
+    >
+  > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<void> => {
+    ): Promise<DatabasesPauseResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -1225,13 +1267,16 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, options },
-      upgradeDataWarehouseOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, serverName, databaseName, options },
+      spec: pauseOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesPauseResponse,
+      OperationState<DatabasesPauseResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -1239,20 +1284,20 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Upgrades a data warehouse.
+   * Pauses a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database to be upgraded.
+   * @param databaseName The name of the database to be paused.
    * @param options The options parameters.
    */
-  async beginUpgradeDataWarehouseAndWait(
+  async beginPauseAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    options?: DatabasesUpgradeDataWarehouseOptionalParams
-  ): Promise<void> {
-    const poller = await this.beginUpgradeDataWarehouse(
+    options?: DatabasesPauseOptionalParams
+  ): Promise<DatabasesPauseResponse> {
+    const poller = await this.beginPause(
       resourceGroupName,
       serverName,
       databaseName,
@@ -1262,55 +1307,31 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Renames a database.
-   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
-   *                          this value from the Azure Resource Manager API or the portal.
-   * @param serverName The name of the server.
-   * @param databaseName The name of the database to rename.
-   * @param parameters The resource move definition for renaming this database.
-   * @param options The options parameters.
-   */
-  rename(
-    resourceGroupName: string,
-    serverName: string,
-    databaseName: string,
-    parameters: ResourceMoveDefinition,
-    options?: DatabasesRenameOptionalParams
-  ): Promise<void> {
-    return this.client.sendOperationRequest(
-      { resourceGroupName, serverName, databaseName, parameters, options },
-      renameOperationSpec
-    );
-  }
-
-  /**
-   * Imports a bacpac into a new database.
+   * Resumes a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database.
-   * @param parameters The database import request parameters.
+   * @param databaseName The name of the database to be resumed.
    * @param options The options parameters.
    */
-  async beginImport(
+  async beginResume(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    parameters: ImportExistingDatabaseDefinition,
-    options?: DatabasesImportOptionalParams
+    options?: DatabasesResumeOptionalParams
   ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesImportResponse>,
-      DatabasesImportResponse
+    SimplePollerLike<
+      OperationState<DatabasesResumeResponse>,
+      DatabasesResumeResponse
     >
   > {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<DatabasesImportResponse> => {
+    ): Promise<DatabasesResumeResponse> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -1343,13 +1364,16 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, parameters, options },
-      importOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, serverName, databaseName, options },
+      spec: resumeOperationSpec
+    });
+    const poller = await createHttpPoller<
+      DatabasesResumeResponse,
+      OperationState<DatabasesResumeResponse>
+    >(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -1357,59 +1381,49 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Imports a bacpac into a new database.
+   * Resumes a database.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database.
-   * @param parameters The database import request parameters.
+   * @param databaseName The name of the database to be resumed.
    * @param options The options parameters.
    */
-  async beginImportAndWait(
+  async beginResumeAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    parameters: ImportExistingDatabaseDefinition,
-    options?: DatabasesImportOptionalParams
-  ): Promise<DatabasesImportResponse> {
-    const poller = await this.beginImport(
+    options?: DatabasesResumeOptionalParams
+  ): Promise<DatabasesResumeResponse> {
+    const poller = await this.beginResume(
       resourceGroupName,
       serverName,
       databaseName,
-      parameters,
       options
     );
     return poller.pollUntilDone();
   }
 
   /**
-   * Exports a database.
+   * Upgrades a data warehouse.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database.
-   * @param parameters The database export request parameters.
+   * @param databaseName The name of the database to be upgraded.
    * @param options The options parameters.
    */
-  async beginExport(
+  async beginUpgradeDataWarehouse(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    parameters: ExportDatabaseDefinition,
-    options?: DatabasesExportOptionalParams
-  ): Promise<
-    PollerLike<
-      PollOperationState<DatabasesExportResponse>,
-      DatabasesExportResponse
-    >
-  > {
+    options?: DatabasesUpgradeDataWarehouseOptionalParams
+  ): Promise<SimplePollerLike<OperationState<void>, void>> {
     const directSendOperation = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
-    ): Promise<DatabasesExportResponse> => {
+    ): Promise<void> => {
       return this.client.sendOperationRequest(args, spec);
     };
-    const sendOperation = async (
+    const sendOperationFn = async (
       args: coreClient.OperationArguments,
       spec: coreClient.OperationSpec
     ) => {
@@ -1442,13 +1456,13 @@ export class DatabasesImpl implements Databases {
       };
     };
 
-    const lro = new LroImpl(
-      sendOperation,
-      { resourceGroupName, serverName, databaseName, parameters, options },
-      exportOperationSpec
-    );
-    const poller = new LroEngine(lro, {
-      resumeFrom: options?.resumeFrom,
+    const lro = createLroSpec({
+      sendOperationFn,
+      args: { resourceGroupName, serverName, databaseName, options },
+      spec: upgradeDataWarehouseOperationSpec
+    });
+    const poller = await createHttpPoller<void, OperationState<void>>(lro, {
+      restoreFrom: options?.resumeFrom,
       intervalInMs: options?.updateIntervalInMs
     });
     await poller.poll();
@@ -1456,31 +1470,66 @@ export class DatabasesImpl implements Databases {
   }
 
   /**
-   * Exports a database.
+   * Upgrades a data warehouse.
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
    *                          this value from the Azure Resource Manager API or the portal.
    * @param serverName The name of the server.
-   * @param databaseName The name of the database.
-   * @param parameters The database export request parameters.
+   * @param databaseName The name of the database to be upgraded.
    * @param options The options parameters.
    */
-  async beginExportAndWait(
+  async beginUpgradeDataWarehouseAndWait(
     resourceGroupName: string,
     serverName: string,
     databaseName: string,
-    parameters: ExportDatabaseDefinition,
-    options?: DatabasesExportOptionalParams
-  ): Promise<DatabasesExportResponse> {
-    const poller = await this.beginExport(
+    options?: DatabasesUpgradeDataWarehouseOptionalParams
+  ): Promise<void> {
+    const poller = await this.beginUpgradeDataWarehouse(
       resourceGroupName,
       serverName,
       databaseName,
-      parameters,
       options
     );
     return poller.pollUntilDone();
   }
 
+  /**
+   * Gets a list of databases in an elastic pool.
+   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
+   *                          this value from the Azure Resource Manager API or the portal.
+   * @param serverName The name of the server.
+   * @param elasticPoolName The name of the elastic pool.
+   * @param options The options parameters.
+   */
+  private _listByElasticPool(
+    resourceGroupName: string,
+    serverName: string,
+    elasticPoolName: string,
+    options?: DatabasesListByElasticPoolOptionalParams
+  ): Promise<DatabasesListByElasticPoolResponse> {
+    return this.client.sendOperationRequest(
+      { resourceGroupName, serverName, elasticPoolName, options },
+      listByElasticPoolOperationSpec
+    );
+  }
+
+  /**
+   * Gets a list of inaccessible databases in a logical server
+   * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
+   *                          this value from the Azure Resource Manager API or the portal.
+   * @param serverName The name of the server.
+   * @param options The options parameters.
+   */
+  private _listInaccessibleByServer(
+    resourceGroupName: string,
+    serverName: string,
+    options?: DatabasesListInaccessibleByServerOptionalParams
+  ): Promise<DatabasesListInaccessibleByServerResponse> {
+    return this.client.sendOperationRequest(
+      { resourceGroupName, serverName, options },
+      listInaccessibleByServerOperationSpec
+    );
+  }
+
   /**
    * ListByServerNext
    * @param resourceGroupName The name of the resource group that contains the resource. You can obtain
@@ -1617,7 +1666,11 @@ const getOperationSpec: coreClient.OperationSpec = {
     },
     default: {}
   },
-  queryParameters: [Parameters.apiVersion1],
+  queryParameters: [
+    Parameters.apiVersion1,
+    Parameters.expand,
+    Parameters.filter1
+  ],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
@@ -1656,7 +1709,7 @@ const createOrUpdateOperationSpec: coreClient.OperationSpec = {
     Parameters.serverName,
     Parameters.databaseName
   ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
+  headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
   serializer
 };
@@ -1703,29 +1756,40 @@ const updateOperationSpec: coreClient.OperationSpec = {
     Parameters.serverName,
     Parameters.databaseName
   ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
+  headerParameters: [Parameters.contentType, Parameters.accept],
   mediaType: "json",
   serializer
 };
-const listByElasticPoolOperationSpec: coreClient.OperationSpec = {
+const exportOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/elasticPools/{elasticPoolName}/databases",
-  httpMethod: "GET",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/export",
+  httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.DatabaseListResult
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    201: {
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    202: {
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    204: {
+      bodyMapper: Mappers.ImportExportOperationResult
     },
     default: {}
   },
+  requestBody: Parameters.parameters5,
   queryParameters: [Parameters.apiVersion1],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
     Parameters.serverName,
-    Parameters.elasticPoolName
+    Parameters.databaseName
   ],
-  headerParameters: [Parameters.accept],
+  headerParameters: [Parameters.contentType, Parameters.accept],
+  mediaType: "json",
   serializer
 };
 const failoverOperationSpec: coreClient.OperationSpec = {
@@ -1743,24 +1807,54 @@ const failoverOperationSpec: coreClient.OperationSpec = {
   ],
   serializer
 };
-const listInaccessibleByServerOperationSpec: coreClient.OperationSpec = {
+const importOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/inaccessibleDatabases",
-  httpMethod: "GET",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/import",
+  httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.DatabaseListResult
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    201: {
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    202: {
+      bodyMapper: Mappers.ImportExportOperationResult
+    },
+    204: {
+      bodyMapper: Mappers.ImportExportOperationResult
     },
     default: {}
   },
+  requestBody: Parameters.parameters6,
   queryParameters: [Parameters.apiVersion1],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
-    Parameters.serverName
+    Parameters.serverName,
+    Parameters.databaseName
   ],
-  headerParameters: [Parameters.accept],
+  headerParameters: [Parameters.contentType, Parameters.accept],
+  mediaType: "json",
+  serializer
+};
+const renameOperationSpec: coreClient.OperationSpec = {
+  path:
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/move",
+  httpMethod: "POST",
+  responses: { 200: {}, default: {} },
+  requestBody: Parameters.parameters7,
+  queryParameters: [Parameters.apiVersion1],
+  urlParameters: [
+    Parameters.$host,
+    Parameters.subscriptionId,
+    Parameters.resourceGroupName,
+    Parameters.serverName,
+    Parameters.databaseName
+  ],
+  headerParameters: [Parameters.contentType],
+  mediaType: "json",
   serializer
 };
 const pauseOperationSpec: coreClient.OperationSpec = {
@@ -1838,86 +1932,45 @@ const upgradeDataWarehouseOperationSpec: coreClient.OperationSpec = {
   ],
   serializer
 };
-const renameOperationSpec: coreClient.OperationSpec = {
-  path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/move",
-  httpMethod: "POST",
-  responses: { 200: {}, default: {} },
-  requestBody: Parameters.parameters5,
-  queryParameters: [Parameters.apiVersion1],
-  urlParameters: [
-    Parameters.$host,
-    Parameters.subscriptionId,
-    Parameters.resourceGroupName,
-    Parameters.serverName,
-    Parameters.databaseName
-  ],
-  headerParameters: [Parameters.contentType],
-  mediaType: "json",
-  serializer
-};
-const importOperationSpec: coreClient.OperationSpec = {
+const listByElasticPoolOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/import",
-  httpMethod: "POST",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/elasticPools/{elasticPoolName}/databases",
+  httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    201: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    202: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    204: {
-      bodyMapper: Mappers.ImportExportOperationResult
+      bodyMapper: Mappers.DatabaseListResult
     },
     default: {}
   },
-  requestBody: Parameters.parameters6,
   queryParameters: [Parameters.apiVersion1],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
     Parameters.serverName,
-    Parameters.databaseName
+    Parameters.elasticPoolName
   ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
-  mediaType: "json",
+  headerParameters: [Parameters.accept],
   serializer
 };
-const exportOperationSpec: coreClient.OperationSpec = {
+const listInaccessibleByServerOperationSpec: coreClient.OperationSpec = {
   path:
-    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/databases/{databaseName}/export",
-  httpMethod: "POST",
+    "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Sql/servers/{serverName}/inaccessibleDatabases",
+  httpMethod: "GET",
   responses: {
     200: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    201: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    202: {
-      bodyMapper: Mappers.ImportExportOperationResult
-    },
-    204: {
-      bodyMapper: Mappers.ImportExportOperationResult
+      bodyMapper: Mappers.DatabaseListResult
     },
     default: {}
   },
-  requestBody: Parameters.parameters7,
   queryParameters: [Parameters.apiVersion1],
   urlParameters: [
     Parameters.$host,
     Parameters.subscriptionId,
     Parameters.resourceGroupName,
-    Parameters.serverName,
-    Parameters.databaseName
+    Parameters.serverName
   ],
-  headerParameters: [Parameters.accept, Parameters.contentType],
-  mediaType: "json",
+  headerParameters: [Parameters.accept],
   serializer
 };
 const listByServerNextOperationSpec: coreClient.OperationSpec = {