import { CancellationToken } from 'vscode-languageserver';
import { IBackgroundAnalysis } from '../backgroundAnalysisBase';
import { CommandLineOptions } from '../common/commandLineOptions';
import { ConfigOptions } from '../common/configOptions';
import { ConsoleInterface } from '../common/console';
import { Diagnostic } from '../common/diagnostic';
import { FileEditAction } from '../common/editAction';
import { EditableProgram, ProgramView } from '../common/extensibility';
import { FileSystem } from '../common/fileSystem';
import { Host, HostFactory } from '../common/host';
import { ServiceProvider } from '../common/serviceProvider';
import { Range } from '../common/textRange';
import { Uri } from '../common/uri/uri';
import { AnalysisCompleteCallback } from './analysis';
import { BackgroundAnalysisProgram, BackgroundAnalysisProgramFactory, InvalidatedReason } from './backgroundAnalysisProgram';
import { ImportResolver, ImportResolverFactory } from './importResolver';
import { ChangedRange, MaxAnalysisTime, Program } from './program';
import { IPythonMode } from './sourceFile';
export interface LibraryReanalysisTimeProvider {
    (): number;
    libraryReanalysisStarted?: () => void;
    libraryUpdated?: (cancelled: boolean) => void;
}
export interface AnalyzerServiceOptions {
    console?: ConsoleInterface;
    hostFactory?: HostFactory;
    importResolverFactory?: ImportResolverFactory;
    configOptions?: ConfigOptions;
    backgroundAnalysis?: IBackgroundAnalysis;
    maxAnalysisTime?: MaxAnalysisTime;
    backgroundAnalysisProgramFactory?: BackgroundAnalysisProgramFactory;
    libraryReanalysisTimeProvider?: LibraryReanalysisTimeProvider;
    serviceId?: string;
    skipScanningUserFiles?: boolean;
    fileSystem?: FileSystem;
    onInvalidated?: (reason: InvalidatedReason) => void;
    onSourceEnumerationComplete?: () => void;
    shouldRunAnalysis: () => boolean;
}
export declare function getNextServiceId(name: string): string;
export declare class AnalyzerService {
    protected readonly options: AnalyzerServiceOptions;
    private readonly _backgroundAnalysisProgram;
    private readonly _serviceProvider;
    private _instanceName;
    private _executionRootUri;
    private _typeStubTargetUri;
    private _typeStubTargetIsSingleFile;
    private _sourceFileWatcher;
    private _reloadConfigTimer;
    private _libraryReanalysisTimer;
    private _primaryConfigFileUri;
    private _extendedConfigFileUris;
    private _configFileWatcher;
    private _libraryFileWatcher;
    private _librarySearchUrisToWatch;
    private _onCompletionCallback;
    private _commandLineOptions;
    private _analyzeTimer;
    private _requireTrackedFileUpdate;
    private _lastUserInteractionTime;
    private _backgroundAnalysisCancellationSource;
    private _sourceEnumerator;
    private _disposed;
    private _pendingLibraryChanges;
    constructor(instanceName: string, serviceProvider: ServiceProvider, options: AnalyzerServiceOptions);
    get fs(): FileSystem;
    get serviceProvider(): ServiceProvider;
    get cancellationProvider(): import("../common/cancellationUtils").CancellationProvider;
    get librarySearchUrisToWatch(): Uri[] | undefined;
    get backgroundAnalysisProgram(): BackgroundAnalysisProgram;
    get test_program(): Program;
    get id(): string;
    get checkOnlyOpenFiles(): boolean;
    setServiceName(instanceName: string): void;
    clone(instanceName: string, serviceId: string, backgroundAnalysis?: IBackgroundAnalysis, fileSystem?: FileSystem): AnalyzerService;
    runEditMode(callback: (e: EditableProgram) => void, token: CancellationToken): FileEditAction[];
    dispose(): void;
    static createImportResolver(serviceProvider: ServiceProvider, options: ConfigOptions, host: Host): ImportResolver;
    setCompletionCallback(callback: AnalysisCompleteCallback | undefined): void;
    setOptions(commandLineOptions: CommandLineOptions): void;
    hasSourceFile(uri: Uri): boolean;
    isTracked(uri: Uri): boolean;
    getUserFiles(): Uri[];
    getOpenFiles(): Uri[];
    getOwnedFiles(): Uri[];
    setFileOpened(uri: Uri, version: number | null, contents: string, ipythonMode?: IPythonMode, chainedFileUri?: Uri): void;
    getChainedUri(uri: Uri): Uri | undefined;
    updateChainedUri(uri: Uri, chainedFileUri: Uri | undefined): void;
    updateOpenFileContents(uri: Uri, version: number | null, contents: string, ipythonMode?: IPythonMode, changedRange?: ChangedRange): void;
    setFileClosed(uri: Uri, isTracked?: boolean): void;
    addInterimFile(uri: Uri): void;
    getParserOutput(uri: Uri): import("../parser/parser").ParserOutput | undefined;
    getParseResults(uri: Uri): import("../parser/parser").ParseFileResults | undefined;
    getSourceFile(uri: Uri): import("./sourceFile").SourceFile | undefined;
    getTextOnRange(fileUri: Uri, range: Range, token: CancellationToken): string | undefined;
    run<T>(callback: (p: ProgramView) => T, token: CancellationToken): T;
    printStats(): void;
    printDetailedAnalysisTimes(): void;
    printDependencies(verbose: boolean): void;
    analyzeFile(fileUri: Uri, token: CancellationToken): Promise<boolean>;
    analyzeFileAndGetDiagnostics(fileUri: Uri, token: CancellationToken): Promise<Diagnostic[]>;
    getDiagnosticsForRange(fileUri: Uri, range: Range, token: CancellationToken): Promise<Diagnostic[]>;
    getConfigOptions(): ConfigOptions;
    getImportResolver(): ImportResolver;
    recordUserInteractionTime(): void;
    test_getConfigOptions(commandLineOptions: CommandLineOptions): ConfigOptions;
    test_getFileNamesFromFileSpecs(): Uri[];
    test_shouldHandleSourceFileWatchChanges(uri: Uri, isFile: boolean): boolean;
    test_shouldHandleLibraryFileWatchChanges(uri: Uri, libSearchUris: Uri[]): boolean;
    writeTypeStub(token: CancellationToken): void;
    writeTypeStubInBackground(token: CancellationToken): Promise<any>;
    invalidateAndScheduleReanalysis(reason: InvalidatedReason): void;
    invalidateAndForceReanalysis(reason: InvalidatedReason): void;
    restart(): void;
    enumerateSourceFiles(maxSourceEnumeratorTime: number): boolean;
    protected runAnalysis(token: CancellationToken): void;
    protected scheduleReanalysis(requireTrackedFileUpdate: boolean): void;
    protected applyConfigOptions(host: Host): void;
    private get _console();
    private get _hostFactory();
    private get _importResolverFactory();
    private get _program();
    private get _configOptions();
    private get _watchForSourceChanges();
    private get _watchForLibraryChanges();
    private get _watchForConfigChanges();
    private get _typeCheckingMode();
    private get _verboseOutput();
    private get _typeStubTargetImportName();
    private _getConfigOptions;
    private _ensureDefaultOptions;
    private _applyLanguageServerOptions;
    private _applyCommandLineOverrides;
    private _getExtendedConfigurations;
    private _getTypeStubFolder;
    private _parseJsonConfigFile;
    private _parsePyprojectTomlFile;
    private _attemptParseFile;
    private _getTrackedFileList;
    private _updateTrackedFileList;
    private _removeSourceFileWatchers;
    private _updateSourceFileWatchers;
    private _shouldHandleSourceFileWatchChanges;
    private _removeLibraryFileWatcher;
    private _updateLibraryFileWatcher;
    private _shouldHandleLibraryFileWatchChanges;
    private _clearLibraryReanalysisTimer;
    private _scheduleLibraryAnalysis;
    private _removeConfigFileWatcher;
    private _updateConfigFileWatcher;
    private _clearReloadConfigTimer;
    private _scheduleReloadConfigFile;
    private _reloadConfigFile;
    private _clearReanalysisTimer;
    private _reportConfigParseError;
}