diff --git a/src/vs/code/electron-main/app.ts b/src/vs/code/electron-main/app.ts
index 789da519ee2..2efd0e0d351 100644
--- a/src/vs/code/electron-main/app.ts
+++ b/src/vs/code/electron-main/app.ts
@@ -76,7 +76,7 @@ export class CodeApplication {
 		@ILogService private logService: ILogService,
 		@IEnvironmentService private environmentService: IEnvironmentService,
 		@ILifecycleService private lifecycleService: ILifecycleService,
-		@IConfigurationService private configurationService: ConfigurationService<any>,
+		@IConfigurationService private configurationService: ConfigurationService,
 		@IStorageService private storageService: IStorageService,
 		@IHistoryMainService private historyService: IHistoryMainService
 	) {
diff --git a/src/vs/editor/standalone/browser/simpleServices.ts b/src/vs/editor/standalone/browser/simpleServices.ts
index a9b23d8d74f..3d84c45b5eb 100644
--- a/src/vs/editor/standalone/browser/simpleServices.ts
+++ b/src/vs/editor/standalone/browser/simpleServices.ts
@@ -442,13 +442,13 @@ export class SimpleConfigurationService implements IConfigurationService {
 	private _onDidUpdateConfiguration = new Emitter<IConfigurationChangeEvent>();
 	public onDidUpdateConfiguration: Event<IConfigurationChangeEvent> = this._onDidUpdateConfiguration.event;
 
-	private _configuration: Configuration<any>;
+	private _configuration: Configuration;
 
 	constructor() {
 		this._configuration = new Configuration(new DefaultConfigurationModel(), new ConfigurationModel());
 	}
 
-	private configuration(): Configuration<any> {
+	private configuration(): Configuration {
 		return this._configuration;
 	}
 
diff --git a/src/vs/platform/configuration/common/configuration.ts b/src/vs/platform/configuration/common/configuration.ts
index 74fba9962fd..b9cbfb0a599 100644
--- a/src/vs/platform/configuration/common/configuration.ts
+++ b/src/vs/platform/configuration/common/configuration.ts
@@ -80,25 +80,25 @@ export interface IConfigurationService {
 	};
 }
 
-export interface IConfiguraionModel<T> {
-	contents: T;
+export interface IConfiguraionModel {
+	contents: any;
 	keys: string[];
-	overrides: IOverrides<T>[];
+	overrides: IOverrides[];
 }
 
-export interface IOverrides<T> {
-	contents: T;
+export interface IOverrides {
+	contents: any;
 	identifiers: string[];
 }
 
-export interface IConfigurationData<T> {
-	defaults: IConfiguraionModel<T>;
-	user: IConfiguraionModel<T>;
-	workspace: IConfiguraionModel<T>;
-	folders: { [folder: string]: IConfiguraionModel<T> };
+export interface IConfigurationData {
+	defaults: IConfiguraionModel;
+	user: IConfiguraionModel;
+	workspace: IConfiguraionModel;
+	folders: { [folder: string]: IConfiguraionModel };
 }
 
-export function compare(from: IConfiguraionModel<any>, to: IConfiguraionModel<any>): { added: string[], removed: string[], updated: string[] } {
+export function compare(from: IConfiguraionModel, to: IConfiguraionModel): { added: string[], removed: string[], updated: string[] } {
 	const added = to.keys.filter(key => from.keys.indexOf(key) === -1);
 	const removed = from.keys.filter(key => to.keys.indexOf(key) === -1);
 	const updated = [];
diff --git a/src/vs/platform/configuration/common/configurationModels.ts b/src/vs/platform/configuration/common/configurationModels.ts
index 4d619fbc13b..8a207935c4a 100644
--- a/src/vs/platform/configuration/common/configurationModels.ts
+++ b/src/vs/platform/configuration/common/configurationModels.ts
@@ -14,16 +14,16 @@ import { IConfigurationRegistry, Extensions, OVERRIDE_PROPERTY_PATTERN } from 'v
 import { IOverrides, overrideIdentifierFromKey, addToValueTree, toValuesTree, IConfiguraionModel, merge, getConfigurationValue, IConfigurationOverrides, IConfigurationData, getDefaultValues, getConfigurationKeys } from 'vs/platform/configuration/common/configuration';
 import { Workspace } from 'vs/platform/workspace/common/workspace';
 
-export class ConfigurationModel<T> implements IConfiguraionModel<T> {
+export class ConfigurationModel implements IConfiguraionModel {
 
-	constructor(protected _contents: T = <T>{}, protected _keys: string[] = [], protected _overrides: IOverrides<T>[] = []) {
+	constructor(protected _contents: any = {}, protected _keys: string[] = [], protected _overrides: IOverrides[] = []) {
 	}
 
-	public get contents(): T {
+	public get contents(): any {
 		return this._contents;
 	}
 
-	public get overrides(): IOverrides<T>[] {
+	public get overrides(): IOverrides[] {
 		return this._overrides;
 	}
 
@@ -35,8 +35,8 @@ export class ConfigurationModel<T> implements IConfiguraionModel<T> {
 		return objects.clone(this.contents[section]);
 	}
 
-	public override<V>(identifier: string): ConfigurationModel<V> {
-		const result = new ConfigurationModel<V>();
+	public override<V>(identifier: string): ConfigurationModel {
+		const result = new ConfigurationModel();
 		const contents = objects.clone<any>(this.contents);
 		if (this._overrides) {
 			for (const override of this._overrides) {
@@ -64,14 +64,14 @@ export class ConfigurationModel<T> implements IConfiguraionModel<T> {
 		}
 	}
 
-	public merge(other: ConfigurationModel<T>, overwrite: boolean = true): ConfigurationModel<T> {
-		const mergedModel = new ConfigurationModel<T>();
+	public merge(other: ConfigurationModel, overwrite: boolean = true): ConfigurationModel {
+		const mergedModel = new ConfigurationModel();
 		this.doMerge(mergedModel, this, overwrite);
 		this.doMerge(mergedModel, other, overwrite);
 		return mergedModel;
 	}
 
-	protected doMerge(source: ConfigurationModel<T>, target: ConfigurationModel<T>, overwrite: boolean = true) {
+	protected doMerge(source: ConfigurationModel, target: ConfigurationModel, overwrite: boolean = true) {
 		merge(source.contents, objects.clone(target.contents), overwrite);
 		const overrides = objects.clone(source._overrides);
 		for (const override of target._overrides) {
@@ -86,7 +86,7 @@ export class ConfigurationModel<T> implements IConfiguraionModel<T> {
 	}
 }
 
-export class DefaultConfigurationModel<T> extends ConfigurationModel<T> {
+export class DefaultConfigurationModel extends ConfigurationModel {
 
 	constructor() {
 		super(getDefaultValues());
@@ -94,7 +94,7 @@ export class DefaultConfigurationModel<T> extends ConfigurationModel<T> {
 		this._overrides = Object.keys(this._contents)
 			.filter(key => OVERRIDE_PROPERTY_PATTERN.test(key))
 			.map(key => {
-				return <IOverrides<any>>{
+				return <IOverrides>{
 					identifiers: [overrideIdentifierFromKey(key).trim()],
 					contents: toValuesTree(this._contents[key], message => console.error(`Conflict in default settings file: ${message}`))
 				};
@@ -106,11 +106,11 @@ export class DefaultConfigurationModel<T> extends ConfigurationModel<T> {
 	}
 }
 
-interface Overrides<T> extends IOverrides<T> {
+interface Overrides extends IOverrides {
 	raw: any;
 }
 
-export class CustomConfigurationModel<T> extends ConfigurationModel<T> {
+export class CustomConfigurationModel extends ConfigurationModel {
 
 	protected _parseErrors: any[] = [];
 
@@ -126,8 +126,8 @@ export class CustomConfigurationModel<T> extends ConfigurationModel<T> {
 	}
 
 	public update(content: string): void {
-		let parsed: T = <T>{};
-		let overrides: Overrides<T>[] = [];
+		let parsed: any = {};
+		let overrides: Overrides[] = [];
 		let currentProperty: string = null;
 		let currentParent: any = [];
 		let previousParents: any[] = [];
@@ -193,7 +193,7 @@ export class CustomConfigurationModel<T> extends ConfigurationModel<T> {
 		this.processRaw(parsed);
 
 		const configurationProperties = Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties();
-		this._overrides = overrides.map<IOverrides<T>>(override => {
+		this._overrides = overrides.map<IOverrides>(override => {
 			// Filter unknown and non-overridable properties
 			const raw = {};
 			for (const key in override.raw) {
@@ -203,61 +203,61 @@ export class CustomConfigurationModel<T> extends ConfigurationModel<T> {
 			}
 			return {
 				identifiers: override.identifiers,
-				contents: <T>toValuesTree(raw, message => console.error(`Conflict in settings file ${this.name}: ${message}`))
+				contents: toValuesTree(raw, message => console.error(`Conflict in settings file ${this.name}: ${message}`))
 			};
 		});
 	}
 
-	protected processRaw(raw: T): void {
+	protected processRaw(raw: any): void {
 		this._contents = toValuesTree(raw, message => console.error(`Conflict in settings file ${this.name}: ${message}`));
 		this._keys = Object.keys(raw);
 	}
 }
 
-export class Configuration<T> {
+export class Configuration {
 
-	private _globalConfiguration: ConfigurationModel<T>;
-	private _workspaceConsolidatedConfiguration: ConfigurationModel<T>;
-	protected _foldersConsolidatedConfigurations: StrictResourceMap<ConfigurationModel<T>>;
-	protected _memoryConsolidatedConfigurations: StrictResourceMap<ConfigurationModel<T>>;
+	private _globalConfiguration: ConfigurationModel;
+	private _workspaceConsolidatedConfiguration: ConfigurationModel;
+	protected _foldersConsolidatedConfigurations: StrictResourceMap<ConfigurationModel>;
+	protected _memoryConsolidatedConfigurations: StrictResourceMap<ConfigurationModel>;
 
-	constructor(protected _defaults: ConfigurationModel<T>,
-		protected _user: ConfigurationModel<T>,
-		protected _workspaceConfiguration: ConfigurationModel<T> = new ConfigurationModel<T>(),
-		protected folders: StrictResourceMap<ConfigurationModel<T>> = new StrictResourceMap<ConfigurationModel<T>>(),
-		protected _memoryConfiguration: ConfigurationModel<T> = new ConfigurationModel<T>(),
-		protected _memoryConfigurationByResource: StrictResourceMap<ConfigurationModel<T>> = new StrictResourceMap<ConfigurationModel<T>>(),
+	constructor(protected _defaults: ConfigurationModel,
+		protected _user: ConfigurationModel,
+		protected _workspaceConfiguration: ConfigurationModel = new ConfigurationModel(),
+		protected folders: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>(),
+		protected _memoryConfiguration: ConfigurationModel = new ConfigurationModel(),
+		protected _memoryConfigurationByResource: StrictResourceMap<ConfigurationModel> = new StrictResourceMap<ConfigurationModel>(),
 		protected _workspace?: Workspace) {
 		this.merge();
 	}
 
-	get defaults(): ConfigurationModel<T> {
+	get defaults(): ConfigurationModel {
 		return this._defaults;
 	}
 
-	get user(): ConfigurationModel<T> {
+	get user(): ConfigurationModel {
 		return this._user;
 	}
 
-	get workspace(): ConfigurationModel<T> {
+	get workspace(): ConfigurationModel {
 		return this._workspaceConfiguration;
 	}
 
 	protected merge(): void {
-		this._globalConfiguration = new ConfigurationModel<T>().merge(this._defaults).merge(this._user);
-		this._workspaceConsolidatedConfiguration = new ConfigurationModel<T>().merge(this._globalConfiguration).merge(this._workspaceConfiguration);
-		this._foldersConsolidatedConfigurations = new StrictResourceMap<ConfigurationModel<T>>();
+		this._globalConfiguration = new ConfigurationModel().merge(this._defaults).merge(this._user);
+		this._workspaceConsolidatedConfiguration = new ConfigurationModel().merge(this._globalConfiguration).merge(this._workspaceConfiguration);
+		this._foldersConsolidatedConfigurations = new StrictResourceMap<ConfigurationModel>();
 		for (const folder of this.folders.keys()) {
 			this.mergeFolder(folder);
 		}
 	}
 
 	protected mergeFolder(folder: URI) {
-		this._foldersConsolidatedConfigurations.set(folder, new ConfigurationModel<T>().merge(this._workspaceConsolidatedConfiguration).merge(this.folders.get(folder)));
+		this._foldersConsolidatedConfigurations.set(folder, new ConfigurationModel().merge(this._workspaceConsolidatedConfiguration).merge(this.folders.get(folder)));
 	}
 
 	protected mergeMemory(folder: URI) {
-		this._foldersConsolidatedConfigurations.set(folder, new ConfigurationModel<T>().merge(this._workspaceConsolidatedConfiguration).merge(this.folders.get(folder)));
+		this._foldersConsolidatedConfigurations.set(folder, new ConfigurationModel().merge(this._workspaceConsolidatedConfiguration).merge(this.folders.get(folder)));
 	}
 
 	getValue<C>(section: string = '', overrides: IConfigurationOverrides = {}): C {
@@ -272,7 +272,7 @@ export class Configuration<T> {
 	}
 
 	updateValue(key: string, value: any, overrides: IConfigurationOverrides = {}): void {
-		let memoryConfiguration: ConfigurationModel<any>;
+		let memoryConfiguration: ConfigurationModel;
 		if (overrides.resource) {
 			let memoryConfiguration = this._memoryConfigurationByResource.get(overrides.resource);
 			if (!memoryConfiguration) {
@@ -326,12 +326,12 @@ export class Configuration<T> {
 		};
 	}
 
-	private getConsolidateConfigurationModel<C>(overrides: IConfigurationOverrides): ConfigurationModel<any> {
+	private getConsolidateConfigurationModel<C>(overrides: IConfigurationOverrides): ConfigurationModel {
 		let configurationModel = this.getConsolidatedConfigurationModelForResource(overrides);
-		return overrides.overrideIdentifier ? configurationModel.override<T>(overrides.overrideIdentifier) : configurationModel;
+		return overrides.overrideIdentifier ? configurationModel.override(overrides.overrideIdentifier) : configurationModel;
 	}
 
-	private getConsolidatedConfigurationModelForResource({ resource }: IConfigurationOverrides): ConfigurationModel<any> {
+	private getConsolidatedConfigurationModelForResource({ resource }: IConfigurationOverrides): ConfigurationModel {
 		if (!this._workspace) {
 			return this._globalConfiguration;
 		}
@@ -354,7 +354,7 @@ export class Configuration<T> {
 		return consolidateConfiguration;
 	}
 
-	private getFolderConfigurationModelForResource(resource?: URI): ConfigurationModel<any> {
+	private getFolderConfigurationModelForResource(resource?: URI): ConfigurationModel {
 		if (!this._workspace || !resource) {
 			return null;
 		}
@@ -363,7 +363,7 @@ export class Configuration<T> {
 		return root ? this.folders.get(root.uri) : null;
 	}
 
-	public toData(): IConfigurationData<any> {
+	public toData(): IConfigurationData {
 		return {
 			defaults: {
 				contents: this._defaults.contents,
@@ -388,18 +388,18 @@ export class Configuration<T> {
 		};
 	}
 
-	public static parse(data: IConfigurationData<any>, workspace: Workspace): Configuration<any> {
+	public static parse(data: IConfigurationData, workspace: Workspace): Configuration {
 		const defaultConfiguration = Configuration.parseConfigurationModel(data.defaults);
 		const userConfiguration = Configuration.parseConfigurationModel(data.user);
 		const workspaceConfiguration = Configuration.parseConfigurationModel(data.workspace);
-		const folders: StrictResourceMap<ConfigurationModel<any>> = Object.keys(data.folders).reduce((result, key) => {
+		const folders: StrictResourceMap<ConfigurationModel> = Object.keys(data.folders).reduce((result, key) => {
 			result.set(URI.parse(key), Configuration.parseConfigurationModel(data.folders[key]));
 			return result;
-		}, new StrictResourceMap<ConfigurationModel<any>>());
-		return new Configuration<any>(defaultConfiguration, userConfiguration, workspaceConfiguration, folders, new ConfigurationModel<any>(), new StrictResourceMap<ConfigurationModel<any>>(), workspace);
+		}, new StrictResourceMap<ConfigurationModel>());
+		return new Configuration(defaultConfiguration, userConfiguration, workspaceConfiguration, folders, new ConfigurationModel(), new StrictResourceMap<ConfigurationModel>(), workspace);
 	}
 
-	private static parseConfigurationModel(model: IConfiguraionModel<any>): ConfigurationModel<any> {
+	private static parseConfigurationModel(model: IConfiguraionModel): ConfigurationModel {
 		return new ConfigurationModel(model.contents, model.keys, model.overrides);
 	}
 }
\ No newline at end of file
diff --git a/src/vs/platform/configuration/node/configurationService.ts b/src/vs/platform/configuration/node/configurationService.ts
index 6cfa5d53fb7..d7b5f65f730 100644
--- a/src/vs/platform/configuration/node/configurationService.ts
+++ b/src/vs/platform/configuration/node/configurationService.ts
@@ -25,12 +25,12 @@ export function isConfigurationOverrides(thing: any): thing is IConfigurationOve
 		&& (!thing.resource || thing.resource instanceof URI);
 }
 
-export class ConfigurationService<T> extends Disposable implements IConfigurationService, IDisposable {
+export class ConfigurationService extends Disposable implements IConfigurationService, IDisposable {
 
 	_serviceBrand: any;
 
-	private _configuration: Configuration<T>;
-	private userConfigModelWatcher: ConfigWatcher<ConfigurationModel<T>>;
+	private _configuration: Configuration;
+	private userConfigModelWatcher: ConfigWatcher<ConfigurationModel>;
 
 	private _onDidUpdateConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
 	readonly onDidUpdateConfiguration: Event<IConfigurationChangeEvent> = this._onDidUpdateConfiguration.event;
@@ -41,8 +41,8 @@ export class ConfigurationService<T> extends Disposable implements IConfiguratio
 		super();
 
 		this.userConfigModelWatcher = new ConfigWatcher(environmentService.appSettingsPath, {
-			changeBufferDelay: 300, onError: error => onUnexpectedError(error), defaultConfig: new CustomConfigurationModel<T>(null, environmentService.appSettingsPath), parse: (content: string, parseErrors: any[]) => {
-				const userConfigModel = new CustomConfigurationModel<T>(content, environmentService.appSettingsPath);
+			changeBufferDelay: 300, onError: error => onUnexpectedError(error), defaultConfig: new CustomConfigurationModel(null, environmentService.appSettingsPath), parse: (content: string, parseErrors: any[]) => {
+				const userConfigModel = new CustomConfigurationModel(content, environmentService.appSettingsPath);
 				parseErrors = [...userConfigModel.errors];
 				return userConfigModel;
 			}
@@ -56,7 +56,7 @@ export class ConfigurationService<T> extends Disposable implements IConfiguratio
 		this._register(Registry.as<IConfigurationRegistry>(Extensions.Configuration).onDidRegisterConfiguration(configurationProperties => this.onDidRegisterConfiguration(configurationProperties)));
 	}
 
-	get configuration(): Configuration<any> {
+	get configuration(): Configuration {
 		return this._configuration;
 	}
 
@@ -126,7 +126,7 @@ export class ConfigurationService<T> extends Disposable implements IConfiguratio
 	}
 
 	private reset(): void {
-		const defaults = new DefaultConfigurationModel<T>();
+		const defaults = new DefaultConfigurationModel();
 		const user = this.userConfigModelWatcher.getConfig();
 		this._configuration = new Configuration(defaults, user);
 	}
diff --git a/src/vs/platform/configuration/test/common/configuration.model.test.ts b/src/vs/platform/configuration/test/common/configuration.model.test.ts
index 4b4ff1e3ed1..65555f8e9f2 100644
--- a/src/vs/platform/configuration/test/common/configuration.model.test.ts
+++ b/src/vs/platform/configuration/test/common/configuration.model.test.ts
@@ -29,8 +29,8 @@ suite('Configuration', () => {
 	});
 
 	test('simple merge', () => {
-		let base = new ConfigurationModel<any>({ 'a': 1, 'b': 2 });
-		let add = new ConfigurationModel<any>({ 'a': 3, 'c': 4 });
+		let base = new ConfigurationModel({ 'a': 1, 'b': 2 });
+		let add = new ConfigurationModel({ 'a': 3, 'c': 4 });
 		let result = base.merge(add);
 		assert.deepEqual(result.contents, { 'a': 3, 'b': 2, 'c': 4 });
 	});
@@ -43,24 +43,24 @@ suite('Configuration', () => {
 	});
 
 	test('simple merge overrides', () => {
-		let base = new ConfigurationModel<any>({ 'a': { 'b': 1 } }, [], [{ identifiers: ['c'], contents: { 'a': 2 } }]);
-		let add = new ConfigurationModel<any>({ 'a': { 'b': 2 } }, [], [{ identifiers: ['c'], contents: { 'b': 2 } }]);
+		let base = new ConfigurationModel({ 'a': { 'b': 1 } }, [], [{ identifiers: ['c'], contents: { 'a': 2 } }]);
+		let add = new ConfigurationModel({ 'a': { 'b': 2 } }, [], [{ identifiers: ['c'], contents: { 'b': 2 } }]);
 		let result = base.merge(add);
 		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
 		assert.deepEqual(result.overrides, [{ identifiers: ['c'], contents: { 'a': 2, 'b': 2 } }]);
 	});
 
 	test('recursive merge overrides', () => {
-		let base = new ConfigurationModel<any>({ 'a': { 'b': 1 } }, [], [{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]);
-		let add = new ConfigurationModel<any>({ 'a': { 'b': 2 } }, [], [{ identifiers: ['c'], contents: { 'a': { 'e': 2 } } }]);
+		let base = new ConfigurationModel({ 'a': { 'b': 1 } }, [], [{ identifiers: ['c'], contents: { 'a': { 'd': 1 } } }]);
+		let add = new ConfigurationModel({ 'a': { 'b': 2 } }, [], [{ identifiers: ['c'], contents: { 'a': { 'e': 2 } } }]);
 		let result = base.merge(add);
 		assert.deepEqual(result.contents, { 'a': { 'b': 2 } });
 		assert.deepEqual(result.overrides, [{ identifiers: ['c'], contents: { 'a': { 'd': 1, 'e': 2 } } }]);
 	});
 
 	test('merge ignore keys', () => {
-		let base = new ConfigurationModel<any>({ 'a': 1, 'b': 2 });
-		let add = new ConfigurationModel<any>({ 'a': 3, 'c': 4 });
+		let base = new ConfigurationModel({ 'a': 1, 'b': 2 });
+		let add = new ConfigurationModel({ 'a': 3, 'c': 4 });
 		let result = base.merge(add);
 		assert.deepEqual(result.keys, []);
 	});
@@ -69,7 +69,7 @@ suite('Configuration', () => {
 		let testObject = new ConfigurationModel({ 'a': 1 });
 		assert.deepEqual(testObject.getContentsFor('a'), 1);
 
-		testObject = new ConfigurationModel<any>({ 'a': { 'b': 1 } });
+		testObject = new ConfigurationModel({ 'a': { 'b': 1 } });
 		assert.deepEqual(testObject.getContentsFor('a'), { 'b': 1 });
 	});
 
@@ -80,7 +80,7 @@ suite('Configuration', () => {
 	});
 
 	test('Test override gives all content merged with overrides', () => {
-		const testObject = new ConfigurationModel<any>({ 'a': 1, 'c': 1 }, [], [{ identifiers: ['b'], contents: { 'a': 2 } }]);
+		const testObject = new ConfigurationModel({ 'a': 1, 'c': 1 }, [], [{ identifiers: ['b'], contents: { 'a': 2 } }]);
 
 		assert.deepEqual(testObject.override('b').contents, { 'a': 2, 'c': 1 });
 	});
diff --git a/src/vs/workbench/api/node/extHost.protocol.ts b/src/vs/workbench/api/node/extHost.protocol.ts
index 4016299feed..16f681bddca 100644
--- a/src/vs/workbench/api/node/extHost.protocol.ts
+++ b/src/vs/workbench/api/node/extHost.protocol.ts
@@ -74,7 +74,7 @@ export interface IInitData {
 	environment: IEnvironment;
 	workspace: IWorkspaceData;
 	extensions: IExtensionDescription[];
-	configuration: IConfigurationData<any>;
+	configuration: IConfigurationData;
 	telemetryInfo: ITelemetryInfo;
 }
 
@@ -412,7 +412,7 @@ export interface ExtHostCommandsShape {
 }
 
 export interface ExtHostConfigurationShape {
-	$acceptConfigurationChanged(data: IConfigurationData<any>): void;
+	$acceptConfigurationChanged(data: IConfigurationData): void;
 }
 
 export interface ExtHostDiagnosticsShape {
diff --git a/src/vs/workbench/api/node/extHostConfiguration.ts b/src/vs/workbench/api/node/extHostConfiguration.ts
index 1647e1736ac..031763f0ff4 100644
--- a/src/vs/workbench/api/node/extHostConfiguration.ts
+++ b/src/vs/workbench/api/node/extHostConfiguration.ts
@@ -39,9 +39,9 @@ export class ExtHostConfiguration implements ExtHostConfigurationShape {
 	private readonly _onDidChangeConfiguration = new Emitter<void>();
 	private readonly _proxy: MainThreadConfigurationShape;
 	private readonly _extHostWorkspace: ExtHostWorkspace;
-	private _configuration: Configuration<any>;
+	private _configuration: Configuration;
 
-	constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationData<any>) {
+	constructor(proxy: MainThreadConfigurationShape, extHostWorkspace: ExtHostWorkspace, data: IConfigurationData) {
 		this._proxy = proxy;
 		this._extHostWorkspace = extHostWorkspace;
 		this._configuration = Configuration.parse(data, extHostWorkspace.workspace);
@@ -51,7 +51,7 @@ export class ExtHostConfiguration implements ExtHostConfigurationShape {
 		return this._onDidChangeConfiguration && this._onDidChangeConfiguration.event;
 	}
 
-	$acceptConfigurationChanged(data: IConfigurationData<any>) {
+	$acceptConfigurationChanged(data: IConfigurationData) {
 		this._configuration = Configuration.parse(data, this._extHostWorkspace.workspace);
 		this._onDidChangeConfiguration.fire(undefined);
 	}
diff --git a/src/vs/workbench/services/configuration/common/configurationModels.ts b/src/vs/workbench/services/configuration/common/configurationModels.ts
index 85afabd93a7..df0c1b196ee 100644
--- a/src/vs/workbench/services/configuration/common/configurationModels.ts
+++ b/src/vs/workbench/services/configuration/common/configurationModels.ts
@@ -15,14 +15,14 @@ import { Workspace } from 'vs/platform/workspace/common/workspace';
 import { StrictResourceMap } from 'vs/base/common/map';
 import URI from 'vs/base/common/uri';
 
-export class WorkspaceConfigurationModel<T> extends CustomConfigurationModel<T> {
+export class WorkspaceConfigurationModel extends CustomConfigurationModel {
 
-	private _raw: T;
+	private _raw: any;
 	private _folders: IStoredWorkspaceFolder[];
-	private _worksapaceSettings: ConfigurationModel<T>;
-	private _tasksConfiguration: ConfigurationModel<T>;
-	private _launchConfiguration: ConfigurationModel<T>;
-	private _workspaceConfiguration: ConfigurationModel<T>;
+	private _worksapaceSettings: ConfigurationModel;
+	private _tasksConfiguration: ConfigurationModel;
+	private _launchConfiguration: ConfigurationModel;
+	private _workspaceConfiguration: ConfigurationModel;
 
 	public update(content: string): void {
 		super.update(content);
@@ -34,11 +34,11 @@ export class WorkspaceConfigurationModel<T> extends CustomConfigurationModel<T>
 		return this._folders;
 	}
 
-	get workspaceConfiguration(): ConfigurationModel<T> {
+	get workspaceConfiguration(): ConfigurationModel {
 		return this._workspaceConfiguration;
 	}
 
-	protected processRaw(raw: T): void {
+	protected processRaw(raw: any): void {
 		this._raw = raw;
 
 		this._folders = (this._raw['folders'] || []) as IStoredWorkspaceFolder[];
@@ -49,27 +49,27 @@ export class WorkspaceConfigurationModel<T> extends CustomConfigurationModel<T>
 		super.processRaw(raw);
 	}
 
-	private parseConfigurationModel(section: string): ConfigurationModel<T> {
+	private parseConfigurationModel(section: string): ConfigurationModel {
 		const rawSection = this._raw[section] || {};
 		const contents = toValuesTree(rawSection, message => console.error(`Conflict in section '${section}' of workspace configuration file ${message}`));
-		return new ConfigurationModel<T>(contents, Object.keys(rawSection));
+		return new ConfigurationModel(contents, Object.keys(rawSection));
 	}
 
-	private consolidate(): ConfigurationModel<T> {
+	private consolidate(): ConfigurationModel {
 		const keys: string[] = [...this._worksapaceSettings.keys,
 		...this._tasksConfiguration.keys.map(key => `tasks.${key}`),
 		...this._launchConfiguration.keys.map(key => `launch.${key}`)];
 
-		const mergedContents = new ConfigurationModel<T>(<T>{}, keys)
+		const mergedContents = new ConfigurationModel({}, keys)
 			.merge(this._worksapaceSettings)
 			.merge(this._tasksConfiguration)
 			.merge(this._launchConfiguration);
 
-		return new ConfigurationModel<T>(mergedContents.contents, keys, mergedContents.overrides);
+		return new ConfigurationModel(mergedContents.contents, keys, mergedContents.overrides);
 	}
 }
 
-export class ScopedConfigurationModel<T> extends CustomConfigurationModel<T> {
+export class ScopedConfigurationModel extends CustomConfigurationModel {
 
 	constructor(content: string, name: string, public readonly scope: string) {
 		super(null, name);
@@ -85,14 +85,14 @@ export class ScopedConfigurationModel<T> extends CustomConfigurationModel<T> {
 
 }
 
-export class FolderSettingsModel<T> extends CustomConfigurationModel<T> {
+export class FolderSettingsModel extends CustomConfigurationModel {
 
-	private _raw: T;
+	private _raw: any;
 	private _unsupportedKeys: string[];
 
-	protected processRaw(raw: T): void {
+	protected processRaw(raw: any): void {
 		this._raw = raw;
-		const processedRaw = <T>{};
+		const processedRaw = {};
 		this._unsupportedKeys = [];
 		const configurationProperties = Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties();
 		for (let key in raw) {
@@ -121,16 +121,16 @@ export class FolderSettingsModel<T> extends CustomConfigurationModel<T> {
 		return !propertySchema.isExecutable;
 	}
 
-	public createWorkspaceConfigurationModel(): ConfigurationModel<any> {
+	public createWorkspaceConfigurationModel(): ConfigurationModel {
 		return this.createScopedConfigurationModel(ConfigurationScope.WINDOW);
 	}
 
-	public createFolderScopedConfigurationModel(): ConfigurationModel<any> {
+	public createFolderScopedConfigurationModel(): ConfigurationModel {
 		return this.createScopedConfigurationModel(ConfigurationScope.RESOURCE);
 	}
 
-	private createScopedConfigurationModel(scope: ConfigurationScope): ConfigurationModel<any> {
-		const workspaceRaw = <T>{};
+	private createScopedConfigurationModel(scope: ConfigurationScope): ConfigurationModel {
+		const workspaceRaw = {};
 		const configurationProperties = Registry.as<IConfigurationRegistry>(Extensions.Configuration).getConfigurationProperties();
 		for (let key in this._raw) {
 			if (this.getScope(key, configurationProperties) === scope) {
@@ -148,15 +148,15 @@ export class FolderSettingsModel<T> extends CustomConfigurationModel<T> {
 	}
 }
 
-export class FolderConfigurationModel<T> extends CustomConfigurationModel<T> {
+export class FolderConfigurationModel extends CustomConfigurationModel {
 
-	constructor(public readonly workspaceSettingsConfig: FolderSettingsModel<T>, private scopedConfigs: ScopedConfigurationModel<T>[], private scope: ConfigurationScope) {
+	constructor(public readonly workspaceSettingsConfig: FolderSettingsModel, private scopedConfigs: ScopedConfigurationModel[], private scope: ConfigurationScope) {
 		super();
 		this.consolidate();
 	}
 
 	private consolidate(): void {
-		this._contents = <T>{};
+		this._contents = {};
 		this._overrides = [];
 
 		this.doMerge(this, ConfigurationScope.WINDOW === this.scope ? this.workspaceSettingsConfig : this.workspaceSettingsConfig.createFolderScopedConfigurationModel());
@@ -183,25 +183,25 @@ export class FolderConfigurationModel<T> extends CustomConfigurationModel<T> {
 	}
 }
 
-export class Configuration<T> extends BaseConfiguration<T> {
+export class Configuration extends BaseConfiguration {
 
 	constructor(
-		defaults: ConfigurationModel<T>,
-		user: ConfigurationModel<T>,
-		workspaceConfiguration: ConfigurationModel<T>,
-		protected folders: StrictResourceMap<FolderConfigurationModel<T>>,
-		memoryConfiguration: ConfigurationModel<T>,
-		memoryConfigurationByResource: StrictResourceMap<ConfigurationModel<T>>,
+		defaults: ConfigurationModel,
+		user: ConfigurationModel,
+		workspaceConfiguration: ConfigurationModel,
+		protected folders: StrictResourceMap<FolderConfigurationModel>,
+		memoryConfiguration: ConfigurationModel,
+		memoryConfigurationByResource: StrictResourceMap<ConfigurationModel>,
 		workspace: Workspace) {
 		super(defaults, user, workspaceConfiguration, folders, memoryConfiguration, memoryConfigurationByResource, workspace);
 	}
 
-	updateDefaultConfiguration(defaults: ConfigurationModel<T>): void {
+	updateDefaultConfiguration(defaults: ConfigurationModel): void {
 		this._defaults = defaults;
 		this.merge();
 	}
 
-	updateUserConfiguration(user: ConfigurationModel<T>): string[] {
+	updateUserConfiguration(user: ConfigurationModel): string[] {
 		let changedKeys = [];
 		const { added, updated, removed } = compare(this._user, user);
 		changedKeys = [...added, ...updated, ...removed];
@@ -217,7 +217,7 @@ export class Configuration<T> extends BaseConfiguration<T> {
 		return [];
 	}
 
-	updateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel<T>): string[] {
+	updateWorkspaceConfiguration(workspaceConfiguration: ConfigurationModel): string[] {
 		let changedKeys = [];
 		const { added, updated, removed } = compare(this._workspaceConfiguration, workspaceConfiguration);
 		changedKeys = [...added, ...updated, ...removed];
@@ -233,7 +233,7 @@ export class Configuration<T> extends BaseConfiguration<T> {
 		return [];
 	}
 
-	updateFolderConfiguration(resource: URI, configuration: FolderConfigurationModel<T>): string[] {
+	updateFolderConfiguration(resource: URI, configuration: FolderConfigurationModel): string[] {
 		const currentFolderConfiguration = this.folders.get(resource);
 
 		if (currentFolderConfiguration) {
@@ -269,7 +269,7 @@ export class Configuration<T> extends BaseConfiguration<T> {
 		return keys;
 	}
 
-	getFolderConfigurationModel(folder: URI): FolderConfigurationModel<T> {
-		return <FolderConfigurationModel<T>>this.folders.get(folder);
+	getFolderConfigurationModel(folder: URI): FolderConfigurationModel {
+		return <FolderConfigurationModel>this.folders.get(folder);
 	}
 }
\ No newline at end of file
diff --git a/src/vs/workbench/services/configuration/node/configurationService.ts b/src/vs/workbench/services/configuration/node/configurationService.ts
index 4e4b99992ee..7e8884d88e7 100644
--- a/src/vs/workbench/services/configuration/node/configurationService.ts
+++ b/src/vs/workbench/services/configuration/node/configurationService.ts
@@ -57,10 +57,10 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 	public _serviceBrand: any;
 
 	private workspace: Workspace;
-	private _configuration: Configuration<any>;
-	private baseConfigurationService: GlobalConfigurationService<any>;
+	private _configuration: Configuration;
+	private baseConfigurationService: GlobalConfigurationService;
 	private workspaceConfiguration: WorkspaceConfiguration;
-	private cachedFolderConfigs: StrictResourceMap<FolderConfiguration<any>>;
+	private cachedFolderConfigs: StrictResourceMap<FolderConfiguration>;
 
 	protected readonly _onDidUpdateConfiguration: Emitter<IConfigurationChangeEvent> = this._register(new Emitter<IConfigurationChangeEvent>());
 	public readonly onDidUpdateConfiguration: Event<IConfigurationChangeEvent> = this._onDidUpdateConfiguration.event;
@@ -315,17 +315,17 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 
 	private loadConfiguration(): TPromise<void> {
 		// reset caches
-		this.cachedFolderConfigs = new StrictResourceMap<FolderConfiguration<any>>();
+		this.cachedFolderConfigs = new StrictResourceMap<FolderConfiguration>();
 
 		const folders = this.workspace.folders;
 		return this.loadFolderConfigurations(folders)
 			.then((folderConfigurations) => {
 
 				let workspaceConfiguration = this.getWorkspaceConfigurationModel(folderConfigurations);
-				const folderConfigurationModels = new StrictResourceMap<FolderConfigurationModel<any>>();
+				const folderConfigurationModels = new StrictResourceMap<FolderConfigurationModel>();
 				folderConfigurations.forEach((folderConfiguration, index) => folderConfigurationModels.set(folders[index].uri, folderConfiguration));
 
-				this._configuration = new Configuration(<any>this.baseConfigurationService.configuration.defaults, this.baseConfigurationService.configuration.user, workspaceConfiguration, folderConfigurationModels, new ConfigurationModel(), new StrictResourceMap<ConfigurationModel<any>>(), this.getWorkbenchState() !== WorkbenchState.EMPTY ? this.workspace : null); //TODO: @Sandy Avoid passing null
+				this._configuration = new Configuration(this.baseConfigurationService.configuration.defaults, this.baseConfigurationService.configuration.user, workspaceConfiguration, folderConfigurationModels, new ConfigurationModel(), new StrictResourceMap<ConfigurationModel>(), this.getWorkbenchState() !== WorkbenchState.EMPTY ? this.workspace : null); //TODO: @Sandy Avoid passing null
 				// TODO: compare with old values??
 
 				const keys = this._configuration.keys();
@@ -333,14 +333,14 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 			});
 	}
 
-	private getWorkspaceConfigurationModel(folderConfigurations: FolderConfigurationModel<any>[]): ConfigurationModel<any> {
+	private getWorkspaceConfigurationModel(folderConfigurations: FolderConfigurationModel[]): ConfigurationModel {
 		switch (this.getWorkbenchState()) {
 			case WorkbenchState.FOLDER:
 				return folderConfigurations[0];
 			case WorkbenchState.WORKSPACE:
 				return this.workspaceConfiguration.workspaceConfigurationModel.workspaceConfiguration;
 			default:
-				return new ConfigurationModel<any>();
+				return new ConfigurationModel();
 		}
 	}
 
@@ -452,7 +452,7 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 		return TPromise.as(changedKeys);
 	}
 
-	private loadFolderConfigurations(folders: IWorkspaceFolder[]): TPromise<FolderConfigurationModel<any>[]> {
+	private loadFolderConfigurations(folders: IWorkspaceFolder[]): TPromise<FolderConfigurationModel[]> {
 		return TPromise.join([...folders.map(folder => {
 			const folderConfiguration = new FolderConfiguration(folder.uri, this.workspaceSettingsRootFolder, this.getWorkbenchState() === WorkbenchState.WORKSPACE ? ConfigurationScope.RESOURCE : ConfigurationScope.WINDOW);
 			this.cachedFolderConfigs.set(folder.uri, this._register(folderConfiguration));
@@ -588,7 +588,7 @@ export class WorkspaceService extends Disposable implements IWorkspaceConfigurat
 class WorkspaceConfiguration extends Disposable {
 
 	private _workspaceConfigPath: URI;
-	private _workspaceConfigurationWatcher: ConfigWatcher<WorkspaceConfigurationModel<any>>;
+	private _workspaceConfigurationWatcher: ConfigWatcher<WorkspaceConfigurationModel>;
 	private _workspaceConfigurationWatcherDisposables: IDisposable[] = [];
 
 	private _onDidUpdateConfiguration: Emitter<void> = this._register(new Emitter<void>());
@@ -618,7 +618,7 @@ class WorkspaceConfiguration extends Disposable {
 		});
 	}
 
-	get workspaceConfigurationModel(): WorkspaceConfigurationModel<any> {
+	get workspaceConfigurationModel(): WorkspaceConfigurationModel {
 		return this._workspaceConfigurationWatcher ? this._workspaceConfigurationWatcher.getConfig() : new WorkspaceConfigurationModel();
 	}
 
@@ -632,15 +632,15 @@ class WorkspaceConfiguration extends Disposable {
 	}
 }
 
-class FolderConfiguration<T> extends Disposable {
+class FolderConfiguration extends Disposable {
 
 	private static RELOAD_CONFIGURATION_DELAY = 50;
 
-	private bulkFetchFromWorkspacePromise: TPromise<any>;
-	private workspaceFilePathToConfiguration: { [relativeWorkspacePath: string]: TPromise<ConfigurationModel<any>> };
+	private bulkFetchFromWorkspacePromise: TPromise;
+	private workspaceFilePathToConfiguration: { [relativeWorkspacePath: string]: TPromise<ConfigurationModel> };
 
 	private reloadConfigurationScheduler: RunOnceScheduler;
-	private reloadConfigurationEventEmitter: Emitter<FolderConfigurationModel<T>> = new Emitter<FolderConfigurationModel<T>>();
+	private reloadConfigurationEventEmitter: Emitter<FolderConfigurationModel> = new Emitter<FolderConfigurationModel>();
 
 	constructor(private folder: URI, private configFolderRelativePath: string, private scope: ConfigurationScope) {
 		super();
@@ -649,17 +649,17 @@ class FolderConfiguration<T> extends Disposable {
 		this.reloadConfigurationScheduler = this._register(new RunOnceScheduler(() => this.loadConfiguration().then(configuration => this.reloadConfigurationEventEmitter.fire(configuration), errors.onUnexpectedError), FolderConfiguration.RELOAD_CONFIGURATION_DELAY));
 	}
 
-	loadConfiguration(): TPromise<FolderConfigurationModel<T>> {
+	loadConfiguration(): TPromise<FolderConfigurationModel> {
 		// Load workspace locals
 		return this.loadWorkspaceConfigFiles().then(workspaceConfigFiles => {
 			// Consolidate (support *.json files in the workspace settings folder)
-			const workspaceSettingsConfig = <FolderSettingsModel<T>>workspaceConfigFiles[WORKSPACE_CONFIG_DEFAULT_PATH] || new FolderSettingsModel<T>(null);
-			const otherConfigModels = Object.keys(workspaceConfigFiles).filter(key => key !== WORKSPACE_CONFIG_DEFAULT_PATH).map(key => <ScopedConfigurationModel<T>>workspaceConfigFiles[key]);
-			return new FolderConfigurationModel<T>(workspaceSettingsConfig, otherConfigModels, this.scope);
+			const workspaceSettingsConfig = <FolderSettingsModel>workspaceConfigFiles[WORKSPACE_CONFIG_DEFAULT_PATH] || new FolderSettingsModel(null);
+			const otherConfigModels = Object.keys(workspaceConfigFiles).filter(key => key !== WORKSPACE_CONFIG_DEFAULT_PATH).map(key => <ScopedConfigurationModel>workspaceConfigFiles[key]);
+			return new FolderConfigurationModel(workspaceSettingsConfig, otherConfigModels, this.scope);
 		});
 	}
 
-	private loadWorkspaceConfigFiles<T>(): TPromise<{ [relativeWorkspacePath: string]: ConfigurationModel<T> }> {
+	private loadWorkspaceConfigFiles(): TPromise<{ [relativeWorkspacePath: string]: ConfigurationModel }> {
 		// once: when invoked for the first time we fetch json files that contribute settings
 		if (!this.bulkFetchFromWorkspacePromise) {
 			this.bulkFetchFromWorkspacePromise = resolveStat(this.toResource(this.configFolderRelativePath)).then(stat => {
@@ -686,7 +686,7 @@ class FolderConfiguration<T> extends Disposable {
 		return this.bulkFetchFromWorkspacePromise.then(() => TPromise.join(this.workspaceFilePathToConfiguration));
 	}
 
-	public handleWorkspaceFileEvents(event: FileChangesEvent): TPromise<FolderConfigurationModel<T>> {
+	public handleWorkspaceFileEvents(event: FileChangesEvent): TPromise<FolderConfigurationModel> {
 		const events = event.changes;
 		let affectedByChanges = false;
 
@@ -744,18 +744,18 @@ class FolderConfiguration<T> extends Disposable {
 		});
 	}
 
-	private createConfigModel<T>(content: IContent): ConfigurationModel<T> {
+	private createConfigModel(content: IContent): ConfigurationModel {
 		const path = this.toFolderRelativePath(content.resource);
 		if (path === WORKSPACE_CONFIG_DEFAULT_PATH) {
-			return new FolderSettingsModel<T>(content.value, content.resource.toString());
+			return new FolderSettingsModel(content.value, content.resource.toString());
 		} else {
 			const matches = /\/([^\.]*)*\.json/.exec(path);
 			if (matches && matches[1]) {
-				return new ScopedConfigurationModel<T>(content.value, content.resource.toString(), matches[1]);
+				return new ScopedConfigurationModel(content.value, content.resource.toString(), matches[1]);
 			}
 		}
 
-		return new CustomConfigurationModel<T>(null);
+		return new CustomConfigurationModel(null);
 	}
 
 	private isWorkspaceConfigurationFile(folderRelativePath: string): boolean {