import { WorkbenchFrame as WorkbenchFrame$1, WorkbenchSnapshotDisplayModeV1, WorkbenchSnapshotLockedLayoutV1, WorkbenchSnapshotLayoutPresetV1, WorkbenchSnapshot, WorkbenchSnapshotNode, WorkbenchSnapshotLayoutBasisV1 } from '@tutti-os/workbench-snapshot';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { HTMLAttributes, ReactNode, CSSProperties } from 'react';
import { I18nRuntime } from '@tutti-os/ui-i18n-runtime';
import { c as WorkbenchWindowChromeI18nRuntime } from './workbenchHostI18n-YFXDkIA1.js';
export { b as WorkbenchWindowChromeI18nKey, d as createWorkbenchHostI18nRuntime, e as createWorkbenchWindowChromeI18nRuntime, f as workbenchHostI18nResources, g as workbenchWindowChromeI18nNamespace, h as workbenchWindowChromeI18nResources } from './workbenchHostI18n-YFXDkIA1.js';

interface WorkbenchSize {
    width: number;
    height: number;
}
type WorkbenchFrame = WorkbenchFrame$1;
interface WorkbenchSafeArea {
    top: number;
    right: number;
    bottom: number;
    left: number;
}
type WorkbenchDisplayMode = WorkbenchSnapshotDisplayModeV1;
type WorkbenchSnapTarget = "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | null;
type WorkbenchQuickLayoutTarget = "left" | "right" | "top" | "bottom" | "center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
type WorkbenchLayoutPreset = WorkbenchSnapshotLayoutPresetV1;
/**
 * A layout preset that stays "locked" onto a set of nodes: whenever the surface
 * is resized the layout is re-applied to these nodes so they keep scaling
 * proportionally. Dragging a locked node swaps grid slots and resizing a
 * locked node moves the shared grid dividers; the lock is only released
 * explicitly (titlebar button) or by programmatic moves.
 */
interface WorkbenchLockedLayout extends WorkbenchSnapshotLockedLayoutV1 {
}
interface WorkbenchNode<TData = unknown> {
    id: string;
    kind: string;
    title: string;
    frame: WorkbenchFrame;
    displayMode: WorkbenchDisplayMode;
    restoreFrame: WorkbenchFrame | null;
    isMinimized: boolean;
    minimizedAtUnixMs?: number | null;
    sizeConstraints?: WorkbenchNodeSizeConstraints | null;
    data: TData;
}
interface WorkbenchNodeSizeConstraints {
    minWidth?: number;
    minHeight?: number;
}
interface WorkbenchState<TData = unknown> {
    nodes: WorkbenchNode<TData>[];
    nodeStack: string[];
    activeDragNodeId: string | null;
    activeResizeNodeId: string | null;
    activeSnapTarget: WorkbenchSnapTarget;
    surfaceSize: WorkbenchSize;
    layoutConstraints: WorkbenchLayoutConstraints;
    lockedLayout: WorkbenchLockedLayout | null;
}
interface WorkbenchLayoutConstraints {
    minWidth: number;
    minHeight: number;
    surfacePadding: number;
    safeArea: WorkbenchSafeArea;
}
interface WorkbenchLayoutConstraintsInput extends Partial<Omit<WorkbenchLayoutConstraints, "safeArea">> {
    safeArea?: Partial<WorkbenchSafeArea>;
}

type WorkbenchAction<TData = unknown> = {
    type: "replaceState";
    state: Partial<WorkbenchState<TData>>;
} | {
    type: "replaceNodes";
    nodes: WorkbenchNode<TData>[];
} | {
    type: "openNode";
    node: WorkbenchNode<TData>;
} | {
    type: "closeNode";
    nodeID: string;
} | {
    type: "focusNode";
    nodeID: string;
} | {
    type: "minimizeNode";
    nodeID: string;
} | {
    type: "restoreNode";
    nodeID: string;
} | {
    type: "enterFullscreen";
    nodeID: string;
} | {
    type: "exitFullscreen";
    nodeID: string;
} | {
    type: "applyQuickLayout";
    nodeID: string;
    target: WorkbenchQuickLayoutTarget;
} | {
    type: "applyLayoutPreset";
    nodeIDs: string[];
    preset: WorkbenchLayoutPreset;
    /**
     * When true, remember this preset + node set so it is re-applied on every
     * surface resize (proportional scaling) until the user manually moves a
     * node. Defaults to a one-off arrangement.
     */
    lock?: boolean;
} | {
    type: "applyVisibleLayoutPreset";
    preset: WorkbenchLayoutPreset;
} | {
    /**
     * Ends a drag of a node that belongs to the locked layout: if the node
     * was dropped over another locked node's slot the two swap slots,
     * otherwise the node snaps back to its own slot.
     */
    type: "settleLockedDrag";
    nodeID: string;
} | {
    /**
     * Swaps a locked node with its nearest neighbor slot in the given
     * direction (window snapping shortcuts while a layout is locked).
     */
    type: "moveLockedNode";
    nodeID: string;
    direction: "left" | "right" | "up" | "down";
} | {
    type: "releaseLockedLayout";
} | {
    type: "applyActiveSnapTarget";
    nodeID: string;
} | {
    type: "applySnapTarget";
    nodeID: string;
    snapTarget: WorkbenchSnapTarget;
} | {
    type: "dragNode";
    nodeID: string;
    frame: WorkbenchFrame;
} | {
    type: "moveNode";
    nodeID: string;
    frame: WorkbenchFrame;
} | {
    type: "resizeNode";
    nodeID: string;
    frame: WorkbenchFrame;
} | {
    type: "setActiveDragNode";
    nodeID: string | null;
} | {
    type: "setActiveResizeNode";
    nodeID: string | null;
} | {
    type: "setActiveSnapTarget";
    snapTarget: WorkbenchSnapTarget;
} | {
    type: "setSurfaceSize";
    size: WorkbenchSize;
} | {
    type: "setLayoutConstraints";
    constraints: WorkbenchLayoutConstraintsInput;
} | {
    type: "setNodeSizeConstraints";
    nodeID: string;
    sizeConstraints: WorkbenchNodeSizeConstraints | null;
};

interface WorkbenchCommands<TData = unknown> {
    replaceState(state: Partial<WorkbenchState<TData>>): void;
    replaceNodes(nodes: WorkbenchNode<TData>[]): void;
    openNode(node: WorkbenchNode<TData>): void;
    closeNode(nodeID: string): void;
    focusNode(nodeID: string): void;
    minimizeNode(nodeID: string): void;
    restoreNode(nodeID: string): void;
    enterFullscreen(nodeID: string): void;
    exitFullscreen(nodeID: string): void;
    applyQuickLayout(nodeID: string, target: WorkbenchQuickLayoutTarget): void;
    applyLayoutPreset(nodeIDs: string[], preset: WorkbenchLayoutPreset, lock?: boolean): void;
    applyVisibleLayoutPreset(preset: WorkbenchLayoutPreset): void;
    settleLockedDrag(nodeID: string): void;
    moveLockedNode(nodeID: string, direction: "left" | "right" | "up" | "down"): void;
    releaseLockedLayout(): void;
    applyActiveSnapTarget(nodeID: string): void;
    applySnapTarget(nodeID: string, snapTarget: WorkbenchSnapTarget): void;
    dragNode(nodeID: string, frame: WorkbenchFrame): void;
    moveNode(nodeID: string, frame: WorkbenchFrame): void;
    resizeNode(nodeID: string, frame: WorkbenchFrame): void;
    setActiveDragNode(nodeID: string | null): void;
    setActiveResizeNode(nodeID: string | null): void;
    setActiveSnapTarget(snapTarget: WorkbenchSnapTarget): void;
    setSurfaceSize(size: WorkbenchSize): void;
    setLayoutConstraints(constraints: WorkbenchLayoutConstraintsInput): void;
    setNodeSizeConstraints(nodeID: string, sizeConstraints: WorkbenchNodeSizeConstraints | null): void;
}

type WorkbenchListener = () => void;
type WorkbenchUnsubscribe = () => void;
interface WorkbenchDebugDiagnostics {
    isEnabled(): boolean;
    log?(input: {
        details?: Record<string, unknown>;
        event: string;
        level?: "debug" | "info" | "warn" | "error";
        source: string;
        workspaceId?: string | null;
    }): Promise<void> | void;
}
interface WorkbenchStore<TData = unknown> {
    getSnapshot(): WorkbenchState<TData>;
    subscribe(listener: WorkbenchListener): WorkbenchUnsubscribe;
    dispatch(action: WorkbenchAction<TData>): void;
}
interface WorkbenchController<TData = unknown> extends WorkbenchStore<TData> {
    readonly commands: WorkbenchCommands<TData>;
}

declare function createWorkbenchController<TData = unknown>(initialState?: Partial<WorkbenchState<TData>>, options?: {
    debugDiagnostics?: WorkbenchDebugDiagnostics;
    onSurfaceSizeMeasured?: () => void;
}): WorkbenchController<TData>;

interface WorkbenchMissionControlSnapshot<TData = unknown> {
    isLayoutLocked: boolean;
    layoutConstraints: WorkbenchLayoutConstraints;
    surfaceSize: WorkbenchSize;
    visibleNodes: readonly WorkbenchNode<TData>[];
}
interface WorkbenchMissionControlAdapter<TData = unknown> {
    applyLayoutPreset(nodeIds: string[], preset: WorkbenchLayoutPreset, lock?: boolean): void;
    getSnapshot(): WorkbenchMissionControlSnapshot<TData>;
    releaseLockedLayout(): void;
    subscribe(listener: () => void): () => void;
}

type WorkbenchWindowManagementShortcutPreset = "commandArrows" | "commandShiftArrows";
declare function isEditableShortcutTarget(target: EventTarget | null): boolean;

interface WorkbenchNodeRenderFrame {
    frame: WorkbenchFrame;
    zIndex: number;
    isFocused: boolean;
    presentation?: WorkbenchSurfacePresentation | null;
}
interface WorkbenchSurfacePresentation {
    frameByNodeId: ReadonlyMap<string, WorkbenchFrame>;
    interaction?: WorkbenchSurfacePresentationInteraction | null;
    mode: "mission-control";
    visibleNodeIds: ReadonlySet<string>;
}
interface WorkbenchSurfacePresentationInteraction {
    onBackdropPress: () => void;
    onNodePress(nodeId: string): void;
    selectedNodeIds: ReadonlySet<string>;
}
interface WorkbenchRenderNodeContext<TData = unknown> {
    node: WorkbenchNode<TData>;
    layout: WorkbenchNodeRenderFrame;
    controller: WorkbenchController<TData>;
    isDragging: boolean;
    isResizing: boolean;
}
interface WorkbenchDockContext<TData = unknown> {
    focusedNodeId: string | null;
    minimizedNodes: readonly WorkbenchNode<TData>[];
    nodes: readonly WorkbenchNode<TData>[];
    controller: WorkbenchController<TData>;
    genie: {
        launchNodeFromAnchor(anchorKey: string, nodeID: string, launch: () => Promise<string | null | void> | string | null | void): void;
        registerDockAnchor(anchorKey: string, element: HTMLElement | null): void;
        shouldAnimateMinimizedDockEnter(nodeID: string): boolean;
        isPendingMinimizedDockNode(nodeID: string): boolean;
    };
}
type WorkbenchDockPlacement = "bottom" | "left";
type WorkbenchMinimizeAnimation = "scale" | "genie" | "off";
interface WorkbenchWindowActionContext<TData = unknown> {
    node: WorkbenchNode<TData>;
    controller: WorkbenchController<TData>;
    genie: {
        minimizeNodeToAnchor(nodeID: string, minimize?: () => void): void;
    };
}
type WorkbenchWindowChromeMode = "system" | "custom-header";
type WorkbenchFullscreenHeaderMode = "persistent";
interface WorkbenchWindowHeaderPresentation {
    border?: "none";
    heightPx?: number;
    layout?: "overlay";
    overflow?: "visible";
}
interface WorkbenchResolveWindowChromeModeContext<TData = unknown> {
    node: WorkbenchNode<TData>;
    controller: WorkbenchController<TData>;
}
type WorkbenchResolveWindowChromeMode<TData = unknown> = (context: WorkbenchResolveWindowChromeModeContext<TData>) => WorkbenchWindowChromeMode;
type WorkbenchResolveWindowHeaderPresentation<TData = unknown> = (context: WorkbenchResolveWindowChromeModeContext<TData>) => WorkbenchWindowHeaderPresentation | undefined;
type WorkbenchWindowSurfaceLayer = "default" | "dialog-popover";
interface WorkbenchResolveWindowSurfaceLayerContext<TData = unknown> {
    node: WorkbenchNode<TData>;
}
type WorkbenchResolveWindowSurfaceLayer<TData = unknown> = (context: WorkbenchResolveWindowSurfaceLayerContext<TData>) => WorkbenchWindowSurfaceLayer;
interface WorkbenchResolveWindowZIndexContext<TData = unknown> {
    baseZIndex: number;
    node: WorkbenchNode<TData>;
}
type WorkbenchResolveWindowZIndex<TData = unknown> = (context: WorkbenchResolveWindowZIndexContext<TData>) => NonNullable<CSSProperties["zIndex"]>;
type WorkbenchResolveFullscreenHeaderMode<TData = unknown> = (context: WorkbenchResolveWindowChromeModeContext<TData>) => WorkbenchFullscreenHeaderMode | undefined;
type WorkbenchKeepMinimizedNodeMounted<TData = unknown> = (node: WorkbenchNode<TData>) => boolean;
interface WorkbenchWindowHeaderDragHandleProps {
    "data-workbench-drag-handle": "true";
    onDoubleClick: HTMLAttributes<HTMLElement>["onDoubleClick"];
    onPointerDown: HTMLAttributes<HTMLElement>["onPointerDown"];
}
interface WorkbenchWindowHeaderContext<TData = unknown> {
    node: WorkbenchNode<TData>;
    controller: WorkbenchController<TData>;
    surfaceSize: WorkbenchSize;
    isDragging: boolean;
    isFocused: boolean;
    isResizing: boolean;
    genie: {
        minimizeNodeToAnchor(nodeID: string, minimize?: () => void): void;
    };
    defaultActions: ReactNode;
    dragHandleProps: WorkbenchWindowHeaderDragHandleProps;
    /** Stable while the non-node inputs used to build header chrome are unchanged. */
    renderRevision: object;
}
type WorkbenchRenderNode<TData = unknown> = (context: WorkbenchRenderNodeContext<TData>) => ReactNode;
type WorkbenchRenderWindowActions<TData = unknown> = (context: WorkbenchWindowActionContext<TData>) => ReactNode;
type WorkbenchRenderWindowHeader<TData = unknown> = (context: WorkbenchWindowHeaderContext<TData>) => ReactNode;

interface WorkbenchDockPreviewCacheKey {
    instanceId: string;
    instanceKey?: string | null;
    nodeId: string;
    revision?: string | null;
    typeId: string;
    workspaceId: string;
}
interface WorkbenchDockPreviewCache {
    read(key: WorkbenchDockPreviewCacheKey): Promise<string | null>;
    write(input: {
        key: WorkbenchDockPreviewCacheKey;
        previewImageUrl: string;
    }): void;
}
type WorkbenchDockPreviewCacheKeyResolver<TData = unknown> = (node: WorkbenchNode<TData>) => WorkbenchDockPreviewCacheKey | null;

interface WorkbenchNodePreviewImages {
    dockPreviewImageUrl: string | null;
    genieImageUrl: string | null;
}
type WorkbenchNodePreviewImagesCapture<TData = unknown> = (node: WorkbenchNode<TData>) => Promise<WorkbenchNodePreviewImages | null> | WorkbenchNodePreviewImages | null;
type WorkbenchNodePreviewImageCapture<TData = unknown> = (node: WorkbenchNode<TData>) => Promise<string | null> | string | null;

type WorkbenchNodeGeniePreviewRenderer<TData = unknown> = (node: WorkbenchNode<TData>, input: {
    previewViewport: {
        height: number;
        width: number;
    };
}) => ReactNode;

interface WorkbenchSurfaceProps<TData = unknown> {
    captureNodePreviewImage?: WorkbenchNodePreviewImageCapture<TData>;
    captureNodePreviewImages?: WorkbenchNodePreviewImagesCapture<TData>;
    className?: string;
    controller: WorkbenchController<TData>;
    debugDiagnostics?: WorkbenchDebugDiagnostics;
    dockPreviewCache?: WorkbenchDockPreviewCache;
    dockPlacement?: WorkbenchDockPlacement;
    interactive?: boolean;
    layoutConstraints?: WorkbenchLayoutConstraintsInput;
    missionControlPhase?: "closed" | "entering" | "open" | "closing";
    minimizeAnimation?: WorkbenchMinimizeAnimation;
    presentation?: WorkbenchSurfacePresentation | null;
    renderBackdrop?: () => ReactNode;
    renderBottomChrome?: () => ReactNode;
    renderDock?: (context: WorkbenchDockContext<TData>) => ReactNode;
    renderNode: WorkbenchRenderNode<TData>;
    renderNodeGeniePreview?: WorkbenchNodeGeniePreviewRenderer<TData>;
    renderOverlay?: () => ReactNode;
    renderTopChrome?: () => ReactNode;
    renderWindowActions?: WorkbenchRenderWindowActions<TData>;
    renderWindowHeader?: WorkbenchRenderWindowHeader<TData>;
    shouldKeepMinimizedNodeMounted?: WorkbenchKeepMinimizedNodeMounted<TData>;
    resolveFullscreenHeaderMode?: WorkbenchResolveFullscreenHeaderMode<TData>;
    resolveWindowHeaderPresentation?: WorkbenchResolveWindowHeaderPresentation<TData>;
    resolveWindowSurfaceLayer?: WorkbenchResolveWindowSurfaceLayer<TData>;
    resolveWindowZIndex?: WorkbenchResolveWindowZIndex<TData>;
    resolveDockAnchorKey?: (node: WorkbenchNode<TData>) => string;
    resolveDockPreviewCacheKey?: WorkbenchDockPreviewCacheKeyResolver<TData>;
    shortcutsEnabled?: boolean;
    shouldCaptureNodePreviewImage?: (node: WorkbenchNode<TData>) => boolean;
    wallpaper?: WorkbenchSurfaceWallpaper;
    windowManagement?: WorkbenchWindowManagementConfig;
    windowChromeMode?: WorkbenchWindowChromeMode | WorkbenchResolveWindowChromeMode<TData>;
    windowChromeI18n?: WorkbenchWindowChromeI18nRuntime;
}
interface WorkbenchWindowManagementConfig {
    edgeSnapEnabled?: boolean;
    shortcutPreset?: WorkbenchWindowManagementShortcutPreset | null;
}
type WorkbenchSurfaceWallpaperFit = "contain" | "cover" | "stretch" | "center";
interface WorkbenchSurfaceWallpaper {
    appearance?: "dark" | "light";
    fit?: WorkbenchSurfaceWallpaperFit;
    position?: string;
    url: string;
}
declare function WorkbenchSurface<TData>({ captureNodePreviewImage, captureNodePreviewImages, className, controller, debugDiagnostics, dockPreviewCache, dockPlacement, interactive, layoutConstraints, missionControlPhase, minimizeAnimation, presentation, renderBackdrop, renderBottomChrome, renderDock, renderNode, renderNodeGeniePreview, renderOverlay, renderTopChrome, renderWindowActions, renderWindowHeader, shouldKeepMinimizedNodeMounted, resolveFullscreenHeaderMode, resolveWindowHeaderPresentation, resolveWindowSurfaceLayer, resolveWindowZIndex, resolveDockAnchorKey, resolveDockPreviewCacheKey, shortcutsEnabled, shouldCaptureNodePreviewImage, wallpaper, windowManagement, windowChromeMode, windowChromeI18n }: WorkbenchSurfaceProps<TData>): react_jsx_runtime.JSX.Element;

interface WorkbenchHostActivation<TPayload = unknown> {
    payload?: TPayload;
    sequence: number;
    type: string;
}
interface WorkbenchHostNodeData {
    activation?: WorkbenchHostActivation | null;
    dockEntryId?: string | null;
    instanceId: string;
    instanceKey?: string | null;
    isProjected?: boolean;
    launchSource?: string | null;
    projectionSubject?: WorkbenchHostProjectedNodeSubject | null;
    runtimeNodeState?: unknown;
    snapshotNodeState?: unknown;
    typeId: string;
}
interface WorkbenchHostProjectedNodeSubject {
    id: string;
    type: string;
}
interface WorkbenchHostProjectedNode {
    dockEntryId?: string | null;
    defaultFrame?: WorkbenchFrame;
    instanceId: string;
    instanceKey?: string | null;
    sizeConstraints?: WorkbenchNodeSizeConstraints | null;
    subject?: WorkbenchHostProjectedNodeSubject | null;
    title: string;
    typeId: string;
}
interface WorkbenchHostExternalStateLookupInput {
    instanceId: string;
    instanceKey?: string | null;
    nodeId: string;
    subject?: WorkbenchHostProjectedNodeSubject | null;
    typeId: string;
    workspaceId: string;
}
interface WorkbenchHostExternalStateSource<TNodeState = unknown, TWorkspaceState = unknown> {
    getNodeState(input: WorkbenchHostExternalStateLookupInput): TNodeState;
    getSnapshotNodeState?(input: WorkbenchHostExternalStateLookupInput): unknown;
    getWorkspaceState(input: {
        workspaceId: string;
    }): TWorkspaceState;
    /**
     * Subscribe to one node's live state. `getNodeState` must return the same
     * reference until this node's observable state changes.
     */
    subscribeNodeState?(input: WorkbenchHostExternalStateLookupInput, listener: () => void): () => void;
    /**
     * Subscribe to workspace state consumed by a node renderer. `getWorkspaceState`
     * must return the same reference until this workspace state changes.
     */
    subscribeWorkspaceState?(input: {
        workspaceId: string;
    }, listener: () => void): () => void;
}
type WorkbenchHostNodeCloseDecision = "close" | "keep-open";
type WorkbenchHostCloseDialogScope = "node" | "window";
type WorkbenchHostCloseDialogVariant = "default" | "destructive";
interface WorkbenchHostCloseDialogRequest {
    cancelLabel: string;
    confirmLabel: string;
    description: string;
    details?: string | null;
    scope: WorkbenchHostCloseDialogScope;
    title: string;
    variant?: WorkbenchHostCloseDialogVariant;
}
interface WorkbenchHostCloseEffect {
    description?: string | null;
    nodeId: string;
    title: string;
    typeId: string;
}
interface WorkbenchHostNodeCloseRequest {
    instanceId: string;
    instanceKey?: string | null;
    isProjected: boolean;
    nodeId: string;
    subject?: WorkbenchHostProjectedNodeSubject | null;
    typeId: string;
    workspaceId: string;
}
type WorkbenchHostLaunchReason = "command" | "dock" | "host" | "launchpad" | "shortcut";
interface WorkbenchHostLaunchInput {
    dockEntryId?: string;
    launchSource?: string;
    payload?: unknown;
    reason: WorkbenchHostLaunchReason;
    typeId: string;
}
interface WorkbenchHostLaunchRequest extends WorkbenchHostLaunchInput {
    layoutConstraints: WorkbenchLayoutConstraints;
    surfaceSize: WorkbenchSize;
    workspaceId: string;
}
type WorkbenchHostLaunchFramePolicy = "absolute" | "cascade" | "cascade-same-type-centered";
interface WorkbenchHostLaunchResult {
    activation?: {
        payload?: unknown;
        type: string;
    } | null;
    cascadeOffset?: {
        x: number;
        y: number;
    };
    defaultFrame?: WorkbenchFrame;
    displayMode?: WorkbenchDisplayMode;
    dockEntryId?: string;
    framePolicy: WorkbenchHostLaunchFramePolicy;
    instanceId: string;
    instanceKey?: string | null;
    launchSource?: string | null;
    /**
     * When true, skip the "cascade-same-type-centered" re-center/resize step
     * for a node that already exists (see openLaunchResult in session.ts).
     * Set this when the launch is re-focusing a specific already-open
     * instance (e.g. reusing the window for a known conversation/session)
     * rather than a fresh/generic open, so the user's current window size and
     * position are preserved instead of being reset to the default frame.
     */
    preserveExistingNodeFrame?: boolean;
    reuseDockEntryNode?: boolean;
    sizeConstraints?: WorkbenchNodeSizeConstraints | null;
    title?: string;
    typeId: string;
}
type WorkbenchHostDockEntryVisibility = "always" | "when-open" | "never";
type WorkbenchHostDockEntryLaunchBehavior = "enabled" | "disabled";
type WorkbenchHostDockEntryStateKind = "enabled" | "disabled" | "loading" | "unavailable";
interface WorkbenchHostDockEntryState {
    kind: WorkbenchHostDockEntryStateKind;
    reason?: string;
}
type WorkbenchHostDockEntryBadge = {
    kind: "count";
    value: number;
} | {
    kind: "status";
    status: "running" | "completed" | "failed" | "warning";
} | {
    content: ReactNode;
    kind: "custom";
};
interface WorkbenchHostDockEntryAction {
    disabled?: boolean;
    id: string;
    label: string;
    pendingLabel?: string;
}
interface WorkbenchHostDockEntryRetentionAction {
    actionId: string;
    disabled?: boolean;
    pendingLabel?: string;
    retained: boolean;
}
type WorkbenchHostDockEntryDiagnostics = Record<string, unknown>;
interface WorkbenchHostDockPopupItemInput {
    externalNodeState?: unknown;
    externalWorkspaceState?: unknown;
    host: WorkbenchHostHandle;
    isFocused: boolean;
    isMinimized: boolean;
    node: WorkbenchNode<WorkbenchHostNodeData>;
    previewViewport?: WorkbenchSize;
}
type WorkbenchHostNodePreviewCapture = (input: WorkbenchHostDockPopupItemInput) => Promise<string | null> | string | null;
type WorkbenchDockPreviewContent = {
    element: ReactNode;
    kind: "component";
    revision?: string | null;
} | {
    kind: "image";
    revision?: string | null;
    src: string;
};
type WorkbenchHostDockPopupPreviewProvider = (input: WorkbenchHostDockPopupItemInput) => WorkbenchDockPreviewContent | null;
interface WorkbenchHostDockPopupItemDescriptor {
    preview?: WorkbenchDockPreviewContent | null;
    revision?: string | null;
    subtitle?: string | null;
    title?: string | null;
}
type WorkbenchHostDockPopupCardLabelMode = "hidden" | "hover-overlay";
interface WorkbenchHostDockEntry {
    anchorKey?: string;
    attentionToken?: number | string | null;
    badge?: WorkbenchHostDockEntryBadge;
    capturePopupItemPreview?: WorkbenchHostNodePreviewCapture;
    clickActionId?: string;
    /**
     * `launch` keeps clicks on the launch request path even when matching nodes
     * already exist.
     */
    /**
     * When false, hides the dock hover-popup "New window" tile even for
     * multi-instance entries. Context-menu "New window" remains available unless
     * the entry is otherwise disabled. Defaults to true.
     */
    allowNewWindowInDockPopup?: boolean;
    clickBehavior?: "default" | "launch";
    hoverActions?: readonly WorkbenchHostDockEntryAction[];
    icon: ReactNode;
    iconSize?: "default" | "large";
    id: string;
    label: string;
    diagnostics?: WorkbenchHostDockEntryDiagnostics;
    dockRetention?: WorkbenchHostDockEntryRetentionAction;
    instanceMode?: WorkbenchHostNodeInstanceStrategy["mode"];
    launchBehavior?: WorkbenchHostDockEntryLaunchBehavior;
    launchPayload?: unknown;
    /**
     * Payload used by the dock popup's explicit "New window" action instead of
     * `launchPayload`. Supply this when a normal dock launch reuses/focuses an
     * existing node (e.g. a single logical instance per provider/target) but the
     * "New window" command must always open a fresh node. Falls back to
     * `launchPayload` when omitted.
     */
    newWindowLaunchPayload?: unknown;
    matchNode?: (node: WorkbenchNode<WorkbenchHostNodeData>) => boolean;
    order?: number;
    popupCardLabelMode?: WorkbenchHostDockPopupCardLabelMode;
    providePopupItemPreview?: WorkbenchHostDockPopupPreviewProvider;
    resolvePopupItem?: (input: WorkbenchHostDockPopupItemInput) => WorkbenchHostDockPopupItemDescriptor;
    separatorAfter?: boolean;
    sectionId?: string;
    state?: WorkbenchHostDockEntryState;
    typeId: string;
    visibility?: WorkbenchHostDockEntryVisibility;
}
type WorkbenchHostDockEntryPresentationOverride = Readonly<Partial<Pick<WorkbenchHostDockEntry, "dockRetention" | "visibility">>>;
type WorkbenchHostDockEntryPresentationOverrides = Readonly<Record<string, WorkbenchHostDockEntryPresentationOverride>>;
type WorkbenchHostDockEntryDynamicState = Partial<Pick<WorkbenchHostDockEntry, "attentionToken" | "badge" | "diagnostics" | "dockRetention" | "hoverActions" | "launchBehavior" | "order" | "state" | "visibility">>;
interface WorkbenchHostDockEntryStateSource {
    getEntryState(entryId: string): WorkbenchHostDockEntryDynamicState | null | undefined;
    subscribe(listener: () => void): () => void;
}
interface WorkbenchHostNodeWindowCapabilities {
    closable?: boolean;
    defaultOpen?: boolean;
    fullscreenHeaderMode?: "persistent";
    fullscreenable?: boolean;
    header?: WorkbenchWindowHeaderPresentation;
    keepMountedWhenMinimized?: boolean | ((node: WorkbenchNode<WorkbenchHostNodeData>) => boolean);
    minimizable?: boolean;
    minimizedDock?: WorkbenchHostNodeMinimizedDockCapability;
    persists?: boolean;
    restoreOnLoad?: boolean;
    surfaceLayer?: WorkbenchHostNodeWindowSurfaceLayer;
}
type WorkbenchHostNodeWindowSurfaceLayer = Exclude<WorkbenchWindowSurfaceLayer, "default">;
type WorkbenchHostNodeMinimizedDockCapability = {
    capturePreview?: WorkbenchHostNodePreviewCapture;
    kind: "snapshot";
} | {
    kind: "component";
    providePreview: WorkbenchHostDockPopupPreviewProvider;
};
interface WorkbenchHostSingleInstanceStrategy {
    mode?: "single";
}
interface WorkbenchHostMultiInstanceStrategy {
    mode: "multi";
}
type WorkbenchHostNodeInstanceStrategy = WorkbenchHostSingleInstanceStrategy | WorkbenchHostMultiInstanceStrategy;
interface WorkbenchHostNodeBodyContext<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> {
    activation: WorkbenchHostActivation | null;
    displayMode: WorkbenchNode<WorkbenchHostNodeData>["displayMode"];
    externalNodeState: TExternalNodeState;
    externalWorkspaceState: TExternalWorkspaceState;
    focus(): void;
    host: WorkbenchHostHandle;
    instanceId: string;
    instanceKey?: string | null;
    /** True while the host is interactively moving this node. */
    isDragging: boolean;
    isFocused: boolean;
    /** True while the host is interactively resizing this node. */
    isResizing: boolean;
    /**
     * True only while the normal Workbench window presentation is visible.
     * False while minimized, Genie-hidden, or inside Mission Control.
     */
    isVisible: boolean;
    /**
     * True when a non-normal Workbench presentation currently paints this node.
     * Omitted by direct hosts that do not use a Workbench presentation.
     */
    isPresentationVisible?: boolean;
    /** Current host presentation mode; null for the normal window layout. */
    presentationMode?: WorkbenchSurfacePresentation["mode"] | null;
    node: WorkbenchNode<WorkbenchHostNodeData>;
    previewViewport?: WorkbenchSize;
    setNodeRuntimeState(state: unknown): void;
    setSnapshotNodeState(state: unknown): void;
}
interface WorkbenchHostWindowCloseEffectContext<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> {
    externalNodeState: TExternalNodeState;
    externalWorkspaceState: TExternalWorkspaceState;
    instanceId: string;
    instanceKey?: string | null;
    node: WorkbenchNode<WorkbenchHostNodeData>;
    workspaceId: string;
}
interface WorkbenchHostNodeLeaseHandle {
    release(): void;
}
interface WorkbenchHostNodeLeaseContext {
    node: WorkbenchNode<WorkbenchHostNodeData>;
    workspaceId: string;
}
interface WorkbenchHostNodeHeaderWindowActions {
    applyQuickLayout(target: WorkbenchQuickLayoutTarget): void;
    close(): void;
    focus(): void;
    getFrame(): WorkbenchFrame;
    minimize(): void;
    resize(frame: WorkbenchFrame): void;
    toggleDisplayMode(): void;
}
interface WorkbenchHostNodeHeaderContext<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> {
    activation: WorkbenchHostActivation | null;
    defaultActions: ReactNode;
    displayMode: WorkbenchNode<WorkbenchHostNodeData>["displayMode"];
    dragHandleProps: WorkbenchWindowHeaderDragHandleProps;
    externalNodeState: TExternalNodeState;
    externalWorkspaceState: TExternalWorkspaceState;
    instanceId: string;
    instanceKey?: string | null;
    isDragging: boolean;
    isFocused: boolean;
    isResizing: boolean;
    node: WorkbenchNode<WorkbenchHostNodeData>;
    surfaceSize: WorkbenchSize;
    windowActions: WorkbenchHostNodeHeaderWindowActions;
}
type WorkbenchHostBodyRenderer<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> = {
    bivarianceHack(context: WorkbenchHostNodeBodyContext<TExternalNodeState, TExternalWorkspaceState>): ReactNode;
}["bivarianceHack"];
type WorkbenchHostHeaderRenderer<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> = {
    bivarianceHack(context: WorkbenchHostNodeHeaderContext<TExternalNodeState, TExternalWorkspaceState>): ReactNode;
}["bivarianceHack"];
type WorkbenchHostNodeHeaderFrameRenderKey = boolean | number | string | null;
type WorkbenchHostHeaderFrameRenderKeyResolver<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> = {
    bivarianceHack(context: WorkbenchHostNodeHeaderContext<TExternalNodeState, TExternalWorkspaceState>): WorkbenchHostNodeHeaderFrameRenderKey;
}["bivarianceHack"];
type WorkbenchHostWindowCloseEffectResolver<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> = {
    bivarianceHack(context: WorkbenchHostWindowCloseEffectContext<TExternalNodeState, TExternalWorkspaceState>): Promise<WorkbenchHostCloseEffect | null | void> | WorkbenchHostCloseEffect | null | void;
}["bivarianceHack"];
interface WorkbenchHostNodeDefinition<TExternalNodeState = unknown, TExternalWorkspaceState = unknown> {
    createLease?: (context: WorkbenchHostNodeLeaseContext) => WorkbenchHostNodeLeaseHandle | null | void;
    description?: string;
    frame: WorkbenchFrame;
    getWindowCloseEffect?: WorkbenchHostWindowCloseEffectResolver<TExternalNodeState, TExternalWorkspaceState>;
    /**
     * Projects frame-derived header presentation during direct manipulation.
     * Equal keys skip renderHeader; omitted definitions keep live frame renders.
     */
    getHeaderFrameRenderKey?: WorkbenchHostHeaderFrameRenderKeyResolver<TExternalNodeState, TExternalWorkspaceState>;
    instance?: WorkbenchHostNodeInstanceStrategy;
    onBodyRenderErrorChange?: (input: {
        hasError: boolean;
        node: WorkbenchNode<WorkbenchHostNodeData>;
    }) => void;
    renderBody: WorkbenchHostBodyRenderer<TExternalNodeState, TExternalWorkspaceState>;
    renderHeader?: WorkbenchHostHeaderRenderer<TExternalNodeState, TExternalWorkspaceState>;
    sizeConstraints?: WorkbenchNodeSizeConstraints | null;
    title: string;
    typeId: string;
    window?: WorkbenchHostNodeWindowCapabilities;
}
interface WorkbenchHostSnapshotRepository {
    hasLoaded?(workspaceId: string): boolean;
    load(workspaceId: string): Promise<WorkbenchSnapshot | null>;
    readCached?(workspaceId: string): WorkbenchSnapshot | null;
    save(workspaceId: string, snapshot: WorkbenchSnapshot): Promise<WorkbenchSnapshot> | WorkbenchSnapshot;
}
type WorkbenchHostActivationTarget = {
    nodeId: string;
} | {
    instanceId?: string;
    typeId: string;
};
interface WorkbenchHostHandle {
    activateNode(target: WorkbenchHostActivationTarget, activation: {
        payload?: unknown;
        type: string;
    }): void;
    clearNodeActivation?(nodeId: string, sequence: number): void;
    closeNode(nodeId: string): void;
    collectWindowCloseEffects(): Promise<readonly WorkbenchHostCloseEffect[]>;
    dispose(): void;
    exitFullscreenNode(nodeId: string): void;
    focusNode(nodeId: string): void;
    getSnapshot(): WorkbenchState<WorkbenchHostNodeData>;
    isHydrating?(): boolean;
    launchNode(input: WorkbenchHostLaunchInput): Promise<string | null>;
    load(): Promise<void>;
    minimizeNode(nodeId: string): void;
    requestNodeClose(nodeId: string): void;
    reconcileProjectedNodes(projectedNodes: readonly WorkbenchHostProjectedNode[]): void;
    setNodeRuntimeState(nodeId: string, state: unknown): void;
    setNodeSizeConstraints(nodeId: string, sizeConstraints: WorkbenchNodeSizeConstraints | null): void;
    setSnapshotNodeState(nodeId: string, state: unknown): void;
    setNodeTitle(nodeId: string, title: string): void;
}
interface WorkbenchHostChromeRenderContext {
    controller: WorkbenchController<WorkbenchHostNodeData>;
    activateNode: WorkbenchHostHandle["activateNode"];
    focusNode: WorkbenchHostHandle["focusNode"];
    launchNode: WorkbenchHostHandle["launchNode"];
}
interface WorkbenchHostMissionControlProps {
    active: boolean;
    nodeIds?: readonly string[];
    onRequestClose: () => void;
}
interface WorkbenchHostMissionControlOpenRequest {
    nodeIds?: readonly string[];
    trigger?: "dock-context-menu";
}
interface WorkbenchHostClosePreparationContext {
    host: WorkbenchHostHandle;
    workspaceId: string;
}
type WorkbenchHostClosePreparer = (context: WorkbenchHostClosePreparationContext) => Promise<boolean> | boolean;
interface WorkbenchContribution {
    dockEntries?: readonly WorkbenchHostDockEntry[];
    externalStateSource?: WorkbenchHostExternalStateSource;
    id: string;
    nodes?: readonly WorkbenchHostNodeDefinition[];
    onLaunchRequest?: (request: WorkbenchHostLaunchRequest) => Promise<WorkbenchHostLaunchResult | null | void> | WorkbenchHostLaunchResult | null | void;
    onNodeCloseRequest?: (request: WorkbenchHostNodeCloseRequest) => Promise<WorkbenchHostNodeCloseDecision | void> | WorkbenchHostNodeCloseDecision | void;
    prepareHostClose?: WorkbenchHostClosePreparer;
}
interface WorkbenchHostProps {
    captureNodePreviewImage?: WorkbenchNodePreviewImageCapture<WorkbenchHostNodeData>;
    captureNodePreviewImages?: WorkbenchNodePreviewImagesCapture<WorkbenchHostNodeData>;
    className?: string;
    contributions?: readonly WorkbenchContribution[];
    debugDiagnostics?: WorkbenchDebugDiagnostics;
    dockPreviewCache?: WorkbenchDockPreviewCache;
    dockPlacement?: WorkbenchDockPlacement;
    dockEntries?: readonly WorkbenchHostDockEntry[];
    dockEntryPresentationOverrides?: WorkbenchHostDockEntryPresentationOverrides;
    dockStateSource?: WorkbenchHostDockEntryStateSource;
    externalStateSource?: WorkbenchHostExternalStateSource;
    i18n?: I18nRuntime<string>;
    layoutConstraints?: WorkbenchLayoutConstraintsInput;
    missionControl?: WorkbenchHostMissionControlProps;
    minimizeAnimation?: WorkbenchMinimizeAnimation;
    nodes?: readonly WorkbenchHostNodeDefinition[];
    onDockEntryAction?: (input: {
        actionId: string;
        entryId: string;
        host: WorkbenchHostHandle;
    }) => Promise<void> | void;
    onDockEntryClick?: (input: {
        entryId: string;
        host: WorkbenchHostHandle;
        nodeId?: string;
    }) => Promise<void> | void;
    onLaunchRequest?: (request: WorkbenchHostLaunchRequest) => Promise<WorkbenchHostLaunchResult | null | void> | WorkbenchHostLaunchResult | null | void;
    onMissionControlAdapterReady?: (adapter: WorkbenchMissionControlAdapter<WorkbenchHostNodeData> | null) => void;
    onMissionControlRequestOpen?: (request?: WorkbenchHostMissionControlOpenRequest) => void;
    onNodeCloseRequest?: (request: WorkbenchHostNodeCloseRequest) => Promise<WorkbenchHostNodeCloseDecision | void> | WorkbenchHostNodeCloseDecision | void;
    onHandleReady?: (handle: WorkbenchHostHandle | null) => void;
    projectedNodes?: readonly WorkbenchHostProjectedNode[];
    renderBottomChrome?: (context: WorkbenchHostChromeRenderContext) => ReactNode;
    renderTopChrome?: (context: WorkbenchHostChromeRenderContext) => ReactNode;
    snapshotRepository: WorkbenchHostSnapshotRepository;
    shortcutsEnabled?: boolean;
    wallpaper?: WorkbenchSurfaceWallpaper;
    windowManagement?: WorkbenchWindowManagementConfig;
    workspaceId: string;
}

declare function WorkbenchHost({ captureNodePreviewImage, captureNodePreviewImages, className, contributions, debugDiagnostics, dockPreviewCache, dockPlacement, dockEntryPresentationOverrides, dockEntries, dockStateSource, externalStateSource, i18n, layoutConstraints, missionControl, minimizeAnimation, nodes, onDockEntryAction, onDockEntryClick, onHandleReady, onLaunchRequest, onMissionControlAdapterReady, onMissionControlRequestOpen, onNodeCloseRequest, projectedNodes, renderBottomChrome, renderTopChrome, snapshotRepository, shortcutsEnabled, wallpaper, windowManagement, workspaceId }: WorkbenchHostProps): react_jsx_runtime.JSX.Element;

declare function resolveWorkbenchHostPrepareClose(contributions: readonly WorkbenchContribution[]): WorkbenchHostClosePreparer | undefined;

declare const workbenchFocusInputActivationType = "focus-input";

interface CreateWorkbenchNodeInput<TData = unknown> {
    data: TData;
    displayMode?: WorkbenchNode<TData>["displayMode"];
    frame: WorkbenchNode<TData>["frame"];
    id: string;
    isMinimized?: boolean;
    kind: string;
    minimizedAtUnixMs?: WorkbenchNode<TData>["minimizedAtUnixMs"];
    restoreFrame?: WorkbenchNode<TData>["restoreFrame"];
    sizeConstraints?: WorkbenchNode<TData>["sizeConstraints"];
    title: string;
}
interface CreateWorkbenchSnapshotFromStateOptions {
    activeSpaceId?: WorkbenchSnapshot["activeSpaceId"];
    metadata?: WorkbenchSnapshot["metadata"];
    spaces?: WorkbenchSnapshot["spaces"];
}
declare function createWorkbenchNode<TData = unknown>(input: CreateWorkbenchNodeInput<TData>): WorkbenchNode<TData>;
declare function createWorkbenchNodeFromSnapshot<TData = unknown>(snapshotNode: WorkbenchSnapshotNode): WorkbenchNode<TData>;
declare function createWorkbenchStateFromSnapshot<TData = unknown>(snapshot: WorkbenchSnapshot): Pick<WorkbenchState<TData>, "lockedLayout" | "nodeStack" | "nodes">;
declare function createWorkbenchSnapshotFromState<TData = unknown>(state: Pick<WorkbenchState<TData>, "nodeStack" | "nodes"> & Partial<Pick<WorkbenchState<TData>, "layoutConstraints" | "lockedLayout" | "surfaceSize">>, options?: CreateWorkbenchSnapshotFromStateOptions): WorkbenchSnapshot;
declare function createWorkbenchSnapshotLayoutBasis(state: Partial<Pick<WorkbenchState, "layoutConstraints" | "surfaceSize">>): WorkbenchSnapshotLayoutBasisV1 | undefined;

interface WorkbenchHostNodeIdentityInput {
    instanceId: string;
    typeId: string;
}
declare function createWorkbenchHostProjectedNodeId(input: WorkbenchHostNodeIdentityInput): string;
declare function createWorkbenchHostLaunchedNodeId(input: WorkbenchHostNodeIdentityInput): string;

interface WorkbenchNodePreviewCaptureRectInput {
    maxHeight: number;
    maxWidth: number;
    nodeId: string;
    rect: {
        height: number;
        width: number;
        x: number;
        y: number;
    };
}
interface WorkbenchNodePreviewCaptureDiagnostic {
    details: Record<string, unknown>;
    event: "capture_failed" | "capture_requested" | "capture_resolved" | "capture_skipped" | "capture_started" | "capture_timed_out";
    level: "debug" | "info" | "warn";
}
interface WorkbenchNodePreviewCaptureAdapterOptions<TData = unknown> {
    captureRect: (input: WorkbenchNodePreviewCaptureRectInput) => Promise<WorkbenchNodePreviewImages | null>;
    diagnostics?: (diagnostic: WorkbenchNodePreviewCaptureDiagnostic) => void;
    maxHeight: number;
    maxWidth: number;
    resolveDiagnosticContext?: (node: WorkbenchNode<TData>) => Record<string, unknown>;
    timeoutMs?: number;
}
declare function createWorkbenchNodePreviewCaptureAdapter<TData = unknown>(options: WorkbenchNodePreviewCaptureAdapterOptions<TData>): WorkbenchNodePreviewImagesCapture<TData>;

interface WorkbenchDockComponentPreviewFrameProps {
    children?: ReactNode;
    sourceSize: WorkbenchSize;
    viewport: WorkbenchSize;
}
declare function WorkbenchDockComponentPreviewFrame({ children, sourceSize, viewport }: WorkbenchDockComponentPreviewFrameProps): ReactNode;

declare function useWorkbenchSelector<TData, TResult>(selector: (state: WorkbenchState<TData>) => TResult): TResult;

interface WorkbenchVisualOcclusionPresentation {
    hiddenNodeIDs: ReadonlySet<string>;
    nonOccludingNodeIDs: ReadonlySet<string>;
    topLayerNodeIDs: readonly string[];
}
declare function selectVisuallyExposedWorkbenchNodeIDs<TData>(state: WorkbenchState<TData>, presentation?: WorkbenchVisualOcclusionPresentation): ReadonlySet<string>;
declare function selectWorkbenchNodeIsVisuallyExposed<TData>(state: WorkbenchState<TData>, nodeID: string, presentation?: WorkbenchVisualOcclusionPresentation): boolean;

declare function useWorkbenchVisualOcclusionPresentation(): WorkbenchVisualOcclusionPresentation;

declare function getWorkbenchLayoutFrame(surfaceSize: WorkbenchSize, constraints?: WorkbenchLayoutConstraints): WorkbenchFrame;

declare function selectFocusedWorkbenchNode<TData>(state: WorkbenchState<TData>): WorkbenchNode<TData> | null;

type WorkbenchHostDockNodeState = "closed" | "minimized" | "open";
interface ResolvedWorkbenchHostDockEntry {
    anchorKey: string;
    dockNodeState: WorkbenchHostDockNodeState;
    entry: WorkbenchHostDockEntry;
    hasMatchingNodes: boolean;
    matchedNodes: WorkbenchNode<WorkbenchHostNodeData>[];
    sectionBreakBefore: boolean;
}
type WorkbenchHostDockClickResolution = {
    actionId: string;
    kind: "action";
} | {
    kind: "blocked";
} | {
    kind: "focus-node";
    nodeId: string;
} | {
    kind: "launch";
} | {
    kind: "open-popup";
};
declare function matchWorkbenchDockEntryNode(entry: WorkbenchHostDockEntry, node: WorkbenchNode<WorkbenchHostNodeData>): boolean;
declare function resolveWorkbenchDockEntries(input: {
    dockEntries: readonly WorkbenchHostDockEntry[];
    minimizedNodeIds: ReadonlySet<string>;
    nodes: readonly WorkbenchNode<WorkbenchHostNodeData>[];
}): ResolvedWorkbenchHostDockEntry[];
declare function resolveWorkbenchDockEntryClick(input: {
    entry: WorkbenchHostDockEntry;
    instanceMode?: WorkbenchHostNodeInstanceStrategy["mode"];
    matchedNodes: readonly WorkbenchNode<WorkbenchHostNodeData>[];
}): WorkbenchHostDockClickResolution;
declare function canCreateNewWindow(entry: WorkbenchHostDockEntry, instanceMode?: WorkbenchHostNodeInstanceStrategy["mode"]): boolean;
declare function canCreateNewWindowInDockPopup(entry: WorkbenchHostDockEntry, instanceMode?: WorkbenchHostNodeInstanceStrategy["mode"]): boolean;
declare function createDockNewWindowLaunchPayload(launchPayload?: unknown): Record<string, unknown>;
interface CreateMultiInstanceDockEntryOptionsInput {
    allowNewWindowInDockPopup?: boolean;
}
declare function createMultiInstanceDockEntryOptions(launchPayload?: unknown, input?: CreateMultiInstanceDockEntryOptionsInput): Pick<WorkbenchHostDockEntry, "allowNewWindowInDockPopup" | "instanceMode" | "launchBehavior" | "launchPayload" | "newWindowLaunchPayload">;
declare function resolveWorkbenchDockCountBadge(activeNodeCount: number): WorkbenchHostDockEntry["badge"];

export { type CreateWorkbenchNodeInput, type CreateWorkbenchSnapshotFromStateOptions, type ResolvedWorkbenchHostDockEntry, type WorkbenchContribution, type WorkbenchController, type WorkbenchDebugDiagnostics, type WorkbenchDisplayMode, WorkbenchDockComponentPreviewFrame, type WorkbenchDockComponentPreviewFrameProps, type WorkbenchDockContext, type WorkbenchDockPlacement, type WorkbenchDockPreviewCache, type WorkbenchDockPreviewCacheKey, type WorkbenchDockPreviewCacheKeyResolver, type WorkbenchDockPreviewContent, type WorkbenchFrame, type WorkbenchFullscreenHeaderMode, WorkbenchHost, type WorkbenchHostActivation, type WorkbenchHostActivationTarget, type WorkbenchHostChromeRenderContext, type WorkbenchHostCloseDialogRequest, type WorkbenchHostCloseDialogScope, type WorkbenchHostCloseDialogVariant, type WorkbenchHostCloseEffect, type WorkbenchHostClosePreparationContext, type WorkbenchHostClosePreparer, type WorkbenchHostDockClickResolution, type WorkbenchHostDockEntry, type WorkbenchHostDockEntryAction, type WorkbenchHostDockEntryBadge, type WorkbenchHostDockEntryDynamicState, type WorkbenchHostDockEntryLaunchBehavior, type WorkbenchHostDockEntryPresentationOverride, type WorkbenchHostDockEntryPresentationOverrides, type WorkbenchHostDockEntryState, type WorkbenchHostDockEntryStateKind, type WorkbenchHostDockEntryStateSource, type WorkbenchHostDockEntryVisibility, type WorkbenchHostDockNodeState, type WorkbenchHostDockPopupItemDescriptor, type WorkbenchHostDockPopupItemInput, type WorkbenchHostExternalStateLookupInput, type WorkbenchHostExternalStateSource, type WorkbenchHostHandle, type WorkbenchHostLaunchFramePolicy, type WorkbenchHostLaunchInput, type WorkbenchHostLaunchReason, type WorkbenchHostLaunchRequest, type WorkbenchHostLaunchResult, type WorkbenchHostMissionControlProps, type WorkbenchHostMultiInstanceStrategy, type WorkbenchHostNodeBodyContext, type WorkbenchHostNodeCloseDecision, type WorkbenchHostNodeCloseRequest, type WorkbenchHostNodeData, type WorkbenchHostNodeDefinition, type WorkbenchHostNodeHeaderContext, type WorkbenchHostNodeHeaderFrameRenderKey, type WorkbenchHostNodeHeaderWindowActions, type WorkbenchHostNodeIdentityInput, type WorkbenchHostNodeInstanceStrategy, type WorkbenchHostNodeMinimizedDockCapability, type WorkbenchHostNodeWindowCapabilities, type WorkbenchHostProjectedNode, type WorkbenchHostProjectedNodeSubject, type WorkbenchHostProps, type WorkbenchHostSingleInstanceStrategy, type WorkbenchHostSnapshotRepository, type WorkbenchHostWindowCloseEffectContext, type WorkbenchLayoutConstraints, type WorkbenchLayoutConstraintsInput, type WorkbenchLayoutPreset, type WorkbenchMissionControlAdapter, type WorkbenchMissionControlSnapshot, type WorkbenchNode, type WorkbenchNodePreviewCaptureAdapterOptions, type WorkbenchNodePreviewCaptureDiagnostic, type WorkbenchNodePreviewCaptureRectInput, type WorkbenchNodePreviewImageCapture, type WorkbenchNodePreviewImages, type WorkbenchNodePreviewImagesCapture, type WorkbenchNodeRenderFrame, type WorkbenchNodeSizeConstraints, type WorkbenchQuickLayoutTarget, type WorkbenchRenderNode, type WorkbenchRenderNodeContext, type WorkbenchRenderWindowActions, type WorkbenchRenderWindowHeader, type WorkbenchResolveFullscreenHeaderMode, type WorkbenchResolveWindowChromeMode, type WorkbenchResolveWindowChromeModeContext, type WorkbenchResolveWindowHeaderPresentation, type WorkbenchSafeArea, type WorkbenchSize, type WorkbenchState, WorkbenchSurface, type WorkbenchSurfacePresentation, type WorkbenchSurfaceProps, type WorkbenchSurfaceWallpaper, type WorkbenchSurfaceWallpaperFit, type WorkbenchVisualOcclusionPresentation, type WorkbenchWindowActionContext, WorkbenchWindowChromeI18nRuntime, type WorkbenchWindowChromeMode, type WorkbenchWindowHeaderContext, type WorkbenchWindowHeaderPresentation, type WorkbenchWindowManagementConfig, canCreateNewWindow, canCreateNewWindowInDockPopup, createDockNewWindowLaunchPayload, createMultiInstanceDockEntryOptions, createWorkbenchController, createWorkbenchHostLaunchedNodeId, createWorkbenchHostProjectedNodeId, createWorkbenchNode, createWorkbenchNodeFromSnapshot, createWorkbenchNodePreviewCaptureAdapter, createWorkbenchSnapshotFromState, createWorkbenchSnapshotLayoutBasis, createWorkbenchStateFromSnapshot, getWorkbenchLayoutFrame, isEditableShortcutTarget, matchWorkbenchDockEntryNode, resolveWorkbenchDockCountBadge, resolveWorkbenchDockEntries, resolveWorkbenchDockEntryClick, resolveWorkbenchHostPrepareClose, selectFocusedWorkbenchNode, selectVisuallyExposedWorkbenchNodeIDs, selectWorkbenchNodeIsVisuallyExposed, useWorkbenchSelector, useWorkbenchVisualOcclusionPresentation, workbenchFocusInputActivationType };