Update product references from 'sqlops' to 'azdata' (#4259)

* Update extensions to use azdata

* Switch core code to use azdata

src/sql/workbench/api/node/extHostAccountManagement.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
 import {
@@ -21,8 +21,8 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 	private _handlePool: number = 0;
 	private _proxy: MainThreadAccountManagementShape;
 	private _providers: { [handle: number]: AccountProviderWithMetadata } = {};
-	private _accounts: { [handle: number]: sqlops.Account[] } = {};
-	private readonly _onDidChangeAccounts = new Emitter<sqlops.DidChangeAccountsParams>();
+	private _accounts: { [handle: number]: azdata.Account[] } = {};
+	private readonly _onDidChangeAccounts = new Emitter<azdata.DidChangeAccountsParams>();
 
 	constructor(mainContext: IMainContext) {
 		super();
@@ -31,24 +31,24 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 
 	// PUBLIC METHODS //////////////////////////////////////////////////////
 	// - MAIN THREAD AVAILABLE METHODS /////////////////////////////////////
-	public $clear(handle: number, accountKey: sqlops.AccountKey): Thenable<void> {
-		return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.clear(accountKey));
+	public $clear(handle: number, accountKey: azdata.AccountKey): Thenable<void> {
+		return this._withProvider(handle, (provider: azdata.AccountProvider) => provider.clear(accountKey));
 	}
 
-	public $initialize(handle: number, restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
-		return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.initialize(restoredAccounts));
+	public $initialize(handle: number, restoredAccounts: azdata.Account[]): Thenable<azdata.Account[]> {
+		return this._withProvider(handle, (provider: azdata.AccountProvider) => provider.initialize(restoredAccounts));
 	}
 
-	public $prompt(handle: number): Thenable<sqlops.Account> {
-		return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.prompt());
+	public $prompt(handle: number): Thenable<azdata.Account> {
+		return this._withProvider(handle, (provider: azdata.AccountProvider) => provider.prompt());
 	}
 
-	public $refresh(handle: number, account: sqlops.Account): Thenable<sqlops.Account> {
-		return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.refresh(account));
+	public $refresh(handle: number, account: azdata.Account): Thenable<azdata.Account> {
+		return this._withProvider(handle, (provider: azdata.AccountProvider) => provider.refresh(account));
 	}
 
 	public $autoOAuthCancelled(handle: number): Thenable<void> {
-		return this._withProvider(handle, (provider: sqlops.AccountProvider) => provider.autoOAuthCancelled());
+		return this._withProvider(handle, (provider: azdata.AccountProvider) => provider.autoOAuthCancelled());
 	}
 
 	// - EXTENSION HOST AVAILABLE METHODS //////////////////////////////////
@@ -60,18 +60,18 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 		this._proxy.$endAutoOAuthDeviceCode();
 	}
 
-	public $accountUpdated(updatedAccount: sqlops.Account): void {
+	public $accountUpdated(updatedAccount: azdata.Account): void {
 		this._proxy.$accountUpdated(updatedAccount);
 	}
 
-	public $getAllAccounts(): Thenable<sqlops.Account[]> {
+	public $getAllAccounts(): Thenable<azdata.Account[]> {
 		if (Object.keys(this._providers).length === 0) {
 			throw new Error('No account providers registered.');
 		}
 
 		this._accounts = {};
 
-		const resultAccounts: sqlops.Account[] = [];
+		const resultAccounts: azdata.Account[] = [];
 
 		const promises: Thenable<void>[] = [];
 
@@ -90,7 +90,7 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 		return Promise.all(promises).then(() => resultAccounts);
 	}
 
-	public $getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> {
+	public $getSecurityToken(account: azdata.Account, resource?: azdata.AzureResource): Thenable<{}> {
 		if (resource === undefined) {
 			resource = AzureResource.ResourceManagement;
 		}
@@ -98,7 +98,7 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 			for (const handle in this._accounts) {
 				const providerHandle = parseInt(handle);
 				if (this._accounts[handle].findIndex((acct) => acct.key.accountId === account.key.accountId) !== -1) {
-					return this._withProvider(providerHandle, (provider: sqlops.AccountProvider) => provider.getSecurityToken(account, resource));
+					return this._withProvider(providerHandle, (provider: azdata.AccountProvider) => provider.getSecurityToken(account, resource));
 				}
 			}
 
@@ -106,15 +106,15 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 		});
 	}
 
-	public get onDidChangeAccounts(): Event<sqlops.DidChangeAccountsParams> {
+	public get onDidChangeAccounts(): Event<azdata.DidChangeAccountsParams> {
 		return this._onDidChangeAccounts.event;
 	}
 
-	public $accountsChanged(handle: number, accounts: sqlops.Account[]): Thenable<void> {
+	public $accountsChanged(handle: number, accounts: azdata.Account[]): Thenable<void> {
 		return this._onDidChangeAccounts.fire({ accounts: accounts });
 	}
 
-	public $registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, provider: sqlops.AccountProvider): Disposable {
+	public $registerAccountProvider(providerMetadata: azdata.AccountProviderMetadata, provider: azdata.AccountProvider): Disposable {
 		let self = this;
 
 		// Look for any account providers that have the same provider ID
@@ -155,7 +155,7 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 		return this._handlePool++;
 	}
 
-	private _withProvider<R>(handle: number, callback: (provider: sqlops.AccountProvider) => Thenable<R>): Thenable<R> {
+	private _withProvider<R>(handle: number, callback: (provider: azdata.AccountProvider) => Thenable<R>): Thenable<R> {
 		let provider = this._providers[handle];
 		if (provider === undefined) {
 			return TPromise.wrapError(new Error(`Provider ${handle} not found.`));
@@ -165,8 +165,8 @@ export class ExtHostAccountManagement extends ExtHostAccountManagementShape {
 }
 
 interface AccountProviderWithMetadata {
-	metadata: sqlops.AccountProviderMetadata;
-	provider: sqlops.AccountProvider;
+	metadata: azdata.AccountProviderMetadata;
+	provider: azdata.AccountProvider;
 }
 
 

src/sql/workbench/api/node/extHostBackgroundTaskManagement.ts

@@ -6,7 +6,7 @@
 
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { ExtHostBackgroundTaskManagementShape, SqlMainContext, MainThreadBackgroundTaskManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 import { Emitter } from 'vs/base/common/event';
 import { generateUuid } from 'vs/base/common/uuid';
@@ -21,7 +21,7 @@ export enum TaskStatus {
 	Canceling = 6
 }
 
-export class ExtBackgroundOperation implements sqlops.BackgroundOperation {
+export class ExtBackgroundOperation implements azdata.BackgroundOperation {
 	private readonly _proxy: MainThreadBackgroundTaskManagementShape;
 	private _onCanceled = new Emitter<void>();
 
@@ -55,7 +55,7 @@ export class ExtBackgroundOperation implements sqlops.BackgroundOperation {
 
 export class ExtHostBackgroundTaskManagement implements ExtHostBackgroundTaskManagementShape {
 	private readonly _proxy: MainThreadBackgroundTaskManagementShape;
-	private readonly _handlers = new Map<string, sqlops.BackgroundOperationInfo>();
+	private readonly _handlers = new Map<string, azdata.BackgroundOperationInfo>();
 	private readonly _operations = new Map<string, ExtBackgroundOperation>();
 	private readonly _mainContext: IMainContext;
 
@@ -82,14 +82,14 @@ export class ExtHostBackgroundTaskManagement implements ExtHostBackgroundTaskMan
 		}
 	}
 
-	$registerTask(operationInfo: sqlops.BackgroundOperationInfo): void {
+	$registerTask(operationInfo: azdata.BackgroundOperationInfo): void {
 		let operationId = operationInfo.operationId || `OperationId${generateUuid()}`;
 		if (this._handlers.has(operationId)) {
 			throw new Error(`operation '${operationId}' already exists`);
 		}
 
 		this._handlers.set(operationId, operationInfo);
-		let taskInfo: sqlops.TaskInfo = {
+		let taskInfo: azdata.TaskInfo = {
 			databaseName: undefined,
 			serverName: undefined,
 			description: operationInfo.description,

src/sql/workbench/api/node/extHostConnectionManagement.ts

@@ -7,7 +7,6 @@
 import { ExtHostConnectionManagementShape, SqlMainContext, MainThreadConnectionManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { generateUuid } from 'vs/base/common/uuid';
-import * as sqlops from 'sqlops';
 import * as azdata from 'azdata';
 
 export class ExtHostConnectionManagement extends ExtHostConnectionManagementShape {
@@ -30,11 +29,11 @@ export class ExtHostConnectionManagement extends ExtHostConnectionManagementShap
 	}
 
 	// "sqlops" back-compat connection APIs
-	public $getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
+	public $getActiveConnections(): Thenable<azdata.connection.Connection[]> {
 		return this._proxy.$getActiveConnections();
 	}
 
-	public $getSqlOpsCurrentConnection(): Thenable<sqlops.connection.Connection> {
+	public $getSqlOpsCurrentConnection(): Thenable<azdata.connection.Connection> {
 		return this._proxy.$getCurrentConnection();
 	}
 
@@ -42,11 +41,11 @@ export class ExtHostConnectionManagement extends ExtHostConnectionManagementShap
 		return this._proxy.$getCredentials(connectionId);
 	}
 
-	public $getServerInfo(connectionId: string): Thenable<sqlops.ServerInfo> {
+	public $getServerInfo(connectionId: string): Thenable<azdata.ServerInfo> {
 		return this._proxy.$getServerInfo(connectionId);
 	}
 
-	public $openConnectionDialog(providers?: string[], initialConnectionProfile?: sqlops.IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Thenable<sqlops.connection.Connection> {
+	public $openConnectionDialog(providers?: string[], initialConnectionProfile?: azdata.IConnectionProfile, connectionCompletionOptions?: azdata.IConnectionCompletionOptions): Thenable<azdata.connection.Connection> {
 		return this._proxy.$openConnectionDialog(providers, initialConnectionProfile, connectionCompletionOptions);
 	}
 
@@ -62,7 +61,7 @@ export class ExtHostConnectionManagement extends ExtHostConnectionManagementShap
 		return this._proxy.$getUriForConnection(connectionId);
 	}
 
-	public $connect(connectionProfile: sqlops.IConnectionProfile): Thenable<sqlops.ConnectionResult> {
+	public $connect(connectionProfile: azdata.IConnectionProfile): Thenable<azdata.ConnectionResult> {
 		return this._proxy.$connect(connectionProfile);
 	}
 }

src/sql/workbench/api/node/extHostCredentialManagement.ts

@@ -8,13 +8,13 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { SqlMainContext, MainThreadCredentialManagementShape, ExtHostCredentialManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
 
 class CredentialAdapter {
-	public provider: sqlops.CredentialProvider;
+	public provider: azdata.CredentialProvider;
 
-	constructor(provider: sqlops.CredentialProvider) {
+	constructor(provider: azdata.CredentialProvider) {
 		this.provider = provider;
 	}
 
@@ -22,7 +22,7 @@ class CredentialAdapter {
 		return this.provider.saveCredential(credentialId, password);
 	}
 
-	public readCredential(credentialId: string): Thenable<sqlops.Credential> {
+	public readCredential(credentialId: string): Thenable<azdata.Credential> {
 		return this.provider.readCredential(credentialId);
 	}
 
@@ -54,7 +54,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
 	}
 
 	// PUBLIC METHODS //////////////////////////////////////////////////////
-	public $registerCredentialProvider(provider: sqlops.CredentialProvider): vscode.Disposable {
+	public $registerCredentialProvider(provider: azdata.CredentialProvider): vscode.Disposable {
 		// Store the credential provider
 		provider.handle = this._nextHandle();
 		this._adapter[provider.handle] = new CredentialAdapter(provider);
@@ -67,7 +67,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
 		return this._createDisposable(provider.handle);
 	}
 
-	public $getCredentialProvider(namespaceId: string): Thenable<sqlops.CredentialProvider> {
+	public $getCredentialProvider(namespaceId: string): Thenable<azdata.CredentialProvider> {
 		let self = this;
 
 		if (!namespaceId) {
@@ -84,7 +84,7 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
 		return this._withAdapter(0, CredentialAdapter, adapter => adapter.saveCredential(credentialId, password));
 	}
 
-	public $readCredential(credentialId: string): Thenable<sqlops.Credential> {
+	public $readCredential(credentialId: string): Thenable<azdata.Credential> {
 		return this._withAdapter(0, CredentialAdapter, adapter => adapter.readCredential(credentialId));
 	}
 
@@ -105,9 +105,9 @@ export class ExtHostCredentialManagement extends ExtHostCredentialManagementShap
 		return `${namespaceId}|${credentialId}`;
 	}
 
-	private _createNamespacedCredentialProvider(namespaceId: string, adapter: CredentialAdapter): Thenable<sqlops.CredentialProvider> {
+	private _createNamespacedCredentialProvider(namespaceId: string, adapter: CredentialAdapter): Thenable<azdata.CredentialProvider> {
 		// Create a provider that wraps the methods in a namespace
-		let provider: sqlops.CredentialProvider = {
+		let provider: azdata.CredentialProvider = {
 			handle: adapter.provider.handle,
 			deleteCredential: (credentialId: string) => {
 				let namespacedId = ExtHostCredentialManagement._getNamespacedCredentialId(namespaceId, credentialId);

src/sql/workbench/api/node/extHostDashboard.ts

@@ -7,16 +7,16 @@
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { Event, Emitter } from 'vs/base/common/event';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { ExtHostDashboardShape, MainThreadDashboardShape, SqlMainContext } from './sqlExtHost.protocol';
 
 export class ExtHostDashboard implements ExtHostDashboardShape {
-	private _onDidOpenDashboard = new Emitter<sqlops.DashboardDocument>();
-	public readonly onDidOpenDashboard: Event<sqlops.DashboardDocument> = this._onDidOpenDashboard.event;
+	private _onDidOpenDashboard = new Emitter<azdata.DashboardDocument>();
+	public readonly onDidOpenDashboard: Event<azdata.DashboardDocument> = this._onDidOpenDashboard.event;
 
-	private _onDidChangeToDashboard = new Emitter<sqlops.DashboardDocument>();
-	public readonly onDidChangeToDashboard: Event<sqlops.DashboardDocument> = this._onDidChangeToDashboard.event;
+	private _onDidChangeToDashboard = new Emitter<azdata.DashboardDocument>();
+	public readonly onDidChangeToDashboard: Event<azdata.DashboardDocument> = this._onDidChangeToDashboard.event;
 
 	private _proxy: MainThreadDashboardShape;
 
@@ -24,11 +24,11 @@ export class ExtHostDashboard implements ExtHostDashboardShape {
 		this._proxy = mainContext.getProxy(SqlMainContext.MainThreadDashboard);
 	}
 
-	$onDidOpenDashboard(dashboard: sqlops.DashboardDocument) {
+	$onDidOpenDashboard(dashboard: azdata.DashboardDocument) {
 		this._onDidOpenDashboard.fire(dashboard);
 	}
 
-	$onDidChangeToDashboard(dashboard: sqlops.DashboardDocument) {
+	$onDidChangeToDashboard(dashboard: azdata.DashboardDocument) {
 		this._onDidChangeToDashboard.fire(dashboard);
 	}
 }

src/sql/workbench/api/node/extHostDashboardWebview.ts

@@ -11,9 +11,9 @@ import { Emitter } from 'vs/base/common/event';
 import { deepClone } from 'vs/base/common/objects';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
-class ExtHostDashboardWebview implements sqlops.DashboardWebview {
+class ExtHostDashboardWebview implements azdata.DashboardWebview {
 
 	private _html: string;
 	public onMessageEmitter = new Emitter<any>();
@@ -22,8 +22,8 @@ class ExtHostDashboardWebview implements sqlops.DashboardWebview {
 	constructor(
 		private readonly _proxy: MainThreadDashboardWebviewShape,
 		private readonly _handle: number,
-		private readonly _connection: sqlops.connection.Connection,
-		private readonly _serverInfo: sqlops.ServerInfo
+		private readonly _connection: azdata.connection.Connection,
+		private readonly _serverInfo: azdata.ServerInfo
 	) { }
 
 	public postMessage(message: any): Thenable<any> {
@@ -38,11 +38,11 @@ class ExtHostDashboardWebview implements sqlops.DashboardWebview {
 		return this.onClosedEmitter.event;
 	}
 
-	public get connection(): sqlops.connection.Connection {
+	public get connection(): azdata.connection.Connection {
 		return deepClone(this._connection);
 	}
 
-	public get serverInfo(): sqlops.ServerInfo {
+	public get serverInfo(): azdata.ServerInfo {
 		return deepClone(this._serverInfo);
 	}
 
@@ -62,7 +62,7 @@ export class ExtHostDashboardWebviews implements ExtHostDashboardWebviewsShape {
 	private readonly _proxy: MainThreadDashboardWebviewShape;
 
 	private readonly _webviews = new Map<number, ExtHostDashboardWebview>();
-	private readonly _handlers = new Map<string, (webview: sqlops.DashboardWebview) => void>();
+	private readonly _handlers = new Map<string, (webview: azdata.DashboardWebview) => void>();
 
 	constructor(
 		mainContext: IMainContext
@@ -81,12 +81,12 @@ export class ExtHostDashboardWebviews implements ExtHostDashboardWebviewsShape {
 		this._webviews.delete(handle);
 	}
 
-	$registerProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void): void {
+	$registerProvider(widgetId: string, handler: (webview: azdata.DashboardWebview) => void): void {
 		this._handlers.set(widgetId, handler);
 		this._proxy.$registerProvider(widgetId);
 	}
 
-	$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void {
+	$registerWidget(handle: number, id: string, connection: azdata.connection.Connection, serverInfo: azdata.ServerInfo): void {
 		let webview = new ExtHostDashboardWebview(this._proxy, handle, connection, serverInfo);
 		this._webviews.set(handle, webview);
 		this._handlers.get(id)(webview);

src/sql/workbench/api/node/extHostDataProtocol.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Event, Emitter } from 'vs/base/common/event';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
@@ -15,15 +15,15 @@ import { TPromise } from 'vs/base/common/winjs.base';
 
 export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 
-	private readonly _onDidChangeLanguageFlavor = new Emitter<sqlops.DidChangeLanguageFlavorParams>();
+	private readonly _onDidChangeLanguageFlavor = new Emitter<azdata.DidChangeLanguageFlavorParams>();
 
-	readonly onDidChangeLanguageFlavor: Event<sqlops.DidChangeLanguageFlavorParams> = this._onDidChangeLanguageFlavor.event;
+	readonly onDidChangeLanguageFlavor: Event<azdata.DidChangeLanguageFlavorParams> = this._onDidChangeLanguageFlavor.event;
 
 	private _proxy: MainThreadDataProtocolShape;
 
 	private static _handlePool: number = 0;
-	private _adapter = new Map<number, sqlops.DataProvider>();
-	private _providersByType = new Map<sqlops.DataProviderType, sqlops.DataProvider[]>();
+	private _adapter = new Map<number, azdata.DataProvider>();
+	private _providersByType = new Map<azdata.DataProviderType, azdata.DataProvider[]>();
 
 	constructor(
 		mainContext: IMainContext
@@ -43,7 +43,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		return ExtHostDataProtocol._handlePool++;
 	}
 
-	private _resolveProvider<P extends sqlops.DataProvider>(handle: number): P {
+	private _resolveProvider<P extends azdata.DataProvider>(handle: number): P {
 		let provider = this._adapter.get(handle) as P;
 		if (provider) {
 			return provider;
@@ -52,7 +52,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		}
 	}
 
-	private registerProvider(provider: sqlops.DataProvider, providerType: DataProviderType): vscode.Disposable {
+	private registerProvider(provider: azdata.DataProvider, providerType: DataProviderType): vscode.Disposable {
 		provider.handle = this._nextHandle();
 		this._adapter.set(provider.handle, provider);
 		let providersForType = this._providersByType.get(providerType);
@@ -65,7 +65,7 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		return this._createDisposable(provider.handle);
 	}
 
-	public getProvider<T extends sqlops.DataProvider>(providerId: string, providerType: sqlops.DataProviderType): T {
+	public getProvider<T extends azdata.DataProvider>(providerId: string, providerType: azdata.DataProviderType): T {
 		let providersForType = this._providersByType.get(providerType);
 		if (!providersForType) {
 			return undefined;
@@ -73,133 +73,133 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		return providersForType.find(provider => provider.providerId === providerId) as T;
 	}
 
-	public getProvidersByType<T extends sqlops.DataProvider>(providerType: sqlops.DataProviderType): T[] {
+	public getProvidersByType<T extends azdata.DataProvider>(providerType: azdata.DataProviderType): T[] {
 		let providersForType = this._providersByType.get(providerType);
 		return (providersForType || []) as T[];
 	}
 
-	$registerConnectionProvider(provider: sqlops.ConnectionProvider): vscode.Disposable {
+	$registerConnectionProvider(provider: azdata.ConnectionProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.ConnectionProvider);
 		this._proxy.$registerConnectionProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerBackupProvider(provider: sqlops.BackupProvider): vscode.Disposable {
+	$registerBackupProvider(provider: azdata.BackupProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.BackupProvider);
 		this._proxy.$registerBackupProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerRestoreProvider(provider: sqlops.RestoreProvider): vscode.Disposable {
+	$registerRestoreProvider(provider: azdata.RestoreProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.RestoreProvider);
 		this._proxy.$registerRestoreProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerScriptingProvider(provider: sqlops.ScriptingProvider): vscode.Disposable {
+	$registerScriptingProvider(provider: azdata.ScriptingProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.ScriptingProvider);
 		this._proxy.$registerScriptingProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerQueryProvider(provider: sqlops.QueryProvider): vscode.Disposable {
+	$registerQueryProvider(provider: azdata.QueryProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.QueryProvider);
 		this._proxy.$registerQueryProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerMetadataProvider(provider: sqlops.MetadataProvider): vscode.Disposable {
+	$registerMetadataProvider(provider: azdata.MetadataProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.MetadataProvider);
 		this._proxy.$registerMetadataProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerTaskServicesProvider(provider: sqlops.TaskServicesProvider): vscode.Disposable {
+	$registerTaskServicesProvider(provider: azdata.TaskServicesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.TaskServicesProvider);
 		this._proxy.$registerTaskServicesProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerFileBrowserProvider(provider: sqlops.FileBrowserProvider): vscode.Disposable {
+	$registerFileBrowserProvider(provider: azdata.FileBrowserProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.FileBrowserProvider);
 		this._proxy.$registerFileBrowserProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerObjectExplorerProvider(provider: sqlops.ObjectExplorerProvider): vscode.Disposable {
+	$registerObjectExplorerProvider(provider: azdata.ObjectExplorerProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.ObjectExplorerProvider);
 		this._proxy.$registerObjectExplorerProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerObjectExplorerNodeProvider(provider: sqlops.ObjectExplorerNodeProvider): vscode.Disposable {
+	$registerObjectExplorerNodeProvider(provider: azdata.ObjectExplorerNodeProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.ObjectExplorerNodeProvider);
 		this._proxy.$registerObjectExplorerNodeProvider(provider.providerId, provider.supportedProviderId, provider.group, provider.handle);
 		return rt;
 	}
 
-	$registerProfilerProvider(provider: sqlops.ProfilerProvider): vscode.Disposable {
+	$registerProfilerProvider(provider: azdata.ProfilerProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.ProfilerProvider);
 		this._proxy.$registerProfilerProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerAdminServicesProvider(provider: sqlops.AdminServicesProvider): vscode.Disposable {
+	$registerAdminServicesProvider(provider: azdata.AdminServicesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.AdminServicesProvider);
 		this._proxy.$registerAdminServicesProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerAgentServiceProvider(provider: sqlops.AgentServicesProvider): vscode.Disposable {
+	$registerAgentServiceProvider(provider: azdata.AgentServicesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.AgentServicesProvider);
 		this._proxy.$registerAgentServicesProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerCapabilitiesServiceProvider(provider: sqlops.CapabilitiesProvider): vscode.Disposable {
+	$registerCapabilitiesServiceProvider(provider: azdata.CapabilitiesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.CapabilitiesProvider);
 		this._proxy.$registerCapabilitiesServiceProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
-	$registerDacFxServiceProvider(provider: sqlops.DacFxServicesProvider): vscode.Disposable {
+	$registerDacFxServiceProvider(provider: azdata.DacFxServicesProvider): vscode.Disposable {
 		let rt = this.registerProvider(provider, DataProviderType.DacFxServicesProvider);
 		this._proxy.$registerDacFxServicesProvider(provider.providerId, provider.handle);
 		return rt;
 	}
 
 	// Capabilities Discovery handlers
-	$getServerCapabilities(handle: number, client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
-		return this._resolveProvider<sqlops.CapabilitiesProvider>(handle).getServerCapabilities(client);
+	$getServerCapabilities(handle: number, client: azdata.DataProtocolClientCapabilities): Thenable<azdata.DataProtocolServerCapabilities> {
+		return this._resolveProvider<azdata.CapabilitiesProvider>(handle).getServerCapabilities(client);
 	}
 
 	// Connection Management handlers
-	$connect(handle: number, connectionUri: string, connection: sqlops.ConnectionInfo): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).connect(connectionUri, connection);
+	$connect(handle: number, connectionUri: string, connection: azdata.ConnectionInfo): Thenable<boolean> {
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).connect(connectionUri, connection);
 	}
 
 	$disconnect(handle: number, connectionUri: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).disconnect(connectionUri);
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).disconnect(connectionUri);
 	}
 
 	$cancelConnect(handle: number, connectionUri: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).cancelConnect(connectionUri);
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).cancelConnect(connectionUri);
 	}
 
 	$changeDatabase(handle: number, connectionUri: string, newDatabase: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).changeDatabase(connectionUri, newDatabase);
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).changeDatabase(connectionUri, newDatabase);
 	}
 
-	$listDatabases(handle: number, connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).listDatabases(connectionUri);
+	$listDatabases(handle: number, connectionUri: string): Thenable<azdata.ListDatabasesResult> {
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).listDatabases(connectionUri);
 	}
 
 	$getConnectionString(handle: number, connectionUri: string, includePassword: boolean): Thenable<string> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).getConnectionString(connectionUri, includePassword);
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).getConnectionString(connectionUri, includePassword);
 	}
 
-	$buildConnectionInfo(handle: number, connectionString: string): Thenable<sqlops.ConnectionInfo> {
-		let provider = this._resolveProvider<sqlops.ConnectionProvider>(handle);
+	$buildConnectionInfo(handle: number, connectionString: string): Thenable<azdata.ConnectionInfo> {
+		let provider = this._resolveProvider<azdata.ConnectionProvider>(handle);
 		if (provider.buildConnectionInfo) {
 			return provider.buildConnectionInfo(connectionString);
 		} else {
@@ -208,10 +208,10 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	}
 
 	$rebuildIntelliSenseCache(handle: number, connectionUri: string): Thenable<void> {
-		return this._resolveProvider<sqlops.ConnectionProvider>(handle).rebuildIntelliSenseCache(connectionUri);
+		return this._resolveProvider<azdata.ConnectionProvider>(handle).rebuildIntelliSenseCache(connectionUri);
 	}
 
-	$onConnectComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
+	$onConnectComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void {
 		this._proxy.$onConnectionComplete(handle, connectionInfoSummary);
 	}
 
@@ -219,107 +219,107 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 		this._proxy.$onIntelliSenseCacheComplete(handle, connectionUri);
 	}
 
-	public $onConnectionChanged(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
+	public $onConnectionChanged(handle: number, changedConnInfo: azdata.ChangedConnectionInfo): void {
 		this._proxy.$onConnectionChangeNotification(handle, changedConnInfo);
 	}
 
 	// Protocol-wide Event Handlers
-	public $languageFlavorChanged(params: sqlops.DidChangeLanguageFlavorParams): void {
+	public $languageFlavorChanged(params: azdata.DidChangeLanguageFlavorParams): void {
 		this._onDidChangeLanguageFlavor.fire(params);
 	}
 
 	// Query Management handlers
 
-	$cancelQuery(handle: number, ownerUri: string): Thenable<sqlops.QueryCancelResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).cancelQuery(ownerUri);
+	$cancelQuery(handle: number, ownerUri: string): Thenable<azdata.QueryCancelResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).cancelQuery(ownerUri);
 	}
 
-	$runQuery(handle: number, ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).runQuery(ownerUri, selection, runOptions);
+	$runQuery(handle: number, ownerUri: string, selection: azdata.ISelectionData, runOptions?: azdata.ExecutionPlanOptions): Thenable<void> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).runQuery(ownerUri, selection, runOptions);
 	}
 
 	$runQueryStatement(handle: number, ownerUri: string, line: number, column: number): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryStatement(ownerUri, line, column);
+		return this._resolveProvider<azdata.QueryProvider>(handle).runQueryStatement(ownerUri, line, column);
 	}
 
 	$runQueryString(handle: number, ownerUri: string, queryString: string): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryString(ownerUri, queryString);
+		return this._resolveProvider<azdata.QueryProvider>(handle).runQueryString(ownerUri, queryString);
 	}
 
-	$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).runQueryAndReturn(ownerUri, queryString);
+	$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<azdata.SimpleExecuteResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).runQueryAndReturn(ownerUri, queryString);
 	}
 
-	$parseSyntax(handle: number, ownerUri: string, query: string): Thenable<sqlops.SyntaxParseResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).parseSyntax(ownerUri, query);
+	$parseSyntax(handle: number, ownerUri: string, query: string): Thenable<azdata.SyntaxParseResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).parseSyntax(ownerUri, query);
 	}
 
-	$getQueryRows(handle: number, rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).getQueryRows(rowData);
+	$getQueryRows(handle: number, rowData: azdata.QueryExecuteSubsetParams): Thenable<azdata.QueryExecuteSubsetResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).getQueryRows(rowData);
 	}
 
 	$disposeQuery(handle: number, ownerUri: string): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).disposeQuery(ownerUri);
+		return this._resolveProvider<azdata.QueryProvider>(handle).disposeQuery(ownerUri);
 	}
 
-	$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void {
+	$onQueryComplete(handle: number, result: azdata.QueryExecuteCompleteNotificationResult): void {
 		this._proxy.$onQueryComplete(handle, result);
 	}
-	$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
+	$onBatchStart(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void {
 		this._proxy.$onBatchStart(handle, batchInfo);
 	}
-	$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
+	$onBatchComplete(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void {
 		this._proxy.$onBatchComplete(handle, batchInfo);
 	}
-	$onResultSetAvailable(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void {
+	$onResultSetAvailable(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void {
 		this._proxy.$onResultSetAvailable(handle, resultSetInfo);
 	}
-	$onResultSetUpdated(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void {
+	$onResultSetUpdated(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void {
 		this._proxy.$onResultSetUpdated(handle, resultSetInfo);
 	}
-	$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void {
+	$onQueryMessage(handle: number, message: azdata.QueryExecuteMessageParams): void {
 		this._proxy.$onQueryMessage(handle, message);
 	}
 
-	$saveResults(handle: number, requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).saveResults(requestParams);
+	$saveResults(handle: number, requestParams: azdata.SaveResultsRequestParams): Thenable<azdata.SaveResultRequestResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).saveResults(requestParams);
 	}
 
 	// Edit Data handlers
 	$commitEdit(handle: number, ownerUri: string): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).commitEdit(ownerUri);
+		return this._resolveProvider<azdata.QueryProvider>(handle).commitEdit(ownerUri);
 	}
 
-	$createRow(handle: number, ownerUri: string): Thenable<sqlops.EditCreateRowResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).createRow(ownerUri);
+	$createRow(handle: number, ownerUri: string): Thenable<azdata.EditCreateRowResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).createRow(ownerUri);
 	}
 
 	$deleteRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).deleteRow(ownerUri, rowId);
+		return this._resolveProvider<azdata.QueryProvider>(handle).deleteRow(ownerUri, rowId);
 	}
 
 	$disposeEdit(handle: number, ownerUri: string): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).disposeEdit(ownerUri);
+		return this._resolveProvider<azdata.QueryProvider>(handle).disposeEdit(ownerUri);
 	}
 
 	$initializeEdit(handle: number, ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number, queryString: string): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit, queryString);
+		return this._resolveProvider<azdata.QueryProvider>(handle).initializeEdit(ownerUri, schemaName, objectName, objectType, rowLimit, queryString);
 	}
 
-	$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).revertCell(ownerUri, rowId, columnId);
+	$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<azdata.EditRevertCellResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).revertCell(ownerUri, rowId, columnId);
 	}
 
 	$revertRow(handle: number, ownerUri: string, rowId: number): Thenable<void> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).revertRow(ownerUri, rowId);
+		return this._resolveProvider<azdata.QueryProvider>(handle).revertRow(ownerUri, rowId);
 	}
 
-	$updateCell(handle: number, ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).updateCell(ownerUri, rowId, columnId, newValue);
+	$updateCell(handle: number, ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<azdata.EditUpdateCellResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).updateCell(ownerUri, rowId, columnId, newValue);
 	}
 
-	$getEditRows(handle: number, rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> {
-		return this._resolveProvider<sqlops.QueryProvider>(handle).getEditRows(rowData);
+	$getEditRows(handle: number, rowData: azdata.EditSubsetParams): Thenable<azdata.EditSubsetResult> {
+		return this._resolveProvider<azdata.QueryProvider>(handle).getEditRows(rowData);
 	}
 
 	$onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -327,171 +327,171 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	}
 
 	// Metadata handlers
-	public $getMetadata(handle: number, connectionUri: string): Thenable<sqlops.ProviderMetadata> {
-		return this._resolveProvider<sqlops.MetadataProvider>(handle).getMetadata(connectionUri);
+	public $getMetadata(handle: number, connectionUri: string): Thenable<azdata.ProviderMetadata> {
+		return this._resolveProvider<azdata.MetadataProvider>(handle).getMetadata(connectionUri);
 	}
 
 	public $getDatabases(handle: number, connectionUri: string): Thenable<string[]> {
-		return this._resolveProvider<sqlops.MetadataProvider>(handle).getDatabases(connectionUri);
+		return this._resolveProvider<azdata.MetadataProvider>(handle).getDatabases(connectionUri);
 	}
 
-	public $getTableInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
-		return this._resolveProvider<sqlops.MetadataProvider>(handle).getTableInfo(connectionUri, metadata);
+	public $getTableInfo(handle: number, connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> {
+		return this._resolveProvider<azdata.MetadataProvider>(handle).getTableInfo(connectionUri, metadata);
 	}
 
-	public $getViewInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
-		return this._resolveProvider<sqlops.MetadataProvider>(handle).getViewInfo(connectionUri, metadata);
+	public $getViewInfo(handle: number, connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> {
+		return this._resolveProvider<azdata.MetadataProvider>(handle).getViewInfo(connectionUri, metadata);
 	}
 
 	// Object Explorer Service
-	public $createObjectExplorerSession(handle: number, connInfo: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> {
-		return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).createNewSession(connInfo);
+	public $createObjectExplorerSession(handle: number, connInfo: azdata.ConnectionInfo): Thenable<azdata.ObjectExplorerSessionResponse> {
+		return this._resolveProvider<azdata.ObjectExplorerProvider>(handle).createNewSession(connInfo);
 	}
 
-	public $createObjectExplorerNodeProviderSession(handle: number, session: sqlops.ObjectExplorerSession): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ObjectExplorerNodeProvider>(handle).handleSessionOpen(session);
+	public $createObjectExplorerNodeProviderSession(handle: number, session: azdata.ObjectExplorerSession): Thenable<boolean> {
+		return this._resolveProvider<azdata.ObjectExplorerNodeProvider>(handle).handleSessionOpen(session);
 	}
 
-	public $expandObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ObjectExplorerProviderBase> (handle).expandNode(nodeInfo);
+	public $expandObjectExplorerNode(handle: number, nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
+		return this._resolveProvider<azdata.ObjectExplorerProviderBase> (handle).expandNode(nodeInfo);
 	}
 
-	public $refreshObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ObjectExplorerProviderBase> (handle).refreshNode(nodeInfo);
+	public $refreshObjectExplorerNode(handle: number, nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
+		return this._resolveProvider<azdata.ObjectExplorerProviderBase> (handle).refreshNode(nodeInfo);
 	}
 
-	public $closeObjectExplorerSession(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
-		return this._resolveProvider<sqlops.ObjectExplorerProvider>(handle).closeSession(closeSessionInfo);
+	public $closeObjectExplorerSession(handle: number, closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): Thenable<azdata.ObjectExplorerCloseSessionResponse> {
+		return this._resolveProvider<azdata.ObjectExplorerProvider>(handle).closeSession(closeSessionInfo);
 	}
 
-	public $handleSessionClose(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): void {
-		return this._resolveProvider<sqlops.ObjectExplorerNodeProvider>(handle).handleSessionClose(closeSessionInfo);
+	public $handleSessionClose(handle: number, closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): void {
+		return this._resolveProvider<azdata.ObjectExplorerNodeProvider>(handle).handleSessionClose(closeSessionInfo);
 	}
 
-	public $findNodes(handle: number, findNodesInfo: sqlops.FindNodesInfo): Thenable<sqlops.ObjectExplorerFindNodesResponse> {
-		return this._resolveProvider<sqlops.ObjectExplorerProviderBase>(handle).findNodes(findNodesInfo);
+	public $findNodes(handle: number, findNodesInfo: azdata.FindNodesInfo): Thenable<azdata.ObjectExplorerFindNodesResponse> {
+		return this._resolveProvider<azdata.ObjectExplorerProviderBase>(handle).findNodes(findNodesInfo);
 	}
 
-	public $onObjectExplorerSessionCreated(handle: number, response: sqlops.ObjectExplorerSession): void {
+	public $onObjectExplorerSessionCreated(handle: number, response: azdata.ObjectExplorerSession): void {
 		this._proxy.$onObjectExplorerSessionCreated(handle, response);
 	}
 
-	public $onObjectExplorerSessionDisconnected(handle: number, response: sqlops.ObjectExplorerSession): void {
+	public $onObjectExplorerSessionDisconnected(handle: number, response: azdata.ObjectExplorerSession): void {
 		this._proxy.$onObjectExplorerSessionDisconnected(handle, response);
 	}
 
-	public $onObjectExplorerNodeExpanded(providerId: string, response: sqlops.ObjectExplorerExpandInfo): void {
+	public $onObjectExplorerNodeExpanded(providerId: string, response: azdata.ObjectExplorerExpandInfo): void {
 		this._proxy.$onObjectExplorerNodeExpanded(providerId, response);
 	}
 
 	// Task Service
-	public $getAllTasks(handle: number, listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> {
-		return this._resolveProvider<sqlops.TaskServicesProvider>(handle).getAllTasks(listTasksParams);
+	public $getAllTasks(handle: number, listTasksParams: azdata.ListTasksParams): Thenable<azdata.ListTasksResponse> {
+		return this._resolveProvider<azdata.TaskServicesProvider>(handle).getAllTasks(listTasksParams);
 	}
 
-	public $cancelTask(handle: number, cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> {
-		return this._resolveProvider<sqlops.TaskServicesProvider>(handle).cancelTask(cancelTaskParams);
+	public $cancelTask(handle: number, cancelTaskParams: azdata.CancelTaskParams): Thenable<boolean> {
+		return this._resolveProvider<azdata.TaskServicesProvider>(handle).cancelTask(cancelTaskParams);
 	}
 
-	public $onTaskStatusChanged(handle: number, response: sqlops.TaskProgressInfo): void {
+	public $onTaskStatusChanged(handle: number, response: azdata.TaskProgressInfo): void {
 		this._proxy.$onTaskStatusChanged(handle, response);
 	}
 
-	public $onTaskCreated(handle: number, response: sqlops.TaskInfo): void {
+	public $onTaskCreated(handle: number, response: azdata.TaskInfo): void {
 		this._proxy.$onTaskCreated(handle, response);
 	}
 
 	// Scripting handlers
 
-	public $scriptAsOperation(handle: number, connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> {
-		return this._resolveProvider<sqlops.ScriptingProvider>(handle).scriptAsOperation(connectionUri, operation, metadata, paramDetails);
+	public $scriptAsOperation(handle: number, connectionUri: string, operation: azdata.ScriptOperation, metadata: azdata.ObjectMetadata, paramDetails: azdata.ScriptingParamDetails): Thenable<azdata.ScriptingResult> {
+		return this._resolveProvider<azdata.ScriptingProvider>(handle).scriptAsOperation(connectionUri, operation, metadata, paramDetails);
 	}
 
-	public $onScriptingComplete(handle: number, scriptingCompleteResult: sqlops.ScriptingCompleteResult): void {
+	public $onScriptingComplete(handle: number, scriptingCompleteResult: azdata.ScriptingCompleteResult): void {
 		this._proxy.$onScriptingComplete(handle, scriptingCompleteResult);
 	}
 
 	/**
 	 * Create a new database on the provided connection
 	 */
-	public $createDatabase(handle: number, connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> {
-		return this._resolveProvider<sqlops.AdminServicesProvider>(handle).createDatabase(connectionUri, database);
+	public $createDatabase(handle: number, connectionUri: string, database: azdata.DatabaseInfo): Thenable<azdata.CreateDatabaseResponse> {
+		return this._resolveProvider<azdata.AdminServicesProvider>(handle).createDatabase(connectionUri, database);
 	}
 
 	/**
 	 * Create a new database on the provided connection
 	 */
-	public $getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> {
-		return this._resolveProvider<sqlops.AdminServicesProvider>(handle).getDefaultDatabaseInfo(connectionUri);
+	public $getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<azdata.DatabaseInfo> {
+		return this._resolveProvider<azdata.AdminServicesProvider>(handle).getDefaultDatabaseInfo(connectionUri);
 	}
 
 	/**
 	 * Get the info on a database
 	 */
-	public $getDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> {
-		return this._resolveProvider<sqlops.AdminServicesProvider>(handle).getDatabaseInfo(connectionUri);
+	public $getDatabaseInfo(handle: number, connectionUri: string): Thenable<azdata.DatabaseInfo> {
+		return this._resolveProvider<azdata.AdminServicesProvider>(handle).getDatabaseInfo(connectionUri);
 	}
 
 	/**
 	 * Create a new login on the provided connection
 	 */
-	public $createLogin(handle: number, connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> {
-		return this._resolveProvider<sqlops.AdminServicesProvider>(handle).createLogin(connectionUri, login);
+	public $createLogin(handle: number, connectionUri: string, login: azdata.LoginInfo): Thenable<azdata.CreateLoginResponse> {
+		return this._resolveProvider<azdata.AdminServicesProvider>(handle).createLogin(connectionUri, login);
 	}
 
 	/**
 	 * Backup a database
 	 */
-	public $backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> {
-		return this._resolveProvider<sqlops.BackupProvider>(handle).backup(connectionUri, backupInfo, taskExecutionMode);
+	public $backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.BackupResponse> {
+		return this._resolveProvider<azdata.BackupProvider>(handle).backup(connectionUri, backupInfo, taskExecutionMode);
 	}
 
 	/**
 	* Create a new database on the provided connection
 	*/
-	public $getBackupConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.BackupConfigInfo> {
-		return this._resolveProvider<sqlops.BackupProvider>(handle).getBackupConfigInfo(connectionUri);
+	public $getBackupConfigInfo(handle: number, connectionUri: string): Thenable<azdata.BackupConfigInfo> {
+		return this._resolveProvider<azdata.BackupProvider>(handle).getBackupConfigInfo(connectionUri);
 	}
 
 	/**
 	 * Restores a database
 	 */
-	public $restore(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> {
-		return this._resolveProvider<sqlops.RestoreProvider>(handle).restore(connectionUri, restoreInfo);
+	public $restore(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestoreResponse> {
+		return this._resolveProvider<azdata.RestoreProvider>(handle).restore(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * Gets a plan for restoring a database
 	 */
-	public $getRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> {
-		return this._resolveProvider<sqlops.RestoreProvider>(handle).getRestorePlan(connectionUri, restoreInfo);
+	public $getRestorePlan(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestorePlanResponse> {
+		return this._resolveProvider<azdata.RestoreProvider>(handle).getRestorePlan(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * cancels a restore plan
 	 */
-	public $cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> {
-		return this._resolveProvider<sqlops.RestoreProvider>(handle).cancelRestorePlan(connectionUri, restoreInfo);
+	public $cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<boolean> {
+		return this._resolveProvider<azdata.RestoreProvider>(handle).cancelRestorePlan(connectionUri, restoreInfo);
 	}
 
 	/**
 	 * Gets restore config Info
 	 */
-	public $getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.RestoreConfigInfo> {
-		return this._resolveProvider<sqlops.RestoreProvider>(handle).getRestoreConfigInfo(connectionUri);
+	public $getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<azdata.RestoreConfigInfo> {
+		return this._resolveProvider<azdata.RestoreProvider>(handle).getRestoreConfigInfo(connectionUri);
 	}
 
 	/**
 	 * Open a file browser
 	 */
 	public $openFileBrowser(handle: number, ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
-		return this._resolveProvider<sqlops.FileBrowserProvider>(handle).openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter);
+		return this._resolveProvider<azdata.FileBrowserProvider>(handle).openFileBrowser(ownerUri, expandPath, fileFilters, changeFilter);
 	}
 
 	/**
 	 * Send event when opening browser is complete
 	 */
-	public $onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void {
+	public $onFileBrowserOpened(handle: number, response: azdata.FileBrowserOpenedParams): void {
 		this._proxy.$onFileBrowserOpened(handle, response);
 	}
 
@@ -499,13 +499,13 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Expand a folder node
 	 */
 	public $expandFolderNode(handle: number, ownerUri: string, expandPath: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.FileBrowserProvider>(handle).expandFolderNode(ownerUri, expandPath);
+		return this._resolveProvider<azdata.FileBrowserProvider>(handle).expandFolderNode(ownerUri, expandPath);
 	}
 
 	/**
 	 * Send event when expansion is complete
 	 */
-	public $onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void {
+	public $onFolderNodeExpanded(handle: number, response: azdata.FileBrowserExpandedParams): void {
 		this._proxy.$onFolderNodeExpanded(handle, response);
 	}
 
@@ -513,21 +513,21 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	 * Validate selected file path
 	 */
 	public $validateFilePaths(handle: number, ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
-		return this._resolveProvider<sqlops.FileBrowserProvider>(handle).validateFilePaths(ownerUri, serviceType, selectedFiles);
+		return this._resolveProvider<azdata.FileBrowserProvider>(handle).validateFilePaths(ownerUri, serviceType, selectedFiles);
 	}
 
 	/**
 	 * Send event when validation is complete
 	 */
-	public $onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams) {
+	public $onFilePathsValidated(handle: number, response: azdata.FileBrowserValidatedParams) {
 		this._proxy.$onFilePathsValidated(handle, response);
 	}
 
 	/**
 	 * Close file browser
 	 */
-	public $closeFileBrowser(handle: number, ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> {
-		return this._resolveProvider<sqlops.FileBrowserProvider>(handle).closeFileBrowser(ownerUri);
+	public $closeFileBrowser(handle: number, ownerUri: string): Thenable<azdata.FileBrowserCloseResponse> {
+		return this._resolveProvider<azdata.FileBrowserProvider>(handle).closeFileBrowser(ownerUri);
 	}
 
 	/**
@@ -537,63 +537,63 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	/**
 	 * Create a new profiler session
 	 */
-	public $createSession(handle: number, sessionId: string, createStatement: string, template: sqlops.ProfilerSessionTemplate): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).createSession(sessionId, createStatement, template);
+	public $createSession(handle: number, sessionId: string, createStatement: string, template: azdata.ProfilerSessionTemplate): Thenable<boolean> {
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).createSession(sessionId, createStatement, template);
 	}
 
 	/**
 	 * Start a profiler session
 	 */
 	public $startSession(handle: number, sessionId: string, sessionName: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).startSession(sessionId, sessionName);
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).startSession(sessionId, sessionName);
 	}
 
 	/**
 	 * Stop a profiler session
 	 */
 	public $stopSession(handle: number, sessionId: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).stopSession(sessionId);
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).stopSession(sessionId);
 	}
 
 	/**
 	 * Pause a profiler session
 	 */
 	public $pauseSession(handle: number, sessionId: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).pauseSession(sessionId);
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).pauseSession(sessionId);
 	}
 
 	/**
 	 * Disconnect a profiler session
 	 */
 	public $disconnectSession(handle: number, sessionId: string): Thenable<boolean> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).disconnectSession(sessionId);
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).disconnectSession(sessionId);
 	}
 
 	/**
 	 * Get list of running XEvent sessions on the session's target server
 	 */
 	public $getXEventSessions(handle: number, sessionId: string): Thenable<string[]> {
-		return this._resolveProvider<sqlops.ProfilerProvider>(handle).getXEventSessions(sessionId);
+		return this._resolveProvider<azdata.ProfilerProvider>(handle).getXEventSessions(sessionId);
 	}
 
 	/**
 	 * Profiler session events available notification
 	 */
-	public $onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void {
+	public $onSessionEventsAvailable(handle: number, response: azdata.ProfilerSessionEvents): void {
 		this._proxy.$onSessionEventsAvailable(handle, response);
 	}
 
 	/**
 	 * Profiler session stopped unexpectedly notification
 	 */
-	public $onSessionStopped(handle: number, response: sqlops.ProfilerSessionStoppedParams): void {
+	public $onSessionStopped(handle: number, response: azdata.ProfilerSessionStoppedParams): void {
 		this._proxy.$onSessionStopped(handle, response);
 	}
 
 	/**
 	 * Profiler session created notification
 	 */
-	public $onProfilerSessionCreated(handle: number, response: sqlops.ProfilerSessionCreatedParams): void {
+	public $onProfilerSessionCreated(handle: number, response: azdata.ProfilerSessionCreatedParams): void {
 		this._proxy.$onProfilerSessionCreated(handle, response);
 	}
 
@@ -605,85 +605,85 @@ export class ExtHostDataProtocol extends ExtHostDataProtocolShape {
 	/**
 	 * Get Agent Job list
 	 */
-	public $getJobs(handle: number, ownerUri: string): Thenable<sqlops.AgentJobsResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getJobs(ownerUri);
+	public $getJobs(handle: number, ownerUri: string): Thenable<azdata.AgentJobsResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getJobs(ownerUri);
 	}
 
 	/**
 	 * Get a Agent Job's history
 	 */
-	public $getJobHistory(handle: number, ownerUri: string, jobID: string, jobName: string): Thenable<sqlops.AgentJobHistoryResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getJobHistory(ownerUri, jobID, jobName);
+	public $getJobHistory(handle: number, ownerUri: string, jobID: string, jobName: string): Thenable<azdata.AgentJobHistoryResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getJobHistory(ownerUri, jobID, jobName);
 	}
 
 	/**
 	 * Run an action on a job
 	 */
-	public $jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).jobAction(ownerUri, jobName, action);
+	public $jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<azdata.ResultStatus> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).jobAction(ownerUri, jobName, action);
 	}
 
 	/**
 	 * Deletes a job
 	 */
-	$deleteJob(handle: number, ownerUri: string, job: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> {
-		throw this._resolveProvider<sqlops.AgentServicesProvider>(handle).deleteJob(ownerUri, job);
+	$deleteJob(handle: number, ownerUri: string, job: azdata.AgentJobInfo): Thenable<azdata.ResultStatus> {
+		throw this._resolveProvider<azdata.AgentServicesProvider>(handle).deleteJob(ownerUri, job);
 	}
 
 	/**
 	 * Deletes a job step
 	 */
-	$deleteJobStep(handle: number, ownerUri: string, step: sqlops.AgentJobStepInfo): Thenable<sqlops.ResultStatus> {
-		throw this._resolveProvider<sqlops.AgentServicesProvider>(handle).deleteJobStep(ownerUri, step);
+	$deleteJobStep(handle: number, ownerUri: string, step: azdata.AgentJobStepInfo): Thenable<azdata.ResultStatus> {
+		throw this._resolveProvider<azdata.AgentServicesProvider>(handle).deleteJobStep(ownerUri, step);
 	}
 
 	/**
 	 * Get Agent Alerts list
 	 */
-	$getAlerts(handle: number, ownerUri: string): Thenable<sqlops.AgentAlertsResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getAlerts(ownerUri);
+	$getAlerts(handle: number, ownerUri: string): Thenable<azdata.AgentAlertsResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getAlerts(ownerUri);
 	}
 
 	/**
 	 * Deletes an alert
 	 */
-	$deleteAlert(handle: number, ownerUri: string, alert: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).deleteAlert(ownerUri, alert);
+	$deleteAlert(handle: number, ownerUri: string, alert: azdata.AgentAlertInfo): Thenable<azdata.ResultStatus> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).deleteAlert(ownerUri, alert);
 	}
 
 	/**
 	 * Get Agent Oeprators list
 	 */
-	$getOperators(handle: number, ownerUri: string): Thenable<sqlops.AgentOperatorsResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getOperators(ownerUri);
+	$getOperators(handle: number, ownerUri: string): Thenable<azdata.AgentOperatorsResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getOperators(ownerUri);
 	}
 
 	/**
 	 * Deletes an operator
 	 */
-	$deleteOperator(handle: number, ownerUri: string, operator: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).deleteOperator(ownerUri, operator);
+	$deleteOperator(handle: number, ownerUri: string, operator: azdata.AgentOperatorInfo): Thenable<azdata.ResultStatus> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).deleteOperator(ownerUri, operator);
 	}
 
 	/**
 	 * Get Agent Proxies list
 	 */
-	$getProxies(handle: number, ownerUri: string): Thenable<sqlops.AgentProxiesResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getProxies(ownerUri);
+	$getProxies(handle: number, ownerUri: string): Thenable<azdata.AgentProxiesResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getProxies(ownerUri);
 	}
 
 	/**
 	 * Deletes a proxy
 	 */
-	$deleteProxy(handle: number, ownerUri: string, proxy: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).deleteProxy(ownerUri, proxy);
+	$deleteProxy(handle: number, ownerUri: string, proxy: azdata.AgentProxyInfo): Thenable<azdata.ResultStatus> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).deleteProxy(ownerUri, proxy);
 	}
 
 	/**
 	 * Gets Agent Credentials from server
 	 */
-	$getCredentials(handle: number, ownerUri: string): Thenable<sqlops.GetCredentialsResult> {
-		return this._resolveProvider<sqlops.AgentServicesProvider>(handle).getCredentials(ownerUri);
+	$getCredentials(handle: number, ownerUri: string): Thenable<azdata.GetCredentialsResult> {
+		return this._resolveProvider<azdata.AgentServicesProvider>(handle).getCredentials(ownerUri);
 	}
 
 	/**

src/sql/workbench/api/node/extHostModalDialog.ts

@@ -7,10 +7,10 @@
 import { SqlMainContext, MainThreadModalDialogShape, ExtHostModalDialogsShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Emitter } from 'vs/base/common/event';
 
-class ExtHostDialog implements sqlops.ModalDialog {
+class ExtHostDialog implements azdata.ModalDialog {
 	private _title: string;
 	private _html: string;
 	private _okTitle: string;
@@ -97,7 +97,7 @@ export class ExtHostModalDialogs implements ExtHostModalDialogsShape {
 
 	createDialog(
 		title: string
-	): sqlops.ModalDialog {
+	): azdata.ModalDialog {
 		console.log(title);
 		const handle = ExtHostModalDialogs._handlePool++;
 		this._proxy.$createDialog(handle);

src/sql/workbench/api/node/extHostModelView.ts

@@ -11,13 +11,13 @@ import { URI } from 'vs/base/common/uri';
 import * as nls from 'vs/nls';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { SqlMainContext, ExtHostModelViewShape, MainThreadModelViewShape, ExtHostModelViewTreeViewsShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { IItemConfig, ModelComponentTypes, IComponentShape, IComponentEventArgs, ComponentEventType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
 
-class ModelBuilderImpl implements sqlops.ModelBuilder {
+class ModelBuilderImpl implements azdata.ModelBuilder {
 	private nextComponentId: number;
 	private readonly _componentBuilders = new Map<string, ComponentBuilderImpl<any>>();
 
@@ -31,182 +31,182 @@ class ModelBuilderImpl implements sqlops.ModelBuilder {
 		this.nextComponentId = 0;
 	}
 
-	navContainer(): sqlops.ContainerBuilder<sqlops.NavContainer, any, any> {
+	navContainer(): azdata.ContainerBuilder<azdata.NavContainer, any, any> {
 		let id = this.getNextComponentId();
-		let container: GenericContainerBuilder<sqlops.NavContainer, any, any> = new GenericContainerBuilder(this._proxy, this._handle, ModelComponentTypes.NavContainer, id);
+		let container: GenericContainerBuilder<azdata.NavContainer, any, any> = new GenericContainerBuilder(this._proxy, this._handle, ModelComponentTypes.NavContainer, id);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	divContainer(): sqlops.DivBuilder {
+	divContainer(): azdata.DivBuilder {
 		let id = this.getNextComponentId();
 		let container = new DivContainerBuilder(this._proxy, this._handle, ModelComponentTypes.DivContainer, id);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	flexContainer(): sqlops.FlexBuilder {
+	flexContainer(): azdata.FlexBuilder {
 		let id = this.getNextComponentId();
-		let container: GenericContainerBuilder<sqlops.FlexContainer, any, any> = new GenericContainerBuilder<sqlops.FlexContainer, sqlops.FlexLayout, sqlops.FlexItemLayout>(this._proxy, this._handle, ModelComponentTypes.FlexContainer, id);
+		let container: GenericContainerBuilder<azdata.FlexContainer, any, any> = new GenericContainerBuilder<azdata.FlexContainer, azdata.FlexLayout, azdata.FlexItemLayout>(this._proxy, this._handle, ModelComponentTypes.FlexContainer, id);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	formContainer(): sqlops.FormBuilder {
+	formContainer(): azdata.FormBuilder {
 		let id = this.getNextComponentId();
 		let container = new FormContainerBuilder(this._proxy, this._handle, ModelComponentTypes.Form, id, this);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	toolbarContainer(): sqlops.ToolbarBuilder {
+	toolbarContainer(): azdata.ToolbarBuilder {
 		let id = this.getNextComponentId();
 		let container = new ToolbarContainerBuilder(this._proxy, this._handle, ModelComponentTypes.Toolbar, id);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	groupContainer(): sqlops.GroupBuilder {
+	groupContainer(): azdata.GroupBuilder {
 		let id = this.getNextComponentId();
-		let container: GenericContainerBuilder<sqlops.GroupContainer, any, any> = new GenericContainerBuilder<sqlops.GroupContainer, sqlops.GroupLayout, sqlops.GroupItemLayout>(this._proxy, this._handle, ModelComponentTypes.Group, id);
+		let container: GenericContainerBuilder<azdata.GroupContainer, any, any> = new GenericContainerBuilder<azdata.GroupContainer, azdata.GroupLayout, azdata.GroupItemLayout>(this._proxy, this._handle, ModelComponentTypes.Group, id);
 		this._componentBuilders.set(id, container);
 		return container;
 	}
 
-	card(): sqlops.ComponentBuilder<sqlops.CardComponent> {
+	card(): azdata.ComponentBuilder<azdata.CardComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.CardComponent> = this.getComponentBuilder(new CardWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.CardComponent> = this.getComponentBuilder(new CardWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	tree<T>(): sqlops.ComponentBuilder<sqlops.TreeComponent<T>> {
+	tree<T>(): azdata.ComponentBuilder<azdata.TreeComponent<T>> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.TreeComponent<T>> = this.getComponentBuilder(new TreeComponentWrapper(this._extHostModelViewTree, this._proxy, this._handle, id, this._extension), id);
+		let builder: ComponentBuilderImpl<azdata.TreeComponent<T>> = this.getComponentBuilder(new TreeComponentWrapper(this._extHostModelViewTree, this._proxy, this._handle, id, this._extension), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	inputBox(): sqlops.ComponentBuilder<sqlops.InputBoxComponent> {
+	inputBox(): azdata.ComponentBuilder<azdata.InputBoxComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.InputBoxComponent> = this.getComponentBuilder(new InputBoxWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.InputBoxComponent> = this.getComponentBuilder(new InputBoxWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	text(): sqlops.ComponentBuilder<sqlops.TextComponent> {
+	text(): azdata.ComponentBuilder<azdata.TextComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.TextComponent> = this.getComponentBuilder(new TextComponentWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.TextComponent> = this.getComponentBuilder(new TextComponentWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	radioButton(): sqlops.ComponentBuilder<sqlops.RadioButtonComponent> {
+	radioButton(): azdata.ComponentBuilder<azdata.RadioButtonComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.RadioButtonComponent> = this.getComponentBuilder(new RadioButtonWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.RadioButtonComponent> = this.getComponentBuilder(new RadioButtonWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	checkBox(): sqlops.ComponentBuilder<sqlops.CheckBoxComponent> {
+	checkBox(): azdata.ComponentBuilder<azdata.CheckBoxComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.CheckBoxComponent> = this.getComponentBuilder(new CheckBoxWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.CheckBoxComponent> = this.getComponentBuilder(new CheckBoxWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	webView(): sqlops.ComponentBuilder<sqlops.WebViewComponent> {
+	webView(): azdata.ComponentBuilder<azdata.WebViewComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.WebViewComponent> = this.getComponentBuilder(new WebViewWrapper(this._proxy, this._handle, id, this._extension.extensionLocation), id);
+		let builder: ComponentBuilderImpl<azdata.WebViewComponent> = this.getComponentBuilder(new WebViewWrapper(this._proxy, this._handle, id, this._extension.extensionLocation), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	editor(): sqlops.ComponentBuilder<sqlops.EditorComponent> {
+	editor(): azdata.ComponentBuilder<azdata.EditorComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.EditorComponent> = this.getComponentBuilder(new EditorWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.EditorComponent> = this.getComponentBuilder(new EditorWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	button(): sqlops.ComponentBuilder<sqlops.ButtonComponent> {
+	button(): azdata.ComponentBuilder<azdata.ButtonComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.ButtonComponent> = this.getComponentBuilder(new ButtonWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.ButtonComponent> = this.getComponentBuilder(new ButtonWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	dropDown(): sqlops.ComponentBuilder<sqlops.DropDownComponent> {
+	dropDown(): azdata.ComponentBuilder<azdata.DropDownComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.DropDownComponent> = this.getComponentBuilder(new DropDownWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.DropDownComponent> = this.getComponentBuilder(new DropDownWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	listBox(): sqlops.ComponentBuilder<sqlops.ListBoxComponent> {
+	listBox(): azdata.ComponentBuilder<azdata.ListBoxComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.ListBoxComponent> = this.getComponentBuilder(new ListBoxWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.ListBoxComponent> = this.getComponentBuilder(new ListBoxWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	table(): sqlops.ComponentBuilder<sqlops.TableComponent> {
+	table(): azdata.ComponentBuilder<azdata.TableComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.TableComponent> = this.getComponentBuilder(new TableComponentWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.TableComponent> = this.getComponentBuilder(new TableComponentWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	declarativeTable(): sqlops.ComponentBuilder<sqlops.DeclarativeTableComponent> {
+	declarativeTable(): azdata.ComponentBuilder<azdata.DeclarativeTableComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.DeclarativeTableComponent> = this.getComponentBuilder(new DeclarativeTableWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.DeclarativeTableComponent> = this.getComponentBuilder(new DeclarativeTableWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	dashboardWidget(widgetId: string): sqlops.ComponentBuilder<sqlops.DashboardWidgetComponent> {
+	dashboardWidget(widgetId: string): azdata.ComponentBuilder<azdata.DashboardWidgetComponent> {
 		let id = this.getNextComponentId();
-		let builder = this.getComponentBuilder<sqlops.DashboardWidgetComponent>(new ComponentWrapper(this._proxy, this._handle, ModelComponentTypes.DashboardWidget, id), id);
+		let builder = this.getComponentBuilder<azdata.DashboardWidgetComponent>(new ComponentWrapper(this._proxy, this._handle, ModelComponentTypes.DashboardWidget, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	dashboardWebview(webviewId: string): sqlops.ComponentBuilder<sqlops.DashboardWebviewComponent> {
+	dashboardWebview(webviewId: string): azdata.ComponentBuilder<azdata.DashboardWebviewComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.DashboardWebviewComponent> = this.getComponentBuilder(new ComponentWrapper(this._proxy, this._handle, ModelComponentTypes.DashboardWebview, id), id);
+		let builder: ComponentBuilderImpl<azdata.DashboardWebviewComponent> = this.getComponentBuilder(new ComponentWrapper(this._proxy, this._handle, ModelComponentTypes.DashboardWebview, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	loadingComponent(): sqlops.LoadingComponentBuilder {
+	loadingComponent(): azdata.LoadingComponentBuilder {
 		let id = this.getNextComponentId();
 		let builder = new LoadingComponentBuilder(new LoadingComponentWrapper(this._proxy, this._handle, id));
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	fileBrowserTree(): sqlops.ComponentBuilder<sqlops.FileBrowserTreeComponent> {
+	fileBrowserTree(): azdata.ComponentBuilder<azdata.FileBrowserTreeComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.FileBrowserTreeComponent> = this.getComponentBuilder(new FileBrowserTreeComponentWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.FileBrowserTreeComponent> = this.getComponentBuilder(new FileBrowserTreeComponentWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	dom(): sqlops.ComponentBuilder<sqlops.DomComponent> {
+	dom(): azdata.ComponentBuilder<azdata.DomComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.DomComponent> = this.getComponentBuilder(new DomComponentWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.DomComponent> = this.getComponentBuilder(new DomComponentWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	hyperlink(): sqlops.ComponentBuilder<sqlops.HyperlinkComponent> {
+	hyperlink(): azdata.ComponentBuilder<azdata.HyperlinkComponent> {
 		let id = this.getNextComponentId();
-		let builder: ComponentBuilderImpl<sqlops.HyperlinkComponent> = this.getComponentBuilder(new HyperlinkComponentWrapper(this._proxy, this._handle, id), id);
+		let builder: ComponentBuilderImpl<azdata.HyperlinkComponent> = this.getComponentBuilder(new HyperlinkComponentWrapper(this._proxy, this._handle, id), id);
 		this._componentBuilders.set(id, builder);
 		return builder;
 	}
 
-	getComponentBuilder<T extends sqlops.Component>(component: ComponentWrapper, id: string): ComponentBuilderImpl<T> {
+	getComponentBuilder<T extends azdata.Component>(component: ComponentWrapper, id: string): ComponentBuilderImpl<T> {
 		let componentBuilder: ComponentBuilderImpl<T> = new ComponentBuilderImpl<T>(component);
 		this._componentBuilders.set(id, componentBuilder);
 		return componentBuilder;
@@ -233,7 +233,7 @@ interface IWithEventHandler {
 	handleEvent(eventArgs: IComponentEventArgs): void;
 }
 
-class ComponentBuilderImpl<T extends sqlops.Component> implements sqlops.ComponentBuilder<T>, IWithEventHandler {
+class ComponentBuilderImpl<T extends azdata.Component> implements azdata.ComponentBuilder<T>, IWithEventHandler {
 
 	constructor(protected _component: ComponentWrapper) {
 		_component.registerEvent();
@@ -247,13 +247,13 @@ class ComponentBuilderImpl<T extends sqlops.Component> implements sqlops.Compone
 		return this._component;
 	}
 
-	withProperties<U>(properties: U): sqlops.ComponentBuilder<T> {
+	withProperties<U>(properties: U): azdata.ComponentBuilder<T> {
 		// Keep any properties that may have been set during initial object construction
 		this._component.properties = Object.assign({}, this._component.properties, properties);
 		return this;
 	}
 
-	withValidation(validation: (component: T) => boolean): sqlops.ComponentBuilder<T> {
+	withValidation(validation: (component: T) => boolean): azdata.ComponentBuilder<T> {
 		this._component.customValidations.push(validation);
 		return this;
 	}
@@ -263,17 +263,17 @@ class ComponentBuilderImpl<T extends sqlops.Component> implements sqlops.Compone
 	}
 }
 
-class ContainerBuilderImpl<T extends sqlops.Component, TLayout, TItemLayout> extends ComponentBuilderImpl<T> implements sqlops.ContainerBuilder<T, TLayout, TItemLayout> {
+class ContainerBuilderImpl<T extends azdata.Component, TLayout, TItemLayout> extends ComponentBuilderImpl<T> implements azdata.ContainerBuilder<T, TLayout, TItemLayout> {
 	constructor(componentWrapper: ComponentWrapper) {
 		super(componentWrapper);
 	}
 
-	withLayout(layout: TLayout): sqlops.ContainerBuilder<T, TLayout, TItemLayout> {
+	withLayout(layout: TLayout): azdata.ContainerBuilder<T, TLayout, TItemLayout> {
 		this._component.layout = layout;
 		return this;
 	}
 
-	withItems(components: sqlops.Component[], itemLayout?: TItemLayout): sqlops.ContainerBuilder<T, TLayout, TItemLayout> {
+	withItems(components: azdata.Component[], itemLayout?: TItemLayout): azdata.ContainerBuilder<T, TLayout, TItemLayout> {
 		this._component.itemConfigs = components.map(item => {
 			let componentWrapper = item as ComponentWrapper;
 			return new InternalItemConfig(componentWrapper, itemLayout);
@@ -282,29 +282,29 @@ class ContainerBuilderImpl<T extends sqlops.Component, TLayout, TItemLayout> ext
 	}
 }
 
-class GenericContainerBuilder<T extends sqlops.Component, TLayout, TItemLayout> extends ContainerBuilderImpl<T, TLayout, TItemLayout> {
+class GenericContainerBuilder<T extends azdata.Component, TLayout, TItemLayout> extends ContainerBuilderImpl<T, TLayout, TItemLayout> {
 	constructor(proxy: MainThreadModelViewShape, handle: number, type: ModelComponentTypes, id: string) {
 		super(new ComponentWrapper(proxy, handle, type, id));
 	}
 }
 
-class DivContainerBuilder extends ContainerBuilderImpl<sqlops.DivContainer, sqlops.DivLayout, sqlops.DivItemLayout> {
+class DivContainerBuilder extends ContainerBuilderImpl<azdata.DivContainer, azdata.DivLayout, azdata.DivItemLayout> {
 	constructor(proxy: MainThreadModelViewShape, handle: number, type: ModelComponentTypes, id: string) {
 		super(new DivContainerWrapper(proxy, handle, type, id));
 	}
 }
 
-class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer, sqlops.FormLayout, sqlops.FormItemLayout> implements sqlops.FormBuilder {
+class FormContainerBuilder extends GenericContainerBuilder<azdata.FormContainer, azdata.FormLayout, azdata.FormItemLayout> implements azdata.FormBuilder {
 	constructor(proxy: MainThreadModelViewShape, handle: number, type: ModelComponentTypes, id: string, private _builder: ModelBuilderImpl) {
 		super(proxy, handle, type, id);
 	}
 
-	withFormItems(components: (sqlops.FormComponent | sqlops.FormComponentGroup)[], itemLayout?: sqlops.FormItemLayout): sqlops.FormBuilder {
+	withFormItems(components: (azdata.FormComponent | azdata.FormComponentGroup)[], itemLayout?: azdata.FormItemLayout): azdata.FormBuilder {
 		this.addFormItems(components, itemLayout);
 		return this;
 	}
 
-	private convertToItemConfig(formComponent: sqlops.FormComponent, itemLayout?: sqlops.FormItemLayout): InternalItemConfig {
+	private convertToItemConfig(formComponent: azdata.FormComponent, itemLayout?: azdata.FormItemLayout): InternalItemConfig {
 		let componentWrapper = formComponent.component as ComponentWrapper;
 		if (formComponent.required && componentWrapper) {
 			componentWrapper.required = true;
@@ -325,7 +325,7 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 		}));
 	}
 
-	private addComponentActions(formComponent: sqlops.FormComponent, itemLayout?: sqlops.FormItemLayout): void {
+	private addComponentActions(formComponent: azdata.FormComponent, itemLayout?: azdata.FormItemLayout): void {
 		if (formComponent.actions) {
 			formComponent.actions.forEach(component => {
 				let componentWrapper = component as ComponentWrapper;
@@ -334,7 +334,7 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 		}
 	}
 
-	private removeComponentActions(formComponent: sqlops.FormComponent): void {
+	private removeComponentActions(formComponent: azdata.FormComponent): void {
 		if (formComponent.actions) {
 			formComponent.actions.forEach(component => {
 				let componentWrapper = component as ComponentWrapper;
@@ -343,18 +343,18 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 		}
 	}
 
-	addFormItems(formComponents: Array<sqlops.FormComponent | sqlops.FormComponentGroup>, itemLayout?: sqlops.FormItemLayout): void {
+	addFormItems(formComponents: Array<azdata.FormComponent | azdata.FormComponentGroup>, itemLayout?: azdata.FormItemLayout): void {
 		formComponents.forEach(formComponent => {
 			this.addFormItem(formComponent, itemLayout);
 		});
 	}
 
-	addFormItem(formComponent: sqlops.FormComponent | sqlops.FormComponentGroup, itemLayout?: sqlops.FormItemLayout): void {
+	addFormItem(formComponent: azdata.FormComponent | azdata.FormComponentGroup, itemLayout?: azdata.FormItemLayout): void {
 		this.insertFormItem(formComponent, undefined, itemLayout);
 	}
 
-	insertFormItem(formComponent: sqlops.FormComponent | sqlops.FormComponentGroup, index?: number, itemLayout?: sqlops.FormItemLayout): void {
-		let componentGroup = formComponent as sqlops.FormComponentGroup;
+	insertFormItem(formComponent: azdata.FormComponent | azdata.FormComponentGroup, index?: number, itemLayout?: azdata.FormItemLayout): void {
+		let componentGroup = formComponent as azdata.FormComponentGroup;
 		if (componentGroup && componentGroup.components !== undefined) {
 			let labelComponent = this._builder.text().component();
 			labelComponent.value = componentGroup.title;
@@ -371,15 +371,15 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 				this.addComponentActions(component, layout);
 			});
 		} else {
-			formComponent = formComponent as sqlops.FormComponent;
+			formComponent = formComponent as azdata.FormComponent;
 			let itemImpl = this.convertToItemConfig(formComponent, itemLayout);
 			this._component.addItem(formComponent.component as ComponentWrapper, itemImpl.config, index);
 			this.addComponentActions(formComponent, itemLayout);
 		}
 	}
 
-	removeFormItem(formComponent: sqlops.FormComponent | sqlops.FormComponentGroup): boolean {
-		let componentGroup = formComponent as sqlops.FormComponentGroup;
+	removeFormItem(formComponent: azdata.FormComponent | azdata.FormComponentGroup): boolean {
+		let componentGroup = formComponent as azdata.FormComponentGroup;
 		let result: boolean = false;
 		if (componentGroup && componentGroup.components !== undefined) {
 			let firstComponent = componentGroup.components[0];
@@ -392,7 +392,7 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 				this._component.removeItem(element.component);
 			});
 		} else {
-			formComponent = formComponent as sqlops.FormComponent;
+			formComponent = formComponent as azdata.FormComponent;
 			if (formComponent) {
 				result = this._component.removeItem(formComponent.component as ComponentWrapper);
 				this.removeComponentActions(formComponent);
@@ -402,15 +402,15 @@ class FormContainerBuilder extends GenericContainerBuilder<sqlops.FormContainer,
 	}
 }
 
-class ToolbarContainerBuilder extends GenericContainerBuilder<sqlops.ToolbarContainer, sqlops.ToolbarLayout, any> implements sqlops.ToolbarBuilder {
-	withToolbarItems(components: sqlops.ToolbarComponent[]): sqlops.ContainerBuilder<sqlops.ToolbarContainer, any, any> {
+class ToolbarContainerBuilder extends GenericContainerBuilder<azdata.ToolbarContainer, azdata.ToolbarLayout, any> implements azdata.ToolbarBuilder {
+	withToolbarItems(components: azdata.ToolbarComponent[]): azdata.ContainerBuilder<azdata.ToolbarContainer, any, any> {
 		this._component.itemConfigs = components.map(item => {
 			return this.convertToItemConfig(item);
 		});
 		return this;
 	}
 
-	private convertToItemConfig(toolbarComponent: sqlops.ToolbarComponent): InternalItemConfig {
+	private convertToItemConfig(toolbarComponent: azdata.ToolbarComponent): InternalItemConfig {
 		let componentWrapper = toolbarComponent.component as ComponentWrapper;
 
 		return new InternalItemConfig(componentWrapper, {
@@ -418,20 +418,20 @@ class ToolbarContainerBuilder extends GenericContainerBuilder<sqlops.ToolbarCont
 		});
 	}
 
-	addToolbarItems(toolbarComponent: Array<sqlops.ToolbarComponent>): void {
+	addToolbarItems(toolbarComponent: Array<azdata.ToolbarComponent>): void {
 		toolbarComponent.forEach(toolbarComponent => {
 			this.addToolbarItem(toolbarComponent);
 		});
 	}
 
-	addToolbarItem(toolbarComponent: sqlops.ToolbarComponent): void {
+	addToolbarItem(toolbarComponent: azdata.ToolbarComponent): void {
 		let itemImpl = this.convertToItemConfig(toolbarComponent);
 		this._component.addItem(toolbarComponent.component as ComponentWrapper, itemImpl.config);
 	}
 }
 
-class LoadingComponentBuilder extends ComponentBuilderImpl<sqlops.LoadingComponent> implements sqlops.LoadingComponentBuilder {
-	withItem(component: sqlops.Component) {
+class LoadingComponentBuilder extends ComponentBuilderImpl<azdata.LoadingComponent> implements azdata.LoadingComponentBuilder {
+	withItem(component: azdata.Component) {
 		this.component().component = component;
 		return this;
 	}
@@ -447,12 +447,12 @@ class InternalItemConfig {
 		};
 	}
 
-	public get component(): sqlops.Component {
+	public get component(): azdata.Component {
 		return this._component;
 	}
 }
 
-class ComponentWrapper implements sqlops.Component {
+class ComponentWrapper implements azdata.Component {
 	public properties: { [key: string]: any } = {};
 	public layout: any;
 	public itemConfigs: InternalItemConfig[];
@@ -482,7 +482,7 @@ class ComponentWrapper implements sqlops.Component {
 		return this._type;
 	}
 
-	public get items(): sqlops.Component[] {
+	public get items(): azdata.Component[] {
 		return this.itemConfigs.map(itemConfig => itemConfig.component);
 	}
 
@@ -533,7 +533,7 @@ class ComponentWrapper implements sqlops.Component {
 		return this._proxy.$clearContainer(this._handle, this.id);
 	}
 
-	public addItems(items: Array<sqlops.Component>, itemLayout?: any): void {
+	public addItems(items: Array<azdata.Component>, itemLayout?: any): void {
 		for (let item of items) {
 			this.addItem(item, itemLayout);
 		}
@@ -549,7 +549,7 @@ class ComponentWrapper implements sqlops.Component {
 		return false;
 	}
 
-	public removeItem(item: sqlops.Component): boolean {
+	public removeItem(item: azdata.Component): boolean {
 		let index = this.itemConfigs.findIndex(c => c.component.id === item.id);
 		if (index >= 0 && index < this.itemConfigs.length) {
 			return this.removeItemAt(index);
@@ -557,11 +557,11 @@ class ComponentWrapper implements sqlops.Component {
 		return false;
 	}
 
-	public insertItem(item: sqlops.Component, index: number, itemLayout?: any) {
+	public insertItem(item: azdata.Component, index: number, itemLayout?: any) {
 		this.addItem(item, itemLayout, index);
 	}
 
-	public addItem(item: sqlops.Component, itemLayout?: any, index?: number): void {
+	public addItem(item: azdata.Component, itemLayout?: any, index?: number): void {
 		let itemImpl = item as ComponentWrapper;
 		if (!itemImpl) {
 			throw new Error(nls.localize('unknownComponentType', 'Unkown component type. Must use ModelBuilder to create objects'));
@@ -653,7 +653,7 @@ class ComponentWrapper implements sqlops.Component {
 	}
 }
 
-class ContainerWrapper<T, U> extends ComponentWrapper implements sqlops.Container<T, U> {
+class ContainerWrapper<T, U> extends ComponentWrapper implements azdata.Container<T, U> {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, type: ModelComponentTypes, id: string) {
 		super(proxy, handle, type, id);
@@ -661,7 +661,7 @@ class ContainerWrapper<T, U> extends ComponentWrapper implements sqlops.Containe
 
 }
 
-class CardWrapper extends ComponentWrapper implements sqlops.CardComponent {
+class CardWrapper extends ComponentWrapper implements azdata.CardComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Card, id);
@@ -688,16 +688,16 @@ class CardWrapper extends ComponentWrapper implements sqlops.CardComponent {
 	public set selected(v: boolean) {
 		this.setProperty('selected', v);
 	}
-	public get cardType(): sqlops.CardType {
+	public get cardType(): azdata.CardType {
 		return this.properties['cardType'];
 	}
-	public set cardType(v: sqlops.CardType) {
+	public set cardType(v: azdata.CardType) {
 		this.setProperty('cardType', v);
 	}
-	public get actions(): sqlops.ActionDescriptor[] {
+	public get actions(): azdata.ActionDescriptor[] {
 		return this.properties['actions'];
 	}
-	public set actions(a: sqlops.ActionDescriptor[]) {
+	public set actions(a: azdata.ActionDescriptor[]) {
 		this.setProperty('actions', a);
 	}
 	public get iconPath(): string | URI | { light: string | URI; dark: string | URI } {
@@ -720,7 +720,7 @@ class CardWrapper extends ComponentWrapper implements sqlops.CardComponent {
 		this.setProperty('iconWidth', v);
 	}
 
-	public get onDidActionClick(): vscode.Event<sqlops.ActionDescriptor> {
+	public get onDidActionClick(): vscode.Event<azdata.ActionDescriptor> {
 		let emitter = this._emitterMap.get(ComponentEventType.onDidClick);
 		return emitter && emitter.event;
 	}
@@ -731,7 +731,7 @@ class CardWrapper extends ComponentWrapper implements sqlops.CardComponent {
 	}
 }
 
-class InputBoxWrapper extends ComponentWrapper implements sqlops.InputBoxComponent {
+class InputBoxWrapper extends ComponentWrapper implements azdata.InputBoxComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.InputBox, id);
@@ -795,10 +795,10 @@ class InputBoxWrapper extends ComponentWrapper implements sqlops.InputBoxCompone
 		this.setProperty('multiline', v);
 	}
 
-	public get inputType(): sqlops.InputBoxInputType {
+	public get inputType(): azdata.InputBoxInputType {
 		return this.properties['inputType'];
 	}
-	public set inputType(v: sqlops.InputBoxInputType) {
+	public set inputType(v: azdata.InputBoxInputType) {
 		this.setProperty('inputType', v);
 	}
 
@@ -808,7 +808,7 @@ class InputBoxWrapper extends ComponentWrapper implements sqlops.InputBoxCompone
 	}
 }
 
-class CheckBoxWrapper extends ComponentWrapper implements sqlops.CheckBoxComponent {
+class CheckBoxWrapper extends ComponentWrapper implements azdata.CheckBoxComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.CheckBox, id);
@@ -836,7 +836,7 @@ class CheckBoxWrapper extends ComponentWrapper implements sqlops.CheckBoxCompone
 	}
 }
 
-class WebViewWrapper extends ComponentWrapper implements sqlops.WebViewComponent {
+class WebViewWrapper extends ComponentWrapper implements azdata.WebViewComponent {
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string, private _extensionLocation: URI) {
 		super(proxy, handle, ModelComponentTypes.WebView, id);
 		this.properties = {
@@ -872,7 +872,7 @@ class WebViewWrapper extends ComponentWrapper implements sqlops.WebViewComponent
 	}
 }
 
-class DomComponentWrapper extends ComponentWrapper implements sqlops.DomComponent {
+class DomComponentWrapper extends ComponentWrapper implements azdata.DomComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Dom, id);
@@ -887,7 +887,7 @@ class DomComponentWrapper extends ComponentWrapper implements sqlops.DomComponen
 	}
 }
 
-class EditorWrapper extends ComponentWrapper implements sqlops.EditorComponent {
+class EditorWrapper extends ComponentWrapper implements azdata.EditorComponent {
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Editor, id);
 		this.properties = {};
@@ -940,7 +940,7 @@ class EditorWrapper extends ComponentWrapper implements sqlops.EditorComponent {
 	}
 }
 
-class RadioButtonWrapper extends ComponentWrapper implements sqlops.RadioButtonComponent {
+class RadioButtonWrapper extends ComponentWrapper implements azdata.RadioButtonComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.RadioButton, id);
@@ -981,7 +981,7 @@ class RadioButtonWrapper extends ComponentWrapper implements sqlops.RadioButtonC
 	}
 }
 
-class TextComponentWrapper extends ComponentWrapper implements sqlops.TextComponentProperties {
+class TextComponentWrapper extends ComponentWrapper implements azdata.TextComponentProperties {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Text, id);
@@ -996,7 +996,7 @@ class TextComponentWrapper extends ComponentWrapper implements sqlops.TextCompon
 	}
 }
 
-class TableComponentWrapper extends ComponentWrapper implements sqlops.TableComponent {
+class TableComponentWrapper extends ComponentWrapper implements azdata.TableComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Table, id);
@@ -1011,10 +1011,10 @@ class TableComponentWrapper extends ComponentWrapper implements sqlops.TableComp
 		this.setProperty('data', v);
 	}
 
-	public get columns(): string[] | sqlops.TableColumn[] {
+	public get columns(): string[] | azdata.TableColumn[] {
 		return this.properties['columns'];
 	}
-	public set columns(v: string[] | sqlops.TableColumn[]) {
+	public set columns(v: string[] | azdata.TableColumn[]) {
 		this.setProperty('columns', v);
 	}
 
@@ -1039,7 +1039,7 @@ class TableComponentWrapper extends ComponentWrapper implements sqlops.TableComp
 	}
 }
 
-class DropDownWrapper extends ComponentWrapper implements sqlops.DropDownComponent {
+class DropDownWrapper extends ComponentWrapper implements azdata.DropDownComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.DropDown, id);
@@ -1047,21 +1047,21 @@ class DropDownWrapper extends ComponentWrapper implements sqlops.DropDownCompone
 		this._emitterMap.set(ComponentEventType.onDidChange, new Emitter<any>());
 	}
 
-	public get value(): string | sqlops.CategoryValue {
+	public get value(): string | azdata.CategoryValue {
 		let val = this.properties['value'];
 		if (!val && this.values && this.values.length > 0) {
 			val = this.values[0];
 		}
 		return val;
 	}
-	public set value(v: string | sqlops.CategoryValue) {
+	public set value(v: string | azdata.CategoryValue) {
 		this.setProperty('value', v);
 	}
 
-	public get values(): string[] | sqlops.CategoryValue[] {
+	public get values(): string[] | azdata.CategoryValue[] {
 		return this.properties['values'];
 	}
-	public set values(v: string[] | sqlops.CategoryValue[]) {
+	public set values(v: string[] | azdata.CategoryValue[]) {
 		this.setProperty('values', v);
 	}
 
@@ -1078,7 +1078,7 @@ class DropDownWrapper extends ComponentWrapper implements sqlops.DropDownCompone
 	}
 }
 
-class DeclarativeTableWrapper extends ComponentWrapper implements sqlops.DeclarativeTableComponent {
+class DeclarativeTableWrapper extends ComponentWrapper implements azdata.DeclarativeTableComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.DeclarativeTable, id);
@@ -1093,11 +1093,11 @@ class DeclarativeTableWrapper extends ComponentWrapper implements sqlops.Declara
 		this.setProperty('data', v);
 	}
 
-	public get columns(): sqlops.DeclarativeTableColumn[] {
+	public get columns(): azdata.DeclarativeTableColumn[] {
 		return this.properties['columns'];
 	}
 
-	public set columns(v: sqlops.DeclarativeTableColumn[]) {
+	public set columns(v: azdata.DeclarativeTableColumn[]) {
 		this.setProperty('columns', v);
 	}
 
@@ -1107,7 +1107,7 @@ class DeclarativeTableWrapper extends ComponentWrapper implements sqlops.Declara
 	}
 }
 
-class ListBoxWrapper extends ComponentWrapper implements sqlops.ListBoxComponent {
+class ListBoxWrapper extends ComponentWrapper implements azdata.ListBoxComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.ListBox, id);
@@ -1135,7 +1135,7 @@ class ListBoxWrapper extends ComponentWrapper implements sqlops.ListBoxComponent
 	}
 }
 
-class ButtonWrapper extends ComponentWrapper implements sqlops.ButtonComponent {
+class ButtonWrapper extends ComponentWrapper implements azdata.ButtonComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Button, id);
@@ -1170,7 +1170,7 @@ class ButtonWrapper extends ComponentWrapper implements sqlops.ButtonComponent {
 	}
 }
 
-class LoadingComponentWrapper extends ComponentWrapper implements sqlops.LoadingComponent {
+class LoadingComponentWrapper extends ComponentWrapper implements azdata.LoadingComponent {
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.LoadingComponent, id);
 		this.properties = {};
@@ -1185,16 +1185,16 @@ class LoadingComponentWrapper extends ComponentWrapper implements sqlops.Loading
 		this.setProperty('loading', value);
 	}
 
-	public get component(): sqlops.Component {
+	public get component(): azdata.Component {
 		return this.items[0];
 	}
 
-	public set component(value: sqlops.Component) {
+	public set component(value: azdata.Component) {
 		this.addItem(value);
 	}
 }
 
-class FileBrowserTreeComponentWrapper extends ComponentWrapper implements sqlops.FileBrowserTreeComponent {
+class FileBrowserTreeComponentWrapper extends ComponentWrapper implements azdata.FileBrowserTreeComponent {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.FileBrowserTree, id);
@@ -1216,7 +1216,7 @@ class FileBrowserTreeComponentWrapper extends ComponentWrapper implements sqlops
 	}
 }
 
-class DivContainerWrapper extends ComponentWrapper implements sqlops.DivContainer {
+class DivContainerWrapper extends ComponentWrapper implements azdata.DivContainer {
 	public get overflowY(): string {
 		return this.properties['overflowY'];
 	}
@@ -1234,7 +1234,7 @@ class DivContainerWrapper extends ComponentWrapper implements sqlops.DivContaine
 	}
 }
 
-class TreeComponentWrapper<T> extends ComponentWrapper implements sqlops.TreeComponent<T> {
+class TreeComponentWrapper<T> extends ComponentWrapper implements azdata.TreeComponent<T> {
 
 	constructor(
 		private _extHostModelViewTree: ExtHostModelViewTreeViewsShape,
@@ -1243,7 +1243,7 @@ class TreeComponentWrapper<T> extends ComponentWrapper implements sqlops.TreeCom
 		this.properties = {};
 	}
 
-	public registerDataProvider<T>(dataProvider: sqlops.TreeComponentDataProvider<T>): sqlops.TreeComponentView<T> {
+	public registerDataProvider<T>(dataProvider: azdata.TreeComponentDataProvider<T>): azdata.TreeComponentView<T> {
 		this.setDataProvider();
 		return this._extHostModelViewTree.$createTreeView(this._handle, this.id, { treeDataProvider: dataProvider }, this._extension);
 	}
@@ -1256,7 +1256,7 @@ class TreeComponentWrapper<T> extends ComponentWrapper implements sqlops.TreeCom
 	}
 }
 
-class HyperlinkComponentWrapper extends ComponentWrapper implements sqlops.HyperlinkComponentProperties {
+class HyperlinkComponentWrapper extends ComponentWrapper implements azdata.HyperlinkComponentProperties {
 
 	constructor(proxy: MainThreadModelViewShape, handle: number, id: string) {
 		super(proxy, handle, ModelComponentTypes.Hyperlink, id);
@@ -1278,20 +1278,20 @@ class HyperlinkComponentWrapper extends ComponentWrapper implements sqlops.Hyper
 	}
 }
 
-class ModelViewImpl implements sqlops.ModelView {
+class ModelViewImpl implements azdata.ModelView {
 
 	public onClosedEmitter = new Emitter<any>();
 	private _onValidityChangedEmitter = new Emitter<boolean>();
 	public readonly onValidityChanged = this._onValidityChangedEmitter.event;
 
 	private _modelBuilder: ModelBuilderImpl;
-	private _component: sqlops.Component;
+	private _component: azdata.Component;
 
 	constructor(
 		private readonly _proxy: MainThreadModelViewShape,
 		private readonly _handle: number,
-		private readonly _connection: sqlops.connection.Connection,
-		private readonly _serverInfo: sqlops.ServerInfo,
+		private readonly _connection: azdata.connection.Connection,
+		private readonly _serverInfo: azdata.ServerInfo,
 		private readonly mainContext: IMainContext,
 		private readonly _extHostModelViewTree: ExtHostModelViewTreeViewsShape,
 		_extension: IExtensionDescription
@@ -1303,15 +1303,15 @@ class ModelViewImpl implements sqlops.ModelView {
 		return this.onClosedEmitter.event;
 	}
 
-	public get connection(): sqlops.connection.Connection {
+	public get connection(): azdata.connection.Connection {
 		return deepClone(this._connection);
 	}
 
-	public get serverInfo(): sqlops.ServerInfo {
+	public get serverInfo(): azdata.ServerInfo {
 		return deepClone(this._serverInfo);
 	}
 
-	public get modelBuilder(): sqlops.ModelBuilder {
+	public get modelBuilder(): azdata.ModelBuilder {
 		return this._modelBuilder;
 	}
 
@@ -1323,7 +1323,7 @@ class ModelViewImpl implements sqlops.ModelView {
 		this._modelBuilder.handleEvent(componentId, eventArgs);
 	}
 
-	public initializeModel<T extends sqlops.Component>(component: T): Thenable<void> {
+	public initializeModel<T extends azdata.Component>(component: T): Thenable<void> {
 		component.onValidityChanged(valid => this._onValidityChangedEmitter.fire(valid));
 		this._component = component;
 		let componentImpl = <any>component as ComponentWrapper;
@@ -1346,7 +1346,7 @@ export class ExtHostModelView implements ExtHostModelViewShape {
 	private readonly _proxy: MainThreadModelViewShape;
 
 	private readonly _modelViews = new Map<number, ModelViewImpl>();
-	private readonly _handlers = new Map<string, (view: sqlops.ModelView) => void>();
+	private readonly _handlers = new Map<string, (view: azdata.ModelView) => void>();
 	private readonly _handlerToExtension = new Map<string, IExtensionDescription>();
 	constructor(
 		private _mainContext: IMainContext,
@@ -1361,13 +1361,13 @@ export class ExtHostModelView implements ExtHostModelViewShape {
 		this._modelViews.delete(handle);
 	}
 
-	$registerProvider(widgetId: string, handler: (webview: sqlops.ModelView) => void, extension: IExtensionDescription): void {
+	$registerProvider(widgetId: string, handler: (webview: azdata.ModelView) => void, extension: IExtensionDescription): void {
 		this._handlers.set(widgetId, handler);
 		this._handlerToExtension.set(widgetId, extension);
 		this._proxy.$registerProvider(widgetId);
 	}
 
-	$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void {
+	$registerWidget(handle: number, id: string, connection: azdata.connection.Connection, serverInfo: azdata.ServerInfo): void {
 		let extension = this._handlerToExtension.get(id);
 		let view = new ModelViewImpl(this._proxy, handle, connection, serverInfo, this._mainContext, this._extHostModelViewTree, extension);
 		this._modelViews.set(handle, view);

src/sql/workbench/api/node/extHostModelViewDialog.ts

@@ -12,7 +12,7 @@ import { generateUuid } from 'vs/base/common/uuid';
 import { URI } from 'vs/base/common/uri';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { SqlMainContext, ExtHostModelViewDialogShape, MainThreadModelViewDialogShape, ExtHostModelViewShape, ExtHostBackgroundTaskManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { IItemConfig, ModelComponentTypes, IComponentShape } from 'sql/workbench/api/common/sqlExtHostTypes';
@@ -26,8 +26,8 @@ const GENERATE_SCRIPT_LABEL = nls.localize('generateScriptLabel', 'Generate scri
 const NEXT_LABEL = nls.localize('dialogNextLabel', 'Next');
 const PREVIOUS_LABEL = nls.localize('dialogPreviousLabel', 'Previous');
 
-class ModelViewPanelImpl implements sqlops.window.ModelViewPanel {
-	private _modelView: sqlops.ModelView;
+class ModelViewPanelImpl implements azdata.window.ModelViewPanel {
+	private _modelView: azdata.ModelView;
 	private _handle: number;
 	protected _modelViewId: string;
 	protected _valid: boolean = true;
@@ -41,7 +41,7 @@ class ModelViewPanelImpl implements sqlops.window.ModelViewPanel {
 		this._onValidityChanged(valid => this._valid = valid);
 	}
 
-	public registerContent(handler: (view: sqlops.ModelView) => Thenable<void>): void {
+	public registerContent(handler: (view: azdata.ModelView) => Thenable<void>): void {
 		if (!this._modelViewId) {
 			let viewId = this._viewType + this._handle;
 			this.setModelViewId(viewId);
@@ -60,11 +60,11 @@ class ModelViewPanelImpl implements sqlops.window.ModelViewPanel {
 		this._modelViewId = value;
 	}
 
-	public get modelView(): sqlops.ModelView {
+	public get modelView(): azdata.ModelView {
 		return this._modelView;
 	}
 
-	public set modelView(value: sqlops.ModelView) {
+	public set modelView(value: azdata.ModelView) {
 		this._modelView = value;
 	}
 
@@ -77,7 +77,7 @@ class ModelViewPanelImpl implements sqlops.window.ModelViewPanel {
 	}
 }
 
-class ModelViewEditorImpl extends ModelViewPanelImpl implements sqlops.workspace.ModelViewEditor {
+class ModelViewEditorImpl extends ModelViewPanelImpl implements azdata.workspace.ModelViewEditor {
 	private _isDirty: boolean;
 	private _saveHandler: () => Thenable<boolean>;
 
@@ -87,7 +87,7 @@ class ModelViewEditorImpl extends ModelViewPanelImpl implements sqlops.workspace
 		extension: IExtensionDescription,
 		private _proxy: MainThreadModelViewDialogShape,
 		private _title: string,
-		private _options: sqlops.ModelViewEditorOptions
+		private _options: azdata.ModelViewEditorOptions
 	) {
 		super('modelViewEditor', extHostModelViewDialog, extHostModelView, extension);
 		this._isDirty = false;
@@ -119,13 +119,13 @@ class ModelViewEditorImpl extends ModelViewPanelImpl implements sqlops.workspace
 	}
 }
 
-class DialogImpl extends ModelViewPanelImpl implements sqlops.window.Dialog {
+class DialogImpl extends ModelViewPanelImpl implements azdata.window.Dialog {
 	public title: string;
-	public content: string | sqlops.window.DialogTab[];
-	public okButton: sqlops.window.Button;
-	public cancelButton: sqlops.window.Button;
-	public customButtons: sqlops.window.Button[];
-	private _message: sqlops.window.DialogMessage;
+	public content: string | azdata.window.DialogTab[];
+	public okButton: azdata.window.Button;
+	public cancelButton: azdata.window.Button;
+	public customButtons: azdata.window.Button[];
+	private _message: azdata.window.DialogMessage;
 	private _closeValidator: () => boolean | Thenable<boolean>;
 	private _operationHandler: BackgroundOperationHandler;
 	private _dialogName: string;
@@ -143,7 +143,7 @@ class DialogImpl extends ModelViewPanelImpl implements sqlops.window.Dialog {
 		});
 	}
 
-	public registerOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
+	public registerOperation(operationInfo: azdata.BackgroundOperationInfo): void {
 		this._operationHandler.registerOperation(operationInfo);
 	}
 
@@ -152,11 +152,11 @@ class DialogImpl extends ModelViewPanelImpl implements sqlops.window.Dialog {
 		this.content = value;
 	}
 
-	public get message(): sqlops.window.DialogMessage {
+	public get message(): azdata.window.DialogMessage {
 		return this._message;
 	}
 
-	public set message(value: sqlops.window.DialogMessage) {
+	public set message(value: azdata.window.DialogMessage) {
 		this._message = value;
 		this._extHostModelViewDialog.updateDialogContent(this);
 	}
@@ -182,7 +182,7 @@ class DialogImpl extends ModelViewPanelImpl implements sqlops.window.Dialog {
 	}
 }
 
-class TabImpl extends ModelViewPanelImpl implements sqlops.window.DialogTab {
+class TabImpl extends ModelViewPanelImpl implements azdata.window.DialogTab {
 	constructor(
 		extHostModelViewDialog: ExtHostModelViewDialog,
 		extHostModelView: ExtHostModelViewShape,
@@ -200,7 +200,7 @@ class TabImpl extends ModelViewPanelImpl implements sqlops.window.DialogTab {
 	}
 }
 
-class ButtonImpl implements sqlops.window.Button {
+class ButtonImpl implements azdata.window.Button {
 	private _label: string;
 	private _enabled: boolean;
 	private _hidden: boolean;
@@ -247,7 +247,7 @@ class ButtonImpl implements sqlops.window.Button {
 
 class BackgroundOperationHandler {
 
-	private _operationInfo: sqlops.BackgroundOperationInfo;
+	private _operationInfo: azdata.BackgroundOperationInfo;
 
 	constructor(
 		private _name: string,
@@ -269,13 +269,13 @@ class BackgroundOperationHandler {
 		}
 	}
 
-	public registerOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
+	public registerOperation(operationInfo: azdata.BackgroundOperationInfo): void {
 		this._operationInfo = operationInfo;
 	}
 }
 
-class WizardPageImpl extends ModelViewPanelImpl implements sqlops.window.WizardPage {
-	public customButtons: sqlops.window.Button[];
+class WizardPageImpl extends ModelViewPanelImpl implements azdata.window.WizardPage {
+	public customButtons: azdata.window.Button[];
 	private _enabled: boolean = true;
 	private _description: string;
 
@@ -320,23 +320,23 @@ export enum WizardPageInfoEventType {
 
 export interface WizardPageEventInfo {
 	eventType: WizardPageInfoEventType;
-	pageChangeInfo: sqlops.window.WizardPageChangeInfo;
-	pages?: sqlops.window.WizardPage[];
+	pageChangeInfo: azdata.window.WizardPageChangeInfo;
+	pages?: azdata.window.WizardPage[];
 }
 
-class WizardImpl implements sqlops.window.Wizard {
+class WizardImpl implements azdata.window.Wizard {
 	private _currentPage: number = undefined;
-	public pages: sqlops.window.WizardPage[] = [];
-	public doneButton: sqlops.window.Button;
-	public cancelButton: sqlops.window.Button;
-	public generateScriptButton: sqlops.window.Button;
-	public nextButton: sqlops.window.Button;
-	public backButton: sqlops.window.Button;
-	public customButtons: sqlops.window.Button[];
-	private _pageChangedEmitter = new Emitter<sqlops.window.WizardPageChangeInfo>();
+	public pages: azdata.window.WizardPage[] = [];
+	public doneButton: azdata.window.Button;
+	public cancelButton: azdata.window.Button;
+	public generateScriptButton: azdata.window.Button;
+	public nextButton: azdata.window.Button;
+	public backButton: azdata.window.Button;
+	public customButtons: azdata.window.Button[];
+	private _pageChangedEmitter = new Emitter<azdata.window.WizardPageChangeInfo>();
 	public readonly onPageChanged = this._pageChangedEmitter.event;
-	private _navigationValidator: (info: sqlops.window.WizardPageChangeInfo) => boolean | Thenable<boolean>;
-	private _message: sqlops.window.DialogMessage;
+	private _navigationValidator: (info: azdata.window.WizardPageChangeInfo) => boolean | Thenable<boolean>;
+	private _message: azdata.window.DialogMessage;
 	private _displayPageTitles: boolean = true;
 	private _operationHandler: BackgroundOperationHandler;
 
@@ -355,7 +355,7 @@ class WizardImpl implements sqlops.window.Wizard {
 		});
 	}
 
-	public registerOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
+	public registerOperation(operationInfo: azdata.BackgroundOperationInfo): void {
 		this._operationHandler.registerOperation(operationInfo);
 	}
 
@@ -363,11 +363,11 @@ class WizardImpl implements sqlops.window.Wizard {
 		return this._currentPage;
 	}
 
-	public get message(): sqlops.window.DialogMessage {
+	public get message(): azdata.window.DialogMessage {
 		return this._message;
 	}
 
-	public set message(value: sqlops.window.DialogMessage) {
+	public set message(value: azdata.window.DialogMessage) {
 		this._message = value;
 		this._extHostModelViewDialog.updateWizard(this);
 	}
@@ -381,7 +381,7 @@ class WizardImpl implements sqlops.window.Wizard {
 		this._extHostModelViewDialog.updateWizard(this);
 	}
 
-	public addPage(page: sqlops.window.WizardPage, index?: number): Thenable<void> {
+	public addPage(page: azdata.window.WizardPage, index?: number): Thenable<void> {
 		return this._extHostModelViewDialog.updateWizardPage(page).then(() => {
 			this._extHostModelViewDialog.addPage(this, page, index);
 		});
@@ -403,11 +403,11 @@ class WizardImpl implements sqlops.window.Wizard {
 		return this._extHostModelViewDialog.closeWizard(this);
 	}
 
-	public registerNavigationValidator(validator: (pageChangeInfo: sqlops.window.WizardPageChangeInfo) => boolean | Thenable<boolean>): void {
+	public registerNavigationValidator(validator: (pageChangeInfo: azdata.window.WizardPageChangeInfo) => boolean | Thenable<boolean>): void {
 		this._navigationValidator = validator;
 	}
 
-	public validateNavigation(info: sqlops.window.WizardPageChangeInfo): Thenable<boolean> {
+	public validateNavigation(info: azdata.window.WizardPageChangeInfo): Thenable<boolean> {
 		if (this._navigationValidator) {
 			return Promise.resolve(this._navigationValidator(info));
 		} else {
@@ -450,8 +450,8 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		return handle;
 	}
 
-	private getHandle(item: sqlops.window.Button | sqlops.window.Dialog | sqlops.window.DialogTab
-		| sqlops.window.ModelViewPanel | sqlops.window.Wizard | sqlops.window.WizardPage | sqlops.workspace.ModelViewEditor) {
+	private getHandle(item: azdata.window.Button | azdata.window.Dialog | azdata.window.DialogTab
+		| azdata.window.ModelViewPanel | azdata.window.Wizard | azdata.window.WizardPage | azdata.workspace.ModelViewEditor) {
 		let handle = this._objectHandles.get(item);
 		if (handle === undefined) {
 			handle = ExtHostModelViewDialog.getNewHandle();
@@ -472,7 +472,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		}
 	}
 
-	public $onWizardPageChanged(handle: number, info: sqlops.window.WizardPageChangeInfo): void {
+	public $onWizardPageChanged(handle: number, info: azdata.window.WizardPageChangeInfo): void {
 		let callback = this._pageInfoChangedCallbacks.get(handle);
 		if (callback) {
 			callback({
@@ -485,7 +485,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 	public $updateWizardPageInfo(handle: number, pageHandles: number[], currentPageIndex: number): void {
 		let callback = this._pageInfoChangedCallbacks.get(handle);
 		if (callback) {
-			let pages = pageHandles.map(pageHandle => this._objectsByHandle.get(handle) as sqlops.window.WizardPage);
+			let pages = pageHandles.map(pageHandle => this._objectsByHandle.get(handle) as azdata.window.WizardPage);
 			callback({
 				eventType: WizardPageInfoEventType.PageAddedOrRemoved,
 				pageChangeInfo: {
@@ -497,7 +497,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		}
 	}
 
-	public $validateNavigation(handle: number, info: sqlops.window.WizardPageChangeInfo): Thenable<boolean> {
+	public $validateNavigation(handle: number, info: azdata.window.WizardPageChangeInfo): Thenable<boolean> {
 		let wizard = this._objectsByHandle.get(handle) as WizardImpl;
 		return wizard.validateNavigation(info);
 	}
@@ -512,25 +512,25 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		return editor.handleSave();
 	}
 
-	public openDialog(dialog: sqlops.window.Dialog): void {
+	public openDialog(dialog: azdata.window.Dialog): void {
 		let handle = this.getHandle(dialog);
 		this.updateDialogContent(dialog);
 		dialog.dialogName ? this._proxy.$openDialog(handle, dialog.dialogName) :
 			this._proxy.$openDialog(handle);
 	}
 
-	public closeDialog(dialog: sqlops.window.Dialog): void {
+	public closeDialog(dialog: azdata.window.Dialog): void {
 		let handle = this.getHandle(dialog);
 		this._proxy.$closeDialog(handle);
 	}
 
-	public createModelViewEditor(title: string, extension: IExtensionDescription, options?: sqlops.ModelViewEditorOptions): sqlops.workspace.ModelViewEditor {
+	public createModelViewEditor(title: string, extension: IExtensionDescription, options?: azdata.ModelViewEditorOptions): azdata.workspace.ModelViewEditor {
 		let editor = new ModelViewEditorImpl(this, this._extHostModelView, extension, this._proxy, title, options);
 		editor.handle = this.getHandle(editor);
 		return editor;
 	}
 
-	public updateDialogContent(dialog: sqlops.window.Dialog): void {
+	public updateDialogContent(dialog: azdata.window.Dialog): void {
 		let handle = this.getHandle(dialog);
 		let tabs = dialog.content;
 		if (tabs && typeof tabs !== 'string') {
@@ -551,7 +551,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		});
 	}
 
-	public updateTabContent(tab: sqlops.window.DialogTab): void {
+	public updateTabContent(tab: azdata.window.DialogTab): void {
 		let handle = this.getHandle(tab);
 		this._proxy.$setTabDetails(handle, {
 			title: tab.title,
@@ -559,7 +559,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		});
 	}
 
-	public updateButton(button: sqlops.window.Button): void {
+	public updateButton(button: azdata.window.Button): void {
 		let handle = this.getHandle(button);
 		this._proxy.$setButtonDetails(handle, {
 			label: button.label,
@@ -568,12 +568,12 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		});
 	}
 
-	public registerOnClickCallback(button: sqlops.window.Button, callback: () => void) {
+	public registerOnClickCallback(button: azdata.window.Button, callback: () => void) {
 		let handle = this.getHandle(button);
 		this._onClickCallbacks.set(handle, callback);
 	}
 
-	public createDialog(title: string, dialogName?: string, extension?: IExtensionDescription): sqlops.window.Dialog {
+	public createDialog(title: string, dialogName?: string, extension?: IExtensionDescription): azdata.window.Dialog {
 		let dialog = new DialogImpl(this, this._extHostModelView, this._extHostTaskManagement, extension);
 		if (dialogName) {
 			dialog.dialogName = dialogName;
@@ -583,14 +583,14 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		return dialog;
 	}
 
-	public createTab(title: string, extension?: IExtensionDescription): sqlops.window.DialogTab {
+	public createTab(title: string, extension?: IExtensionDescription): azdata.window.DialogTab {
 		let tab = new TabImpl(this, this._extHostModelView, extension);
 		tab.title = title;
 		tab.handle = this.getHandle(tab);
 		return tab;
 	}
 
-	public createButton(label: string): sqlops.window.Button {
+	public createButton(label: string): azdata.window.Button {
 		let button = new ButtonImpl(this);
 		this.getHandle(button);
 		this.registerOnClickCallback(button, button.getOnClickCallback());
@@ -598,7 +598,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		return button;
 	}
 
-	public getValidityChangedEvent(panel: sqlops.window.ModelViewPanel) {
+	public getValidityChangedEvent(panel: azdata.window.ModelViewPanel) {
 		let handle = this.getHandle(panel);
 		let emitter = this._validityEmitters.get(handle);
 		if (!emitter) {
@@ -608,24 +608,24 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		return emitter.event;
 	}
 
-	public registerWizardPageInfoChangedCallback(wizard: sqlops.window.Wizard, callback: (info: WizardPageEventInfo) => void): void {
+	public registerWizardPageInfoChangedCallback(wizard: azdata.window.Wizard, callback: (info: WizardPageEventInfo) => void): void {
 		let handle = this.getHandle(wizard);
 		this._pageInfoChangedCallbacks.set(handle, callback);
 	}
 
-	public createWizardPage(title: string, extension?: IExtensionDescription): sqlops.window.WizardPage {
+	public createWizardPage(title: string, extension?: IExtensionDescription): azdata.window.WizardPage {
 		let page = new WizardPageImpl(title, this, this._extHostModelView, extension);
 		page.handle = this.getHandle(page);
 		return page;
 	}
 
-	public createWizard(title: string): sqlops.window.Wizard {
+	public createWizard(title: string): azdata.window.Wizard {
 		let wizard = new WizardImpl(title, this, this._extHostTaskManagement);
 		this.getHandle(wizard);
 		return wizard;
 	}
 
-	public updateWizardPage(page: sqlops.window.WizardPage): Thenable<void> {
+	public updateWizardPage(page: azdata.window.WizardPage): Thenable<void> {
 		let handle = this.getHandle(page);
 		if (page.customButtons) {
 			page.customButtons.forEach(button => this.updateButton(button));
@@ -639,7 +639,7 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		});
 	}
 
-	public updateWizard(wizard: sqlops.window.Wizard): Thenable<void> {
+	public updateWizard(wizard: azdata.window.Wizard): Thenable<void> {
 		let handle = this.getHandle(wizard);
 		wizard.pages.forEach(page => this.updateWizardPage(page));
 		this.updateButton(wizard.backButton);
@@ -665,25 +665,25 @@ export class ExtHostModelViewDialog implements ExtHostModelViewDialogShape {
 		});
 	}
 
-	public addPage(wizard: sqlops.window.Wizard, page: sqlops.window.WizardPage, pageIndex?: number): Thenable<void> {
+	public addPage(wizard: azdata.window.Wizard, page: azdata.window.WizardPage, pageIndex?: number): Thenable<void> {
 		return this._proxy.$addWizardPage(this.getHandle(wizard), this.getHandle(page), pageIndex);
 	}
 
-	public removePage(wizard: sqlops.window.Wizard, pageIndex: number): Thenable<void> {
+	public removePage(wizard: azdata.window.Wizard, pageIndex: number): Thenable<void> {
 		return this._proxy.$removeWizardPage(this.getHandle(wizard), pageIndex);
 	}
 
-	public setWizardPage(wizard: sqlops.window.Wizard, pageIndex: number): Thenable<void> {
+	public setWizardPage(wizard: azdata.window.Wizard, pageIndex: number): Thenable<void> {
 		return this._proxy.$setWizardPage(this.getHandle(wizard), pageIndex);
 	}
 
-	public openWizard(wizard: sqlops.window.Wizard): Thenable<void> {
+	public openWizard(wizard: azdata.window.Wizard): Thenable<void> {
 		let handle = this.getHandle(wizard);
 		this.updateWizard(wizard);
 		return this._proxy.$openWizard(handle);
 	}
 
-	public closeWizard(wizard: sqlops.window.Wizard): Thenable<void> {
+	public closeWizard(wizard: azdata.window.Wizard): Thenable<void> {
 		let handle = this.getHandle(wizard);
 		return this._proxy.$closeWizard(handle);
 	}

src/sql/workbench/api/node/extHostModelViewTree.ts

@@ -11,7 +11,7 @@ import { SqlMainContext, ExtHostModelViewTreeViewsShape, MainThreadModelViewShap
 import { ITreeComponentItem } from 'sql/workbench/common/views';
 import { CommandsConverter } from 'vs/workbench/api/node/extHostCommands';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as  vsTreeExt from 'vs/workbench/api/node/extHostTreeViews';
 import { Emitter } from 'vs/base/common/event';
 import { IExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
@@ -27,7 +27,7 @@ export class ExtHostModelViewTreeViews implements ExtHostModelViewTreeViewsShape
 		this._proxy = this._mainContext.getProxy(SqlMainContext.MainThreadModelView);
 	}
 
-	$createTreeView<T>(handle: number, componentId: string, options: { treeDataProvider: sqlops.TreeComponentDataProvider<T> }, extension: IExtensionDescription): sqlops.TreeComponentView<T> {
+	$createTreeView<T>(handle: number, componentId: string, options: { treeDataProvider: azdata.TreeComponentDataProvider<T> }, extension: IExtensionDescription): azdata.TreeComponentView<T> {
 		if (!options || !options.treeDataProvider) {
 			throw new Error('Options with treeDataProvider is mandatory');
 		}
@@ -75,7 +75,7 @@ export class ExtHostModelViewTreeViews implements ExtHostModelViewTreeViewsShape
 	$setVisible(treeViewId: string, visible: boolean): void {
 	}
 
-	private createExtHostTreeViewer<T>(handle: number, id: string, dataProvider: sqlops.TreeComponentDataProvider<T>, extension: IExtensionDescription): ExtHostTreeView<T> {
+	private createExtHostTreeViewer<T>(handle: number, id: string, dataProvider: azdata.TreeComponentDataProvider<T>, extension: IExtensionDescription): ExtHostTreeView<T> {
 		const treeView = new ExtHostTreeView<T>(handle, id, dataProvider, this._proxy, undefined, extension);
 		this.treeViews.set(`${handle}-${id}`, treeView);
 		return treeView;
@@ -84,12 +84,12 @@ export class ExtHostModelViewTreeViews implements ExtHostModelViewTreeViewsShape
 
 export class ExtHostTreeView<T> extends vsTreeExt.ExtHostTreeView<T> {
 
-	private _onNodeCheckedChanged = new Emitter<sqlops.NodeCheckedEventParameters<T>>();
+	private _onNodeCheckedChanged = new Emitter<azdata.NodeCheckedEventParameters<T>>();
 	private _onChangeSelection = new Emitter<vscode.TreeViewSelectionChangeEvent<T>>();
-	public readonly NodeCheckedChanged: vscode.Event<sqlops.NodeCheckedEventParameters<T>> = this._onNodeCheckedChanged.event;
+	public readonly NodeCheckedChanged: vscode.Event<azdata.NodeCheckedEventParameters<T>> = this._onNodeCheckedChanged.event;
 	public readonly ChangeSelection: vscode.Event<vscode.TreeViewSelectionChangeEvent<T>> = this._onChangeSelection.event;
 	constructor(
-		private handle: number, private componentId: string, private componentDataProvider: sqlops.TreeComponentDataProvider<T>,
+		private handle: number, private componentId: string, private componentDataProvider: azdata.TreeComponentDataProvider<T>,
 		private modelViewProxy: MainThreadModelViewShape, commands: CommandsConverter, extension: IExtensionDescription) {
 		super(componentId, { treeDataProvider: componentDataProvider }, undefined, commands, undefined, extension);
 	}
@@ -162,7 +162,7 @@ export class ExtHostTreeView<T> extends vsTreeExt.ExtHostTreeView<T> {
 			});
 	}
 
-	protected createTreeItem(element: T, extensionTreeItem: sqlops.TreeComponentItem, parent?: vsTreeExt.TreeNode): ITreeComponentItem {
+	protected createTreeItem(element: T, extensionTreeItem: azdata.TreeComponentItem, parent?: vsTreeExt.TreeNode): ITreeComponentItem {
 		let item = super.createTreeItem(element, extensionTreeItem, parent);
 		item = Object.assign({}, item, { checked: extensionTreeItem.checked, enabled: extensionTreeItem.enabled });
 		return item;

src/sql/workbench/api/node/extHostNotebook.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 import { TPromise } from 'vs/base/common/winjs.base';
@@ -16,7 +16,7 @@ import { URI, UriComponents } from 'vs/base/common/uri';
 import { ExtHostNotebookShape, MainThreadNotebookShape, SqlMainContext } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { INotebookManagerDetails, INotebookSessionDetails, INotebookKernelDetails, INotebookFutureDetails, FutureMessageType } from 'sql/workbench/api/common/sqlExtHostTypes';
 
-type Adapter = sqlops.nb.NotebookProvider | sqlops.nb.NotebookManager | sqlops.nb.ISession | sqlops.nb.IKernel | sqlops.nb.IFuture;
+type Adapter = azdata.nb.NotebookProvider | azdata.nb.NotebookManager | azdata.nb.ISession | azdata.nb.IKernel | azdata.nb.IFuture;
 
 export class ExtHostNotebook implements ExtHostNotebookShape {
 	private static _handlePool: number = 0;
@@ -64,22 +64,22 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		return this._withServerManager(managerHandle, (serverManager) => serverManager.stopServer());
 	}
 
-	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<sqlops.nb.INotebookContents> {
+	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<azdata.nb.INotebookContents> {
 		return this._withContentManager(managerHandle, (contentManager) => contentManager.getNotebookContents(URI.revive(notebookUri)));
 	}
 
-	$save(managerHandle: number, notebookUri: UriComponents, notebook: sqlops.nb.INotebookContents): Thenable<sqlops.nb.INotebookContents> {
+	$save(managerHandle: number, notebookUri: UriComponents, notebook: azdata.nb.INotebookContents): Thenable<azdata.nb.INotebookContents> {
 		return this._withContentManager(managerHandle, (contentManager) => contentManager.save(URI.revive(notebookUri), notebook));
 	}
 
-	$refreshSpecs(managerHandle: number): Thenable<sqlops.nb.IAllKernels> {
+	$refreshSpecs(managerHandle: number): Thenable<azdata.nb.IAllKernels> {
 		return this._withSessionManager(managerHandle, async (sessionManager) => {
 			await sessionManager.ready;
 			return sessionManager.specs;
 		});
 	}
 
-	$startNewSession(managerHandle: number, options: sqlops.nb.ISessionOptions): Thenable<INotebookSessionDetails> {
+	$startNewSession(managerHandle: number, options: azdata.nb.ISessionOptions): Thenable<INotebookSessionDetails> {
 		return this._withSessionManager(managerHandle, async (sessionManager) => {
 			let session = await sessionManager.startNew(options);
 			let sessionId = this._addNewAdapter(session);
@@ -101,7 +101,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	private saveKernel(kernel: sqlops.nb.IKernel): INotebookKernelDetails {
+	private saveKernel(kernel: azdata.nb.IKernel): INotebookKernelDetails {
 		let kernelId = this._addNewAdapter(kernel);
 		let kernelDetails: INotebookKernelDetails = {
 			kernelId: kernelId,
@@ -119,38 +119,38 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	$changeKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<INotebookKernelDetails> {
-		let session = this._getAdapter<sqlops.nb.ISession>(sessionId);
+	$changeKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<INotebookKernelDetails> {
+		let session = this._getAdapter<azdata.nb.ISession>(sessionId);
 		return session.changeKernel(kernelInfo).then(kernel => this.saveKernel(kernel));
 	}
 
-	$configureKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<void> {
-		let session = this._getAdapter<sqlops.nb.ISession>(sessionId);
+	$configureKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<void> {
+		let session = this._getAdapter<azdata.nb.ISession>(sessionId);
 		return session.configureKernel(kernelInfo).then(() => null);
 	}
 
-	$configureConnection(sessionId: number, connection: sqlops.IConnectionProfile): Thenable<void> {
-		let session = this._getAdapter<sqlops.nb.ISession>(sessionId);
+	$configureConnection(sessionId: number, connection: azdata.IConnectionProfile): Thenable<void> {
+		let session = this._getAdapter<azdata.nb.ISession>(sessionId);
 		return session.configureConnection(connection).then(() => null);
 	}
 
-	$getKernelReadyStatus(kernelId: number): Thenable<sqlops.nb.IInfoReply> {
-		let kernel = this._getAdapter<sqlops.nb.IKernel>(kernelId);
+	$getKernelReadyStatus(kernelId: number): Thenable<azdata.nb.IInfoReply> {
+		let kernel = this._getAdapter<azdata.nb.IKernel>(kernelId);
 		return kernel.ready.then(success => kernel.info);
 	}
 
-	$getKernelSpec(kernelId: number): Thenable<sqlops.nb.IKernelSpec> {
-		let kernel = this._getAdapter<sqlops.nb.IKernel>(kernelId);
+	$getKernelSpec(kernelId: number): Thenable<azdata.nb.IKernelSpec> {
+		let kernel = this._getAdapter<azdata.nb.IKernel>(kernelId);
 		return kernel.getSpec();
 	}
 
-	$requestComplete(kernelId: number, content: sqlops.nb.ICompleteRequest): Thenable<sqlops.nb.ICompleteReplyMsg> {
-		let kernel = this._getAdapter<sqlops.nb.IKernel>(kernelId);
+	$requestComplete(kernelId: number, content: azdata.nb.ICompleteRequest): Thenable<azdata.nb.ICompleteReplyMsg> {
+		let kernel = this._getAdapter<azdata.nb.IKernel>(kernelId);
 		return kernel.requestComplete(content);
 	}
 
-	$requestExecute(kernelId: number, content: sqlops.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails> {
-		let kernel = this._getAdapter<sqlops.nb.IKernel>(kernelId);
+	$requestExecute(kernelId: number, content: azdata.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails> {
+		let kernel = this._getAdapter<azdata.nb.IKernel>(kernelId);
 		let future = kernel.requestExecute(content, disposeOnDone);
 		let futureId = this._addNewAdapter(future);
 		this.hookFutureDone(futureId, future);
@@ -161,7 +161,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	private hookFutureDone(futureId: number, future: sqlops.nb.IFuture): void {
+	private hookFutureDone(futureId: number, future: azdata.nb.IFuture): void {
 		future.done.then(success => {
 			return this._proxy.$onFutureDone(futureId, { succeeded: true, message: success, rejectReason: undefined });
 		}, err => {
@@ -179,31 +179,31 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	private hookFutureMessages(futureId: number, future: sqlops.nb.IFuture): void {
+	private hookFutureMessages(futureId: number, future: azdata.nb.IFuture): void {
 		future.setReplyHandler({ handle: (msg) => this._proxy.$onFutureMessage(futureId, FutureMessageType.Reply, msg) });
 		future.setStdInHandler({ handle: (msg) => this._proxy.$onFutureMessage(futureId, FutureMessageType.StdIn, msg) });
 		future.setIOPubHandler({ handle: (msg) => this._proxy.$onFutureMessage(futureId, FutureMessageType.IOPub, msg) });
 	}
 
 	$interruptKernel(kernelId: number): Thenable<void> {
-		let kernel = this._getAdapter<sqlops.nb.IKernel>(kernelId);
+		let kernel = this._getAdapter<azdata.nb.IKernel>(kernelId);
 		return kernel.interrupt();
 	}
 
-	$sendInputReply(futureId: number, content: sqlops.nb.IInputReply): void {
-		let future = this._getAdapter<sqlops.nb.IFuture>(futureId);
+	$sendInputReply(futureId: number, content: azdata.nb.IInputReply): void {
+		let future = this._getAdapter<azdata.nb.IFuture>(futureId);
 		return future.sendInputReply(content);
 	}
 
 	$disposeFuture(futureId: number): void {
-		let future = this._getAdapter<sqlops.nb.IFuture>(futureId);
+		let future = this._getAdapter<azdata.nb.IFuture>(futureId);
 		future.dispose();
 	}
 
 	//#endregion
 
 	//#region APIs called by extensions
-	registerNotebookProvider(provider: sqlops.nb.NotebookProvider): vscode.Disposable {
+	registerNotebookProvider(provider: azdata.nb.NotebookProvider): vscode.Disposable {
 		if (!provider || !provider.providerId) {
 			throw new Error(localize('providerRequired', 'A NotebookProvider with valid providerId must be passed to this method'));
 		}
@@ -235,7 +235,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		return undefined;
 	}
 
-	private async createManager(provider: sqlops.nb.NotebookProvider, notebookUri: URI): Promise<NotebookManagerAdapter> {
+	private async createManager(provider: azdata.nb.NotebookProvider, notebookUri: URI): Promise<NotebookManagerAdapter> {
 		let manager = await provider.getNotebookManager(notebookUri);
 		let uriString = notebookUri.toString();
 		let adapter = new NotebookManagerAdapter(provider, manager, uriString);
@@ -254,8 +254,8 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		return ExtHostNotebook._handlePool++;
 	}
 
-	private _withProvider<R>(handle: number, callback: (provider: sqlops.nb.NotebookProvider) => R | PromiseLike<R>): TPromise<R> {
-		let provider = this._adapters.get(handle) as sqlops.nb.NotebookProvider;
+	private _withProvider<R>(handle: number, callback: (provider: azdata.nb.NotebookProvider) => R | PromiseLike<R>): TPromise<R> {
+		let provider = this._adapters.get(handle) as azdata.nb.NotebookProvider;
 		if (provider === undefined) {
 			return TPromise.wrapError<R>(new Error(localize('errNoProvider', 'no notebook provider found')));
 		}
@@ -270,7 +270,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		return TPromise.wrap(callback(manager));
 	}
 
-	private _withServerManager<R>(handle: number, callback: (manager: sqlops.nb.ServerManager) => R | PromiseLike<R>): TPromise<R> {
+	private _withServerManager<R>(handle: number, callback: (manager: azdata.nb.ServerManager) => R | PromiseLike<R>): TPromise<R> {
 		return this._withNotebookManager(handle, (notebookManager) => {
 			let serverManager = notebookManager.serverManager;
 			if (!serverManager) {
@@ -280,7 +280,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	private _withContentManager<R>(handle: number, callback: (manager: sqlops.nb.ContentManager) => R | PromiseLike<R>): TPromise<R> {
+	private _withContentManager<R>(handle: number, callback: (manager: azdata.nb.ContentManager) => R | PromiseLike<R>): TPromise<R> {
 		return this._withNotebookManager(handle, (notebookManager) => {
 			let contentManager = notebookManager.contentManager;
 			if (!contentManager) {
@@ -290,7 +290,7 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 		});
 	}
 
-	private _withSessionManager<R>(handle: number, callback: (manager: sqlops.nb.SessionManager) => R | PromiseLike<R>): TPromise<R> {
+	private _withSessionManager<R>(handle: number, callback: (manager: azdata.nb.SessionManager) => R | PromiseLike<R>): TPromise<R> {
 		return this._withNotebookManager(handle, (notebookManager) => {
 			let sessionManager = notebookManager.sessionManager;
 			if (!sessionManager) {
@@ -318,24 +318,24 @@ export class ExtHostNotebook implements ExtHostNotebookShape {
 }
 
 
-class NotebookManagerAdapter implements sqlops.nb.NotebookManager {
+class NotebookManagerAdapter implements azdata.nb.NotebookManager {
 	public handle: number;
 	constructor(
-		public readonly provider: sqlops.nb.NotebookProvider,
-		private manager: sqlops.nb.NotebookManager,
+		public readonly provider: azdata.nb.NotebookProvider,
+		private manager: azdata.nb.NotebookManager,
 		public readonly uriString: string
 	) {
 	}
 
-	public get contentManager(): sqlops.nb.ContentManager {
+	public get contentManager(): azdata.nb.ContentManager {
 		return this.manager.contentManager;
 	}
 
-	public get sessionManager(): sqlops.nb.SessionManager {
+	public get sessionManager(): azdata.nb.SessionManager {
 		return this.manager.sessionManager;
 	}
 
-	public get serverManager(): sqlops.nb.ServerManager {
+	public get serverManager(): azdata.nb.ServerManager {
 		return this.manager.serverManager;
 	}
 }

src/sql/workbench/api/node/extHostNotebookDocumentData.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
@@ -17,15 +17,15 @@ import { CellRange } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 
 export class ExtHostNotebookDocumentData implements IDisposable {
-	private _document: sqlops.nb.NotebookDocument;
+	private _document: azdata.nb.NotebookDocument;
 	private _isDisposed: boolean = false;
-	private _kernelSpec: sqlops.nb.IKernelSpec;
+	private _kernelSpec: azdata.nb.IKernelSpec;
 
 	constructor(private readonly _proxy: MainThreadNotebookDocumentsAndEditorsShape,
 		private readonly _uri: URI,
 		private _providerId: string,
 		private _isDirty: boolean,
-		private _cells: sqlops.nb.NotebookCell[]
+		private _cells: azdata.nb.NotebookCell[]
 	) {
 	}
 
@@ -39,7 +39,7 @@ export class ExtHostNotebookDocumentData implements IDisposable {
 	}
 
 
-	get document(): sqlops.nb.NotebookDocument {
+	get document(): azdata.nb.NotebookDocument {
 		if (!this._document) {
 			const data = this;
 			this._document = {
@@ -77,7 +77,7 @@ export class ExtHostNotebookDocumentData implements IDisposable {
 
 	// ---- range math
 
-	private _validateRange(range: sqlops.nb.CellRange): sqlops.nb.CellRange {
+	private _validateRange(range: azdata.nb.CellRange): azdata.nb.CellRange {
 		if (!(range instanceof CellRange)) {
 			throw new Error('Invalid argument');
 		}

src/sql/workbench/api/node/extHostNotebookDocumentsAndEditors.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 import { Event, Emitter } from 'vs/base/common/event';
@@ -35,13 +35,13 @@ export class ExtHostNotebookDocumentsAndEditors implements ExtHostNotebookDocume
 
 	private readonly _onDidChangeVisibleNotebookEditors = new Emitter<ExtHostNotebookEditor[]>();
 	private readonly _onDidChangeActiveNotebookEditor = new Emitter<ExtHostNotebookEditor>();
-	private _onDidOpenNotebook = new Emitter<sqlops.nb.NotebookDocument>();
-	private _onDidChangeNotebookCell = new Emitter<sqlops.nb.NotebookCellChangeEvent>();
+	private _onDidOpenNotebook = new Emitter<azdata.nb.NotebookDocument>();
+	private _onDidChangeNotebookCell = new Emitter<azdata.nb.NotebookCellChangeEvent>();
 
 	readonly onDidChangeVisibleNotebookEditors: Event<ExtHostNotebookEditor[]> = this._onDidChangeVisibleNotebookEditors.event;
 	readonly onDidChangeActiveNotebookEditor: Event<ExtHostNotebookEditor> = this._onDidChangeActiveNotebookEditor.event;
-	readonly onDidOpenNotebookDocument: Event<sqlops.nb.NotebookDocument> = this._onDidOpenNotebook.event;
-	readonly onDidChangeNotebookCell: Event<sqlops.nb.NotebookCellChangeEvent> = this._onDidChangeNotebookCell.event;
+	readonly onDidOpenNotebookDocument: Event<azdata.nb.NotebookDocument> = this._onDidOpenNotebook.event;
+	readonly onDidChangeNotebookCell: Event<azdata.nb.NotebookCellChangeEvent> = this._onDidChangeNotebookCell.event;
 
 
 	constructor(
@@ -156,11 +156,11 @@ export class ExtHostNotebookDocumentsAndEditors implements ExtHostNotebookDocume
 	//#endregion
 
 	//#region Extension accessible methods
-	showNotebookDocument(uri: vscode.Uri, showOptions: sqlops.nb.NotebookShowOptions): Thenable<sqlops.nb.NotebookEditor> {
+	showNotebookDocument(uri: vscode.Uri, showOptions: azdata.nb.NotebookShowOptions): Thenable<azdata.nb.NotebookEditor> {
 		return this.doShowNotebookDocument(uri, showOptions);
 	}
 
-	private async doShowNotebookDocument(uri: vscode.Uri, showOptions: sqlops.nb.NotebookShowOptions): Promise<sqlops.nb.NotebookEditor> {
+	private async doShowNotebookDocument(uri: vscode.Uri, showOptions: azdata.nb.NotebookShowOptions): Promise<azdata.nb.NotebookEditor> {
 		let options: INotebookShowOptions = {};
 		if (showOptions) {
 			options.preserveFocus = showOptions.preserveFocus;

src/sql/workbench/api/node/extHostNotebookEditor.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 import { ok } from 'vs/base/common/assert';
@@ -17,8 +17,8 @@ import { ExtHostNotebookDocumentData } from 'sql/workbench/api/node/extHostNoteb
 import { CellRange, ISingleNotebookEditOperation, ICellRange } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 export interface INotebookEditOperation {
-	range: sqlops.nb.CellRange;
-	cell: Partial<sqlops.nb.ICellContents>;
+	range: azdata.nb.CellRange;
+	cell: Partial<azdata.nb.ICellContents>;
 	forceMoveMarkers: boolean;
 }
 
@@ -29,7 +29,7 @@ export interface INotebookEditData {
 	undoStopAfter: boolean;
 }
 
-function toICellRange(range: sqlops.nb.CellRange): ICellRange {
+function toICellRange(range: azdata.nb.CellRange): ICellRange {
 	return {
 		start: range.start,
 		end: range.end
@@ -38,13 +38,13 @@ function toICellRange(range: sqlops.nb.CellRange): ICellRange {
 
 export class NotebookEditorEdit {
 
-	private readonly _document: sqlops.nb.NotebookDocument;
+	private readonly _document: azdata.nb.NotebookDocument;
 	private readonly _documentVersionId: number;
 	private _collectedEdits: INotebookEditOperation[];
 	private readonly _undoStopBefore: boolean;
 	private readonly _undoStopAfter: boolean;
 
-	constructor(document: sqlops.nb.NotebookDocument, options: { undoStopBefore: boolean; undoStopAfter: boolean; }) {
+	constructor(document: azdata.nb.NotebookDocument, options: { undoStopBefore: boolean; undoStopAfter: boolean; }) {
 		this._document = document;
 		// TODO add version handling
 		this._documentVersionId = 0;
@@ -63,7 +63,7 @@ export class NotebookEditorEdit {
 		};
 	}
 
-	replace(location: number | CellRange, value: Partial<sqlops.nb.ICellContents>): void {
+	replace(location: number | CellRange, value: Partial<azdata.nb.ICellContents>): void {
 		let range: CellRange = this.getAsRange(location);
 		this._pushEdit(range, value, false);
 	}
@@ -82,7 +82,7 @@ export class NotebookEditorEdit {
 		return range;
 	}
 
-	insertCell(value:  Partial<sqlops.nb.ICellContents>, location?: number): void {
+	insertCell(value:  Partial<azdata.nb.ICellContents>, location?: number): void {
 		if (location === null || location === undefined) {
 			// If not specified, assume adding to end of list
 			location = this._document.cells.length;
@@ -105,7 +105,7 @@ export class NotebookEditorEdit {
 		this._pushEdit(range, null, true);
 	}
 
-	private _pushEdit(range: sqlops.nb.CellRange, cell:  Partial<sqlops.nb.ICellContents>, forceMoveMarkers: boolean): void {
+	private _pushEdit(range: azdata.nb.CellRange, cell:  Partial<azdata.nb.ICellContents>, forceMoveMarkers: boolean): void {
 		let validRange = this._document.validateCellRange(range);
 		this._collectedEdits.push({
 			range: validRange,
@@ -115,7 +115,7 @@ export class NotebookEditorEdit {
 	}
 }
 
-export class ExtHostNotebookEditor implements sqlops.nb.NotebookEditor, IDisposable {
+export class ExtHostNotebookEditor implements azdata.nb.NotebookEditor, IDisposable {
 	private _disposed: boolean = false;
 
 	constructor(
@@ -132,7 +132,7 @@ export class ExtHostNotebookEditor implements sqlops.nb.NotebookEditor, IDisposa
 		this._disposed = true;
 	}
 
-	get document(): sqlops.nb.NotebookDocument {
+	get document(): azdata.nb.NotebookDocument {
 		return this._documentData.document;
 	}
 
@@ -152,12 +152,12 @@ export class ExtHostNotebookEditor implements sqlops.nb.NotebookEditor, IDisposa
 		return this._id;
 	}
 
-	public runCell(cell: sqlops.nb.NotebookCell): Thenable<boolean> {
+	public runCell(cell: azdata.nb.NotebookCell): Thenable<boolean> {
 		let uri = cell ? cell.uri : undefined;
 		return this._proxy.$runCell(this._id, uri);
 	}
 
-	public edit(callback: (editBuilder: sqlops.nb.NotebookEditorEdit) => void, options?: { undoStopBefore: boolean; undoStopAfter: boolean; }): Thenable<boolean> {
+	public edit(callback: (editBuilder: azdata.nb.NotebookEditorEdit) => void, options?: { undoStopBefore: boolean; undoStopAfter: boolean; }): Thenable<boolean> {
 		if (this._disposed) {
 			return TPromise.wrapError<boolean>(new Error('NotebookEditor#edit not possible on closed editors'));
 		}

src/sql/workbench/api/node/extHostObjectExplorer.ts

@@ -6,7 +6,7 @@
 
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { ExtHostObjectExplorerShape, SqlMainContext, MainThreadObjectExplorerShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 export class ExtHostObjectExplorer implements ExtHostObjectExplorerShape {
@@ -19,15 +19,15 @@ export class ExtHostObjectExplorer implements ExtHostObjectExplorerShape {
 		this._proxy = mainContext.getProxy(SqlMainContext.MainThreadObjectExplorer);
 	}
 
-	public $getNode(connectionId: string, nodePath?: string): Thenable<sqlops.objectexplorer.ObjectExplorerNode> {
+	public $getNode(connectionId: string, nodePath?: string): Thenable<azdata.objectexplorer.ObjectExplorerNode> {
 		return this._proxy.$getNode(connectionId, nodePath).then(nodeInfo => nodeInfo === undefined ? undefined : new ExtHostObjectExplorerNode(nodeInfo, connectionId, this._proxy));
 	}
 
-	public $getActiveConnectionNodes(): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
+	public $getActiveConnectionNodes(): Thenable<azdata.objectexplorer.ObjectExplorerNode[]> {
 		return this._proxy.$getActiveConnectionNodes().then(results => results.map(result => new ExtHostObjectExplorerNode(result.nodeInfo, result.connectionId, this._proxy)));
 	}
 
-	public $findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
+	public $findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<azdata.objectexplorer.ObjectExplorerNode[]> {
 		return this._proxy.$findNodes(connectionId, type, schema, name, database, parentObjectNames).then(results => results.map(result => new ExtHostObjectExplorerNode(result, connectionId, this._proxy)));
 	}
 
@@ -35,12 +35,12 @@ export class ExtHostObjectExplorer implements ExtHostObjectExplorerShape {
 		return this._proxy.$getNodeActions(connectionId, nodePath);
 	}
 
-	public $getSessionConnectionProfile(sessionId: string): Thenable<sqlops.IConnectionProfile> {
+	public $getSessionConnectionProfile(sessionId: string): Thenable<azdata.IConnectionProfile> {
 		return this._proxy.$getSessionConnectionProfile(sessionId);
 	}
 }
 
-class ExtHostObjectExplorerNode implements sqlops.objectexplorer.ObjectExplorerNode {
+class ExtHostObjectExplorerNode implements azdata.objectexplorer.ObjectExplorerNode {
 	public connectionId: string;
 	public nodePath: string;
 	public nodeType: string;
@@ -48,10 +48,10 @@ class ExtHostObjectExplorerNode implements sqlops.objectexplorer.ObjectExplorerN
 	public nodeStatus: string;
 	public label: string;
 	public isLeaf: boolean;
-	public metadata: sqlops.ObjectMetadata;
+	public metadata: azdata.ObjectMetadata;
 	public errorMessage: string;
 
-	constructor(nodeInfo: sqlops.NodeInfo, connectionId: string, private _proxy: MainThreadObjectExplorerShape) {
+	constructor(nodeInfo: azdata.NodeInfo, connectionId: string, private _proxy: MainThreadObjectExplorerShape) {
 		this.getDetailsFromInfo(nodeInfo);
 		this.connectionId = connectionId;
 	}
@@ -68,11 +68,11 @@ class ExtHostObjectExplorerNode implements sqlops.objectexplorer.ObjectExplorerN
 		return this._proxy.$setSelected(this.connectionId, this.nodePath, selected, clearOtherSelections);
 	}
 
-	getChildren(): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
+	getChildren(): Thenable<azdata.objectexplorer.ObjectExplorerNode[]> {
 		return this._proxy.$getChildren(this.connectionId, this.nodePath).then(children => children.map(nodeInfo => new ExtHostObjectExplorerNode(nodeInfo, this.connectionId, this._proxy)));
 	}
 
-	getParent(): Thenable<sqlops.objectexplorer.ObjectExplorerNode> {
+	getParent(): Thenable<azdata.objectexplorer.ObjectExplorerNode> {
 		let parentPathEndIndex = this.nodePath.lastIndexOf('/');
 		if (parentPathEndIndex === -1) {
 			return Promise.resolve(undefined);
@@ -84,7 +84,7 @@ class ExtHostObjectExplorerNode implements sqlops.objectexplorer.ObjectExplorerN
 		return this._proxy.$refresh(this.connectionId, this.nodePath).then(nodeInfo => this.getDetailsFromInfo(nodeInfo));
 	}
 
-	private getDetailsFromInfo(nodeInfo: sqlops.NodeInfo): void {
+	private getDetailsFromInfo(nodeInfo: azdata.NodeInfo): void {
 		Object.entries(nodeInfo).forEach(([key, value]) => this[key] = value);
 	}
 }

src/sql/workbench/api/node/extHostQueryEditor.ts

@@ -6,7 +6,7 @@
 
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { ExtHostQueryEditorShape, SqlMainContext, MainThreadQueryEditorShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 export class ExtHostQueryEditor implements ExtHostQueryEditorShape  {

src/sql/workbench/api/node/extHostResourceProvider.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
@@ -27,15 +27,15 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
 
 	// PUBLIC METHODS //////////////////////////////////////////////////////
 	// - MAIN THREAD AVAILABLE METHODS /////////////////////////////////////
-	public $createFirewallRule(handle: number, account: sqlops.Account, firewallRuleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> {
-		return this._withProvider(handle, (provider: sqlops.ResourceProvider) => provider.createFirewallRule(account, firewallRuleInfo));
+	public $createFirewallRule(handle: number, account: azdata.Account, firewallRuleInfo: azdata.FirewallRuleInfo): Thenable<azdata.CreateFirewallRuleResponse> {
+		return this._withProvider(handle, (provider: azdata.ResourceProvider) => provider.createFirewallRule(account, firewallRuleInfo));
 	}
-	public $handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> {
-		return this._withProvider(handle, (provider: sqlops.ResourceProvider) => provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId));
+	public $handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<azdata.HandleFirewallRuleResponse> {
+		return this._withProvider(handle, (provider: azdata.ResourceProvider) => provider.handleFirewallRule(errorCode, errorMessage, connectionTypeId));
 	}
 
 	// - EXTENSION HOST AVAILABLE METHODS //////////////////////////////////
-	public $registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, provider: sqlops.ResourceProvider): Disposable {
+	public $registerResourceProvider(providerMetadata: azdata.ResourceProviderMetadata, provider: azdata.ResourceProvider): Disposable {
 		let self = this;
 
 		// Look for any account providers that have the same provider ID
@@ -76,7 +76,7 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
 		return this._handlePool++;
 	}
 
-	private _withProvider<R>(handle: number, callback: (provider: sqlops.ResourceProvider) => Thenable<R>): Thenable<R> {
+	private _withProvider<R>(handle: number, callback: (provider: azdata.ResourceProvider) => Thenable<R>): Thenable<R> {
 		let provider = this._providers[handle];
 		if (provider === undefined) {
 			return TPromise.wrapError(new Error(`Provider ${handle} not found.`));
@@ -86,8 +86,8 @@ export class ExtHostResourceProvider extends ExtHostResourceProviderShape {
 }
 
 interface ResourceProviderWithMetadata {
-	metadata: sqlops.ResourceProviderMetadata;
-	provider: sqlops.ResourceProvider;
+	metadata: azdata.ResourceProviderMetadata;
+	provider: azdata.ResourceProvider;
 }
 
 

src/sql/workbench/api/node/extHostSerializationProvider.ts

@@ -8,17 +8,17 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import { SqlMainContext, MainThreadSerializationProviderShape, ExtHostSerializationProviderShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Disposable } from 'vs/workbench/api/node/extHostTypes';
 
 class SerializationAdapter {
-	private _provider: sqlops.SerializationProvider;
+	private _provider: azdata.SerializationProvider;
 
-	constructor(provider: sqlops.SerializationProvider) {
+	constructor(provider: azdata.SerializationProvider) {
 		this._provider = provider;
 	}
 
-	public saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
+	public saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<azdata.SaveResultRequestResult> {
 		return this._provider.saveAs(saveFormat, savePath, results, appendToFile);
 	}
 
@@ -59,14 +59,14 @@ export class ExtHostSerializationProvider extends ExtHostSerializationProviderSh
 		this._proxy = mainContext.getProxy(SqlMainContext.MainThreadSerializationProvider);
 	}
 
-	public $registerSerializationProvider(provider: sqlops.SerializationProvider): vscode.Disposable {
+	public $registerSerializationProvider(provider: azdata.SerializationProvider): vscode.Disposable {
 		provider.handle = this._nextHandle();
 		this._adapter[provider.handle] = new SerializationAdapter(provider);
 		this._proxy.$registerSerializationProvider(provider.handle);
 		return this._createDisposable(provider.handle);
 	}
 
-	public $saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
+	public $saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<azdata.SaveResultRequestResult> {
 		return this._withAdapter(0, SerializationAdapter, adapter => adapter.saveAs(saveFormat, savePath, results, appendToFile));
 	}
 

src/sql/workbench/api/node/extHostTasks.ts

@@ -10,7 +10,7 @@ import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
 import * as extHostTypes from 'vs/workbench/api/node/extHostTypes';
 import { TPromise } from 'vs/base/common/winjs.base';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { ITaskHandlerDescription } from 'sql/platform/tasks/common/tasks';
 import { SqlMainContext, MainThreadTasksShape, ExtHostTasksShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
@@ -32,7 +32,7 @@ export class ExtHostTasks implements ExtHostTasksShape {
 		this._proxy = mainContext.getProxy(SqlMainContext.MainThreadTasks);
 	}
 
-	registerTask(id: string, callback: sqlops.tasks.ITaskHandler, thisArg?: any, description?: ITaskHandlerDescription): extHostTypes.Disposable {
+	registerTask(id: string, callback: azdata.tasks.ITaskHandler, thisArg?: any, description?: ITaskHandlerDescription): extHostTypes.Disposable {
 		this.logService.trace('ExtHostTasks#registerTask', id);
 
 		if (!id.trim().length) {

src/sql/workbench/api/node/mainThreadAccountManagement.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IAccountManagementService } from 'sql/platform/accountManagement/common/interfaces';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
@@ -20,7 +20,7 @@ import { UpdateAccountListEventParams } from 'sql/platform/accountManagement/com
 
 @extHostNamedCustomer(SqlMainContext.MainThreadAccountManagement)
 export class MainThreadAccountManagement implements MainThreadAccountManagementShape {
-	private _providerMetadata: { [handle: number]: sqlops.AccountProviderMetadata };
+	private _providerMetadata: { [handle: number]: azdata.AccountProviderMetadata };
 	private _proxy: ExtHostAccountManagementShape;
 	private _toDispose: IDisposable[];
 
@@ -39,7 +39,7 @@ export class MainThreadAccountManagement implements MainThreadAccountManagementS
 				return;
 			}
 
-			const providerMetadataIndex = Object.values(this._providerMetadata).findIndex((providerMetadata: sqlops.AccountProviderMetadata) => providerMetadata.id === e.providerId);
+			const providerMetadataIndex = Object.values(this._providerMetadata).findIndex((providerMetadata: azdata.AccountProviderMetadata) => providerMetadata.id === e.providerId);
 			if (providerMetadataIndex === -1) {
 				return;
 			}
@@ -57,35 +57,35 @@ export class MainThreadAccountManagement implements MainThreadAccountManagementS
 		return this._accountManagementService.endAutoOAuthDeviceCode();
 	}
 
-	$accountUpdated(updatedAccount: sqlops.Account): void {
+	$accountUpdated(updatedAccount: azdata.Account): void {
 		this._accountManagementService.accountUpdated(updatedAccount);
 	}
 
-	public $getAccountsForProvider(providerId: string): Thenable<sqlops.Account[]> {
+	public $getAccountsForProvider(providerId: string): Thenable<azdata.Account[]> {
 		return this._accountManagementService.getAccountsForProvider(providerId);
 	}
 
-	public $registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, handle: number): Thenable<any> {
+	public $registerAccountProvider(providerMetadata: azdata.AccountProviderMetadata, handle: number): Thenable<any> {
 		let self = this;
 
 		// Create the account provider that interfaces with the extension via the proxy and register it
-		let accountProvider: sqlops.AccountProvider = {
+		let accountProvider: azdata.AccountProvider = {
 			autoOAuthCancelled(): Thenable<void> {
 				return self._proxy.$autoOAuthCancelled(handle);
 			},
-			clear(accountKey: sqlops.AccountKey): Thenable<void> {
+			clear(accountKey: azdata.AccountKey): Thenable<void> {
 				return self._proxy.$clear(handle, accountKey);
 			},
-			getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
+			getSecurityToken(account: azdata.Account, resource: azdata.AzureResource): Thenable<{}> {
 				return self._proxy.$getSecurityToken(account, resource);
 			},
-			initialize(restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
+			initialize(restoredAccounts: azdata.Account[]): Thenable<azdata.Account[]> {
 				return self._proxy.$initialize(handle, restoredAccounts);
 			},
-			prompt(): Thenable<sqlops.Account> {
+			prompt(): Thenable<azdata.Account> {
 				return self._proxy.$prompt(handle);
 			},
-			refresh(account: sqlops.Account): Thenable<sqlops.Account> {
+			refresh(account: azdata.Account): Thenable<azdata.Account> {
 				return self._proxy.$refresh(handle, account);
 			}
 		};

src/sql/workbench/api/node/mainThreadBackgroundTaskManagement.ts

@@ -12,7 +12,7 @@ import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 import { Disposable } from 'vs/base/common/lifecycle';
 
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 export enum TaskStatus {
 	NotStarted = 0,
@@ -41,12 +41,12 @@ export class MainThreadBackgroundTaskManagement extends Disposable implements Ma
 		}));
 	}
 
-	$registerTask(taskInfo: sqlops.TaskInfo): void {
+	$registerTask(taskInfo: azdata.TaskInfo): void {
 		this._taskService.createNewTask(taskInfo);
 		this._proxy.$onTaskRegistered(taskInfo.taskId);
 	}
 
-	$updateTask(taskProgressInfo: sqlops.TaskProgressInfo): void {
+	$updateTask(taskProgressInfo: azdata.TaskProgressInfo): void {
 		this._taskService.updateTask(taskProgressInfo);
 	}
 }

src/sql/workbench/api/node/mainThreadConnectionManagement.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import { SqlExtHostContext, SqlMainContext, ExtHostConnectionManagementShape, MainThreadConnectionManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { IConnectionManagementService } from 'sql/platform/connection/common/connectionManagement';
@@ -44,11 +44,11 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
 		this._toDispose = dispose(this._toDispose);
 	}
 
-	public $getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
+	public $getActiveConnections(): Thenable<azdata.connection.Connection[]> {
 		return Promise.resolve(this._connectionManagementService.getActiveConnections().map(profile => this.convertConnection(profile)));
 	}
 
-	public $getCurrentConnection(): Thenable<sqlops.connection.Connection> {
+	public $getCurrentConnection(): Thenable<azdata.connection.Connection> {
 		return Promise.resolve(this.convertConnection(TaskUtilities.getCurrentGlobalConnection(this._objectExplorerService, this._connectionManagementService, this._workbenchEditorService, true)));
 	}
 
@@ -56,11 +56,11 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
 		return Promise.resolve(this._connectionManagementService.getActiveConnectionCredentials(connectionId));
 	}
 
-	public $getServerInfo(connectionId: string): Thenable<sqlops.ServerInfo> {
+	public $getServerInfo(connectionId: string): Thenable<azdata.ServerInfo> {
 		return Promise.resolve(this._connectionManagementService.getServerInfo(connectionId));
 	}
 
-	public async $openConnectionDialog(providers: string[], initialConnectionProfile?: IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Promise<sqlops.connection.Connection> {
+	public async $openConnectionDialog(providers: string[], initialConnectionProfile?: IConnectionProfile, connectionCompletionOptions?: azdata.IConnectionCompletionOptions): Promise<azdata.connection.Connection> {
 		let connectionProfile = await this._connectionDialogService.openDialogAndWait(this._connectionManagementService, { connectionType: 1, providers: providers }, initialConnectionProfile);
 		const connection = connectionProfile ? {
 			connectionId: connectionProfile.id,
@@ -97,12 +97,12 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
 		return Promise.resolve(this._connectionManagementService.getConnectionUriFromId(connectionId));
 	}
 
-	private convertConnection(profile: IConnectionProfile): sqlops.connection.Connection {
+	private convertConnection(profile: IConnectionProfile): azdata.connection.Connection {
 		if (!profile) {
 			return undefined;
 		}
 		profile = this._connectionManagementService.removeConnectionProfileCredentials(profile);
-		let connection: sqlops.connection.Connection = {
+		let connection: azdata.connection.Connection = {
 			providerName: profile.providerName,
 			connectionId: profile.id,
 			options: profile.options
@@ -110,7 +110,7 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
 		return connection;
 	}
 
-	public $connect(connectionProfile: IConnectionProfile): Thenable<sqlops.ConnectionResult> {
+	public $connect(connectionProfile: IConnectionProfile): Thenable<azdata.ConnectionResult> {
 		let profile = new ConnectionProfile(this._capabilitiesService, connectionProfile);
 		profile.id = generateUuid();
 		return this._connectionManagementService.connectAndSaveProfile(profile, undefined, {
@@ -120,7 +120,7 @@ export class MainThreadConnectionManagement implements MainThreadConnectionManag
 			showConnectionDialogOnError: true,
 			showFirewallRuleOnError: true
 		}).then((result) => {
-			return <sqlops.ConnectionResult>{
+			return <azdata.ConnectionResult>{
 				connected: result.connected,
 				connectionId: result.connected ? profile.id : undefined,
 				errorCode: result.errorCode,

src/sql/workbench/api/node/mainThreadCredentialManagement.ts

@@ -11,7 +11,7 @@ import {
 	MainThreadCredentialManagementShape, SqlMainContext
 } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { ICredentialsService } from 'sql/platform/credentials/common/credentialsService';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 
@@ -44,7 +44,7 @@ export class MainThreadCredentialManagement implements MainThreadCredentialManag
 			onSaveCredential(credentialId: string, password: string): Thenable<boolean> {
 				return self._proxy.$saveCredential(credentialId, password);
 			},
-			onReadCredential(credentialId: string): Thenable<sqlops.Credential> {
+			onReadCredential(credentialId: string): Thenable<azdata.Credential> {
 				return self._proxy.$readCredential(credentialId);
 			},
 			onDeleteCredential(credentialId: string): Thenable<boolean> {

src/sql/workbench/api/node/mainThreadDataProtocol.ts

@@ -13,7 +13,7 @@ import {
 import { IConnectionManagementService } from 'sql/platform/connection/common/connectionManagement';
 import { ICapabilitiesService } from 'sql/platform/capabilities/common/capabilitiesService';
 import { IQueryManagementService } from 'sql/platform/query/common/queryManagement';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { IMetadataService } from 'sql/platform/metadata/common/metadataService';
 import { IObjectExplorerService, NodeExpandInfoWithProviderId } from 'sql/workbench/services/objectExplorer/common/objectExplorerService';
 import { IScriptingService } from 'sql/platform/scripting/common/scriptingService';
@@ -73,8 +73,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerConnectionProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._connectionManagementService.registerProvider(providerId, <sqlops.ConnectionProvider>{
-			connect(connectionUri: string, connectionInfo: sqlops.ConnectionInfo): Thenable<boolean> {
+		this._connectionManagementService.registerProvider(providerId, <azdata.ConnectionProvider>{
+			connect(connectionUri: string, connectionInfo: azdata.ConnectionInfo): Thenable<boolean> {
 				return self._proxy.$connect(handle, connectionUri, connectionInfo);
 			},
 			disconnect(connectionUri: string): Thenable<boolean> {
@@ -86,13 +86,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			cancelConnect(connectionUri: string): Thenable<boolean> {
 				return self._proxy.$cancelConnect(handle, connectionUri);
 			},
-			listDatabases(connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
+			listDatabases(connectionUri: string): Thenable<azdata.ListDatabasesResult> {
 				return self._proxy.$listDatabases(handle, connectionUri);
 			},
 			getConnectionString(connectionUri: string, includePassword: boolean): Thenable<string> {
 				return self._proxy.$getConnectionString(handle, connectionUri, includePassword);
 			},
-			buildConnectionInfo(connectionString: string): Thenable<sqlops.ConnectionInfo> {
+			buildConnectionInfo(connectionString: string): Thenable<azdata.ConnectionInfo> {
 				return self._proxy.$buildConnectionInfo(handle, connectionString);
 			},
 			rebuildIntelliSenseCache(connectionUri: string): Thenable<void> {
@@ -106,10 +106,10 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 	public $registerQueryProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
 		this._queryManagementService.addQueryRequestHandler(providerId, {
-			cancelQuery(ownerUri: string): Thenable<sqlops.QueryCancelResult> {
+			cancelQuery(ownerUri: string): Thenable<azdata.QueryCancelResult> {
 				return self._proxy.$cancelQuery(handle, ownerUri);
 			},
-			runQuery(ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> {
+			runQuery(ownerUri: string, selection: azdata.ISelectionData, runOptions?: azdata.ExecutionPlanOptions): Thenable<void> {
 				return self._proxy.$runQuery(handle, ownerUri, selection, runOptions);
 			},
 			runQueryStatement(ownerUri: string, line: number, column: number): Thenable<void> {
@@ -118,19 +118,19 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			runQueryString(ownerUri: string, queryString: string): Thenable<void> {
 				return self._proxy.$runQueryString(handle, ownerUri, queryString);
 			},
-			runQueryAndReturn(ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> {
+			runQueryAndReturn(ownerUri: string, queryString: string): Thenable<azdata.SimpleExecuteResult> {
 				return self._proxy.$runQueryAndReturn(handle, ownerUri, queryString);
 			},
-			parseSyntax(ownerUri: string, query: string): Thenable<sqlops.SyntaxParseResult> {
+			parseSyntax(ownerUri: string, query: string): Thenable<azdata.SyntaxParseResult> {
 				return self._proxy.$parseSyntax(handle, ownerUri, query);
 			},
-			getQueryRows(rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> {
+			getQueryRows(rowData: azdata.QueryExecuteSubsetParams): Thenable<azdata.QueryExecuteSubsetResult> {
 				return self._proxy.$getQueryRows(handle, rowData);
 			},
 			disposeQuery(ownerUri: string): Thenable<void> {
 				return self._proxy.$disposeQuery(handle, ownerUri);
 			},
-			saveResults(requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> {
+			saveResults(requestParams: azdata.SaveResultsRequestParams): Thenable<azdata.SaveResultRequestResult> {
 				let serializationProvider = self._serializationService.getSerializationFeatureMetadataProvider(requestParams.ownerUri);
 				if (serializationProvider && serializationProvider.enabled) {
 					return self._proxy.$saveResults(handle, requestParams);
@@ -145,13 +145,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			initializeEdit(ownerUri: string, schemaName: string, objectName: string, objectType: string, rowLimit: number, queryString: string): Thenable<void> {
 				return self._proxy.$initializeEdit(handle, ownerUri, schemaName, objectName, objectType, rowLimit, queryString);
 			},
-			updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> {
+			updateCell(ownerUri: string, rowId: number, columnId: number, newValue: string): Thenable<azdata.EditUpdateCellResult> {
 				return self._proxy.$updateCell(handle, ownerUri, rowId, columnId, newValue);
 			},
 			commitEdit(ownerUri): Thenable<void> {
 				return self._proxy.$commitEdit(handle, ownerUri);
 			},
-			createRow(ownerUri: string): Thenable<sqlops.EditCreateRowResult> {
+			createRow(ownerUri: string): Thenable<azdata.EditCreateRowResult> {
 				return self._proxy.$createRow(handle, ownerUri);
 			},
 			deleteRow(ownerUri: string, rowId: number): Thenable<void> {
@@ -160,13 +160,13 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			disposeEdit(ownerUri: string): Thenable<void> {
 				return self._proxy.$disposeEdit(handle, ownerUri);
 			},
-			revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> {
+			revertCell(ownerUri: string, rowId: number, columnId: number): Thenable<azdata.EditRevertCellResult> {
 				return self._proxy.$revertCell(handle, ownerUri, rowId, columnId);
 			},
 			revertRow(ownerUri: string, rowId: number): Thenable<void> {
 				return self._proxy.$revertRow(handle, ownerUri, rowId);
 			},
-			getEditRows(rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> {
+			getEditRows(rowData: azdata.EditSubsetParams): Thenable<azdata.EditSubsetResult> {
 				return self._proxy.$getEditRows(handle, rowData);
 			}
 		});
@@ -176,11 +176,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerBackupProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._backupService.registerProvider(providerId, <sqlops.BackupProvider>{
-			backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> {
+		this._backupService.registerProvider(providerId, <azdata.BackupProvider>{
+			backup(connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.BackupResponse> {
 				return self._proxy.$backup(handle, connectionUri, backupInfo, taskExecutionMode);
 			},
-			getBackupConfigInfo(connectionUri: string): Thenable<sqlops.BackupConfigInfo> {
+			getBackupConfigInfo(connectionUri: string): Thenable<azdata.BackupConfigInfo> {
 				return self._proxy.$getBackupConfigInfo(handle, connectionUri);
 			}
 		});
@@ -190,17 +190,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerRestoreProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._restoreService.registerProvider(providerId, <sqlops.RestoreProvider>{
-			getRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> {
+		this._restoreService.registerProvider(providerId, <azdata.RestoreProvider>{
+			getRestorePlan(connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestorePlanResponse> {
 				return self._proxy.$getRestorePlan(handle, connectionUri, restoreInfo);
 			},
-			cancelRestorePlan(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> {
+			cancelRestorePlan(connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<boolean> {
 				return self._proxy.$cancelRestorePlan(handle, connectionUri, restoreInfo);
 			},
-			restore(connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> {
+			restore(connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestoreResponse> {
 				return self._proxy.$restore(handle, connectionUri, restoreInfo);
 			},
-			getRestoreConfigInfo(connectionUri: string): Thenable<sqlops.RestoreConfigInfo> {
+			getRestoreConfigInfo(connectionUri: string): Thenable<azdata.RestoreConfigInfo> {
 				return self._proxy.$getRestoreConfigInfo(handle, connectionUri);
 			}
 		});
@@ -210,17 +210,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerMetadataProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._metadataService.registerProvider(providerId, <sqlops.MetadataProvider>{
-			getMetadata(connectionUri: string): Thenable<sqlops.ProviderMetadata> {
+		this._metadataService.registerProvider(providerId, <azdata.MetadataProvider>{
+			getMetadata(connectionUri: string): Thenable<azdata.ProviderMetadata> {
 				return self._proxy.$getMetadata(handle, connectionUri);
 			},
 			getDatabases(connectionUri: string): Thenable<string[]> {
 				return self._proxy.$getDatabases(handle, connectionUri);
 			},
-			getTableInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
+			getTableInfo(connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> {
 				return self._proxy.$getTableInfo(handle, connectionUri, metadata);
 			},
-			getViewInfo(connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> {
+			getViewInfo(connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> {
 				return self._proxy.$getViewInfo(handle, connectionUri, metadata);
 			}
 		});
@@ -230,21 +230,21 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerObjectExplorerProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._objectExplorerService.registerProvider(providerId, <sqlops.ObjectExplorerProvider>{
+		this._objectExplorerService.registerProvider(providerId, <azdata.ObjectExplorerProvider>{
 			providerId: providerId,
-			createNewSession(connection: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> {
+			createNewSession(connection: azdata.ConnectionInfo): Thenable<azdata.ObjectExplorerSessionResponse> {
 				return self._proxy.$createObjectExplorerSession(handle, connection);
 			},
-			expandNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+			expandNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 				return self._proxy.$expandObjectExplorerNode(handle, nodeInfo);
 			},
-			refreshNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+			refreshNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 				return self._proxy.$refreshObjectExplorerNode(handle, nodeInfo);
 			},
-			closeSession(closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
+			closeSession(closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): Thenable<azdata.ObjectExplorerCloseSessionResponse> {
 				return self._proxy.$closeObjectExplorerSession(handle, closeSessionInfo);
 			},
-			findNodes(findNodesInfo: sqlops.FindNodesInfo): Thenable<sqlops.ObjectExplorerFindNodesResponse> {
+			findNodes(findNodesInfo: azdata.FindNodesInfo): Thenable<azdata.ObjectExplorerFindNodesResponse> {
 				return self._proxy.$findNodes(handle, findNodesInfo);
 			}
 		});
@@ -254,23 +254,23 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerObjectExplorerNodeProvider(providerId: string, supportedProviderId: string, group: string, handle: number): TPromise<any> {
 		const self = this;
-		this._objectExplorerService.registerNodeProvider(<sqlops.ObjectExplorerNodeProvider> {
+		this._objectExplorerService.registerNodeProvider(<azdata.ObjectExplorerNodeProvider> {
 			supportedProviderId: supportedProviderId,
 			providerId: providerId,
 			group: group,
-			expandNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+			expandNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 				return self._proxy.$expandObjectExplorerNode(handle, nodeInfo);
 			},
-			refreshNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+			refreshNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 				return self._proxy.$refreshObjectExplorerNode(handle, nodeInfo);
 			},
-			findNodes(findNodesInfo: sqlops.FindNodesInfo): Thenable<sqlops.ObjectExplorerFindNodesResponse> {
+			findNodes(findNodesInfo: azdata.FindNodesInfo): Thenable<azdata.ObjectExplorerFindNodesResponse> {
 				return self._proxy.$findNodes(handle, findNodesInfo);
 			},
-			handleSessionOpen(session: sqlops.ObjectExplorerSession): Thenable<boolean> {
+			handleSessionOpen(session: azdata.ObjectExplorerSession): Thenable<boolean> {
 				return self._proxy.$createObjectExplorerNodeProviderSession(handle, session);
 			},
-			handleSessionClose(closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): void {
+			handleSessionClose(closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): void {
 				return self._proxy.$handleSessionClose(handle, closeSessionInfo);
 			}
 		});
@@ -280,11 +280,11 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerTaskServicesProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._taskService.registerProvider(providerId, <sqlops.TaskServicesProvider>{
-			getAllTasks(listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> {
+		this._taskService.registerProvider(providerId, <azdata.TaskServicesProvider>{
+			getAllTasks(listTasksParams: azdata.ListTasksParams): Thenable<azdata.ListTasksResponse> {
 				return self._proxy.$getAllTasks(handle, listTasksParams);
 			},
-			cancelTask(cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> {
+			cancelTask(cancelTaskParams: azdata.CancelTaskParams): Thenable<boolean> {
 				return self._proxy.$cancelTask(handle, cancelTaskParams);
 			}
 		});
@@ -294,8 +294,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerScriptingProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._scriptingService.registerProvider(providerId, <sqlops.ScriptingProvider>{
-			scriptAsOperation(connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> {
+		this._scriptingService.registerProvider(providerId, <azdata.ScriptingProvider>{
+			scriptAsOperation(connectionUri: string, operation: azdata.ScriptOperation, metadata: azdata.ObjectMetadata, paramDetails: azdata.ScriptingParamDetails): Thenable<azdata.ScriptingResult> {
 				return self._proxy.$scriptAsOperation(handle, connectionUri, operation, metadata, paramDetails);
 			}
 		});
@@ -305,7 +305,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerFileBrowserProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._fileBrowserService.registerProvider(providerId, <sqlops.FileBrowserProvider>{
+		this._fileBrowserService.registerProvider(providerId, <azdata.FileBrowserProvider>{
 			openFileBrowser(ownerUri: string, expandPath: string, fileFilters: string[], changeFilter: boolean): Thenable<boolean> {
 				return self._proxy.$openFileBrowser(handle, ownerUri, expandPath, fileFilters, changeFilter);
 			},
@@ -315,7 +315,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 			validateFilePaths(ownerUri: string, serviceType: string, selectedFiles: string[]): Thenable<boolean> {
 				return self._proxy.$validateFilePaths(handle, ownerUri, serviceType, selectedFiles);
 			},
-			closeFileBrowser(ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> {
+			closeFileBrowser(ownerUri: string): Thenable<azdata.FileBrowserCloseResponse> {
 				return self._proxy.$closeFileBrowser(handle, ownerUri);
 			}
 		});
@@ -325,8 +325,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerProfilerProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._profilerService.registerProvider(providerId, <sqlops.ProfilerProvider>{
-			createSession(sessionId: string, createStatement: string, template: sqlops.ProfilerSessionTemplate): Thenable<boolean> {
+		this._profilerService.registerProvider(providerId, <azdata.ProfilerProvider>{
+			createSession(sessionId: string, createStatement: string, template: azdata.ProfilerSessionTemplate): Thenable<boolean> {
 				return self._proxy.$createSession(handle, sessionId, createStatement, template);
 			},
 			startSession(sessionId: string, sessionName: string): Thenable<boolean> {
@@ -354,17 +354,17 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerAdminServicesProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._adminService.registerProvider(providerId, <sqlops.AdminServicesProvider>{
-			createDatabase(connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> {
+		this._adminService.registerProvider(providerId, <azdata.AdminServicesProvider>{
+			createDatabase(connectionUri: string, database: azdata.DatabaseInfo): Thenable<azdata.CreateDatabaseResponse> {
 				return self._proxy.$createDatabase(handle, connectionUri, database);
 			},
-			getDefaultDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
+			getDefaultDatabaseInfo(connectionUri: string): Thenable<azdata.DatabaseInfo> {
 				return self._proxy.$getDefaultDatabaseInfo(handle, connectionUri);
 			},
-			getDatabaseInfo(connectionUri: string): Thenable<sqlops.DatabaseInfo> {
+			getDatabaseInfo(connectionUri: string): Thenable<azdata.DatabaseInfo> {
 				return self._proxy.$getDatabaseInfo(handle, connectionUri);
 			},
-			createLogin(connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> {
+			createLogin(connectionUri: string, login: azdata.LoginInfo): Thenable<azdata.CreateLoginResponse> {
 				return self._proxy.$createLogin(handle, connectionUri, login);
 			}
 		});
@@ -374,42 +374,42 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerAgentServicesProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._jobManagementService.registerProvider(providerId, <sqlops.AgentServicesProvider>{
+		this._jobManagementService.registerProvider(providerId, <azdata.AgentServicesProvider>{
 			providerId: providerId,
-			getJobs(connectionUri: string): Thenable<sqlops.AgentJobsResult> {
+			getJobs(connectionUri: string): Thenable<azdata.AgentJobsResult> {
 				return self._proxy.$getJobs(handle, connectionUri);
 			},
-			getJobHistory(connectionUri: string, jobID: string, jobName: string): Thenable<sqlops.AgentJobHistoryResult> {
+			getJobHistory(connectionUri: string, jobID: string, jobName: string): Thenable<azdata.AgentJobHistoryResult> {
 				return self._proxy.$getJobHistory(handle, connectionUri, jobID, jobName);
 			},
-			jobAction(connectionUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> {
+			jobAction(connectionUri: string, jobName: string, action: string): Thenable<azdata.ResultStatus> {
 				return self._proxy.$jobAction(handle, connectionUri, jobName, action);
 			},
-			deleteJob(connectionUri: string, jobInfo: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> {
+			deleteJob(connectionUri: string, jobInfo: azdata.AgentJobInfo): Thenable<azdata.ResultStatus> {
 				return self._proxy.$deleteJob(handle, connectionUri, jobInfo);
 			},
-			deleteJobStep(connectionUri: string, stepInfo: sqlops.AgentJobStepInfo): Thenable<sqlops.ResultStatus> {
+			deleteJobStep(connectionUri: string, stepInfo: azdata.AgentJobStepInfo): Thenable<azdata.ResultStatus> {
 				return self._proxy.$deleteJobStep(handle, connectionUri, stepInfo);
 			},
-			getAlerts(connectionUri: string): Thenable<sqlops.AgentAlertsResult> {
+			getAlerts(connectionUri: string): Thenable<azdata.AgentAlertsResult> {
 				return self._proxy.$getAlerts(handle, connectionUri);
 			},
-			deleteAlert(connectionUri: string, alertInfo: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> {
+			deleteAlert(connectionUri: string, alertInfo: azdata.AgentAlertInfo): Thenable<azdata.ResultStatus> {
 				return self._proxy.$deleteAlert(handle, connectionUri, alertInfo);
 			},
-			getOperators(connectionUri: string): Thenable<sqlops.AgentOperatorsResult> {
+			getOperators(connectionUri: string): Thenable<azdata.AgentOperatorsResult> {
 				return self._proxy.$getOperators(handle, connectionUri);
 			},
-			deleteOperator(connectionUri: string, operatorInfo: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> {
+			deleteOperator(connectionUri: string, operatorInfo: azdata.AgentOperatorInfo): Thenable<azdata.ResultStatus> {
 				return self._proxy.$deleteOperator(handle, connectionUri, operatorInfo);
 			},
-			getProxies(connectionUri: string): Thenable<sqlops.AgentProxiesResult> {
+			getProxies(connectionUri: string): Thenable<azdata.AgentProxiesResult> {
 				return self._proxy.$getProxies(handle, connectionUri);
 			},
-			deleteProxy(connectionUri: string, proxyInfo: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus> {
+			deleteProxy(connectionUri: string, proxyInfo: azdata.AgentProxyInfo): Thenable<azdata.ResultStatus> {
 				return self._proxy.$deleteProxy(handle, connectionUri, proxyInfo);
 			},
-			getCredentials(connectionUri: string): Thenable<sqlops.GetCredentialsResult> {
+			getCredentials(connectionUri: string): Thenable<azdata.GetCredentialsResult> {
 				return self._proxy.$getCredentials(handle, connectionUri);
 			}
 		});
@@ -419,8 +419,8 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerCapabilitiesServiceProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._capabilitiesService.registerProvider(<sqlops.CapabilitiesProvider>{
-			getServerCapabilities(client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> {
+		this._capabilitiesService.registerProvider(<azdata.CapabilitiesProvider>{
+			getServerCapabilities(client: azdata.DataProtocolClientCapabilities): Thenable<azdata.DataProtocolServerCapabilities> {
 				return self._proxy.$getServerCapabilities(handle, client);
 			}
 		});
@@ -430,23 +430,23 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 
 	public $registerDacFxServicesProvider(providerId: string, handle: number): TPromise<any> {
 		const self = this;
-		this._dacFxService.registerProvider(providerId, <sqlops.DacFxServicesProvider>{
-			exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+		this._dacFxService.registerProvider(providerId, <azdata.DacFxServicesProvider>{
+			exportBacpac(databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> {
 				return self._proxy.$exportBacpac(handle, databaseName, packageFilePath, ownerUri, taskExecutionMode);
 			},
-			importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+			importBacpac(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> {
 				return self._proxy.$importBacpac(handle, packageFilePath, databaseName, ownerUri, taskExecutionMode);
 			},
-			extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+			extractDacpac(databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> {
 				return self._proxy.$extractDacpac(handle, databaseName, packageFilePath, applicationName, applicationVersion, ownerUri, taskExecutionMode);
 			},
-			deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+			deployDacpac(packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> {
 				return self._proxy.$deployDacpac(handle, packageFilePath, databaseName, upgradeExisting, ownerUri, taskExecutionMode);
 			},
-			generateDeployScript(packageFilePath: string, databaseName: string, scriptFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> {
+			generateDeployScript(packageFilePath: string, databaseName: string, scriptFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> {
 				return self._proxy.$generateDeployScript(handle, packageFilePath, databaseName, scriptFilePath, ownerUri, taskExecutionMode);
 			},
-			generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.GenerateDeployPlanResult> {
+			generateDeployPlan(packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.GenerateDeployPlanResult> {
 				return self._proxy.$generateDeployPlan(handle, packageFilePath, databaseName, ownerUri, taskExecutionMode);
 			}
 		});
@@ -455,7 +455,7 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 	}
 
 	// Connection Management handlers
-	public $onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
+	public $onConnectionComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void {
 		this._connectionManagementService.onConnectionComplete(handle, connectionInfoSummary);
 	}
 
@@ -463,27 +463,27 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 		this._connectionManagementService.onIntelliSenseCacheComplete(handle, connectionUri);
 	}
 
-	public $onConnectionChangeNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
+	public $onConnectionChangeNotification(handle: number, changedConnInfo: azdata.ChangedConnectionInfo): void {
 		this._connectionManagementService.onConnectionChangedNotification(handle, changedConnInfo);
 	}
 
 	// Query Management handlers
-	public $onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void {
+	public $onQueryComplete(handle: number, result: azdata.QueryExecuteCompleteNotificationResult): void {
 		this._queryManagementService.onQueryComplete(result);
 	}
-	public $onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
+	public $onBatchStart(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void {
 		this._queryManagementService.onBatchStart(batchInfo);
 	}
-	public $onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void {
+	public $onBatchComplete(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void {
 		this._queryManagementService.onBatchComplete(batchInfo);
 	}
-	public $onResultSetAvailable(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void {
+	public $onResultSetAvailable(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void {
 		this._queryManagementService.onResultSetAvailable(resultSetInfo);
 	}
-	public $onResultSetUpdated(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void {
+	public $onResultSetUpdated(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void {
 		this._queryManagementService.onResultSetUpdated(resultSetInfo);
 	}
-	public $onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void {
+	public $onQueryMessage(handle: number, message: azdata.QueryExecuteMessageParams): void {
 		this._queryManagementService.onMessage(message);
 	}
 	public $onEditSessionReady(handle: number, ownerUri: string, success: boolean, message: string): void {
@@ -491,56 +491,56 @@ export class MainThreadDataProtocol implements MainThreadDataProtocolShape {
 	}
 
 	// Script Handlers
-	public $onScriptingComplete(handle: number, scriptingCompleteResult: sqlops.ScriptingCompleteResult): void {
+	public $onScriptingComplete(handle: number, scriptingCompleteResult: azdata.ScriptingCompleteResult): void {
 		this._scriptingService.onScriptingComplete(handle, scriptingCompleteResult);
 	}
 
 	//OE handlers
-	public $onObjectExplorerSessionCreated(handle: number, sessionResponse: sqlops.ObjectExplorerSession): void {
+	public $onObjectExplorerSessionCreated(handle: number, sessionResponse: azdata.ObjectExplorerSession): void {
 		this._objectExplorerService.onSessionCreated(handle, sessionResponse);
 	}
 
-	public $onObjectExplorerSessionDisconnected(handle: number, sessionResponse: sqlops.ObjectExplorerSession): void {
+	public $onObjectExplorerSessionDisconnected(handle: number, sessionResponse: azdata.ObjectExplorerSession): void {
 		this._objectExplorerService.onSessionDisconnected(handle, sessionResponse);
 	}
 
-	public $onObjectExplorerNodeExpanded(providerId: string, expandResponse: sqlops.ObjectExplorerExpandInfo): void {
+	public $onObjectExplorerNodeExpanded(providerId: string, expandResponse: azdata.ObjectExplorerExpandInfo): void {
 		let expandInfo: NodeExpandInfoWithProviderId = Object.assign({ providerId: providerId }, expandResponse);
 		this._objectExplorerService.onNodeExpanded(expandInfo);
 	}
 
 	//Tasks handlers
-	public $onTaskCreated(handle: number, taskInfo: sqlops.TaskInfo): void {
+	public $onTaskCreated(handle: number, taskInfo: azdata.TaskInfo): void {
 		this._taskService.onNewTaskCreated(handle, taskInfo);
 	}
 
-	public $onTaskStatusChanged(handle: number, taskProgressInfo: sqlops.TaskProgressInfo): void {
+	public $onTaskStatusChanged(handle: number, taskProgressInfo: azdata.TaskProgressInfo): void {
 		this._taskService.onTaskStatusChanged(handle, taskProgressInfo);
 	}
 
 	//File browser handlers
-	public $onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void {
+	public $onFileBrowserOpened(handle: number, response: azdata.FileBrowserOpenedParams): void {
 		this._fileBrowserService.onFileBrowserOpened(handle, response);
 	}
 
-	public $onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void {
+	public $onFolderNodeExpanded(handle: number, response: azdata.FileBrowserExpandedParams): void {
 		this._fileBrowserService.onFolderNodeExpanded(handle, response);
 	}
 
-	public $onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams): void {
+	public $onFilePathsValidated(handle: number, response: azdata.FileBrowserValidatedParams): void {
 		this._fileBrowserService.onFilePathsValidated(handle, response);
 	}
 
 	// Profiler handlers
-	public $onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void {
+	public $onSessionEventsAvailable(handle: number, response: azdata.ProfilerSessionEvents): void {
 		this._profilerService.onMoreRows(response);
 	}
 
-	public $onSessionStopped(handle: number, response: sqlops.ProfilerSessionStoppedParams): void {
+	public $onSessionStopped(handle: number, response: azdata.ProfilerSessionStoppedParams): void {
 		this._profilerService.onSessionStopped(response);
 	}
 
-	public $onProfilerSessionCreated(handle: number, response: sqlops.ProfilerSessionCreatedParams): void {
+	public $onProfilerSessionCreated(handle: number, response: azdata.ProfilerSessionCreatedParams): void {
 		this._profilerService.onProfilerSessionCreated(response);
 	}
 

src/sql/workbench/api/node/mainThreadModelViewDialog.ts

@@ -16,7 +16,7 @@ import { IModelViewDialogDetails, IModelViewTabDetails, IModelViewButtonDetails,
 import { ModelViewInput, ModelViewInputModel, ModeViewSaveHandler } from 'sql/parts/modelComponents/modelEditor/modelViewInput';
 
 import * as vscode from 'vscode';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
 
 @extHostNamedCustomer(SqlMainContext.MainThreadModelViewDialog)
@@ -45,7 +45,7 @@ export class MainThreadModelViewDialog implements MainThreadModelViewDialogShape
 		throw new Error('Method not implemented.');
 	}
 
-	public $openEditor(handle: number, modelViewId: string, title: string, options?: sqlops.ModelViewEditorOptions, position?: vscode.ViewColumn): Thenable<void> {
+	public $openEditor(handle: number, modelViewId: string, title: string, options?: azdata.ModelViewEditorOptions, position?: vscode.ViewColumn): Thenable<void> {
 		return new Promise<void>((resolve, reject) => {
 			let saveHandler: ModeViewSaveHandler = options && options.supportsSave ? (h) => this.handleSave(h) : undefined;
 			let model = new ModelViewInputModel(modelViewId, handle, saveHandler);
@@ -286,7 +286,7 @@ export class MainThreadModelViewDialog implements MainThreadModelViewDialogShape
 		this._proxy.$updateWizardPageInfo(handle, wizard.pages.map(page => this._wizardPageHandles.get(page)), wizard.currentPage);
 	}
 
-	private validateNavigation(handle: number, info: sqlops.window.WizardPageChangeInfo): Thenable<boolean> {
+	private validateNavigation(handle: number, info: azdata.window.WizardPageChangeInfo): Thenable<boolean> {
 		return this._proxy.$validateNavigation(handle, info);
 	}
 

src/sql/workbench/api/node/mainThreadNotebook.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { SqlExtHostContext, SqlMainContext, ExtHostNotebookShape, MainThreadNotebookShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { Disposable } from 'vs/base/common/lifecycle';
@@ -63,7 +63,7 @@ export class MainThreadNotebook extends Disposable implements MainThreadNotebook
 		}
 	}
 
-	public $onFutureMessage(futureId: number, type: FutureMessageType, payload: sqlops.nb.IMessage): void {
+	public $onFutureMessage(futureId: number, type: FutureMessageType, payload: azdata.nb.IMessage): void {
 		let future = this._futures.get(futureId);
 		if (future) {
 			future.onMessage(type, payload);
@@ -115,9 +115,9 @@ class NotebookProviderWrapper extends Disposable implements INotebookProvider {
 }
 
 class NotebookManagerWrapper implements INotebookManager {
-	private _sessionManager: sqlops.nb.SessionManager;
-	private _contentManager: sqlops.nb.ContentManager;
-	private _serverManager: sqlops.nb.ServerManager;
+	private _sessionManager: azdata.nb.SessionManager;
+	private _contentManager: azdata.nb.ContentManager;
+	private _serverManager: azdata.nb.ServerManager;
 	private managerDetails: INotebookManagerDetails;
 
 	constructor(private _proxy: Proxies,
@@ -134,13 +134,13 @@ class NotebookManagerWrapper implements INotebookManager {
 		return this;
 	}
 
-	public get sessionManager(): sqlops.nb.SessionManager {
+	public get sessionManager(): azdata.nb.SessionManager {
 		return this._sessionManager;
 	}
-	public get contentManager(): sqlops.nb.ContentManager {
+	public get contentManager(): azdata.nb.ContentManager {
 		return this._contentManager;
 	}
-	public get serverManager(): sqlops.nb.ServerManager {
+	public get serverManager(): azdata.nb.ServerManager {
 		return this._serverManager;
 	}
 
@@ -149,20 +149,20 @@ class NotebookManagerWrapper implements INotebookManager {
 	}
 }
 
-class ContentManagerWrapper implements sqlops.nb.ContentManager {
+class ContentManagerWrapper implements azdata.nb.ContentManager {
 
 	constructor(private handle: number, private _proxy: Proxies) {
 	}
-	getNotebookContents(notebookUri: URI): Thenable<sqlops.nb.INotebookContents> {
+	getNotebookContents(notebookUri: URI): Thenable<azdata.nb.INotebookContents> {
 		return this._proxy.ext.$getNotebookContents(this.handle, notebookUri);
 	}
 
-	save(path: URI, notebook: sqlops.nb.INotebookContents): Thenable<sqlops.nb.INotebookContents> {
+	save(path: URI, notebook: azdata.nb.INotebookContents): Thenable<azdata.nb.INotebookContents> {
 		return this._proxy.ext.$save(this.handle, path, notebook);
 	}
 }
 
-class ServerManagerWrapper implements sqlops.nb.ServerManager {
+class ServerManagerWrapper implements azdata.nb.ServerManager {
 	private onServerStartedEmitter = new Emitter<void>();
 	private _isStarted: boolean;
 	constructor(private handle: number, private _proxy: Proxies) {
@@ -201,10 +201,10 @@ class ServerManagerWrapper implements sqlops.nb.ServerManager {
 	}
 }
 
-class SessionManagerWrapper implements sqlops.nb.SessionManager {
+class SessionManagerWrapper implements azdata.nb.SessionManager {
 	private readyPromise: Promise<void>;
 	private _isReady: boolean;
-	private _specs: sqlops.nb.IAllKernels;
+	private _specs: azdata.nb.IAllKernels;
 	constructor(private managerHandle: number, private _proxy: Proxies) {
 		this._isReady = false;
 		this.readyPromise = this.initializeSessionManager();
@@ -218,15 +218,15 @@ class SessionManagerWrapper implements sqlops.nb.SessionManager {
 		return this.readyPromise;
 	}
 
-	get specs(): sqlops.nb.IAllKernels {
+	get specs(): azdata.nb.IAllKernels {
 		return this._specs;
 	}
 
-	startNew(options: sqlops.nb.ISessionOptions): Thenable<sqlops.nb.ISession> {
+	startNew(options: azdata.nb.ISessionOptions): Thenable<azdata.nb.ISession> {
 		return this.doStartNew(options);
 	}
 
-	private async doStartNew(options: sqlops.nb.ISessionOptions): Promise<sqlops.nb.ISession> {
+	private async doStartNew(options: azdata.nb.ISessionOptions): Promise<azdata.nb.ISession> {
 		let sessionDetails = await this._proxy.ext.$startNewSession(this.managerHandle, options);
 		return new SessionWrapper(this._proxy, sessionDetails);
 	}
@@ -248,7 +248,7 @@ class SessionManagerWrapper implements sqlops.nb.SessionManager {
 	}
 }
 
-class SessionWrapper implements sqlops.nb.ISession {
+class SessionWrapper implements azdata.nb.ISession {
 	private _kernel: KernelWrapper;
 	constructor(private _proxy: Proxies, private sessionDetails: INotebookSessionDetails) {
 		if (sessionDetails && sessionDetails.kernelDetails) {
@@ -276,48 +276,48 @@ class SessionWrapper implements sqlops.nb.ISession {
 		return this.sessionDetails.type;
 	}
 
-	get status(): sqlops.nb.KernelStatus {
-		return this.sessionDetails.status as sqlops.nb.KernelStatus;
+	get status(): azdata.nb.KernelStatus {
+		return this.sessionDetails.status as azdata.nb.KernelStatus;
 	}
 
-	get kernel(): sqlops.nb.IKernel {
+	get kernel(): azdata.nb.IKernel {
 		return this._kernel;
 	}
 
-	changeKernel(kernelInfo: sqlops.nb.IKernelSpec): Thenable<sqlops.nb.IKernel> {
+	changeKernel(kernelInfo: azdata.nb.IKernelSpec): Thenable<azdata.nb.IKernel> {
 		return this.doChangeKernel(kernelInfo);
 	}
 
-	configureKernel(kernelInfo: sqlops.nb.IKernelSpec): Thenable<void> {
+	configureKernel(kernelInfo: azdata.nb.IKernelSpec): Thenable<void> {
 		return this.doConfigureKernel(kernelInfo);
 	}
 
-	configureConnection(connection: sqlops.IConnectionProfile): Thenable<void> {
+	configureConnection(connection: azdata.IConnectionProfile): Thenable<void> {
 		if (connection['capabilitiesService'] !== undefined) {
 			connection['capabilitiesService'] = undefined;
 		}
 		return this.doConfigureConnection(connection);
 	}
 
-	private async doChangeKernel(kernelInfo: sqlops.nb.IKernelSpec): Promise<sqlops.nb.IKernel> {
+	private async doChangeKernel(kernelInfo: azdata.nb.IKernelSpec): Promise<azdata.nb.IKernel> {
 		let kernelDetails = await this._proxy.ext.$changeKernel(this.sessionDetails.sessionId, kernelInfo);
 		this._kernel = new KernelWrapper(this._proxy, kernelDetails);
 		return this._kernel;
 	}
 
-	private async doConfigureKernel(kernelInfo: sqlops.nb.IKernelSpec): Promise<void> {
+	private async doConfigureKernel(kernelInfo: azdata.nb.IKernelSpec): Promise<void> {
 		await this._proxy.ext.$configureKernel(this.sessionDetails.sessionId, kernelInfo);
 	}
 
-	private async doConfigureConnection(connection: sqlops.IConnectionProfile): Promise<void> {
+	private async doConfigureConnection(connection: azdata.IConnectionProfile): Promise<void> {
 		await this._proxy.ext.$configureConnection(this.sessionDetails.sessionId, connection);
 	}
 }
 
-class KernelWrapper implements sqlops.nb.IKernel {
+class KernelWrapper implements azdata.nb.IKernel {
 	private _isReady: boolean = false;
 	private _ready = new Deferred<void>();
-	private _info: sqlops.nb.IInfoReply;
+	private _info: azdata.nb.IInfoReply;
 	constructor(private _proxy: Proxies, private kernelDetails: INotebookKernelDetails) {
 		this.initialize(kernelDetails);
 	}
@@ -352,19 +352,19 @@ class KernelWrapper implements sqlops.nb.IKernel {
 		return this.kernelDetails.supportsIntellisense;
 	}
 
-	get info(): sqlops.nb.IInfoReply {
+	get info(): azdata.nb.IInfoReply {
 		return this._info;
 	}
 
-	getSpec(): Thenable<sqlops.nb.IKernelSpec> {
+	getSpec(): Thenable<azdata.nb.IKernelSpec> {
 		return this._proxy.ext.$getKernelSpec(this.kernelDetails.kernelId);
 	}
 
-	requestComplete(content: sqlops.nb.ICompleteRequest): Thenable<sqlops.nb.ICompleteReplyMsg> {
+	requestComplete(content: azdata.nb.ICompleteRequest): Thenable<azdata.nb.ICompleteReplyMsg> {
 		return this._proxy.ext.$requestComplete(this.kernelDetails.kernelId, content);
 	}
 
-	requestExecute(content: sqlops.nb.IExecuteRequest, disposeOnDone?: boolean): sqlops.nb.IFuture {
+	requestExecute(content: azdata.nb.IExecuteRequest, disposeOnDone?: boolean): azdata.nb.IFuture {
 		let future = new FutureWrapper(this._proxy);
 		this._proxy.ext.$requestExecute(this.kernelDetails.kernelId, content, disposeOnDone)
 			.then(details => {
@@ -383,9 +383,9 @@ class KernelWrapper implements sqlops.nb.IKernel {
 
 class FutureWrapper implements FutureInternal {
 	private _futureId: number;
-	private _done = new Deferred<sqlops.nb.IShellMessage>();
-	private _messageHandlers = new Map<FutureMessageType, sqlops.nb.MessageHandler<sqlops.nb.IMessage>>();
-	private _msg: sqlops.nb.IMessage;
+	private _done = new Deferred<azdata.nb.IShellMessage>();
+	private _messageHandlers = new Map<FutureMessageType, azdata.nb.MessageHandler<azdata.nb.IMessage>>();
+	private _msg: azdata.nb.IMessage;
 	private _inProgress: boolean;
 
 	constructor(private _proxy: Proxies) {
@@ -401,7 +401,7 @@ class FutureWrapper implements FutureInternal {
 		this._done.reject(error);
 	}
 
-	public onMessage(type: FutureMessageType, payload: sqlops.nb.IMessage): void {
+	public onMessage(type: FutureMessageType, payload: azdata.nb.IMessage): void {
 		let handler = this._messageHandlers.get(type);
 		if (handler) {
 			try {
@@ -421,7 +421,7 @@ class FutureWrapper implements FutureInternal {
 		}
 	}
 
-	private addMessageHandler(type: FutureMessageType, handler: sqlops.nb.MessageHandler<sqlops.nb.IMessage>): void {
+	private addMessageHandler(type: FutureMessageType, handler: azdata.nb.MessageHandler<azdata.nb.IMessage>): void {
 		// Note: there can only be 1 message handler according to the Jupyter Notebook spec.
 		// You can use a message hook to override this / add additional side-processors
 		this._messageHandlers.set(type, handler);
@@ -436,27 +436,27 @@ class FutureWrapper implements FutureInternal {
 		this._inProgress = value;
 	}
 
-	get msg(): sqlops.nb.IMessage {
+	get msg(): azdata.nb.IMessage {
 		return this._msg;
 	}
 
-	get done(): Thenable<sqlops.nb.IShellMessage> {
+	get done(): Thenable<azdata.nb.IShellMessage> {
 		return this._done.promise;
 	}
 
-	setReplyHandler(handler: sqlops.nb.MessageHandler<sqlops.nb.IShellMessage>): void {
+	setReplyHandler(handler: azdata.nb.MessageHandler<azdata.nb.IShellMessage>): void {
 		this.addMessageHandler(FutureMessageType.Reply, handler);
 	}
 
-	setStdInHandler(handler: sqlops.nb.MessageHandler<sqlops.nb.IStdinMessage>): void {
+	setStdInHandler(handler: azdata.nb.MessageHandler<azdata.nb.IStdinMessage>): void {
 		this.addMessageHandler(FutureMessageType.StdIn, handler);
 	}
 
-	setIOPubHandler(handler: sqlops.nb.MessageHandler<sqlops.nb.IIOPubMessage>): void {
+	setIOPubHandler(handler: azdata.nb.MessageHandler<azdata.nb.IIOPubMessage>): void {
 		this.addMessageHandler(FutureMessageType.IOPub, handler);
 	}
 
-	sendInputReply(content: sqlops.nb.IInputReply): void {
+	sendInputReply(content: azdata.nb.IInputReply): void {
 		this._proxy.ext.$sendInputReply(this._futureId, content);
 	}
 
@@ -465,10 +465,10 @@ class FutureWrapper implements FutureInternal {
 		this._proxy.ext.$disposeFuture(this._futureId);
 	}
 
-	registerMessageHook(hook: (msg: sqlops.nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+	registerMessageHook(hook: (msg: azdata.nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
 		throw new Error('Method not implemented.');
 	}
-	removeMessageHook(hook: (msg: sqlops.nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
+	removeMessageHook(hook: (msg: azdata.nb.IIOPubMessage) => boolean | Thenable<boolean>): void {
 		throw new Error('Method not implemented.');
 	}
 	//#endregion

src/sql/workbench/api/node/mainThreadNotebookDocumentsAndEditors.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
 import { URI, UriComponents } from 'vs/base/common/uri';
@@ -529,13 +529,13 @@ export class MainThreadNotebookDocumentsAndEditors extends Disposable implements
 		return changeData;
 	}
 
-	private getKernelSpec(editor: MainThreadNotebookEditor): sqlops.nb.IKernelSpec {
+	private getKernelSpec(editor: MainThreadNotebookEditor): azdata.nb.IKernelSpec {
 		let spec = editor && editor.model && editor.model.clientSession ? editor.model.clientSession.cachedKernelSpec : undefined;
 		return spec;
 	}
 
-	private convertCellModelToNotebookCell(cells: ICellModel | ICellModel[]): sqlops.nb.NotebookCell[] {
-		let notebookCells: sqlops.nb.NotebookCell[] = [];
+	private convertCellModelToNotebookCell(cells: ICellModel | ICellModel[]): azdata.nb.NotebookCell[] {
+		let notebookCells: azdata.nb.NotebookCell[] = [];
 		if (Array.isArray(cells)) {
 			for (let cell of cells) {
 				notebookCells.push({

src/sql/workbench/api/node/mainThreadObjectExplorer.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import { SqlExtHostContext, SqlMainContext, ExtHostObjectExplorerShape, MainThreadObjectExplorerShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
@@ -39,7 +39,7 @@ export class MainThreadObjectExplorer implements MainThreadObjectExplorerShape {
 		this._toDispose = dispose(this._toDispose);
 	}
 
-	public $getNode(connectionId: string, nodePath?: string): Thenable<sqlops.NodeInfo> {
+	public $getNode(connectionId: string, nodePath?: string): Thenable<azdata.NodeInfo> {
 		return this._objectExplorerService.getTreeNode(connectionId, nodePath).then(treeNode => {
 			if (!treeNode) {
 				return undefined;
@@ -63,7 +63,7 @@ export class MainThreadObjectExplorer implements MainThreadObjectExplorerShape {
 		return this._objectExplorerService.getTreeNode(connectionId, nodePath).then(treeNode => treeNode.setSelected(selected, clearOtherSelections));
 	}
 
-	public $getChildren(connectionId: string, nodePath: string): Thenable<sqlops.NodeInfo[]> {
+	public $getChildren(connectionId: string, nodePath: string): Thenable<azdata.NodeInfo[]> {
 		return this._objectExplorerService.getTreeNode(connectionId, nodePath).then(treeNode => treeNode.getChildren().then(children => children.map(node => node.toNodeInfo())));
 	}
 
@@ -71,19 +71,19 @@ export class MainThreadObjectExplorer implements MainThreadObjectExplorerShape {
 		return this._objectExplorerService.getTreeNode(connectionId, nodePath).then(treeNode => treeNode.isExpanded());
 	}
 
-	public $findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<sqlops.NodeInfo[]> {
+	public $findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<azdata.NodeInfo[]> {
 		return this._objectExplorerService.findNodes(connectionId, type, schema, name, database, parentObjectNames);
 	}
 
-	public $refresh(connectionId: string, nodePath: string): Thenable<sqlops.NodeInfo> {
+	public $refresh(connectionId: string, nodePath: string): Thenable<azdata.NodeInfo> {
 		return this._objectExplorerService.refreshNodeInView(connectionId, nodePath).then(node => node.toNodeInfo());
 	}
 
 	public $getNodeActions(connectionId: string, nodePath: string): Thenable<string[]> {
 		return this._objectExplorerService.getNodeActions(connectionId, nodePath);
 	}
-	
-	public $getSessionConnectionProfile(sessionId: string): Thenable<sqlops.IConnectionProfile> {
+
+	public $getSessionConnectionProfile(sessionId: string): Thenable<azdata.IConnectionProfile> {
 		return Promise.resolve(this._objectExplorerService.getSessionConnectionProfile(sessionId));
 	}
 }

src/sql/workbench/api/node/mainThreadResourceProvider.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IResourceProviderService } from 'sql/workbench/services/resourceProvider/common/resourceProviderService';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
@@ -20,7 +20,7 @@ import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostC
 
 @extHostNamedCustomer(SqlMainContext.MainThreadResourceProvider)
 export class MainThreadResourceProvider implements MainThreadResourceProviderShape {
-	private _providerMetadata: { [handle: number]: sqlops.AccountProviderMetadata };
+	private _providerMetadata: { [handle: number]: azdata.AccountProviderMetadata };
 	private _proxy: ExtHostResourceProviderShape;
 	private _toDispose: IDisposable[];
 
@@ -35,15 +35,15 @@ export class MainThreadResourceProvider implements MainThreadResourceProviderSha
 		this._toDispose = [];
 	}
 
-	public $registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, handle: number): Thenable<any> {
+	public $registerResourceProvider(providerMetadata: azdata.ResourceProviderMetadata, handle: number): Thenable<any> {
 		let self = this;
 
 		// Create the account provider that interfaces with the extension via the proxy and register it
-		let resourceProvider: sqlops.ResourceProvider = {
-			createFirewallRule(account: sqlops.Account, firewallruleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> {
+		let resourceProvider: azdata.ResourceProvider = {
+			createFirewallRule(account: azdata.Account, firewallruleInfo: azdata.FirewallRuleInfo): Thenable<azdata.CreateFirewallRuleResponse> {
 				return self._proxy.$createFirewallRule(handle, account, firewallruleInfo);
 			},
-			handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> {
+			handleFirewallRule(errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<azdata.HandleFirewallRuleResponse> {
 				return self._proxy.$handleFirewallRule(handle, errorCode, errorMessage, connectionTypeId);
 			}
 		};

src/sql/workbench/api/node/mainThreadSerializationProvider.ts

@@ -11,7 +11,7 @@ import {
 	MainThreadSerializationProviderShape, SqlMainContext
 } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { ISerializationService } from 'sql/platform/serialization/common/serializationService';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { IExtHostContext } from 'vs/workbench/api/node/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 
@@ -42,7 +42,7 @@ export class MainThreadSerializationProvider implements MainThreadSerializationP
 		let self = this;
 
 		this._registrations[handle] = this.serializationService.addEventListener(handle, {
-			onSaveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> {
+			onSaveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<azdata.SaveResultRequestResult> {
 				return self._proxy.$saveAs(saveFormat, savePath, results, appendToFile);
 			}
 		});

src/sql/workbench/api/node/sqlExtHost.api.impl.ts

@@ -99,16 +99,16 @@ export function createApiFactory(
 				},
 
 				// "sqlops" back-compat APIs
-				getActiveConnections(): Thenable<sqlops.connection.Connection[]> {
+				getActiveConnections(): Thenable<azdata.connection.Connection[]> {
 					return extHostConnectionManagement.$getActiveConnections();
 				},
 				getCredentials(connectionId: string): Thenable<{ [name: string]: string }> {
 					return extHostConnectionManagement.$getCredentials(connectionId);
 				},
-				getServerInfo(connectionId: string): Thenable<sqlops.ServerInfo> {
+				getServerInfo(connectionId: string): Thenable<azdata.ServerInfo> {
 					return extHostConnectionManagement.$getServerInfo(connectionId);
 				},
-				openConnectionDialog(providers?: string[], initialConnectionProfile?: sqlops.IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Thenable<sqlops.connection.Connection> {
+				openConnectionDialog(providers?: string[], initialConnectionProfile?: azdata.IConnectionProfile, connectionCompletionOptions?: azdata.IConnectionCompletionOptions): Thenable<azdata.connection.Connection> {
 					return extHostConnectionManagement.$openConnectionDialog(providers, initialConnectionProfile, connectionCompletionOptions);
 				},
 				listDatabases(connectionId: string): Thenable<string[]> {
@@ -120,15 +120,15 @@ export function createApiFactory(
 				getUriForConnection(connectionId: string): Thenable<string> {
 					return extHostConnectionManagement.$getUriForConnection(connectionId);
 				},
-				connect(connectionProfile: sqlops.IConnectionProfile): Thenable<sqlops.ConnectionResult> {
+				connect(connectionProfile: azdata.IConnectionProfile): Thenable<azdata.ConnectionResult> {
 					return extHostConnectionManagement.$connect(connectionProfile);
 				}
 			};
 
 			// Backcompat "sqlops" APIs
 			// namespace: accounts
-			const accounts: typeof sqlops.accounts = {
-				registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, provider: sqlops.AccountProvider): vscode.Disposable {
+			const accounts: typeof azdata.accounts = {
+				registerAccountProvider(providerMetadata: azdata.AccountProviderMetadata, provider: azdata.AccountProvider): vscode.Disposable {
 					return extHostAccountManagement.$registerAccountProvider(providerMetadata, provider);
 				},
 				beginAutoOAuthDeviceCode(providerId: string, title: string, message: string, userCode: string, uri: string): Thenable<void> {
@@ -137,66 +137,66 @@ export function createApiFactory(
 				endAutoOAuthDeviceCode(): void {
 					return extHostAccountManagement.$endAutoOAuthDeviceCode();
 				},
-				accountUpdated(updatedAccount: sqlops.Account): void {
+				accountUpdated(updatedAccount: azdata.Account): void {
 					return extHostAccountManagement.$accountUpdated(updatedAccount);
 				},
-				getAllAccounts(): Thenable<sqlops.Account[]> {
+				getAllAccounts(): Thenable<azdata.Account[]> {
 					return extHostAccountManagement.$getAllAccounts();
 				},
-				getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> {
+				getSecurityToken(account: azdata.Account, resource?: azdata.AzureResource): Thenable<{}> {
 					return extHostAccountManagement.$getSecurityToken(account, resource);
 				},
-				onDidChangeAccounts(listener: (e: sqlops.DidChangeAccountsParams) => void, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
+				onDidChangeAccounts(listener: (e: azdata.DidChangeAccountsParams) => void, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostAccountManagement.onDidChangeAccounts(listener, thisArgs, disposables);
 				}
 			};
 
 			// namespace: credentials
-			const credentials: typeof sqlops.credentials = {
-				registerProvider(provider: sqlops.CredentialProvider): vscode.Disposable {
+			const credentials: typeof azdata.credentials = {
+				registerProvider(provider: azdata.CredentialProvider): vscode.Disposable {
 					return extHostCredentialManagement.$registerCredentialProvider(provider);
 				},
-				getProvider(namespaceId: string): Thenable<sqlops.CredentialProvider> {
+				getProvider(namespaceId: string): Thenable<azdata.CredentialProvider> {
 					return extHostCredentialManagement.$getCredentialProvider(namespaceId);
 				}
 			};
 
 			// namespace: objectexplorer
-			const objectExplorer: typeof sqlops.objectexplorer = {
-				getNode(connectionId: string, nodePath?: string): Thenable<sqlops.objectexplorer.ObjectExplorerNode> {
+			const objectExplorer: typeof azdata.objectexplorer = {
+				getNode(connectionId: string, nodePath?: string): Thenable<azdata.objectexplorer.ObjectExplorerNode> {
 					return extHostObjectExplorer.$getNode(connectionId, nodePath);
 				},
-				getActiveConnectionNodes(): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
+				getActiveConnectionNodes(): Thenable<azdata.objectexplorer.ObjectExplorerNode[]> {
 					return extHostObjectExplorer.$getActiveConnectionNodes();
 				},
-				findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<sqlops.objectexplorer.ObjectExplorerNode[]> {
+				findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<azdata.objectexplorer.ObjectExplorerNode[]> {
 					return extHostObjectExplorer.$findNodes(connectionId, type, schema, name, database, parentObjectNames);
 				},
 				getNodeActions(connectionId: string, nodePath: string): Thenable<string[]> {
 					return extHostObjectExplorer.$getNodeActions(connectionId, nodePath);
 				},
-				getSessionConnectionProfile(sessionId: string): Thenable<sqlops.IConnectionProfile> {
+				getSessionConnectionProfile(sessionId: string): Thenable<azdata.IConnectionProfile> {
 					return extHostObjectExplorer.$getSessionConnectionProfile(sessionId);
 				}
 			};
 
 			// namespace: serialization
-			const serialization: typeof sqlops.serialization = {
-				registerProvider(provider: sqlops.SerializationProvider): vscode.Disposable {
+			const serialization: typeof azdata.serialization = {
+				registerProvider(provider: azdata.SerializationProvider): vscode.Disposable {
 					return extHostSerializationProvider.$registerSerializationProvider(provider);
 				},
 			};
 
 			// namespace: serialization
-			const resources: typeof sqlops.resources = {
-				registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, provider: sqlops.ResourceProvider): vscode.Disposable {
+			const resources: typeof azdata.resources = {
+				registerResourceProvider(providerMetadata: azdata.ResourceProviderMetadata, provider: azdata.ResourceProvider): vscode.Disposable {
 					return extHostResourceProvider.$registerResourceProvider(providerMetadata, provider);
 				}
 			};
 
-			let registerConnectionProvider = (provider: sqlops.ConnectionProvider): vscode.Disposable => {
+			let registerConnectionProvider = (provider: azdata.ConnectionProvider): vscode.Disposable => {
 				// Connection callbacks
-				provider.registerOnConnectionComplete((connSummary: sqlops.ConnectionInfoSummary) => {
+				provider.registerOnConnectionComplete((connSummary: azdata.ConnectionInfoSummary) => {
 					extHostDataProvider.$onConnectComplete(provider.handle, connSummary);
 				});
 
@@ -204,35 +204,35 @@ export function createApiFactory(
 					extHostDataProvider.$onIntelliSenseCacheComplete(provider.handle, connectionUri);
 				});
 
-				provider.registerOnConnectionChanged((changedConnInfo: sqlops.ChangedConnectionInfo) => {
+				provider.registerOnConnectionChanged((changedConnInfo: azdata.ChangedConnectionInfo) => {
 					extHostDataProvider.$onConnectionChanged(provider.handle, changedConnInfo);
 				});
 
 				return extHostDataProvider.$registerConnectionProvider(provider);
 			};
 
-			let registerQueryProvider = (provider: sqlops.QueryProvider): vscode.Disposable => {
-				provider.registerOnQueryComplete((result: sqlops.QueryExecuteCompleteNotificationResult) => {
+			let registerQueryProvider = (provider: azdata.QueryProvider): vscode.Disposable => {
+				provider.registerOnQueryComplete((result: azdata.QueryExecuteCompleteNotificationResult) => {
 					extHostDataProvider.$onQueryComplete(provider.handle, result);
 				});
 
-				provider.registerOnBatchStart((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
+				provider.registerOnBatchStart((batchInfo: azdata.QueryExecuteBatchNotificationParams) => {
 					extHostDataProvider.$onBatchStart(provider.handle, batchInfo);
 				});
 
-				provider.registerOnBatchComplete((batchInfo: sqlops.QueryExecuteBatchNotificationParams) => {
+				provider.registerOnBatchComplete((batchInfo: azdata.QueryExecuteBatchNotificationParams) => {
 					extHostDataProvider.$onBatchComplete(provider.handle, batchInfo);
 				});
 
-				provider.registerOnResultSetAvailable((resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams) => {
+				provider.registerOnResultSetAvailable((resultSetInfo: azdata.QueryExecuteResultSetNotificationParams) => {
 					extHostDataProvider.$onResultSetAvailable(provider.handle, resultSetInfo);
 				});
 
-				provider.registerOnResultSetUpdated((resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams) => {
+				provider.registerOnResultSetUpdated((resultSetInfo: azdata.QueryExecuteResultSetNotificationParams) => {
 					extHostDataProvider.$onResultSetUpdated(provider.handle, resultSetInfo);
 				});
 
-				provider.registerOnMessage((message: sqlops.QueryExecuteMessageParams) => {
+				provider.registerOnMessage((message: azdata.QueryExecuteMessageParams) => {
 					extHostDataProvider.$onQueryMessage(provider.handle, message);
 				});
 
@@ -243,105 +243,105 @@ export function createApiFactory(
 				return extHostDataProvider.$registerQueryProvider(provider);
 			};
 
-			let registerObjectExplorerProvider = (provider: sqlops.ObjectExplorerProvider): vscode.Disposable => {
-				provider.registerOnSessionCreated((response: sqlops.ObjectExplorerSession) => {
+			let registerObjectExplorerProvider = (provider: azdata.ObjectExplorerProvider): vscode.Disposable => {
+				provider.registerOnSessionCreated((response: azdata.ObjectExplorerSession) => {
 					extHostDataProvider.$onObjectExplorerSessionCreated(provider.handle, response);
 				});
 
 				if (provider.registerOnSessionDisconnected) {
-					provider.registerOnSessionDisconnected((response: sqlops.ObjectExplorerSession) => {
+					provider.registerOnSessionDisconnected((response: azdata.ObjectExplorerSession) => {
 						extHostDataProvider.$onObjectExplorerSessionDisconnected(provider.handle, response);
 					});
 				}
 
-				provider.registerOnExpandCompleted((response: sqlops.ObjectExplorerExpandInfo) => {
+				provider.registerOnExpandCompleted((response: azdata.ObjectExplorerExpandInfo) => {
 					extHostDataProvider.$onObjectExplorerNodeExpanded(provider.providerId, response);
 				});
 
 				return extHostDataProvider.$registerObjectExplorerProvider(provider);
 			};
 
-			let registerObjectExplorerNodeProvider = (provider: sqlops.ObjectExplorerNodeProvider): vscode.Disposable => {
-				provider.registerOnExpandCompleted((response: sqlops.ObjectExplorerExpandInfo) => {
+			let registerObjectExplorerNodeProvider = (provider: azdata.ObjectExplorerNodeProvider): vscode.Disposable => {
+				provider.registerOnExpandCompleted((response: azdata.ObjectExplorerExpandInfo) => {
 					extHostDataProvider.$onObjectExplorerNodeExpanded(provider.providerId, response);
 				});
 
 				return extHostDataProvider.$registerObjectExplorerNodeProvider(provider);
 			};
 
-			let registerTaskServicesProvider = (provider: sqlops.TaskServicesProvider): vscode.Disposable => {
-				provider.registerOnTaskCreated((response: sqlops.TaskInfo) => {
+			let registerTaskServicesProvider = (provider: azdata.TaskServicesProvider): vscode.Disposable => {
+				provider.registerOnTaskCreated((response: azdata.TaskInfo) => {
 					extHostDataProvider.$onTaskCreated(provider.handle, response);
 				});
 
-				provider.registerOnTaskStatusChanged((response: sqlops.TaskProgressInfo) => {
+				provider.registerOnTaskStatusChanged((response: azdata.TaskProgressInfo) => {
 					extHostDataProvider.$onTaskStatusChanged(provider.handle, response);
 				});
 
 				return extHostDataProvider.$registerTaskServicesProvider(provider);
 			};
 
-			let registerFileBrowserProvider = (provider: sqlops.FileBrowserProvider): vscode.Disposable => {
-				provider.registerOnFileBrowserOpened((response: sqlops.FileBrowserOpenedParams) => {
+			let registerFileBrowserProvider = (provider: azdata.FileBrowserProvider): vscode.Disposable => {
+				provider.registerOnFileBrowserOpened((response: azdata.FileBrowserOpenedParams) => {
 					extHostDataProvider.$onFileBrowserOpened(provider.handle, response);
 				});
 
-				provider.registerOnFolderNodeExpanded((response: sqlops.FileBrowserExpandedParams) => {
+				provider.registerOnFolderNodeExpanded((response: azdata.FileBrowserExpandedParams) => {
 					extHostDataProvider.$onFolderNodeExpanded(provider.handle, response);
 				});
 
-				provider.registerOnFilePathsValidated((response: sqlops.FileBrowserValidatedParams) => {
+				provider.registerOnFilePathsValidated((response: azdata.FileBrowserValidatedParams) => {
 					extHostDataProvider.$onFilePathsValidated(provider.handle, response);
 				});
 
 				return extHostDataProvider.$registerFileBrowserProvider(provider);
 			};
 
-			let registerScriptingProvider = (provider: sqlops.ScriptingProvider): vscode.Disposable => {
-				provider.registerOnScriptingComplete((response: sqlops.ScriptingCompleteResult) => {
+			let registerScriptingProvider = (provider: azdata.ScriptingProvider): vscode.Disposable => {
+				provider.registerOnScriptingComplete((response: azdata.ScriptingCompleteResult) => {
 					extHostDataProvider.$onScriptingComplete(provider.handle, response);
 				});
 
 				return extHostDataProvider.$registerScriptingProvider(provider);
 			};
 
-			let registerProfilerProvider = (provider: sqlops.ProfilerProvider): vscode.Disposable => {
-				provider.registerOnSessionEventsAvailable((response: sqlops.ProfilerSessionEvents) => {
+			let registerProfilerProvider = (provider: azdata.ProfilerProvider): vscode.Disposable => {
+				provider.registerOnSessionEventsAvailable((response: azdata.ProfilerSessionEvents) => {
 					extHostDataProvider.$onSessionEventsAvailable(provider.handle, response);
 				});
 
-				provider.registerOnSessionStopped((response: sqlops.ProfilerSessionStoppedParams) => {
+				provider.registerOnSessionStopped((response: azdata.ProfilerSessionStoppedParams) => {
 					extHostDataProvider.$onSessionStopped(provider.handle, response);
 				});
 
-				provider.registerOnProfilerSessionCreated((response: sqlops.ProfilerSessionCreatedParams) => {
+				provider.registerOnProfilerSessionCreated((response: azdata.ProfilerSessionCreatedParams) => {
 					extHostDataProvider.$onProfilerSessionCreated(provider.handle, response);
 				});
 
 				return extHostDataProvider.$registerProfilerProvider(provider);
 			};
 
-			let registerBackupProvider = (provider: sqlops.BackupProvider): vscode.Disposable => {
+			let registerBackupProvider = (provider: azdata.BackupProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerBackupProvider(provider);
 			};
 
-			let registerRestoreProvider = (provider: sqlops.RestoreProvider): vscode.Disposable => {
+			let registerRestoreProvider = (provider: azdata.RestoreProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerRestoreProvider(provider);
 			};
 
-			let registerMetadataProvider = (provider: sqlops.MetadataProvider): vscode.Disposable => {
+			let registerMetadataProvider = (provider: azdata.MetadataProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerMetadataProvider(provider);
 			};
 
-			let registerCapabilitiesServiceProvider = (provider: sqlops.CapabilitiesProvider): vscode.Disposable => {
+			let registerCapabilitiesServiceProvider = (provider: azdata.CapabilitiesProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerCapabilitiesServiceProvider(provider);
 			};
 
-			let registerAdminServicesProvider = (provider: sqlops.AdminServicesProvider): vscode.Disposable => {
+			let registerAdminServicesProvider = (provider: azdata.AdminServicesProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerAdminServicesProvider(provider);
 			};
 
-			let registerAgentServicesProvider = (provider: sqlops.AgentServicesProvider): vscode.Disposable => {
+			let registerAgentServicesProvider = (provider: azdata.AgentServicesProvider): vscode.Disposable => {
 				provider.registerOnUpdated(() => {
 					extHostDataProvider.$onJobDataUpdated(provider.handle);
 				});
@@ -349,12 +349,12 @@ export function createApiFactory(
 				return extHostDataProvider.$registerAgentServiceProvider(provider);
 			};
 
-			let registerDacFxServicesProvider = (provider: sqlops.DacFxServicesProvider): vscode.Disposable => {
+			let registerDacFxServicesProvider = (provider: azdata.DacFxServicesProvider): vscode.Disposable => {
 				return extHostDataProvider.$registerDacFxServiceProvider(provider);
 			};
 
 			// namespace: dataprotocol
-			const dataprotocol: typeof sqlops.dataprotocol = {
+			const dataprotocol: typeof azdata.dataprotocol = {
 				registerBackupProvider,
 				registerConnectionProvider,
 				registerFileBrowserProvider,
@@ -370,113 +370,113 @@ export function createApiFactory(
 				registerAgentServicesProvider,
 				registerCapabilitiesServiceProvider,
 				registerDacFxServicesProvider,
-				onDidChangeLanguageFlavor(listener: (e: sqlops.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
+				onDidChangeLanguageFlavor(listener: (e: azdata.DidChangeLanguageFlavorParams) => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) {
 					return extHostDataProvider.onDidChangeLanguageFlavor(listener, thisArgs, disposables);
 				},
-				getProvider<T extends sqlops.DataProvider>(providerId: string, providerType: sqlops.DataProviderType) {
+				getProvider<T extends azdata.DataProvider>(providerId: string, providerType: azdata.DataProviderType) {
 					return extHostDataProvider.getProvider<T>(providerId, providerType);
 				},
-				getProvidersByType<T extends sqlops.DataProvider>(providerType: sqlops.DataProviderType) {
+				getProvidersByType<T extends azdata.DataProvider>(providerType: azdata.DataProviderType) {
 					return extHostDataProvider.getProvidersByType<T>(providerType);
 				}
 			};
 
-			const modelViewDialog: typeof sqlops.window.modelviewdialog = {
-				createDialog(title: string, dialogName?: string): sqlops.window.modelviewdialog.Dialog {
-					console.warn('the method sqlops.window.modelviewdialog.createDialog has been deprecated, replace it with sqlops.window.createModelViewDialog');
+			const modelViewDialog: typeof azdata.window.modelviewdialog = {
+				createDialog(title: string, dialogName?: string): azdata.window.modelviewdialog.Dialog {
+					console.warn('the method azdata.window.modelviewdialog.createDialog has been deprecated, replace it with azdata.window.createModelViewDialog');
 					return extHostModelViewDialog.createDialog(title, dialogName, extension);
 				},
-				createTab(title: string): sqlops.window.modelviewdialog.DialogTab {
-					console.warn('the method sqlops.window.modelviewdialog.createTab has been deprecated, replace it with sqlops.window.createTab');
+				createTab(title: string): azdata.window.modelviewdialog.DialogTab {
+					console.warn('the method azdata.window.modelviewdialog.createTab has been deprecated, replace it with azdata.window.createTab');
 					return extHostModelViewDialog.createTab(title, extension);
 				},
-				createButton(label: string): sqlops.window.modelviewdialog.Button {
-					console.warn('the method sqlops.window.modelviewdialog.createButton has been deprecated, replace it with sqlops.window.createButton');
+				createButton(label: string): azdata.window.modelviewdialog.Button {
+					console.warn('the method azdata.window.modelviewdialog.createButton has been deprecated, replace it with azdata.window.createButton');
 					return extHostModelViewDialog.createButton(label);
 				},
-				openDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
-					console.warn('the method sqlops.window.modelviewdialog.openDialog has been deprecated, replace it with sqlops.window.openDialog');
+				openDialog(dialog: azdata.window.modelviewdialog.Dialog) {
+					console.warn('the method azdata.window.modelviewdialog.openDialog has been deprecated, replace it with azdata.window.openDialog');
 					return extHostModelViewDialog.openDialog(dialog);
 				},
-				closeDialog(dialog: sqlops.window.modelviewdialog.Dialog) {
-					console.warn('the method sqlops.window.modelviewdialog.closeDialog has been deprecated, replace it with sqlops.window.closeDialog');
+				closeDialog(dialog: azdata.window.modelviewdialog.Dialog) {
+					console.warn('the method azdata.window.modelviewdialog.closeDialog has been deprecated, replace it with azdata.window.closeDialog');
 					return extHostModelViewDialog.closeDialog(dialog);
 				},
-				createWizardPage(title: string): sqlops.window.modelviewdialog.WizardPage {
-					console.warn('the method sqlops.window.modelviewdialog.createWizardPage has been deprecated, replace it with sqlops.window.createWizardPage');
+				createWizardPage(title: string): azdata.window.modelviewdialog.WizardPage {
+					console.warn('the method azdata.window.modelviewdialog.createWizardPage has been deprecated, replace it with azdata.window.createWizardPage');
 					return extHostModelViewDialog.createWizardPage(title);
 				},
-				createWizard(title: string): sqlops.window.modelviewdialog.Wizard {
-					console.warn('the method sqlops.window.modelviewdialog.createWizard has been deprecated, replace it with sqlops.window.createWizard');
+				createWizard(title: string): azdata.window.modelviewdialog.Wizard {
+					console.warn('the method azdata.window.modelviewdialog.createWizard has been deprecated, replace it with azdata.window.createWizard');
 					return extHostModelViewDialog.createWizard(title);
 				},
 				MessageLevel: sqlExtHostTypes.MessageLevel
 			};
 
-			const window: typeof sqlops.window = {
+			const window: typeof azdata.window = {
 				createDialog(name: string) {
-					console.warn('the method sqlops.window.createDialog has been deprecated, replace it with sqlops.window.createWebViewDialog');
+					console.warn('the method azdata.window.createDialog has been deprecated, replace it with azdata.window.createWebViewDialog');
 					return extHostModalDialogs.createDialog(name);
 				},
 				modelviewdialog: modelViewDialog,
 				createWebViewDialog(name: string) {
 					return extHostModalDialogs.createDialog(name);
 				},
-				createModelViewDialog(title: string, dialogName?: string): sqlops.window.Dialog {
+				createModelViewDialog(title: string, dialogName?: string): azdata.window.Dialog {
 					return extHostModelViewDialog.createDialog(title, dialogName, extension);
 				},
-				createTab(title: string): sqlops.window.DialogTab {
+				createTab(title: string): azdata.window.DialogTab {
 					return extHostModelViewDialog.createTab(title, extension);
 				},
-				createButton(label: string): sqlops.window.Button {
+				createButton(label: string): azdata.window.Button {
 					return extHostModelViewDialog.createButton(label);
 				},
-				openDialog(dialog: sqlops.window.Dialog) {
+				openDialog(dialog: azdata.window.Dialog) {
 					return extHostModelViewDialog.openDialog(dialog);
 				},
-				closeDialog(dialog: sqlops.window.Dialog) {
+				closeDialog(dialog: azdata.window.Dialog) {
 					return extHostModelViewDialog.closeDialog(dialog);
 				},
-				createWizardPage(title: string): sqlops.window.WizardPage {
+				createWizardPage(title: string): azdata.window.WizardPage {
 					return extHostModelViewDialog.createWizardPage(title);
 				},
-				createWizard(title: string): sqlops.window.Wizard {
+				createWizard(title: string): azdata.window.Wizard {
 					return extHostModelViewDialog.createWizard(title);
 				},
 				MessageLevel: sqlExtHostTypes.MessageLevel
 			};
 
-			const tasks: typeof sqlops.tasks = {
+			const tasks: typeof azdata.tasks = {
 				registerTask(id: string, task: (...args: any[]) => any, thisArgs?: any): vscode.Disposable {
 					return extHostTasks.registerTask(id, task, thisArgs);
 				},
-				startBackgroundOperation(operationInfo: sqlops.BackgroundOperationInfo): void {
+				startBackgroundOperation(operationInfo: azdata.BackgroundOperationInfo): void {
 					extHostBackgroundTaskManagement.$registerTask(operationInfo);
 				}
 			};
 
-			const workspace: typeof sqlops.workspace = {
+			const workspace: typeof azdata.workspace = {
 				onDidOpenDashboard: extHostDashboard.onDidOpenDashboard,
 				onDidChangeToDashboard: extHostDashboard.onDidChangeToDashboard,
-				createModelViewEditor(title: string, options?: sqlops.ModelViewEditorOptions): sqlops.workspace.ModelViewEditor {
+				createModelViewEditor(title: string, options?: azdata.ModelViewEditorOptions): azdata.workspace.ModelViewEditor {
 					return extHostModelViewDialog.createModelViewEditor(title, extension, options);
 				}
 			};
 
 			const dashboard = {
-				registerWebviewProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void) {
+				registerWebviewProvider(widgetId: string, handler: (webview: azdata.DashboardWebview) => void) {
 					extHostWebviewWidgets.$registerProvider(widgetId, handler);
 				}
 			};
 
 			const ui = {
-				registerModelViewProvider(modelViewId: string, handler: (view: sqlops.ModelView) => void): void {
+				registerModelViewProvider(modelViewId: string, handler: (view: azdata.ModelView) => void): void {
 					extHostModelView.$registerProvider(modelViewId, handler, extension);
 				}
 			};
 
 			// namespace: queryeditor
-			const queryEditor: typeof sqlops.queryeditor = {
+			const queryEditor: typeof azdata.queryeditor = {
 
 				connect(fileUri: string, connectionId: string): Thenable<void> {
 					return extHostQueryEditor.$connect(fileUri, connectionId);
@@ -487,7 +487,7 @@ export function createApiFactory(
 				}
 			};
 
-			const extensions: typeof sqlops.extensions = {
+			const extensions: typeof azdata.extensions = {
 				install(vsixPath: string): Thenable<string> {
 					return extHostExtensionManagement.$install(vsixPath);
 				}
@@ -509,10 +509,10 @@ export function createApiFactory(
 				get onDidChangeNotebookCell() {
 					return extHostNotebookDocumentsAndEditors.onDidChangeNotebookCell;
 				},
-				showNotebookDocument(uri: vscode.Uri, showOptions: sqlops.nb.NotebookShowOptions) {
+				showNotebookDocument(uri: vscode.Uri, showOptions: azdata.nb.NotebookShowOptions) {
 					return extHostNotebookDocumentsAndEditors.showNotebookDocument(uri, showOptions);
 				},
-				registerNotebookProvider(provider: sqlops.nb.NotebookProvider): vscode.Disposable {
+				registerNotebookProvider(provider: azdata.nb.NotebookProvider): vscode.Disposable {
 					return extHostNotebook.registerNotebookProvider(provider);
 				},
 				CellRange: sqlExtHostTypes.CellRange
@@ -557,6 +557,7 @@ export function createApiFactory(
 				nb: nb,
 				AzureResource: sqlExtHostTypes.AzureResource,
 				TreeItem: sqlExtHostTypes.TreeItem,
+				extensions: extensions
 			};
 		},
 

src/sql/workbench/api/node/sqlExtHost.protocol.ts

@@ -14,7 +14,7 @@ import { UriComponents } from 'vs/base/common/uri';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IDisposable } from 'vs/base/common/lifecycle';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 import { ITreeComponentItem } from 'sql/workbench/common/views';
@@ -29,16 +29,16 @@ import { IExtensionDescription } from 'vs/workbench/services/extensions/common/e
 
 export abstract class ExtHostAccountManagementShape {
 	$autoOAuthCancelled(handle: number): Thenable<void> { throw ni(); }
-	$clear(handle: number, accountKey: sqlops.AccountKey): Thenable<void> { throw ni(); }
-	$getSecurityToken(account: sqlops.Account, resource?: sqlops.AzureResource): Thenable<{}> { throw ni(); }
-	$initialize(handle: number, restoredAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> { throw ni(); }
-	$prompt(handle: number): Thenable<sqlops.Account> { throw ni(); }
-	$refresh(handle: number, account: sqlops.Account): Thenable<sqlops.Account> { throw ni(); }
-	$accountsChanged(handle: number, accounts: sqlops.Account[]): Thenable<void> { throw ni(); }
+	$clear(handle: number, accountKey: azdata.AccountKey): Thenable<void> { throw ni(); }
+	$getSecurityToken(account: azdata.Account, resource?: azdata.AzureResource): Thenable<{}> { throw ni(); }
+	$initialize(handle: number, restoredAccounts: azdata.Account[]): Thenable<azdata.Account[]> { throw ni(); }
+	$prompt(handle: number): Thenable<azdata.Account> { throw ni(); }
+	$refresh(handle: number, account: azdata.Account): Thenable<azdata.Account> { throw ni(); }
+	$accountsChanged(handle: number, accounts: azdata.Account[]): Thenable<void> { throw ni(); }
 }
 
 export abstract class ExtHostConnectionManagementShape {
-	$onConnectionOpened(handleId: string, connection: sqlops.connection.Connection): void { throw ni; }
+	$onConnectionOpened(handleId: string, connection: azdata.connection.Connection): void { throw ni; }
 }
 
 export abstract class ExtHostDataProtocolShape {
@@ -46,7 +46,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Establish a connection to a data source using the provided ConnectionInfo instance.
 	 */
-	$connect(handle: number, connectionUri: string, connection: sqlops.ConnectionInfo): Thenable<boolean> { throw ni(); }
+	$connect(handle: number, connectionUri: string, connection: azdata.ConnectionInfo): Thenable<boolean> { throw ni(); }
 
 	/**
 	 * Disconnect from a data source using the provided connectionUri string.
@@ -68,7 +68,7 @@ export abstract class ExtHostDataProtocolShape {
 	 * @param handle the handle to use when looking up a provider
 	 * @param connectionUri URI identifying a connected resource
 	 */
-	$listDatabases(handle: number, connectionUri: string): Thenable<sqlops.ListDatabasesResult> { throw ni(); }
+	$listDatabases(handle: number, connectionUri: string): Thenable<azdata.ListDatabasesResult> { throw ni(); }
 
 	/**
 	 * Get the connection string for the connection specified by connectionUri
@@ -82,7 +82,7 @@ export abstract class ExtHostDataProtocolShape {
 	 * @param handle the handle to use when looking up a provider
 	 * @param connectionString the connection string to serialize
 	 */
-	$buildConnectionInfo(handle: number, connectionString: string): Thenable<sqlops.ConnectionInfo> { throw ni(); }
+	$buildConnectionInfo(handle: number, connectionString: string): Thenable<azdata.ConnectionInfo> { throw ni(); }
 
 	/**
 	 * Notifies all listeners on the Extension Host side that a language change occurred
@@ -90,69 +90,69 @@ export abstract class ExtHostDataProtocolShape {
 	 * and other events
 	 * @param params information on what URI was changed and the new language
 	 */
-	$languageFlavorChanged(params: sqlops.DidChangeLanguageFlavorParams): void { throw ni(); }
+	$languageFlavorChanged(params: azdata.DidChangeLanguageFlavorParams): void { throw ni(); }
 
 	/**
 	 * Callback when a connection request has completed
 	 */
-	$onConnectComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void { throw ni(); }
+	$onConnectComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void { throw ni(); }
 
 	/**
 	 * Callback when a IntelliSense cache has been built
 	 */
 	$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void { throw ni(); }
 
-	$getServerCapabilities(handle: number, client: sqlops.DataProtocolClientCapabilities): Thenable<sqlops.DataProtocolServerCapabilities> { throw ni(); }
+	$getServerCapabilities(handle: number, client: azdata.DataProtocolClientCapabilities): Thenable<azdata.DataProtocolServerCapabilities> { throw ni(); }
 
 	/**
 	 * Metadata service methods
 	 *
 	 */
-	$getMetadata(handle: number, connectionUri: string): Thenable<sqlops.ProviderMetadata> { throw ni(); }
+	$getMetadata(handle: number, connectionUri: string): Thenable<azdata.ProviderMetadata> { throw ni(); }
 
 	$getDatabases(handle: number, connectionUri: string): Thenable<string[]> { throw ni(); }
 
-	$getTableInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> { throw ni(); }
+	$getTableInfo(handle: number, connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> { throw ni(); }
 
-	$getViewInfo(handle: number, connectionUri: string, metadata: sqlops.ObjectMetadata): Thenable<sqlops.ColumnMetadata[]> { throw ni(); }
+	$getViewInfo(handle: number, connectionUri: string, metadata: azdata.ObjectMetadata): Thenable<azdata.ColumnMetadata[]> { throw ni(); }
 
 	/**
 	 * Object Explorer
 	 */
-	$createObjectExplorerSession(handle: number, connInfo: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerSessionResponse> { throw ni(); }
+	$createObjectExplorerSession(handle: number, connInfo: azdata.ConnectionInfo): Thenable<azdata.ObjectExplorerSessionResponse> { throw ni(); }
 
-	$expandObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
+	$expandObjectExplorerNode(handle: number, nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
 
-	$refreshObjectExplorerNode(handle: number, nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
+	$refreshObjectExplorerNode(handle: number, nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> { throw ni(); }
 
-	$closeObjectExplorerSession(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> { throw ni(); }
+	$closeObjectExplorerSession(handle: number, closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): Thenable<azdata.ObjectExplorerCloseSessionResponse> { throw ni(); }
 
-	$findNodes(handle: number, findNodesInfo: sqlops.FindNodesInfo): Thenable<sqlops.ObjectExplorerFindNodesResponse> { throw ni(); }
+	$findNodes(handle: number, findNodesInfo: azdata.FindNodesInfo): Thenable<azdata.ObjectExplorerFindNodesResponse> { throw ni(); }
 
-	$createObjectExplorerNodeProviderSession(handle: number, sessionInfo: sqlops.ObjectExplorerSession): Thenable<boolean> { throw ni(); }
+	$createObjectExplorerNodeProviderSession(handle: number, sessionInfo: azdata.ObjectExplorerSession): Thenable<boolean> { throw ni(); }
 
-	$handleSessionClose(handle: number, closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): void { throw ni(); }
+	$handleSessionClose(handle: number, closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): void { throw ni(); }
 
 	/**
 	 * Tasks
 	 */
-	$getAllTasks(handle: number, listTasksParams: sqlops.ListTasksParams): Thenable<sqlops.ListTasksResponse> { throw ni(); }
-	$cancelTask(handle: number, cancelTaskParams: sqlops.CancelTaskParams): Thenable<boolean> { throw ni(); }
+	$getAllTasks(handle: number, listTasksParams: azdata.ListTasksParams): Thenable<azdata.ListTasksResponse> { throw ni(); }
+	$cancelTask(handle: number, cancelTaskParams: azdata.CancelTaskParams): Thenable<boolean> { throw ni(); }
 
 	/**
 	 * Scripting methods
 	 */
-	$scriptAsOperation(handle: number, connectionUri: string, operation: sqlops.ScriptOperation, metadata: sqlops.ObjectMetadata, paramDetails: sqlops.ScriptingParamDetails): Thenable<sqlops.ScriptingResult> { throw ni(); }
+	$scriptAsOperation(handle: number, connectionUri: string, operation: azdata.ScriptOperation, metadata: azdata.ObjectMetadata, paramDetails: azdata.ScriptingParamDetails): Thenable<azdata.ScriptingResult> { throw ni(); }
 
 	/**
 	 * Cancels the currently running query for a URI
 	 */
-	$cancelQuery(handle: number, ownerUri: string): Thenable<sqlops.QueryCancelResult> { throw ni(); }
+	$cancelQuery(handle: number, ownerUri: string): Thenable<azdata.QueryCancelResult> { throw ni(); }
 
 	/**
 	 * Runs a query for a text selection inside a document
 	 */
-	$runQuery(handle: number, ownerUri: string, selection: sqlops.ISelectionData, runOptions?: sqlops.ExecutionPlanOptions): Thenable<void> { throw ni(); }
+	$runQuery(handle: number, ownerUri: string, selection: azdata.ISelectionData, runOptions?: azdata.ExecutionPlanOptions): Thenable<void> { throw ni(); }
 	/**
 	 * Runs the current SQL statement query for a text document
 	 */
@@ -164,15 +164,15 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Runs a query for a provided query and returns result
 	 */
-	$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<sqlops.SimpleExecuteResult> { throw ni(); }
+	$runQueryAndReturn(handle: number, ownerUri: string, queryString: string): Thenable<azdata.SimpleExecuteResult> { throw ni(); }
 	/**
 	 * Parses a T-SQL string without actually executing it
 	 */
-	$parseSyntax(handle: number, ownerUri: string, query: string): Thenable<sqlops.SyntaxParseResult> { throw ni(); }
+	$parseSyntax(handle: number, ownerUri: string, query: string): Thenable<azdata.SyntaxParseResult> { throw ni(); }
 	/**
 	 * Gets a subset of rows in a result set in order to display in the UI
 	 */
-	$getQueryRows(handle: number, rowData: sqlops.QueryExecuteSubsetParams): Thenable<sqlops.QueryExecuteSubsetResult> { throw ni(); }
+	$getQueryRows(handle: number, rowData: azdata.QueryExecuteSubsetParams): Thenable<azdata.QueryExecuteSubsetResult> { throw ni(); }
 
 	/**
 	 * Disposes the cached information regarding a query
@@ -187,33 +187,33 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Callback when a query has completed
 	 */
-	$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void { throw ni(); }
+	$onQueryComplete(handle: number, result: azdata.QueryExecuteCompleteNotificationResult): void { throw ni(); }
 	/**
 	 * Callback when a batch has started. This enables the UI to display when batch execution has started
 	 */
-	$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void { throw ni(); }
+	$onBatchStart(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void { throw ni(); }
 	/**
 	 * Callback when a batch is complete. This includes updated information on result sets, time to execute, and
 	 * other relevant batch information
 	 */
-	$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void { throw ni(); }
+	$onBatchComplete(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void { throw ni(); }
 	/**
 	 * Callback when a result set has been returned from query execution and can be displayed
 	 */
-	$onResultSetAvailable(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void { throw ni(); }
+	$onResultSetAvailable(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void { throw ni(); }
 	/**
 	 * Callback when a result set has been returned from query execution and can be displayed
 	 */
-	$onResultSetUpdate(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void { throw ni(); }
+	$onResultSetUpdate(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void { throw ni(); }
 	/**
 	 * Callback when a message generated during query execution is issued
 	 */
-	$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void { throw ni(); }
+	$onQueryMessage(handle: number, message: azdata.QueryExecuteMessageParams): void { throw ni(); }
 
 	/**
 	 * Requests saving of the results from a result set into a specific format (CSV, JSON, Excel)
 	 */
-	$saveResults(handle: number, requestParams: sqlops.SaveResultsRequestParams): Thenable<sqlops.SaveResultRequestResult> { throw ni(); }
+	$saveResults(handle: number, requestParams: azdata.SaveResultsRequestParams): Thenable<azdata.SaveResultRequestResult> { throw ni(); }
 
 	/**
 	 * Commits all pending edits in an edit session
@@ -223,7 +223,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Creates a new row in the edit session
 	 */
-	$createRow(handle: number, ownerUri: string): Thenable<sqlops.EditCreateRowResult> { throw ni(); }
+	$createRow(handle: number, ownerUri: string): Thenable<azdata.EditCreateRowResult> { throw ni(); }
 
 	/**
 	 * Marks the selected row for deletion in the edit session
@@ -238,7 +238,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Reverts any pending changes for the requested cell and returns the original value
 	 */
-	$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<sqlops.EditRevertCellResult> { throw ni(); }
+	$revertCell(handle: number, ownerUri: string, rowId: number, columnId: number): Thenable<azdata.EditRevertCellResult> { throw ni(); }
 
 	/**
 	 * Reverts any pending changes for the requested row
@@ -248,12 +248,12 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Updates a cell value in the requested row. Returns if there are any corrections to the value
 	 */
-	$updateCell(handle: number, ownerUri: string, rowId: number, columId: number, newValue: string): Thenable<sqlops.EditUpdateCellResult> { throw ni(); }
+	$updateCell(handle: number, ownerUri: string, rowId: number, columId: number, newValue: string): Thenable<azdata.EditUpdateCellResult> { throw ni(); }
 
 	/**
 	 * Gets a subset of rows in a result set, merging pending edit changes in order to display in the UI
 	 */
-	$getEditRows(handle: number, rowData: sqlops.EditSubsetParams): Thenable<sqlops.EditSubsetResult> { throw ni(); }
+	$getEditRows(handle: number, rowData: azdata.EditSubsetParams): Thenable<azdata.EditSubsetResult> { throw ni(); }
 
 	/**
 	 * Diposes an initialized edit session and cleans up pending edits
@@ -263,52 +263,52 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Create a new database on the provided connection
 	 */
-	$createDatabase(handle: number, connectionUri: string, database: sqlops.DatabaseInfo): Thenable<sqlops.CreateDatabaseResponse> { throw ni(); }
+	$createDatabase(handle: number, connectionUri: string, database: azdata.DatabaseInfo): Thenable<azdata.CreateDatabaseResponse> { throw ni(); }
 
 	/**
 	 * Get the default database prototype
 	 */
-	$getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> { throw ni(); }
+	$getDefaultDatabaseInfo(handle: number, connectionUri: string): Thenable<azdata.DatabaseInfo> { throw ni(); }
 
 	/**
 	 * Get the database info
 	 */
-	$getDatabaseInfo(handle: number, connectionUri: string): Thenable<sqlops.DatabaseInfo> { throw ni(); }
+	$getDatabaseInfo(handle: number, connectionUri: string): Thenable<azdata.DatabaseInfo> { throw ni(); }
 
 	/**
 	 * Create a new login on the provided connection
 	 */
-	$createLogin(handle: number, connectionUri: string, login: sqlops.LoginInfo): Thenable<sqlops.CreateLoginResponse> { throw ni(); }
+	$createLogin(handle: number, connectionUri: string, login: azdata.LoginInfo): Thenable<azdata.CreateLoginResponse> { throw ni(); }
 
 	/**
 	 * Backup a database
 	 */
-	$backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.BackupResponse> { throw ni(); }
+	$backup(handle: number, connectionUri: string, backupInfo: { [key: string]: any }, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.BackupResponse> { throw ni(); }
 
 	/**
 	 * Get the extended database prototype
 	 */
-	$getBackupConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.BackupConfigInfo> { throw ni(); }
+	$getBackupConfigInfo(handle: number, connectionUri: string): Thenable<azdata.BackupConfigInfo> { throw ni(); }
 
 	/**
 	 * Restores a database
 	 */
-	$restore(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestoreResponse> { throw ni(); }
+	$restore(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestoreResponse> { throw ni(); }
 
 	/**
 	 * Gets a plan for restoring a database
 	 */
-	$getRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<sqlops.RestorePlanResponse> { throw ni(); }
+	$getRestorePlan(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<azdata.RestorePlanResponse> { throw ni(); }
 
 	/**
 	 * Cancels a plan
 	 */
-	$cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: sqlops.RestoreInfo): Thenable<boolean> { throw ni(); }
+	$cancelRestorePlan(handle: number, connectionUri: string, restoreInfo: azdata.RestoreInfo): Thenable<boolean> { throw ni(); }
 
 	/**
 	 * Gets restore config Info
 	 */
-	$getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<sqlops.RestoreConfigInfo> { throw ni(); }
+	$getRestoreConfigInfo(handle: number, connectionUri: string): Thenable<azdata.RestoreConfigInfo> { throw ni(); }
 
 
 	/**
@@ -330,7 +330,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Close file browser
 	 */
-	$closeFileBrowser(handle: number, ownerUri: string): Thenable<sqlops.FileBrowserCloseResponse> { throw ni(); }
+	$closeFileBrowser(handle: number, ownerUri: string): Thenable<azdata.FileBrowserCloseResponse> { throw ni(); }
 
 	/**
 	 * Profiler Provider methods
@@ -339,7 +339,7 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Create a profiler session
 	 */
-	$createSession(handle: number, sessionId: string, createStatement: string, template: sqlops.ProfilerSessionTemplate): Thenable<boolean> { throw ni(); }
+	$createSession(handle: number, sessionId: string, createStatement: string, template: azdata.ProfilerSessionTemplate): Thenable<boolean> { throw ni(); }
 
 	/**
 	 * Start a profiler session
@@ -369,92 +369,92 @@ export abstract class ExtHostDataProtocolShape {
 	/**
 	 * Get Agent Job list
 	 */
-	$getJobs(handle: number, ownerUri: string): Thenable<sqlops.AgentJobsResult> { throw ni(); }
+	$getJobs(handle: number, ownerUri: string): Thenable<azdata.AgentJobsResult> { throw ni(); }
 
 	/**
 	 * Get a Agent Job's history
 	 */
-	$getJobHistory(handle: number, ownerUri: string, jobID: string, jobName: string): Thenable<sqlops.AgentJobHistoryResult> { throw ni(); }
+	$getJobHistory(handle: number, ownerUri: string, jobID: string, jobName: string): Thenable<azdata.AgentJobHistoryResult> { throw ni(); }
 
 	/**
 	 * Run an action on a Job
 	 */
-	$jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$jobAction(handle: number, ownerUri: string, jobName: string, action: string): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Deletes a job
 	 */
-	$deleteJob(handle: number, ownerUri: string, job: sqlops.AgentJobInfo): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$deleteJob(handle: number, ownerUri: string, job: azdata.AgentJobInfo): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Deletes a job step
 	 */
-	$deleteJobStep(handle: number, ownerUri: string, step: sqlops.AgentJobStepInfo): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$deleteJobStep(handle: number, ownerUri: string, step: azdata.AgentJobStepInfo): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Get Agent Alerts list
 	 */
-	$getAlerts(handle: number, connectionUri: string): Thenable<sqlops.AgentAlertsResult> { throw ni(); }
+	$getAlerts(handle: number, connectionUri: string): Thenable<azdata.AgentAlertsResult> { throw ni(); }
 
 	/**
 	 * Deletes  an alert
 	 */
-	$deleteAlert(handle: number, connectionUri: string, alert: sqlops.AgentAlertInfo): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$deleteAlert(handle: number, connectionUri: string, alert: azdata.AgentAlertInfo): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Get Agent Oeprators list
 	 */
-	$getOperators(handle: number, connectionUri: string): Thenable<sqlops.AgentOperatorsResult> { throw ni(); }
+	$getOperators(handle: number, connectionUri: string): Thenable<azdata.AgentOperatorsResult> { throw ni(); }
 
 	/**
 	 * Deletes  an operator
 	 */
-	$deleteOperator(handle: number, connectionUri: string, operator: sqlops.AgentOperatorInfo): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$deleteOperator(handle: number, connectionUri: string, operator: azdata.AgentOperatorInfo): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Get Agent Proxies list
 	 */
-	$getProxies(handle: number, connectionUri: string): Thenable<sqlops.AgentProxiesResult> { throw ni(); }
+	$getProxies(handle: number, connectionUri: string): Thenable<azdata.AgentProxiesResult> { throw ni(); }
 
 	/**
 	 * Deletes  a proxy
 	 */
-	$deleteProxy(handle: number, connectionUri: string, proxy: sqlops.AgentProxyInfo): Thenable<sqlops.ResultStatus> { throw ni(); }
+	$deleteProxy(handle: number, connectionUri: string, proxy: azdata.AgentProxyInfo): Thenable<azdata.ResultStatus> { throw ni(); }
 
 	/**
 	 * Get Agent Credentials list
 	 */
-	$getCredentials(handle: number, connectionUri: string): Thenable<sqlops.GetCredentialsResult> { throw ni(); }
+	$getCredentials(handle: number, connectionUri: string): Thenable<azdata.GetCredentialsResult> { throw ni(); }
 
 	/**
 	 * DacFx export bacpac
 	 */
-	$exportBacpac(handle: number, databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+	$exportBacpac(handle: number, databaseName: string, packageFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> { throw ni(); }
 
 	/**
 	 * DacFx import bacpac
 	 */
-	$importBacpac(handle: number, packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+	$importBacpac(handle: number, packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> { throw ni(); }
 
 	/**
 	 * DacFx extract dacpac
 	 */
-	$extractDacpac(handle: number, databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+	$extractDacpac(handle: number, databaseName: string, packageFilePath: string, applicationName: string, applicationVersion: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> { throw ni(); }
 
 	/**
 	 * DacFx deploy dacpac
 	 */
-	$deployDacpac(handle: number, packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+	$deployDacpac(handle: number, packageFilePath: string, databaseName: string, upgradeExisting: boolean, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> { throw ni(); }
 
 	/**
 	 * DacFx generate deploy script
 	 */
-	$generateDeployScript(handle: number, packageFilePath: string, databaseName: string, scriptFilePath: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.DacFxResult> { throw ni(); }
+	$generateDeployScript(handle: number, packageFilePath: string, databaseName: string, scriptFilePath: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.DacFxResult> { throw ni(); }
 
 	/**
 	 * DacFx generate deploy plan
 	 */
-	$generateDeployPlan(handle: number, packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: sqlops.TaskExecutionMode): Thenable<sqlops.GenerateDeployPlanResult> { throw ni(); }
+	$generateDeployPlan(handle: number, packageFilePath: string, databaseName: string, ownerUri: string, taskExecutionMode: azdata.TaskExecutionMode): Thenable<azdata.GenerateDeployPlanResult> { throw ni(); }
 
 }
 
@@ -465,12 +465,12 @@ export abstract class ExtHostResourceProviderShape {
 	/**
 	 * Create a firewall rule
 	 */
-	$createFirewallRule(handle: number, account: sqlops.Account, firewallRuleInfo: sqlops.FirewallRuleInfo): Thenable<sqlops.CreateFirewallRuleResponse> { throw ni(); }
+	$createFirewallRule(handle: number, account: azdata.Account, firewallRuleInfo: azdata.FirewallRuleInfo): Thenable<azdata.CreateFirewallRuleResponse> { throw ni(); }
 
 	/**
 	 * Handle firewall rule
 	 */
-	$handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<sqlops.HandleFirewallRuleResponse> { throw ni(); }
+	$handleFirewallRule(handle: number, errorCode: number, errorMessage: string, connectionTypeId: string): Thenable<azdata.HandleFirewallRuleResponse> { throw ni(); }
 
 }
 
@@ -480,7 +480,7 @@ export abstract class ExtHostResourceProviderShape {
 export abstract class ExtHostCredentialManagementShape {
 	$saveCredential(credentialId: string, password: string): Thenable<boolean> { throw ni(); }
 
-	$readCredential(credentialId: string): Thenable<sqlops.Credential> { throw ni(); }
+	$readCredential(credentialId: string): Thenable<azdata.Credential> { throw ni(); }
 
 	$deleteCredential(credentialId: string): Thenable<boolean> { throw ni(); }
 }
@@ -489,23 +489,23 @@ export abstract class ExtHostCredentialManagementShape {
  * Serialization provider extension host class.
  */
 export abstract class ExtHostSerializationProviderShape {
-	$saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<sqlops.SaveResultRequestResult> { throw ni(); }
+	$saveAs(saveFormat: string, savePath: string, results: string, appendToFile: boolean): Thenable<azdata.SaveResultRequestResult> { throw ni(); }
 }
 
 export interface MainThreadAccountManagementShape extends IDisposable {
-	$registerAccountProvider(providerMetadata: sqlops.AccountProviderMetadata, handle: number): Thenable<any>;
+	$registerAccountProvider(providerMetadata: azdata.AccountProviderMetadata, handle: number): Thenable<any>;
 	$unregisterAccountProvider(handle: number): Thenable<any>;
 
 	$beginAutoOAuthDeviceCode(providerId: string, title: string, message: string, userCode: string, uri: string): Thenable<void>;
 	$endAutoOAuthDeviceCode(): void;
 
-	$accountUpdated(updatedAccount: sqlops.Account): void;
+	$accountUpdated(updatedAccount: azdata.Account): void;
 
-	$getAccountsForProvider(providerId: string): Thenable<sqlops.Account[]>;
+	$getAccountsForProvider(providerId: string): Thenable<azdata.Account[]>;
 }
 
 export interface MainThreadResourceProviderShape extends IDisposable {
-	$registerResourceProvider(providerMetadata: sqlops.ResourceProviderMetadata, handle: number): Thenable<any>;
+	$registerResourceProvider(providerMetadata: azdata.ResourceProviderMetadata, handle: number): Thenable<any>;
 	$unregisterResourceProvider(handle: number): Thenable<any>;
 }
 
@@ -526,27 +526,27 @@ export interface MainThreadDataProtocolShape extends IDisposable {
 	$registerAgentServicesProvider(providerId: string, handle: number): TPromise<any>;
 	$registerDacFxServicesProvider(providerId: string, handle: number): TPromise<any>;
 	$unregisterProvider(handle: number): TPromise<any>;
-	$onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void;
+	$onConnectionComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void;
 	$onIntelliSenseCacheComplete(handle: number, connectionUri: string): void;
-	$onConnectionChangeNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void;
-	$onQueryComplete(handle: number, result: sqlops.QueryExecuteCompleteNotificationResult): void;
-	$onBatchStart(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void;
-	$onBatchComplete(handle: number, batchInfo: sqlops.QueryExecuteBatchNotificationParams): void;
-	$onResultSetAvailable(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void;
-	$onResultSetUpdated(handle: number, resultSetInfo: sqlops.QueryExecuteResultSetNotificationParams): void;
-	$onQueryMessage(handle: number, message: sqlops.QueryExecuteMessageParams): void;
-	$onObjectExplorerSessionCreated(handle: number, message: sqlops.ObjectExplorerSession): void;
-	$onObjectExplorerSessionDisconnected(handle: number, message: sqlops.ObjectExplorerSession): void;
-	$onObjectExplorerNodeExpanded(providerId: string, message: sqlops.ObjectExplorerExpandInfo): void;
-	$onTaskCreated(handle: number, sessionResponse: sqlops.TaskInfo): void;
-	$onTaskStatusChanged(handle: number, sessionResponse: sqlops.TaskProgressInfo): void;
-	$onFileBrowserOpened(handle: number, response: sqlops.FileBrowserOpenedParams): void;
-	$onFolderNodeExpanded(handle: number, response: sqlops.FileBrowserExpandedParams): void;
-	$onFilePathsValidated(handle: number, response: sqlops.FileBrowserValidatedParams): void;
-	$onScriptingComplete(handle: number, message: sqlops.ScriptingCompleteResult): void;
-	$onSessionEventsAvailable(handle: number, response: sqlops.ProfilerSessionEvents): void;
-	$onSessionStopped(handle: number, response: sqlops.ProfilerSessionStoppedParams): void;
-	$onProfilerSessionCreated(handle: number, response: sqlops.ProfilerSessionCreatedParams): void;
+	$onConnectionChangeNotification(handle: number, changedConnInfo: azdata.ChangedConnectionInfo): void;
+	$onQueryComplete(handle: number, result: azdata.QueryExecuteCompleteNotificationResult): void;
+	$onBatchStart(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void;
+	$onBatchComplete(handle: number, batchInfo: azdata.QueryExecuteBatchNotificationParams): void;
+	$onResultSetAvailable(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void;
+	$onResultSetUpdated(handle: number, resultSetInfo: azdata.QueryExecuteResultSetNotificationParams): void;
+	$onQueryMessage(handle: number, message: azdata.QueryExecuteMessageParams): void;
+	$onObjectExplorerSessionCreated(handle: number, message: azdata.ObjectExplorerSession): void;
+	$onObjectExplorerSessionDisconnected(handle: number, message: azdata.ObjectExplorerSession): void;
+	$onObjectExplorerNodeExpanded(providerId: string, message: azdata.ObjectExplorerExpandInfo): void;
+	$onTaskCreated(handle: number, sessionResponse: azdata.TaskInfo): void;
+	$onTaskStatusChanged(handle: number, sessionResponse: azdata.TaskProgressInfo): void;
+	$onFileBrowserOpened(handle: number, response: azdata.FileBrowserOpenedParams): void;
+	$onFolderNodeExpanded(handle: number, response: azdata.FileBrowserExpandedParams): void;
+	$onFilePathsValidated(handle: number, response: azdata.FileBrowserValidatedParams): void;
+	$onScriptingComplete(handle: number, message: azdata.ScriptingCompleteResult): void;
+	$onSessionEventsAvailable(handle: number, response: azdata.ProfilerSessionEvents): void;
+	$onSessionStopped(handle: number, response: azdata.ProfilerSessionStoppedParams): void;
+	$onProfilerSessionCreated(handle: number, response: azdata.ProfilerSessionCreatedParams): void;
 	$onJobDataUpdated(handle: Number): void;
 
 	/**
@@ -556,15 +556,15 @@ export interface MainThreadDataProtocolShape extends IDisposable {
 }
 
 export interface MainThreadConnectionManagementShape extends IDisposable {
-	$getActiveConnections(): Thenable<sqlops.connection.Connection[]>;
-	$getCurrentConnection(): Thenable<sqlops.connection.Connection>;
+	$getActiveConnections(): Thenable<azdata.connection.Connection[]>;
+	$getCurrentConnection(): Thenable<azdata.connection.Connection>;
 	$getCredentials(connectionId: string): Thenable<{ [name: string]: string }>;
-	$getServerInfo(connectedId: string): Thenable<sqlops.ServerInfo>;
-	$openConnectionDialog(providers: string[], initialConnectionProfile?: sqlops.IConnectionProfile, connectionCompletionOptions?: sqlops.IConnectionCompletionOptions): Thenable<sqlops.connection.Connection>;
+	$getServerInfo(connectedId: string): Thenable<azdata.ServerInfo>;
+	$openConnectionDialog(providers: string[], initialConnectionProfile?: azdata.IConnectionProfile, connectionCompletionOptions?: azdata.IConnectionCompletionOptions): Thenable<azdata.connection.Connection>;
 	$listDatabases(connectionId: string): Thenable<string[]>;
 	$getConnectionString(connectionId: string, includePassword: boolean): Thenable<string>;
 	$getUriForConnection(connectionId: string): Thenable<string>;
-	$connect(connectionProfile: sqlops.IConnectionProfile): Thenable<sqlops.ConnectionResult>;
+	$connect(connectionProfile: azdata.IConnectionProfile): Thenable<azdata.ConnectionResult>;
 }
 
 export interface MainThreadCredentialManagementShape extends IDisposable {
@@ -630,8 +630,8 @@ export interface MainThreadDashboardShape extends IDisposable {
 }
 
 export interface ExtHostDashboardShape {
-	$onDidOpenDashboard(dashboard: sqlops.DashboardDocument): void;
-	$onDidChangeToDashboard(dashboard: sqlops.DashboardDocument): void;
+	$onDidOpenDashboard(dashboard: azdata.DashboardDocument): void;
+	$onDidChangeToDashboard(dashboard: azdata.DashboardDocument): void;
 }
 
 export interface MainThreadModalDialogShape extends IDisposable {
@@ -659,10 +659,10 @@ export interface MainThreadTasksShape extends IDisposable {
 }
 
 export interface ExtHostDashboardWebviewsShape {
-	$registerProvider(widgetId: string, handler: (webview: sqlops.DashboardWebview) => void): void;
+	$registerProvider(widgetId: string, handler: (webview: azdata.DashboardWebview) => void): void;
 	$onMessage(handle: number, message: any): void;
 	$onClosed(handle: number): void;
-	$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void;
+	$registerWidget(handle: number, id: string, connection: azdata.connection.Connection, serverInfo: azdata.ServerInfo): void;
 }
 
 export interface MainThreadDashboardWebviewShape extends IDisposable {
@@ -672,16 +672,16 @@ export interface MainThreadDashboardWebviewShape extends IDisposable {
 }
 
 export interface ExtHostModelViewShape {
-	$registerProvider(widgetId: string, handler: (webview: sqlops.ModelView) => void, extension: IExtensionDescription): void;
+	$registerProvider(widgetId: string, handler: (webview: azdata.ModelView) => void, extension: IExtensionDescription): void;
 	$onClosed(handle: number): void;
-	$registerWidget(handle: number, id: string, connection: sqlops.connection.Connection, serverInfo: sqlops.ServerInfo): void;
+	$registerWidget(handle: number, id: string, connection: azdata.connection.Connection, serverInfo: azdata.ServerInfo): void;
 	$handleEvent(handle: number, id: string, eventArgs: any);
 	$runCustomValidations(handle: number, id: string): Thenable<boolean>;
 }
 
 export interface ExtHostModelViewTreeViewsShape {
 	$getChildren(treeViewId: string, treeItemHandle?: string): TPromise<ITreeComponentItem[]>;
-	$createTreeView(handle: number, componentId: string, options: { treeDataProvider: vscode.TreeDataProvider<any> }, extension: IExtensionDescription): sqlops.TreeComponentView<any>;
+	$createTreeView(handle: number, componentId: string, options: { treeDataProvider: vscode.TreeDataProvider<any> }, extension: IExtensionDescription): azdata.TreeComponentView<any>;
 	$onNodeCheckedChanged(treeViewId: string, treeItemHandle?: string, checked?: boolean): void;
 	$onNodeSelected(treeViewId: string, nodes: string[]): void;
 
@@ -693,13 +693,13 @@ export interface ExtHostModelViewTreeViewsShape {
 export interface ExtHostBackgroundTaskManagementShape {
 	$onTaskRegistered(operationId: string): void;
 	$onTaskCanceled(operationId: string): void;
-	$registerTask(operationInfo: sqlops.BackgroundOperationInfo): void;
+	$registerTask(operationInfo: azdata.BackgroundOperationInfo): void;
 	$removeTask(operationId: string): void;
 }
 
 export interface MainThreadBackgroundTaskManagementShape extends IDisposable {
-	$registerTask(taskInfo: sqlops.TaskInfo): void;
-	$updateTask(taskProgressInfo: sqlops.TaskProgressInfo): void;
+	$registerTask(taskInfo: azdata.TaskInfo): void;
+	$updateTask(taskProgressInfo: azdata.TaskProgressInfo): void;
 }
 
 export interface MainThreadModelViewShape extends IDisposable {
@@ -720,30 +720,30 @@ export interface ExtHostObjectExplorerShape {
 }
 
 export interface MainThreadObjectExplorerShape extends IDisposable {
-	$getNode(connectionId: string, nodePath?: string): Thenable<sqlops.NodeInfo>;
-	$getActiveConnectionNodes(): Thenable<{ nodeInfo: sqlops.NodeInfo, connectionId: string }[]>;
+	$getNode(connectionId: string, nodePath?: string): Thenable<azdata.NodeInfo>;
+	$getActiveConnectionNodes(): Thenable<{ nodeInfo: azdata.NodeInfo, connectionId: string }[]>;
 	$setExpandedState(connectionId: string, nodePath: string, expandedState: vscode.TreeItemCollapsibleState): Thenable<void>;
 	$setSelected(connectionId: string, nodePath: string, selected: boolean, clearOtherSelections?: boolean): Thenable<void>;
-	$getChildren(connectionId: string, nodePath: string): Thenable<sqlops.NodeInfo[]>;
+	$getChildren(connectionId: string, nodePath: string): Thenable<azdata.NodeInfo[]>;
 	$isExpanded(connectionId: string, nodePath: string): Thenable<boolean>;
-	$findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<sqlops.NodeInfo[]>;
-	$refresh(connectionId: string, nodePath: string): Thenable<sqlops.NodeInfo>;
+	$findNodes(connectionId: string, type: string, schema: string, name: string, database: string, parentObjectNames: string[]): Thenable<azdata.NodeInfo[]>;
+	$refresh(connectionId: string, nodePath: string): Thenable<azdata.NodeInfo>;
 	$getNodeActions(connectionId: string, nodePath: string): Thenable<string[]>;
-	$getSessionConnectionProfile(sessionId: string): Thenable<sqlops.IConnectionProfile>;
+	$getSessionConnectionProfile(sessionId: string): Thenable<azdata.IConnectionProfile>;
 }
 
 export interface ExtHostModelViewDialogShape {
 	$onButtonClick(handle: number): void;
 	$onPanelValidityChanged(handle: number, valid: boolean): void;
-	$onWizardPageChanged(handle: number, info: sqlops.window.WizardPageChangeInfo): void;
+	$onWizardPageChanged(handle: number, info: azdata.window.WizardPageChangeInfo): void;
 	$updateWizardPageInfo(handle: number, pageHandles: number[], currentPageIndex: number): void;
-	$validateNavigation(handle: number, info: sqlops.window.WizardPageChangeInfo): Thenable<boolean>;
+	$validateNavigation(handle: number, info: azdata.window.WizardPageChangeInfo): Thenable<boolean>;
 	$validateDialogClose(handle: number): Thenable<boolean>;
 	$handleSave(handle: number): Thenable<boolean>;
 }
 
 export interface MainThreadModelViewDialogShape extends IDisposable {
-	$openEditor(handle: number, modelViewId: string, title: string, options?: sqlops.ModelViewEditorOptions, position?: vscode.ViewColumn): Thenable<void>;
+	$openEditor(handle: number, modelViewId: string, title: string, options?: azdata.ModelViewEditorOptions, position?: vscode.ViewColumn): Thenable<void>;
 	$openDialog(handle: number, dialogName?: string): Thenable<void>;
 	$closeDialog(handle: number): Thenable<void>;
 	$setDialogDetails(handle: number, details: IModelViewDialogDetails): Thenable<void>;
@@ -782,35 +782,35 @@ export interface ExtHostNotebookShape {
 	$doStopServer(managerHandle: number): Thenable<void>;
 
 	// Content Manager APIs
-	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<sqlops.nb.INotebookContents>;
-	$save(managerHandle: number, notebookUri: UriComponents, notebook: sqlops.nb.INotebookContents): Thenable<sqlops.nb.INotebookContents>;
+	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<azdata.nb.INotebookContents>;
+	$save(managerHandle: number, notebookUri: UriComponents, notebook: azdata.nb.INotebookContents): Thenable<azdata.nb.INotebookContents>;
 
 	// Session Manager APIs
-	$refreshSpecs(managerHandle: number): Thenable<sqlops.nb.IAllKernels>;
-	$startNewSession(managerHandle: number, options: sqlops.nb.ISessionOptions): Thenable<INotebookSessionDetails>;
+	$refreshSpecs(managerHandle: number): Thenable<azdata.nb.IAllKernels>;
+	$startNewSession(managerHandle: number, options: azdata.nb.ISessionOptions): Thenable<INotebookSessionDetails>;
 	$shutdownSession(managerHandle: number, sessionId: string): Thenable<void>;
 
 	// Session APIs
-	$changeKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<INotebookKernelDetails>;
-	$configureKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<void>;
-	$configureConnection(sessionId: number, connection: sqlops.IConnectionProfile): Thenable<void>;
+	$changeKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<INotebookKernelDetails>;
+	$configureKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<void>;
+	$configureConnection(sessionId: number, connection: azdata.IConnectionProfile): Thenable<void>;
 
 	// Kernel APIs
-	$getKernelReadyStatus(kernelId: number): Thenable<sqlops.nb.IInfoReply>;
-	$getKernelSpec(kernelId: number): Thenable<sqlops.nb.IKernelSpec>;
-	$requestComplete(kernelId: number, content: sqlops.nb.ICompleteRequest): Thenable<sqlops.nb.ICompleteReplyMsg>;
-	$requestExecute(kernelId: number, content: sqlops.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails>;
+	$getKernelReadyStatus(kernelId: number): Thenable<azdata.nb.IInfoReply>;
+	$getKernelSpec(kernelId: number): Thenable<azdata.nb.IKernelSpec>;
+	$requestComplete(kernelId: number, content: azdata.nb.ICompleteRequest): Thenable<azdata.nb.ICompleteReplyMsg>;
+	$requestExecute(kernelId: number, content: azdata.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails>;
 	$interruptKernel(kernelId: number): Thenable<void>;
 
 	// Future APIs
-	$sendInputReply(futureId: number, content: sqlops.nb.IInputReply): void;
+	$sendInputReply(futureId: number, content: azdata.nb.IInputReply): void;
 	$disposeFuture(futureId: number): void;
 }
 
 export interface MainThreadNotebookShape extends IDisposable {
 	$registerNotebookProvider(providerId: string, handle: number): void;
 	$unregisterNotebookProvider(handle: number): void;
-	$onFutureMessage(futureId: number, type: FutureMessageType, payload: sqlops.nb.IMessage): void;
+	$onFutureMessage(futureId: number, type: FutureMessageType, payload: azdata.nb.IMessage): void;
 	$onFutureDone(futureId: number, done: INotebookFutureDone): void;
 }
 
@@ -827,7 +827,7 @@ export interface INotebookModelAddedData {
 	providerId: string;
 	providers: string[];
 	isDirty: boolean;
-	cells: sqlops.nb.NotebookCell[];
+	cells: azdata.nb.NotebookCell[];
 }
 
 export interface INotebookModelChangedData {
@@ -835,8 +835,8 @@ export interface INotebookModelChangedData {
 	providerId: string;
 	providers: string[];
 	isDirty: boolean;
-	cells: sqlops.nb.NotebookCell[];
-	kernelSpec: sqlops.nb.IKernelSpec;
+	cells: azdata.nb.NotebookCell[];
+	kernelSpec: azdata.nb.IKernelSpec;
 }
 
 export interface INotebookEditorAddData {
@@ -851,7 +851,7 @@ export interface INotebookShowOptions {
 	preview?: boolean;
 	providerId?: string;
 	connectionId?: string;
-	defaultKernel?: sqlops.nb.IKernelSpec;
+	defaultKernel?: azdata.nb.IKernelSpec;
 }
 
 export interface ExtHostNotebookDocumentsAndEditorsShape {