@pstdio/workbench 0.1.0

package/dist/react.d.ts

@@ -0,0 +1,2020 @@
+import { BoxProps } from '@chakra-ui/react';
+import { ComponentType } from 'react';
+import { Context } from 'react';
+import { FileIconThemePreferenceOption as FileIconThemePreferenceOption_2 } from '@pstdio/ui';
+import { IconProps } from '@chakra-ui/react';
+import { JSX } from 'react/jsx-runtime';
+import { JSXElementConstructor } from 'react';
+import { ListRowActionMenuItem } from '@pstdio/ui';
+import { Param } from '@pstdio/ui';
+import { ParamEditorProps } from '@pstdio/ui';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { TerminalBridge } from '@pstdio/ui/terminal';
+import { ThemePreference as ThemePreference_3 } from '@pstdio/ui';
+import { ThemePreferenceOption as ThemePreferenceOption_3 } from '@pstdio/ui';
+
+declare interface AttributeDescriptor {
+    id: string;
+    label: string;
+    type: AttributeType;
+    filterable?: boolean;
+    groupable?: boolean;
+    sortable?: boolean;
+    displayable?: boolean;
+    editable?: boolean;
+    display?: AttributeDisplayDescriptor;
+    render?: (value: unknown, row: DataRendererRow) => ReactNode;
+    compare?: (a: unknown, b: unknown) => number;
+}
+
+declare type AttributeDisplayDescriptor = {
+    kind: "workspace-badge";
+    itemsAttributeId: string;
+};
+
+/**
+ * Reactive source for an entire attribute schema. Lets a contribution
+ * add/remove/edit attributes at runtime without re-registering.
+ */
+declare interface AttributesSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => AttributeDescriptor[];
+}
+
+declare type AttributeType = {
+    kind: "enum";
+    options: EnumOptions;
+} | {
+    kind: "enum-multi";
+    options: EnumOptions;
+} | {
+    kind: "string";
+} | {
+    kind: "date";
+} | {
+    kind: "number";
+} | {
+    kind: "user";
+};
+
+declare interface BoardColumnAction {
+    id: string;
+    label: string;
+    icon: ComponentType<{
+        size?: number | string;
+    }>;
+}
+
+/** Board-column behavior and menu configuration for a resolved column group. */
+declare interface BoardColumnConfig {
+    /** Color palette token used for the column header and group badges. */
+    color?: string;
+    canDragIn?: boolean;
+    canDragOut?: boolean;
+    canCreate?: boolean;
+    actions?: BoardColumnAction[];
+}
+
+export declare const buildSettingsTreeBody: (input: BuildSettingsTreeInput) => Promise<TreeViewSection[]>;
+
+export declare interface BuildSettingsTreeInput {
+    settings: SettingsRegistry;
+    hasProjectScope: boolean;
+}
+
+/**
+ * A data-driven list of items, each opening a contributor-supplied editor. The
+ * framework knows nothing about what an item is — it only calls these hooks.
+ */
+declare interface CollectionSettingsPanel<TItem = unknown> extends SettingsPanelBase {
+    kind: "collection";
+    items(): TItem[] | Promise<TItem[]>;
+    itemId(item: TItem): string;
+    itemLabel(item: TItem): string;
+    itemIcon?(item: TItem): string | undefined;
+    groupBy?: SettingsCollectionGroupBy<TItem>;
+    renderItem(item: TItem, input: WorkbenchWidgetRenderInput): unknown;
+    actions?: SettingsAction[];
+}
+
+declare interface Command {
+    id: string;
+    label: string;
+    category?: string;
+    description?: string;
+    icon?: string;
+    when?: string;
+    params?: CommandParamSchema;
+}
+
+declare interface CommandHandler<TArgs = unknown, TResult = unknown> {
+    execute(args: TArgs, context?: WorkbenchCommandExecutionContext): TResult | Promise<TResult>;
+    isEnabled?(args: TArgs): boolean;
+    isVisible?(args: TArgs): boolean;
+    isToggled?(args: TArgs): boolean;
+}
+
+declare interface CommandPaletteResourceProvider {
+    id: string;
+    title: string;
+    refreshEventIds?: string[];
+    query(context: CommandPaletteResourceQueryContext): Promise<readonly CommandPaletteResourceResult[]>;
+}
+
+declare interface CommandPaletteResourceProviderResult {
+    providerId: string;
+    title: string;
+    results: readonly CommandPaletteResourceResult[];
+}
+
+declare interface CommandPaletteResourceQueryContext {
+    query: string;
+    limit: number;
+}
+
+declare interface CommandPaletteResourceRegistry {
+    store: WorkbenchStore<CommandPaletteResourceRegistryStoreState>;
+    registerProvider(provider: CommandPaletteResourceProvider): Disposable_2;
+    listProviders(): CommandPaletteResourceProvider[];
+    queryProviders(context: CommandPaletteResourceQueryContext): Promise<CommandPaletteResourceProviderResult[]>;
+    refresh(): void;
+}
+
+declare interface CommandPaletteResourceRegistryStoreState {
+    providers: Record<string, CommandPaletteResourceProvider>;
+    refreshToken: number;
+}
+
+declare interface CommandPaletteResourceResult {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    keywords?: string[];
+    group?: string;
+    activate(): void | Promise<void>;
+}
+
+declare interface CommandParamDescriptor {
+    type: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: unknown;
+    options?: CommandParamOption[];
+    templateType?: string;
+    resourceType?: string;
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface CommandParamEntry extends CommandParamDescriptor {
+    key: string;
+    label: string;
+}
+
+export declare interface CommandParamFieldProps {
+    entry: CommandParamEntry;
+    value: CommandParamValue;
+    context?: WorkbenchCommandExecutionContext;
+    disabled: boolean;
+    onChange: (value: CommandParamValue) => void;
+}
+
+export declare type CommandParamFieldRenderer = (props: CommandParamFieldProps) => ReactNode;
+
+declare interface CommandParamOption {
+    label: string;
+    value: string;
+}
+
+declare type CommandParamSchema = Record<string, CommandParamDescriptor>;
+
+declare interface CommandParamsRequest {
+    record: {
+        command: Pick<Command, "id" | "label" | "description" | "params">;
+    };
+    action?: RegisteredMenuItem;
+    label: string;
+    submitLabel?: string;
+    args?: unknown;
+    context?: WorkbenchCommandExecutionContext;
+}
+
+export declare type CommandParamValue = string | boolean | string[] | undefined;
+
+declare interface CommandRegistry {
+    store: WorkbenchStore<CommandRegistryStoreState>;
+    registerCommand<TArgs = unknown, TResult = unknown>(command: Command, handler: CommandHandler<TArgs, TResult>, metadata?: ContributionMetadata): Disposable_2;
+    getCommand(id: string): RegisteredCommand | undefined;
+    listCommands(): RegisteredCommand[];
+    isCommandEnabled(id: string, args?: unknown): boolean;
+    isCommandVisible(id: string, args?: unknown): boolean;
+    isCommandToggled(id: string, args?: unknown): boolean;
+    executeCommand(id: string, args?: unknown, context?: WorkbenchCommandExecutionContext): Promise<unknown>;
+    onDidExecuteError(listener: WorkbenchCommandExecutionErrorListener): Disposable_2;
+}
+
+declare interface CommandRegistryStoreState {
+    commands: Record<string, RegisteredCommand>;
+}
+
+declare interface ContextKeyScope extends Disposable_2 {
+    ownerId: string;
+    set(key: string, value: ContextKeyValue): void;
+    get(key: string): ContextKeyValue;
+    delete(key: string): void;
+}
+
+declare interface ContextKeyService {
+    store: WorkbenchStore<ContextKeyStoreState>;
+    set(key: string, value: ContextKeyValue): void;
+    get(key: string): ContextKeyValue;
+    delete(key: string): void;
+    createScope(ownerId: string): ContextKeyScope;
+    deleteOwner(ownerId: string): void;
+    snapshot(): Record<string, ContextKeyValue>;
+    matches(expression?: string): boolean;
+}
+
+declare interface ContextKeyStoreState {
+    values: Record<string, ContextKeyValue>;
+}
+
+declare type ContextKeyValue = boolean | number | string | undefined;
+
+declare interface ContributionMetadata {
+    source?: ContributionSource;
+    ownerId?: string;
+    priority?: number;
+}
+
+declare type ContributionSource = "module" | "extension";
+
+declare type ContributionSource_2 = "module" | "extension";
+
+declare interface ControllerTerminalBridgeOptions {
+    getResource?: () => ResourceRef | undefined;
+    getTitle?: () => string | undefined;
+}
+
+declare interface ControlsApplyInput {
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
+}
+
+declare interface ControlsQueryResult {
+    params?: unknown[];
+    groups?: unknown[];
+    values?: Record<string, unknown>;
+    readOnly?: boolean;
+}
+
+declare type ControlsRendererArea = "main-right" | "secondary" | "overlay";
+
+declare interface ControlsRendererContribution {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    layout?: ControlsRendererLayout;
+    defaultValues?: Record<string, unknown>;
+    /** Load the control declarations + current values for the active resource. */
+    executeQuery(resource?: ResourceRef): Promise<ControlsQueryResult> | ControlsQueryResult;
+    /** Live-save a single control edit. Omit for explicit-apply or read-only panels. */
+    updateValue?(input: ControlsUpdateValueInput): Promise<void> | void;
+    /** Commit the full value map from a sticky footer. */
+    apply?(input: ControlsApplyInput): Promise<void> | void;
+    /** Reset some or all controls to their defaults. */
+    reset?(input: ControlsResetInput): Promise<void> | void;
+    subscribe?: (listener: () => void) => Disposable_2 | (() => void);
+}
+
+declare type ControlsRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    controlsRendererId: string;
+}) => unknown;
+
+declare interface ControlsRendererLayout {
+    area?: ControlsRendererArea;
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface ControlsRendererRefreshEvent {
+    controlsRendererId: string;
+}
+
+declare type ControlsRendererRefreshListener = (event: ControlsRendererRefreshEvent) => void;
+
+declare interface ControlsRendererRegistry {
+    controlsStore: WorkbenchStore<ControlsRendererStoreState>;
+    registerControlsRenderer(contribution: ControlsRendererContribution, metadata?: ContributionMetadata): Disposable_2;
+    setControlsRendererImplementation(impl: ControlsRendererImplementation): void;
+    getControlsRenderer(id: string): RegisteredControlsRendererContribution | undefined;
+    listControlsRenderers(): RegisteredControlsRendererContribution[];
+    refreshControlsRenderer(id: string): void;
+    onDidRefreshControlsRenderer(listener: ControlsRendererRefreshListener): Disposable_2;
+}
+
+declare interface ControlsRendererStoreState {
+    renderers: Record<string, RegisteredControlsRendererContribution>;
+}
+
+declare interface ControlsResetInput {
+    controlIds?: string[];
+    resource?: ResourceRef;
+}
+
+declare interface ControlsUpdateValueInput {
+    controlId: string;
+    value: unknown;
+    values: Record<string, unknown>;
+    resource?: ResourceRef;
+}
+
+export declare const createControllerTerminalBridge: (terminal: WorkbenchTerminalController, options?: ControllerTerminalBridgeOptions) => TerminalBridge;
+
+export declare const createTreeContextMenuItems: (input: CreateTreeContextMenuItemsInput) => ListRowActionMenuItem[];
+
+declare interface CreateTreeContextMenuItemsInput {
+    actions?: TreeAction[];
+    menuPath?: MenuPath;
+    workbench: WorkbenchCoreContributionContext;
+    context?: WorkbenchCommandExecutionContext;
+    onCommandError?: (error: unknown) => void;
+    onRequestParams?: (request: TreeActionParamsRequest) => void;
+}
+
+export declare const createWorkbenchHotkeyRegistrations: (input: CreateWorkbenchHotkeyRegistrationsInput) => {
+    commandId: string;
+    hotkey: KeybindingSequence;
+    enabled: boolean;
+    ignoreInputs: true;
+    execute: () => Promise<unknown>;
+}[];
+
+declare interface CreateWorkbenchHotkeyRegistrationsInput {
+    workbench: WorkbenchCore;
+    disabled?: boolean;
+    commandIds?: readonly string[];
+}
+
+export declare const createWorkbenchRendererRegistry: (input?: CreateWorkbenchRendererRegistryInput) => WorkbenchRendererRegistry;
+
+declare interface CreateWorkbenchRendererRegistryInput {
+    initialRenderers?: WorkbenchRendererRegistration[];
+    createHost?: () => HTMLElement;
+}
+
+export declare const createWorkbenchSettingsModule: (options?: WorkbenchSettingsModuleOptions) => WorkbenchModuleContribution;
+
+/**
+ * Host-owned terminal surface: tabbed placements in the `secondary` area whose
+ * chrome, focus, lifecycle, and styling belong to the workbench. Sessions are
+ * owned by `workbench.terminal` (the same registry the `terminal.session`
+ * webview capability uses); the host injects a session opener via
+ * `workbench.terminal.setSessionOpener(...)`. Closing a tab kills its session;
+ * disposing the controller kills every live session.
+ */
+export declare const createWorkbenchTerminalModule: () => WorkbenchModuleContribution;
+
+/**
+ * Renders its own page. `render` returns `unknown` so core stays React-free — the
+ * React layer treats the result as a node, exactly like WorkbenchRendererRegistration.
+ */
+declare interface CustomSettingsPanel extends SettingsPanelBase {
+    kind: "custom";
+    render(input: WorkbenchWidgetRenderInput): unknown;
+}
+
+declare interface DataRendererContribution<TRow extends DataRendererRow = DataRendererRow> {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    /**
+     * Declarative attribute schema. The renderer dispatches filter / group /
+     * sort / display / inline-edit behavior on each descriptor's `type.kind`.
+     *
+     * Pass an `AttributesSource` ({ subscribe, getSnapshot }) instead of a
+     * static array to let the contribution mutate its schema at runtime —
+     * `WorkbenchDataView` subscribes so additions / removals / kind changes
+     * propagate live without re-registering the renderer.
+     */
+    attributes: AttributeDescriptor[] | AttributesSource;
+    /** Per-board-column overrides (color, drag/create rules, custom actions). */
+    getBoardColumnConfig?: (groupKey: string) => BoardColumnConfig;
+    hideToolbar?: boolean;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** Initial settings/filters applied when the data renderer mounts. */
+    defaultSettings?: Partial<DataRendererSettings>;
+    defaultFilters?: DataRendererFilterState;
+    /**
+     * Data source. Receives the current display state so backends can paginate
+     * / filter / sort. The renderer re-applies filter / sort / group locally,
+     * so this can return unfiltered rows in simple cases.
+     */
+    executeQuery(state: DataRendererQueryState): Promise<TRow[]> | TRow[];
+    subscribe?: (listener: () => void) => Disposable_2 | (() => void);
+    /** Row interactions surfaced by the renderer (mirrored from <DataRenderer>). */
+    onRowClick?: (row: TRow) => void;
+    /** Per-row right-click context menu actions (mirrored from <DataRenderer>). */
+    getRowContextMenuActions?: (row: TRow) => ResourceContextAction[];
+    /**
+     * Fires for inline attribute edits AND for cross-column drag-to-reorder on
+     * the board (the renderer passes the grouping attribute id + the target
+     * column value).
+     */
+    onAttributeChange?: (rowId: string, attributeId: string, value: unknown) => Promise<void> | void;
+    /** Manual within-column reorder (only fires when ordering is manual). */
+    onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
+    onCreateRow?: (columnId: string) => void;
+    onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
+}
+
+declare type DataRendererFilterState = Record<string, string[]>;
+
+declare type DataRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    dataRendererId: string;
+}) => unknown;
+
+declare interface DataRendererOrdering {
+    attributeId: string | typeof MANUAL_ORDERING;
+    direction: SortDirection;
+}
+
+declare interface DataRendererQueryState {
+    settings: DataRendererSettings;
+    filters: DataRendererFilterState;
+}
+
+declare interface DataRendererRefreshEvent {
+    dataRendererId: string;
+}
+
+declare type DataRendererRefreshListener = (event: DataRendererRefreshEvent) => void;
+
+declare interface DataRendererRegistry {
+    dataStore: WorkbenchStore<DataRendererStoreState>;
+    registerDataRenderer<TRow extends DataRendererRow = DataRendererRow>(contribution: DataRendererContribution<TRow>, metadata?: ContributionMetadata): Disposable_2;
+    setDataRendererImplementation(impl: DataRendererImplementation): void;
+    getDataRenderer(id: string): RegisteredDataRendererContribution | undefined;
+    listDataRenderers(): RegisteredDataRendererContribution[];
+    refreshDataRenderer(id: string): void;
+    onDidRefreshDataRenderer(listener: DataRendererRefreshListener): Disposable_2;
+}
+
+declare interface DataRendererRow {
+    id: string;
+    title: string;
+    /**
+     * Optional navigation handle. When set, the renderer's default click handler
+     * routes through the contribution's onRowClick (which typically opens the
+     * resource via the workbench).
+     */
+    resource?: unknown;
+    attributes: Record<string, unknown>;
+}
+
+declare interface DataRendererSettings {
+    viewMode: ViewMode;
+    columnGrouping: string | typeof NO_GROUPING;
+    rowGrouping: string | typeof NO_GROUPING;
+    ordering: DataRendererOrdering;
+    displayProperties: string[];
+}
+
+declare interface DataRendererStoreState {
+    renderers: Record<string, RegisteredDataRendererContribution>;
+}
+
+declare interface Disposable_2 {
+    dispose(): void;
+}
+
+export declare const disposeWorkbenchModuleHostRegistrations: (registrations: Map<string, WorkbenchModuleHostRegistration>) => void;
+
+declare interface EnumOption {
+    value: string;
+    label: string;
+    color?: string;
+    icon?: string | null;
+}
+
+declare type EnumOptions = EnumOption[] | EnumOptionsSource;
+
+/**
+ * Reactive options source for enum / enum-multi attributes. Mirrors React's
+ * useSyncExternalStore contract so a contribution can hand its options off as
+ * a live collection instead of a frozen array.
+ */
+declare interface EnumOptionsSource {
+    subscribe: (listener: () => void) => () => void;
+    getSnapshot: () => EnumOption[];
+}
+
+/**
+ * Core-owned contract for file icon theme registrations. Structurally identical
+ * to @pstdio/ui's FileIconThemePreferenceOption; the React layer bridges the two
+ * so core does not depend on UI package ownership.
+ */
+declare interface FileIconThemeFont {
+    fontFamily: string;
+    src: {
+        url: string;
+        format?: string;
+    }[];
+    weight?: string;
+    style?: string;
+}
+
+declare interface FileIconThemePreferenceOption {
+    id: string;
+    title?: string;
+    definitions: Record<string, unknown>;
+    fileExtensions: Record<string, string>;
+    fileNames: Record<string, string>;
+    defaults: {
+        file?: string;
+        folder?: string;
+    };
+    fonts: FileIconThemeFont[];
+}
+
+declare interface FileIconThemeRegistry {
+    store: WorkbenchStore<WorkbenchFileIconThemeStoreState>;
+    register(themes: readonly FileIconThemePreferenceOption[]): Disposable_2;
+    listThemes(): readonly FileIconThemePreferenceOption[];
+}
+
+declare interface FileRendererContent {
+    fileName?: string;
+    mimeType?: string;
+    content?: string;
+    dataUrl?: string;
+    placeholder?: string;
+}
+
+declare interface FileRendererContribution {
+    id: string;
+    title: string;
+    resourceKind?: string;
+    /** Resolve the file's content (and identity) for the bound resource. */
+    load(resource: ResourceRef | undefined): Promise<FileRendererContent> | FileRendererContent;
+    /** Persist edited text. Absent ⇒ read-only. Never called for images. */
+    save?(resource: ResourceRef | undefined, content: string): Promise<void> | void;
+}
+
+declare type FileRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    fileRendererId: string;
+}) => unknown;
+
+declare interface FileRendererRefreshEvent {
+    fileRendererId: string;
+}
+
+declare type FileRendererRefreshListener = (event: FileRendererRefreshEvent) => void;
+
+declare interface FileRendererRegistry {
+    fileRendererStore: WorkbenchStore<FileRendererStoreState>;
+    registerFileRenderer(contribution: FileRendererContribution, metadata?: ContributionMetadata): Disposable_2;
+    setFileRendererImplementation(impl: FileRendererImplementation): void;
+    getFileRenderer(id: string): RegisteredFileRendererContribution | undefined;
+    listFileRenderers(): RegisteredFileRendererContribution[];
+    refreshFileRenderer(id: string): void;
+    onDidRefreshFileRenderer(listener: FileRendererRefreshListener): Disposable_2;
+}
+
+declare interface FileRendererStoreState {
+    renderers: Record<string, RegisteredFileRendererContribution>;
+}
+
+declare interface HistoryController {
+    store: WorkbenchStore<HistoryStoreState>;
+    goBack(): HistoryEntry | undefined;
+    goForward(): HistoryEntry | undefined;
+    goPrevious(): HistoryEntry | undefined;
+    recentlyClosed(): readonly HistoryEntry[];
+    reopenLastClosed(): HistoryEntry | undefined;
+    clear(): void;
+}
+
+declare interface HistoryEntry {
+    entryId: string;
+    recordedAt: number;
+    kind: "resource" | "widget" | "mode";
+    modeId?: string;
+    resource?: ResourceRef;
+    widgetId?: string;
+    contributionId?: string;
+    title?: string;
+}
+
+declare interface HistoryStoreState {
+    entries: readonly HistoryEntry[];
+    cursor: number;
+    recentlyClosed: readonly HistoryEntry[];
+}
+
+export declare const isSettingsScopeVisible: (scope: SettingsScope | undefined, hasProjectScope: boolean) => boolean;
+
+declare interface Keybinding {
+    commandId: string;
+    keybinding: KeybindingSequence;
+    when?: string;
+    args?: unknown;
+}
+
+declare interface KeybindingRegistry {
+    store: WorkbenchStore<KeybindingRegistryStoreState>;
+    registerKeybinding(keybinding: Keybinding, metadata?: ContributionMetadata): Disposable_2;
+    listKeybindings(): RegisteredKeybinding[];
+    listActiveKeybindings(): RegisteredKeybinding[];
+}
+
+declare interface KeybindingRegistryStoreState {
+    keybindings: RegisteredKeybinding[];
+}
+
+declare type KeybindingSequence = string | string[];
+
+declare interface LayoutModel {
+    store: WorkbenchStore<WorkbenchLayoutStoreState>;
+    registerPlaceholder(placeholder: PlaceholderContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    registerWidget(widget: WidgetContribution, metadata?: ContributionMetadata): {
+        dispose(): void;
+    };
+    unregisterWidget(id: string, options?: {
+        removePlacements?: boolean;
+        persist?: boolean;
+    }): void;
+    getPlaceholder(areaId: WorkbenchArea_2): RegisteredPlaceholderContribution | undefined;
+    getWidget(id: string): RegisteredWidgetContribution | undefined;
+    getAreaSize(areaId: WorkbenchArea_2): WorkbenchAreaSize | undefined;
+    getAreaCollapsible(areaId: WorkbenchArea_2): boolean;
+    getAreaHeaderBorderBottom(areaId: WorkbenchArea_2): boolean;
+    setAreaVisible(areaId: WorkbenchArea_2, visible: boolean): void;
+    setAreaSize(areaId: WorkbenchArea_2, size: number): void;
+    listPlaceholders(): RegisteredPlaceholderContribution[];
+    listWidgets(): RegisteredWidgetContribution[];
+    openWidget(id: string, input?: OpenWidgetInput): WorkbenchWidgetPlacement;
+    updateWidgetPlacement(widgetId: string, input: OpenWidgetInput): WorkbenchWidgetPlacement;
+    activateWidget(widgetId: string): WorkbenchWidgetPlacement;
+    closeWidget(widgetId: string): WorkbenchWidgetPlacement | undefined;
+    removeWidgetPlacement(widgetId: string): WorkbenchWidgetPlacement | undefined;
+    clearArea(areaId: WorkbenchArea_2): void;
+    resetAreas(): void;
+    getLayout(): WorkbenchLayout;
+    restoreLayout(layout: WorkbenchLayout): void;
+    setPersistenceScope(scope: LayoutScope | undefined): void;
+    getPersistenceScope(): LayoutScope | undefined;
+    onDidChangePersistenceScope(listener: (scope: LayoutScope | undefined) => void): {
+        dispose(): void;
+    };
+}
+
+declare type LayoutScope = string;
+
+export declare const listWorkbenchMenuItems: (workbench: WorkbenchCore, menuPath: MenuPath, context?: WorkbenchMenuItemContext) => WorkbenchMenuItem[];
+
+declare const MANUAL_ORDERING = "manual";
+
+declare interface MenuItem {
+    commandId: string;
+    label?: string;
+    description?: string;
+    icon?: string;
+    iconSrc?: string;
+    overflowLabel?: string;
+    when?: string;
+    group?: string;
+    order?: number;
+    args?: unknown;
+    readOnly?: boolean;
+    /** Marks a menu action that navigates outside the app, rendered with a trailing external-link icon. */
+    external?: boolean;
+}
+
+declare type MenuPath = readonly string[];
+
+declare interface MenuRegistry {
+    menuStore: WorkbenchStore<MenuRegistryStoreState>;
+    registerMenuItem(path: MenuPath, item: MenuItem, metadata?: ContributionMetadata): Disposable_2;
+    listMenuItems(path: MenuPath): RegisteredMenuItem[];
+}
+
+declare interface MenuRegistryStoreState {
+    itemsByPath: Record<string, RegisteredMenuItem[]>;
+}
+
+declare interface NavigationParser {
+    id: string;
+    priority?: number;
+    canParse(location: string): boolean;
+    parse(location: string): NavigationTarget;
+}
+
+declare interface NavigationRegistry {
+    store: WorkbenchStore<NavigationRegistryStoreState>;
+    registerParser(parser: NavigationParser, metadata?: ContributionMetadata): Disposable_2;
+    listParsers(): RegisteredNavigationParser[];
+    resolveLocation(location: string): NavigationTarget;
+    openTarget(target: NavigationTarget): Promise<readonly unknown[]>;
+    navigate(location: string): Promise<readonly unknown[]>;
+    registerNavigator(navigator: ResourceNavigator, metadata?: ContributionMetadata): Disposable_2;
+    listNavigators(): RegisteredResourceNavigator[];
+    createHref(resource: ResourceRef): string;
+    navigateResource(resource: ResourceRef): Promise<unknown>;
+}
+
+declare interface NavigationRegistryStoreState {
+    parsers: Record<string, RegisteredNavigationParser>;
+    navigators: Record<string, RegisteredResourceNavigator>;
+}
+
+declare type NavigationTarget = NavigationTargetItem | NavigationTargetCompound;
+
+declare interface NavigationTargetCommand {
+    kind: "command";
+    commandId: string;
+    args?: unknown;
+}
+
+declare interface NavigationTargetCompound {
+    kind: "compound";
+    targets: readonly NavigationTargetItem[];
+}
+
+declare type NavigationTargetItem = NavigationTargetResource | NavigationTargetView | NavigationTargetCommand;
+
+declare interface NavigationTargetResource {
+    kind: "resource";
+    resource: ResourceRef;
+    input?: OpenResourceInput;
+}
+
+declare interface NavigationTargetView {
+    kind: "view";
+    widgetId: string;
+    input?: OpenWidgetInput;
+}
+
+declare const NO_GROUPING = "none";
+
+export declare const normalizeWorkbenchKeybinding: (keybinding: KeybindingSequence) => KeybindingSequence;
+
+declare interface NotificationRegistry {
+    store: WorkbenchStore<WorkbenchNotificationStoreState>;
+    show(notification: WorkbenchNotification, metadata?: ContributionMetadata): RegisteredWorkbenchNotification;
+    dismiss(id: string): boolean;
+    clear(): void;
+    listNotifications(): RegisteredWorkbenchNotification[];
+    subscribe(listener: WorkbenchNotificationListener): Disposable_2;
+}
+
+declare interface OpenResourceInput {
+    replaceActive?: boolean;
+}
+
+declare interface OpenWidgetInput {
+    resource?: ResourceRef;
+    title?: string;
+    area?: WorkbenchArea_2;
+    ownerId?: string;
+    source?: ContributionSource;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+    replaceActive?: boolean;
+}
+
+export declare const openWorkbenchTerminal: (ctx: WorkbenchCoreContributionContext, input?: OpenWorkbenchTerminalInput) => WorkbenchWidgetPlacement_2;
+
+declare type OpenWorkbenchTerminalInput = NonNullable<Parameters<WorkbenchCoreContributionContext["layout"]["openWidget"]>[1]>;
+
+declare type ParamValue = Parameters<NonNullable<ParamEditorProps["onChange"]>>[1];
+
+export declare const paramValueToPreference: (schema: PreferencePropertySchema, value: ParamValue) => PreferenceValue;
+
+declare interface PlaceholderContribution {
+    id: string;
+    title: string;
+    area: WorkbenchArea_2;
+    rendererId: string;
+    areaSize?: WorkbenchAreaSize;
+    areaCollapsible?: boolean;
+    config?: unknown;
+    priority?: number;
+}
+
+export declare interface PreferenceParamEntry {
+    name: string;
+    schema: PreferencePropertySchema;
+    label?: string;
+    /** Current value; falls back to the schema default when omitted. */
+    value?: PreferenceValue;
+}
+
+declare interface PreferencePropertySchema {
+    type: "boolean" | "number" | "string" | "array" | "object";
+    enum?: PreferenceValue[];
+    default?: PreferenceValue;
+    scope: PreferenceScope;
+    description?: string;
+}
+
+declare interface PreferenceRegistry {
+    store: WorkbenchStore<PreferenceRegistryStoreState>;
+    registerSchema(schema: PreferenceSchemaContribution, metadata?: ContributionMetadata): Disposable_2;
+    getSchema(name: string): RegisteredPreferenceSchema | undefined;
+    setValue(name: string, value: PreferenceValue, scope: PreferenceScopeRef): void;
+    getValue(name: string, scope?: PreferenceScopeRef): PreferenceValue | undefined;
+}
+
+declare interface PreferenceRegistryStoreState {
+    schemas: Record<string, RegisteredPreferenceSchema>;
+}
+
+declare interface PreferenceSchemaContribution {
+    properties: Record<string, PreferencePropertySchema>;
+}
+
+export declare const preferenceSchemaToParams: (entries: PreferenceParamEntry[]) => Param[];
+
+declare type PreferenceScope = "default" | "user" | "project" | "repo" | "workspace" | "extension" | "session";
+
+declare interface PreferenceScopeRef {
+    scope: PreferenceScope;
+    scopeId?: string;
+}
+
+declare type PreferenceValue = boolean | number | string | string[] | number[] | boolean[] | Record<string, unknown>;
+
+declare interface RegisteredCommand extends RegisteredContributionMetadata {
+    command: Command;
+    handler: CommandHandler;
+}
+
+declare interface RegisteredContributionMetadata {
+    source: ContributionSource;
+    ownerId: string;
+    priority: number;
+}
+
+declare interface RegisteredControlsRendererContribution extends ControlsRendererContribution, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredDataRendererContribution<TRow extends DataRendererRow = DataRendererRow> extends DataRendererContribution<TRow>, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredFileRendererContribution extends FileRendererContribution, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredKeepAliveHost {
+    rendererId: string;
+    host: HTMLElement;
+    attachedTo?: HTMLElement;
+}
+
+declare interface RegisteredKeybinding extends Keybinding, RegisteredContributionMetadata {
+}
+
+declare interface RegisteredMenuItem extends MenuItem, RegisteredContributionMetadata {
+    path: MenuPath;
+}
+
+declare type RegisteredNavigationParser = Omit<NavigationParser, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredPlaceholderContribution = Omit<PlaceholderContribution, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredPreferenceSchema = PreferencePropertySchema & {
+    ownerId: string;
+    source: string;
+};
+
+declare interface RegisteredResourceKind extends ResourceKindContribution, RegisteredContributionMetadata {
+}
+
+declare type RegisteredResourceNavigator = Omit<ResourceNavigator, "priority"> & RegisteredContributionMetadata;
+
+declare type RegisteredSettingsPanel = SettingsPanelContribution & RegisteredContributionMetadata;
+
+declare type RegisteredSettingsSection = SettingsSectionContribution & RegisteredContributionMetadata;
+
+declare interface RegisteredTreeRendererContribution extends TreeRendererContribution, RegisteredContributionMetadata {
+}
+
+declare type RegisteredWidgetContribution = Omit<WidgetContribution, "priority" | "singleton" | "reuse"> & {
+    singleton: boolean;
+    reuse: WidgetReusePolicy;
+} & RegisteredContributionMetadata;
+
+declare interface RegisteredWorkbenchNotification extends RegisteredContributionMetadata {
+    id: string;
+    level: WorkbenchNotificationLevel;
+    title: string;
+    message?: string;
+    createdAt: string;
+    resource?: ResourceRef;
+    actions?: WorkbenchNotificationAction[];
+    metadata?: Record<string, unknown>;
+}
+
+declare type ResolvedResourceOpener = Required<ResourceOpener>;
+
+declare interface ResourceBrowseEntry {
+    resource: ResourceRef;
+    searchText?: string;
+    description?: string;
+    group?: string;
+    order?: number;
+    activate?: (resource: ResourceRef) => unknown | Promise<unknown>;
+}
+
+/** Row-level context menu action surfaced by the renderer. */
+declare interface ResourceContextAction {
+    key: string;
+    label: string;
+    onClick: () => Promise<void> | void;
+    isDisabled?: boolean;
+    icon?: ReactNode;
+    endContent?: ReactNode;
+    separatorBefore?: boolean;
+}
+
+declare interface ResourceKindContribution {
+    kind: string;
+    label: string;
+    icon?: string;
+    surface?: ResourceSurface;
+    paletteOpenInput?: OpenResourceInput;
+}
+
+declare interface ResourceListContext {
+    primary?: ResourceRef;
+}
+
+declare interface ResourceNavigator<TResult = unknown> {
+    id: string;
+    priority?: number;
+    canNavigate(resource: ResourceRef): boolean;
+    createHref?(resource: ResourceRef): string;
+    navigate(resource: ResourceRef): TResult | Promise<TResult>;
+}
+
+declare interface ResourceOpener<TResult = unknown> {
+    id: string;
+    priority?: number;
+    canOpen(resource: ResourceRef): boolean;
+    open(resource: ResourceRef, input: OpenResourceInput): TResult | Promise<TResult>;
+}
+
+declare interface ResourceProvider {
+    id: string;
+    kind: string;
+    list(query: string, context: ResourceListContext): readonly ResourceBrowseEntry[];
+}
+
+declare interface ResourceRef {
+    kind: string;
+    uri: string;
+    id?: string;
+    label?: string;
+    icon?: string;
+    metadata?: Record<string, unknown>;
+}
+
+declare interface ResourceRef_2 {
+    kind: string;
+    uri: string;
+    id?: string;
+    label?: string;
+    icon?: string;
+    metadata?: Record<string, unknown>;
+}
+
+declare interface ResourceRegistry {
+    store: WorkbenchStore<ResourceRegistryStoreState>;
+    registerKind(kind: ResourceKindContribution, metadata?: ContributionMetadata): Disposable_2;
+    getKind(kind: string): RegisteredResourceKind | undefined;
+    getSurface(resource: ResourceRef): ResourceSurface | undefined;
+    listKinds(): RegisteredResourceKind[];
+    registerOpener(opener: ResourceOpener): Disposable_2;
+    listOpeners(): ResolvedResourceOpener[];
+    registerProvider(provider: ResourceProvider): Disposable_2;
+    listProviders(): ResourceProvider[];
+    listResources(query: string): readonly ResourceBrowseEntry[];
+    openResource(resource: ResourceRef, input?: OpenResourceInput): Promise<unknown>;
+    onDidOpenResource(listener: (resource: ResourceRef) => void): Disposable_2;
+}
+
+declare interface ResourceRegistryStoreState {
+    kinds: Record<string, RegisteredResourceKind>;
+    openers: Record<string, ResolvedResourceOpener>;
+    providers: Record<string, ResourceProvider>;
+}
+
+declare type ResourceSurface = "primary" | "secondary" | "attached";
+
+/** Auto-rendered as a param editor from the registered preference schema. */
+declare interface SchemaSettingsPanel extends SettingsPanelBase {
+    kind: "schema";
+    preferences: SettingsPanelPreference[];
+    /** "live" persists on change (default); "apply" stages edits behind Save/Discard. */
+    save?: "live" | "apply";
+}
+
+export declare const SETTINGS_RESOURCE_KIND = "workbench-settings";
+
+/** A "+ create"-style action surfaced on a section or a collection's parent node. */
+declare interface SettingsAction {
+    id: string;
+    label: string;
+    icon?: string;
+    run(): void | Promise<void>;
+}
+
+declare interface SettingsCollectionGroupBy<TItem> {
+    key(item: TItem): string;
+    order?: string[];
+    label(key: string): string;
+    icon?(key: string): string | undefined;
+}
+
+export declare const settingsItemResource: (panelId: string, item: {
+    id: string;
+    label: string;
+    icon?: string;
+}) => ResourceRef;
+
+declare interface SettingsPanelBase {
+    id: string;
+    title: string;
+    description?: string;
+    /** Section id this panel belongs to. */
+    section?: string;
+    icon?: string;
+    /** Lower sorts first; ties fall back to contribution priority then registration order. */
+    order?: number;
+    scope?: SettingsScope;
+    when?: string;
+}
+
+declare type SettingsPanelContribution = SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel;
+
+/** A preference this panel edits; a bare string uses the preference name as its label. */
+declare type SettingsPanelPreference = string | {
+    name: string;
+    label?: string;
+};
+
+export declare const settingsPanelResource: (panel: {
+    id: string;
+    title: string;
+    icon?: string;
+}) => ResourceRef;
+
+declare interface SettingsRegistry {
+    store: WorkbenchStore<SettingsRegistryStoreState>;
+    registerSection(section: SettingsSectionContribution, metadata?: ContributionMetadata): Disposable_2;
+    registerPanel<TItem = unknown>(panel: SchemaSettingsPanel | CustomSettingsPanel | CollectionSettingsPanel<TItem>, metadata?: ContributionMetadata): Disposable_2;
+    getSection(id: string): RegisteredSettingsSection | undefined;
+    getPanel(id: string): RegisteredSettingsPanel | undefined;
+    listSections(): RegisteredSettingsSection[];
+    listPanels(): RegisteredSettingsPanel[];
+    /** Signal that a collection's backing data changed so the surface refreshes. */
+    refresh(): void;
+}
+
+declare interface SettingsRegistryStoreState {
+    sections: Record<string, RegisteredSettingsSection>;
+    panels: Record<string, RegisteredSettingsPanel>;
+    /** Bumped by refresh() so the surface re-reads collection items() after backing data changes. */
+    revision: number;
+}
+
+/** Settings are stored either per-user (global) or per-project. Projectless surfaces show only global entries. */
+declare type SettingsScope = "global" | "project";
+
+/** An ordered sidebar container. Headerless when `title` is omitted. */
+declare interface SettingsSectionContribution {
+    id: string;
+    title?: string;
+    order?: number;
+    scope?: SettingsScope;
+    actions?: SettingsAction[];
+}
+
+declare type SortDirection = "asc" | "desc";
+
+export declare const syncWorkbenchModuleHostRegistrations: (workbench: WorkbenchCore, registrations: Map<string, WorkbenchModuleHostRegistration>, modules: readonly WorkbenchModuleContribution[]) => void;
+
+/**
+ * Core-owned contract for theme registrations. Structurally identical to
+ * @pstdio/ui's ThemePreferenceOption; the React layer bridges the two so core
+ * does not depend on UI package ownership.
+ */
+declare type ThemePreference = string;
+
+/**
+ * Core-owned contract for theme registrations. Structurally identical to
+ * @pstdio/ui's ThemePreferenceOption; the React layer bridges the two so core
+ * does not depend on UI package ownership.
+ */
+declare type ThemePreference_2 = string;
+
+declare type ThemePreferenceMode = "light" | "dark";
+
+declare type ThemePreferenceMode_2 = "light" | "dark";
+
+declare interface ThemePreferenceOption {
+    id: ThemePreference;
+    title?: string;
+    mode: ThemePreferenceMode;
+    tokens?: ThemePreferenceTokens;
+    monacoTheme?: unknown;
+}
+
+declare interface ThemePreferenceOption_2 {
+    id: ThemePreference_2;
+    title?: string;
+    mode: ThemePreferenceMode_2;
+    tokens?: ThemePreferenceTokens_2;
+    monacoTheme?: unknown;
+}
+
+declare type ThemePreferenceTokens = Record<string, string>;
+
+declare type ThemePreferenceTokens_2 = Record<string, string>;
+
+declare interface ThemeRegistry {
+    store: WorkbenchStore<WorkbenchThemeStoreState>;
+    register(themes: readonly ThemePreferenceOption[]): Disposable_2;
+    listThemes(): readonly ThemePreferenceOption[];
+}
+
+declare interface TreeAction {
+    id: string;
+    label?: string;
+    icon?: string;
+    commandId?: string;
+    args?: unknown;
+    params?: CommandParamSchema;
+    submitLabel?: string;
+    when?: string;
+    disabled?: boolean;
+    run?(args?: unknown): Promise<void> | void;
+}
+
+export declare interface TreeActionParamsRequest {
+    request: CommandParamsRequest;
+    run: (args: unknown) => Promise<void>;
+}
+
+declare interface TreeContext {
+    filter?: string;
+    resource?: ResourceRef;
+    /** Widget/view contribution id for trees rendered through a view-backed widget. */
+    viewId?: string;
+}
+
+declare interface TreeNode {
+    id: string;
+    label: string;
+    icon?: string;
+    iconElement?: unknown;
+    iconColor?: string;
+    iconTooltip?: string;
+    endContent?: unknown;
+    commandId?: string;
+    resource?: ResourceRef;
+    target?: NavigationTarget;
+    /** Visual row variant for non-data rows such as placeholders. */
+    rowVariant?: TreeNodeRowVariant;
+    actions?: TreeAction[];
+    contextMenuActions?: TreeAction[];
+    contextMenuPath?: MenuPath;
+    menuPath?: MenuPath;
+    menuPlacement?: "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "left-start";
+    collapsible?: boolean;
+    disabled?: boolean;
+    children?: TreeNode[];
+    description?: string;
+    contextValue?: string;
+    hiddenByDefault?: boolean;
+    /** When true, the node (e.g. a header/footer row) opts in to the tree's hide/show customization menu. */
+    canHide?: boolean;
+}
+
+declare type TreeNodeRowVariant = "empty-state";
+
+declare interface TreeRendererContribution {
+    id: string;
+    title: string;
+    icon?: string;
+    when?: string;
+    defaultExpandedSectionIds?: string[];
+    defaultExpandedNodeIds?: string[];
+    getBody(ctx: TreeContext): Promise<TreeViewSection[]> | TreeViewSection[];
+    getHeader?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    getFooter?(ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+    getChildren(node: TreeNode, ctx: TreeContext): Promise<TreeNode[]> | TreeNode[];
+}
+
+declare type TreeRendererImplementation = (input: WorkbenchWidgetRenderInput & {
+    treeId: string;
+}) => unknown;
+
+declare interface TreeRendererRefreshEvent {
+    treeId: string;
+}
+
+declare type TreeRendererRefreshListener = (event: TreeRendererRefreshEvent) => void;
+
+declare interface TreeRendererRegistry {
+    treeStore: WorkbenchStore<TreeRendererStoreState>;
+    registerTreeRenderer(view: TreeRendererContribution, metadata?: ContributionMetadata): Disposable_2;
+    setTreeRendererImplementation(impl: TreeRendererImplementation): void;
+    getTreeRenderer(id: string): RegisteredTreeRendererContribution | undefined;
+    listTreeRenderers(): RegisteredTreeRendererContribution[];
+    getBody(id: string, ctx?: TreeContext): Promise<TreeViewSection[]>;
+    getHeader(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
+    getFooter(id: string, ctx?: TreeContext): Promise<TreeNode[]>;
+    getChildren(id: string, node: TreeNode, ctx?: TreeContext): Promise<TreeNode[]>;
+    getTreeState(id: string): TreeRendererState;
+    setNodeExpanded(id: string, nodeId: string, expanded: boolean): void;
+    setSectionExpanded(id: string, sectionId: string, expanded: boolean): void;
+    setSelectedNode(id: string, nodeId: string | undefined): void;
+    setLoading(id: string, loading: boolean): void;
+    refresh(id: string): void;
+    onDidRefresh(listener: TreeRendererRefreshListener): Disposable_2;
+}
+
+declare interface TreeRendererState {
+    expandedNodeIds: string[];
+    expandedSectionIds: string[];
+    selectedNodeId?: string;
+    loading?: boolean;
+}
+
+declare interface TreeRendererStoreState {
+    trees: Record<string, RegisteredTreeRendererContribution>;
+    statesByTreeId: Record<string, TreeRendererState>;
+    refreshKeysByTreeId: Record<string, number>;
+}
+
+declare interface TreeSectionEmptyState {
+    title: string;
+    description?: string;
+    icon?: string;
+}
+
+declare interface TreeViewSection {
+    id: string;
+    label?: string;
+    actions?: TreeAction[];
+    collapsible?: boolean;
+    emptyState?: TreeSectionEmptyState;
+    nodes: TreeNode[];
+    hiddenByDefault?: boolean;
+    /** When true, the section (category) opts in to the tree's hide/show customization menu. */
+    canHide?: boolean;
+}
+
+export declare const useWorkbenchClaim: () => WorkbenchWidgetRenderInput | undefined;
+
+export declare const useWorkbenchStore: <TState, TSlice>(store: WorkbenchStore<TState>, selector: (state: TState) => TSlice) => TSlice;
+
+export declare const useWorkbenchThemePreferences: (workbench: WorkbenchCore) => (ThemePreferenceOption_2 | {
+    id: string;
+    mode: "light";
+} | {
+    id: string;
+    mode: "dark";
+})[];
+
+/**
+ * Core-owned contracts for data renderer contributions. @pstdio/ui's
+ * DataRenderer props are structurally identical; the React layer bridges the
+ * two, so drift surfaces as a compile error there instead of coupling core's
+ * API shape to UI package ownership.
+ */
+declare type ViewMode = "board" | "list";
+
+declare interface WidgetContribution {
+    id: string;
+    title: string;
+    area: WorkbenchArea_2;
+    fallbackArea?: WorkbenchArea_2;
+    singleton?: boolean;
+    reuse?: WidgetReusePolicy;
+    mountStrategy?: WidgetMountStrategy;
+    closable?: boolean;
+    hiddenByDefault?: boolean;
+    areaSize?: WorkbenchAreaSize;
+    areaCollapsible?: boolean;
+    headerBorderBottom?: boolean;
+    resourceKinds?: string[];
+    priority?: number;
+    rendererId: string;
+    config?: unknown;
+    canOpen?(resource: ResourceRef): boolean;
+}
+
+declare type WidgetMountStrategy = "active" | "keep-mounted";
+
+declare type WidgetMountStrategy_2 = "active" | "keep-mounted";
+
+declare type WidgetReusePolicy = "resource" | "none";
+
+export declare const Workbench: (props: WorkbenchProps) => JSX.Element;
+
+export declare const WORKBENCH_SETTINGS_NAV_WIDGET_ID = "workbench.settings.nav";
+
+export declare const WORKBENCH_SETTINGS_OPEN_COMMAND_ID = "workbench.settings.open";
+
+export declare const WORKBENCH_SETTINGS_PANEL_WIDGET_ID = "workbench.settings.panel";
+
+export declare const WORKBENCH_SETTINGS_WIDGET_ID = "workbench.settings";
+
+export declare const WORKBENCH_TERMINAL_LAUNCHER_WIDGET_ID = "workbench.terminal.launcher";
+
+export declare const WORKBENCH_TERMINAL_OPEN_COMMAND_ID = "workbench.terminal.open";
+
+export declare const WORKBENCH_TERMINAL_WIDGET_ID = "workbench.terminal";
+
+export declare const WorkbenchArea: (props: WorkbenchAreaProps) => JSX.Element | null;
+
+declare type WorkbenchArea_2 = (typeof workbenchAreas)[number];
+
+declare interface WorkbenchAreaProps {
+    workbench: WorkbenchCore;
+    area: WorkbenchArea_2;
+    title?: string;
+    showHeader?: boolean;
+    hideSingleTabHeader?: boolean;
+    pointerEvents?: "auto" | "none";
+    transparent?: boolean;
+}
+
+declare const workbenchAreas: readonly ["nav", "activity", "left-header", "left", "main-header", "main-left", "main", "main-right", "secondary-header", "secondary", "status", "overlay", "floating-header", "floating"];
+
+declare interface WorkbenchAreaSize {
+    defaultPx?: number;
+    minPx?: number;
+    maxPx?: number;
+}
+
+declare interface WorkbenchAreaState {
+    id: WorkbenchArea_2;
+    visible: boolean;
+    size?: number;
+    widgets: WorkbenchWidgetPlacement[];
+    activeWidgetId?: string;
+}
+
+export declare const WorkbenchAreaTabs: (props: WorkbenchAreaTabsProps) => JSX.Element | null;
+
+declare interface WorkbenchAreaTabsProps {
+    workbench: WorkbenchCore;
+    area: WorkbenchArea_2;
+    visibilityStorageKey?: string;
+}
+
+declare type WorkbenchBreadcrumbChangeListener = () => void;
+
+declare interface WorkbenchBreadcrumbController {
+    store: WorkbenchStore<WorkbenchBreadcrumbState>;
+    setItems(items: WorkbenchBreadcrumbItem[]): Disposable_2;
+    clearItems(): void;
+    getItems(): WorkbenchBreadcrumbItem[] | undefined;
+    onDidChange(listener: WorkbenchBreadcrumbChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchBreadcrumbItem {
+    title: unknown;
+    icon?: string;
+    url?: string;
+    onClick?: () => void;
+    resource?: ResourceRef;
+}
+
+declare interface WorkbenchBreadcrumbState {
+    items: WorkbenchBreadcrumbItem[] | undefined;
+}
+
+export declare const WorkbenchBreadcrumbView: (props: WorkbenchBreadcrumbViewProps) => JSX.Element | null;
+
+declare interface WorkbenchBreadcrumbViewProps {
+    workbench: WorkbenchCore;
+}
+
+export declare const WorkbenchClaimContext: Context<WorkbenchWidgetRenderInput | undefined>;
+
+declare interface WorkbenchCommandExecutionContext {
+    resource?: ResourceRef;
+}
+
+declare interface WorkbenchCommandExecutionError {
+    commandId: string;
+    args: unknown;
+    error: unknown;
+}
+
+declare type WorkbenchCommandExecutionErrorListener = (event: WorkbenchCommandExecutionError) => void;
+
+export declare const WorkbenchCommandPalette: (props: WorkbenchCommandPaletteProps) => JSX.Element;
+
+declare type WorkbenchCommandPaletteChangeListener = (open: boolean) => void;
+
+declare interface WorkbenchCommandPaletteController {
+    store: WorkbenchStore<WorkbenchCommandPaletteState>;
+    isOpen(): boolean;
+    getView(): WorkbenchCommandPaletteView;
+    getInitialQuery(): string;
+    getParamsRequest(): WorkbenchCommandParamsRequest | null;
+    open(input?: WorkbenchCommandPaletteOpenInput): void;
+    close(): void;
+    toggle(): void;
+    requestParams(request: WorkbenchCommandParamsRequest): void;
+    clearParams(): void;
+    onDidChange(listener: WorkbenchCommandPaletteChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchCommandPaletteOpenInput {
+    view?: WorkbenchCommandPaletteView;
+    initialQuery?: string;
+}
+
+declare interface WorkbenchCommandPaletteProps {
+    workbench: WorkbenchCore;
+    open: boolean;
+    menuPath?: MenuPath;
+    initialQuery?: string;
+    renderParamField?: CommandParamFieldRenderer;
+    onClose: () => void;
+}
+
+declare interface WorkbenchCommandPaletteState {
+    open: boolean;
+    view: WorkbenchCommandPaletteView;
+    initialQuery: string;
+    paramsRequest: WorkbenchCommandParamsRequest | null;
+}
+
+declare type WorkbenchCommandPaletteView = "main" | "theme" | "mode";
+
+declare interface WorkbenchCommandParamsRequest {
+    record: {
+        command: {
+            id: string;
+            label: string;
+            params?: CommandParamSchema;
+        };
+    };
+    label: string;
+    args?: unknown;
+    context?: WorkbenchCommandExecutionContext;
+}
+
+declare interface WorkbenchCore extends WorkbenchCoreContributionContext {
+    registerModule(module: WorkbenchModuleContribution): Disposable_2;
+    unregisterModule(moduleId: string): void;
+}
+
+declare interface WorkbenchCoreContributionContext {
+    breadcrumbs: WorkbenchBreadcrumbController;
+    commandPalette: WorkbenchCommandPaletteController;
+    commandPaletteResources: CommandPaletteResourceRegistry;
+    commands: CommandRegistry;
+    context: ContextKeyService;
+    focus: WorkbenchFocusController;
+    history: HistoryController;
+    keybindings: KeybindingRegistry;
+    lastResource: WorkbenchLastResourceController;
+    layout: WorkbenchLayoutModel;
+    modes: WorkbenchModeRegistry;
+    navigation: NavigationRegistry;
+    notifications: NotificationRegistry;
+    panels: WorkbenchPanelsController;
+    preferences: PreferenceRegistry;
+    renderers: WorkbenchRenderers;
+    resources: ResourceRegistry;
+    settings: SettingsRegistry;
+    sessionPanel: WorkbenchSessionPanelController;
+    terminal: WorkbenchTerminalController;
+    themes: ThemeRegistry;
+    fileIconThemes: FileIconThemeRegistry;
+    getPrimaryResource(): ResourceRef | undefined;
+    onDidChangePrimaryResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
+    getActiveResource(): ResourceRef | undefined;
+    onDidChangeActiveResource(listener: (resource: ResourceRef | undefined) => void): Disposable_2;
+}
+
+declare interface WorkbenchFileIconThemeStoreState {
+    themes: readonly FileIconThemePreferenceOption[];
+}
+
+declare type WorkbenchFocusArea = (typeof workbenchFocusAreas)[number];
+
+declare const workbenchFocusAreas: readonly ["activityBar", "sideBar", "main", "panel", "statusBar"];
+
+declare type WorkbenchFocusChangeListener = (area: WorkbenchFocusArea | undefined) => void;
+
+declare interface WorkbenchFocusController {
+    store: WorkbenchStore<WorkbenchFocusState>;
+    setActiveArea(area: WorkbenchFocusArea): void;
+    clearFocus(): void;
+    getActiveArea(): WorkbenchFocusArea | undefined;
+    onDidChange(listener: WorkbenchFocusChangeListener): Disposable_2;
+}
+
+export declare const WorkbenchFocusRegion: (props: WorkbenchFocusRegionProps) => JSX.Element;
+
+declare interface WorkbenchFocusRegionProps extends BoxProps {
+    workbench: WorkbenchCore;
+    area: WorkbenchFocusArea;
+    children: ReactNode;
+}
+
+declare interface WorkbenchFocusState {
+    activeArea: WorkbenchFocusArea | undefined;
+}
+
+export declare const WorkbenchHeaderActions: (props: WorkbenchHeaderActionsProps) => JSX.Element | null;
+
+declare interface WorkbenchHeaderActionsProps {
+    workbench: WorkbenchCore;
+    menuPath: MenuPath;
+}
+
+export declare interface WorkbenchHotkeyRegistration {
+    commandId: string;
+    hotkey: KeybindingSequence;
+    enabled: boolean;
+    ignoreInputs: boolean;
+    execute(): Promise<unknown>;
+}
+
+export declare const WorkbenchIcon: (props: WorkbenchIconProps) => JSX.Element | null;
+
+declare interface WorkbenchIconProps extends Omit<IconProps, "as" | "size"> {
+    name?: string;
+    size?: number | string;
+}
+
+export declare const WorkbenchKeepAliveLayer: (props: WorkbenchKeepAliveLayerProps) => JSX.Element;
+
+declare interface WorkbenchKeepAliveLayerProps {
+    workbench: WorkbenchCore;
+}
+
+export declare const WorkbenchKeybindingDispatcher: (props: WorkbenchKeybindingDispatcherProps) => null;
+
+declare interface WorkbenchKeybindingDispatcherProps {
+    workbench: WorkbenchCore;
+    disabled?: boolean;
+    commandIds?: readonly string[];
+}
+
+declare interface WorkbenchLastResourceController {
+    get(): ResourceRef | undefined;
+    set(resource: ResourceRef | undefined): void;
+    restore(): Promise<boolean>;
+}
+
+declare interface WorkbenchLayout {
+    areas: Record<WorkbenchArea_2, WorkbenchAreaState>;
+    activeWidgetId?: string;
+    activeResourceUri?: string;
+}
+
+declare type WorkbenchLayoutModel = LayoutModel & MenuRegistry;
+
+declare interface WorkbenchLayoutStoreState {
+    layout: WorkbenchLayout;
+    widgets: Record<string, RegisteredWidgetContribution>;
+    placeholders: Partial<Record<WorkbenchArea_2, RegisteredPlaceholderContribution>>;
+}
+
+export declare interface WorkbenchMenuItem {
+    id: string;
+    commandId: string;
+    label: string;
+    description?: string;
+    icon: string | undefined;
+    iconSrc?: string;
+    overflowLabel?: string;
+    group: string | undefined;
+    args: unknown;
+    disabled: boolean;
+    separatorBefore?: boolean;
+    readOnly?: true;
+}
+
+declare interface WorkbenchMenuItemContext {
+    resource?: ResourceRef | undefined;
+}
+
+declare type WorkbenchModeActivationContext = WorkbenchCoreContributionContext;
+
+declare type WorkbenchModeActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
+
+declare type WorkbenchModeChangeListener = () => void;
+
+declare interface WorkbenchModeContribution {
+    id: string;
+    label?: string;
+    activate(ctx: WorkbenchModeActivationContext): WorkbenchModeActivationResult;
+}
+
+declare interface WorkbenchModeRegistry {
+    store: WorkbenchStore<WorkbenchModeStoreState>;
+    registerMode(mode: WorkbenchModeContribution): Disposable_2;
+    getMode(id: string): WorkbenchModeContribution | undefined;
+    listModes(): WorkbenchModeContribution[];
+    getActiveModeId(): string | undefined;
+    setActiveMode(id: string | undefined): void;
+    onDidChangeActive(listener: WorkbenchModeChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchModeStoreState {
+    modes: Record<string, WorkbenchModeContribution>;
+    activeModeId: string | undefined;
+}
+
+declare type WorkbenchModuleActivationResult = Disposable_2 | readonly Disposable_2[] | undefined;
+
+declare interface WorkbenchModuleContribution {
+    id: string;
+    source?: ContributionSource;
+    ownerId?: string;
+    activate(ctx: WorkbenchModuleContributionContext): WorkbenchModuleActivationResult;
+}
+
+declare type WorkbenchModuleContributionContext = WorkbenchCoreContributionContext;
+
+export declare const WorkbenchModuleHost: (props: WorkbenchModuleHostProps) => null;
+
+export declare interface WorkbenchModuleHostProps {
+    workbench: WorkbenchCore;
+    modules: readonly WorkbenchModuleContribution[];
+}
+
+export declare interface WorkbenchModuleHostRegistration {
+    disposable: Disposable_2;
+}
+
+declare interface WorkbenchNotification {
+    id?: string;
+    level: WorkbenchNotificationLevel;
+    title: string;
+    message?: string;
+    createdAt?: string;
+    resource?: ResourceRef;
+    actions?: WorkbenchNotificationAction[];
+    metadata?: Record<string, unknown>;
+}
+
+declare interface WorkbenchNotificationAction {
+    commandId: string;
+    title: string;
+    args?: unknown;
+}
+
+declare type WorkbenchNotificationEvent = {
+    type: "show";
+    id: string;
+    notification: RegisteredWorkbenchNotification;
+} | {
+    type: "dismiss";
+    id: string;
+};
+
+export declare const WorkbenchNotificationHost: (props: WorkbenchNotificationHostProps) => null;
+
+declare interface WorkbenchNotificationHostProps {
+    workbench: WorkbenchCore;
+}
+
+declare type WorkbenchNotificationLevel = "info" | "success" | "warning" | "error";
+
+declare type WorkbenchNotificationListener = (event: WorkbenchNotificationEvent) => void;
+
+declare interface WorkbenchNotificationStoreState {
+    notifications: Record<string, RegisteredWorkbenchNotification>;
+}
+
+export declare const WorkbenchOverlayLayer: (props: WorkbenchOverlayLayerProps) => JSX.Element | null;
+
+declare interface WorkbenchOverlayLayerProps {
+    workbench: WorkbenchCore;
+}
+
+export declare interface WorkbenchOverlayWidgetConfig {
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "cover" | "full";
+    placement?: "center" | "top" | "bottom";
+    scrollBehavior?: "inside" | "outside";
+    closeOnEscape?: boolean;
+    closeOnInteractOutside?: boolean;
+    modal?: boolean;
+    preventScroll?: boolean;
+    trapFocus?: boolean;
+    motionPreset?: "scale" | "slide-in-bottom" | "slide-in-top" | "slide-in-left" | "slide-in-right" | "none";
+    role?: "dialog" | "alertdialog";
+    contentHeight?: string;
+    contentMaxHeight?: string;
+    contentMinHeight?: string;
+    closeTriggerTop?: string;
+}
+
+declare type WorkbenchPanelsChangeListener = (state: WorkbenchPanelsState) => void;
+
+declare interface WorkbenchPanelsController {
+    store: WorkbenchStore<WorkbenchPanelsState>;
+    isOpen(areaId: string): boolean;
+    setOpen(areaId: string, open: boolean): void;
+    toggle(areaId: string): void;
+    onDidChange(listener: WorkbenchPanelsChangeListener): Disposable_2;
+}
+
+declare interface WorkbenchPanelsState {
+    openByAreaId: Record<string, boolean>;
+}
+
+export declare const WorkbenchPreferencesForm: (props: WorkbenchPreferencesFormProps) => JSX.Element;
+
+export declare interface WorkbenchPreferencesFormProps {
+    preferences: PreferenceRegistry;
+    /** Preference names to edit; an object form overrides the displayed label. */
+    names: (string | {
+        name: string;
+        label?: string;
+    })[];
+    /** Resolves the scopeId for a preference's scope (e.g. "project" -> active project id). */
+    resolveScopeId?: (scope: PreferenceScope) => string | undefined;
+    /** "live" persists on change (default); "apply" stages edits behind Save/Discard. */
+    mode?: "live" | "apply";
+}
+
+declare interface WorkbenchProps {
+    workbench: WorkbenchCore;
+    renderParamField?: CommandParamFieldRenderer;
+}
+
+declare type WorkbenchRendererChangeListener = () => void;
+
+export declare type WorkbenchRendererRegistration = {
+    id: string;
+    keepAlive?: false;
+    render: (input: WorkbenchWidgetRenderInput) => unknown;
+} | {
+    id: string;
+    keepAlive: true;
+    render: () => unknown;
+};
+
+export declare interface WorkbenchRendererRegistry {
+    store: WorkbenchStore<WorkbenchRendererStoreState>;
+    registerRenderer(renderer: WorkbenchRendererRegistration): Disposable_2;
+    getRenderer(id: string): WorkbenchRendererRegistration | undefined;
+    listRenderers(): WorkbenchRendererRegistration[];
+    onDidChange(listener: WorkbenchRendererChangeListener): Disposable_2;
+    claim(rendererId: string, slot: HTMLElement, input: WorkbenchWidgetRenderInput): Disposable_2;
+    getHost(rendererId: string): HTMLElement | undefined;
+    getClaim(rendererId: string): WorkbenchWidgetRenderInput | undefined;
+}
+
+declare type WorkbenchRenderers = WorkbenchRendererRegistry & TreeRendererRegistry & DataRendererRegistry & FileRendererRegistry & ControlsRendererRegistry;
+
+declare interface WorkbenchRendererStoreState {
+    renderers: Record<string, WorkbenchRendererRegistration>;
+    hosts: Record<string, RegisteredKeepAliveHost>;
+    claims: Record<string, WorkbenchWidgetRenderInput>;
+}
+
+export declare const WorkbenchSessionAttachedPanel: (props: WorkbenchSessionPanelProps) => JSX.Element;
+
+export declare const WorkbenchSessionBubbleContainer: (props: WorkbenchSessionPanelProps) => JSX.Element | null;
+
+declare type WorkbenchSessionPanelChangeListener = (mode: WorkbenchSessionPanelMode) => void;
+
+declare interface WorkbenchSessionPanelController {
+    store: WorkbenchStore<WorkbenchSessionPanelState>;
+    getMode(): WorkbenchSessionPanelMode;
+    setMode(mode: WorkbenchSessionPanelMode): void;
+    onDidChange(listener: WorkbenchSessionPanelChangeListener): Disposable_2;
+}
+
+declare type WorkbenchSessionPanelMode = "bubble" | "closed" | "attached";
+
+declare interface WorkbenchSessionPanelProps {
+    workbench: WorkbenchCore;
+    contentSlotRef: (node: HTMLDivElement | null) => void;
+    bottomOffset?: string;
+    header?: ReactNode;
+}
+
+declare interface WorkbenchSessionPanelState {
+    mode: WorkbenchSessionPanelMode;
+}
+
+export declare interface WorkbenchSettingsModuleOptions {
+    /** Maps a preference scope (e.g. "project") to its scope id; project entries hide until this resolves. */
+    resolveScopeId?: (scope: PreferenceScope) => string | undefined;
+    /** Heading shown at the top of the settings overlay. */
+    title?: string;
+}
+
+declare interface WorkbenchStore<TState> {
+    getState(): TState;
+    getInitialState(): TState;
+    subscribe(listener: WorkbenchStoreListener<TState>): () => void;
+    subscribeSelector<TValue>(selector: WorkbenchStoreSelector<TState, TValue>, listener: WorkbenchStoreSelectorListener<TValue>, options?: {
+        equalityFn?: (left: TValue, right: TValue) => boolean;
+        fireImmediately?: boolean;
+    }): () => void;
+}
+
+declare type WorkbenchStoreListener<TState> = (state: TState, previousState: TState) => void;
+
+declare type WorkbenchStoreSelector<TState, TValue> = (state: TState) => TValue;
+
+declare type WorkbenchStoreSelectorListener<TValue> = (value: TValue, previousValue: TValue) => void;
+
+declare interface WorkbenchTerminalController {
+    store: WorkbenchStore<WorkbenchTerminalState>;
+    /** True once the host injected a session opener. */
+    isAvailable(): boolean;
+    setSessionOpener(opener: WorkbenchTerminalSessionOpener | null): void;
+    /** Opens a session; the live adapter stays host-side and only the id is returned. */
+    open(input: {
+        request: WorkbenchTerminalSessionRequest;
+        title?: string;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    write(input: {
+        sessionId: string;
+        data: string | Uint8Array;
+    }): void;
+    resize(input: {
+        sessionId: string;
+        cols: number;
+        rows: number;
+    }): void;
+    kill(input: {
+        sessionId: string;
+        signal?: string;
+    }): Promise<void>;
+    subscribe(sessionId: string, sink: WorkbenchTerminalSessionSink): () => void;
+    getSession(sessionId: string): WorkbenchTerminalSessionModel | undefined;
+    listSessions(): WorkbenchTerminalSessionModel[];
+    /** Kills every live session. Called when the owning workbench is torn down. */
+    dispose(): Promise<void>;
+}
+
+/**
+ * Body of the host-owned terminal panel. Chrome (tab, title, close action,
+ * resize) comes from the workbench `secondary` area; this component only mounts
+ * the terminal bound to the workbench terminal controller. Closing the panel
+ * unmounts the terminal, which kills its session (close = kill).
+ */
+export declare const WorkbenchTerminalPanel: (props: WorkbenchTerminalPanelProps) => JSX.Element;
+
+declare interface WorkbenchTerminalPanelProps {
+    placement: WorkbenchWidgetPlacement;
+    workbench: WorkbenchCore;
+}
+
+declare interface WorkbenchTerminalSessionAdapter {
+    readonly id: string;
+    write(data: string | Uint8Array): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): Promise<void> | void;
+    onData(handler: (chunk: Uint8Array) => void): () => void;
+    /** Foreground process name updates, when the opener can report them (real PTYs). */
+    onTitle?(handler: (title: string) => void): () => void;
+    onExit(handler: (exit: WorkbenchTerminalSessionExit) => void): () => void;
+    onError(handler: (error: WorkbenchTerminalSessionError) => void): () => void;
+}
+
+declare interface WorkbenchTerminalSessionError {
+    message: string;
+}
+
+declare interface WorkbenchTerminalSessionExit {
+    code: number | null;
+    signal: string | null;
+}
+
+declare interface WorkbenchTerminalSessionModel {
+    id: string;
+    title: string;
+    status: WorkbenchTerminalSessionStatus;
+    exit?: WorkbenchTerminalSessionExit;
+}
+
+declare type WorkbenchTerminalSessionOpener = (request: WorkbenchTerminalSessionRequest) => Promise<WorkbenchTerminalSessionAdapter>;
+
+declare interface WorkbenchTerminalSessionRequest {
+    command?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    cols: number;
+    rows: number;
+}
+
+declare interface WorkbenchTerminalSessionSink {
+    onData?(chunk: Uint8Array): void;
+    onExit?(exit: WorkbenchTerminalSessionExit): void;
+    onError?(error: WorkbenchTerminalSessionError): void;
+}
+
+declare type WorkbenchTerminalSessionStatus = "running" | "exited" | "killed";
+
+declare interface WorkbenchTerminalState {
+    sessionsById: Record<string, WorkbenchTerminalSessionModel>;
+}
+
+export declare const WorkbenchThemeProvider: (props: WorkbenchThemeProviderProps) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+
+declare interface WorkbenchThemeProviderProps {
+    children: ReactNode;
+    initialThemePreference?: ThemePreference_3;
+    themePreferences?: readonly ThemePreferenceOption_3[];
+    fileIconThemePreferences?: readonly FileIconThemePreferenceOption_2[];
+}
+
+export declare const WorkbenchThemeScope: (props: WorkbenchThemeScopeProps) => JSX.Element;
+
+declare interface WorkbenchThemeScopeProps extends Omit<BoxProps, "children"> {
+    children: ReactNode;
+}
+
+declare interface WorkbenchThemeStoreState {
+    themes: readonly ThemePreferenceOption[];
+}
+
+export declare const WorkbenchTreeView: (props: WorkbenchTreeViewProps) => JSX.Element;
+
+declare interface WorkbenchTreeViewProps {
+    workbench: WorkbenchCore;
+    treeViewId: string;
+    activeNodeId?: string | null;
+    resource?: ResourceRef;
+    viewId?: string;
+    renderParamField?: CommandParamFieldRenderer;
+    onOpenResourceError?: (error: unknown) => void;
+}
+
+export declare const WorkbenchWidgetHost: (props: WorkbenchWidgetHostProps) => JSX.Element;
+
+declare interface WorkbenchWidgetHostProps {
+    workbench: WorkbenchCore;
+    placement: WorkbenchWidgetPlacement;
+    widget?: RegisteredWidgetContribution | RegisteredPlaceholderContribution;
+}
+
+declare interface WorkbenchWidgetPlacement {
+    widgetId: string;
+    contributionId: string;
+    ownerId?: string;
+    source?: ContributionSource;
+    resource?: ResourceRef;
+    resourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy;
+    hiddenByDefault?: boolean;
+}
+
+declare interface WorkbenchWidgetPlacement_2 {
+    widgetId: string;
+    contributionId: string;
+    ownerId?: string;
+    source?: ContributionSource_2;
+    resource?: ResourceRef_2;
+    resourceUri?: string;
+    title?: string;
+    pinned?: boolean;
+    closable?: boolean;
+    mountStrategy?: WidgetMountStrategy_2;
+    hiddenByDefault?: boolean;
+}
+
+export declare interface WorkbenchWidgetRenderInput {
+    workbench: WorkbenchCore;
+    widget: RegisteredWidgetContribution | RegisteredPlaceholderContribution;
+    placement: WorkbenchWidgetPlacement;
+    refresh: () => void;
+}
+
+export { }