reactive-vscode 0.4.0 → 1.0.0-beta.1

package/dist/index.d.ts

@@ -1,161 +1,97 @@
-import { ChatFollowupProvider } from 'vscode';
+import { ChatParticipant } from 'vscode';
 import { ChatRequestHandler } from 'vscode';
-import { ChatResultFeedback } from 'vscode';
 import { ColorTheme } from 'vscode';
-import { CommentController } from 'vscode';
+import { commands } 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 { InputBoxValidationMessage } 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 { Memento } from 'vscode';
 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 { TerminalShellIntegration } 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 { Webview } from 'vscode';
 import { WebviewOptions } from 'vscode';
 import { WebviewPanel } from 'vscode';
+import { WebviewPanelOptions } from 'vscode';
 import { WebviewView } from 'vscode';
 import { WebviewViewResolveContext } from 'vscode';
 import { window } from 'vscode';
+import { WorkspaceConfiguration } 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.
+     * @see {@linkcode ChatParticipant.iconPath}
      */
-    $set: (key: keyof C, value: C[keyof C]) => void;
-};
-
-export declare interface ConfigRef<T> extends WritableComputedRef<T> {
+    iconPath?: MaybeRefOrGetter<ChatParticipant['iconPath']>;
     /**
-     * Write the configuration value to the workspace.
-     *
-     * @see https://code.visualstudio.com/api/references/vscode-api#WorkspaceConfiguration.update
+     * @see {@linkcode ChatParticipant.followupProvider}
      */
-    update: (value: T, configurationTarget?: ConfigurationTarget | boolean | null, overrideInLanguage?: boolean) => Promise<void>;
+    followupProvider?: MaybeRefOrGetter<ChatParticipant['followupProvider']>;
     /**
-     * Set the value without updating the workspace.
+     * @see {@linkcode ChatParticipant.onDidReceiveFeedback}
      */
-    set: (value: T) => void;
-}
-
-export declare interface ConfigType<T> extends ObjectConstructor {
-    [ConfigTypeSymbol]: T;
+    onDidReceiveFeedback?: EventListener_2<ChatParticipant['onDidReceiveFeedback']>;
 }
 
-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).
+ * Define configurations of an extension.
  *
+ * @see {@linkcode workspace.getConfiguration}
  * @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>;
+export declare function defineConfig<C extends object>(section: Nullable<string>, scope?: Nullable<ConfigurationScope>): C & {
+    get: WorkspaceConfiguration['get'];
+    has: WorkspaceConfiguration['has'];
+    inspect: WorkspaceConfiguration['inspect'];
+    update: WorkspaceConfiguration['update'];
+};
 
 /**
  * Define a new extension.
@@ -164,56 +100,31 @@ export declare function defineConfigs<C extends object>(section: Nullable<string
  */
 export declare function defineExtension<T>(setup: (context: ExtensionContext) => T): {
     activate: (context: ExtensionContext) => T | undefined;
-    deactivate: () => void;
+    deactivate: () => Promise<void>;
 };
 
 /**
  * Define a logger which is usable before activation.
  *
+ * @see {@linkcode window.createOutputChannel}
  * @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;
+export declare function defineLogger(name: string): {
+    trace: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (error: string | Error, ...args: 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;
+        (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;
+    logger: ComputedRef<LogOutputChannel | null>;
 };
 
 /**
@@ -221,24 +132,96 @@ export declare function defineLogger(name: string, options?: UseLoggerOptions):
  *
  * @category lifecycle
  */
-export declare const defineService: typeof createSingletonComposable;
+export declare function defineService<T>(fn: () => T): () => T;
 
-/**
- * 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>;
+declare type EventListener_2<T extends Event_2<any>> = T extends Event_2<infer U> ? (e: U) => any : never;
+export { EventListener_2 as EventListener }
 
 export declare const extensionContext: ShallowRef<ExtensionContext | null, ExtensionContext | null>;
 
 /* Excluded from this release type: extensionScope */
 
-export declare function getDefaultLoggerPrefix(type: string): string;
+export declare type ExtensionSecretRef = WritableComputedRef<string | null | undefined, string | undefined> & {
+    /**
+     * Set the secret value. Compared to directly setting the `value`, this method
+     * returns a promise that resolves when the secret has been stored.
+     */
+    set: (newValue: string) => Promise<void>;
+    /**
+     * Remove the secret value. Compared to directly setting the `value` to `undefined`,
+     * this method returns a promise that resolves when the secret has been deleted.
+     */
+    remove: () => Promise<void>;
+};
 
-declare type LoggingType = 'info' | 'warn' | 'error';
+export declare interface InputBoxProps extends QuickInputOptions {
+    /**
+     * The current input value.
+     *
+     * If provided as a ref, the value will be kept in sync with the input box's value, just like `v-model`.
+     */
+    value?: MaybeRef<string>;
+    /**
+     * Selection range in the input value.
+     *
+     * Defined as tuple of two numbers where the first is the inclusive start index and the second the
+     * exclusive end index. When `undefined` the whole pre-filled value will be selected, when empty
+     * (start equals end) only the cursor will be set, otherwise the defined range will be selected.
+     *
+     * This property does not get updated when the user types or makes a selection, but it can be updated
+     * by the extension.
+     */
+    valueSelection?: MaybeRefOrGetter<readonly [number, number] | undefined>;
+    /**
+     * Optional placeholder text shown when no value has been input.
+     */
+    placeholder?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * Determines if the input value should be hidden. Defaults to `false`.
+     */
+    password?: MaybeRefOrGetter<boolean>;
+    /**
+     * An event signaling when the value has changed.
+     */
+    onDidChangeValue?: (value: string) => void;
+    /**
+     * An event signaling when the user indicated acceptance of the input value.
+     */
+    onDidAccept?: () => void;
+    /**
+     * Buttons for actions in the UI.
+     */
+    buttons?: MaybeRefOrGetter<readonly QuickInputButton[]>;
+    /**
+     * An event signaling when a button was triggered.
+     */
+    onDidTriggerButton?: (button: QuickInputButton) => void;
+    /**
+     * An optional prompt text providing some ask or explanation to the user.
+     */
+    prompt?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * An optional validation message indicating a problem with the current input value.
+     *
+     * By setting a string, the InputBox will use a default {@link InputBoxValidationSeverity} of Error.
+     * Returning `undefined` clears the validation message.
+     */
+    validationMessage?: MaybeRefOrGetter<string | InputBoxValidationMessage | undefined>;
+}
 
-export declare type MaybeNullableRefOrGetter<T> = T | Ref<Nullable<T>> | (() => Nullable<T>);
+export declare type MaybeNullableRefOrGetter<T> = T | Ref<Nullable<T>> | ShallowRef<Nullable<T>> | WritableComputedRef<Nullable<T>> | ComputedRef<Nullable<T>> | (() => Nullable<T>);
+
+export declare type MementoItemRef<T> = WritableComputedRef<T, T | undefined> & {
+    /**
+     * Update the memento value. Compared to directly setting the `value`, this method
+     * returns a promise that resolves when the value has been stored.
+     *
+     * If `undefined` is passed, the key will be deleted from the memento.
+     *
+     * @see {@linkcode Memento.update}
+     */
+    update: (newValue: T | undefined) => Promise<void>;
+};
 
 export declare type Nullable<T> = T | null | undefined;
 
@@ -258,23 +241,9 @@ declare type OnActivateCb = (context: ExtensionContext) => void;
  */
 export declare function onDeactivate(fn: OnDeactivateCb): void;
 
-declare type OnDeactivateCb = () => 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]>;
-};
+declare type OnDeactivateCb = () => Awaitable<void>;
 
-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[]>;
+declare interface QuickInputOptions {
     /**
      * An optional title.
      */
@@ -302,14 +271,61 @@ export declare interface QuickPickOptions<T extends QuickPickItem> {
      */
     busy?: MaybeRefOrGetter<boolean>;
     /**
-     * If the UI should stay open even when loosing UI focus. Defaults to false.
+     * If the UI should stay open even when losing UI focus. Defaults to false.
      * This setting is ignored on iPad and is always false.
      */
     ignoreFocusOut?: MaybeRefOrGetter<boolean>;
+    visible?: MaybeRefOrGetter<boolean>;
+    /**
+     * An event signaling when this input UI is hidden.
+     *
+     * There are several reasons why this UI might have to be hidden and the extension will be notified
+     * through {@link QuickInput.onDidHide onDidHide}. Examples include: an explicit call to
+     * {@link QuickInput.hide hide}, the user pressing Esc, some other input UI opening, etc.
+     */
+    onDidHide?: () => void;
+}
+
+export declare interface QuickPickProps<T extends QuickPickItem> extends QuickInputOptions {
+    /**
+     * The current value of the filter text.
+     *
+     * If provided as a ref, the value will be kept in sync with the quick pick's value, just like `v-model`.
+     */
+    value?: MaybeRef<string>;
     /**
      * Optional placeholder shown in the filter textbox when no filter has been entered.
      */
     placeholder?: MaybeRefOrGetter<string | undefined>;
+    /**
+     * An event signaling when the value of the filter text has changed.
+     */
+    onDidChangeValue?: (value: string) => void;
+    /**
+     * An event signaling when the user indicated acceptance of the selected item(s).
+     */
+    onDidAccept?: () => void;
+    /**
+     * Buttons for actions in the UI.
+     */
+    buttons?: MaybeRefOrGetter<readonly QuickInputButton[]>;
+    /**
+     * An event signaling when a button was triggered.
+     *
+     * This event fires for buttons stored in the {@link QuickPick.buttons buttons} array. This event does
+     * not fire for buttons on a {@link QuickPickItem}.
+     */
+    onDidTriggerButton?: (button: QuickInputButton) => void;
+    /**
+     * An event signaling when a button in a particular {@link QuickPickItem} was triggered.
+     *
+     * This event does not fire for buttons in the title bar which are part of {@link QuickPick.buttons buttons}.
+     */
+    onDidTriggerItemButton?: (event: QuickPickItemButtonEvent<T>) => void;
+    /**
+     * Items to pick from. This can be read and updated by the extension.
+     */
+    items?: MaybeRefOrGetter<readonly T[]>;
     /**
      * If multiple items can be selected at the same time. Defaults to false.
      */
@@ -327,159 +343,152 @@ export declare interface QuickPickOptions<T extends QuickPickItem> {
      */
     keepScrollPosition?: MaybeRefOrGetter<boolean>;
     /**
-     * Initial value of the filter text.
+     * Items to pick from. This can be read and updated by the extension.
      */
-    value?: string;
+    activeItems?: MaybeRef<readonly T[]>;
     /**
-     * Initial active items. This can be read and updated by the extension.
+     * An event signaling when the active items have changed.
+     *
+     * If provided as a ref, the value will be kept in sync with the quick pick's value, just like `v-model`.
      */
-    activeItems?: readonly T[];
+    onDidChangeActive?: (items: readonly T[]) => void;
     /**
      * Initial selected items. This can be read and updated by the extension.
      */
-    selectedItems?: readonly T[];
+    selectedItems?: MaybeRef<readonly T[]>;
+    /**
+     * An event signaling when the selected items have changed.
+     *
+     * If provided as a ref, the value will be kept in sync with the quick pick's value, just like `v-model`.
+     */
+    onDidChangeSelection?: (items: readonly T[]) => void;
 }
 
-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 type TextEditorCommandCallback = Parameters<typeof commands.registerTextEditorCommand>[1];
 
 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;
+export declare type TreeViewProps<T> = Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'resolveTreeItem'> & {
+    /**
+     * @see {@linkcode TreeView.onDidExpandElement}
+     */
+    onDidExpandElement?: EventListener_2<TreeView<T>['onDidExpandElement']>;
+    /**
+     * @see {@linkcode TreeView.onDidCollapseElement}
+     */
+    onDidCollapseElement?: EventListener_2<TreeView<T>['onDidCollapseElement']>;
+    /**
+     * @see {@linkcode TreeView.onDidChangeSelection}
+     */
+    onDidChangeSelection?: EventListener_2<TreeView<T>['onDidChangeSelection']>;
+    /**
+     * @see {@linkcode TreeView.onDidChangeVisibility}
+     */
+    onDidChangeVisibility?: EventListener_2<TreeView<T>['onDidChangeVisibility']>;
+    /**
+     * @see {@linkcode TreeView.onDidChangeCheckboxState}
+     */
+    onDidChangeCheckboxState?: EventListener_2<TreeView<T>['onDidChangeCheckboxState']>;
+    /**
+     * @see {@linkcode TreeView.message}
+     */
+    message?: MaybeRefOrGetter<TreeView<T>['message']>;
+    /**
+     * @see {@linkcode TreeView.title}
+     */
+    title?: MaybeRefOrGetter<TreeView<T>['title']>;
+    /**
+     * @see {@linkcode TreeView.description}
+     */
+    description?: MaybeRefOrGetter<TreeView<T>['description']>;
+    /**
+     * @see {@linkcode TreeView.badge}
+     */
+    badge?: MaybeRefOrGetter<TreeView<T>['badge']>;
+};
 
 /**
+ * @reactive {@linkcode ExtensionContext.asAbsolutePath}
  * @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>;
+export declare function useAbsoluteUri(relativePath: MaybeRefOrGetter<string>): ComputedRef<Uri>;
 
 /**
- * @reactive `window.activeColorTheme`
+ * @reactive {@linkcode window.activeColorTheme}
  */
 export declare const useActiveColorTheme: () => ShallowRef<ColorTheme, ColorTheme>;
 
 /**
- * @reactive `debug.activeDebugSession`
+ * @reactive {@linkcode 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`
+ * @reactive {@linkcode window.activeNotebookEditor}
  * @category editor
  */
 export declare const useActiveNotebookEditor: () => ShallowRef<NotebookEditor | undefined, NotebookEditor | undefined>;
 
 /**
- * @reactive `window.activeTerminal`
+ * @reactive {@linkcode window.activeTerminal}
  * @category terminal
  */
 export declare const useActiveTerminal: () => ShallowRef<Terminal | undefined, Terminal | undefined>;
 
 /**
- * @reactive `window.activeTextEditor`
+ * @reactive {@linkcode window.activeTextEditor}
  * @category editor
  */
-export declare const useActiveTextEditor: () => ShallowRef<TextEditor | undefined, TextEditor | undefined>;
+export declare const useActiveTextEditor: () => ComputedRef<TextEditor | undefined>;
 
 /**
- * @reactive `extensions.all`
+ * @reactive {@linkcode extensions.all}
  * @category extension
  */
 export declare const useAllExtensions: () => ComputedRef<readonly Extension<any>[]>;
 
 /**
- * @reactive `chat.createChatParticipant`
+ * @reactive {@linkcode 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;
-};
+export declare function useChatParticipant(id: string, handler: MaybeRef<ChatRequestHandler>, options?: ChatParticipantOptions): ChatParticipant;
 
 /**
- * Register a command. See `vscode::commands.registerCommand`.
- *
+ * @reactive {@linkcode commands.registerCommand}
  * @category commands
  */
-export declare function useCommand<K extends Extract<keyof Commands, string>>(command: K, callback: Commands[K]): void;
+export declare function useCommand(command: string, callback: MaybeRef<Nullable<(...args: any[]) => any>>): void;
 
 /**
- * Register multiple commands. See `vscode::commands.registerCommand`.
- *
+ * @reactive {@linkcode commands.registerCommand}
  * @category commands
  */
-export declare function useCommands(commands: Partial<Commands>): void;
-
-/**
- * @reactive `comments.createCommentController`
- */
-export declare function useCommentController(id: string, label: string): CommentController;
+export declare function useCommands(commands: Record<string, MaybeRef<Nullable<(...args: any[]) => any>>>): void;
 
 /**
- * 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`.
+ * Dispose the disposable when the current scope is disposed.
  *
+ * @see {@linkcode Disposable}
  * @category lifecycle
  */
 export declare function useDisposable<T extends Disposable_2>(disposable: T): T;
 
 /**
- * @reactive `TextDocument.getText`
+ * @reactive {@linkcode TextDocument.getText}
  * @category document
  */
-export declare function useDocumentText(doc: MaybeRefOrGetter<TextDocument | undefined>): ShallowRef<string | undefined, string | undefined>;
+export declare function useDocumentText(doc: MaybeNullableRefOrGetter<TextDocument>): ShallowRef<string | undefined, string | undefined>;
 
 /**
- * Reactively set decorations on the given editor. See `vscode::TextEditor.setDecorations`.
+ * Reactively set decorations on the given editor.
  *
+ * @see {@linkcode 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): {
+export declare function useEditorDecorations(editor: MaybeNullableRefOrGetter<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.
      */
@@ -490,190 +499,231 @@ export declare interface UseEditorDecorationsOptions {
     /**
      * The triggers to update the decorations.
      *
-     * @default ['effect', 'documentChanged']
+     * @default true
+     */
+    watchDocumentChange?: boolean;
+    /**
+     * Immediately trigger an update.
+     *
+     * @default true
      */
-    updateOn?: ('effect' | 'documentChanged')[];
+    immediate?: boolean;
 }
 
+/**
+ * @reactive {@linkcode env.shell}
+ */
+export declare const useEnvShell: () => ComputedRef<string>;
+
 /**
  * @category utilities
- * @reactive `Event`
+ * @reactive {@linkcode Event}
  */
-export declare function useEvent<T>(event: Event_2<T>, listeners?: ((e: T) => any)[]): (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable_2[]) => void;
+export declare function useEvent<T>(event: Event_2<T>, listeners?: ((e: T) => any)[]): Event_2<T>;
 
 /**
  * @category utilities
- * @reactive `EventEmitter`
+ * @reactive {@linkcode 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>;
+export declare function useEventEmitter<T>(listeners: ((e: T) => any)[]): UseEventEmitterReturn<T>;
 
 declare interface UseEventEmitterReturn<T> {
+    emitter: EventEmitter<T>;
     event: Event_2<T>;
-    fire: (data: T) => void;
-    addListener: (listener: (e: T) => any) => void;
+    fire: EventEmitter<T>['fire'];
 }
 
 /**
  * Get a reactive secret value from the extension's secrets.
  *
- * @reactive `ExtensionContext.secrets`
+ * - `null` indicates that the value has not been loaded yet.
+ * - `undefined` indicates that there is no value stored for the given key.
+ *
+ * @reactive {@linkcode 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>;
+export declare function useExtensionSecret(key: string): ExtensionSecretRef;
+
+/**
+ * @reactive {@linkcode workspace.createFileSystemWatcher}
+ */
+export declare function useFileSystemWatcher(globPatterns: MaybeRefOrGetter<GlobPattern | readonly GlobPattern[] | ReadonlySet<GlobPattern>>, handlers?: {
+    onDidCreate?: false | ((ev: Uri) => void);
+    onDidChange?: false | ((ev: Uri) => void);
+    onDidDelete?: false | ((ev: Uri) => void);
+}): {
+    watchers: ReadonlyMap<string | {
+        readonly baseUri: {
+            readonly scheme: string;
+            readonly authority: string;
+            readonly path: string;
+            readonly query: string;
+            readonly fragment: string;
+            readonly fsPath: string;
+            readonly with: (change: {
+                scheme?: string;
+                authority?: string;
+                path?: string;
+                query?: string;
+                fragment?: string;
+            }) => Uri;
+            readonly toString: (skipEncoding?: boolean) => string;
+            readonly toJSON: () => any;
+        };
+        readonly base: string;
+        readonly pattern: string;
+    }, {
+        readonly ignoreCreateEvents: boolean;
+        readonly ignoreChangeEvents: boolean;
+        readonly ignoreDeleteEvents: boolean;
+        readonly onDidCreate: Event_2<Uri>;
+        readonly onDidChange: Event_2<Uri>;
+        readonly onDidDelete: Event_2<Uri>;
+        readonly dispose: () => any;
+    }>;
+    /**
+     * @see {@link FileSystemWatcher.onDidCreate}
+     */
+    onDidCreate: Event_2<Uri>;
+    /**
+     * @see {@link FileSystemWatcher.onDidChange}
+     */
+    onDidChange: Event_2<Uri>;
+    /**
+     * @see {@link FileSystemWatcher.onDidDelete}
+     */
+    onDidDelete: Event_2<Uri>;
+};
 
 /**
- * @reactive `languages.registerFoldingRangeProvider`
+ * @reactive {@linkcode ExtensionContext.globalState}
+ * @category extension
  */
-export declare function useFoldingRangeProvider(selector: DocumentSelector, provideFoldingRanges: MaybeRefOrGetter<FoldingRangeProvider['provideFoldingRanges']>): void;
+export declare function useGlobalState<T>(key: string): MementoItemRef<T>;
 
-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>;
-}
+export declare function useGlobalState<T>(key: string, defaultValue: T): Ref<T>;
 
 /**
- * @reactive `workspace.createFileSystemWatcher`
+ * @reactive {@linkcode window.createInputBox}
  */
-export declare function useFsWatcher(globPattern: MaybeRefOrGetter<GlobPattern | readonly GlobPattern[] | ReadonlySet<GlobPattern>>, ignoreCreateEvents?: MaybeNullableRefOrGetter<boolean>, ignoreChangeEvents?: MaybeNullableRefOrGetter<boolean>, ignoreDeleteEvents?: MaybeNullableRefOrGetter<boolean>): UseFSWatcher;
+export declare function useInputBox(options?: InputBoxProps): {
+    /**
+     * @see {@linkcode InputBox.value}
+     */
+    value: Ref<string, string> | ShallowRef<string, string> | WritableComputedRef<string, string>;
+    valueSelection: readonly [number, number] | undefined;
+    placeholder: string | undefined;
+    password: boolean;
+    onDidChangeValue: Event_2<string>;
+    onDidAccept: Event_2<void>;
+    buttons: readonly QuickInputButton[];
+    onDidTriggerButton: Event_2<QuickInputButton>;
+    prompt: string | undefined;
+    validationMessage: string | InputBoxValidationMessage | undefined;
+    title: string | undefined;
+    step: number | undefined;
+    totalSteps: number | undefined;
+    enabled: boolean;
+    busy: boolean;
+    ignoreFocusOut: boolean;
+    show(): void;
+    hide(): void;
+    onDidHide: Event_2<void>;
+    dispose(): void;
+};
 
 /**
- * Determines if the current color theme is dark. See `vscode::ColorTheme.kind`.
+ * Determines if the current color theme is dark.
  *
+ * @see {@linkcode ColorTheme.kind}
  * @category window
  */
 export declare const useIsDarkTheme: () => ComputedRef<boolean>;
 
 /**
- * @reactive `env.isTelemetryEnabled`
+ * @reactive {@linkcode env.isTelemetryEnabled}
  */
 export declare const useIsTelemetryEnabled: () => ComputedRef<boolean>;
 
 /**
- * @reactive `l10n.t`
+ * @reactive {@linkcode 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: MaybeRefOrGetter<string | number | boolean>[]): ComputedRef<string>;
 
-export declare function useL10nText(message: MaybeRefOrGetter<string>, args: Record<string, any>): ComputedRef<string>;
+export declare function useL10nText(message: MaybeRefOrGetter<string>, args: MaybeRefOrGetter<Record<string, any>>): ComputedRef<string>;
 
 /**
- * A list of all available tools that were registered by all extensions using `vscode::lm.registerTool`.
- *
- * @reactive `lm.tools`
+ * @reactive {@linkcode lm.tools}
  * @category lm
  */
 export declare const useLmTools: () => ComputedRef<readonly LanguageModelToolInformation[]>;
 
 /**
- * Creates a logger that writes to the output channel.
- *
- * @category view
+ * @reactive {@linkcode env.logLevel}
  */
-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 const useLogLevel: () => ComputedRef<LogLevel>;
 
-export declare interface UseLoggerOptions {
-    outputChannel?: OutputChannel;
-    getPrefix?: ((type: LoggingType) => string) | null;
-    /**
-     * @default ['error', 'warn']
-     */
-    toConsole?: LoggingType[];
-}
+/* Excluded declaration from this release type: useMementoItem */
 
-/**
- * @reactive `env.logLevel`
- */
-export declare const useLogLevel: () => ComputedRef<LogLevel>;
+export declare function useMementoItem<T>(memento: Memento, key: string, defaultValue: T): MementoItemRef<T>;
 
 /**
- * @reactive `NotebookEditor.selection`
+ * @reactive {@linkcode NotebookEditor.selection}
  * @category editor
  */
-export declare function useNotebookEditorSelection(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): WritableComputedRef<NotebookRange, NotebookRange>;
+export declare function useNotebookEditorSelection(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): WritableComputedRef<NotebookRange | undefined, NotebookRange | undefined>;
 
 /**
- * @reactive `NotebookEditor.selections`
+ * @reactive {@linkcode NotebookEditor.selections}
  * @category editor
  */
 export declare function useNotebookEditorSelections(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): WritableComputedRef<readonly NotebookRange[], readonly NotebookRange[]>;
 
 /**
- * @reactive `NotebookEditor.visibleRanges`
+ * @reactive {@linkcode NotebookEditor.visibleRanges}
  * @category editor
  */
 export declare function useNotebookEditorVisibleRanges(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): ComputedRef<readonly NotebookRange[]>;
 
 /**
- * @reactive `window.terminals`
+ * @reactive {@linkcode 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[]>;
+ * @reactive {@linkcode window.createQuickPick}
+ */
+export declare function useQuickPick<T extends QuickPickItem>(options?: QuickPickProps<T>): {
+    /**
+     * @see {@linkcode QuickPick.value}
+     */
+    value: Ref<string, string> | ShallowRef<string, string> | WritableComputedRef<string, string>;
+    /**
+     * @see {@linkcode QuickPick.activeItems}
+     */
+    activeItems: Ref<readonly T[], readonly T[]> | ShallowRef<readonly T[], readonly T[]> | WritableComputedRef<readonly T[], readonly T[]>;
+    /**
+     * @see {@linkcode QuickPick.selectedItems}
+     */
+    selectedItems: Ref<readonly T[], readonly T[]> | ShallowRef<readonly T[], readonly T[]> | WritableComputedRef<readonly T[], readonly T[]>;
     placeholder: string | undefined;
+    onDidChangeValue: Event_2<string>;
+    onDidAccept: Event_2<void>;
     buttons: readonly QuickInputButton[];
+    onDidTriggerButton: Event_2<QuickInputButton>;
     onDidTriggerItemButton: Event_2<QuickPickItemButtonEvent<T>>;
     items: readonly T[];
     canSelectMany: boolean;
     matchOnDescription: boolean;
     matchOnDetail: boolean;
     keepScrollPosition?: boolean;
+    onDidChangeActive: Event_2<readonly T[]>;
+    onDidChangeSelection: Event_2<readonly T[]>;
     title: string | undefined;
     step: number | undefined;
     totalSteps: number | undefined;
@@ -682,19 +732,14 @@ export declare function useQuickPick<T extends QuickPickItem>(options?: QuickPic
     ignoreFocusOut: boolean;
     show(): void;
     hide(): void;
+    onDidHide: Event_2<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;
+/* Excluded from this release type: useReactiveOptions */
 
 /**
- * @reactive `window.createStatusBarItem`
+ * @reactive {@linkcode window.createStatusBarItem}
  */
 export declare function useStatusBarItem(options: UseStatusBarItemOptions): StatusBarItem;
 
@@ -702,24 +747,48 @@ export declare interface UseStatusBarItemOptions {
     id?: string;
     alignment?: StatusBarAlignment;
     priority?: number;
+    /**
+     * @see {@linkcode StatusBarItem.name}
+     */
     name?: MaybeRefOrGetter<StatusBarItem['name']>;
+    /**
+     * @see {@linkcode StatusBarItem.text}
+     */
     text?: MaybeRefOrGetter<StatusBarItem['text']>;
+    /**
+     * @see {@linkcode StatusBarItem.tooltip}
+     */
     tooltip?: MaybeRefOrGetter<StatusBarItem['tooltip']>;
+    /**
+     * @see {@linkcode StatusBarItem.color}
+     */
     color?: MaybeRefOrGetter<StatusBarItem['color']>;
+    /**
+     * @see {@linkcode StatusBarItem.backgroundColor}
+     */
     backgroundColor?: MaybeRefOrGetter<StatusBarItem['backgroundColor']>;
+    /**
+     * @see {@linkcode StatusBarItem.command}
+     */
     command?: MaybeRefOrGetter<StatusBarItem['command']>;
+    /**
+     * @see {@linkcode StatusBarItem.accessibilityInformation}
+     */
     accessibilityInformation?: MaybeRefOrGetter<StatusBarItem['accessibilityInformation']>;
+    /**
+     * Whether the status bar item is visible
+     */
     visible?: MaybeRefOrGetter<boolean>;
 }
 
 /**
- * @reactive `tasks.taskExecutions`
+ * @reactive {@linkcode tasks.taskExecutions}
  */
 export declare const useTaskExecutions: () => ComputedRef<readonly TaskExecution[]>;
 
 /**
  * @category terminal
- * @reactive `window.createTerminal()`
+ * @reactive {@linkcode window.createTerminal}
  */
 export declare function useTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): UseTerminalReturn;
 
@@ -727,138 +796,208 @@ export declare function useTerminal(options: TerminalOptions): UseTerminalReturn
 
 export declare function useTerminal(options: ExtensionTerminalOptions): UseTerminalReturn;
 
-declare interface UseTerminalReturn extends Omit<Terminal, 'state' | 'dispose'> {
+declare interface UseTerminalReturn extends Pick<Terminal, 'sendText' | 'show' | 'hide' | 'dispose'> {
     terminal: Terminal;
+    /**
+     * @see {@linkcode Terminal.state}
+     */
     state: ComputedRef<TerminalState>;
+    /**
+     * @see {@linkcode Terminal.shellIntegration}
+     */
+    shellIntegration: ComputedRef<TerminalShellIntegration>;
 }
 
 /**
- * @reactive `Terminal.state`
+ * @reactive {@linkcode Terminal.shellIntegration}
  * @category terminal
  */
+export declare function useTerminalShellIntegration(terminal: MaybeRefOrGetter<Terminal>): ComputedRef<TerminalShellIntegration>;
+
+export declare function useTerminalShellIntegration(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef<TerminalShellIntegration | undefined>;
+
+/**
+ * @reactive {@linkcode Terminal.state}
+ * @category terminal
+ */
+export declare function useTerminalState(terminal: MaybeRefOrGetter<Terminal>): ComputedRef<TerminalState>;
+
 export declare function useTerminalState(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef<TerminalState | undefined>;
 
 /**
- * Register a text editor command. See `vscode::commands.registerTextEditorCommand`.
- *
+ * @reactive {@linkcode commands.registerTextEditorCommand}
  * @category commands
  */
-export declare function useTextEditorCommand(command: string, callback: TextEditorCommandCallback): void;
+export declare function useTextEditorCommand(command: string, callback: MaybeRef<Nullable<TextEditorCommandCallback>>): void;
 
 /**
- * Register multiple text editor commands. See `vscode::commands.registerTextEditorCommand`.
- *
+ * @reactive {@linkcode commands.registerTextEditorCommand}
  * @category commands
  */
-export declare function useTextEditorCommands(commands: Record<string, TextEditorCommandCallback>): void;
+export declare function useTextEditorCommands(commands: Record<string, MaybeRef<Nullable<TextEditorCommandCallback>>>): void;
 
 /**
- * @reactive `TextEditor.selection`
+ * @reactive {@linkcode TextEditor.selection}
  * @category editor
  */
-export declare function useTextEditorSelection(textEditor: MaybeNullableRefOrGetter<TextEditor>, acceptKind?: MaybeRefOrGetter<(TextEditorSelectionChangeKind | undefined)[]>): WritableComputedRef<Selection, Selection>;
+export declare function useTextEditorSelection(textEditor: MaybeNullableRefOrGetter<TextEditor>, acceptKind?: MaybeRefOrGetter<(TextEditorSelectionChangeKind | undefined)[]>): WritableComputedRef<Selection | undefined, Selection | undefined>;
 
 /**
- * @reactive `TextEditor.selections`
+ * @reactive {@linkcode TextEditor.selections}
  * @category editor
  */
 export declare function useTextEditorSelections(textEditor: MaybeNullableRefOrGetter<TextEditor>, acceptKind?: MaybeRefOrGetter<(TextEditorSelectionChangeKind | undefined)[]>): WritableComputedRef<readonly Selection[], readonly Selection[]>;
 
 /**
- * @reactive `TextEditor.viewColumn`
+ * @reactive {@linkcode TextEditor.viewColumn}
  * @category editor
  */
 export declare function useTextEditorViewColumn(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<ViewColumn | undefined>;
 
 /**
- * @reactive `TextEditor.visibleRanges`
+ * @reactive {@linkcode TextEditor.visibleRanges}
  * @category editor
  */
 export declare function useTextEditorVisibleRanges(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<readonly Range[]>;
 
 /**
- * Register a tree view. See `vscode::window.createTreeView`.
- *
+ * @reactive {@linkcode 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>;
+export declare function useTreeView<T extends TreeViewNode>(viewId: string, treeData: MaybeRefOrGetter<Awaitable<T[]>>, options?: TreeViewProps<T>): {
+    view: TreeView<T>;
+    /**
+     * @see {@linkcode TreeView.selection}
+     */
+    selection: ShallowRef<readonly T[], readonly T[]>;
+    /**
+     * @see {@linkcode TreeView.visible}
+     */
+    visible: ComputedRef<boolean>;
     /**
-     * Additional watch source to trigger a change event. Useful when `treeItem` is a promise.
+     * @see {@linkcode TreeView.reveal}
      */
-    watchSource?: AnyWatchSource;
+    reveal: (element: T, options?: {
+        readonly select?: boolean;
+        readonly focus?: boolean;
+        readonly expand?: boolean | number;
+    }) => Thenable<void>;
 };
 
 /**
- * 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`).
- *
+ * @reactive {@linkcode TreeView.visible}, {@linkcode WebviewView.visible}
  * @category view
  */
 export declare function useViewVisibility(view: MaybeNullableRefOrGetter<ViewWithVisibility>): ComputedRef<boolean>;
 
 /**
- * @reactive `window.visibleNotebookEditors`
+ * @reactive {@linkcode window.visibleNotebookEditors}
  * @category editor
  */
-export declare const useVisibleNotebookEditors: () => ShallowRef<readonly NotebookEditor[], readonly NotebookEditor[]>;
+export declare const useVisibleNotebookEditors: () => ComputedRef<readonly NotebookEditor[]>;
 
 /**
- * @reactive `window.visibleTextEditors`
+ * @reactive {@linkcode window.visibleTextEditors}
  * @category editor
  */
-export declare const useVisibleTextEditors: () => ShallowRef<readonly TextEditor[], readonly TextEditor[]>;
+export declare const useVisibleTextEditors: () => ComputedRef<readonly TextEditor[]>;
 
-export declare function useVscodeContext<T>(name: string, value: WritableComputedRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): WritableComputedRef<T>;
+/**
+ * Reactively set a VS Code context. See [custom when clause context](https://code.visualstudio.com/api/references/when-clause-contexts#add-a-custom-when-clause-context).
+ *
+ * @category lifecycle
+ */
+export declare function useVscodeContext<T>(name: string, value: WritableComputedRef<T>): 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: ComputedRef<T> | (() => T)): ComputedRef<T>;
 
-export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): Ref<T>;
+export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>): Ref<T>;
 
 /**
- * Register a webview panel. See `vscode::window.createWebviewPanel`.
- *
+ * @reactive {@linkcode window.createWebviewPanel}
  * @category view
  */
-export declare function useWebviewPanel(viewType: string, title: MaybeRefOrGetter<string>, html: MaybeRefOrGetter<string>, showOptions: Parameters<typeof window.createWebviewPanel>[2], options?: WebviewPanelRegisterOptions): {
+export declare function useWebviewPanel(viewType: string, title: MaybeRefOrGetter<string>, html: MaybeRefOrGetter<string>, showOptions: Parameters<typeof window.createWebviewPanel>[2], options?: WebviewPanelProps): {
     panel: WebviewPanel;
-    context: ShallowRef<unknown, unknown>;
-    active: Ref<boolean, boolean>;
-    visible: Ref<boolean, boolean>;
+    webview: Webview;
+    /**
+     * @see {@linkcode WebviewPanel.viewColumn}
+     */
+    viewColumn: ComputedRef<ViewColumn | undefined>;
+    /**
+     * @see {@linkcode WebviewPanel.active}
+     */
+    active: ComputedRef<boolean>;
+    /**
+     * @see {@linkcode WebviewPanel.visible}
+     */
+    visible: ComputedRef<boolean>;
+    /**
+     * @see {@linkcode WebviewPanel.reveal}
+     */
+    reveal: (viewColumn?: ViewColumn, preserveFocus?: boolean) => void;
+    /**
+     * @see {@linkcode Webview.postMessage}
+     */
     postMessage: (message: any) => Thenable<boolean>;
-    forceRefresh: () => void;
+    /**
+     * @see {@linkcode Webview.asWebviewUri}
+     */
+    asWebviewUri: (localResource: Uri) => Uri;
+    /**
+     * Force reload the webview content.
+     */
+    forceReload: () => void;
 };
 
 /**
- * Register a webview view. See `vscode::window.registerWebviewViewProvider`.
- *
+ * @reactive {@linkcode 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>;
+export declare function useWebviewView(viewId: string, html: MaybeRefOrGetter<string>, options?: WebviewViewProps): {
+    view: ComputedRef<WebviewView | undefined>;
+    /**
+     * @see {@linkcode WebviewView.webview}
+     */
+    webview: ComputedRef<Webview | undefined>;
+    /**
+     * Additional metadata about the view being resolved.
+     */
+    context: ComputedRef<WebviewViewResolveContext<unknown> | undefined>;
+    /**
+     * @see {@linkcode WebviewView.visible}
+     */
+    visible: ComputedRef<boolean>;
+    /**
+     * @see {@linkcode WebviewView.show}
+     */
+    show: (preserveFocus?: boolean) => void | undefined;
+    /**
+     * @see {@linkcode Webview.postMessage}
+     */
     postMessage: (message: any) => Thenable<boolean> | undefined;
-    forceRefresh: () => void;
+    /**
+     * @see {@linkcode Webview.asWebviewUri}
+     */
+    asWebviewUri: (resource: Uri) => Uri | undefined;
+    /**
+     * Force reload the webview content.
+     */
+    forceReload: () => void;
 };
 
 /**
- * @reactive `window.state`
+ * @reactive {@linkcode window.state.active}
+ */
+export declare const useWindowActive: () => ComputedRef<boolean>;
+
+/**
+ * @reactive {@linkcode window.state.focused}
+ */
+export declare const useWindowFocused: () => ComputedRef<boolean>;
+
+/**
+ * @reactive {@linkcode window.state}
  */
 export declare const useWindowState: () => {
     focused: ComputedRef<boolean>;
@@ -866,29 +1005,74 @@ export declare const useWindowState: () => {
 };
 
 /**
- * @reactive `workspace.workspaceFolders`
+ * @reactive {@linkcode workspace.workspaceFolders}
  */
 export declare const useWorkspaceFolders: () => ComputedRef<readonly WorkspaceFolder[] | undefined>;
 
-declare type ViewWithBadge = Pick<TreeView<unknown> | WebviewView, 'badge'>;
+/**
+ * @reactive {@linkcode ExtensionContext.workspaceState}
+ * @category extension
+ */
+export declare function useWorkspaceState<T>(key: string): MementoItemRef<T>;
 
-declare type ViewWithTitle = Pick<TreeView<unknown> | WebviewView, 'title'>;
+export declare function useWorkspaceState<T>(key: string, defaultValue: T): Ref<T>;
 
 declare type ViewWithVisibility = Pick<TreeView<unknown> | WebviewView, 'visible' | 'onDidChangeVisibility'>;
 
-export declare interface WebviewPanelRegisterOptions {
-    enableFindWidget?: boolean;
-    retainContextWhenHidden?: boolean;
-    onDidReceiveMessage?: (message: any) => void;
+declare type WebviewCreationOptions = (Parameters<typeof window.registerWebviewViewProvider>[2] & {})['webviewOptions'] & {};
+
+export declare interface WebviewPanelProps extends WebviewPanelOptions, WebviewOptions {
+    /**
+     * @see {@linkcode WebviewPanel.title}
+     */
+    title?: MaybeRefOrGetter<WebviewPanel['title']>;
+    /**
+     * @see {@linkcode WebviewPanel.iconPath}
+     */
+    iconPath?: MaybeRefOrGetter<WebviewPanel['iconPath']>;
+    /**
+     * @see {@linkcode WebviewPanel.onDidChangeViewState}
+     */
+    onDidChangeViewState?: EventListener_2<WebviewPanel['onDidChangeViewState']>;
+    /**
+     * @see {@linkcode WebviewPanel.onDidDispose}
+     */
+    onDidDispose?: EventListener_2<WebviewPanel['onDidDispose']>;
+    /**
+     * @see {@linkcode Webview.options}
+     */
     webviewOptions?: MaybeRefOrGetter<WebviewOptions>;
+    /**
+     * @see {@linkcode Webview.onDidReceiveMessage}
+     */
+    onDidReceiveMessage?: EventListener_2<Webview['onDidReceiveMessage']>;
 }
 
-export declare interface WebviewViewRegisterOptions {
-    retainContextWhenHidden?: boolean;
-    onDidReceiveMessage?: (message: any) => void;
+export declare interface WebviewViewProps extends WebviewCreationOptions {
+    /**
+     * @see {@linkcode WebviewView.title}
+     */
+    title?: MaybeRefOrGetter<WebviewView['title']>;
+    /**
+     * @see {@linkcode WebviewView.description}
+     */
+    description?: MaybeRefOrGetter<WebviewView['description']>;
+    /**
+     * @see {@linkcode WebviewView.badge}
+     */
+    badge?: MaybeRefOrGetter<WebviewView['badge']>;
+    /**
+     * @see {@linkcode WebviewViewOptions.onDidDispose}
+     */
+    onDidDispose?: EventListener_2<WebviewView['onDidDispose']>;
+    /**
+     * @see {@linkcode Webview.options}
+     */
     webviewOptions?: MaybeRefOrGetter<WebviewOptions>;
-    title?: MaybeRefOrGetter<string | undefined>;
-    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
+    /**
+     * @see {@linkcode Webview.onDidReceiveMessage}
+     */
+    onDidReceiveMessage?: EventListener_2<Webview['onDidReceiveMessage']>;
 }