import * as React from '@theia/core/shared/react';
import { LabelProvider } from '@theia/core/lib/browser';
import { DebugProtocol } from '@vscode/debugprotocol';
import { Emitter, Event, DisposableCollection, Disposable, MessageClient, MessageType, ContributionProvider, CommandService } from '@theia/core/lib/common';
import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
import { EditorManager } from '@theia/editor/lib/browser';
import { CompositeTreeElement } from '@theia/core/lib/browser/source-tree';
import { DebugSessionConnection, DebugRequestTypes, DebugEventTypes } from './debug-session-connection';
import { DebugThread, StoppedDetails } from './model/debug-thread';
import { DebugScope, DebugVariable } from './console/debug-console-items';
import { DebugStackFrame } from './model/debug-stack-frame';
import { DebugSource } from './model/debug-source';
import { DebugBreakpoint } from './model/debug-breakpoint';
import URI from '@theia/core/lib/common/uri';
import { BreakpointManager } from './breakpoint/breakpoint-manager';
import { DebugConfigurationSessionOptions, TestRunReference } from './debug-session-options';
import { DebugConfiguration } from '../common/debug-common';
import { TerminalWidgetOptions, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
import { FileService } from '@theia/filesystem/lib/browser/file-service';
import { DebugContribution } from './debug-contribution';
import { Deferred } from '@theia/core/lib/common/promise-util';
import { WorkspaceService } from '@theia/workspace/lib/browser';
import { TestService } from '@theia/test/lib/browser/test-service';
import { DebugSessionManager } from './debug-session-manager';
import { DebugPreferences } from '../common/debug-preferences';
export declare enum DebugState {
    Inactive = 0,
    Initializing = 1,
    Running = 2,
    Stopped = 3
}
/**
 * The mapped string values must not change as they are used for the `debugState` when context closure.
 * For more details see the `Debugger contexts` section of the [official doc](https://code.visualstudio.com/api/references/when-clause-contexts#available-contexts).
 */
export declare function debugStateContextValue(state: DebugState): string;
/**
 * Returns a formatted message string. The format is compatible with {@link DebugProtocol.Message.format}.
 * @param format A format string for the message. Embedded variables have the form `{name}`.
 * @param variables An object used as a dictionary for looking up the variables in the format string.
 */
export declare function formatMessage(format: string, variables?: {
    [key: string]: string;
}): string;
export declare class DebugSession implements CompositeTreeElement {
    readonly id: string;
    readonly options: DebugConfigurationSessionOptions;
    readonly parentSession: DebugSession | undefined;
    protected readonly connection: DebugSessionConnection;
    protected readonly terminalServer: TerminalService;
    protected readonly editorManager: EditorManager;
    protected readonly breakpoints: BreakpointManager;
    protected readonly labelProvider: LabelProvider;
    protected readonly messages: MessageClient;
    protected readonly fileService: FileService;
    protected readonly debugContributionProvider: ContributionProvider<DebugContribution>;
    protected readonly workspaceService: WorkspaceService;
    protected readonly debugPreferences: DebugPreferences;
    protected readonly commandService: CommandService;
    /**
     * Number of millis after a `stop` request times out. It's 5 seconds by default.
     */
    protected readonly stopTimeout: number;
    protected readonly deferredOnDidConfigureCapabilities: Deferred<void>;
    protected readonly onDidChangeEmitter: Emitter<void>;
    readonly onDidChange: Event<void>;
    protected fireDidChange(): void;
    protected readonly onDidFocusStackFrameEmitter: Emitter<DebugStackFrame | undefined>;
    get onDidFocusStackFrame(): Event<DebugStackFrame | undefined>;
    protected readonly onDidFocusThreadEmitter: Emitter<DebugThread | undefined>;
    get onDidFocusThread(): Event<DebugThread | undefined>;
    protected readonly onDidResolveLazyVariableEmitter: Emitter<DebugVariable>;
    readonly onDidResolveLazyVariable: Event<DebugVariable>;
    protected readonly childSessions: Map<string, DebugSession>;
    protected readonly toDispose: DisposableCollection;
    protected isStopping: boolean;
    /** Maximum time to wait for the shell integration prompt before proceeding. */
    protected readonly PROMPT_READY_TIMEOUT_MS = 3000;
    constructor(id: string, options: DebugConfigurationSessionOptions, parentSession: DebugSession | undefined, testService: TestService, testRun: TestRunReference | undefined, sessionManager: DebugSessionManager, connection: DebugSessionConnection, terminalServer: TerminalService, editorManager: EditorManager, breakpoints: BreakpointManager, labelProvider: LabelProvider, messages: MessageClient, fileService: FileService, debugContributionProvider: ContributionProvider<DebugContribution>, workspaceService: WorkspaceService, debugPreferences: DebugPreferences, commandService: CommandService, 
    /**
     * Number of millis after a `stop` request times out. It's 5 seconds by default.
     */
    stopTimeout?: number);
    get onDispose(): Event<void>;
    get configuration(): DebugConfiguration;
    protected _capabilities: DebugProtocol.Capabilities;
    get capabilities(): DebugProtocol.Capabilities;
    get autoExpandLazyVariables(): boolean;
    protected readonly sources: Map<string, DebugSource>;
    getSource(raw: DebugProtocol.Source): DebugSource;
    getSourceForUri(uri: URI): DebugSource | undefined;
    toSource(uri: URI): Promise<DebugSource>;
    toDebugSource(uri: URI): Promise<DebugProtocol.Source>;
    protected _threads: Map<number, DebugThread>;
    get threads(): IterableIterator<DebugThread>;
    get threadCount(): number;
    getThreads(filter: (thread: DebugThread) => boolean): IterableIterator<DebugThread>;
    get runningThreads(): IterableIterator<DebugThread>;
    get stoppedThreads(): IterableIterator<DebugThread>;
    pauseAll(): Promise<void>;
    continueAll(): Promise<void>;
    get currentFrame(): DebugStackFrame | undefined;
    protected _currentThread: DebugThread | undefined;
    protected readonly toDisposeOnCurrentThread: DisposableCollection;
    get currentThread(): DebugThread | undefined;
    set currentThread(thread: DebugThread | undefined);
    get state(): DebugState;
    getScopes(): Promise<DebugScope[]>;
    showMessage(messageType: MessageType, message: string): void;
    start(): Promise<void>;
    protected initialize(): Promise<void>;
    protected launchOrAttach(): Promise<void>;
    /**
     * The `send('initialize')` request could resolve later than `on('initialized')` emits the event.
     * Hence, the `configure` would use the empty object `capabilities`.
     * Using the empty `capabilities` could result in missing exception breakpoint filters, as
     * always `capabilities.exceptionBreakpointFilters` is falsy. This deferred promise works
     * around this timing issue. https://github.com/eclipse-theia/theia/issues/11886
     */
    protected didReceiveCapabilities: Deferred<void>;
    protected initialized: boolean;
    protected configure(): Promise<void>;
    canTerminate(): boolean;
    canRestart(): boolean;
    restart(): Promise<void>;
    stop(isRestart: boolean, callback: () => void): Promise<void>;
    /**
     * Invoked when sending the `terminate` request to the debugger is rejected or timed out.
     */
    protected handleTerminateError(err: unknown): void;
    /**
     * Invoked when sending the `disconnect` request to the debugger is rejected or timed out.
     */
    protected handleDisconnectError(err: unknown): void;
    disconnect(isRestart: boolean, callback: () => void): Promise<void>;
    completions(text: string, column: number, line: number): Promise<DebugProtocol.CompletionItem[]>;
    evaluate(expression: string, context?: string): Promise<DebugProtocol.EvaluateResponse['body']>;
    sendRequest<K extends keyof DebugRequestTypes>(command: K, args: DebugRequestTypes[K][0], timeout?: number): Promise<DebugRequestTypes[K][1]>;
    sendCustomRequest<T extends DebugProtocol.Response>(command: string, args?: any): Promise<T>;
    on<K extends keyof DebugEventTypes>(kind: K, listener: (e: DebugEventTypes[K]) => any): Disposable;
    waitFor<K extends keyof DebugEventTypes>(kind: K, ms: number): Promise<void>;
    get onDidCustomEvent(): Event<DebugProtocol.Event>;
    protected runInTerminal({ arguments: { title, cwd, args, env } }: DebugProtocol.RunInTerminalRequest): Promise<DebugProtocol.RunInTerminalResponse['body']>;
    protected doCreateTerminal(options: TerminalWidgetOptions): Promise<TerminalWidget>;
    protected clearThreads(): void;
    protected clearThread(threadId: number): void;
    protected readonly scheduleUpdateThreads: () => Promise<void>;
    protected pendingThreads: Promise<void>;
    updateThreads(stoppedDetails: StoppedDetails | undefined): Promise<void>;
    protected doUpdateThreads(threads: DebugProtocol.Thread[], stoppedDetails?: StoppedDetails): void;
    protected updateCurrentThread(stoppedDetails?: StoppedDetails): void;
    protected updateFrames(): Promise<void>;
    protected updateCapabilities(capabilities: DebugProtocol.Capabilities): void;
    protected updatingBreakpoints: boolean;
    protected updateBreakpoint(body: DebugProtocol.BreakpointEvent['body']): void;
    protected findBreakpoint(match: (breakpoint: DebugBreakpoint) => boolean): DebugBreakpoint | undefined;
    protected updateBreakpoints(options: {
        uri?: URI;
        sourceModified: boolean;
    }): Promise<void>;
    protected sendExceptionBreakpoints(): Promise<void>;
    protected sendFunctionBreakpoints(affectedUri: URI): Promise<void>;
    protected sendSourceBreakpoints(affectedUri: URI, sourceModified?: boolean): Promise<void>;
    protected sendInstructionBreakpoints(): Promise<void>;
    protected sendDataBreakpoints(): Promise<void>;
    protected getAffectedUris(uri?: URI): IterableIterator<URI>;
    get label(): string;
    get visible(): boolean;
    render(): React.ReactNode;
    getElements(): IterableIterator<DebugThread | DebugSession>;
    protected getSingleChildSession(): DebugSession | undefined;
    protected handleContinued({ body: { allThreadsContinued, threadId } }: DebugProtocol.ContinuedEvent): Promise<void>;
    protected handleStopped({ body }: DebugProtocol.StoppedEvent): Promise<void>;
    protected handleThread({ body: { reason, threadId } }: DebugProtocol.ThreadEvent): Promise<void>;
    protected registerDebugContributions(configType: string, connection: DebugSessionConnection): void;
    /**
     * Returns the top-most parent session that is responsible for the console. If this session uses a {@link DebugConsoleMode.Separate separate console}
     * or does not have any parent session, undefined is returned.
     */
    findConsoleParent(): DebugSession | undefined;
}
//# sourceMappingURL=debug-session.d.ts.map