import { IMarkdownString } from "../../../base/common/htmlContent.js";
import { ScrollbarVisibility } from "../../../base/common/scrollable.js";
import { FontInfo } from "./fontInfo.js";
import { AccessibilitySupport } from "../../../platform/accessibility/common/accessibility.js";
import { IConfigurationPropertySchema } from "../../../platform/configuration/common/configurationRegistry.js";
/**
 * Configuration options for auto closing quotes and brackets
 */
export type EditorAutoClosingStrategy = "always" | "languageDefined" | "beforeWhitespace" | "never";
/**
 * Configuration options for auto wrapping quotes and brackets
 */
export type EditorAutoSurroundStrategy = "languageDefined" | "quotes" | "brackets" | "never";
/**
 * Configuration options for typing over closing quotes or brackets
 */
export type EditorAutoClosingEditStrategy = "always" | "auto" | "never";
/**
 * Configuration options for auto indentation in the editor
 */
export declare enum EditorAutoIndentStrategy {
    None = 0,
    Keep = 1,
    Brackets = 2,
    Advanced = 3,
    Full = 4
}
/**
 * Configuration options for the editor.
 */
export type IEditorOptions = import("monaco-editor").editor.IEditorOptions;
/**
 * @internal
 * The width of the minimap gutter, in pixels.
 */
export declare const MINIMAP_GUTTER_WIDTH = 8;
export interface IDiffEditorBaseOptions {
    /**
     * Allow the user to resize the diff editor split view.
     * Defaults to true.
     */
    enableSplitViewResizing?: boolean;
    /**
     * The default ratio when rendering side-by-side editors.
     * Must be a number between 0 and 1, min sizes apply.
     * Defaults to 0.5
     */
    splitViewDefaultRatio?: number;
    /**
     * Render the differences in two side-by-side editors.
     * Defaults to true.
     */
    renderSideBySide?: boolean;
    /**
     * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
     * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
     */
    renderSideBySideInlineBreakpoint?: number | undefined;
    /**
     * When `renderSideBySide` is enabled, `useInlineViewWhenSpaceIsLimited` is set,
     * and the diff editor has a width less than `renderSideBySideInlineBreakpoint`, the inline view is used.
     */
    useInlineViewWhenSpaceIsLimited?: boolean;
    /**
     * If set, the diff editor is optimized for small views.
     * Defaults to `false`.
    */
    compactMode?: boolean;
    /**
     * Timeout in milliseconds after which diff computation is cancelled.
     * Defaults to 5000.
     */
    maxComputationTime?: number;
    /**
     * Maximum supported file size in MB.
     * Defaults to 50.
     */
    maxFileSize?: number;
    /**
     * Compute the diff by ignoring leading/trailing whitespace
     * Defaults to true.
     */
    ignoreTrimWhitespace?: boolean;
    /**
     * Render +/- indicators for added/deleted changes.
     * Defaults to true.
     */
    renderIndicators?: boolean;
    /**
     * Shows icons in the glyph margin to revert changes.
     * Default to true.
     */
    renderMarginRevertIcon?: boolean;
    /**
     * Indicates if the gutter menu should be rendered.
    */
    renderGutterMenu?: boolean;
    /**
     * Original model should be editable?
     * Defaults to false.
     */
    originalEditable?: boolean;
    /**
     * Should the diff editor enable code lens?
     * Defaults to false.
     */
    diffCodeLens?: boolean;
    /**
     * Is the diff editor should render overview ruler
     * Defaults to true
     */
    renderOverviewRuler?: boolean;
    /**
     * Control the wrapping of the diff editor.
     */
    diffWordWrap?: "off" | "on" | "inherit";
    /**
     * Diff Algorithm
    */
    diffAlgorithm?: "legacy" | "advanced";
    /**
     * Whether the diff editor aria label should be verbose.
     */
    accessibilityVerbose?: boolean;
    experimental?: {
        /**
         * Defaults to false.
         */
        showMoves?: boolean;
        showEmptyDecorations?: boolean;
        /**
         * Only applies when `renderSideBySide` is set to false.
        */
        useTrueInlineView?: boolean;
    };
    /**
     * Is the diff editor inside another editor
     * Defaults to false
     */
    isInEmbeddedEditor?: boolean;
    /**
     * If the diff editor should only show the difference review mode.
     */
    onlyShowAccessibleDiffViewer?: boolean;
    hideUnchangedRegions?: {
        enabled?: boolean;
        revealLineCount?: number;
        minimumLineCount?: number;
        contextLineCount?: number;
    };
}
/**
 * Configuration options for the diff editor.
 */
export interface IDiffEditorOptions extends IEditorOptions, IDiffEditorBaseOptions {
}
/**
 * @internal
 */
export type ValidDiffEditorBaseOptions = Readonly<Required<IDiffEditorBaseOptions>>;
/**
 * An event describing that the configuration of the editor has changed.
 */
export declare class ConfigurationChangedEvent {
    private readonly _values;
    /**
     * @internal
     */
    constructor(values: boolean[]);
    hasChanged(id: EditorOption): boolean;
}
/**
 * All computed editor options.
 */
export interface IComputedEditorOptions {
    get<T extends EditorOption>(id: T): FindComputedEditorOptionValueById<T>;
}
/**
 * @internal
 */
export interface IEnvironmentalOptions {
    readonly memory: ComputeOptionsMemory | null;
    readonly outerWidth: number;
    readonly outerHeight: number;
    readonly fontInfo: FontInfo;
    readonly extraEditorClassName: string;
    readonly isDominatedByLongLines: boolean;
    readonly viewLineCount: number;
    readonly lineNumbersDigitCount: number;
    readonly emptySelectionClipboard: boolean;
    readonly pixelRatio: number;
    readonly tabFocusMode: boolean;
    readonly inputMode: "insert" | "overtype";
    readonly accessibilitySupport: AccessibilitySupport;
    readonly glyphMarginDecorationLaneCount: number;
    readonly editContextSupported: boolean;
}
/**
 * @internal
 */
export declare class ComputeOptionsMemory {
    stableMinimapLayoutInput: IMinimapLayoutInput | null;
    stableFitMaxMinimapScale: number;
    stableFitRemainingWidth: number;
    constructor();
}
export interface IEditorOption<K extends EditorOption, V> {
    readonly id: K;
    readonly name: string;
    defaultValue: V;
    /**
     * @internal
     */
    readonly schema: IConfigurationPropertySchema | {
        [path: string]: IConfigurationPropertySchema;
    } | undefined;
    /**
     * @internal
     */
    validate(input: any): V;
    /**
     * @internal
     */
    compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, value: V): V;
    /**
     * Might modify `value`.
    */
    applyUpdate(value: V | undefined, update: V): ApplyUpdateResult<V>;
}
/**
 * @internal
 */
type PossibleKeyName0<V> = {
    [K in keyof IEditorOptions]: IEditorOptions[K] extends V | undefined ? K : never;
}[keyof IEditorOptions];
/**
 * @internal
 */
type PossibleKeyName<V> = NonNullable<PossibleKeyName0<V>>;
/**
 * @internal
 */
declare abstract class BaseEditorOption<K extends EditorOption, T, V> implements IEditorOption<K, V> {
    readonly id: K;
    readonly name: string;
    readonly defaultValue: V;
    readonly schema: IConfigurationPropertySchema | {
        [path: string]: IConfigurationPropertySchema;
    } | undefined;
    constructor(id: K, name: PossibleKeyName<T>, defaultValue: V, schema?: IConfigurationPropertySchema | {
        [path: string]: IConfigurationPropertySchema;
    });
    applyUpdate(value: V | undefined, update: V): ApplyUpdateResult<V>;
    abstract validate(input: any): V;
    compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, value: V): V;
}
export declare class ApplyUpdateResult<T> {
    readonly newValue: T;
    readonly didChange: boolean;
    constructor(newValue: T, didChange: boolean);
}
/**
 * @internal
 */
declare abstract class ComputedEditorOption<K extends EditorOption, V> implements IEditorOption<K, V> {
    readonly id: K;
    readonly name: "_never_";
    readonly defaultValue: V;
    readonly schema: IConfigurationPropertySchema | undefined;
    constructor(id: K);
    applyUpdate(value: V | undefined, update: V): ApplyUpdateResult<V>;
    validate(input: any): V;
    abstract compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, value: V): V;
}
/**
 * @internal
 */
export declare function boolean(value: any, defaultValue: boolean): boolean;
/**
 * @internal
 */
export declare function clampedInt<T>(value: any, defaultValue: T, minimum: number, maximum: number): number | T;
/**
 * @internal
 */
export declare function clampedFloat<T extends number>(value: any, defaultValue: T, minimum: number, maximum: number): number | T;
/**
 * @internal
 */
export declare function stringSet<T>(value: T | undefined, defaultValue: T, allowedValues: ReadonlyArray<T>, renamedValues?: Record<string, T>): T;
/**
 * Configuration options for editor comments
 */
export interface IEditorCommentsOptions {
    /**
     * Insert a space after the line comment token and inside the block comments tokens.
     * Defaults to true.
     */
    insertSpace?: boolean;
    /**
     * Ignore empty lines when inserting line comments.
     * Defaults to true.
     */
    ignoreEmptyLines?: boolean;
}
/**
 * @internal
 */
export type EditorCommentsOptions = Readonly<Required<IEditorCommentsOptions>>;
/**
 * The kind of animation in which the editor's cursor should be rendered.
 */
export declare enum TextEditorCursorBlinkingStyle {
    /**
     * Hidden
     */
    Hidden = 0,
    /**
     * Blinking
     */
    Blink = 1,
    /**
     * Blinking with smooth fading
     */
    Smooth = 2,
    /**
     * Blinking with prolonged filled state and smooth fading
     */
    Phase = 3,
    /**
     * Expand collapse animation on the y axis
     */
    Expand = 4,
    /**
     * No-Blinking
     */
    Solid = 5
}
/**
 * @internal
 */
export declare function cursorBlinkingStyleFromString(cursorBlinkingStyle: "blink" | "smooth" | "phase" | "expand" | "solid"): TextEditorCursorBlinkingStyle;
/**
 * The style in which the editor's cursor should be rendered.
 */
export declare enum TextEditorCursorStyle {
    /**
     * As a vertical line (sitting between two characters).
     */
    Line = 1,
    /**
     * As a block (sitting on top of a character).
     */
    Block = 2,
    /**
     * As a horizontal line (sitting under a character).
     */
    Underline = 3,
    /**
     * As a thin vertical line (sitting between two characters).
     */
    LineThin = 4,
    /**
     * As an outlined block (sitting on top of a character).
     */
    BlockOutline = 5,
    /**
     * As a thin horizontal line (sitting under a character).
     */
    UnderlineThin = 6
}
/**
 * @internal
 */
export declare function cursorStyleToString(cursorStyle: TextEditorCursorStyle): "line" | "block" | "underline" | "line-thin" | "block-outline" | "underline-thin";
/**
 * @internal
 */
export declare function cursorStyleFromString(cursorStyle: "line" | "block" | "underline" | "line-thin" | "block-outline" | "underline-thin"): TextEditorCursorStyle;
/**
 * Configuration options for editor find widget
 */
export interface IEditorFindOptions {
    /**
    * Controls whether the cursor should move to find matches while typing.
    */
    cursorMoveOnType?: boolean;
    /**
     * Controls whether the find widget should search as you type.
     */
    findOnType?: boolean;
    /**
     * Controls if we seed search string in the Find Widget with editor selection.
     */
    seedSearchStringFromSelection?: "never" | "always" | "selection";
    /**
     * Controls if Find in Selection flag is turned on in the editor.
     */
    autoFindInSelection?: "never" | "always" | "multiline";
    addExtraSpaceOnTop?: boolean;
    /**
     * @internal
     * Controls if the Find Widget should read or modify the shared find clipboard on macOS
     */
    globalFindClipboard?: boolean;
    /**
     * Controls whether the search result and diff result automatically restarts from the beginning (or the end) when no further matches can be found
     */
    loop?: boolean;
    /**
     * @internal
     * Controls how the find widget search history should be stored
     */
    history?: "never" | "workspace";
    /**
     * @internal
     * Controls how the replace widget search history should be stored
     */
    replaceHistory?: "never" | "workspace";
}
/**
 * @internal
 */
export type EditorFindOptions = Readonly<Required<IEditorFindOptions>>;
/**
 * @internal
 */
export declare class EditorFontLigatures extends BaseEditorOption<EditorOption.fontLigatures, boolean | string, string> {
    static OFF: string;
    static ON: string;
    constructor();
    validate(input: any): string;
}
/**
 * @internal
 */
export declare class EditorFontVariations extends BaseEditorOption<EditorOption.fontVariations, boolean | string, string> {
    static OFF: string;
    static TRANSLATE: string;
    constructor();
    validate(input: any): string;
    compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, value: string): string;
}
export type GoToLocationValues = "peek" | "gotoAndPeek" | "goto";
/**
 * Configuration options for go to location
 */
export interface IGotoLocationOptions {
    multiple?: GoToLocationValues;
    multipleDefinitions?: GoToLocationValues;
    multipleTypeDefinitions?: GoToLocationValues;
    multipleDeclarations?: GoToLocationValues;
    multipleImplementations?: GoToLocationValues;
    multipleReferences?: GoToLocationValues;
    multipleTests?: GoToLocationValues;
    alternativeDefinitionCommand?: string;
    alternativeTypeDefinitionCommand?: string;
    alternativeDeclarationCommand?: string;
    alternativeImplementationCommand?: string;
    alternativeReferenceCommand?: string;
    alternativeTestsCommand?: string;
}
/**
 * @internal
 */
export type GoToLocationOptions = Readonly<Required<IGotoLocationOptions>>;
/**
 * Configuration options for editor hover
 */
export interface IEditorHoverOptions {
    /**
     * Enable the hover.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * Delay for showing the hover.
     * Defaults to 300.
     */
    delay?: number;
    /**
     * Is the hover sticky such that it can be clicked and its contents selected?
     * Defaults to true.
     */
    sticky?: boolean;
    /**
     * Controls how long the hover is visible after you hovered out of it.
     * Require sticky setting to be true.
     */
    hidingDelay?: number;
    /**
     * Should the hover be shown above the line if possible?
     * Defaults to false.
     */
    above?: boolean;
}
/**
 * @internal
 */
export type EditorHoverOptions = Readonly<Required<IEditorHoverOptions>>;
/**
 * A description for the overview ruler position.
 */
export interface OverviewRulerPosition {
    /**
     * Width of the overview ruler
     */
    readonly width: number;
    /**
     * Height of the overview ruler
     */
    readonly height: number;
    /**
     * Top position for the overview ruler
     */
    readonly top: number;
    /**
     * Right position for the overview ruler
     */
    readonly right: number;
}
export declare enum RenderMinimap {
    None = 0,
    Text = 1,
    Blocks = 2
}
/**
 * The internal layout details of the editor.
 */
export interface EditorLayoutInfo {
    /**
     * Full editor width.
     */
    readonly width: number;
    /**
     * Full editor height.
     */
    readonly height: number;
    /**
     * Left position for the glyph margin.
     */
    readonly glyphMarginLeft: number;
    /**
     * The width of the glyph margin.
     */
    readonly glyphMarginWidth: number;
    /**
     * The number of decoration lanes to render in the glyph margin.
     */
    readonly glyphMarginDecorationLaneCount: number;
    /**
     * Left position for the line numbers.
     */
    readonly lineNumbersLeft: number;
    /**
     * The width of the line numbers.
     */
    readonly lineNumbersWidth: number;
    /**
     * Left position for the line decorations.
     */
    readonly decorationsLeft: number;
    /**
     * The width of the line decorations.
     */
    readonly decorationsWidth: number;
    /**
     * Left position for the content (actual text)
     */
    readonly contentLeft: number;
    /**
     * The width of the content (actual text)
     */
    readonly contentWidth: number;
    /**
     * Layout information for the minimap
     */
    readonly minimap: EditorMinimapLayoutInfo;
    /**
     * The number of columns (of typical characters) fitting on a viewport line.
     */
    readonly viewportColumn: number;
    readonly isWordWrapMinified: boolean;
    readonly isViewportWrapping: boolean;
    readonly wrappingColumn: number;
    /**
     * The width of the vertical scrollbar.
     */
    readonly verticalScrollbarWidth: number;
    /**
     * The height of the horizontal scrollbar.
     */
    readonly horizontalScrollbarHeight: number;
    /**
     * The position of the overview ruler.
     */
    readonly overviewRuler: OverviewRulerPosition;
}
/**
 * The internal layout details of the editor.
 */
export interface EditorMinimapLayoutInfo {
    readonly renderMinimap: RenderMinimap;
    readonly minimapLeft: number;
    readonly minimapWidth: number;
    readonly minimapHeightIsEditorHeight: boolean;
    readonly minimapIsSampling: boolean;
    readonly minimapScale: number;
    readonly minimapLineHeight: number;
    readonly minimapCanvasInnerWidth: number;
    readonly minimapCanvasInnerHeight: number;
    readonly minimapCanvasOuterWidth: number;
    readonly minimapCanvasOuterHeight: number;
}
/**
 * @internal
 */
export interface EditorLayoutInfoComputerEnv {
    readonly memory: ComputeOptionsMemory | null;
    readonly outerWidth: number;
    readonly outerHeight: number;
    readonly isDominatedByLongLines: boolean;
    readonly lineHeight: number;
    readonly viewLineCount: number;
    readonly lineNumbersDigitCount: number;
    readonly typicalHalfwidthCharacterWidth: number;
    readonly maxDigitWidth: number;
    readonly pixelRatio: number;
    readonly glyphMarginDecorationLaneCount: number;
}
/**
 * @internal
 */
export interface IEditorLayoutComputerInput {
    readonly outerWidth: number;
    readonly outerHeight: number;
    readonly isDominatedByLongLines: boolean;
    readonly lineHeight: number;
    readonly lineNumbersDigitCount: number;
    readonly typicalHalfwidthCharacterWidth: number;
    readonly maxDigitWidth: number;
    readonly pixelRatio: number;
    readonly glyphMargin: boolean;
    readonly lineDecorationsWidth: string | number;
    readonly folding: boolean;
    readonly minimap: Readonly<Required<IEditorMinimapOptions>>;
    readonly scrollbar: InternalEditorScrollbarOptions;
    readonly lineNumbers: InternalEditorRenderLineNumbersOptions;
    readonly lineNumbersMinChars: number;
    readonly scrollBeyondLastLine: boolean;
    readonly wordWrap: "wordWrapColumn" | "on" | "off" | "bounded";
    readonly wordWrapColumn: number;
    readonly wordWrapMinified: boolean;
    readonly accessibilitySupport: AccessibilitySupport;
}
/**
 * @internal
 */
export interface IMinimapLayoutInput {
    readonly outerWidth: number;
    readonly outerHeight: number;
    readonly lineHeight: number;
    readonly typicalHalfwidthCharacterWidth: number;
    readonly pixelRatio: number;
    readonly scrollBeyondLastLine: boolean;
    readonly paddingTop: number;
    readonly paddingBottom: number;
    readonly minimap: Readonly<Required<IEditorMinimapOptions>>;
    readonly verticalScrollbarWidth: number;
    readonly viewLineCount: number;
    readonly remainingWidth: number;
    readonly isViewportWrapping: boolean;
}
/**
 * @internal
 */
export declare class EditorLayoutInfoComputer extends ComputedEditorOption<EditorOption.layoutInfo, EditorLayoutInfo> {
    constructor();
    compute(env: IEnvironmentalOptions, options: IComputedEditorOptions, _: EditorLayoutInfo): EditorLayoutInfo;
    static computeContainedMinimapLineCount(input: {
        viewLineCount: number;
        scrollBeyondLastLine: boolean;
        paddingTop: number;
        paddingBottom: number;
        height: number;
        lineHeight: number;
        pixelRatio: number;
    }): {
        typicalViewportLineCount: number;
        extraLinesBeforeFirstLine: number;
        extraLinesBeyondLastLine: number;
        desiredRatio: number;
        minimapLineCount: number;
    };
    private static _computeMinimapLayout;
    static computeLayout(options: IComputedEditorOptions, env: EditorLayoutInfoComputerEnv): EditorLayoutInfo;
}
export declare enum ShowLightbulbIconMode {
    Off = "off",
    OnCode = "onCode",
    On = "on"
}
/**
 * Configuration options for editor lightbulb
 */
export interface IEditorLightbulbOptions {
    /**
     * Enable the lightbulb code action.
     * The three possible values are `off`, `on` and `onCode` and the default is `onCode`.
     * `off` disables the code action menu.
     * `on` shows the code action menu on code and on empty lines.
     * `onCode` shows the code action menu on code only.
     */
    enabled?: ShowLightbulbIconMode;
}
/**
 * @internal
 */
export type EditorLightbulbOptions = Readonly<Required<IEditorLightbulbOptions>>;
export interface IEditorStickyScrollOptions {
    /**
     * Enable the sticky scroll
     */
    enabled?: boolean;
    /**
     * Maximum number of sticky lines to show
     */
    maxLineCount?: number;
    /**
     * Model to choose for sticky scroll by default
     */
    defaultModel?: "outlineModel" | "foldingProviderModel" | "indentationModel";
    /**
     * Define whether to scroll sticky scroll with editor horizontal scrollbae
     */
    scrollWithEditor?: boolean;
}
/**
 * @internal
 */
export type EditorStickyScrollOptions = Readonly<Required<IEditorStickyScrollOptions>>;
/**
 * Configuration options for editor inlayHints
 */
export interface IEditorInlayHintsOptions {
    /**
     * Enable the inline hints.
     * Defaults to true.
     */
    enabled?: "on" | "off" | "offUnlessPressed" | "onUnlessPressed";
    /**
     * Font size of inline hints.
     * Default to 90% of the editor font size.
     */
    fontSize?: number;
    /**
     * Font family of inline hints.
     * Defaults to editor font family.
     */
    fontFamily?: string;
    /**
     * Enables the padding around the inlay hint.
     * Defaults to false.
     */
    padding?: boolean;
    /**
     * Maximum length for inlay hints per line
     * Set to 0 to have an unlimited length.
     */
    maximumLength?: number;
}
/**
 * @internal
 */
export type EditorInlayHintsOptions = Readonly<Required<IEditorInlayHintsOptions>>;
/**
 * Configuration options for editor minimap
 */
export interface IEditorMinimapOptions {
    /**
     * Enable the rendering of the minimap.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * Control the rendering of minimap.
     */
    autohide?: "none" | "mouseover" | "scroll";
    /**
     * Control the side of the minimap in editor.
     * Defaults to 'right'.
     */
    side?: "right" | "left";
    /**
     * Control the minimap rendering mode.
     * Defaults to 'actual'.
     */
    size?: "proportional" | "fill" | "fit";
    /**
     * Control the rendering of the minimap slider.
     * Defaults to 'mouseover'.
     */
    showSlider?: "always" | "mouseover";
    /**
     * Render the actual text on a line (as opposed to color blocks).
     * Defaults to true.
     */
    renderCharacters?: boolean;
    /**
     * Limit the width of the minimap to render at most a certain number of columns.
     * Defaults to 120.
     */
    maxColumn?: number;
    /**
     * Relative size of the font in the minimap. Defaults to 1.
     */
    scale?: number;
    /**
     * Whether to show named regions as section headers. Defaults to true.
     */
    showRegionSectionHeaders?: boolean;
    /**
     * Whether to show MARK: comments as section headers. Defaults to true.
     */
    showMarkSectionHeaders?: boolean;
    /**
     * When specified, is used to create a custom section header parser regexp.
     * Must contain a match group named 'label' (written as (?<label>.+)) that encapsulates the section header.
     * Optionally can include another match group named 'separator'.
     * To match multi-line headers like:
     *   // ==========
     *   // My Section
     *   // ==========
     * Use a pattern like: ^={3,}\n^\/\/ *(?<label>[^\n]*?)\n^={3,}$
     */
    markSectionHeaderRegex?: string;
    /**
     * Font size of section headers. Defaults to 9.
     */
    sectionHeaderFontSize?: number;
    /**
     * Spacing between the section header characters (in CSS px). Defaults to 1.
     */
    sectionHeaderLetterSpacing?: number;
}
/**
 * @internal
 */
export type EditorMinimapOptions = Readonly<Required<IEditorMinimapOptions>>;
/**
 * Configuration options for editor padding
 */
export interface IEditorPaddingOptions {
    /**
     * Spacing between top edge of editor and first line.
     */
    top?: number;
    /**
     * Spacing between bottom edge of editor and last line.
     */
    bottom?: number;
}
/**
 * @internal
 */
export type InternalEditorPaddingOptions = Readonly<Required<IEditorPaddingOptions>>;
/**
 * Configuration options for parameter hints
 */
export interface IEditorParameterHintOptions {
    /**
     * Enable parameter hints.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * Enable cycling of parameter hints.
     * Defaults to false.
     */
    cycle?: boolean;
}
/**
 * @internal
 */
export type InternalParameterHintOptions = Readonly<Required<IEditorParameterHintOptions>>;
export type QuickSuggestionsValue = "on" | "inline" | "off";
/**
 * Configuration options for quick suggestions
 */
export interface IQuickSuggestionsOptions {
    other?: boolean | QuickSuggestionsValue;
    comments?: boolean | QuickSuggestionsValue;
    strings?: boolean | QuickSuggestionsValue;
}
export interface InternalQuickSuggestionsOptions {
    readonly other: QuickSuggestionsValue;
    readonly comments: QuickSuggestionsValue;
    readonly strings: QuickSuggestionsValue;
}
export type LineNumbersType = "on" | "off" | "relative" | "interval" | ((lineNumber: number) => string);
export declare enum RenderLineNumbersType {
    Off = 0,
    On = 1,
    Relative = 2,
    Interval = 3,
    Custom = 4
}
export interface InternalEditorRenderLineNumbersOptions {
    readonly renderType: RenderLineNumbersType;
    readonly renderFn: ((lineNumber: number) => string) | null;
}
/**
 * @internal
 */
export declare function filterValidationDecorations(options: IComputedEditorOptions): boolean;
/**
 * @internal
 */
export declare function filterFontDecorations(options: IComputedEditorOptions): boolean;
export interface IRulerOption {
    readonly column: number;
    readonly color: string | null;
}
/**
 * Configuration options for editor scrollbars
 */
export interface IEditorScrollbarOptions {
    /**
     * The size of arrows (if displayed).
     * Defaults to 11.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    arrowSize?: number;
    /**
     * Render vertical scrollbar.
     * Defaults to 'auto'.
     */
    vertical?: "auto" | "visible" | "hidden";
    /**
     * Render horizontal scrollbar.
     * Defaults to 'auto'.
     */
    horizontal?: "auto" | "visible" | "hidden";
    /**
     * Cast horizontal and vertical shadows when the content is scrolled.
     * Defaults to true.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    useShadows?: boolean;
    /**
     * Render arrows at the top and bottom of the vertical scrollbar.
     * Defaults to false.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    verticalHasArrows?: boolean;
    /**
     * Render arrows at the left and right of the horizontal scrollbar.
     * Defaults to false.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    horizontalHasArrows?: boolean;
    /**
     * Listen to mouse wheel events and react to them by scrolling.
     * Defaults to true.
     */
    handleMouseWheel?: boolean;
    /**
     * Always consume mouse wheel events (always call preventDefault() and stopPropagation() on the browser events).
     * Defaults to true.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    alwaysConsumeMouseWheel?: boolean;
    /**
     * Height in pixels for the horizontal scrollbar.
     * Defaults to 12 (px).
     */
    horizontalScrollbarSize?: number;
    /**
     * Width in pixels for the vertical scrollbar.
     * Defaults to 14 (px).
     */
    verticalScrollbarSize?: number;
    /**
     * Width in pixels for the vertical slider.
     * Defaults to `verticalScrollbarSize`.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    verticalSliderSize?: number;
    /**
     * Height in pixels for the horizontal slider.
     * Defaults to `horizontalScrollbarSize`.
     * **NOTE**: This option cannot be updated using `updateOptions()`
     */
    horizontalSliderSize?: number;
    /**
     * Scroll gutter clicks move by page vs jump to position.
     * Defaults to false.
     */
    scrollByPage?: boolean;
    /**
     * When set, the horizontal scrollbar will not increase content height.
     * Defaults to false.
     */
    ignoreHorizontalScrollbarInContentHeight?: boolean;
}
export interface InternalEditorScrollbarOptions {
    readonly arrowSize: number;
    readonly vertical: ScrollbarVisibility;
    readonly horizontal: ScrollbarVisibility;
    readonly useShadows: boolean;
    readonly verticalHasArrows: boolean;
    readonly horizontalHasArrows: boolean;
    readonly handleMouseWheel: boolean;
    readonly alwaysConsumeMouseWheel: boolean;
    readonly horizontalScrollbarSize: number;
    readonly horizontalSliderSize: number;
    readonly verticalScrollbarSize: number;
    readonly verticalSliderSize: number;
    readonly scrollByPage: boolean;
    readonly ignoreHorizontalScrollbarInContentHeight: boolean;
}
export type InUntrustedWorkspace = "inUntrustedWorkspace";
/**
 * @internal
*/
export declare const inUntrustedWorkspace: InUntrustedWorkspace;
/**
 * Configuration options for unicode highlighting.
 */
export interface IUnicodeHighlightOptions {
    /**
     * Controls whether all non-basic ASCII characters are highlighted. Only characters between U+0020 and U+007E, tab, line-feed and carriage-return are considered basic ASCII.
     */
    nonBasicASCII?: boolean | InUntrustedWorkspace;
    /**
     * Controls whether characters that just reserve space or have no width at all are highlighted.
     */
    invisibleCharacters?: boolean;
    /**
     * Controls whether characters are highlighted that can be confused with basic ASCII characters, except those that are common in the current user locale.
     */
    ambiguousCharacters?: boolean;
    /**
     * Controls whether characters in comments should also be subject to unicode highlighting.
     */
    includeComments?: boolean | InUntrustedWorkspace;
    /**
     * Controls whether characters in strings should also be subject to unicode highlighting.
     */
    includeStrings?: boolean | InUntrustedWorkspace;
    /**
     * Defines allowed characters that are not being highlighted.
     */
    allowedCharacters?: Record<string, true>;
    /**
     * Unicode characters that are common in allowed locales are not being highlighted.
     */
    allowedLocales?: Record<string | "_os" | "_vscode", true>;
}
/**
 * @internal
 */
export type InternalUnicodeHighlightOptions = Required<Readonly<IUnicodeHighlightOptions>>;
/**
 * @internal
 */
export declare const unicodeHighlightConfigKeys: {
    allowedCharacters: string;
    invisibleCharacters: string;
    nonBasicASCII: string;
    ambiguousCharacters: string;
    includeComments: string;
    includeStrings: string;
    allowedLocales: string;
};
export interface IInlineSuggestOptions {
    /**
     * Enable or disable the rendering of automatic inline completions.
    */
    enabled?: boolean;
    /**
     * Configures the mode.
     * Use `prefix` to only show ghost text if the text to replace is a prefix of the suggestion text.
     * Use `subword` to only show ghost text if the replace text is a subword of the suggestion text.
     * Use `subwordSmart` to only show ghost text if the replace text is a subword of the suggestion text, but the subword must start after the cursor position.
     * Defaults to `prefix`.
    */
    mode?: "prefix" | "subword" | "subwordSmart";
    showToolbar?: "always" | "onHover" | "never";
    syntaxHighlightingEnabled?: boolean;
    suppressSuggestions?: boolean;
    minShowDelay?: number;
    suppressInSnippetMode?: boolean;
    /**
     * Does not clear active inline suggestions when the editor loses focus.
     */
    keepOnBlur?: boolean;
    /**
     * Font family for inline suggestions.
     */
    fontFamily?: string | "default";
    edits?: {
        allowCodeShifting?: "always" | "horizontal" | "never";
        renderSideBySide?: "never" | "auto";
        showCollapsed?: boolean;
        /**
        * @internal
        */
        enabled?: boolean;
    };
    /**
    * @internal
    */
    triggerCommandOnProviderChange?: boolean;
    /**
    * @internal
    */
    experimental?: {
        /**
        * @internal
        */
        suppressInlineSuggestions?: string;
        /**
        * @internal
        */
        emptyResponseInformation?: boolean;
        showOnSuggestConflict?: "always" | "never" | "whenSuggestListIsIncomplete";
    };
}
type RequiredRecursive<T> = {
    [P in keyof T]-?: T[P] extends object | undefined ? RequiredRecursive<T[P]> : T[P];
};
/**
 * @internal
 */
export type InternalInlineSuggestOptions = Readonly<RequiredRecursive<IInlineSuggestOptions>>;
export interface IBracketPairColorizationOptions {
    /**
     * Enable or disable bracket pair colorization.
    */
    enabled?: boolean;
    /**
     * Use independent color pool per bracket type.
    */
    independentColorPoolPerBracketType?: boolean;
}
/**
 * @internal
 */
export type InternalBracketPairColorizationOptions = Readonly<Required<IBracketPairColorizationOptions>>;
export interface IGuidesOptions {
    /**
     * Enable rendering of bracket pair guides.
     * Defaults to false.
    */
    bracketPairs?: boolean | "active";
    /**
     * Enable rendering of vertical bracket pair guides.
     * Defaults to 'active'.
     */
    bracketPairsHorizontal?: boolean | "active";
    /**
     * Enable highlighting of the active bracket pair.
     * Defaults to true.
    */
    highlightActiveBracketPair?: boolean;
    /**
     * Enable rendering of indent guides.
     * Defaults to true.
     */
    indentation?: boolean;
    /**
     * Enable highlighting of the active indent guide.
     * Defaults to true.
     */
    highlightActiveIndentation?: boolean | "always";
}
/**
 * @internal
 */
export type InternalGuidesOptions = Readonly<Required<IGuidesOptions>>;
/**
 * Configuration options for editor suggest widget
 */
export interface ISuggestOptions {
    /**
     * Overwrite word ends on accept. Default to false.
     */
    insertMode?: "insert" | "replace";
    /**
     * Enable graceful matching. Defaults to true.
     */
    filterGraceful?: boolean;
    /**
     * Prevent quick suggestions when a snippet is active. Defaults to true.
     */
    snippetsPreventQuickSuggestions?: boolean;
    /**
     * Favors words that appear close to the cursor.
     */
    localityBonus?: boolean;
    /**
     * Enable using global storage for remembering suggestions.
     */
    shareSuggestSelections?: boolean;
    /**
     * Select suggestions when triggered via quick suggest or trigger characters
     */
    selectionMode?: "always" | "never" | "whenTriggerCharacter" | "whenQuickSuggestion";
    /**
     * Enable or disable icons in suggestions. Defaults to true.
     */
    showIcons?: boolean;
    /**
     * Enable or disable the suggest status bar.
     */
    showStatusBar?: boolean;
    /**
     * Enable or disable the rendering of the suggestion preview.
     */
    preview?: boolean;
    /**
     * Configures the mode of the preview.
    */
    previewMode?: "prefix" | "subword" | "subwordSmart";
    /**
     * Show details inline with the label. Defaults to true.
     */
    showInlineDetails?: boolean;
    /**
     * Show method-suggestions.
     */
    showMethods?: boolean;
    /**
     * Show function-suggestions.
     */
    showFunctions?: boolean;
    /**
     * Show constructor-suggestions.
     */
    showConstructors?: boolean;
    /**
     * Show deprecated-suggestions.
     */
    showDeprecated?: boolean;
    /**
     * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
     */
    matchOnWordStartOnly?: boolean;
    /**
     * Show field-suggestions.
     */
    showFields?: boolean;
    /**
     * Show variable-suggestions.
     */
    showVariables?: boolean;
    /**
     * Show class-suggestions.
     */
    showClasses?: boolean;
    /**
     * Show struct-suggestions.
     */
    showStructs?: boolean;
    /**
     * Show interface-suggestions.
     */
    showInterfaces?: boolean;
    /**
     * Show module-suggestions.
     */
    showModules?: boolean;
    /**
     * Show property-suggestions.
     */
    showProperties?: boolean;
    /**
     * Show event-suggestions.
     */
    showEvents?: boolean;
    /**
     * Show operator-suggestions.
     */
    showOperators?: boolean;
    /**
     * Show unit-suggestions.
     */
    showUnits?: boolean;
    /**
     * Show value-suggestions.
     */
    showValues?: boolean;
    /**
     * Show constant-suggestions.
     */
    showConstants?: boolean;
    /**
     * Show enum-suggestions.
     */
    showEnums?: boolean;
    /**
     * Show enumMember-suggestions.
     */
    showEnumMembers?: boolean;
    /**
     * Show keyword-suggestions.
     */
    showKeywords?: boolean;
    /**
     * Show text-suggestions.
     */
    showWords?: boolean;
    /**
     * Show color-suggestions.
     */
    showColors?: boolean;
    /**
     * Show file-suggestions.
     */
    showFiles?: boolean;
    /**
     * Show reference-suggestions.
     */
    showReferences?: boolean;
    /**
     * Show folder-suggestions.
     */
    showFolders?: boolean;
    /**
     * Show typeParameter-suggestions.
     */
    showTypeParameters?: boolean;
    /**
     * Show issue-suggestions.
     */
    showIssues?: boolean;
    /**
     * Show user-suggestions.
     */
    showUsers?: boolean;
    /**
     * Show snippet-suggestions.
     */
    showSnippets?: boolean;
}
/**
 * @internal
 */
export type InternalSuggestOptions = Readonly<Required<ISuggestOptions>>;
export interface ISmartSelectOptions {
    selectLeadingAndTrailingWhitespace?: boolean;
    selectSubwords?: boolean;
}
/**
 * @internal
 */
export type SmartSelectOptions = Readonly<Required<ISmartSelectOptions>>;
/**
 * Describes how to indent wrapped lines.
 */
export declare enum WrappingIndent {
    /**
     * No indentation => wrapped lines begin at column 1.
     */
    None = 0,
    /**
     * Same => wrapped lines get the same indentation as the parent.
     */
    Same = 1,
    /**
     * Indent => wrapped lines get +1 indentation toward the parent.
     */
    Indent = 2,
    /**
     * DeepIndent => wrapped lines get +2 indentation toward the parent.
     */
    DeepIndent = 3
}
export interface EditorWrappingInfo {
    readonly isDominatedByLongLines: boolean;
    readonly isWordWrapMinified: boolean;
    readonly isViewportWrapping: boolean;
    readonly wrappingColumn: number;
}
/**
 * Configuration options for editor drop into behavior
 */
export interface IDropIntoEditorOptions {
    /**
     * Enable dropping into editor.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * Controls if a widget is shown after a drop.
     * Defaults to 'afterDrop'.
     */
    showDropSelector?: "afterDrop" | "never";
}
/**
 * @internal
 */
export type EditorDropIntoEditorOptions = Readonly<Required<IDropIntoEditorOptions>>;
/**
 * Configuration options for editor pasting as into behavior
 */
export interface IPasteAsOptions {
    /**
     * Enable paste as functionality in editors.
     * Defaults to true.
     */
    enabled?: boolean;
    /**
     * Controls if a widget is shown after a drop.
     * Defaults to 'afterPaste'.
     */
    showPasteSelector?: "afterPaste" | "never";
}
/**
 * @internal
 */
export type EditorPasteAsOptions = Readonly<Required<IPasteAsOptions>>;
/**
 * @internal
 */
export declare const EDITOR_FONT_DEFAULTS: {
    fontFamily: string;
    fontWeight: string;
    fontSize: number;
    lineHeight: number;
    letterSpacing: number;
};
/**
 * @internal
 */
export declare const editorOptionsRegistry: IEditorOption<EditorOption, any>[];
export declare enum EditorOption {
    acceptSuggestionOnCommitCharacter = 0,
    acceptSuggestionOnEnter = 1,
    accessibilitySupport = 2,
    accessibilityPageSize = 3,
    allowOverflow = 4,
    allowVariableLineHeights = 5,
    allowVariableFonts = 6,
    allowVariableFontsInAccessibilityMode = 7,
    ariaLabel = 8,
    ariaRequired = 9,
    autoClosingBrackets = 10,
    autoClosingComments = 11,
    screenReaderAnnounceInlineSuggestion = 12,
    autoClosingDelete = 13,
    autoClosingOvertype = 14,
    autoClosingQuotes = 15,
    autoIndent = 16,
    autoIndentOnPaste = 17,
    autoIndentOnPasteWithinString = 18,
    automaticLayout = 19,
    autoSurround = 20,
    bracketPairColorization = 21,
    guides = 22,
    codeLens = 23,
    codeLensFontFamily = 24,
    codeLensFontSize = 25,
    colorDecorators = 26,
    colorDecoratorsLimit = 27,
    columnSelection = 28,
    comments = 29,
    contextmenu = 30,
    copyWithSyntaxHighlighting = 31,
    cursorBlinking = 32,
    cursorSmoothCaretAnimation = 33,
    cursorStyle = 34,
    cursorSurroundingLines = 35,
    cursorSurroundingLinesStyle = 36,
    cursorWidth = 37,
    cursorHeight = 38,
    disableLayerHinting = 39,
    disableMonospaceOptimizations = 40,
    domReadOnly = 41,
    dragAndDrop = 42,
    dropIntoEditor = 43,
    editContext = 44,
    emptySelectionClipboard = 45,
    experimentalGpuAcceleration = 46,
    experimentalWhitespaceRendering = 47,
    extraEditorClassName = 48,
    fastScrollSensitivity = 49,
    find = 50,
    fixedOverflowWidgets = 51,
    folding = 52,
    foldingStrategy = 53,
    foldingHighlight = 54,
    foldingImportsByDefault = 55,
    foldingMaximumRegions = 56,
    unfoldOnClickAfterEndOfLine = 57,
    fontFamily = 58,
    fontInfo = 59,
    fontLigatures = 60,
    fontSize = 61,
    fontWeight = 62,
    fontVariations = 63,
    formatOnPaste = 64,
    formatOnType = 65,
    glyphMargin = 66,
    gotoLocation = 67,
    hideCursorInOverviewRuler = 68,
    hover = 69,
    inDiffEditor = 70,
    inlineSuggest = 71,
    letterSpacing = 72,
    lightbulb = 73,
    lineDecorationsWidth = 74,
    lineHeight = 75,
    lineNumbers = 76,
    lineNumbersMinChars = 77,
    linkedEditing = 78,
    links = 79,
    matchBrackets = 80,
    minimap = 81,
    mouseStyle = 82,
    mouseWheelScrollSensitivity = 83,
    mouseWheelZoom = 84,
    multiCursorMergeOverlapping = 85,
    multiCursorModifier = 86,
    mouseMiddleClickAction = 87,
    multiCursorPaste = 88,
    multiCursorLimit = 89,
    occurrencesHighlight = 90,
    occurrencesHighlightDelay = 91,
    overtypeCursorStyle = 92,
    overtypeOnPaste = 93,
    overviewRulerBorder = 94,
    overviewRulerLanes = 95,
    padding = 96,
    pasteAs = 97,
    parameterHints = 98,
    peekWidgetDefaultFocus = 99,
    placeholder = 100,
    definitionLinkOpensInPeek = 101,
    quickSuggestions = 102,
    quickSuggestionsDelay = 103,
    readOnly = 104,
    readOnlyMessage = 105,
    renameOnType = 106,
    renderRichScreenReaderContent = 107,
    renderControlCharacters = 108,
    renderFinalNewline = 109,
    renderLineHighlight = 110,
    renderLineHighlightOnlyWhenFocus = 111,
    renderValidationDecorations = 112,
    renderWhitespace = 113,
    revealHorizontalRightPadding = 114,
    roundedSelection = 115,
    rulers = 116,
    scrollbar = 117,
    scrollBeyondLastColumn = 118,
    scrollBeyondLastLine = 119,
    scrollPredominantAxis = 120,
    selectionClipboard = 121,
    selectionHighlight = 122,
    selectionHighlightMaxLength = 123,
    selectionHighlightMultiline = 124,
    selectOnLineNumbers = 125,
    showFoldingControls = 126,
    showUnused = 127,
    snippetSuggestions = 128,
    smartSelect = 129,
    smoothScrolling = 130,
    stickyScroll = 131,
    stickyTabStops = 132,
    stopRenderingLineAfter = 133,
    suggest = 134,
    suggestFontSize = 135,
    suggestLineHeight = 136,
    suggestOnTriggerCharacters = 137,
    suggestSelection = 138,
    tabCompletion = 139,
    tabIndex = 140,
    trimWhitespaceOnDelete = 141,
    unicodeHighlighting = 142,
    unusualLineTerminators = 143,
    useShadowDOM = 144,
    useTabStops = 145,
    wordBreak = 146,
    wordSegmenterLocales = 147,
    wordSeparators = 148,
    wordWrap = 149,
    wordWrapBreakAfterCharacters = 150,
    wordWrapBreakBeforeCharacters = 151,
    wordWrapColumn = 152,
    wordWrapOverride1 = 153,
    wordWrapOverride2 = 154,
    wrappingIndent = 155,
    wrappingStrategy = 156,
    showDeprecated = 157,
    inertialScroll = 158,
    inlayHints = 159,
    wrapOnEscapedLineFeeds = 160,
    effectiveCursorStyle = 161,
    editorClassName = 162,
    pixelRatio = 163,
    tabFocusMode = 164,
    layoutInfo = 165,
    wrappingInfo = 166,
    defaultColorDecorators = 167,
    colorDecoratorsActivatedOn = 168,
    inlineCompletionsAccessibilityVerbose = 169,
    effectiveEditContext = 170,
    scrollOnMiddleClick = 171,
    effectiveAllowVariableFonts = 172
}
export declare const EditorOptions: {
    acceptSuggestionOnCommitCharacter: IEditorOption<EditorOption.acceptSuggestionOnCommitCharacter, boolean>;
    acceptSuggestionOnEnter: IEditorOption<EditorOption.acceptSuggestionOnEnter, "on" | "off" | "smart">;
    accessibilitySupport: IEditorOption<EditorOption.accessibilitySupport, AccessibilitySupport>;
    accessibilityPageSize: IEditorOption<EditorOption.accessibilityPageSize, number>;
    allowOverflow: IEditorOption<EditorOption.allowOverflow, boolean>;
    allowVariableLineHeights: IEditorOption<EditorOption.allowVariableLineHeights, boolean>;
    allowVariableFonts: IEditorOption<EditorOption.allowVariableFonts, boolean>;
    allowVariableFontsInAccessibilityMode: IEditorOption<EditorOption.allowVariableFontsInAccessibilityMode, boolean>;
    ariaLabel: IEditorOption<EditorOption.ariaLabel, string>;
    ariaRequired: IEditorOption<EditorOption.ariaRequired, boolean>;
    screenReaderAnnounceInlineSuggestion: IEditorOption<EditorOption.screenReaderAnnounceInlineSuggestion, boolean>;
    autoClosingBrackets: IEditorOption<EditorOption.autoClosingBrackets, "always" | "languageDefined" | "beforeWhitespace" | "never">;
    autoClosingComments: IEditorOption<EditorOption.autoClosingComments, "always" | "languageDefined" | "beforeWhitespace" | "never">;
    autoClosingDelete: IEditorOption<EditorOption.autoClosingDelete, "auto" | "always" | "never">;
    autoClosingOvertype: IEditorOption<EditorOption.autoClosingOvertype, "auto" | "always" | "never">;
    autoClosingQuotes: IEditorOption<EditorOption.autoClosingQuotes, "always" | "languageDefined" | "beforeWhitespace" | "never">;
    autoIndent: IEditorOption<EditorOption.autoIndent, EditorAutoIndentStrategy>;
    autoIndentOnPaste: IEditorOption<EditorOption.autoIndentOnPaste, boolean>;
    autoIndentOnPasteWithinString: IEditorOption<EditorOption.autoIndentOnPasteWithinString, boolean>;
    automaticLayout: IEditorOption<EditorOption.automaticLayout, boolean>;
    autoSurround: IEditorOption<EditorOption.autoSurround, "quotes" | "languageDefined" | "never" | "brackets">;
    bracketPairColorization: IEditorOption<EditorOption.bracketPairColorization, Readonly<Required<IBracketPairColorizationOptions>>>;
    bracketPairGuides: IEditorOption<EditorOption.guides, Readonly<Required<IGuidesOptions>>>;
    stickyTabStops: IEditorOption<EditorOption.stickyTabStops, boolean>;
    codeLens: IEditorOption<EditorOption.codeLens, boolean>;
    codeLensFontFamily: IEditorOption<EditorOption.codeLensFontFamily, string>;
    codeLensFontSize: IEditorOption<EditorOption.codeLensFontSize, number>;
    colorDecorators: IEditorOption<EditorOption.colorDecorators, boolean>;
    colorDecoratorActivatedOn: IEditorOption<EditorOption.colorDecoratorsActivatedOn, "click" | "hover" | "clickAndHover">;
    colorDecoratorsLimit: IEditorOption<EditorOption.colorDecoratorsLimit, number>;
    columnSelection: IEditorOption<EditorOption.columnSelection, boolean>;
    comments: IEditorOption<EditorOption.comments, Readonly<Required<IEditorCommentsOptions>>>;
    contextmenu: IEditorOption<EditorOption.contextmenu, boolean>;
    copyWithSyntaxHighlighting: IEditorOption<EditorOption.copyWithSyntaxHighlighting, boolean>;
    cursorBlinking: IEditorOption<EditorOption.cursorBlinking, TextEditorCursorBlinkingStyle>;
    cursorSmoothCaretAnimation: IEditorOption<EditorOption.cursorSmoothCaretAnimation, "on" | "off" | "explicit">;
    cursorStyle: IEditorOption<EditorOption.cursorStyle, TextEditorCursorStyle>;
    overtypeCursorStyle: IEditorOption<EditorOption.overtypeCursorStyle, TextEditorCursorStyle>;
    cursorSurroundingLines: IEditorOption<EditorOption.cursorSurroundingLines, number>;
    cursorSurroundingLinesStyle: IEditorOption<EditorOption.cursorSurroundingLinesStyle, "default" | "all">;
    cursorWidth: IEditorOption<EditorOption.cursorWidth, number>;
    cursorHeight: IEditorOption<EditorOption.cursorHeight, number>;
    disableLayerHinting: IEditorOption<EditorOption.disableLayerHinting, boolean>;
    disableMonospaceOptimizations: IEditorOption<EditorOption.disableMonospaceOptimizations, boolean>;
    domReadOnly: IEditorOption<EditorOption.domReadOnly, boolean>;
    dragAndDrop: IEditorOption<EditorOption.dragAndDrop, boolean>;
    emptySelectionClipboard: IEditorOption<EditorOption.emptySelectionClipboard, boolean>;
    dropIntoEditor: IEditorOption<EditorOption.dropIntoEditor, Readonly<Required<IDropIntoEditorOptions>>>;
    editContext: IEditorOption<EditorOption.editContext, boolean>;
    renderRichScreenReaderContent: IEditorOption<EditorOption.renderRichScreenReaderContent, boolean>;
    stickyScroll: IEditorOption<EditorOption.stickyScroll, Readonly<Required<IEditorStickyScrollOptions>>>;
    experimentalGpuAcceleration: IEditorOption<EditorOption.experimentalGpuAcceleration, "on" | "off">;
    experimentalWhitespaceRendering: IEditorOption<EditorOption.experimentalWhitespaceRendering, "svg" | "font" | "off">;
    extraEditorClassName: IEditorOption<EditorOption.extraEditorClassName, string>;
    fastScrollSensitivity: IEditorOption<EditorOption.fastScrollSensitivity, number>;
    find: IEditorOption<EditorOption.find, Readonly<Required<IEditorFindOptions>>>;
    fixedOverflowWidgets: IEditorOption<EditorOption.fixedOverflowWidgets, boolean>;
    folding: IEditorOption<EditorOption.folding, boolean>;
    foldingStrategy: IEditorOption<EditorOption.foldingStrategy, "auto" | "indentation">;
    foldingHighlight: IEditorOption<EditorOption.foldingHighlight, boolean>;
    foldingImportsByDefault: IEditorOption<EditorOption.foldingImportsByDefault, boolean>;
    foldingMaximumRegions: IEditorOption<EditorOption.foldingMaximumRegions, number>;
    unfoldOnClickAfterEndOfLine: IEditorOption<EditorOption.unfoldOnClickAfterEndOfLine, boolean>;
    fontFamily: IEditorOption<EditorOption.fontFamily, string>;
    fontInfo: IEditorOption<EditorOption.fontInfo, FontInfo>;
    fontLigatures2: IEditorOption<EditorOption.fontLigatures, string>;
    fontSize: IEditorOption<EditorOption.fontSize, number>;
    fontWeight: IEditorOption<EditorOption.fontWeight, string>;
    fontVariations: IEditorOption<EditorOption.fontVariations, string>;
    formatOnPaste: IEditorOption<EditorOption.formatOnPaste, boolean>;
    formatOnType: IEditorOption<EditorOption.formatOnType, boolean>;
    glyphMargin: IEditorOption<EditorOption.glyphMargin, boolean>;
    gotoLocation: IEditorOption<EditorOption.gotoLocation, Readonly<Required<IGotoLocationOptions>>>;
    hideCursorInOverviewRuler: IEditorOption<EditorOption.hideCursorInOverviewRuler, boolean>;
    hover: IEditorOption<EditorOption.hover, Readonly<Required<IEditorHoverOptions>>>;
    inDiffEditor: IEditorOption<EditorOption.inDiffEditor, boolean>;
    inertialScroll: IEditorOption<EditorOption.inertialScroll, boolean>;
    letterSpacing: IEditorOption<EditorOption.letterSpacing, number>;
    lightbulb: IEditorOption<EditorOption.lightbulb, Readonly<Required<IEditorLightbulbOptions>>>;
    lineDecorationsWidth: IEditorOption<EditorOption.lineDecorationsWidth, number>;
    lineHeight: IEditorOption<EditorOption.lineHeight, number>;
    lineNumbers: IEditorOption<EditorOption.lineNumbers, InternalEditorRenderLineNumbersOptions>;
    lineNumbersMinChars: IEditorOption<EditorOption.lineNumbersMinChars, number>;
    linkedEditing: IEditorOption<EditorOption.linkedEditing, boolean>;
    links: IEditorOption<EditorOption.links, boolean>;
    matchBrackets: IEditorOption<EditorOption.matchBrackets, "always" | "never" | "near">;
    minimap: IEditorOption<EditorOption.minimap, Readonly<Required<IEditorMinimapOptions>>>;
    mouseStyle: IEditorOption<EditorOption.mouseStyle, "text" | "copy" | "default">;
    mouseWheelScrollSensitivity: IEditorOption<EditorOption.mouseWheelScrollSensitivity, number>;
    mouseWheelZoom: IEditorOption<EditorOption.mouseWheelZoom, boolean>;
    multiCursorMergeOverlapping: IEditorOption<EditorOption.multiCursorMergeOverlapping, boolean>;
    multiCursorModifier: IEditorOption<EditorOption.multiCursorModifier, "ctrlKey" | "altKey" | "metaKey">;
    mouseMiddleClickAction: IEditorOption<EditorOption.mouseMiddleClickAction, MouseMiddleClickAction>;
    multiCursorPaste: IEditorOption<EditorOption.multiCursorPaste, "spread" | "full">;
    multiCursorLimit: IEditorOption<EditorOption.multiCursorLimit, number>;
    occurrencesHighlight: IEditorOption<EditorOption.occurrencesHighlight, "off" | "singleFile" | "multiFile">;
    occurrencesHighlightDelay: IEditorOption<EditorOption.occurrencesHighlightDelay, number>;
    overtypeOnPaste: IEditorOption<EditorOption.overtypeOnPaste, boolean>;
    overviewRulerBorder: IEditorOption<EditorOption.overviewRulerBorder, boolean>;
    overviewRulerLanes: IEditorOption<EditorOption.overviewRulerLanes, number>;
    padding: IEditorOption<EditorOption.padding, Readonly<Required<IEditorPaddingOptions>>>;
    pasteAs: IEditorOption<EditorOption.pasteAs, Readonly<Required<IPasteAsOptions>>>;
    parameterHints: IEditorOption<EditorOption.parameterHints, Readonly<Required<IEditorParameterHintOptions>>>;
    peekWidgetDefaultFocus: IEditorOption<EditorOption.peekWidgetDefaultFocus, "tree" | "editor">;
    placeholder: IEditorOption<EditorOption.placeholder, string | undefined>;
    definitionLinkOpensInPeek: IEditorOption<EditorOption.definitionLinkOpensInPeek, boolean>;
    quickSuggestions: IEditorOption<EditorOption.quickSuggestions, InternalQuickSuggestionsOptions>;
    quickSuggestionsDelay: IEditorOption<EditorOption.quickSuggestionsDelay, number>;
    readOnly: IEditorOption<EditorOption.readOnly, boolean>;
    readOnlyMessage: IEditorOption<EditorOption.readOnlyMessage, IMarkdownString | undefined>;
    renameOnType: IEditorOption<EditorOption.renameOnType, boolean>;
    renderControlCharacters: IEditorOption<EditorOption.renderControlCharacters, boolean>;
    renderFinalNewline: IEditorOption<EditorOption.renderFinalNewline, "on" | "off" | "dimmed">;
    renderLineHighlight: IEditorOption<EditorOption.renderLineHighlight, "line" | "none" | "all" | "gutter">;
    renderLineHighlightOnlyWhenFocus: IEditorOption<EditorOption.renderLineHighlightOnlyWhenFocus, boolean>;
    renderValidationDecorations: IEditorOption<EditorOption.renderValidationDecorations, "on" | "off" | "editable">;
    renderWhitespace: IEditorOption<EditorOption.renderWhitespace, "none" | "all" | "selection" | "boundary" | "trailing">;
    revealHorizontalRightPadding: IEditorOption<EditorOption.revealHorizontalRightPadding, number>;
    roundedSelection: IEditorOption<EditorOption.roundedSelection, boolean>;
    rulers: IEditorOption<EditorOption.rulers, IRulerOption[]>;
    scrollbar: IEditorOption<EditorOption.scrollbar, InternalEditorScrollbarOptions>;
    scrollBeyondLastColumn: IEditorOption<EditorOption.scrollBeyondLastColumn, number>;
    scrollBeyondLastLine: IEditorOption<EditorOption.scrollBeyondLastLine, boolean>;
    scrollOnMiddleClick: IEditorOption<EditorOption.scrollOnMiddleClick, boolean>;
    scrollPredominantAxis: IEditorOption<EditorOption.scrollPredominantAxis, boolean>;
    selectionClipboard: IEditorOption<EditorOption.selectionClipboard, boolean>;
    selectionHighlight: IEditorOption<EditorOption.selectionHighlight, boolean>;
    selectionHighlightMaxLength: IEditorOption<EditorOption.selectionHighlightMaxLength, number>;
    selectionHighlightMultiline: IEditorOption<EditorOption.selectionHighlightMultiline, boolean>;
    selectOnLineNumbers: IEditorOption<EditorOption.selectOnLineNumbers, boolean>;
    showFoldingControls: IEditorOption<EditorOption.showFoldingControls, "mouseover" | "always" | "never">;
    showUnused: IEditorOption<EditorOption.showUnused, boolean>;
    showDeprecated: IEditorOption<EditorOption.showDeprecated, boolean>;
    inlayHints: IEditorOption<EditorOption.inlayHints, Readonly<Required<IEditorInlayHintsOptions>>>;
    snippetSuggestions: IEditorOption<EditorOption.snippetSuggestions, "top" | "none" | "bottom" | "inline">;
    smartSelect: IEditorOption<EditorOption.smartSelect, Readonly<Required<ISmartSelectOptions>>>;
    smoothScrolling: IEditorOption<EditorOption.smoothScrolling, boolean>;
    stopRenderingLineAfter: IEditorOption<EditorOption.stopRenderingLineAfter, number>;
    suggest: IEditorOption<EditorOption.suggest, Readonly<Required<ISuggestOptions>>>;
    inlineSuggest: IEditorOption<EditorOption.inlineSuggest, Readonly<RequiredRecursive<IInlineSuggestOptions>>>;
    inlineCompletionsAccessibilityVerbose: IEditorOption<EditorOption.inlineCompletionsAccessibilityVerbose, boolean>;
    suggestFontSize: IEditorOption<EditorOption.suggestFontSize, number>;
    suggestLineHeight: IEditorOption<EditorOption.suggestLineHeight, number>;
    suggestOnTriggerCharacters: IEditorOption<EditorOption.suggestOnTriggerCharacters, boolean>;
    suggestSelection: IEditorOption<EditorOption.suggestSelection, "first" | "recentlyUsed" | "recentlyUsedByPrefix">;
    tabCompletion: IEditorOption<EditorOption.tabCompletion, "on" | "off" | "onlySnippets">;
    tabIndex: IEditorOption<EditorOption.tabIndex, number>;
    trimWhitespaceOnDelete: IEditorOption<EditorOption.trimWhitespaceOnDelete, boolean>;
    unicodeHighlight: IEditorOption<EditorOption.unicodeHighlighting, Required<Readonly<IUnicodeHighlightOptions>>>;
    unusualLineTerminators: IEditorOption<EditorOption.unusualLineTerminators, "prompt" | "auto" | "off">;
    useShadowDOM: IEditorOption<EditorOption.useShadowDOM, boolean>;
    useTabStops: IEditorOption<EditorOption.useTabStops, boolean>;
    wordBreak: IEditorOption<EditorOption.wordBreak, "normal" | "keepAll">;
    wordSegmenterLocales: IEditorOption<EditorOption.wordSegmenterLocales, string[]>;
    wordSeparators: IEditorOption<EditorOption.wordSeparators, string>;
    wordWrap: IEditorOption<EditorOption.wordWrap, "on" | "off" | "wordWrapColumn" | "bounded">;
    wordWrapBreakAfterCharacters: IEditorOption<EditorOption.wordWrapBreakAfterCharacters, string>;
    wordWrapBreakBeforeCharacters: IEditorOption<EditorOption.wordWrapBreakBeforeCharacters, string>;
    wordWrapColumn: IEditorOption<EditorOption.wordWrapColumn, number>;
    wordWrapOverride1: IEditorOption<EditorOption.wordWrapOverride1, "on" | "inherit" | "off">;
    wordWrapOverride2: IEditorOption<EditorOption.wordWrapOverride2, "on" | "inherit" | "off">;
    wrapOnEscapedLineFeeds: IEditorOption<EditorOption.wrapOnEscapedLineFeeds, boolean>;
    effectiveCursorStyle: IEditorOption<EditorOption.effectiveCursorStyle, TextEditorCursorStyle>;
    editorClassName: IEditorOption<EditorOption.editorClassName, string>;
    defaultColorDecorators: IEditorOption<EditorOption.defaultColorDecorators, "auto" | "always" | "never">;
    pixelRatio: IEditorOption<EditorOption.pixelRatio, number>;
    tabFocusMode: IEditorOption<EditorOption.tabFocusMode, boolean>;
    layoutInfo: IEditorOption<EditorOption.layoutInfo, EditorLayoutInfo>;
    wrappingInfo: IEditorOption<EditorOption.wrappingInfo, EditorWrappingInfo>;
    wrappingIndent: IEditorOption<EditorOption.wrappingIndent, WrappingIndent>;
    wrappingStrategy: IEditorOption<EditorOption.wrappingStrategy, "simple" | "advanced">;
    effectiveEditContextEnabled: IEditorOption<EditorOption.effectiveEditContext, boolean>;
    effectiveAllowVariableFonts: IEditorOption<EditorOption.effectiveAllowVariableFonts, boolean>;
};
type EditorOptionsType = typeof EditorOptions;
type FindEditorOptionsKeyById<T extends EditorOption> = {
    [K in keyof EditorOptionsType]: EditorOptionsType[K]["id"] extends T ? K : never;
}[keyof EditorOptionsType];
type ComputedEditorOptionValue<T extends IEditorOption<any, any>> = T extends IEditorOption<any, infer R> ? R : never;
export type FindComputedEditorOptionValueById<T extends EditorOption> = NonNullable<ComputedEditorOptionValue<EditorOptionsType[FindEditorOptionsKeyById<T>]>>;
export type MouseMiddleClickAction = "default" | "openLink" | "ctrlLeftClick";
export {};
