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

* Update extensions to use azdata

* Switch core code to use azdata

src/sqltest/parts/accountManagement/accountActions.test.ts

@@ -6,14 +6,14 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import { AddAccountAction, RemoveAccountAction } from 'sql/parts/accountManagement/common/accountActions';
 import { AccountManagementTestService } from 'sqltest/stubs/accountManagementStubs';
 // import { MessageServiceStub } from 'sqltest/stubs/messageServiceStub';
 import { ErrorMessageServiceStub } from 'sqltest/stubs/errorMessageServiceStub';
 
-let testAccount = <sqlops.Account>{
+let testAccount = <azdata.Account>{
 	key: {
 		providerId: 'azure',
 		accountId: 'testAccount'

src/sqltest/parts/accountManagement/accountPickerService.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import * as TypeMoq from 'typemoq';
 import { EventVerifierSingle } from 'sqltest/utils/eventVerifier';
@@ -19,7 +19,7 @@ import { InstantiationService } from 'vs/platform/instantiation/common/instantia
 let mockAddAccountCompleteEmitter: Emitter<void>;
 let mockAddAccountErrorEmitter: Emitter<string>;
 let mockAddAccountStartEmitter: Emitter<void>;
-let mockOnAccountSelectionChangeEvent: Emitter<sqlops.Account>;
+let mockOnAccountSelectionChangeEvent: Emitter<azdata.Account>;
 
 // TESTS ///////////////////////////////////////////////////////////////////
 suite('Account picker service tests', () => {
@@ -28,7 +28,7 @@ suite('Account picker service tests', () => {
 		mockAddAccountCompleteEmitter = new Emitter<void>();
 		mockAddAccountErrorEmitter = new Emitter<string>();
 		mockAddAccountStartEmitter = new Emitter<void>();
-		mockOnAccountSelectionChangeEvent = new Emitter<sqlops.Account>();
+		mockOnAccountSelectionChangeEvent = new Emitter<azdata.Account>();
 	});
 
 	test('Construction - Events are properly defined', () => {
@@ -76,7 +76,7 @@ suite('Account picker service tests', () => {
 			properties: [],
 			isStale: false
 		};
-		let evOnAccountSelectionChangeEvent = new EventVerifierSingle<sqlops.Account>();
+		let evOnAccountSelectionChangeEvent = new EventVerifierSingle<azdata.Account>();
 		service.onAccountSelectionChangeEvent(evOnAccountSelectionChangeEvent.eventHandler);
 		mockOnAccountSelectionChangeEvent.fire(account);
 		evOnAccountSelectionChangeEvent.assertFired(account);

src/sqltest/parts/accountManagement/accountPickerViewModel.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import * as TypeMoq from 'typemoq';
 import { EventVerifierSingle } from 'sqltest/utils/eventVerifier';
@@ -16,8 +16,8 @@ import { AccountManagementTestService } from 'sqltest/stubs/accountManagementStu
 // SUITE STATE /////////////////////////////////////////////////////////////
 let mockUpdateAccountEmitter: Emitter<UpdateAccountListEventParams>;
 
-let providers: sqlops.AccountProviderMetadata[];
-let accounts: sqlops.Account[];
+let providers: azdata.AccountProviderMetadata[];
+let accounts: azdata.Account[];
 suite('Account picker view model tests', () => {
 	setup(() => {
 		providers = [{

src/sqltest/parts/accountManagement/accountViewModel.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import { EventVerifierSingle } from 'sqltest/utils/eventVerifier';
 import { Emitter } from 'vs/base/common/event';
@@ -16,11 +16,11 @@ import { AccountManagementTestService } from 'sqltest/stubs/accountManagementStu
 
 // SUITE STATE /////////////////////////////////////////////////////////////
 let mockAddProviderEmitter: Emitter<AccountProviderAddedEventParams>;
-let mockRemoveProviderEmitter: Emitter<sqlops.AccountProviderMetadata>;
+let mockRemoveProviderEmitter: Emitter<azdata.AccountProviderMetadata>;
 let mockUpdateAccountEmitter: Emitter<UpdateAccountListEventParams>;
 
-let providers: sqlops.AccountProviderMetadata[];
-let accounts: sqlops.Account[];
+let providers: azdata.AccountProviderMetadata[];
+let accounts: azdata.Account[];
 
 suite('Account Management Dialog ViewModel Tests', () => {
 
@@ -56,7 +56,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
 
 		// Setup event mocks for the account management service
 		mockAddProviderEmitter = new Emitter<AccountProviderAddedEventParams>();
-		mockRemoveProviderEmitter = new Emitter<sqlops.AccountProviderMetadata>();
+		mockRemoveProviderEmitter = new Emitter<azdata.AccountProviderMetadata>();
 		mockUpdateAccountEmitter = new Emitter<UpdateAccountListEventParams>();
 	});
 
@@ -79,7 +79,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
 		evAddProvider.assertFired(argAddProvider);
 
 		let argRemoveProvider = providers[0];
-		let evRemoveProvider = new EventVerifierSingle<sqlops.AccountProviderMetadata>();
+		let evRemoveProvider = new EventVerifierSingle<azdata.AccountProviderMetadata>();
 		vm.removeProviderEvent(evRemoveProvider.eventHandler);
 		mockRemoveProviderEmitter.fire(argRemoveProvider);
 		evRemoveProvider.assertFired(argRemoveProvider);
@@ -95,7 +95,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
 		// Setup: Create a viewmodel with event handlers
 		let mockAccountManagementService = getMockAccountManagementService(true, true);
 		let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
-		let evRemoveProvider = new EventVerifierSingle<sqlops.AccountProviderMetadata>();
+		let evRemoveProvider = new EventVerifierSingle<azdata.AccountProviderMetadata>();
 		let evUpdateAccounts = new EventVerifierSingle<UpdateAccountListEventParams>();
 		let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
 
@@ -125,7 +125,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
 		// Setup: Create a mock account management service that rejects looking up providers
 		let mockAccountManagementService = getMockAccountManagementService(false, true);
 		let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
-		let evRemoveProvider = new EventVerifierSingle<sqlops.AccountProviderMetadata>();
+		let evRemoveProvider = new EventVerifierSingle<azdata.AccountProviderMetadata>();
 		let evUpdateAccounts = new EventVerifierSingle<UpdateAccountListEventParams>();
 		let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
 
@@ -154,7 +154,7 @@ suite('Account Management Dialog ViewModel Tests', () => {
 		// Setup: Create a mock account management service that rejects the promise
 		let mockAccountManagementService = getMockAccountManagementService(true, false);
 		let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
-		let evRemoveProvider = new EventVerifierSingle<sqlops.AccountProviderMetadata>();
+		let evRemoveProvider = new EventVerifierSingle<azdata.AccountProviderMetadata>();
 		let evUpdateAccounts = new EventVerifierSingle<UpdateAccountListEventParams>();
 		let vm = getViewModel(mockAccountManagementService.object, evAddProvider, evRemoveProvider, evUpdateAccounts);
 
@@ -202,7 +202,7 @@ function getMockAccountManagementService(resolveProviders: boolean, resolveAccou
 function getViewModel(
 	ams: AccountManagementTestService,
 	evAdd: EventVerifierSingle<AccountProviderAddedEventParams>,
-	evRemove: EventVerifierSingle<sqlops.AccountProviderMetadata>,
+	evRemove: EventVerifierSingle<azdata.AccountProviderMetadata>,
 	evUpdate: EventVerifierSingle<UpdateAccountListEventParams>
 ): AccountViewModel {
 	let vm = new AccountViewModel(ams);
@@ -215,7 +215,7 @@ function getViewModel(
 
 function assertNoEventsFired(
 	evAdd: EventVerifierSingle<AccountProviderAddedEventParams>,
-	evRemove: EventVerifierSingle<sqlops.AccountProviderMetadata>,
+	evRemove: EventVerifierSingle<azdata.AccountProviderMetadata>,
 	evUpdate: EventVerifierSingle<UpdateAccountListEventParams>
 ): void {
 	evAdd.assertNotFired();

src/sqltest/parts/accountManagement/firewallRuleDialogController.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import { Emitter } from 'vs/base/common/event';
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
@@ -21,7 +21,7 @@ import { Deferred } from 'sql/base/common/promise';
 // TESTS ///////////////////////////////////////////////////////////////////
 suite('Firewall rule dialog controller tests', () => {
 	let connectionProfile: IConnectionProfile;
-	let account: sqlops.Account;
+	let account: azdata.Account;
 	let IPAddress = '250.222.155.198';
 	let mockOnAddAccountErrorEvent: Emitter<string>;
 	let mockOnCreateFirewallRule: Emitter<void>;
@@ -237,7 +237,7 @@ function getMockAccountManagementService(resolveSecurityToken: boolean): TypeMoq
 	return mockAccountManagementService;
 }
 
-function getMockResourceProvider(resolveCreateFirewallRule: boolean, response?: sqlops.CreateFirewallRuleResponse): TypeMoq.Mock<ResourceProviderStub> {
+function getMockResourceProvider(resolveCreateFirewallRule: boolean, response?: azdata.CreateFirewallRuleResponse): TypeMoq.Mock<ResourceProviderStub> {
 	let resourceProviderStub = new ResourceProviderStub();
 	let mockResourceProvider = TypeMoq.Mock.ofInstance(resourceProviderStub);
 	mockResourceProvider.setup(x => x.createFirewallRule(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))

src/sqltest/parts/commandLine/commandLineService.test.ts

@@ -2,7 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
  /* Disabled pending next vscode merge which allows electron module to be imported during test runs
  NOTE: Import added above to prevent tests from failing due to the file being empty. Remove when reenabling the tests
 

src/sqltest/parts/common/optionsDialogHelper.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 import * as OptionsDialogHelper from 'sql/workbench/browser/modal/optionsDialogHelper';
 import { InputBox } from 'vs/base/browser/ui/inputbox/inputBox';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Builder, $ } from 'sql/base/browser/builder';
 import * as TypeMoq from 'typemoq';
 import * as assert from 'assert';
@@ -15,11 +15,11 @@ import { ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 suite('Advanced options helper tests', () => {
 	var possibleInputs: string[];
 	let options: { [name: string]: any };
-	var categoryOption: sqlops.ServiceOption;
-	var booleanOption: sqlops.ServiceOption;
-	var numberOption: sqlops.ServiceOption;
-	var stringOption: sqlops.ServiceOption;
-	var defaultGroupOption: sqlops.ServiceOption;
+	var categoryOption: azdata.ServiceOption;
+	var booleanOption: azdata.ServiceOption;
+	var numberOption: azdata.ServiceOption;
+	var stringOption: azdata.ServiceOption;
+	var defaultGroupOption: azdata.ServiceOption;
 	var isValid: boolean;
 	var inputValue: string;
 	var inputBox: TypeMoq.Mock<InputBox>;

src/sqltest/parts/connection/advancedPropertiesDialog.test.ts

@@ -8,14 +8,14 @@ import { OptionsDialog } from 'sql/workbench/browser/modal/optionsDialog';
 import { AdvancedPropertiesController } from 'sql/parts/connection/connectionDialog/advancedPropertiesController';
 import { Builder, $ } from 'sql/base/browser/builder';
 import { ContextKeyServiceStub } from 'sqltest/stubs/contextKeyServiceStub';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import * as assert from 'assert';
 import { ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 
 suite('Advanced properties dialog tests', () => {
 	var advancedController: AdvancedPropertiesController;
-	var providerOptions: sqlops.ConnectionOption[];
+	var providerOptions: azdata.ConnectionOption[];
 
 	setup(() => {
 		advancedController = new AdvancedPropertiesController(() => { }, null);

src/sqltest/parts/connection/connectionConfig.test.ts

@@ -18,7 +18,7 @@ import { IConnectionProfileGroup, ConnectionProfileGroup } from 'sql/platform/co
 import { TPromise } from 'vs/base/common/winjs.base';
 import * as assert from 'assert';
 import { ProviderFeatures, ICapabilitiesService } from 'sql/platform/capabilities/common/capabilitiesService';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Emitter } from 'vs/base/common/event';
 import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { CapabilitiesTestService } from 'sqltest/stubs/capabilitiesTestService';
@@ -188,7 +188,7 @@ suite('SQL ConnectionConfig tests', () => {
 	setup(() => {
 		capabilitiesService = TypeMoq.Mock.ofType(CapabilitiesTestService);
 		capabilities = [];
-		let connectionProvider: sqlops.ConnectionProviderOptions = {
+		let connectionProvider: azdata.ConnectionProviderOptions = {
 			options: [
 				{
 					name: 'serverName',
@@ -304,7 +304,7 @@ suite('SQL ConnectionConfig tests', () => {
 	}
 
 	test('allGroups should return groups from user and workspace settings', () => {
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -354,7 +354,7 @@ suite('SQL ConnectionConfig tests', () => {
 				description: 'g1-2'
 			}];
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToMerge);
 
@@ -387,10 +387,10 @@ suite('SQL ConnectionConfig tests', () => {
 
 		let expectedNumberOfConnections = connections.user.length + 1;
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -429,10 +429,10 @@ suite('SQL ConnectionConfig tests', () => {
 
 		let expectedNumberOfConnections = connections.user.length;
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -472,11 +472,11 @@ suite('SQL ConnectionConfig tests', () => {
 		let expectedNumberOfConnections = connections.user.length + 1;
 		let expectedNumberOfGroups = configValueToConcat.user.length + 1;
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -496,7 +496,7 @@ suite('SQL ConnectionConfig tests', () => {
 	test('getConnections should return connections from user and workspace settings given getWorkspaceConnections set to true', () => {
 		let getWorkspaceConnections: boolean = true;
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
@@ -508,7 +508,7 @@ suite('SQL ConnectionConfig tests', () => {
 	test('getConnections should return connections from user settings given getWorkspaceConnections set to false', () => {
 		let getWorkspaceConnections: boolean = false;
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
@@ -532,7 +532,7 @@ suite('SQL ConnectionConfig tests', () => {
 			value: connections.value,
 			workspaceFolder: []
 		};
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connectionsWithNoId);
 
@@ -584,7 +584,7 @@ suite('SQL ConnectionConfig tests', () => {
 		let capabilitiesService2: TypeMoq.Mock<ICapabilitiesService> = TypeMoq.Mock.ofType(CapabilitiesTestService);
 		capabilitiesService2.setup(x => x.getCapabilities('MSSQL')).returns(() => msSQLCapabilities2);
 		(capabilitiesService2.object as any).onCapabilitiesRegistered = onCapabilitiesRegistered.event;
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => configValue);
 
@@ -664,7 +664,7 @@ suite('SQL ConnectionConfig tests', () => {
 		};
 
 		let expectedNumberOfConnections = connections.user.length - 1;
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
@@ -709,11 +709,11 @@ suite('SQL ConnectionConfig tests', () => {
 
 		let expectedNumberOfConnections = connections.user.length - 1;
 		let expectedNumberOfGroups = configValueToConcat.user.length - 2;
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -750,7 +750,7 @@ suite('SQL ConnectionConfig tests', () => {
 		};
 
 		let expectedNumberOfConnections = connections.user.length;
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
@@ -775,7 +775,7 @@ suite('SQL ConnectionConfig tests', () => {
 		configEditingServiceMock.setup(x => x.writeConfiguration(ConfigurationTarget.USER, TypeMoq.It.isAny())).callback((x: any, val: any) => {
 			calledValue = val.value as IConnectionProfileStore[];
 		}).returns(() => Promise.resolve(undefined));
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -803,7 +803,7 @@ suite('SQL ConnectionConfig tests', () => {
 		configEditingServiceMock.setup(x => x.writeConfiguration(ConfigurationTarget.USER, TypeMoq.It.isAny())).callback((x: any, val: any) => {
 			calledValue = val.value as IConnectionProfileStore[];
 		}).returns(() => Promise.resolve(undefined));
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 
@@ -842,7 +842,7 @@ suite('SQL ConnectionConfig tests', () => {
 		};
 
 		let expectedNumberOfConnections = connections.user.length;
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
 
@@ -926,10 +926,10 @@ suite('SQL ConnectionConfig tests', () => {
 
 	test('addConnection should not move the connection when editing', async () => {
 		// Set up the connection config
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionsArrayName))
 			.returns(() => connections);
-		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | sqlops.DataProtocolServerCapabilities[]>(
+		workspaceConfigurationServiceMock.setup(x => x.inspect<IConnectionProfileStore[] | IConnectionProfileGroup[] | azdata.DataProtocolServerCapabilities[]>(
 			Constants.connectionGroupsArrayName))
 			.returns(() => configValueToConcat);
 		let config = new ConnectionConfig(configEditingServiceMock.object, workspaceConfigurationServiceMock.object, capabilitiesService.object);

src/sqltest/parts/connection/connectionManagementService.test.ts

@@ -25,7 +25,7 @@ import { CapabilitiesTestService } from 'sqltest/stubs/capabilitiesTestService';
 import { ConnectionProviderStub } from 'sqltest/stubs/connectionProviderStub';
 import { ResourceProviderStub } from 'sqltest/stubs/resourceProviderServiceStub';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import { WorkspaceConfigurationTestService } from 'sqltest/stubs/workspaceConfigurationTestService';
@@ -219,7 +219,7 @@ suite('SQL ConnectionManagementService tests', () => {
 			let id = connectionToUse.getOptionsKey();
 			let defaultUri = 'connection://' + (id ? id : connectionToUse.serverName + ':' + connectionToUse.databaseName);
 			connectionManagementService.onConnectionRequestSent(() => {
-				let info: sqlops.ConnectionInfoSummary = {
+				let info: azdata.ConnectionInfoSummary = {
 					connectionId: error ? undefined : 'id',
 					connectionSummary: {
 						databaseName: connectionToUse.databaseName,
@@ -712,7 +712,7 @@ suite('SQL ConnectionManagementService tests', () => {
 		// when I call doChangeLanguageFlavor
 		try {
 			let called = false;
-			connectionManagementService.onLanguageFlavorChanged((changeParams: sqlops.DidChangeLanguageFlavorParams) => {
+			connectionManagementService.onLanguageFlavorChanged((changeParams: azdata.DidChangeLanguageFlavorParams) => {
 				called = true;
 				assert.equal(changeParams.uri, uri);
 				assert.equal(changeParams.language, language);
@@ -737,7 +737,7 @@ suite('SQL ConnectionManagementService tests', () => {
 		};
 		let connectionManagementService = createConnectionManagementService();
 		let called = false;
-		connectionManagementService.onLanguageFlavorChanged((changeParams: sqlops.DidChangeLanguageFlavorParams) => {
+		connectionManagementService.onLanguageFlavorChanged((changeParams: azdata.DidChangeLanguageFlavorParams) => {
 			called = true;
 		});
 		connect(uri, options).then(() => {
@@ -850,7 +850,7 @@ suite('SQL ConnectionManagementService tests', () => {
 		azureConnectionProfile.serverName = servername;
 
 		// Set up the account management service to return a token for the given user
-		accountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny())).returns(providerId => Promise.resolve<sqlops.Account[]>([
+		accountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny())).returns(providerId => Promise.resolve<azdata.Account[]>([
 			{
 				key: {
 					accountId: username,
@@ -892,7 +892,7 @@ suite('SQL ConnectionManagementService tests', () => {
 		azureConnectionProfile.azureTenantId = azureTenantId;
 
 		// Set up the account management service to return a token for the given user
-		accountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny())).returns(providerId => Promise.resolve<sqlops.Account[]>([
+		accountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny())).returns(providerId => Promise.resolve<azdata.Account[]>([
 			{
 				key: {
 					accountId: username,

src/sqltest/parts/connection/connectionProfile.test.ts

@@ -8,7 +8,7 @@
 
 import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';
 import { IConnectionProfile, IConnectionProfileStore } from 'sql/platform/connection/common/interfaces';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { CapabilitiesTestService } from 'sqltest/stubs/capabilitiesTestService';
@@ -52,7 +52,7 @@ suite('SQL ConnectionProfileInfo tests', () => {
 	};
 
 	setup(() => {
-		let connectionProvider: sqlops.ConnectionOption[] = [
+		let connectionProvider: azdata.ConnectionOption[] = [
 			{
 				name: 'connectionName',
 				displayName: undefined,

src/sqltest/parts/connection/connectionStatusManager.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ConnectionStatusManager } from 'sql/platform/connection/common/connectionStatusManager';
 import * as Utils from 'sql/platform/connection/common/utils';
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
@@ -129,7 +129,7 @@ suite('SQL ConnectionStatusManager tests', () => {
 
 	test('addConnection should set connecting to true', () => {
 		let expected = true;
-		let summary: sqlops.ConnectionInfoSummary = {
+		let summary: azdata.ConnectionInfoSummary = {
 			ownerUri: connection1Id,
 			connectionId: connection1Id,
 			messages: undefined,
@@ -145,7 +145,7 @@ suite('SQL ConnectionStatusManager tests', () => {
 
 	test('onConnectionComplete should set connecting to false', () => {
 		let expected = false;
-		let summary: sqlops.ConnectionInfoSummary = {
+		let summary: azdata.ConnectionInfoSummary = {
 			ownerUri: connection1Id,
 			connectionId: connection1Id,
 			messages: undefined,
@@ -179,7 +179,7 @@ suite('SQL ConnectionStatusManager tests', () => {
 
 	test('updateDatabaseName should update the database name in connection', () => {
 		let dbName: string = 'db name';
-		let summary: sqlops.ConnectionInfoSummary = {
+		let summary: azdata.ConnectionInfoSummary = {
 			connectionSummary: {
 				databaseName: dbName,
 				serverName: undefined,
@@ -205,7 +205,7 @@ suite('SQL ConnectionStatusManager tests', () => {
 
 	test('getOriginalOwnerUri should return the original uri given uri with db name', () => {
 		let dbName: string = 'db name';
-		let summary: sqlops.ConnectionInfoSummary = {
+		let summary: azdata.ConnectionInfoSummary = {
 			connectionSummary: {
 				databaseName: dbName,
 				serverName: undefined,

src/sqltest/parts/connection/connectionStore.test.ts

@@ -15,7 +15,7 @@ import { CredentialsService } from 'sql/platform/credentials/common/credentialsS
 import * as assert from 'assert';
 import { Memento } from 'vs/workbench/common/memento';
 import { CapabilitiesService } from 'sql/platform/capabilities/common/capabilitiesService';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';
 import { Emitter } from 'vs/base/common/event';
 import { ConnectionProfileGroup, IConnectionProfileGroup } from 'sql/platform/connection/common/connectionProfileGroup';
@@ -119,7 +119,7 @@ suite('SQL ConnectionStore tests', () => {
 		};
 
 		capabilitiesService = new CapabilitiesTestService();
-		let connectionProvider: sqlops.ConnectionOption[] = [
+		let connectionProvider: azdata.ConnectionOption[] = [
 			{
 				name: 'connectionName',
 				displayName: undefined,

src/sqltest/parts/connection/objectExplorerService.test.ts

@@ -13,7 +13,7 @@ import { NodeType } from 'sql/parts/objectExplorer/common/nodeType';
 import { TreeNode, TreeItemCollapsibleState } from 'sql/parts/objectExplorer/common/treeNode';
 
 import { TPromise } from 'vs/base/common/winjs.base';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import * as assert from 'assert';
 import { ServerTreeView } from 'sql/parts/objectExplorer/viewlet/serverTreeView';
@@ -28,9 +28,9 @@ suite('SQL Object Explorer Service tests', () => {
 	let connectionToFail: ConnectionProfile;
 	let conProfGroup: ConnectionProfileGroup;
 	let objectExplorerService: ObjectExplorerService;
-	let objectExplorerSession: sqlops.ObjectExplorerSession;
-	let objectExplorerFailedSession: sqlops.ObjectExplorerSession;
-	let objectExplorerCloseSessionResponse: sqlops.ObjectExplorerCloseSessionResponse;
+	let objectExplorerSession: azdata.ObjectExplorerSession;
+	let objectExplorerFailedSession: azdata.ObjectExplorerSession;
+	let objectExplorerCloseSessionResponse: azdata.ObjectExplorerCloseSessionResponse;
 	let objectExplorerExpandInfo: NodeExpandInfoWithProviderId;
 	let objectExplorerExpandInfoRefresh: NodeExpandInfoWithProviderId;
 	let sessionId = '1234';
@@ -116,11 +116,11 @@ suite('SQL Object Explorer Service tests', () => {
 			nodePath: objectExplorerSession.rootNode.nodePath,
 			providerId: providerId
 		};
-		let response: sqlops.ObjectExplorerSessionResponse = {
+		let response: azdata.ObjectExplorerSessionResponse = {
 			sessionId: objectExplorerSession.sessionId
 		};
 
-		let failedResponse: sqlops.ObjectExplorerSessionResponse = {
+		let failedResponse: azdata.ObjectExplorerSessionResponse = {
 			sessionId: failedSessionId
 		};
 
@@ -273,10 +273,10 @@ suite('SQL Object Explorer Service tests', () => {
 
 		objectExplorerService = new ObjectExplorerService(connectionManagementService.object, undefined, capabilitiesService);
 		objectExplorerService.registerProvider('MSSQL', sqlOEProvider.object);
-		sqlOEProvider.setup(x => x.createNewSession(TypeMoq.It.is<sqlops.ConnectionInfo>(x => x.options['serverName'] === connection.serverName))).returns(() => new Promise<any>((resolve) => {
+		sqlOEProvider.setup(x => x.createNewSession(TypeMoq.It.is<azdata.ConnectionInfo>(x => x.options['serverName'] === connection.serverName))).returns(() => new Promise<any>((resolve) => {
 			resolve(response);
 		}));
-		sqlOEProvider.setup(x => x.createNewSession(TypeMoq.It.is<sqlops.ConnectionInfo>(x => x.options['serverName'] === connectionToFail.serverName))).returns(() => new Promise<any>((resolve) => {
+		sqlOEProvider.setup(x => x.createNewSession(TypeMoq.It.is<azdata.ConnectionInfo>(x => x.options['serverName'] === connectionToFail.serverName))).returns(() => new Promise<any>((resolve) => {
 			resolve(failedResponse);
 		}));
 		sqlOEProvider.setup(x => x.expandNode(TypeMoq.It.isAny())).callback(() => {

src/sqltest/parts/connection/providerConnectionInfo.test.ts

@@ -8,7 +8,7 @@
 
 import { ProviderConnectionInfo } from 'sql/platform/connection/common/providerConnectionInfo';
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { ICapabilitiesService } from 'sql/platform/capabilities/common/capabilitiesService';
@@ -37,8 +37,8 @@ suite('SQL ProviderConnectionInfo tests', () => {
 	};
 
 	setup(() => {
-		let capabilities: sqlops.DataProtocolServerCapabilities[] = [];
-		let connectionProvider: sqlops.ConnectionOption[] = [
+		let capabilities: azdata.DataProtocolServerCapabilities[] = [];
+		let connectionProvider: azdata.ConnectionOption[] = [
 			{
 				name: 'connectionName',
 				displayName: undefined,

src/sqltest/parts/disasterRecovery/restoreViewModel.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import { RestoreViewModel } from 'sql/parts/disasterRecovery/restore/restoreViewModel';
 import { ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
@@ -14,14 +14,14 @@ suite('Restore Dialog view model tests', () => {
 	let option2Category = 'option2';
 	let option3Boolean = 'option3';
 	let options: { [name: string]: any };
-	let stringServiceOption: sqlops.ServiceOption;
-	let categoryServiceOption: sqlops.ServiceOption;
-	let booleanServiceOption: sqlops.ServiceOption;
+	let stringServiceOption: azdata.ServiceOption;
+	let categoryServiceOption: azdata.ServiceOption;
+	let booleanServiceOption: azdata.ServiceOption;
 
 	let viewModel: RestoreViewModel;
 
-	let planDetails: { [key: string]: sqlops.RestorePlanDetailInfo };
-	let backupSets: sqlops.DatabaseFileInfo[];
+	let planDetails: { [key: string]: azdata.RestorePlanDetailInfo };
+	let backupSets: azdata.DatabaseFileInfo[];
 
 	setup(() => {
 		options = {};
@@ -168,7 +168,7 @@ suite('Restore Dialog view model tests', () => {
 	});
 
 	test('on restore plan response should update all options from restore plan response correctly', () => {
-		let restorePlanResponse: sqlops.RestorePlanResponse = {
+		let restorePlanResponse: azdata.RestorePlanResponse = {
 			sessionId: '123',
 			backupSetsToRestore: backupSets,
 			canRestore: true,
@@ -198,7 +198,7 @@ suite('Restore Dialog view model tests', () => {
 
 
 	test('on reset restore options should reset all options', () => {
-		let restorePlanResponse: sqlops.RestorePlanResponse = {
+		let restorePlanResponse: azdata.RestorePlanResponse = {
 			sessionId: '123',
 			backupSetsToRestore: backupSets,
 			canRestore: true,

src/sqltest/parts/grid/services/sharedServices.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import * as SharedServices from 'sql/parts/grid/services/sharedServices';
 

src/sqltest/parts/insights/insightsDialogController.test.ts

@@ -12,7 +12,7 @@ import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
 
 import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
 
-import { IDbColumn, BatchSummary, QueryExecuteSubsetResult, ResultSetSubset } from 'sqlops';
+import { IDbColumn, BatchSummary, QueryExecuteSubsetResult, ResultSetSubset } from 'azdata';
 import { EventEmitter } from 'sql/base/common/eventEmitter';
 import { equal } from 'assert';
 import { Mock, MockBehavior, It } from 'typemoq';

src/sqltest/parts/notebook/common.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { nb, IConnectionProfile } from 'sqlops';
+import { nb, IConnectionProfile } from 'azdata';
 
 import { Event, Emitter } from 'vs/base/common/event';
 import { INotebookModel, ICellModel, IClientSession, IDefaultConnection, NotebookContentChange } from 'sql/parts/notebook/models/modelInterfaces';

src/sqltest/parts/notebook/model/cell.test.ts

@@ -7,7 +7,7 @@
 
 import * as should from 'should';
 import * as TypeMoq from 'typemoq';
-import { nb } from 'sqlops';
+import { nb } from 'azdata';
 
 import * as objects from 'vs/base/common/objects';
 

src/sqltest/parts/notebook/model/clientSession.test.ts

@@ -8,7 +8,7 @@
 
 import * as should from 'should';
 import * as TypeMoq from 'typemoq';
-import { nb } from 'sqlops';
+import { nb } from 'azdata';
 
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { TestNotificationService } from 'vs/platform/notification/test/common/testNotificationService';

src/sqltest/parts/notebook/model/contentManagers.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as should from 'should';
-import { nb } from 'sqlops';
+import { nb } from 'azdata';
 
 import { URI } from 'vs/base/common/uri';
 import * as tempWrite from 'temp-write';

src/sqltest/parts/notebook/model/notebookModel.test.ts

@@ -7,7 +7,7 @@
 
 import * as should from 'should';
 import * as TypeMoq from 'typemoq';
-import { nb } from 'sqlops';
+import { nb } from 'azdata';
 
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { TestNotificationService } from 'vs/platform/notification/test/common/testNotificationService';

src/sqltest/parts/notebook/model/notebookUtils.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as should from 'should';
-import { nb, IConnectionProfile } from 'sqlops';
+import { nb, IConnectionProfile } from 'azdata';
 
 import { CapabilitiesTestService } from 'sqltest/stubs/capabilitiesTestService';
 import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';

src/sqltest/parts/query/editor/queryActions.test.ts

@@ -7,7 +7,7 @@
 import { Emitter } from 'vs/base/common/event';
 import { TPromise } from 'vs/base/common/winjs.base';
 
-import { ISelectionData } from 'sqlops';
+import { ISelectionData } from 'azdata';
 
 import {
 	IConnectionManagementService,

src/sqltest/services/accountManagement/accountManagementService.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import AccountStore from 'sql/platform/accountManagement/common/accountStore';
 import { AccountDialogController } from 'sql/parts/accountManagement/accountDialog/accountDialogController';
@@ -18,16 +18,16 @@ import { EventVerifierSingle } from 'sqltest/utils/eventVerifier';
 import { InstantiationService } from 'vs/platform/instantiation/common/instantiationService';
 
 // SUITE CONSTANTS /////////////////////////////////////////////////////////
-const hasAccountProvider: sqlops.AccountProviderMetadata = {
+const hasAccountProvider: azdata.AccountProviderMetadata = {
 	id: 'hasAccounts',
 	displayName: 'Provider with Accounts'
 };
-const noAccountProvider: sqlops.AccountProviderMetadata = {
+const noAccountProvider: azdata.AccountProviderMetadata = {
 	id: 'noAccounts',
 	displayName: 'Provider without Accounts'
 };
 
-const account: sqlops.Account = {
+const account: azdata.Account = {
 	key: {
 		providerId: hasAccountProvider.id,
 		accountId: 'testAccount1'
@@ -40,7 +40,7 @@ const account: sqlops.Account = {
 	isStale: false,
 	properties: {}
 };
-const accountList: sqlops.Account[] = [account];
+const accountList: azdata.Account[] = [account];
 
 suite('Account Management Service Tests:', () => {
 	test('Constructor', () => {
@@ -69,7 +69,7 @@ suite('Account Management Service Tests:', () => {
 			.returns(() => Promise.resolve(true));
 
 		// ... Register a account provider with the management service
-		let mockProvider = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+		let mockProvider = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 		mockProvider.setup(x => x.clear(TypeMoq.It.isAny())).returns(() => Promise.resolve());
 		state.accountManagementService._providers[hasAccountProvider.id] = {
 			accounts: [account],
@@ -102,7 +102,7 @@ suite('Account Management Service Tests:', () => {
 			}));
 
 		// ... Register a account provider with the management service
-		let mockProvider = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+		let mockProvider = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 		mockProvider.setup(x => x.clear(TypeMoq.It.isAny())).returns(() => Promise.resolve());
 		state.accountManagementService._providers[hasAccountProvider.id] = {
 			accounts: [account],
@@ -364,7 +364,7 @@ suite('Account Management Service Tests:', () => {
 			.returns(() => Promise.resolve(true));
 
 		// ... Register a account provider with the management service
-		let mockProvider = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+		let mockProvider = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 		mockProvider.setup(x => x.clear(TypeMoq.It.isAny())).returns(() => Promise.resolve());
 		state.accountManagementService._providers[hasAccountProvider.id] = {
 			accounts: [account],
@@ -571,7 +571,7 @@ function getTestState(): AccountManagementState {
 	// Wire up event handlers
 	let evUpdate = new EventVerifierSingle<UpdateAccountListEventParams>();
 	let evAddProvider = new EventVerifierSingle<AccountProviderAddedEventParams>();
-	let evRemoveProvider = new EventVerifierSingle<sqlops.AccountProviderMetadata>();
+	let evRemoveProvider = new EventVerifierSingle<azdata.AccountProviderMetadata>();
 	ams.updateAccountListEvent(evUpdate.eventHandler);
 	ams.addAccountProviderEvent(evAddProvider.eventHandler);
 	ams.removeAccountProviderEvent(evRemoveProvider.eventHandler);
@@ -587,8 +587,8 @@ function getTestState(): AccountManagementState {
 	};
 }
 
-function getMockAccountProvider(): TypeMoq.Mock<sqlops.AccountProvider> {
-	let mockProvider = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+function getMockAccountProvider(): TypeMoq.Mock<azdata.AccountProvider> {
+	let mockProvider = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 	mockProvider.setup(x => x.clear(TypeMoq.It.isAny())).returns(() => Promise.resolve());
 	mockProvider.setup(x => x.initialize(TypeMoq.It.isAny())).returns(param => Promise.resolve(param));
 	mockProvider.setup(x => x.prompt()).returns(() => Promise.resolve(account));
@@ -596,8 +596,8 @@ function getMockAccountProvider(): TypeMoq.Mock<sqlops.AccountProvider> {
 	return mockProvider;
 }
 
-function getFailingMockAccountProvider(cancel: boolean): TypeMoq.Mock<sqlops.AccountProvider> {
-	let mockProvider = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+function getFailingMockAccountProvider(cancel: boolean): TypeMoq.Mock<azdata.AccountProvider> {
+	let mockProvider = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 	mockProvider.setup(x => x.clear(TypeMoq.It.isAny()))
 		.returns(() => Promise.resolve());
 	mockProvider.setup(x => x.initialize(TypeMoq.It.isAny()))
@@ -605,13 +605,13 @@ function getFailingMockAccountProvider(cancel: boolean): TypeMoq.Mock<sqlops.Acc
 	mockProvider.setup(x => x.prompt())
 		.returns(() => {
 			return cancel
-				? Promise.reject(<sqlops.UserCancelledSignInError>{ userCancelledSignIn: true }).then()
+				? Promise.reject(<azdata.UserCancelledSignInError>{ userCancelledSignIn: true }).then()
 				: Promise.reject(new Error()).then();
 		});
 	mockProvider.setup(x => x.refresh(TypeMoq.It.isAny()))
 		.returns(() => {
 			return cancel
-				? Promise.reject(<sqlops.UserCancelledSignInError>{ userCancelledSignIn: true }).then()
+				? Promise.reject(<azdata.UserCancelledSignInError>{ userCancelledSignIn: true }).then()
 				: Promise.reject(new Error()).then();
 		});
 	return mockProvider;
@@ -623,5 +623,5 @@ interface AccountManagementState {
 	mockAccountStore: TypeMoq.Mock<IAccountStore>;
 	eventVerifierUpdate: EventVerifierSingle<UpdateAccountListEventParams>;
 	eventVerifierProviderAdded: EventVerifierSingle<AccountProviderAddedEventParams>;
-	eventVerifierProviderRemoved: EventVerifierSingle<sqlops.AccountProviderMetadata>;
+	eventVerifierProviderRemoved: EventVerifierSingle<azdata.AccountProviderMetadata>;
 }

src/sqltest/services/accountManagement/accountStore.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import AccountStore from 'sql/platform/accountManagement/common/accountStore';
 import { EventVerifierSingle } from 'sqltest/utils/eventVerifier';
 
@@ -68,7 +68,7 @@ suite('Account Store Tests', () => {
 		let as = new AccountStore(memento);
 
 		// If: I add an account to the store that already exists
-		let param = <sqlops.Account>{
+		let param = <azdata.Account>{
 			key: account2.key,
 			displayInfo: account1.displayInfo,
 			isStale: account1.isStale
@@ -308,7 +308,7 @@ suite('Account Store Tests', () => {
 		let as = new AccountStore(memento);
 
 		// ... Create a callback that we can verify was called
-		let updateCallback = new EventVerifierSingle<sqlops.Account>();
+		let updateCallback = new EventVerifierSingle<azdata.Account>();
 
 		// If: I update an account
 		as.update(account1.key, updateCallback.eventHandler)
@@ -337,7 +337,7 @@ suite('Account Store Tests', () => {
 		let as = new AccountStore(memento);
 
 		// ... Create a callback that we can verify was called
-		let updateCallback = new EventVerifierSingle<sqlops.Account>();
+		let updateCallback = new EventVerifierSingle<azdata.Account>();
 
 		// If: I update an account that doesn't exist
 		as.update({ accountId: 'testyTest', providerId: 'cloudyCloud' }, updateCallback.eventHandler)
@@ -366,7 +366,7 @@ suite('Account Store Tests', () => {
 
 		// ... Create a callback to update the account
 		let newDisplayName = 'Display Name Changed!';
-		let updateCallback = (arg: sqlops.Account) => {
+		let updateCallback = (arg: azdata.Account) => {
 			arg.displayInfo.displayName = newDisplayName;
 		};
 
@@ -397,7 +397,7 @@ suite('Account Store Tests', () => {
 });
 
 // TODO: Reinstate contextual logo once UI changes are checked in
-const account1 = <sqlops.Account>{
+const account1 = <azdata.Account>{
 	key: {
 		providerId: 'azure',
 		accountId: 'testAccount1'
@@ -410,7 +410,7 @@ const account1 = <sqlops.Account>{
 	isStale: false
 };
 
-const account2 = <sqlops.Account>{
+const account2 = <azdata.Account>{
 	key: {
 		providerId: 'azure',
 		accountId: 'testAccount2'
@@ -430,7 +430,7 @@ function getTestMemento() {
 	return memento;
 }
 
-function assertAccountEqual(a: sqlops.Account, b: sqlops.Account) {
+function assertAccountEqual(a: azdata.Account, b: azdata.Account) {
 	assert.equal(a.key.providerId, b.key.providerId);
 	assert.equal(a.key.accountId, b.key.accountId);
 

src/sqltest/stubs/accountManagementStubs.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Event } from 'vs/base/common/event';
 import { IAccountManagementService } from 'sql/platform/accountManagement/common/interfaces';
 import { AccountProviderAddedEventParams, UpdateAccountListEventParams } from 'sql/platform/accountManagement/common/eventTypes';
@@ -15,10 +15,10 @@ export class AccountManagementTestService implements IAccountManagementService {
 	_serviceBrand: any;
 
 	public get addAccountProviderEvent(): Event<AccountProviderAddedEventParams> { return () => { return undefined; }; }
-	public get removeAccountProviderEvent(): Event<sqlops.AccountProviderMetadata> { return () => { return undefined; }; }
+	public get removeAccountProviderEvent(): Event<azdata.AccountProviderMetadata> { return () => { return undefined; }; }
 	public get updateAccountListEvent(): Event<UpdateAccountListEventParams> { return () => { return undefined; }; }
 
-	accountUpdated(account: sqlops.Account): Thenable<void> {
+	accountUpdated(account: azdata.Account): Thenable<void> {
 		return undefined;
 	}
 
@@ -42,23 +42,23 @@ export class AccountManagementTestService implements IAccountManagementService {
 		return undefined;
 	}
 
-	getAccountProviderMetadata(): Thenable<sqlops.AccountProviderMetadata[]> {
+	getAccountProviderMetadata(): Thenable<azdata.AccountProviderMetadata[]> {
 		return undefined;
 	}
 
-	getAccountsForProvider(providerId: string): Thenable<sqlops.Account[]> {
+	getAccountsForProvider(providerId: string): Thenable<azdata.Account[]> {
 		return undefined;
 	}
 
-	getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
+	getSecurityToken(account: azdata.Account, resource: azdata.AzureResource): Thenable<{}> {
 		return undefined;
 	}
 
-	removeAccount(accountKey: sqlops.AccountKey): Thenable<boolean> {
+	removeAccount(accountKey: azdata.AccountKey): Thenable<boolean> {
 		return undefined;
 	}
 
-	refreshAccount(account: sqlops.Account): Thenable<sqlops.Account> {
+	refreshAccount(account: azdata.Account): Thenable<azdata.Account> {
 		return undefined;
 	}
 
@@ -66,7 +66,7 @@ export class AccountManagementTestService implements IAccountManagementService {
 		return undefined;
 	}
 
-	registerProvider(providerMetadata: sqlops.AccountProviderMetadata, provider: sqlops.AccountProvider): void {
+	registerProvider(providerMetadata: azdata.AccountProviderMetadata, provider: azdata.AccountProvider): void {
 		return undefined;
 	}
 
@@ -74,33 +74,33 @@ export class AccountManagementTestService implements IAccountManagementService {
 		return undefined;
 	}
 
-	unregisterProvider(providerMetadata: sqlops.AccountProviderMetadata): void {
+	unregisterProvider(providerMetadata: azdata.AccountProviderMetadata): void {
 		return undefined;
 	}
 }
 
-export class AccountProviderStub implements sqlops.AccountProvider {
+export class AccountProviderStub implements azdata.AccountProvider {
 	autoOAuthCancelled(): Thenable<void> {
 		return Promise.resolve();
 	}
 
-	clear(account: sqlops.AccountKey): Thenable<void> {
+	clear(account: azdata.AccountKey): Thenable<void> {
 		return Promise.resolve();
 	}
 
-	getSecurityToken(account: sqlops.Account, resource: sqlops.AzureResource): Thenable<{}> {
+	getSecurityToken(account: azdata.Account, resource: azdata.AzureResource): Thenable<{}> {
 		return Promise.resolve({});
 	}
 
-	initialize(storedAccounts: sqlops.Account[]): Thenable<sqlops.Account[]> {
+	initialize(storedAccounts: azdata.Account[]): Thenable<azdata.Account[]> {
 		return Promise.resolve(storedAccounts);
 	}
 
-	prompt(): Thenable<sqlops.Account> {
+	prompt(): Thenable<azdata.Account> {
 		return Promise.resolve(undefined);
 	}
 
-	refresh(account: sqlops.Account): Thenable<sqlops.Account> {
+	refresh(account: azdata.Account): Thenable<azdata.Account> {
 		return Promise.resolve(account);
 	}
 }

src/sqltest/stubs/capabilitiesTestService.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 'use strict';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ConnectionManagementInfo } from 'sql/platform/connection/common/connectionManagementInfo';
 import { ICapabilitiesService, ProviderFeatures } from 'sql/platform/capabilities/common/capabilitiesService';
 import { ConnectionOptionSpecialType, ServiceOptionType } from 'sql/workbench/api/common/sqlExtHostTypes';
@@ -20,7 +20,7 @@ export class CapabilitiesTestService implements ICapabilitiesService {
 
 	constructor() {
 
-		let connectionProvider: sqlops.ConnectionOption[] = [
+		let connectionProvider: azdata.ConnectionOption[] = [
 			{
 				name: 'connectionName',
 				displayName: undefined,
@@ -110,7 +110,7 @@ export class CapabilitiesTestService implements ICapabilitiesService {
 		return this.capabilities[provider];
 	}
 
-	public getLegacyCapabilities(provider: string): sqlops.DataProtocolServerCapabilities {
+	public getLegacyCapabilities(provider: string): azdata.DataProtocolServerCapabilities {
 		throw new Error('Method not implemented.');
 	}
 
@@ -122,11 +122,11 @@ export class CapabilitiesTestService implements ICapabilitiesService {
 	 * Register the capabilities provider and query the provider for its capabilities
 	 * @param provider
 	 */
-	public registerProvider(provider: sqlops.CapabilitiesProvider): void {
+	public registerProvider(provider: azdata.CapabilitiesProvider): void {
 	}
 
 	// Event Emitters
-	public get onProviderRegisteredEvent(): Event<sqlops.DataProtocolServerCapabilities> {
+	public get onProviderRegisteredEvent(): Event<azdata.DataProtocolServerCapabilities> {
 		return undefined;
 	}
 

src/sqltest/stubs/connectionManagementService.test.ts

@@ -9,7 +9,7 @@ import { IConnectionProfileGroup, ConnectionProfileGroup } from 'sql/platform/co
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
 import { ConnectionProfile } from 'sql/platform/connection/common/connectionProfile';
 import { ConnectionManagementInfo } from 'sql/platform/connection/common/connectionManagementInfo';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Event, Emitter } from 'vs/base/common/event';
 
 // Test stubs for commonly used objects
@@ -31,7 +31,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return conEvent.event;
 	}
 
-	registerProvider(providerId: string, provider: sqlops.ConnectionProvider): void {
+	registerProvider(providerId: string, provider: azdata.ConnectionProvider): void {
 
 	}
 
@@ -47,7 +47,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return undefined;
 	}
 
-	onConnectionComplete(handle: number, connectionInfoSummary: sqlops.ConnectionInfoSummary): void {
+	onConnectionComplete(handle: number, connectionInfoSummary: azdata.ConnectionInfoSummary): void {
 
 	}
 
@@ -55,11 +55,11 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 
 	}
 
-	public onConnectionChangedNotification(handle: number, changedConnInfo: sqlops.ChangedConnectionInfo): void {
+	public onConnectionChangedNotification(handle: number, changedConnInfo: azdata.ChangedConnectionInfo): void {
 
 	}
 
-	getCurrentConnectionSummary(): sqlops.ConnectionSummary {
+	getCurrentConnectionSummary(): azdata.ConnectionSummary {
 		return undefined;
 	}
 
@@ -111,7 +111,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		});
 	}
 
-	getAdvancedProperties(): sqlops.ConnectionOption[] {
+	getAdvancedProperties(): azdata.ConnectionOption[] {
 		return [];
 	}
 
@@ -181,7 +181,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return new Promise<IConnectionProfile>(() => connectionProfile);
 	}
 
-	public listDatabases(connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
+	public listDatabases(connectionUri: string): Thenable<azdata.ListDatabasesResult> {
 		return Promise.resolve(undefined);
 	}
 
@@ -215,7 +215,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return true;
 	}
 
-	getCapabilities(providerName: string): sqlops.DataProtocolServerCapabilities {
+	getCapabilities(providerName: string): azdata.DataProtocolServerCapabilities {
 		return undefined;
 	}
 
@@ -254,7 +254,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return undefined;
 	}
 
-	getServerInfo(profileId: string): sqlops.ServerInfo {
+	getServerInfo(profileId: string): azdata.ServerInfo {
 		return undefined;
 	}
 
@@ -262,7 +262,7 @@ export class TestConnectionManagementService implements IConnectionManagementSer
 		return undefined;
 	}
 
-	buildConnectionInfo(connectionString: string, provider?: string): Thenable<sqlops.ConnectionInfo> {
+	buildConnectionInfo(connectionString: string, provider?: string): Thenable<azdata.ConnectionInfo> {
 		return undefined;
 	}
 

src/sqltest/stubs/connectionProviderStub.ts

@@ -3,12 +3,12 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
-export class ConnectionProviderStub implements sqlops.ConnectionProvider {
+export class ConnectionProviderStub implements azdata.ConnectionProvider {
 	public readonly providerId = 'MSSQL';
 
-	connect(connectionUri: string, connectionInfo: sqlops.ConnectionInfo): Thenable<boolean> {
+	connect(connectionUri: string, connectionInfo: azdata.ConnectionInfo): Thenable<boolean> {
 		return undefined;
 	}
 
@@ -20,7 +20,7 @@ export class ConnectionProviderStub implements sqlops.ConnectionProvider {
 		return undefined;
 	}
 
-	listDatabases(connectionUri: string): Thenable<sqlops.ListDatabasesResult> {
+	listDatabases(connectionUri: string): Thenable<azdata.ListDatabasesResult> {
 		return undefined;
 	}
 
@@ -36,7 +36,7 @@ export class ConnectionProviderStub implements sqlops.ConnectionProvider {
 		return undefined;
 	}
 
-	registerOnConnectionComplete(handler: (connSummary: sqlops.ConnectionInfoSummary) => any) {
+	registerOnConnectionComplete(handler: (connSummary: azdata.ConnectionInfoSummary) => any) {
 		return undefined;
 	}
 
@@ -44,7 +44,7 @@ export class ConnectionProviderStub implements sqlops.ConnectionProvider {
 		return undefined;
 	}
 
-	registerOnConnectionChanged(handler: (changedConnInfo: sqlops.ChangedConnectionInfo) => any) {
+	registerOnConnectionChanged(handler: (changedConnInfo: azdata.ChangedConnectionInfo) => any) {
 		return undefined;
 	}
 }

src/sqltest/stubs/credentialsTestStubs.ts

@@ -5,15 +5,15 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { CredentialManagementEvents, ICredentialsService } from 'sql/platform/credentials/common/credentialsService';
 import { IDisposable } from 'vs/base/common/lifecycle';
 
-export class CredentialsTestProvider implements sqlops.CredentialProvider {
+export class CredentialsTestProvider implements azdata.CredentialProvider {
 	handle: number;
 
-	public storedCredentials: { [K: string]: sqlops.Credential } = {};
+	public storedCredentials: { [K: string]: azdata.Credential } = {};
 
 	saveCredential(credentialId: string, password: string): Thenable<boolean> {
 		this.storedCredentials[credentialId] = {
@@ -23,7 +23,7 @@ export class CredentialsTestProvider implements sqlops.CredentialProvider {
 		return TPromise.as(true);
 	}
 
-	readCredential(credentialId: string): Thenable<sqlops.Credential> {
+	readCredential(credentialId: string): Thenable<azdata.Credential> {
 		return TPromise.as(this.storedCredentials[credentialId]);
 	}
 
@@ -41,7 +41,7 @@ export class CredentialsTestService implements ICredentialsService {
 		return undefined;
 	}
 
-	readCredential(credentialId: string): Thenable<sqlops.Credential> {
+	readCredential(credentialId: string): Thenable<azdata.Credential> {
 		return undefined;
 	}
 

src/sqltest/stubs/objectExplorerProviderTestService.ts

@@ -2,43 +2,43 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 
 // Test stubs for commonly used objects
 
-export class ObjectExplorerProviderTestService implements sqlops.ObjectExplorerProvider {
+export class ObjectExplorerProviderTestService implements azdata.ObjectExplorerProvider {
 
 	public readonly providerId = 'MSSQL';
 
-	public createNewSession(connInfo: sqlops.ConnectionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
+	public createNewSession(connInfo: azdata.ConnectionInfo): Thenable<azdata.ObjectExplorerCloseSessionResponse> {
 		return Promise.resolve(undefined);
 	}
 
-	public expandNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+	public expandNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 		return Promise.resolve(undefined);
 	}
 
-	public refreshNode(nodeInfo: sqlops.ExpandNodeInfo): Thenable<boolean> {
+	public refreshNode(nodeInfo: azdata.ExpandNodeInfo): Thenable<boolean> {
 		return Promise.resolve(undefined);
 	}
 
-	public closeSession(closeSessionInfo: sqlops.ObjectExplorerCloseSessionInfo): Thenable<sqlops.ObjectExplorerCloseSessionResponse> {
+	public closeSession(closeSessionInfo: azdata.ObjectExplorerCloseSessionInfo): Thenable<azdata.ObjectExplorerCloseSessionResponse> {
 		return Promise.resolve(undefined);
 	}
 
-	public registerOnSessionCreated(handler: (response: sqlops.ObjectExplorerSession) => any): void {
+	public registerOnSessionCreated(handler: (response: azdata.ObjectExplorerSession) => any): void {
 
 	}
 
-	public registerOnSessionDisconnected(handler: (response: sqlops.ObjectExplorerSession) => any): void {
+	public registerOnSessionDisconnected(handler: (response: azdata.ObjectExplorerSession) => any): void {
 
 	}
 
-	public registerOnExpandCompleted(handler: (response: sqlops.ObjectExplorerExpandInfo) => any): void {
+	public registerOnExpandCompleted(handler: (response: azdata.ObjectExplorerExpandInfo) => any): void {
 
 	}
 
-	public findNodes(findNodesInfo: sqlops.FindNodesInfo): Thenable<sqlops.ObjectExplorerFindNodesResponse> {
+	public findNodes(findNodesInfo: azdata.FindNodesInfo): Thenable<azdata.ObjectExplorerFindNodesResponse> {
 		return undefined;
 	}
 }

src/sqltest/stubs/resourceProviderServiceStub.ts

@@ -3,14 +3,14 @@
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { IHandleFirewallRuleResult, IResourceProviderService } from 'sql/workbench/services/resourceProvider/common/resourceProviderService';
 import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
 
 export class ResourceProviderStub implements IResourceProviderService {
 	_serviceBrand: any;
 
-	registerProvider(providerId: string, provider: sqlops.ResourceProvider) {
+	registerProvider(providerId: string, provider: azdata.ResourceProvider) {
 
 	}
 
@@ -18,7 +18,7 @@ export class ResourceProviderStub implements IResourceProviderService {
 
 	}
 
-	createFirewallRule(selectedAccount: sqlops.Account, firewallruleInfo: sqlops.FirewallRuleInfo, resourceProviderId: string): Promise<sqlops.CreateFirewallRuleResponse> {
+	createFirewallRule(selectedAccount: azdata.Account, firewallruleInfo: azdata.FirewallRuleInfo, resourceProviderId: string): Promise<azdata.CreateFirewallRuleResponse> {
 		return undefined;
 	}
 

src/sqltest/workbench/api/extHostAccountManagement.test.ts

@@ -6,7 +6,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as TypeMoq from 'typemoq';
 import { AccountProviderStub, AccountManagementTestService } from 'sqltest/stubs/accountManagementStubs';
 import { ExtHostAccountManagement } from 'sql/workbench/api/node/extHostAccountManagement';
@@ -22,8 +22,8 @@ const IRPCProtocol = createDecorator<IRPCProtocol>('rpcProtocol');
 
 // SUITE STATE /////////////////////////////////////////////////////////////
 let instantiationService: TestInstantiationService;
-let mockAccountMetadata: sqlops.AccountProviderMetadata;
-let mockAccount: sqlops.Account;
+let mockAccountMetadata: azdata.AccountProviderMetadata;
+let mockAccount: azdata.Account;
 let threadService: TestRPCProtocol;
 
 // TESTS ///////////////////////////////////////////////////////////////////
@@ -428,8 +428,8 @@ suite('ExtHostAccountManagement', () => {
 	});
 });
 
-function getMockAccountProvider(): TypeMoq.Mock<sqlops.AccountProvider> {
-	let mock = TypeMoq.Mock.ofType<sqlops.AccountProvider>(AccountProviderStub);
+function getMockAccountProvider(): TypeMoq.Mock<azdata.AccountProvider> {
+	let mock = TypeMoq.Mock.ofType<azdata.AccountProvider>(AccountProviderStub);
 	mock.setup((obj) => obj.clear(TypeMoq.It.isValue(mockAccount.key)))
 		.returns(() => Promise.resolve(undefined));
 	mock.setup((obj) => obj.refresh(TypeMoq.It.isValue(mockAccount)))
@@ -442,7 +442,7 @@ function getMockAccountProvider(): TypeMoq.Mock<sqlops.AccountProvider> {
 	return mock;
 }
 
-function getMockAccountManagementService(accounts: sqlops.Account[]): TypeMoq.Mock<AccountManagementTestService> {
+function getMockAccountManagementService(accounts: azdata.Account[]): TypeMoq.Mock<AccountManagementTestService> {
 	let mockAccountManagementService = TypeMoq.Mock.ofType(AccountManagementTestService);
 
 	mockAccountManagementService.setup(x => x.getAccountsForProvider(TypeMoq.It.isAny()))

src/sqltest/workbench/api/extHostBackgroundTaskManagement.test.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import { Mock, It, Times } from 'typemoq';
 import { ExtHostBackgroundTaskManagement, TaskStatus } from 'sql/workbench/api/node/extHostBackgroundTaskManagement';
@@ -21,8 +21,8 @@ suite('ExtHostBackgroundTaskManagement Tests', () => {
 	setup(() => {
 		mockProxy = Mock.ofInstance(<MainThreadBackgroundTaskManagementShape>{
 
-			$registerTask: (taskInfo: sqlops.TaskInfo) => nothing,
-			$updateTask: (taskProgressInfo: sqlops.TaskProgressInfo) => nothing
+			$registerTask: (taskInfo: azdata.TaskInfo) => nothing,
+			$updateTask: (taskProgressInfo: azdata.TaskProgressInfo) => nothing
 		});
 		let mainContext = <IMainContext>{
 			getProxy: proxyType => mockProxy.object
@@ -35,12 +35,12 @@ suite('ExtHostBackgroundTaskManagement Tests', () => {
 	});
 
 	test('RegisterTask should successfully create background task and update status', () => {
-		let operationInfo: sqlops.BackgroundOperationInfo = {
+		let operationInfo: azdata.BackgroundOperationInfo = {
 			connection: undefined,
 			description: 'description',
 			displayName: 'displayName',
 			isCancelable: true,
-			operation: (op: sqlops.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
+			operation: (op: azdata.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
 			operationId: operationId
 		};
 		extHostBackgroundTaskManagement.$registerTask(operationInfo);
@@ -56,12 +56,12 @@ suite('ExtHostBackgroundTaskManagement Tests', () => {
 	});
 
 	test('Canceling the task should notify the extension', () => {
-		let operationInfo: sqlops.BackgroundOperationInfo = {
+		let operationInfo: azdata.BackgroundOperationInfo = {
 			connection: undefined,
 			description: 'description',
 			displayName: 'displayName',
 			isCancelable: true,
-			operation: (op: sqlops.BackgroundOperation) => {
+			operation: (op: azdata.BackgroundOperation) => {
 				op.onCanceled(() => {
 					op.updateStatus(TaskStatus.Canceled);
 				});
@@ -76,12 +76,12 @@ suite('ExtHostBackgroundTaskManagement Tests', () => {
 	});
 
 	test('RegisterTask should assign unique id to the operation is not assigned', () => {
-		let operationInfo: sqlops.BackgroundOperationInfo = {
+		let operationInfo: azdata.BackgroundOperationInfo = {
 			connection: undefined,
 			description: 'description',
 			displayName: 'displayName',
 			isCancelable: true,
-			operation: (op: sqlops.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
+			operation: (op: azdata.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
 			operationId: undefined
 		};
 		extHostBackgroundTaskManagement.$registerTask(operationInfo);
@@ -91,12 +91,12 @@ suite('ExtHostBackgroundTaskManagement Tests', () => {
 	});
 
 	test('RegisterTask should fail given id of an existing operation', () => {
-		let operationInfo: sqlops.BackgroundOperationInfo = {
+		let operationInfo: azdata.BackgroundOperationInfo = {
 			connection: undefined,
 			description: 'description',
 			displayName: 'displayName',
 			isCancelable: true,
-			operation: (op: sqlops.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
+			operation: (op: azdata.BackgroundOperation) => { op.updateStatus(TaskStatus.Succeeded); },
 			operationId: operationId
 		};
 		extHostBackgroundTaskManagement.$registerTask(operationInfo);

src/sqltest/workbench/api/extHostCredentialManagement.test.ts

@@ -14,7 +14,7 @@ import { IRPCProtocol } from 'vs/workbench/services/extensions/node/proxyIdentif
 import { MainThreadCredentialManagement } from 'sql/workbench/api/node/mainThreadCredentialManagement';
 import { CredentialsTestProvider, CredentialsTestService } from 'sqltest/stubs/credentialsTestStubs';
 import { ICredentialsService } from 'sql/platform/credentials/common/credentialsService';
-import { Credential, CredentialProvider } from 'sqlops';
+import { Credential, CredentialProvider } from 'azdata';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
 
 const IRPCProtocol = createDecorator<IRPCProtocol>('rpcProtocol');

src/sqltest/workbench/api/extHostDataProtocol.test.ts

@@ -7,7 +7,7 @@
 
 import * as assert from 'assert';
 import { Mock } from 'typemoq';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ExtHostDataProtocol } from 'sql/workbench/api/node/extHostDataProtocol';
 import { DataProviderType } from 'sql/workbench/api/common/sqlExtHostTypes';
 import { ProxyAuthHandler } from 'vs/code/electron-main/auth';
@@ -36,7 +36,7 @@ suite('ExtHostDataProtocol', () => {
 			getTableInfo: () => undefined,
 			getViewInfo: () => undefined,
 			providerId: extension1Id
-		} as sqlops.MetadataProvider);
+		} as azdata.MetadataProvider);
 
 		let extension2Id = 'provider2';
 		let extension2MetadataMock = Mock.ofInstance({
@@ -45,15 +45,15 @@ suite('ExtHostDataProtocol', () => {
 			getTableInfo: () => undefined,
 			getViewInfo: () => undefined,
 			providerId: extension2Id
-		} as sqlops.MetadataProvider);
+		} as azdata.MetadataProvider);
 
 		// If I register both providers and then get them using the getProvider API
 		extHostDataProtocol.$registerMetadataProvider(extension1MetadataMock.object);
 		extHostDataProtocol.$registerMetadataProvider(extension2MetadataMock.object);
-		extHostDataProtocol.$registerConnectionProvider({} as sqlops.ConnectionProvider);
-		let retrievedProvider1 = extHostDataProtocol.getProvider<sqlops.MetadataProvider>(extension1Id, DataProviderType.MetadataProvider);
-		let retrievedProvider2 = extHostDataProtocol.getProvider<sqlops.MetadataProvider>(extension2Id, DataProviderType.MetadataProvider);
-		let allProviders = extHostDataProtocol.getProvidersByType<sqlops.MetadataProvider>(DataProviderType.MetadataProvider);
+		extHostDataProtocol.$registerConnectionProvider({} as azdata.ConnectionProvider);
+		let retrievedProvider1 = extHostDataProtocol.getProvider<azdata.MetadataProvider>(extension1Id, DataProviderType.MetadataProvider);
+		let retrievedProvider2 = extHostDataProtocol.getProvider<azdata.MetadataProvider>(extension2Id, DataProviderType.MetadataProvider);
+		let allProviders = extHostDataProtocol.getProvidersByType<azdata.MetadataProvider>(DataProviderType.MetadataProvider);
 
 		// Then each provider was retrieved successfully
 		assert.equal(retrievedProvider1, extension1MetadataMock.object, 'Expected metadata provider was not retrieved for extension 1');

src/sqltest/workbench/api/extHostModelView.test.ts

@@ -7,7 +7,7 @@
 
 import * as assert from 'assert';
 import { Mock, It, Times, MockBehavior } from 'typemoq';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { ExtHostModelView } from 'sql/workbench/api/node/extHostModelView';
 import { MainThreadModelViewShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
 import { IMainContext } from 'vs/workbench/api/node/extHost.protocol';
@@ -24,8 +24,8 @@ interface IWithItemConfig {
 suite('ExtHostModelView Validation Tests', () => {
 	let extHostModelView: ExtHostModelView;
 	let mockProxy: Mock<MainThreadModelViewShape>;
-	let modelView: sqlops.ModelView;
-	let inputBox: sqlops.InputBoxComponent;
+	let modelView: azdata.ModelView;
+	let inputBox: azdata.InputBoxComponent;
 	let validText = 'valid';
 	let widgetId = 'widget_id';
 	let handle = 1;
@@ -146,7 +146,7 @@ suite('ExtHostModelView Validation Tests', () => {
 		inputComponent.required = false;
 
 		// If I build a form that sets the input component as required
-		let inputFormComponent: sqlops.FormComponent = {
+		let inputFormComponent: azdata.FormComponent = {
 			component: inputComponent,
 			title: 'test_input',
 			required: true
@@ -171,17 +171,17 @@ suite('ExtHostModelView Validation Tests', () => {
 		let groupInput = modelView.modelBuilder.inputBox().component();
 		let groupDropdown = modelView.modelBuilder.dropDown().component();
 
-		let topLevelInputFormComponent: sqlops.FormComponent = { component: topLevelList, title: 'top_level_input' };
-		let groupInputFormComponent: sqlops.FormComponent = { component: groupInput, title: 'group_input' };
-		let groupDropdownFormComponent: sqlops.FormComponent = { component: groupDropdown, title: 'group_dropdown' };
+		let topLevelInputFormComponent: azdata.FormComponent = { component: topLevelList, title: 'top_level_input' };
+		let groupInputFormComponent: azdata.FormComponent = { component: groupInput, title: 'group_input' };
+		let groupDropdownFormComponent: azdata.FormComponent = { component: groupDropdown, title: 'group_dropdown' };
 
 		let groupTitle = 'group_title';
 
 		// Give the group a default layout and add one just for the input component too
-		let defaultLayout: sqlops.FormItemLayout = {
+		let defaultLayout: azdata.FormItemLayout = {
 			horizontal: true
 		};
-		let groupInputLayout: sqlops.FormItemLayout = {
+		let groupInputLayout: azdata.FormItemLayout = {
 			horizontal: false
 		};
 
@@ -216,9 +216,9 @@ suite('ExtHostModelView Validation Tests', () => {
 		assert.equal((groupLabelConfig.config as TitledFormItemLayout).isGroupLabel, true);
 
 		// Verify that the components' layouts are correct
-		assert.equal((listBoxConfig.config as sqlops.FormItemLayout).horizontal, defaultLayout.horizontal);
-		assert.equal((inputBoxConfig.config as sqlops.FormItemLayout).horizontal, groupInputLayout.horizontal);
-		assert.equal((dropdownConfig.config as sqlops.FormItemLayout).horizontal, defaultLayout.horizontal);
+		assert.equal((listBoxConfig.config as azdata.FormItemLayout).horizontal, defaultLayout.horizontal);
+		assert.equal((inputBoxConfig.config as azdata.FormItemLayout).horizontal, groupInputLayout.horizontal);
+		assert.equal((dropdownConfig.config as azdata.FormItemLayout).horizontal, defaultLayout.horizontal);
 	});
 
 	test('Inserting and removing components from a container should work correctly', () => {
@@ -342,7 +342,7 @@ suite('ExtHostModelView Validation Tests', () => {
 		let dropDown = modelView.modelBuilder.dropDown().component();
 		let checkBox = modelView.modelBuilder.checkBox().component();
 
-		let groupItems: sqlops.FormComponentGroup = {
+		let groupItems: azdata.FormComponentGroup = {
 			title: 'Group',
 			components: [{
 				title: 'Drop Down',
@@ -352,11 +352,11 @@ suite('ExtHostModelView Validation Tests', () => {
 				component: checkBox
 			}]
 		};
-		let listBoxFormItem: sqlops.FormComponent = {
+		let listBoxFormItem: azdata.FormComponent = {
 			title: 'List Box',
 			component: listBox
 		};
-		let inputBoxFormItem: sqlops.FormComponent = {
+		let inputBoxFormItem: azdata.FormComponent = {
 			title: 'Input Box',
 			component: inputBox
 		};

src/sqltest/workbench/api/extHostModelViewDialog.test.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as assert from 'assert';
 import { Mock, It, Times } from 'typemoq';
 import { ExtHostModelViewDialog } from 'sql/workbench/api/node/extHostModelViewDialog';
@@ -276,7 +276,7 @@ suite('ExtHostModelViewDialog Tests', () => {
 		// Create the wizard and add a validation that records that it has been called
 		let wizard = extHostModelViewDialog.createWizard('wizard_1');
 		extHostModelViewDialog.updateWizard(wizard);
-		let validationInfo: sqlops.window.WizardPageChangeInfo;
+		let validationInfo: azdata.window.WizardPageChangeInfo;
 		wizard.registerNavigationValidator(info => {
 			validationInfo = info;
 			return true;

src/sqltest/workbench/api/exthostNotebook.test.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 import * as assert from 'assert';
 import * as TypeMoq from 'typemoq';
@@ -120,11 +120,11 @@ suite('ExtHostNotebook Tests', () => {
 	});
 });
 
-class NotebookProviderStub implements sqlops.nb.NotebookProvider {
+class NotebookProviderStub implements azdata.nb.NotebookProvider {
 	providerId: string = 'TestProvider';
-	standardKernels: sqlops.nb.IStandardKernel[] = [{name: 'fakeKernel', connectionProviderIds: ['MSSQL']}];
+	standardKernels: azdata.nb.IStandardKernel[] = [{name: 'fakeKernel', connectionProviderIds: ['MSSQL']}];
 
-	getNotebookManager(notebookUri: vscode.Uri): Thenable<sqlops.nb.NotebookManager> {
+	getNotebookManager(notebookUri: vscode.Uri): Thenable<azdata.nb.NotebookManager> {
 		throw new Error('Method not implemented.');
 	}
 	handleNotebookClosed(notebookUri: vscode.Uri): void {
@@ -132,16 +132,16 @@ class NotebookProviderStub implements sqlops.nb.NotebookProvider {
 	}
 }
 
-class NotebookManagerStub implements sqlops.nb.NotebookManager {
-	get contentManager(): sqlops.nb.ContentManager {
+class NotebookManagerStub implements azdata.nb.NotebookManager {
+	get contentManager(): azdata.nb.ContentManager {
 		return undefined;
 	}
 
-	get sessionManager(): sqlops.nb.SessionManager {
+	get sessionManager(): azdata.nb.SessionManager {
 		return undefined;
 	}
 
-	get serverManager(): sqlops.nb.ServerManager {
+	get serverManager(): azdata.nb.ServerManager {
 		return undefined;
 	}
 }

src/sqltest/workbench/api/mainThreadBackgroundTaskManagement.test.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import { Mock, It, Times } from 'typemoq';
 import { MainThreadBackgroundTaskManagement, TaskStatus } from 'sql/workbench/api/node/mainThreadBackgroundTaskManagement';
 import { ExtHostBackgroundTaskManagementShape } from 'sql/workbench/api/node/sqlExtHost.protocol';
@@ -26,7 +26,7 @@ suite('MainThreadBackgroundTaskManagement Tests', () => {
 		mockProxy = Mock.ofInstance(<ExtHostBackgroundTaskManagementShape>{
 			$onTaskRegistered: (operationId: string) => nothing,
 			$onTaskCanceled: (operationId: string) => nothing,
-			$registerTask: (operationInfo: sqlops.BackgroundOperationInfo) => nothing,
+			$registerTask: (operationInfo: azdata.BackgroundOperationInfo) => nothing,
 			$removeTask: (operationId: string) => nothing,
 		});
 		taskService = Mock.ofInstance(<ITaskService>{
@@ -38,8 +38,8 @@ suite('MainThreadBackgroundTaskManagement Tests', () => {
 			getAllTasks: undefined,
 			getNumberOfInProgressTasks: undefined,
 			onNewTaskCreated: undefined,
-			createNewTask: (taskInfo: sqlops.TaskInfo) => nothing,
-			updateTask: (taskProgressInfo: sqlops.TaskProgressInfo) => nothing,
+			createNewTask: (taskInfo: azdata.TaskInfo) => nothing,
+			updateTask: (taskProgressInfo: azdata.TaskProgressInfo) => nothing,
 			onTaskStatusChanged: undefined,
 			cancelTask: undefined,
 			registerProvider: undefined
@@ -54,7 +54,7 @@ suite('MainThreadBackgroundTaskManagement Tests', () => {
 	});
 
 	test('RegisterTask should successfully create background task', () => {
-		let taskInfo: sqlops.TaskInfo = {
+		let taskInfo: azdata.TaskInfo = {
 			taskId: operationId,
 			databaseName: undefined,
 			description: undefined,
@@ -71,7 +71,7 @@ suite('MainThreadBackgroundTaskManagement Tests', () => {
 	});
 
 	test('UpdateTask should successfully update the background task status', () => {
-		let taskInfo: sqlops.TaskProgressInfo = {
+		let taskInfo: azdata.TaskProgressInfo = {
 			taskId: operationId,
 			status: TaskStatus.InProgress,
 			message: undefined,
@@ -81,7 +81,7 @@ suite('MainThreadBackgroundTaskManagement Tests', () => {
 	});
 
 	test('Canceling the task should notify the proxy', () => {
-		let taskInfo: sqlops.TaskProgressInfo = {
+		let taskInfo: azdata.TaskProgressInfo = {
 			taskId: operationId,
 			status: TaskStatus.InProgress,
 			message: undefined,

src/sqltest/workbench/api/mainThreadNotebook.test.ts

@@ -6,7 +6,7 @@
 
 import * as assert from 'assert';
 import * as TypeMoq from 'typemoq';
-import * as sqlops from 'sqlops';
+import * as azdata from 'azdata';
 import * as vscode from 'vscode';
 
 import { URI, UriComponents } from 'vs/base/common/uri';
@@ -132,46 +132,46 @@ class ExtHostNotebookStub implements ExtHostNotebookShape {
 	$doStopServer(managerHandle: number): Thenable<void> {
 		throw new Error('Method not implemented.');
 	}
-	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<sqlops.nb.INotebookContents> {
+	$getNotebookContents(managerHandle: number, notebookUri: UriComponents): Thenable<azdata.nb.INotebookContents> {
 		throw new Error('Method not implemented.');
 	}
-	$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> {
 		throw new Error('Method not implemented.');
 	}
-	$refreshSpecs(managerHandle: number): Thenable<sqlops.nb.IAllKernels> {
+	$refreshSpecs(managerHandle: number): Thenable<azdata.nb.IAllKernels> {
 		throw new Error('Method not implemented.');
 	}
-	$startNewSession(managerHandle: number, options: sqlops.nb.ISessionOptions): Thenable<INotebookSessionDetails> {
+	$startNewSession(managerHandle: number, options: azdata.nb.ISessionOptions): Thenable<INotebookSessionDetails> {
 		throw new Error('Method not implemented.');
 	}
 	$shutdownSession(managerHandle: number, sessionId: string): Thenable<void> {
 		throw new Error('Method not implemented.');
 	}
-	$changeKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<INotebookKernelDetails> {
+	$changeKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<INotebookKernelDetails> {
 		throw new Error('Method not implemented.');
 	}
-	$configureKernel(sessionId: number, kernelInfo: sqlops.nb.IKernelSpec): Thenable<void> {
+	$configureKernel(sessionId: number, kernelInfo: azdata.nb.IKernelSpec): Thenable<void> {
 		throw new Error('Method not implemented.');
 	}
-	$configureConnection(sessionId: number, conneection: sqlops.IConnectionProfile): Thenable<void> {
+	$configureConnection(sessionId: number, conneection: azdata.IConnectionProfile): Thenable<void> {
 		throw new Error('Method not implemented.');
 	}
-	$getKernelReadyStatus(kernelId: number): Thenable<sqlops.nb.IInfoReply> {
+	$getKernelReadyStatus(kernelId: number): Thenable<azdata.nb.IInfoReply> {
 		throw new Error('Method not implemented.');
 	}
-	$getKernelSpec(kernelId: number): Thenable<sqlops.nb.IKernelSpec> {
+	$getKernelSpec(kernelId: number): Thenable<azdata.nb.IKernelSpec> {
 		throw new Error('Method not implemented.');
 	}
-	$requestComplete(kernelId: number, content: sqlops.nb.ICompleteRequest): Thenable<sqlops.nb.ICompleteReplyMsg> {
+	$requestComplete(kernelId: number, content: azdata.nb.ICompleteRequest): Thenable<azdata.nb.ICompleteReplyMsg> {
 		throw new Error('Method not implemented.');
 	}
-	$requestExecute(kernelId: number, content: sqlops.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails> {
+	$requestExecute(kernelId: number, content: azdata.nb.IExecuteRequest, disposeOnDone?: boolean): Thenable<INotebookFutureDetails> {
 		throw new Error('Method not implemented.');
 	}
 	$interruptKernel(kernelId: number): Thenable<void> {
 		throw new Error('Method not implemented.');
 	}
-	$sendInputReply(futureId: number, content: sqlops.nb.IInputReply): void {
+	$sendInputReply(futureId: number, content: azdata.nb.IInputReply): void {
 		throw new Error('Method not implemented.');
 	}
 	$disposeFuture(futureId: number): void {