@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/languageFeatures.d.ts

@@ -1,26 +1,237 @@
-import { S as ServiceIdentifier, I as IInstantiationService } from './instantiation.js';
-import { E as Event, C as CancellationToken, a as IDisposable, b as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { S as ServiceIdentifier, a as ServicesAccessor, I as IInstantiationService } from './instantiation.js';
+import { E as Event, a as IDisposable, C as CancellationToken, c as Emitter, d as IWaitUntil, D as Disposable } from './event.js';
+import { I as IJSONSchema } from './jsonSchema.js';
 import { c as ITextModel, P as Position, R as Range, S as Selection, h as IRange, E as EndOfLineSequence, g as IPosition, i as IMarkdownString, j as ISingleEditOperation, k as EditorAutoIndentStrategy, I as IEditorOptions, l as IEditorModel, m as IDimension, n as ITextEditorModel, o as ITextSnapshot, p as ITextBufferFactory, q as IDiffEditor, r as IBaseTextResourceEditorInput, s as IBaseUntypedEditorInput, t as IResourceEditorInput, u as ITextResourceEditorInput } from './editorBrowser.js';
+import { S as Severity$1 } from './severity.js';
 import { U as URI } from './uri.js';
 import { V as VSBuffer, m as VSBufferReadable, n as VSBufferReadableStream, o as IFileStatWithMetadata, p as FileOperation, q as ReadableStream, r as IReadFileStreamOptions, s as IWriteFileOptions, t as IBaseFileStatWithMetadata, u as IFileReadLimits, v as IRelativePattern } from './files.js';
-import { f as IProgress, g as IProgressStep, c as IComposite, h as ICompositeControl } from './colorRegistry.js';
+import { b as IProgress, c as IProgressStep, I as IComposite, d as ICompositeControl } from './composite.js';
 import { a as IContextKeyService } from './contextkey.js';
 import { T as ThemeIcon } from './themables.js';
-import { S as Severity, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { E as ExtensionIdentifier } from './extensions.d2.ts';
+
+type TypeConstraint = string | Function;
+
+interface ICommandEvent {
+    commandId: string;
+    args: any[];
+}
+
+declare const ICommandService: ServiceIdentifier<ICommandService>;
+interface ICommandService {
+    readonly _serviceBrand: undefined;
+    onWillExecuteCommand: Event<ICommandEvent>;
+    onDidExecuteCommand: Event<ICommandEvent>;
+    executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T | undefined>;
+}
+type ICommandsMap = Map<string, ICommand>;
+interface ICommandHandler {
+    (accessor: ServicesAccessor, ...args: any[]): void;
+}
+interface ICommand {
+    id: string;
+    handler: ICommandHandler;
+    description?: ICommandHandlerDescription | null;
+}
+interface ICommandHandlerDescription {
+    readonly description: string;
+    readonly args: ReadonlyArray<{
+        readonly name: string;
+        readonly isOptional?: boolean;
+        readonly description?: string;
+        readonly constraint?: TypeConstraint;
+        readonly schema?: IJSONSchema;
+    }>;
+    readonly returns?: string;
+}
+interface ICommandRegistry {
+    onDidRegisterCommand: Event<string>;
+    registerCommand(id: string, command: ICommandHandler): IDisposable;
+    registerCommand(command: ICommand): IDisposable;
+    registerCommandAlias(oldId: string, newId: string): IDisposable;
+    getCommand(id: string): ICommand | undefined;
+    getCommands(): ICommandsMap;
+}
+declare const CommandsRegistry: ICommandRegistry;
+
+declare class RGBA {
+    _rgbaBrand: void;
+    /**
+     * Red: integer in [0-255]
+     */
+    readonly r: number;
+    /**
+     * Green: integer in [0-255]
+     */
+    readonly g: number;
+    /**
+     * Blue: integer in [0-255]
+     */
+    readonly b: number;
+    /**
+     * Alpha: float in [0-1]
+     */
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    static equals(a: RGBA, b: RGBA): boolean;
+}
+declare class HSLA {
+    _hslaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Luminosity: float in [0, 1]
+     */
+    readonly l: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, l: number, a: number);
+    static equals(a: HSLA, b: HSLA): boolean;
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+    static fromRGBA(rgba: RGBA): HSLA;
+    private static _hue2rgb;
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+    static toRGBA(hsla: HSLA): RGBA;
+}
+declare class HSVA {
+    _hsvaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Value: float in [0, 1]
+     */
+    readonly v: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, v: number, a: number);
+    static equals(a: HSVA, b: HSVA): boolean;
+    static fromRGBA(rgba: RGBA): HSVA;
+    static toRGBA(hsva: HSVA): RGBA;
+}
+declare class Color {
+    static fromHex(hex: string): Color;
+    static equals(a: Color | null, b: Color | null): boolean;
+    readonly rgba: RGBA;
+    private _hsla?;
+    get hsla(): HSLA;
+    private _hsva?;
+    get hsva(): HSVA;
+    constructor(arg: RGBA | HSLA | HSVA);
+    equals(other: Color | null): boolean;
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+    getRelativeLuminance(): number;
+    private static _relativeLuminanceForComponent;
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    getContrastRatio(another: Color): number;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+    isDarker(): boolean;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+    isLighter(): boolean;
+    isLighterThan(another: Color): boolean;
+    isDarkerThan(another: Color): boolean;
+    lighten(factor: number): Color;
+    darken(factor: number): Color;
+    transparent(factor: number): Color;
+    isTransparent(): boolean;
+    isOpaque(): boolean;
+    opposite(): Color;
+    blend(c: Color): Color;
+    makeOpaque(opaqueBackground: Color): Color;
+    flatten(...backgrounds: Color[]): Color;
+    private static _flatten;
+    private _toString?;
+    toString(): string;
+    static getLighterColor(of: Color, relative: Color, factor?: number): Color;
+    static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
+    static readonly white: Color;
+    static readonly black: Color;
+    static readonly red: Color;
+    static readonly blue: Color;
+    static readonly green: Color;
+    static readonly cyan: Color;
+    static readonly lightgrey: Color;
+    static readonly transparent: Color;
+}
+declare namespace Color {
+    namespace Format {
+        namespace CSS {
+            function formatRGB(color: Color): string;
+            function formatRGBA(color: Color): string;
+            function formatHSL(color: Color): string;
+            function formatHSLA(color: Color): string;
+            /**
+             * Formats the color as #RRGGBB
+             */
+            function formatHex(color: Color): string;
+            /**
+             * Formats the color as #RRGGBBAA
+             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
+             */
+            function formatHexA(color: Color, compact?: boolean): string;
+            /**
+             * The default format will use HEX if opaque and RGBA otherwise.
+             */
+            function format(color: Color): string;
+            /**
+             * Converts an Hex color value to a Color.
+             * returns r, g, and b are contained in the set [0, 255]
+             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
+             */
+            function parseHex(hex: string): Color | null;
+        }
+    }
+}
 
 interface IDataTransferFile {
+    readonly id: string;
     readonly name: string;
     readonly uri?: URI;
     data(): Promise<Uint8Array>;
 }
 interface IDataTransferItem {
-    readonly id: string;
     asString(): Thenable<string>;
     asFile(): IDataTransferFile | undefined;
     value: any;
 }
-declare class VSDataTransfer {
-    private readonly _entries;
+interface IReadonlyVSDataTransfer extends Iterable<readonly [string, IDataTransferItem]> {
     /**
      * Get the total number of entries in this data transfer.
      */
@@ -32,54 +243,19 @@ declare class VSDataTransfer {
      */
     has(mimeType: string): boolean;
     /**
-     * Check if this data transfer contains data matching `mimeTypeGlob`.
+     * Check if this data transfer contains data matching `pattern`.
      *
      * This allows matching for wildcards, such as `image/*`.
      *
      * Use the special `files` mime type to match any file in the data transfer.
      */
-    matches(mimeTypeGlob: string): boolean;
+    matches(pattern: string): boolean;
     /**
      * Retrieve the first entry for `mimeType`.
      *
-     * Note that if want to find all entries for a given mime type, use {@link VSDataTransfer.entries} instead.
+     * Note that if you want to find all entries for a given mime type, use {@link IReadonlyVSDataTransfer.entries} instead.
      */
     get(mimeType: string): IDataTransferItem | undefined;
-    /**
-     * Add a new entry to this data transfer.
-     *
-     * This does not replace existing entries for `mimeType`.
-     */
-    append(mimeType: string, value: IDataTransferItem): void;
-    /**
-     * Set the entry for a given mime type.
-     *
-     * This replaces all existing entries for `mimeType`.
-     */
-    replace(mimeType: string, value: IDataTransferItem): void;
-    /**
-     * Remove all entries for `mimeType`.
-     */
-    delete(mimeType: string): void;
-    /**
-     * Iterate over all `[mime, item]` pairs in this data transfer.
-     *
-     * There may be multiple entries for each mime type.
-     */
-    entries(): Iterable<[string, IDataTransferItem]>;
-    /**
-     * Iterate over all items in this data transfer.
-     *
-     * There may be multiple entries for each mime type.
-     */
-    values(): Iterable<IDataTransferItem>;
-    /**
-     * Call `f` for each item and mime in the data transfer.
-     *
-     * There may be multiple entries for each mime type.
-     */
-    forEach(f: (value: IDataTransferItem, mime: string) => void): void;
-    private toKey;
 }
 
 /**
@@ -140,8 +316,8 @@ declare enum MarkerSeverity {
 declare namespace MarkerSeverity {
     function compare(a: MarkerSeverity, b: MarkerSeverity): number;
     function toString(a: MarkerSeverity): string;
-    function fromSeverity(severity: Severity): MarkerSeverity;
-    function toSeverity(severity: MarkerSeverity): Severity;
+    function fromSeverity(severity: Severity$1): MarkerSeverity;
+    function toSeverity(severity: MarkerSeverity): Severity$1;
 }
 interface IResourceMarker {
     resource: URI;
@@ -699,8 +875,12 @@ interface CodeActionProvider {
  * @internal
  */
 interface DocumentPasteEdit {
+    readonly id: string;
+    readonly label: string;
+    readonly detail: string;
+    readonly priority: number;
     insertText: string | {
-        snippet: string;
+        readonly snippet: string;
     };
     additionalEdit?: WorkspaceEdit;
 }
@@ -708,9 +888,11 @@ interface DocumentPasteEdit {
  * @internal
  */
 interface DocumentPasteEditProvider {
-    readonly pasteMimeTypes: readonly string[];
-    prepareDocumentPaste?(model: ITextModel, ranges: readonly IRange[], dataTransfer: VSDataTransfer, token: CancellationToken): Promise<undefined | VSDataTransfer>;
-    provideDocumentPasteEdits(model: ITextModel, ranges: readonly IRange[], dataTransfer: VSDataTransfer, token: CancellationToken): Promise<DocumentPasteEdit | undefined>;
+    readonly id?: string;
+    readonly copyMimeTypes?: readonly string[];
+    readonly pasteMimeTypes?: readonly string[];
+    prepareDocumentPaste?(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<undefined | IReadonlyVSDataTransfer>;
+    provideDocumentPasteEdits?(model: ITextModel, ranges: readonly IRange[], dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): Promise<DocumentPasteEdit | undefined>;
 }
 /**
  * Represents a parameter of a callable-signature. A parameter can
@@ -1405,9 +1587,11 @@ interface DocumentRangeSemanticTokensProvider {
  * @internal
  */
 interface DocumentOnDropEdit {
+    readonly id: string;
     readonly label: string;
+    readonly priority: number;
     insertText: string | {
-        snippet: string;
+        readonly snippet: string;
     };
     additionalEdit?: WorkspaceEdit;
 }
@@ -1415,9 +1599,8 @@ interface DocumentOnDropEdit {
  * @internal
  */
 interface DocumentOnDropEditProvider {
-    readonly id: string;
     readonly dropMimeTypes?: readonly string[];
-    provideDocumentOnDropEdits(model: ITextModel, position: IPosition, dataTransfer: VSDataTransfer, token: CancellationToken): ProviderResult<DocumentOnDropEdit>;
+    provideDocumentOnDropEdits(model: ITextModel, position: IPosition, dataTransfer: IReadonlyVSDataTransfer, token: CancellationToken): ProviderResult<DocumentOnDropEdit>;
 }
 
 interface IViewLineTokens {
@@ -1992,13 +2175,392 @@ declare class ResolvedLanguageConfiguration {
     private static _handleComments;
 }
 
+interface IAction {
+    readonly id: string;
+    label: string;
+    tooltip: string;
+    class: string | undefined;
+    enabled: boolean;
+    checked?: boolean;
+    run(...args: unknown[]): unknown;
+}
+interface IActionRunner extends IDisposable {
+    readonly onDidRun: Event<IRunEvent>;
+    readonly onWillRun: Event<IRunEvent>;
+    run(action: IAction, context?: unknown): unknown;
+}
+interface IRunEvent {
+    readonly action: IAction;
+    readonly error?: Error;
+}
+declare class SubmenuAction implements IAction {
+    readonly id: string;
+    readonly label: string;
+    readonly class: string | undefined;
+    readonly tooltip: string;
+    readonly enabled: boolean;
+    readonly checked: undefined;
+    private readonly _actions;
+    get actions(): readonly IAction[];
+    constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string);
+    run(): Promise<void>;
+}
+
+type Severity = Severity$1;
+type NotificationMessage = string | Error;
+declare enum NotificationPriority {
+    /**
+     * Default priority: notification will be visible unless do not disturb mode is enabled.
+     */
+    DEFAULT = 0,
+    /**
+     * Silent priority: notification will only be visible from the notifications center.
+     */
+    SILENT = 1,
+    /**
+     * Urgent priority: notification will be visible even when do not disturb mode is enabled.
+     */
+    URGENT = 2
+}
+interface INotificationProperties {
+    /**
+     * Sticky notifications are not automatically removed after a certain timeout.
+     *
+     * Currently, only 2 kinds of notifications are sticky:
+     * - Error notifications with primary actions
+     * - Notifications that show progress
+     */
+    readonly sticky?: boolean;
+    /**
+     * Allows to override the priority of the notification based on needs.
+     */
+    readonly priority?: NotificationPriority;
+    /**
+     * Adds an action to never show the notification again. The choice will be persisted
+     * such as future requests will not cause the notification to show again.
+     */
+    readonly neverShowAgain?: INeverShowAgainOptions;
+}
+declare enum NeverShowAgainScope {
+    /**
+     * Will never show this notification on the current workspace again.
+     */
+    WORKSPACE = 0,
+    /**
+     * Will never show this notification on any workspace of the same
+     * profile again.
+     */
+    PROFILE = 1,
+    /**
+     * Will never show this notification on any workspace across all
+     * profiles again.
+     */
+    APPLICATION = 2
+}
+interface INeverShowAgainOptions {
+    /**
+     * The id is used to persist the selection of not showing the notification again.
+     */
+    readonly id: string;
+    /**
+     * By default the action will show up as primary action. Setting this to true will
+     * make it a secondary action instead.
+     */
+    readonly isSecondary?: boolean;
+    /**
+     * Whether to persist the choice in the current workspace or for all workspaces. By
+     * default it will be persisted for all workspaces across all profiles
+     * (= `NeverShowAgainScope.APPLICATION`).
+     */
+    readonly scope?: NeverShowAgainScope;
+}
+interface INotification extends INotificationProperties {
+    /**
+     * The id of the notification. If provided, will be used to compare
+     * notifications with others to decide whether a notification is
+     * duplicate or not.
+     */
+    readonly id?: string;
+    /**
+     * The severity of the notification. Either `Info`, `Warning` or `Error`.
+     */
+    readonly severity: Severity;
+    /**
+     * The message of the notification. This can either be a `string` or `Error`. Messages
+     * can optionally include links in the format: `[text](link)`
+     */
+    readonly message: NotificationMessage;
+    /**
+     * The source of the notification appears as additional information.
+     */
+    readonly source?: string | {
+        label: string;
+        id: string;
+    };
+    /**
+     * Actions to show as part of the notification. Primary actions show up as
+     * buttons as part of the message and will close the notification once clicked.
+     *
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     *
+     * **Note:** If your intent is to show a message with actions to the user, consider
+     * the `INotificationService.prompt()` method instead which are optimized for
+     * this usecase and much easier to use!
+     */
+    actions?: INotificationActions;
+    /**
+     * The initial set of progress properties for the notification. To update progress
+     * later on, access the `INotificationHandle.progress` property.
+     */
+    readonly progress?: INotificationProgressProperties;
+}
+interface INotificationActions {
+    /**
+     * Primary actions show up as buttons as part of the message and will close
+     * the notification once clicked.
+     *
+     * Pass `ActionWithMenuAction` for an action that has additional menu actions.
+     */
+    readonly primary?: readonly IAction[];
+    /**
+     * Secondary actions are meant to provide additional configuration or context
+     * for the notification and will show up less prominent. A notification does not
+     * close automatically when invoking a secondary action.
+     */
+    readonly secondary?: readonly IAction[];
+}
+interface INotificationProgressProperties {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
+    readonly infinite?: boolean;
+    /**
+     * Indicate the total amount of work.
+     */
+    readonly total?: number;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
+    readonly worked?: number;
+}
+interface INotificationProgress {
+    /**
+     * Causes the progress bar to spin infinitley.
+     */
+    infinite(): void;
+    /**
+     * Indicate the total amount of work.
+     */
+    total(value: number): void;
+    /**
+     * Indicate that a specific chunk of work is done.
+     */
+    worked(value: number): void;
+    /**
+     * Indicate that the long running operation is done.
+     */
+    done(): void;
+}
+interface INotificationHandle {
+    /**
+     * Will be fired once the notification is closed.
+     */
+    readonly onDidClose: Event<void>;
+    /**
+     * Will be fired whenever the visibility of the notification changes.
+     * A notification can either be visible as toast or inside the notification
+     * center if it is visible.
+     */
+    readonly onDidChangeVisibility: Event<boolean>;
+    /**
+     * Allows to indicate progress on the notification even after the
+     * notification is already visible.
+     */
+    readonly progress: INotificationProgress;
+    /**
+     * Allows to update the severity of the notification.
+     */
+    updateSeverity(severity: Severity): void;
+    /**
+     * Allows to update the message of the notification even after the
+     * notification is already visible.
+     */
+    updateMessage(message: NotificationMessage): void;
+    /**
+     * Allows to update the actions of the notification even after the
+     * notification is already visible.
+     */
+    updateActions(actions?: INotificationActions): void;
+    /**
+     * Hide the notification and remove it from the notification center.
+     */
+    close(): void;
+}
+interface IBasePromptChoice {
+    /**
+     * Label to show for the choice to the user.
+     */
+    readonly label: string;
+    /**
+     * Whether to keep the notification open after the choice was selected
+     * by the user. By default, will close the notification upon click.
+     */
+    readonly keepOpen?: boolean;
+    /**
+     * Triggered when the user selects the choice.
+     */
+    run: () => void;
+}
+interface IPromptChoice extends IBasePromptChoice {
+    /**
+     * Primary choices show up as buttons in the notification below the message.
+     * Secondary choices show up under the gear icon in the header of the notification.
+     */
+    readonly isSecondary?: boolean;
+}
+interface IPromptChoiceWithMenu extends IPromptChoice {
+    /**
+     * Additional choices those will be shown in the dropdown menu for this choice.
+     */
+    readonly menu: IBasePromptChoice[];
+    /**
+     * Menu is not supported on secondary choices
+     */
+    readonly isSecondary: false | undefined;
+}
+interface IPromptOptions extends INotificationProperties {
+    /**
+     * Will be called if the user closed the notification without picking
+     * any of the provided choices.
+     */
+    onCancel?: () => void;
+}
+interface IStatusMessageOptions {
+    /**
+     * An optional timeout after which the status message should show. By default
+     * the status message will show immediately.
+     */
+    readonly showAfter?: number;
+    /**
+     * An optional timeout after which the status message is to be hidden. By default
+     * the status message will not hide until another status message is displayed.
+     */
+    readonly hideAfter?: number;
+}
+declare enum NotificationsFilter {
+    /**
+     * No filter is enabled.
+     */
+    OFF = 0,
+    /**
+     * All notifications are configured as silent. See
+     * `INotificationProperties.silent` for more info.
+     */
+    SILENT = 1,
+    /**
+     * All notifications are silent except error notifications.
+    */
+    ERROR = 2
+}
+declare const INotificationService: ServiceIdentifier<INotificationService>;
+/**
+ * A service to bring up notifications and non-modal prompts.
+ *
+ * Note: use the `IDialogService` for a modal way to ask the user for input.
+ */
+interface INotificationService {
+    readonly _serviceBrand: undefined;
+    /**
+     * The DND mode can be enabled or disabled
+     * and will result in all info and warning
+     * notifications to be silent.
+     */
+    doNotDisturbMode: boolean;
+    /**
+     * Emitted when a new notification is added.
+     */
+    readonly onDidAddNotification: Event<INotification>;
+    /**
+     * Emitted when a notification is removed.
+     */
+    readonly onDidRemoveNotification: Event<INotification>;
+    /**
+     * Emitted when a do not disturb mode has changed.
+     */
+    readonly onDidChangeDoNotDisturbMode: Event<void>;
+    /**
+     * Show the provided notification to the user. The returned `INotificationHandle`
+     * can be used to control the notification afterwards.
+     *
+     * **Note:** If your intent is to show a message with actions to the user, consider
+     * the `INotificationService.prompt()` method instead which are optimized for
+     * this usecase and much easier to use!
+     *
+     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+     */
+    notify(notification: INotification): INotificationHandle;
+    /**
+     * A convenient way of reporting infos. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    info(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * A convenient way of reporting warnings. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    warn(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * A convenient way of reporting errors. Use the `INotificationService.notify`
+     * method if you need more control over the notification.
+     */
+    error(message: NotificationMessage | NotificationMessage[]): void;
+    /**
+     * Shows a prompt in the notification area with the provided choices. The prompt
+     * is non-modal. If you want to show a modal dialog instead, use `IDialogService`.
+     *
+     * @param severity the severity of the notification. Either `Info`, `Warning` or `Error`.
+     * @param message the message to show as status.
+     * @param choices options to be chosen from.
+     * @param options provides some optional configuration options.
+     *
+     * @returns a handle on the notification to e.g. hide it or update message, buttons, etc.
+     */
+    prompt(severity: Severity, message: string, choices: (IPromptChoice | IPromptChoiceWithMenu)[], options?: IPromptOptions): INotificationHandle;
+    /**
+     * Shows a status message in the status area with the provided text.
+     *
+     * @param message the message to show as status
+     * @param options provides some optional configuration options
+     *
+     * @returns a disposable to hide the status message
+     */
+    status(message: NotificationMessage, options?: IStatusMessageOptions): IDisposable;
+}
+declare class NoOpNotification implements INotificationHandle {
+    readonly progress: NoOpProgress;
+    readonly onDidClose: Event<any>;
+    readonly onDidChangeVisibility: Event<any>;
+    updateSeverity(severity: Severity): void;
+    updateMessage(message: NotificationMessage): void;
+    updateActions(actions?: INotificationActions): void;
+    close(): void;
+}
+declare class NoOpProgress implements INotificationProgress {
+    infinite(): void;
+    done(): void;
+    total(value: number): void;
+    worked(value: number): void;
+}
+
 interface IDialogArgs {
     readonly confirmArgs?: IConfirmDialogArgs;
     readonly inputArgs?: IInputDialogArgs;
     readonly promptArgs?: IPromptDialogArgs;
 }
 interface IBaseDialogOptions {
-    readonly type?: Severity | DialogType;
+    readonly type?: Severity$1 | DialogType;
     readonly title?: string;
     readonly message: string;
     readonly detail?: string;
@@ -2416,7 +2978,13 @@ declare const enum WorkingCopyCapabilities {
      * additional input when saving, e.g. an
      * associated path to save to.
      */
-    Untitled = 2
+    Untitled = 2,
+    /**
+     * The working copy will not indicate that
+     * it is dirty and unsaved content will be
+     * discarded without prompting if closed.
+     */
+    Scratchpad = 4
 }
 /**
  * Data to be associated with working copy backups. Use
@@ -2518,7 +3086,18 @@ interface IWorkingCopy extends IWorkingCopyIdentifier {
      * (unless this working copy is untitled).
      */
     readonly onDidSave: Event<IWorkingCopySaveEvent>;
+    /**
+     * Indicates that the file has unsaved changes
+     * and should confirm before closing.
+     */
     isDirty(): boolean;
+    /**
+     * Indicates that the file has unsaved changes.
+     * Used for backup tracking and accounts for
+     * working copies that are never dirty e.g.
+     * scratchpads.
+     */
+    isModified(): boolean;
     /**
      * The workbench may call this method often after it receives
      * the `onDidChangeContent` event for the working copy. The motivation
@@ -3276,6 +3855,10 @@ interface IUntitledTextEditorModelManager {
     resolve(options?: INewUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
     resolve(options?: INewUntitledTextEditorWithAssociatedResourceOptions): Promise<IUntitledTextEditorModel>;
     resolve(options?: IExistingUntitledTextEditorOptions): Promise<IUntitledTextEditorModel>;
+    /**
+     * Figures out if the given resource has an associated resource or not.
+     */
+    isUntitledWithAssociatedResource(resource: URI): boolean;
 }
 
 /**
@@ -3448,9 +4031,9 @@ interface IStoredFileWorkingCopy<M extends IStoredFileWorkingCopyModel> extends
      */
     resolve(options?: IStoredFileWorkingCopyResolveOptions): Promise<void>;
     /**
-     * Explicitly sets the working copy to be dirty.
+     * Explicitly sets the working copy to be modified.
      */
-    markDirty(): void;
+    markModified(): void;
     /**
      * Whether the stored file working copy is in the provided `state`
      * or not.
@@ -4099,6 +4682,59 @@ interface IResolvedTextFileEditorModel extends ITextFileEditorModel {
     createSnapshot(): ITextSnapshot;
 }
 
+type ColorIdentifier = string;
+declare const enum ColorTransformType {
+    Darken = 0,
+    Lighten = 1,
+    Transparent = 2,
+    Opaque = 3,
+    OneOf = 4,
+    LessProminent = 5,
+    IfDefinedThenElse = 6
+}
+type ColorTransform = {
+    op: ColorTransformType.Darken;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Lighten;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Transparent;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Opaque;
+    value: ColorValue;
+    background: ColorValue;
+} | {
+    op: ColorTransformType.OneOf;
+    values: readonly ColorValue[];
+} | {
+    op: ColorTransformType.LessProminent;
+    value: ColorValue;
+    background: ColorValue;
+    factor: number;
+    transparency: number;
+} | {
+    op: ColorTransformType.IfDefinedThenElse;
+    if: ColorIdentifier;
+    then: ColorValue;
+    else: ColorValue;
+};
+interface ColorDefaults {
+    light: ColorValue | null;
+    dark: ColorValue | null;
+    hcDark: ColorValue | null;
+    hcLight: ColorValue | null;
+}
+/**
+ * A Color Value is either a color literal, a reference to an other color or a derived color
+ */
+type ColorValue = Color | string | ColorIdentifier | ColorTransform;
+declare function registerColor(id: string, defaults: ColorDefaults | null, description: string, needsTransparency?: boolean, deprecationMessage?: string): ColorIdentifier;
+
 interface IEditorDescriptor<T extends IEditorPane> {
     /**
      * The unique type identifier of the editor. All instances
@@ -4512,7 +5148,12 @@ declare const enum EditorInputCapabilities {
      * Signals that the editor is composed of multiple editors
      * within.
      */
-    MultipleEditors = 256
+    MultipleEditors = 256,
+    /**
+     * Signals that the editor cannot be in a dirty state
+     * and may still have unsaved changes
+     */
+    Scratchpad = 512
 }
 type IUntypedEditorInput = IResourceEditorInput | ITextResourceEditorInput | IUntitledTextResourceEditorInput | IResourceDiffEditorInput | IResourceSideBySideEditorInput | IResourceMergeEditorInput;
 declare abstract class AbstractEditorInput extends Disposable {
@@ -4599,7 +5240,8 @@ interface IEditorPartConfiguration {
     scrollToSwitchTabs?: boolean;
     highlightModifiedTabs?: boolean;
     tabCloseButton?: 'left' | 'right' | 'off';
-    tabSizing?: 'fit' | 'shrink';
+    tabSizing?: 'fit' | 'shrink' | 'fixed';
+    tabSizingFixedMaxWidth?: number;
     pinnedTabSizing?: 'normal' | 'compact' | 'shrink';
     titleScrollbarSizing?: 'default' | 'large';
     focusRecentEditorAfterClose?: boolean;
@@ -4758,4 +5400,4 @@ interface ILanguageFeaturesService {
     setNotebookTypeResolver(resolver: NotebookInfoResolver | undefined): void;
 }
 
-export { IPromptBaseButton as $, IDialogArgs as A, IDialogResult as B, Command as C, DialogType as D, EditorInput as E, FoldingRangeProvider as F, GroupIdentifier as G, IDialogHandler as H, ILanguageFeaturesService as I, IConfirmDialogArgs as J, IInputDialogArgs as K, LanguageFeatureRegistry as L, IPromptDialogArgs as M, IBaseDialogOptions as N, ICheckbox as O, ICheckboxResult as P, ICustomDialogOptions as Q, ICustomDialogMarkdown as R, IConfirmation as S, TextEdit as T, IConfirmationResult as U, IInput as V, WorkspaceEdit as W, IInputResult as X, IInputElement as Y, IPrompt as Z, IPromptResult as _, ILanguageConfigurationService as a, IPromptButton as a0, IPromptCancelButton as a1, IPromptResultWithCancel as a2, IPromptWithCustomCancel as a3, IPromptWithDefaultCancel as a4, ITextFileEditorModel as b, ILanguageIdCodec as c, IEditorCloseEvent as d, IVisibleEditorPane as e, EditorsOrder as f, IEditorIdentifier as g, IEditorGroup as h, IEditorPane as i, IUntitledTextResourceEditorInput as j, IResourceDiffEditorInput as k, ITextDiffEditorPane as l, IUntypedEditorInput as m, ICloseEditorOptions as n, IFindEditorOptions as o, IRevertOptions as p, ISaveOptions as q, IGroupModelChangeEvent as r, LanguageSelector as s, IInplaceReplaceSupportResult as t, WorkspaceEditMetadata as u, IDialogService as v, IMarkerService as w, IEditorGroupsService as x, ITextFileService as y, IWorkingCopyFileService as z };
+export { INotificationHandle as $, IInplaceReplaceSupportResult as A, WorkspaceEditMetadata as B, CommandsRegistry as C, IActionRunner as D, EditorInput as E, FoldingRangeProvider as F, GroupIdentifier as G, IDialogService as H, ILanguageFeaturesService as I, IMarkerService as J, IEditorGroupsService as K, LanguageFeatureRegistry as L, ITextFileService as M, IWorkingCopyFileService as N, NotificationsFilter as O, NotificationMessage as P, NotificationPriority as Q, INotificationProperties as R, SubmenuAction as S, TextEdit as T, NeverShowAgainScope as U, INeverShowAgainOptions as V, WorkspaceEdit as W, INotification as X, INotificationActions as Y, INotificationProgress as Z, INotificationProgressProperties as _, ILanguageConfigurationService as a, IPromptChoice as a0, IPromptChoiceWithMenu as a1, IPromptOptions as a2, IStatusMessageOptions as a3, NoOpNotification as a4, NoOpProgress as a5, IDialogArgs as a6, DialogType as a7, IDialogResult as a8, IDialogHandler as a9, IConfirmDialogArgs as aa, IInputDialogArgs as ab, IPromptDialogArgs as ac, IBaseDialogOptions as ad, ICheckbox as ae, ICheckboxResult as af, ICustomDialogOptions as ag, ICustomDialogMarkdown as ah, IConfirmation as ai, IConfirmationResult as aj, IInput as ak, IInputResult as al, IInputElement as am, IPrompt as an, IPromptResult as ao, IPromptBaseButton as ap, IPromptButton as aq, IPromptCancelButton as ar, IPromptResultWithCancel as as, IPromptWithCustomCancel as at, IPromptWithDefaultCancel as au, INotificationService as b, ITextFileEditorModel as c, ILanguageIdCodec as d, IAction as e, ICommandService as f, IEditorCloseEvent as g, IVisibleEditorPane as h, EditorsOrder as i, IEditorIdentifier as j, IEditorGroup as k, IEditorPane as l, IUntitledTextResourceEditorInput as m, IResourceDiffEditorInput as n, ITextDiffEditorPane as o, IUntypedEditorInput as p, ICloseEditorOptions as q, registerColor as r, IFindEditorOptions as s, IRevertOptions as t, ISaveOptions as u, IGroupModelChangeEvent as v, ColorIdentifier as w, Color as x, LanguageSelector as y, Command as z };