reactive-vscode/dist/index.d.ts

Develop VSCode extension with Vue Reactivity API

import { ChatFollowupProvider } from 'vscode';
import { ChatRequestHandler } from 'vscode';
import { ChatResultFeedback } from 'vscode';
import { ColorTheme } from 'vscode';
import { CommentController } from 'vscode';
import { ComputedRef } from '@reactive-vscode/reactivity';
import { ConfigurationScope } from 'vscode';
import { ConfigurationTarget } from 'vscode';
import { DebugSession } from 'vscode';
import { DecorationOptions } from 'vscode';
import { DecorationRenderOptions } from 'vscode';
import { Disposable as Disposable_2 } from 'vscode';
import { DocumentSelector } from 'vscode';
import { EffectScope } from '@reactive-vscode/reactivity';
import { Event as Event_2 } from 'vscode';
import { EventEmitter } from 'vscode';
import { Extension } from 'vscode';
import { ExtensionContext } from 'vscode';
import { ExtensionTerminalOptions } from 'vscode';
import { FileSystemWatcher } from 'vscode';
import { FoldingRangeProvider } from 'vscode';
import { GlobPattern } from 'vscode';
import { IconPath } from 'vscode';
import { LanguageModelToolInformation } from 'vscode';
import { LogLevel } from 'vscode';
import { LogOutputChannel } from 'vscode';
import { MaybeRef } from '@reactive-vscode/reactivity';
import { MaybeRefOrGetter } from '@reactive-vscode/reactivity';
import { NotebookEditor } from 'vscode';
import { NotebookRange } from 'vscode';
import { OutputChannel } from 'vscode';
import { QuickInputButton } from 'vscode';
import { QuickPickItem } from 'vscode';
import { QuickPickItemButtonEvent } from 'vscode';
import { Range } from 'vscode';
import { Ref } from '@reactive-vscode/reactivity';
import { Selection } from 'vscode';
import { ShallowReactive } from '@reactive-vscode/reactivity';
import { ShallowRef } from '@reactive-vscode/reactivity';
import { StatusBarAlignment } from 'vscode';
import { StatusBarItem } from 'vscode';
import { Task } from 'vscode';
import { TaskExecution } from 'vscode';
import { TaskFilter } from 'vscode';
import { Terminal } from 'vscode';
import { TerminalOptions } from 'vscode';
import { TerminalState } from 'vscode';
import { TextDocument } from 'vscode';
import { TextEditor } from 'vscode';
import { TextEditorDecorationType } from 'vscode';
import { TextEditorEdit } from 'vscode';
import { TextEditorSelectionChangeKind } from 'vscode';
import { TreeDataProvider } from 'vscode';
import { TreeItem } from 'vscode';
import { TreeView } from 'vscode';
import { TreeViewOptions } from 'vscode';
import { UnwrapNestedRefs } from '@reactive-vscode/reactivity';
import { Uri } from 'vscode';
import { ViewBadge } from 'vscode';
import { ViewColumn } from 'vscode';
import { WebviewOptions } from 'vscode';
import { WebviewPanel } from 'vscode';
import { WebviewView } from 'vscode';
import { WebviewViewResolveContext } from 'vscode';
import { window } from 'vscode';
import { WorkspaceFolder } from 'vscode';
import { WritableComputedRef } from '@reactive-vscode/reactivity';

/* Excluded from this release type: activateCbs */

export declare type AnyWatchSource = any;

export declare type Awaitable<T> = T | Promise<T>;

export declare interface ChatParticipantOptions {
    iconPath?: MaybeRefOrGetter<IconPath>;
    followupProvider?: MaybeRef<ChatFollowupProvider>;
}

export declare interface Commands extends Record<string, (...args: any[]) => any> {
    'vscode.open': (uri: Uri) => void;
}

export declare type ConfigObject<C extends object> = UnwrapNestedRefs<C> & {
    /**
     * Write the configuration value to the workspace.
     *
     * @see https://code.visualstudio.com/api/references/vscode-api#WorkspaceConfiguration.update
     */
    $update: (key: keyof C, value: C[keyof C], configurationTarget?: ConfigurationTarget | boolean | null, overrideInLanguage?: boolean) => Promise<void>;
    /**
     * Set the value without updating the workspace.
     */
    $set: (key: keyof C, value: C[keyof C]) => void;
};

export declare interface ConfigRef<T> extends WritableComputedRef<T> {
    /**
     * Write the configuration value to the workspace.
     *
     * @see https://code.visualstudio.com/api/references/vscode-api#WorkspaceConfiguration.update
     */
    update: (value: T, configurationTarget?: ConfigurationTarget | boolean | null, overrideInLanguage?: boolean) => Promise<void>;
    /**
     * Set the value without updating the workspace.
     */
    set: (value: T) => void;
}

export declare interface ConfigType<T> extends ObjectConstructor {
    [ConfigTypeSymbol]: T;
}

export declare type ConfigTypeOptions = Record<string, ConfigTypeRaw<any>>;

declare type ConfigTypeRaw<T> = ConfigTypeSingle<T> | ConfigTypeSingle<T>[];

declare type ConfigTypeSingle<T> = typeof String | typeof Number | typeof Boolean | typeof Array | typeof Object | null | ConfigType<T>;

declare const ConfigTypeSymbol: unique symbol;

/**
 * Creates a composable that caches the result of a function based on a key.
 *
 * @category utilities
 */
export declare function createKeyedComposable<P extends unknown[], R, K>(fn: (...args: P) => R, key: NoInfer<(...args: P) => K>): (...args: P) => R;

/**
 * Creates a composable that should only be called once.
 *
 * @category lifecycle
 */
export declare function createSingletonComposable<T>(fn: () => T): () => T;

/* Excluded from this release type: deactivateCbs */

/**
 * Define configurations of an extension. See `vscode::workspace.getConfiguration`.
 *
 * You can use this function with [vscode-ext-gen](https://github.com/antfu/vscode-ext-gen).
 *
 * @category lifecycle
 */
export declare function defineConfigObject<const C extends ConfigTypeOptions>(section: Nullable<string>, configs: C, scope?: Nullable<ConfigurationScope>): ConfigObject<ParseConfigTypeOptions<C>>;

export declare function defineConfigObject<C extends object>(section: Nullable<string>, configs: Record<string, any>, scope?: Nullable<ConfigurationScope>): ConfigObject<C>;

/**
 * Define configurations of an extension. See `vscode::workspace.getConfiguration`.
 *
 * You can use this function with [vscode-ext-gen](https://github.com/antfu/vscode-ext-gen).
 *
 * @category lifecycle
 */
export declare function defineConfigs<const C extends ConfigTypeOptions>(section: Nullable<string>, configs: C, scope?: Nullable<ConfigurationScope>): ToConfigRefs<ParseConfigTypeOptions<C>>;

export declare function defineConfigs<C extends object>(section: Nullable<string>, configs: C, scope?: Nullable<ConfigurationScope>): ToConfigRefs<C>;

/**
 * Define a new extension.
 *
 * @category lifecycle
 */
export declare function defineExtension<T>(setup: (context: ExtensionContext) => T): {
    activate: (context: ExtensionContext) => T | undefined;
    deactivate: () => Promise<void>;
};

/**
 * Define a logger which is usable before activation.
 *
 * @category view
 */
export declare function defineLogger(name: string, options?: UseLoggerOptions): {
    logger: ShallowRef<    {
    outputChannel: OutputChannel;
    createLoggerFunc: (type: "info" | "warn" | "error") => (...message: any[]) => void;
    info: (...message: any[]) => void;
    warn: (...message: any[]) => void;
    error: (...message: any[]) => void;
    append: (value: string) => void;
    appendLine: (value: string) => void;
    replace: (value: string) => void;
    clear: () => void;
    show: {
    (preserveFocus?: boolean): void;
    (column?: ViewColumn, preserveFocus?: boolean): void;
    };
    hide: () => void;
    } | null, {
    outputChannel: OutputChannel;
    createLoggerFunc: (type: "info" | "warn" | "error") => (...message: any[]) => void;
    info: (...message: any[]) => void;
    warn: (...message: any[]) => void;
    error: (...message: any[]) => void;
    append: (value: string) => void;
    appendLine: (value: string) => void;
    replace: (value: string) => void;
    clear: () => void;
    show: {
    (preserveFocus?: boolean): void;
    (column?: ViewColumn, preserveFocus?: boolean): void;
    };
    hide: () => void;
    } | null>;
    outputChannel: ComputedRef<OutputChannel | undefined>;
    info: (...args: any[]) => void | null;
    warn: (...args: any[]) => void | null;
    error: (...args: any[]) => void | null;
    append: (value: string) => void | null;
    appendLine: (value: string) => void | null;
    replace: (value: string) => void | null;
    clear: () => void | null;
    show: (column?: ViewColumn | undefined, preserveFocus?: boolean | undefined) => void | null;
    hide: () => void | null;
};

/**
 * Define a service that should only be instantiated once.
 *
 * @category lifecycle
 */
export declare const defineService: typeof createSingletonComposable;

/**
 * Execute a command, with type checking. See `vscode::commands.executeCommand`.
 *
 * @category commands
 */
export declare function executeCommand<K extends Extract<keyof Commands, string>>(command: K, ...args: Parameters<Commands[K]>): Thenable<unknown>;

export declare const extensionContext: ShallowRef<ExtensionContext | null, ExtensionContext | null>;

/* Excluded from this release type: extensionScope */

export declare function getDefaultLoggerPrefix(type: string): string;

declare type LoggingType = 'info' | 'warn' | 'error';

export declare type MaybeNullableRefOrGetter<T> = T | Ref<Nullable<T>> | (() => Nullable<T>);

export declare type Nullable<T> = T | null | undefined;

/**
 * Registers a callback to be called after the extension has been activated.
 *
 * @category lifecycle
 */
export declare function onActivate(fn: OnActivateCb): void;

declare type OnActivateCb = (context: ExtensionContext) => void;

/**
 * Registers a callback to be called when the extension is deactivated.
 *
 * @category lifecycle
 */
export declare function onDeactivate(fn: OnDeactivateCb): void;

declare type OnDeactivateCb = () => Awaitable<void>;

declare type ParseConfigType<C extends ConfigTypeRaw<any>> = C extends (infer C1)[] ? (C1 extends ConfigTypeSingle<any> ? ParseConfigType<C1> : never) : C extends ConfigType<infer T> ? T : (C extends typeof String ? string : C extends typeof Number ? number : C extends typeof Boolean ? boolean : C extends typeof Array ? any[] : C extends typeof Object ? Record<string | number, any> : C extends null ? null : never);

export declare type ParseConfigTypeOptions<C extends ConfigTypeOptions> = {
    -readonly [K in keyof C]: ParseConfigType<C[K]>;
};

export declare interface QuickPickOptions<T extends QuickPickItem> {
    /**
     * Items to pick from. This can be read and updated by the extension.
     */
    items?: MaybeRefOrGetter<readonly T[]>;
    /**
     * Buttons for actions in the UI.
     */
    buttons?: MaybeRefOrGetter<readonly QuickInputButton[]>;
    /**
     * An optional title.
     */
    title?: MaybeRefOrGetter<string | undefined>;
    /**
     * An optional current step count.
     */
    step?: MaybeRefOrGetter<number | undefined>;
    /**
     * An optional total step count.
     */
    totalSteps?: MaybeRefOrGetter<number | undefined>;
    /**
     * If the UI should allow for user input. Defaults to true.
     *
     * Change this to false, e.g., while validating user input or
     * loading data for the next step in user input.
     */
    enabled?: MaybeRefOrGetter<boolean>;
    /**
     * If the UI should show a progress indicator. Defaults to false.
     *
     * Change this to true, e.g., while loading more data or validating
     * user input.
     */
    busy?: MaybeRefOrGetter<boolean>;
    /**
     * If the UI should stay open even when loosing UI focus. Defaults to false.
     * This setting is ignored on iPad and is always false.
     */
    ignoreFocusOut?: MaybeRefOrGetter<boolean>;
    /**
     * Optional placeholder shown in the filter textbox when no filter has been entered.
     */
    placeholder?: MaybeRefOrGetter<string | undefined>;
    /**
     * If multiple items can be selected at the same time. Defaults to false.
     */
    canSelectMany?: MaybeRefOrGetter<boolean>;
    /**
     * If the filter text should also be matched against the description of the items. Defaults to false.
     */
    matchOnDescription?: MaybeRefOrGetter<boolean>;
    /**
     * If the filter text should also be matched against the detail of the items. Defaults to false.
     */
    matchOnDetail?: MaybeRefOrGetter<boolean>;
    /**
     * An optional flag to maintain the scroll position of the quick pick when the quick pick items are updated. Defaults to false.
     */
    keepScrollPosition?: MaybeRefOrGetter<boolean>;
    /**
     * Initial value of the filter text.
     */
    value?: string;
    /**
     * Initial active items. This can be read and updated by the extension.
     */
    activeItems?: readonly T[];
    /**
     * Initial selected items. This can be read and updated by the extension.
     */
    selectedItems?: readonly T[];
}

export declare type TextEditorCommandCallback = (textEditor: TextEditor, edit: TextEditorEdit, ...args: any[]) => void;

declare type ToConfigRefs<C extends object> = {
    [K in keyof C]: ConfigRef<C[K]>;
};

export declare interface TreeViewNode {
    readonly children?: Awaitable<this[]>;
    readonly treeItem: TreeItem | Thenable<TreeItem>;
}

/**
 * The safe version of `vue::onScopeDispose(https://vuejs.org/api/reactivity-advanced.html#onscopedispose)`.
 *
 * @category lifecycle
 */
export declare function tryOnScopeDispose(fn: () => void): boolean;

/**
 * @category utilities
 * @reactive `ExtensionContext.asAbsolutePath`
 */
export declare function useAbsolutePath(relativePath: MaybeRefOrGetter<string>, silent: true): ComputedRef<string | undefined>;

export declare function useAbsolutePath(relativePath: MaybeRefOrGetter<string>, silent?: false): ComputedRef<string>;

/**
 * @reactive `window.activeColorTheme`
 */
export declare const useActiveColorTheme: () => ShallowRef<ColorTheme, ColorTheme>;

/**
 * @reactive `debug.activeDebugSession`
 */
export declare const useActiveDebugSession: () => ComputedRef<DebugSession | undefined>;

/**
 * Reactively set decorations on the active editor. See `vscode::window.activeTextEditor`.
 *
 * @category editor
 */
export declare function useActiveEditorDecorations(decorationTypeOrOptions: MaybeRefOrGetter<TextEditorDecorationType | DecorationRenderOptions>, decorations: MaybeRef<readonly Range[] | readonly DecorationOptions[]> | ((editor: TextEditor) => Awaitable<readonly Range[] | readonly DecorationOptions[]>), options?: UseEditorDecorationsOptions): {
    update: () => Promise<void>;
};

/**
 * @reactive `window.activeNotebookEditor`
 * @category editor
 */
export declare const useActiveNotebookEditor: () => ShallowRef<NotebookEditor | undefined, NotebookEditor | undefined>;

/**
 * @reactive `window.activeTerminal`
 * @category terminal
 */
export declare const useActiveTerminal: () => ShallowRef<Terminal | undefined, Terminal | undefined>;

/**
 * @reactive `window.activeTextEditor`
 * @category editor
 */
export declare const useActiveTextEditor: () => ShallowRef<TextEditor | undefined, TextEditor | undefined>;

/**
 * @reactive `extensions.all`
 * @category extension
 */
export declare const useAllExtensions: () => ComputedRef<readonly Extension<any>[]>;

/**
 * @reactive `chat.createChatParticipant`
 * @category chat
 */
export declare const useChatParticipant: (id: string, handler: MaybeRef<ChatRequestHandler>, options?: ChatParticipantOptions | undefined) => {
    onDidReceiveFeedback: (listener: (e: ChatResultFeedback) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
};

/**
 * Register a command. See `vscode::commands.registerCommand`.
 *
 * @category commands
 */
export declare function useCommand<K extends Extract<keyof Commands, string>>(command: K, callback: Commands[K]): void;

/**
 * Register multiple commands. See `vscode::commands.registerCommand`.
 *
 * @category commands
 */
export declare function useCommands(commands: Partial<Commands>): void;

/**
 * @reactive `comments.createCommentController`
 */
export declare function useCommentController(id: string, label: string): CommentController;

/**
 * Create terminal, and allows you to control the terminal lifecycle.
 *
 * @category terminal
 */
export declare function useControlledTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): UseControlledTerminalReturn;

export declare function useControlledTerminal(options: TerminalOptions): UseControlledTerminalReturn;

export declare function useControlledTerminal(options: ExtensionTerminalOptions): UseControlledTerminalReturn;

declare interface UseControlledTerminalReturn {
    terminal: Ref<Terminal | null>;
    getIsActive: () => boolean;
    show: () => void;
    sendText: (text: string) => void;
    close: () => void;
    state: ComputedRef<TerminalState | undefined>;
}

/**
 * @reactive `env.shell`
 */
export declare const useDefaultShell: () => ComputedRef<string>;

/**
 * Dispose the disposable when the current scope is disposed. See `vscode::Disposable`.
 *
 * @category lifecycle
 */
export declare function useDisposable<T extends Disposable_2>(disposable: T): T;

/**
 * @reactive `TextDocument.getText`
 * @category document
 */
export declare function useDocumentText(doc: MaybeRefOrGetter<TextDocument | undefined>): ShallowRef<string | undefined, string | undefined>;

/**
 * Reactively set decorations on the given editor. See `vscode::TextEditor.setDecorations`.
 *
 * @category editor
 */
export declare function useEditorDecorations(editor: MaybeRefOrGetter<Nullable<TextEditor>>, decorationTypeOrOptions: MaybeRefOrGetter<TextEditorDecorationType | DecorationRenderOptions>, decorations: MaybeRef<readonly Range[] | readonly DecorationOptions[]> | ((editor: TextEditor) => Awaitable<readonly Range[] | readonly DecorationOptions[]>), options?: UseEditorDecorationsOptions): {
    /**
     * Manually trigger the decoration update.
     */
    update: () => Promise<void>;
};

export declare interface UseEditorDecorationsOptions {
    /**
     * The triggers to update the decorations.
     *
     * @default ['effect', 'documentChanged']
     */
    updateOn?: ('effect' | 'documentChanged')[];
}

/**
 * @category utilities
 * @reactive `Event`
 */
export declare function useEvent<T>(event: Event_2<T>, listeners?: ((e: T) => any)[]): (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;

/**
 * @category utilities
 * @reactive `EventEmitter`
 */
export declare function useEventEmitter<T>(eventEmitter?: EventEmitter<T>, listeners?: ((e: T) => any)[]): UseEventEmitterReturn<T>;

export declare function useEventEmitter<T>(listeners?: ((e: T) => any)[]): UseEventEmitterReturn<T>;

declare interface UseEventEmitterReturn<T> {
    event: Event_2<T>;
    fire: (data: T) => void;
    addListener: (listener: (e: T) => any) => void;
}

/**
 * Get a reactive secret value from the extension's secrets.
 *
 * @reactive `ExtensionContext.secrets`
 * @category extension
 */
export declare function useExtensionSecret(key: string): Promise<Ref<string | undefined, string | undefined> & {
    set: (newValue: string) => Promise<void>;
    remove: () => Promise<void>;
}>;

/**
 * @reactive `tasks.fetchTasks`
 */
export declare function useFetchTasks(filter?: MaybeRefOrGetter<TaskFilter | undefined>): ComputedRef<Thenable<Task[]>>;

/**
 * @reactive `Uri.file`
 * @category utilities
 */
export declare function useFileUri(path: MaybeRefOrGetter<string>): ComputedRef<Uri>;

/**
 * @reactive `languages.registerFoldingRangeProvider`
 */
export declare function useFoldingRangeProvider(selector: DocumentSelector, provideFoldingRanges: MaybeRefOrGetter<FoldingRangeProvider['provideFoldingRanges']>): void;

export declare interface UseFSWatcher {
    readonly watchers: ShallowReactive<Map<GlobPattern, FileSystemWatcher>>;
    readonly onDidCreate: Event_2<Uri>;
    readonly onDidChange: Event_2<Uri>;
    readonly onDidDelete: Event_2<Uri>;
}

/**
 * @reactive `workspace.createFileSystemWatcher`
 */
export declare function useFsWatcher(globPattern: MaybeRefOrGetter<GlobPattern | readonly GlobPattern[] | ReadonlySet<GlobPattern>>, ignoreCreateEvents?: MaybeNullableRefOrGetter<boolean>, ignoreChangeEvents?: MaybeNullableRefOrGetter<boolean>, ignoreDeleteEvents?: MaybeNullableRefOrGetter<boolean>): UseFSWatcher;

/**
 * Determines if the current color theme is dark. See `vscode::ColorTheme.kind`.
 *
 * @category window
 */
export declare const useIsDarkTheme: () => ComputedRef<boolean>;

/**
 * @reactive `env.isTelemetryEnabled`
 */
export declare const useIsTelemetryEnabled: () => ComputedRef<boolean>;

/**
 * @reactive `l10n.t`
 */
export declare function useL10nText(message: MaybeRefOrGetter<string>, ...args: Array<MaybeRefOrGetter<string | number | boolean>>): ComputedRef<string>;

export declare function useL10nText(message: MaybeRefOrGetter<string>, args: Record<string, any>): ComputedRef<string>;

/**
 * A list of all available tools that were registered by all extensions using `vscode::lm.registerTool`.
 *
 * @reactive `lm.tools`
 * @category lm
 */
export declare const useLmTools: () => ComputedRef<readonly LanguageModelToolInformation[]>;

/**
 * Creates a logger that writes to the output channel.
 *
 * @category view
 */
export declare function useLogger(name: string, options?: UseLoggerOptions): {
    outputChannel: OutputChannel;
    createLoggerFunc: (type: LoggingType) => (...message: any[]) => void;
    info: (...message: any[]) => void;
    warn: (...message: any[]) => void;
    error: (...message: any[]) => void;
    append: (value: string) => void;
    appendLine: (value: string) => void;
    replace: (value: string) => void;
    clear: () => void;
    show: {
        (preserveFocus?: boolean): void;
        (column?: ViewColumn, preserveFocus?: boolean): void;
    };
    hide: () => void;
};

export declare interface UseLoggerOptions {
    outputChannel?: OutputChannel;
    getPrefix?: ((type: LoggingType) => string) | null;
    /**
     * @default ['error', 'warn']
     */
    toConsole?: LoggingType[];
}

/**
 * @reactive `env.logLevel`
 */
export declare const useLogLevel: () => ComputedRef<LogLevel>;

/**
 * @reactive `NotebookEditor.selection`
 * @category editor
 */
export declare function useNotebookEditorSelection(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): WritableComputedRef<NotebookRange, NotebookRange>;

/**
 * @reactive `NotebookEditor.selections`
 * @category editor
 */
export declare function useNotebookEditorSelections(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): WritableComputedRef<readonly NotebookRange[], readonly NotebookRange[]>;

/**
 * @reactive `NotebookEditor.visibleRanges`
 * @category editor
 */
export declare function useNotebookEditorVisibleRanges(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): ComputedRef<readonly NotebookRange[]>;

/**
 * @reactive `window.terminals`
 * @category terminal
 */
export declare const useOpenedTerminals: () => ShallowRef<readonly Terminal[], readonly Terminal[]>;

/**
 * @reactive `window.createOutputChannel`
 * @category view
 */
export declare function useOutputChannel(name: string, options: {
    log: true;
}): LogOutputChannel;

export declare function useOutputChannel(name: string, languageId?: string): OutputChannel;

/**
 * Creates a customizable quick pick UI.
 *
 * @reactive `window.createQuickPick`
 */
export declare function useQuickPick<T extends QuickPickItem>(options?: QuickPickOptions<T>): {
    onDidChangeActive: (listener: (e: readonly T[]) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    onDidChangeSelection: (listener: (e: readonly T[]) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    onDidAccept: (listener: (e: void) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    onDidHide: (listener: (e: void) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    onDidTriggerButton: (listener: (e: QuickInputButton) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    onDidChangeValue: (listener: (e: string) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
    value: ShallowRef<string, string>;
    activeItems: ShallowRef<readonly T[], readonly T[]>;
    selectedItems: ShallowRef<readonly T[], readonly T[]>;
    placeholder: string | undefined;
    buttons: readonly QuickInputButton[];
    onDidTriggerItemButton: Event_2<QuickPickItemButtonEvent<T>>;
    items: readonly T[];
    canSelectMany: boolean;
    matchOnDescription: boolean;
    matchOnDetail: boolean;
    keepScrollPosition?: boolean;
    title: string | undefined;
    step: number | undefined;
    totalSteps: number | undefined;
    enabled: boolean;
    busy: boolean;
    ignoreFocusOut: boolean;
    show(): void;
    hide(): void;
    dispose(): void;
};

/**
 * Set multiple reactive options on a target object.
 * @category utilities
 */
export declare function useReactiveOptions<T extends object>(target: T, options: {
    [K in keyof T]?: MaybeRefOrGetter<T[K]>;
}, keys: (keyof T)[]): void;

/**
 * @reactive `window.createStatusBarItem`
 */
export declare function useStatusBarItem(options: UseStatusBarItemOptions): StatusBarItem;

export declare interface UseStatusBarItemOptions {
    id?: string;
    alignment?: StatusBarAlignment;
    priority?: number;
    name?: MaybeRefOrGetter<StatusBarItem['name']>;
    text?: MaybeRefOrGetter<StatusBarItem['text']>;
    tooltip?: MaybeRefOrGetter<StatusBarItem['tooltip']>;
    color?: MaybeRefOrGetter<StatusBarItem['color']>;
    backgroundColor?: MaybeRefOrGetter<StatusBarItem['backgroundColor']>;
    command?: MaybeRefOrGetter<StatusBarItem['command']>;
    accessibilityInformation?: MaybeRefOrGetter<StatusBarItem['accessibilityInformation']>;
    visible?: MaybeRefOrGetter<boolean>;
}

/**
 * @reactive `tasks.taskExecutions`
 */
export declare const useTaskExecutions: () => ComputedRef<readonly TaskExecution[]>;

/**
 * @category terminal
 * @reactive `window.createTerminal()`
 */
export declare function useTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): UseTerminalReturn;

export declare function useTerminal(options: TerminalOptions): UseTerminalReturn;

export declare function useTerminal(options: ExtensionTerminalOptions): UseTerminalReturn;

declare interface UseTerminalReturn extends Omit<Terminal, 'state' | 'dispose'> {
    terminal: Terminal;
    state: ComputedRef<TerminalState>;
}

/**
 * @reactive `Terminal.state`
 * @category terminal
 */
export declare function useTerminalState(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef<TerminalState | undefined>;

/**
 * Register a text editor command. See `vscode::commands.registerTextEditorCommand`.
 *
 * @category commands
 */
export declare function useTextEditorCommand(command: string, callback: TextEditorCommandCallback): void;

/**
 * Register multiple text editor commands. See `vscode::commands.registerTextEditorCommand`.
 *
 * @category commands
 */
export declare function useTextEditorCommands(commands: Record<string, TextEditorCommandCallback>): void;

/**
 * @reactive `TextEditor.selection`
 * @category editor
 */
export declare function useTextEditorSelection(textEditor: MaybeNullableRefOrGetter<TextEditor>, acceptKind?: MaybeRefOrGetter<(TextEditorSelectionChangeKind | undefined)[]>): WritableComputedRef<Selection, Selection>;

/**
 * @reactive `TextEditor.selections`
 * @category editor
 */
export declare function useTextEditorSelections(textEditor: MaybeNullableRefOrGetter<TextEditor>, acceptKind?: MaybeRefOrGetter<(TextEditorSelectionChangeKind | undefined)[]>): WritableComputedRef<readonly Selection[], readonly Selection[]>;

/**
 * @reactive `TextEditor.viewColumn`
 * @category editor
 */
export declare function useTextEditorViewColumn(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<ViewColumn | undefined>;

/**
 * @reactive `TextEditor.visibleRanges`
 * @category editor
 */
export declare function useTextEditorVisibleRanges(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<readonly Range[]>;

/**
 * Register a tree view. See `vscode::window.createTreeView`.
 *
 * @category view
 */
export declare const useTreeView: <T extends TreeViewNode>(viewId: string, treeData: MaybeRefOrGetter<Awaitable<T[]>>, options?: UseTreeViewOptions<T> | undefined) => TreeView<T>;

export declare type UseTreeViewOptions<T> = Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'resolveTreeItem'> & {
    title?: MaybeRefOrGetter<string | undefined>;
    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
    /**
     * Additional watch source to trigger a change event. Useful when `treeItem` is a promise.
     */
    watchSource?: AnyWatchSource;
};

/**
 * Reactively set the badge of a view (`vscode::TreeView` or `vscode::WebviewView`).
 *
 * @category view
 */
export declare function useViewBadge(view: MaybeRefOrGetter<Nullable<ViewWithBadge>>, badge: MaybeRefOrGetter<ViewBadge | undefined>): void;

/**
 * Reactively set the title of a view (`vscode::TreeView` or `vscode::WebviewView`).
 *
 * @category view
 */
export declare function useViewTitle(view: MaybeRefOrGetter<Nullable<ViewWithTitle>>, title: MaybeRefOrGetter<string | undefined>): void;

/**
 * Reactively get the visibility of a view (`vscode::TreeView` or `vscode::WebviewView`).
 *
 * @category view
 */
export declare function useViewVisibility(view: MaybeNullableRefOrGetter<ViewWithVisibility>): ComputedRef<boolean>;

/**
 * @reactive `window.visibleNotebookEditors`
 * @category editor
 */
export declare const useVisibleNotebookEditors: () => ShallowRef<readonly NotebookEditor[], readonly NotebookEditor[]>;

/**
 * @reactive `window.visibleTextEditors`
 * @category editor
 */
export declare const useVisibleTextEditors: () => ShallowRef<readonly TextEditor[], readonly TextEditor[]>;

export declare function useVscodeContext<T>(name: string, value: WritableComputedRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): WritableComputedRef<T>;

export declare function useVscodeContext<T>(name: string, value: ComputedRef<T> | (() => T), shouldUpdate?: MaybeRefOrGetter<boolean>): ComputedRef<T>;

export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): Ref<T>;

/**
 * Register a webview panel. See `vscode::window.createWebviewPanel`.
 *
 * @category view
 */
export declare function useWebviewPanel(viewType: string, title: MaybeRefOrGetter<string>, html: MaybeRefOrGetter<string>, showOptions: Parameters<typeof window.createWebviewPanel>[2], options?: WebviewPanelRegisterOptions): {
    panel: WebviewPanel;
    context: ShallowRef<unknown, unknown>;
    active: Ref<boolean, boolean>;
    visible: Ref<boolean, boolean>;
    postMessage: (message: any) => Thenable<boolean>;
    forceRefresh: () => void;
};

/**
 * Register a webview view. See `vscode::window.registerWebviewViewProvider`.
 *
 * @category view
 */
export declare const useWebviewView: (viewId: string, html: MaybeRefOrGetter<string>, options?: WebviewViewRegisterOptions | undefined) => {
    view: ShallowRef<WebviewView | undefined, WebviewView | undefined>;
    context: ShallowRef<WebviewViewResolveContext<unknown> | undefined, WebviewViewResolveContext<unknown> | undefined>;
    postMessage: (message: any) => Thenable<boolean> | undefined;
    forceRefresh: () => void;
};

/**
 * @reactive `window.state`
 */
export declare const useWindowState: () => {
    focused: ComputedRef<boolean>;
    active: ComputedRef<boolean>;
};

/**
 * @reactive `workspace.workspaceFolders`
 */
export declare const useWorkspaceFolders: () => ComputedRef<readonly WorkspaceFolder[] | undefined>;

declare type ViewWithBadge = Pick<TreeView<unknown> | WebviewView, 'badge'>;

declare type ViewWithTitle = Pick<TreeView<unknown> | WebviewView, 'title'>;

declare type ViewWithVisibility = Pick<TreeView<unknown> | WebviewView, 'visible' | 'onDidChangeVisibility'>;

export declare interface WebviewPanelRegisterOptions {
    enableFindWidget?: boolean;
    retainContextWhenHidden?: boolean;
    onDidReceiveMessage?: (message: any) => void;
    webviewOptions?: MaybeRefOrGetter<WebviewOptions>;
}

export declare interface WebviewViewRegisterOptions {
    retainContextWhenHidden?: boolean;
    onDidReceiveMessage?: (message: any) => void;
    webviewOptions?: MaybeRefOrGetter<WebviewOptions>;
    title?: MaybeRefOrGetter<string | undefined>;
    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
}


export * from "@reactive-vscode/reactivity";

export { }