@codingame/monaco-vscode-api 2.2.1 → 3.0.0

package/vscode/src/vs/editor/editor.api.d.ts

@@ -3454,6 +3454,7 @@ declare namespace editor {
 		 */
 		suggest?: ISuggestOptions;
 		inlineSuggest?: IInlineSuggestOptions;
+		experimentalInlineEdit?: IInlineEditOptions;
 		/**
 		 * Smart select options.
 		 */
@@ -4507,6 +4508,23 @@ declare namespace editor {
 		fontFamily?: string | 'default';
 	}
 
+	export interface IInlineEditOptions {
+		/**
+		 * Enable or disable the rendering of automatic inline edit.
+		*/
+		enabled?: boolean;
+		showToolbar?: 'always' | 'onHover' | 'never';
+		/**
+		 * Font family for inline suggestions.
+		 */
+		fontFamily?: string | 'default';
+		/**
+		 * Does not clear active inline suggestions when the editor loses focus.
+		 */
+		keepOnBlur?: boolean;
+		backgroundColoring?: boolean;
+	}
+
 	export interface IBracketPairColorizationOptions {
 		/**
 		 * Enable or disable bracket pair colorization.
@@ -4842,91 +4860,92 @@ declare namespace editor {
 		hover = 60,
 		inDiffEditor = 61,
 		inlineSuggest = 62,
-		letterSpacing = 63,
-		lightbulb = 64,
-		lineDecorationsWidth = 65,
-		lineHeight = 66,
-		lineNumbers = 67,
-		lineNumbersMinChars = 68,
-		linkedEditing = 69,
-		links = 70,
-		matchBrackets = 71,
-		minimap = 72,
-		mouseStyle = 73,
-		mouseWheelScrollSensitivity = 74,
-		mouseWheelZoom = 75,
-		multiCursorMergeOverlapping = 76,
-		multiCursorModifier = 77,
-		multiCursorPaste = 78,
-		multiCursorLimit = 79,
-		occurrencesHighlight = 80,
-		overviewRulerBorder = 81,
-		overviewRulerLanes = 82,
-		padding = 83,
-		pasteAs = 84,
-		parameterHints = 85,
-		peekWidgetDefaultFocus = 86,
-		definitionLinkOpensInPeek = 87,
-		quickSuggestions = 88,
-		quickSuggestionsDelay = 89,
-		readOnly = 90,
-		readOnlyMessage = 91,
-		renameOnType = 92,
-		renderControlCharacters = 93,
-		renderFinalNewline = 94,
-		renderLineHighlight = 95,
-		renderLineHighlightOnlyWhenFocus = 96,
-		renderValidationDecorations = 97,
-		renderWhitespace = 98,
-		revealHorizontalRightPadding = 99,
-		roundedSelection = 100,
-		rulers = 101,
-		scrollbar = 102,
-		scrollBeyondLastColumn = 103,
-		scrollBeyondLastLine = 104,
-		scrollPredominantAxis = 105,
-		selectionClipboard = 106,
-		selectionHighlight = 107,
-		selectOnLineNumbers = 108,
-		showFoldingControls = 109,
-		showUnused = 110,
-		snippetSuggestions = 111,
-		smartSelect = 112,
-		smoothScrolling = 113,
-		stickyScroll = 114,
-		stickyTabStops = 115,
-		stopRenderingLineAfter = 116,
-		suggest = 117,
-		suggestFontSize = 118,
-		suggestLineHeight = 119,
-		suggestOnTriggerCharacters = 120,
-		suggestSelection = 121,
-		tabCompletion = 122,
-		tabIndex = 123,
-		unicodeHighlighting = 124,
-		unusualLineTerminators = 125,
-		useShadowDOM = 126,
-		useTabStops = 127,
-		wordBreak = 128,
-		wordSeparators = 129,
-		wordWrap = 130,
-		wordWrapBreakAfterCharacters = 131,
-		wordWrapBreakBeforeCharacters = 132,
-		wordWrapColumn = 133,
-		wordWrapOverride1 = 134,
-		wordWrapOverride2 = 135,
-		wrappingIndent = 136,
-		wrappingStrategy = 137,
-		showDeprecated = 138,
-		inlayHints = 139,
-		editorClassName = 140,
-		pixelRatio = 141,
-		tabFocusMode = 142,
-		layoutInfo = 143,
-		wrappingInfo = 144,
-		defaultColorDecorators = 145,
-		colorDecoratorsActivatedOn = 146,
-		inlineCompletionsAccessibilityVerbose = 147
+		inlineEdit = 63,
+		letterSpacing = 64,
+		lightbulb = 65,
+		lineDecorationsWidth = 66,
+		lineHeight = 67,
+		lineNumbers = 68,
+		lineNumbersMinChars = 69,
+		linkedEditing = 70,
+		links = 71,
+		matchBrackets = 72,
+		minimap = 73,
+		mouseStyle = 74,
+		mouseWheelScrollSensitivity = 75,
+		mouseWheelZoom = 76,
+		multiCursorMergeOverlapping = 77,
+		multiCursorModifier = 78,
+		multiCursorPaste = 79,
+		multiCursorLimit = 80,
+		occurrencesHighlight = 81,
+		overviewRulerBorder = 82,
+		overviewRulerLanes = 83,
+		padding = 84,
+		pasteAs = 85,
+		parameterHints = 86,
+		peekWidgetDefaultFocus = 87,
+		definitionLinkOpensInPeek = 88,
+		quickSuggestions = 89,
+		quickSuggestionsDelay = 90,
+		readOnly = 91,
+		readOnlyMessage = 92,
+		renameOnType = 93,
+		renderControlCharacters = 94,
+		renderFinalNewline = 95,
+		renderLineHighlight = 96,
+		renderLineHighlightOnlyWhenFocus = 97,
+		renderValidationDecorations = 98,
+		renderWhitespace = 99,
+		revealHorizontalRightPadding = 100,
+		roundedSelection = 101,
+		rulers = 102,
+		scrollbar = 103,
+		scrollBeyondLastColumn = 104,
+		scrollBeyondLastLine = 105,
+		scrollPredominantAxis = 106,
+		selectionClipboard = 107,
+		selectionHighlight = 108,
+		selectOnLineNumbers = 109,
+		showFoldingControls = 110,
+		showUnused = 111,
+		snippetSuggestions = 112,
+		smartSelect = 113,
+		smoothScrolling = 114,
+		stickyScroll = 115,
+		stickyTabStops = 116,
+		stopRenderingLineAfter = 117,
+		suggest = 118,
+		suggestFontSize = 119,
+		suggestLineHeight = 120,
+		suggestOnTriggerCharacters = 121,
+		suggestSelection = 122,
+		tabCompletion = 123,
+		tabIndex = 124,
+		unicodeHighlighting = 125,
+		unusualLineTerminators = 126,
+		useShadowDOM = 127,
+		useTabStops = 128,
+		wordBreak = 129,
+		wordSeparators = 130,
+		wordWrap = 131,
+		wordWrapBreakAfterCharacters = 132,
+		wordWrapBreakBeforeCharacters = 133,
+		wordWrapColumn = 134,
+		wordWrapOverride1 = 135,
+		wordWrapOverride2 = 136,
+		wrappingIndent = 137,
+		wrappingStrategy = 138,
+		showDeprecated = 139,
+		inlayHints = 140,
+		editorClassName = 141,
+		pixelRatio = 142,
+		tabFocusMode = 143,
+		layoutInfo = 144,
+		wrappingInfo = 145,
+		defaultColorDecorators = 146,
+		colorDecoratorsActivatedOn = 147,
+		inlineCompletionsAccessibilityVerbose = 148
 	}
 
 	export const EditorOptions: {
@@ -5051,6 +5070,7 @@ declare namespace editor {
 		stopRenderingLineAfter: IEditorOption<EditorOption.stopRenderingLineAfter, number>;
 		suggest: IEditorOption<EditorOption.suggest, Readonly<Required<ISuggestOptions>>>;
 		inlineSuggest: IEditorOption<EditorOption.inlineSuggest, Readonly<Required<IInlineSuggestOptions>>>;
+		inlineEdit: IEditorOption<EditorOption.inlineEdit, Readonly<Required<IInlineEditOptions>>>;
 		inlineCompletionsAccessibilityVerbose: IEditorOption<EditorOption.inlineCompletionsAccessibilityVerbose, boolean>;
 		suggestFontSize: IEditorOption<EditorOption.suggestFontSize, number>;
 		suggestLineHeight: IEditorOption<EditorOption.suggestLineHeight, number>;
@@ -6330,6 +6350,11 @@ declare namespace languages {
 	 */
 	export function registerRenameProvider(languageSelector: LanguageSelector, provider: RenameProvider): IDisposable;
 
+	/**
+	 * Register a new symbol-name provider (e.g., when a symbol is being renamed, show new possible symbol-names)
+	 */
+	export function registerNewSymbolNameProvider(languageSelector: LanguageSelector, provider: NewSymbolNamesProvider): IDisposable;
+
 	/**
 	 * Register a signature help provider (used by e.g. parameter hints).
 	 */
@@ -6448,6 +6473,8 @@ declare namespace languages {
 	 */
 	export function registerInlineCompletionsProvider(languageSelector: LanguageSelector, provider: InlineCompletionsProvider): IDisposable;
 
+	export function registerInlineEditProvider(languageSelector: LanguageSelector, provider: InlineEditProvider): IDisposable;
+
 	/**
 	 * Register an inlay hints provider.
 	 */
@@ -7765,6 +7792,19 @@ declare namespace languages {
 		resolveRenameLocation?(model: editor.ITextModel, position: Position, token: CancellationToken): ProviderResult<RenameLocation & Rejection>;
 	}
 
+	export enum NewSymbolNameTag {
+		AIGenerated = 1
+	}
+
+	export interface NewSymbolName {
+		readonly newSymbolName: string;
+		readonly tags?: readonly NewSymbolNameTag[];
+	}
+
+	export interface NewSymbolNamesProvider {
+		provideNewSymbolNames(model: editor.ITextModel, range: IRange, token: CancellationToken): ProviderResult<NewSymbolName[]>;
+	}
+
 	export interface Command {
 		id: string;
 		title: string;
@@ -7894,6 +7934,27 @@ declare namespace languages {
 		provideMappedEdits(document: editor.ITextModel, codeBlocks: string[], context: MappedEditsContext, token: CancellationToken): Promise<WorkspaceEdit | null>;
 	}
 
+	export interface IInlineEdit {
+		text: string;
+		range: IRange;
+		accepted?: Command;
+		rejected?: Command;
+	}
+
+	export interface IInlineEditContext {
+		triggerKind: InlineEditTriggerKind;
+	}
+
+	export enum InlineEditTriggerKind {
+		Invoke = 0,
+		Automatic = 1
+	}
+
+	export interface InlineEditProvider<T extends IInlineEdit = IInlineEdit> {
+		provideInlineEdit(model: editor.ITextModel, context: IInlineEditContext, token: CancellationToken): ProviderResult<T>;
+		freeInlineEdit(edit: T): void;
+	}
+
 	export interface ILanguageExtensionPoint {
 		id: string;
 		extensions?: string[];

package/vscode/src/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js

@@ -15,7 +15,7 @@ class IPadShowKeyboard extends Disposable {
         }
     }
     update() {
-        const shouldHaveWidget = (!this.editor.getOption(90 ));
+        const shouldHaveWidget = (!this.editor.getOption(91 ));
         if (!this.widget && shouldHaveWidget) {
             this.widget = ( new ShowKeyboardWidget(this.editor));
         }

package/vscode/src/vs/editor/standalone/browser/quickInput/standaloneQuickInputService.js

@@ -11,10 +11,9 @@ import { ICodeEditorService } from '../../../browser/services/codeEditorService.
 import { QuickInputService } from '../../../../platform/quickinput/browser/quickInputService.js';
 import { createSingleCallFunction } from '../../../../base/common/functional.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IHoverService } from '../../../../platform/hover/browser/hover.js';
 let EditorScopedQuickInputService = class EditorScopedQuickInputService extends QuickInputService {
-    constructor(editor, instantiationService, contextKeyService, themeService, codeEditorService, configurationService, hoverService) {
-        super(instantiationService, contextKeyService, themeService, ( new EditorScopedLayoutService(editor.getContainerDomNode(), codeEditorService)), configurationService, hoverService);
+    constructor(editor, instantiationService, contextKeyService, themeService, codeEditorService, configurationService) {
+        super(instantiationService, contextKeyService, themeService, ( new EditorScopedLayoutService(editor.getContainerDomNode(), codeEditorService)), configurationService);
         this.host = undefined;
         const contribution = QuickInputEditorContribution.get(editor);
         if (contribution) {
@@ -54,8 +53,7 @@ EditorScopedQuickInputService = ( __decorate([
     ( __param(2, IContextKeyService)),
     ( __param(3, IThemeService)),
     ( __param(4, ICodeEditorService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IHoverService))
+    ( __param(5, IConfigurationService))
 ], EditorScopedQuickInputService));
 let StandaloneQuickInputService = class StandaloneQuickInputService {
     get activeService() {

package/vscode/src/vs/editor/standalone/browser/standaloneCodeEditor.js

@@ -26,8 +26,10 @@ import { PLAINTEXT_LANGUAGE_ID } from '../../common/languages/modesRegistry.js';
 import { ILanguageConfigurationService } from '../../common/languages/languageConfigurationRegistry.js';
 import { ILanguageFeaturesService } from '../../common/services/languageFeatures.js';
 import { DiffEditorWidget } from '../../browser/widget/diffEditor/diffEditorWidget.js';
-import { IAudioCueService } from '../../../platform/audioCues/browser/audioCueService.js';
+import { IAccessibilitySignalService } from '../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { mainWindow } from '../../../base/browser/window.js';
+import { setHoverDelegateFactory } from '../../../base/browser/ui/hover/hoverDelegate.js';
+import { WorkbenchHoverDelegate } from '../../../platform/hover/browser/hover.js';
 let LAST_GENERATED_COMMAND_ID = 0;
 let ariaDomNodeCreated = false;
 function createAriaDomNode(parent) {
@@ -44,7 +46,7 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
         const options = { ..._options };
         options.ariaLabel = options.ariaLabel || StandaloneCodeEditorNLS.editorViewAccessibleLabel;
         options.ariaLabel = options.ariaLabel + ';' + (StandaloneCodeEditorNLS.accessibilityHelpMessage);
-        super(domElement, options, {}, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
+        super(domElement, options, { isStandaloneEditor: true }, instantiationService, codeEditorService, commandService, contextKeyService, themeService, notificationService, accessibilityService, languageConfigurationService, languageFeaturesService);
         if (keybindingService instanceof StandaloneKeybindingService) {
             this._standaloneKeybindingService = keybindingService;
         }
@@ -52,6 +54,7 @@ let StandaloneCodeEditor = class StandaloneCodeEditor extends CodeEditorWidget {
             this._standaloneKeybindingService = null;
         }
         createAriaDomNode(options.ariaContainerElement);
+        setHoverDelegateFactory((placement, enableInstantHover) => instantiationService.createInstance(WorkbenchHoverDelegate, placement, enableInstantHover, {}));
     }
     addCommand(keybinding, handler, context) {
         if (!this._standaloneKeybindingService) {
@@ -148,10 +151,7 @@ StandaloneCodeEditor = ( __decorate([
 ], StandaloneCodeEditor));
 let StandaloneEditor = class StandaloneEditor extends StandaloneCodeEditor {
     constructor(domElement, _options, instantiationService, codeEditorService, commandService, contextKeyService, keybindingService, themeService, notificationService, configurationService, accessibilityService, modelService, languageService, languageConfigurationService, languageFeaturesService) {
-        const options = {
-            extraEditorClassName: 'standalone-monaco-editor',
-            ..._options
-        };
+        const options = { ..._options };
         updateConfigurationService(configurationService, options, false);
         const themeDomRegistration = themeService.registerEditorContainer(domElement);
         if (typeof options.theme === 'string') {
@@ -222,7 +222,7 @@ StandaloneEditor = ( __decorate([
     ( __param(14, ILanguageFeaturesService))
 ], StandaloneEditor));
 let StandaloneDiffEditor2 = class StandaloneDiffEditor2 extends DiffEditorWidget {
-    constructor(domElement, _options, instantiationService, contextKeyService, codeEditorService, themeService, notificationService, configurationService, contextMenuService, editorProgressService, clipboardService, audioCueService) {
+    constructor(domElement, _options, instantiationService, contextKeyService, codeEditorService, themeService, notificationService, configurationService, contextMenuService, editorProgressService, clipboardService, accessibilitySignalService) {
         const options = { ..._options };
         updateConfigurationService(configurationService, options, true);
         const themeDomRegistration = themeService.registerEditorContainer(domElement);
@@ -232,7 +232,7 @@ let StandaloneDiffEditor2 = class StandaloneDiffEditor2 extends DiffEditorWidget
         if (typeof options.autoDetectHighContrast !== 'undefined') {
             themeService.setAutoDetectHighContrast(Boolean(options.autoDetectHighContrast));
         }
-        super(domElement, options, {}, contextKeyService, instantiationService, codeEditorService, audioCueService, editorProgressService);
+        super(domElement, options, { isStandaloneEditor: true }, contextKeyService, instantiationService, codeEditorService, accessibilitySignalService, editorProgressService);
         this._configurationService = configurationService;
         this._standaloneThemeService = themeService;
         this._register(themeDomRegistration);
@@ -279,7 +279,7 @@ StandaloneDiffEditor2 = ( __decorate([
     ( __param(8, IContextMenuService)),
     ( __param(9, IEditorProgressService)),
     ( __param(10, IClipboardService)),
-    ( __param(11, IAudioCueService))
+    ( __param(11, IAccessibilitySignalService))
 ], StandaloneDiffEditor2));
 function createTextModel(modelService, languageService, value, languageId, uri) {
     value = value || '';

package/vscode/src/vs/editor/standalone/browser/standaloneServices.js

@@ -79,7 +79,7 @@ import { IOpenerService } from '../../../platform/opener/common/opener.js';
 import { IQuickInputService } from '../../../platform/quickinput/common/quickInput.js';
 import { InMemoryStorageService, IStorageService } from '../../../platform/storage/common/storage.js';
 import { DefaultConfiguration as DefaultConfiguration$1 } from '../../../platform/configuration/common/configurations.js';
-import { IAudioCueService } from '../../../platform/audioCues/browser/audioCueService.js';
+import { IAccessibilitySignalService } from '../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
 import { LogService } from '../../../platform/log/common/logService.js';
 import { IEnvironmentService } from '../../../platform/environment/common/environment.js';
 import { mainWindow } from '../../../base/browser/window.js';
@@ -857,26 +857,26 @@ StandaloneContextMenuService = ( __decorate([
     ( __param(4, IMenuService)),
     ( __param(5, IContextKeyService))
 ], StandaloneContextMenuService));
-class StandaloneAudioService {
-    async playAudioCue(cue, options) {
+class StandaloneAccessbilitySignalService {
+    async playSignal(cue, options) {
     }
-    async playAudioCues(cues) {
+    async playAccessibilitySignals(cues) {
     }
-    isCueEnabled(cue) {
+    isSoundEnabled(cue) {
         return false;
     }
-    isAlertEnabled(cue) {
+    isAnnouncementEnabled(cue) {
         return false;
     }
-    onEnabledChanged(cue) {
+    onSoundEnabledChanged(cue) {
         return Event.None;
     }
-    onAlertEnabledChanged(cue) {
+    onAnnouncementEnabledChanged(cue) {
         return Event.None;
     }
     async playSound(cue, allowManyInParallel) {
     }
-    playAudioCueLoop(cue) {
+    playSignalLoop(cue) {
         return toDisposable(() => { });
     }
 }
@@ -913,7 +913,7 @@ registerSingleton(IOpenerService, OpenerService, 0 );
 registerSingleton(IClipboardService, BrowserClipboardService, 0 );
 registerSingleton(IContextMenuService, StandaloneContextMenuService, 0 );
 registerSingleton(IMenuService, MenuService, 0 );
-registerSingleton(IAudioCueService, StandaloneAudioService, 0 );
+registerSingleton(IAccessibilitySignalService, StandaloneAccessbilitySignalService, 0 );
 var StandaloneServices;
 ( (function(StandaloneServices) {
     const serviceCollection = ( new ServiceCollection());

package/vscode/src/vs/platform/accessibilitySignal/browser/accessibilitySignalService.d.ts

@@ -0,0 +1,99 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { IDisposable } from '../../../base/common/lifecycle.js';
+import { Event } from '../../../base/common/event.js';
+
+declare const IAccessibilitySignalService: ServiceIdentifier<IAccessibilitySignalService>;
+interface IAccessibilitySignalService {
+    readonly _serviceBrand: undefined;
+    playSignal(cue: AccessibilitySignal, options?: IAccessbilitySignalOptions): Promise<void>;
+    playAccessibilitySignals(cues: (AccessibilitySignal | {
+        cue: AccessibilitySignal;
+        source: string;
+    })[]): Promise<void>;
+    isSoundEnabled(cue: AccessibilitySignal): boolean;
+    isAnnouncementEnabled(cue: AccessibilitySignal): boolean;
+    onSoundEnabledChanged(cue: AccessibilitySignal): Event<void>;
+    onAnnouncementEnabledChanged(cue: AccessibilitySignal): Event<void>;
+    playSound(cue: Sound, allowManyInParallel?: boolean): Promise<void>;
+    playSignalLoop(cue: AccessibilitySignal, milliseconds: number): IDisposable;
+}
+interface IAccessbilitySignalOptions {
+    allowManyInParallel?: boolean;
+    source?: string;
+    /**
+     * For actions like save or format, depending on the
+     * configured value, we will only
+     * play the sound if the user triggered the action.
+     */
+    userGesture?: boolean;
+}
+/**
+ * Corresponds to the audio files in ./media.
+*/
+declare class Sound {
+    readonly fileName: string;
+    private static register;
+    static readonly error: Sound;
+    static readonly warning: Sound;
+    static readonly foldedArea: Sound;
+    static readonly break: Sound;
+    static readonly quickFixes: Sound;
+    static readonly taskCompleted: Sound;
+    static readonly taskFailed: Sound;
+    static readonly terminalBell: Sound;
+    static readonly diffLineInserted: Sound;
+    static readonly diffLineDeleted: Sound;
+    static readonly diffLineModified: Sound;
+    static readonly chatRequestSent: Sound;
+    static readonly chatResponsePending: Sound;
+    static readonly chatResponseReceived1: Sound;
+    static readonly chatResponseReceived2: Sound;
+    static readonly chatResponseReceived3: Sound;
+    static readonly chatResponseReceived4: Sound;
+    static readonly clear: Sound;
+    static readonly save: Sound;
+    static readonly format: Sound;
+    private constructor();
+}
+declare class SoundSource {
+    readonly randomOneOf: Sound[];
+    constructor(randomOneOf: Sound[]);
+    getSound(deterministic?: boolean): Sound;
+}
+declare class AccessibilitySignal {
+    readonly sound: SoundSource;
+    readonly name: string;
+    readonly legacySoundSettingsKey: string;
+    readonly settingsKey: string;
+    readonly legacyAnnouncementSettingsKey?: string | undefined;
+    readonly announcementMessage?: string | undefined;
+    private static _signals;
+    private static register;
+    static get allAccessibilitySignals(): AccessibilitySignal[];
+    static readonly error: AccessibilitySignal;
+    static readonly warning: AccessibilitySignal;
+    static readonly foldedArea: AccessibilitySignal;
+    static readonly break: AccessibilitySignal;
+    static readonly inlineSuggestion: AccessibilitySignal;
+    static readonly terminalQuickFix: AccessibilitySignal;
+    static readonly onDebugBreak: AccessibilitySignal;
+    static readonly noInlayHints: AccessibilitySignal;
+    static readonly taskCompleted: AccessibilitySignal;
+    static readonly taskFailed: AccessibilitySignal;
+    static readonly terminalCommandFailed: AccessibilitySignal;
+    static readonly terminalBell: AccessibilitySignal;
+    static readonly notebookCellCompleted: AccessibilitySignal;
+    static readonly notebookCellFailed: AccessibilitySignal;
+    static readonly diffLineInserted: AccessibilitySignal;
+    static readonly diffLineDeleted: AccessibilitySignal;
+    static readonly diffLineModified: AccessibilitySignal;
+    static readonly chatRequestSent: AccessibilitySignal;
+    static readonly chatResponseReceived: AccessibilitySignal;
+    static readonly chatResponsePending: AccessibilitySignal;
+    static readonly clear: AccessibilitySignal;
+    static readonly save: AccessibilitySignal;
+    static readonly format: AccessibilitySignal;
+    private constructor();
+}
+
+export { AccessibilitySignal, type IAccessbilitySignalOptions, IAccessibilitySignalService, Sound, SoundSource };