@vscode/chat-lib 0.0.1 → 0.0.2

package/src/_internal/extension/inlineEdits/common/nearbyCursorInlineEditProvider.ts

@@ -1,225 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { StatelessNextEditDocument } from '../../../platform/inlineEdits/common/statelessNextEditProvider';
-import { ChoiceLogProbs } from '../../../platform/networking/common/openai';
-import { BugIndicatingError } from '../../../util/vs/base/common/errors';
-import { Range } from '../../../util/vs/editor/common/core/range';
-import { OffsetRange, OffsetRangeSet } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-
-/**
- * Read the selection from the document, otherwise deduce it from the last edit.
- */
-export function getOrDeduceSelectionFromLastEdit(activeDoc: StatelessNextEditDocument): Range | null {
-	const origin = new OffsetRange(0, 0);
-	if (activeDoc.lastSelectionInAfterEdit && !activeDoc.lastSelectionInAfterEdit.equals(origin)) {
-		return activeDoc.documentAfterEdits.getTransformer().getRange(activeDoc.lastSelectionInAfterEdit);
-	}
-
-	const selectionRange = deduceSelectionFromLastEdit(activeDoc);
-	return selectionRange;
-}
-
-function deduceSelectionFromLastEdit(activeDoc: StatelessNextEditDocument): Range | null {
-	const mostRecentEdit = activeDoc.recentEdits.edits.at(-1);
-	if (mostRecentEdit === undefined) {
-		return null;
-	}
-
-	const mostRecentSingleEdit = mostRecentEdit.replacements.at(-1);
-	if (mostRecentSingleEdit === undefined) {
-		return null;
-	}
-
-	const offsetRange = mostRecentSingleEdit.replaceRange;
-	const newText = mostRecentSingleEdit.newText;
-	const change = newText.length - offsetRange.length;
-	const newOffset = offsetRange.endExclusive + change;
-
-	const selectionRange = activeDoc.documentAfterEdits.getTransformer().getRange(new OffsetRange(newOffset, newOffset));
-
-	return selectionRange;
-}
-
-type Tokens = Token<number>[];
-
-export class Token<T> {
-	public readonly range: OffsetRange;
-
-	get id(): string {
-		return this.text + '_' + this.range.toString();
-	}
-
-	constructor(public readonly text: string, public readonly value: T, offset: number) {
-		this.range = new OffsetRange(offset, offset + text.length);
-	}
-
-	public equals(other: Token<T>): boolean {
-		return this.range.equals(other.range) && this.text === other.text;
-	}
-
-	public deltaOffset(offset: number): Token<T> {
-		return new Token(this.text, this.value, this.range.start + offset);
-	}
-}
-
-export function clipTokensToRange(tokens: Tokens, range: OffsetRange): Tokens {
-	return tokens.filter(token => range.intersects(token.range));
-}
-
-export function clipTokensToRangeAndAdjustOffsets(tokens: Tokens, range: OffsetRange): Tokens {
-	return clipTokensToRange(tokens, range).map(token => token.deltaOffset(-range.start));
-}
-
-export function removeTokensInRangeAndAdjustOffsets(tokens: Tokens, range: OffsetRange): Tokens {
-	const adjustedTokens: Tokens = [];
-	for (let token of tokens) {
-		// remove tokens inside the range
-		if (range.containsRange(token.range)) {
-			continue;
-		}
-		// adjust the token offset
-		if (token.range.start > range.start) {
-			token = token.deltaOffset(-range.length);
-		}
-
-		adjustedTokens.push(token);
-	}
-
-	return adjustedTokens;
-}
-
-export function getTokensFromLogProbs(logProbs: ChoiceLogProbs, offset: number): Tokens {
-	let acc = offset;
-	return logProbs.content.map(tokenContent => {
-		const token = new Token(tokenContent.token, tokenContent.logprob, acc);
-		acc += token.range.length;
-		return token;
-	});
-}
-
-export class LineWithTokens {
-
-	static stringEquals(a: LineWithTokens, b: LineWithTokens): boolean {
-		return a._text === b._text;
-	}
-
-	static fromText(text: string, tokens: Tokens | undefined): LineWithTokens[] {
-		tokens = tokens ?? [];
-
-		const lines: LineWithTokens[] = [];
-		while (true) {
-			const eolIdxWith = text.indexOf('\r\n');
-			const eolIdxWithout = text.indexOf('\n');
-			const eolIdx = (eolIdxWith === -1 ? eolIdxWithout : (eolIdxWithout === -1 ? eolIdxWith : Math.min(eolIdxWith, eolIdxWithout)));
-			const eol = (eolIdxWith !== -1 ? '\r\n' : (eolIdxWithout === -1 ? undefined : '\n'));
-
-			if (eol === undefined) {
-				lines.push(new LineWithTokens(text, tokens, '\n'));
-				break;
-			}
-
-			const lineLength = eolIdx + eol.length;
-			const line = text.substring(0, eolIdx);
-			const lineTokensWithBoundary = tokens.filter(t => t.range.start < lineLength && t.range.endExclusive > 0);
-			lines.push(new LineWithTokens(line, lineTokensWithBoundary, eol));
-
-			text = text.substring(lineLength);
-			tokens = tokens.map(t => t.deltaOffset(-lineLength)).filter(t => t.range.endExclusive > 0);
-		}
-
-		return lines;
-	}
-
-	get text(): string { return this._text; }
-	get tokens(): Tokens { return this._tokens; }
-	get length(): number { return this._text.length; }
-	get lengthWithEOL(): number { return this._text.length + this._eol.length; }
-	get eol(): '\n' | '\r\n' { return this._eol; }
-
-	constructor(
-		private readonly _text: string,
-		private readonly _tokens: Tokens,
-		private readonly _eol: '\n' | '\r\n'
-	) { }
-
-	trim() {
-		return this.trimStart().trimEnd();
-	}
-
-	trimStart() {
-		const lineStartTrimmed = this._text.trimStart();
-		const trimmedLength = this._text.length - lineStartTrimmed.length;
-		const tokensUpdated = this._tokens.map(t => t.deltaOffset(-trimmedLength)).filter(t => t.range.endExclusive > 0);
-		return new LineWithTokens(lineStartTrimmed, tokensUpdated, this._eol);
-	}
-
-	trimEnd() {
-		const lineEndTrimmed = this._text.trimEnd();
-		const tokensUpdated = this._tokens.filter(t => t.range.start < lineEndTrimmed.length);
-		return new LineWithTokens(lineEndTrimmed, tokensUpdated, this._eol);
-	}
-
-	substring(start: number, end: number): LineWithTokens {
-		const lineSubstring = this._text.substring(start, end);
-		const tokensUpdated = this._tokens.map(t => t.deltaOffset(-start)).filter(t => t.range.endExclusive > 0 && t.range.start < lineSubstring.length);
-		return new LineWithTokens(lineSubstring, tokensUpdated, this._eol);
-	}
-
-	stringEquals(other: LineWithTokens): boolean {
-		return LineWithTokens.stringEquals(this, other);
-	}
-
-	equals(other: LineWithTokens): boolean {
-		return this._text === other.text
-			&& this._tokens.length === other.tokens.length
-			&& this._tokens.every((t, i) => t.equals(other.tokens[i]));
-	}
-
-	dropTokens(tokens: Tokens): LineWithTokens {
-		return new LineWithTokens(this._text, this._tokens.filter(t => !tokens.some(token => t.equals(token))), this._eol);
-	}
-
-	findTokens(fn: (token: Token<number>) => boolean): Token<number>[] {
-		return this._tokens.filter(fn);
-	}
-}
-
-export function getTokensFromLinesWithTokens(lines: LineWithTokens[]): Tokens {
-	let offset = 0;
-
-	const tokens: Tokens = [];
-	for (const line of lines) {
-		const textLine = line.text + line.eol;
-		tokens.push(...line.tokens.map(t => t.deltaOffset(offset)));
-		offset += textLine.length;
-	}
-
-	const tokensDeduplicated: Tokens = [];
-	const tokensSeen = new Set<string>();
-	for (const token of tokens) {
-		if (!tokensSeen.has(token.id)) {
-			tokensSeen.add(token.id);
-			tokensDeduplicated.push(token);
-		}
-	}
-
-	return tokensDeduplicated;
-}
-
-export function mergeOffsetRangesAtDistance(ranges: OffsetRange[], distance: number): OffsetRange[] {
-	if (distance < 0) {
-		throw new BugIndicatingError('Distance must be positive');
-	}
-
-	const rangesGrown = ranges.map(r => new OffsetRange(r.start - distance, r.endExclusive + distance));
-
-	const set = new OffsetRangeSet();
-	for (const range of rangesGrown) {
-		set.addRange(range);
-	}
-
-	return set.ranges.map(r => new OffsetRange(r.start + distance, r.endExclusive - distance));
-}

package/src/_internal/extension/inlineEdits/common/rejectionCollector.ts

@@ -1,164 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DocumentId } from '../../../platform/inlineEdits/common/dataTypes/documentId';
-import { IObservableDocument, ObservableWorkspace } from '../../../platform/inlineEdits/common/observableWorkspace';
-import { autorunWithChanges } from '../../../platform/inlineEdits/common/utils/observable';
-import { createTracer, ITracer } from '../../../util/common/tracing';
-import { Disposable, IDisposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { mapObservableArrayCached } from '../../../util/vs/base/common/observable';
-import { StringEdit, StringReplacement } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-
-export class RejectionCollector extends Disposable {
-	private readonly _garbageCollector = this._register(new LRUGarbageCollector(20));
-	private readonly _documentCaches = new Map<DocumentId, DocumentRejectionTracker>();
-	private readonly _tracer: ITracer;
-
-	constructor(
-		public readonly workspace: ObservableWorkspace,
-		trace: (s: string) => void,
-	) {
-		super();
-
-		this._tracer = createTracer(['NES', 'RejectionCollector'], trace);
-
-		mapObservableArrayCached(this, workspace.openDocuments, (doc, store) => {
-			const state = new DocumentRejectionTracker(doc, this._garbageCollector, this._tracer);
-			this._documentCaches.set(state.doc.id, state);
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-				selection: doc.selection,
-				languageId: doc.languageId,
-			}, (data) => {
-				for (const edit of data.value.changes) {
-					state.handleEdit(edit, data.value.value);
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				this._documentCaches.delete(doc.id);
-			}));
-		}).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	public reject(docId: DocumentId, edit: StringReplacement): void {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			this._tracer.trace(`Rejecting, no document cache: ${edit}`);
-			return;
-		}
-		const e = edit.removeCommonSuffixAndPrefix(docCache.doc.value.get().value);
-		this._tracer.trace(`Rejecting: ${e}`);
-		docCache.reject(e);
-	}
-
-	public isRejected(docId: DocumentId, edit: StringReplacement): boolean {
-		const docCache = this._documentCaches.get(docId);
-		if (!docCache) {
-			this._tracer.trace(`Checking rejection, no document cache: ${edit}`);
-			return false;
-		}
-		const e = edit.removeCommonSuffixAndPrefix(docCache.doc.value.get().value);
-		const isRejected = docCache.isRejected(e);
-		this._tracer.trace(`Checking rejection, ${isRejected ? 'rejected' : 'not rejected'}: ${e}`);
-		return isRejected;
-	}
-
-	public clear() {
-		this._garbageCollector.clear();
-	}
-}
-
-class DocumentRejectionTracker {
-	private readonly _rejectedEdits = new Set<RejectedEdit>();
-
-	constructor(
-		public readonly doc: IObservableDocument,
-		private readonly _garbageCollector: LRUGarbageCollector,
-		private readonly _tracer: ITracer,
-	) {
-	}
-
-	public handleEdit(edit: StringEdit, currentContent: StringText): void {
-		for (const r of [...this._rejectedEdits]) {
-			r.handleEdit(edit, currentContent); // this can remove the rejected edit from the set
-		}
-	}
-
-	public reject(edit: StringReplacement): void {
-		if (this.isRejected(edit)) {
-			// already tracked
-			return;
-		}
-		const r = new RejectedEdit(edit.toEdit(), () => {
-			this._tracer.trace(`Evicting: ${edit}`);
-			this._rejectedEdits.delete(r);
-		});
-		this._rejectedEdits.add(r);
-		this._garbageCollector.put(r);
-	}
-
-	public isRejected(edit: StringReplacement): boolean {
-		for (const r of this._rejectedEdits) {
-			if (r.isRejected(edit)) {
-				return true;
-			}
-		}
-		return false;
-	}
-}
-
-class RejectedEdit implements IDisposable {
-	constructor(
-		private _edit: StringEdit,
-		private readonly _onDispose: () => void,
-	) { }
-
-	public handleEdit(edit: StringEdit, currentContent: StringText): void {
-		const d = this._edit.tryRebase(edit);
-		if (d) {
-			this._edit = d.removeCommonSuffixAndPrefix(currentContent.value);
-		} else {
-			this.dispose();
-		}
-	}
-
-	public isRejected(edit: StringReplacement): boolean {
-		return this._edit.equals(edit.toEdit());
-	}
-
-	public dispose(): void {
-		this._onDispose();
-	}
-}
-
-class LRUGarbageCollector implements IDisposable {
-	private _disposables: IDisposable[] = [];
-
-	constructor(
-		private _maxSize: number,
-	) {
-	}
-
-	put(disposable: IDisposable): void {
-		this._disposables.push(disposable);
-		if (this._disposables.length > this._maxSize) {
-			this._disposables.shift()!.dispose();
-		}
-	}
-
-	public clear(): void {
-		for (const d of this._disposables) {
-			d.dispose();
-		}
-		this._disposables = [];
-	}
-
-	public dispose(): void {
-		this.clear();
-	}
-}

package/src/_internal/extension/inlineEdits/node/debugRecorder.ts

@@ -1,205 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { DocumentId } from '../../../platform/inlineEdits/common/dataTypes/documentId';
-import { serializeStringEdit } from '../../../platform/inlineEdits/common/dataTypes/editUtils';
-import { LanguageId } from '../../../platform/inlineEdits/common/dataTypes/languageId';
-import { DebugRecorderBookmark } from '../../../platform/inlineEdits/common/debugRecorderBookmark';
-import { ObservableWorkspace } from '../../../platform/inlineEdits/common/observableWorkspace';
-import { autorunWithChanges } from '../../../platform/inlineEdits/common/utils/observable';
-import { Instant, now } from '../../../platform/inlineEdits/common/utils/utils';
-import { ISerializedOffsetRange, LogEntry } from '../../../platform/workspaceRecorder/common/workspaceLog';
-import { compareBy, numberComparator } from '../../../util/vs/base/common/arrays';
-import { Disposable, toDisposable } from '../../../util/vs/base/common/lifecycle';
-import { Schemas } from '../../../util/vs/base/common/network';
-import { mapObservableArrayCached } from '../../../util/vs/base/common/observableInternal';
-import { relative } from '../../../util/vs/base/common/path';
-import { URI } from '../../../util/vs/base/common/uri';
-import { generateUuid } from '../../../util/vs/base/common/uuid';
-import { StringEdit } from '../../../util/vs/editor/common/core/edits/stringEdit';
-import { OffsetRange } from '../../../util/vs/editor/common/core/ranges/offsetRange';
-import { StringText } from '../../../util/vs/editor/common/core/text/abstractText';
-
-export class DebugRecorder extends Disposable {
-	private _id: number = 0;
-	private readonly _documentHistories = new Map<DocumentId, DocumentHistory>();
-
-	private _workspaceRoot: URI | undefined;
-
-	constructor(
-		private readonly _workspace: ObservableWorkspace,
-		private readonly getNow = now
-	) {
-		super();
-
-		mapObservableArrayCached(this, this._workspace.openDocuments, (doc, store) => {
-			const root = this._workspace.getWorkspaceRoot(doc.id);
-			if (!root) {
-				return;
-			}
-			if (!this._workspaceRoot) {
-				this._workspaceRoot = root;
-			} else {
-				if (this._workspaceRoot.toString() !== root.toString()) {
-					// document is from a different root -> ignore
-					return;
-				}
-			}
-
-			const state = new DocumentHistory(root, doc.id, doc.value.get().value, this._id++, doc.languageId.get(), () => this.getTimestamp());
-			this._documentHistories.set(state.docId, state);
-
-			store.add(autorunWithChanges(this, {
-				value: doc.value,
-				selection: doc.selection,
-				languageId: doc.languageId,
-			}, (data) => {
-				if (data.languageId.changes.length > 0) {
-					state.languageId = data.languageId.value;
-				}
-				for (const edit of data.value.changes) {
-					state.handleEdit(edit);
-				}
-				if (data.selection.changes.length > 0) {
-					state.handleSelections(data.selection.value);
-				}
-			}));
-
-			store.add(toDisposable(() => {
-				// We might want to soft-delete the document
-				this._documentHistories.delete(doc.id);
-			}));
-		}, d => d.id).recomputeInitiallyAndOnChange(this._store);
-	}
-
-	private _lastTimestamp: number | undefined;
-	public getTimestamp(): number {
-		let newTimestamp = this.getNow();
-		if (this._lastTimestamp !== undefined && newTimestamp <= this._lastTimestamp) { // we want total ordering on the events
-			newTimestamp = this._lastTimestamp + 1;
-		}
-		this._lastTimestamp = newTimestamp;
-		return newTimestamp;
-	}
-
-	public getRecentLog(bookmark: DebugRecorderBookmark | undefined = undefined): LogEntry[] | undefined {
-		if (!this._workspaceRoot) { // possible if the open file doesn't belong to a workspace
-			return undefined;
-		}
-
-		const log: {
-			entry: LogEntry;
-			sortTime: number;
-		}[] = [];
-
-		log.push({ entry: { documentType: 'workspaceRecording@1.0', kind: 'header', repoRootUri: this._workspaceRoot.toString(), time: this.getNow(), uuid: generateUuid() }, sortTime: 0 });
-
-		for (const doc of this._documentHistories.values()) {
-			log.push(...doc.getDocumentLog(bookmark));
-		}
-
-		log.sort(compareBy(e => e.sortTime, numberComparator));
-
-		return log.map(l => l.entry);
-	}
-
-	public createBookmark(): DebugRecorderBookmark {
-		return new DebugRecorderBookmark(this.getNow());
-	}
-}
-
-class DocumentHistory {
-	private _baseValue: StringText;
-	/**
-	 * Stores edits and selection changes in the order they happened.
-	 */
-	private _edits: ({
-		kind: 'edit';
-		edit: StringEdit;
-		instant: Instant;
-	} | {
-		kind: 'selections';
-		selections: readonly OffsetRange[];
-		instant: Instant;
-	})[] = [];
-
-	public readonly creationTime: number;
-	private _baseValueTime: number;
-
-	constructor(
-		public readonly workspaceUri: URI,
-		public readonly docId: DocumentId,
-		initialValue: string,
-		public readonly id: number,
-		public languageId: LanguageId,
-		private readonly getNow: () => Instant
-	) {
-		this._baseValue = new StringText(initialValue);
-		this.creationTime = this.getNow();
-		this._baseValueTime = this.creationTime;
-	}
-
-	public handleSelections(selections: readonly OffsetRange[]): void {
-		this._edits.push({ kind: 'selections', selections, instant: this.getNow() });
-	}
-
-	public handleEdit(edit: StringEdit): void {
-		if (edit.isEmpty()) {
-			return;
-		}
-
-		this._edits.push({ kind: 'edit', edit, instant: this.getNow() });
-
-		this.cleanUpHistory();
-	}
-
-	public cleanUpHistory(): void {
-		const minuteMs = 60 * 1000;
-		const earliestTime = this.getNow() - 10 * minuteMs;
-		while (this._edits.length > 0 && this._edits[0].instant < earliestTime) {
-			const edit = this._edits.shift()!;
-			if (edit.kind === 'selections') {
-				continue; // we drop selection changes
-			}
-			this._baseValue = edit.edit.applyOnText(this._baseValue);
-			this._baseValueTime = edit.instant;
-		}
-	}
-
-	private readonly relativePath = (() => {
-		const basePath = relative(this.workspaceUri.path, this.docId.path);
-		return this.docId.toUri().scheme === Schemas.vscodeNotebookCell ? `${basePath}#${this.docId.fragment}` : basePath;
-	})();
-
-	getDocumentLog(bookmark: DebugRecorderBookmark | undefined): { entry: LogEntry; sortTime: number }[] {
-		this.cleanUpHistory();
-
-		if (this._edits.length === 0) {
-			return [];
-		}
-
-		const log: { entry: LogEntry; sortTime: number }[] = [];
-		log.push({ entry: { kind: 'documentEncountered', id: this.id, relativePath: this.relativePath, time: this.creationTime }, sortTime: this.creationTime });
-		let docVersion = 1;
-		log.push({ entry: { kind: 'setContent', id: this.id, v: docVersion, content: this._baseValue.value, time: this._baseValueTime }, sortTime: this._baseValueTime });
-		log.push({ entry: { kind: 'opened', id: this.id, time: this._baseValueTime }, sortTime: this._baseValueTime });
-
-		for (const editOrSelectionChange of this._edits) {
-			if (bookmark && editOrSelectionChange.instant > bookmark.timeMs) {
-				// only considers edits that happened before the bookmark
-				break;
-			}
-			docVersion++;
-			if (editOrSelectionChange.kind === 'selections') {
-				const serializedOffsetRange: ISerializedOffsetRange[] = editOrSelectionChange.selections.map(s => [s.start, s.endExclusive]);
-				log.push({ entry: { kind: 'selectionChanged', id: this.id, selection: serializedOffsetRange, time: editOrSelectionChange.instant }, sortTime: editOrSelectionChange.instant });
-			} else {
-				log.push({ entry: { kind: 'changed', id: this.id, v: docVersion, edit: serializeStringEdit(editOrSelectionChange.edit), time: editOrSelectionChange.instant }, sortTime: editOrSelectionChange.instant });
-			}
-		}
-
-		return log;
-	}
-}

package/src/_internal/extension/inlineEdits/node/importFiltering.ts

@@ -1,25 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { StatelessNextEditDocument } from '../../../platform/inlineEdits/common/statelessNextEditProvider';
-import { coalesce } from '../../../util/vs/base/common/arrays';
-import { LineReplacement } from '../../../util/vs/editor/common/core/edits/lineEdit';
-import { isImportStatement } from '../../prompt/common/importStatement';
-
-export class IgnoreImportChangesAspect {
-	public static isImportChange(edit: LineReplacement, languageId: string, lines: string[]): boolean {
-		return edit.newLines.some(l => isImportStatement(l, languageId)) || getOldLines(edit, lines).some(l => isImportStatement(l, languageId));
-	}
-
-	public static filterEdit(resultDocument: StatelessNextEditDocument, singleEdits: readonly LineReplacement[]): readonly LineReplacement[] {
-		const languageId = resultDocument.languageId;
-		const filteredEdits = singleEdits.filter(e => !IgnoreImportChangesAspect.isImportChange(e, languageId, resultDocument.documentLinesBeforeEdit));
-		return filteredEdits;
-	}
-}
-
-function getOldLines(edit: LineReplacement, lines: string[]): string[] {
-	return coalesce(edit.lineRange.mapToLineArray<string | undefined>(l => lines[l - 1]));
-}

package/src/_internal/extension/inlineEdits/node/nesConfigs.ts

@@ -1,12 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export interface INesConfigs {
-	isAsyncCompletions: boolean;
-	isRevisedCacheStrategy: boolean;
-	isCacheTracksRejections: boolean;
-	isRecentlyShownCacheEnabled: boolean;
-	debounceUseCoreRequestTime: boolean;
-}