namespace ts {

// WARNING: The script `configureNightly.ts` uses a regexp to parse out these values.

// If changing the text in this section, be sure to test `configureNightly` too.

export const versionMajorMinor = "2.6";

/** The version of the TypeScript compiler release */

export const version = `${versionMajorMinor}.0`;

namespace ts {

export function isExternalModuleNameRelative(moduleName: string): boolean {

}

namespace ts {

// More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.

export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator(/*locales*/ undefined, { usage: "sort", sensitivity: "accent" }) : undefined;

// Intl is missing in Safari, and node 0.10 treats "a" as greater than "B".

export const localeCompareIsCorrect = ts.collator && ts.collator.compare("a", "B") < 0;

/** Create a MapLike with good performance. */

function createDictionaryObject<T>(): MapLike<T> {

}

/** Create a new map. If a template object is provided, the map will copy entries from it. */

export function createMap<T>(): Map<T> {

return new MapCtr<T>();

}

/** Create a new escaped identifier map. */

export function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T> {

return new MapCtr<T>() as UnderscoreEscapedMap<T>;

}

export function createSymbolTable(symbols?: ReadonlyArray<Symbol>): SymbolTable {

}

export function createMapFromTemplate<T>(template?: MapLike<T>): Map<T> {

}

// The global Map object. This may not be available, so we must test for it.

declare const Map: { new<T>(): Map<T> } | undefined;

// Internet Explorer's Map doesn't support iteration, so don't use it.

// tslint:disable-next-line:no-in-operator

const MapCtr = typeof Map !== "undefined" && "entries" in Map.prototype ? Map : shimMap();

// Keep the class inside a function so it doesn't get compiled if it's not used.

function shimMap(): { new<T>(): Map<T> } {

}

export function toPath(fileName: string, basePath: string, getCanonicalFileName: (path: string) => string): Path {

}

export const enum Comparison {

}

export function length(array: ReadonlyArray<any>) {

return array ? array.length : 0;

}

/**

export function forEach<T, U>(array: ReadonlyArray<T> | undefined, callback: (element: T, index: number) => U | undefined): U | undefined {

}

/**

export function findAncestor<T extends Node>(node: Node, callback: (element: Node) => element is T): T | undefined;

export function findAncestor(node: Node, callback: (element: Node) => boolean | "quit"): Node | undefined;

export function findAncestor(node: Node, callback: (element: Node) => boolean | "quit"): Node {

}

export function zipWith<T, U>(arrayA: ReadonlyArray<T>, arrayB: ReadonlyArray<U>, callback: (a: T, b: U, index: number) => void): void {

}

export function zipToMap<T>(keys: ReadonlyArray<string>, values: ReadonlyArray<T>): Map<T> {

}

/**

export function every<T>(array: ReadonlyArray<T>, callback: (element: T, index: number) => boolean): boolean {

}

/** Works like Array.prototype.find, returning `undefined` if no element satisfying the predicate is found. */

export function find<T>(array: ReadonlyArray<T>, predicate: (element: T, index: number) => boolean): T | undefined {

}

/** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */

export function findIndex<T>(array: ReadonlyArray<T>, predicate: (element: T, index: number) => boolean): number {

}

/**

export function findMap<T, U>(array: ReadonlyArray<T>, callback: (element: T, index: number) => U | undefined): U {

}

export function contains<T>(array: ReadonlyArray<T>, value: T): boolean {

}

export function indexOf<T>(array: ReadonlyArray<T>, value: T): number {

}

export function indexOfAnyCharCode(text: string, charCodes: ReadonlyArray<number>, start?: number): number {

}

export function countWhere<T>(array: ReadonlyArray<T>, predicate: (x: T, i: number) => boolean): number {

}

/**

export function filter<T, U extends T>(array: T[], f: (x: T) => x is U): U[];

export function filter<T>(array: T[], f: (x: T) => boolean): T[];

export function filter<T, U extends T>(array: ReadonlyArray<T>, f: (x: T) => x is U): ReadonlyArray<U>;

export function filter<T, U extends T>(array: ReadonlyArray<T>, f: (x: T) => boolean): ReadonlyArray<T>;

export function filter<T>(array: T[], f: (x: T) => boolean): T[] {

}

export function removeWhere<T>(array: T[], f: (x: T) => boolean): boolean {

}

export function filterMutate<T>(array: T[], f: (x: T, i: number, array: T[]) => boolean): void {

}

export function clear(array: {}[]): void {

array.length = 0;

}

export function map<T, U>(array: ReadonlyArray<T>, f: (x: T, i: number) => U): U[] {

}

// Maps from T to T and avoids allocation if all elements map to themselves

export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[];

export function sameMap<T>(array: ReadonlyArray<T>, f: (x: T, i: number) => T): ReadonlyArray<T>;

export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[] {

}

/**

export function flatten<T>(array: ReadonlyArray<T | ReadonlyArray<T>>): T[] {

}

/**

export function flatMap<T, U>(array: ReadonlyArray<T> | undefined, mapfn: (x: T, i: number) => U | ReadonlyArray<U> | undefined): U[] | undefined {

}

export function flatMapIter<T, U>(iter: Iterator<T>, mapfn: (x: T) => U | U[] | undefined): U[] {

}

/**

export function sameFlatMap<T>(array: T[], mapfn: (x: T, i: number) => T | ReadonlyArray<T>): T[];

export function sameFlatMap<T>(array: ReadonlyArray<T>, mapfn: (x: T, i: number) => T | ReadonlyArray<T>): ReadonlyArray<T>;

export function sameFlatMap<T>(array: T[], mapfn: (x: T, i: number) => T | T[]): T[] {

}

export function mapDefined<T, U>(array: ReadonlyArray<T> | undefined, mapFn: (x: T, i: number) => U | undefined): U[] {

}

export function mapDefinedIter<T, U>(iter: Iterator<T>, mapFn: (x: T) => U | undefined): U[] {

}

/**

export function span<T>(array: ReadonlyArray<T>, f: (x: T, i: number) => boolean): [T[], T[]] {

}

/**

export function spanMap<T, K, U>(array: ReadonlyArray<T>, keyfn: (x: T, i: number) => K, mapfn: (chunk: T[], key: K, start: number, end: number) => U): U[] {

}

export function mapEntries<T, U>(map: ReadonlyMap<T>, f: (key: string, value: T) => [string, U]): Map<U> {

}

export function some<T>(array: ReadonlyArray<T>, predicate?: (value: T) => boolean): boolean {

}

export function concatenate<T>(array1: T[], array2: T[]): T[];

export function concatenate<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>): ReadonlyArray<T>;

export function concatenate<T>(array1: T[], array2: T[]): T[] {

}

// TODO: fixme (N^2) - add optional comparer so collection can be sorted before deduplication.

export function deduplicate<T>(array: ReadonlyArray<T>, areEqual?: (a: T, b: T) => boolean): T[] {

}

export function arrayIsEqualTo<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, equaler?: (a: T, b: T) => boolean): boolean {

}

export function changesAffectModuleResolution(oldOptions: CompilerOptions, newOptions: CompilerOptions): boolean {

}

/**

export function compact<T>(array: T[]): T[];

export function compact<T>(array: ReadonlyArray<T>): ReadonlyArray<T>;

export function compact<T>(array: T[]): T[] {