@gjsify/adwaita-web 0.64.1 → 0.64.2-next.252

package/lib/types/application.d.ts

@@ -17,7 +17,7 @@ export declare class GtkApplication extends GtkApplication_base {
 export declare class AdwApplication extends GtkApplication {
 }
 /**
- * `Gtk.Window:application` and the window's `Gio.ActionMap` (`win.` actions) on an element class.
+ * `Gtk.Window:application`, `get_application()` and `set_application()` on a window element class.
  * Setting the property is `add_window`, as on GTK; setting it to `null` is `remove_window`.
  */
 export declare function defineWindowApplication(proto: object): void;

package/lib/types/child-slot.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwChildSlotTest: () => Promise<void>;

package/lib/types/container-fill.spec.d.ts

@@ -0,0 +1 @@
+export declare const ContainerFillTest: () => Promise<void>;

package/lib/types/elements/adw-alert-dialog.d.ts

@@ -1,4 +1,5 @@
 import type { AdwResponseAppearance } from '@gjsify/adwaita-core';
+import type { DispatchedSignals } from '../signals.js';
 /** Response button appearance — mirrors Adw.ResponseAppearance. */
 export type { AdwResponseAppearance } from '@gjsify/adwaita-core';
 /**
@@ -10,8 +11,39 @@ export type { AdwResponseAppearance } from '@gjsify/adwaita-core';
 export declare class AdwAlertResponse extends HTMLElement {
     static get observedAttributes(): string[];
 }
+/** The `Adw.AlertDialog` construct properties, in GJS's snake_case or the camelCase GJS also takes. */
+export interface AdwAlertDialogProps {
+    heading?: string;
+    body?: string;
+    heading_use_markup?: boolean;
+    headingUseMarkup?: boolean;
+    body_use_markup?: boolean;
+    bodyUseMarkup?: boolean;
+    close_response?: string;
+    closeResponse?: string;
+    default_response?: string | null;
+    defaultResponse?: string | null;
+    prefer_wide_layout?: boolean;
+    preferWideLayout?: boolean;
+}
 export declare class AdwAlertDialog extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
+    /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
+    connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
+    /** `GObject.Object.disconnect`: throws for an id that is not connected. */
+    disconnect: (id: number) => void;
+    /** `GObject.Object.emit`. */
+    emit: (signal: string, ...args: unknown[]) => void;
+    /** `GObject.Object.notify`. */
+    notify: (name: string) => void;
+    /** `GObject.Object.get_property`, by GTK's dashed name. */
+    get_property: (name: string) => unknown;
+    /** `GObject.Object.set_property`. */
+    set_property: (name: string, value: unknown) => void;
     private _initialized;
+    /** Set when `present()` attached the dialog, so closing detaches it again. */
+    private _attachedByPresent;
     private _scrimEl;
     private _dialogEl;
     private _headingEl;
@@ -24,6 +56,12 @@ export declare class AdwAlertDialog extends HTMLElement {
     /** The rendered button per registered response id (the DOM half of the model). */
     private readonly _buttons;
     private _blockCloseResponse;
+    /**
+     * `new Adw.AlertDialog({ heading, body, close_response, default_response })`, the GJS
+     * construct bag. Only the `new` form passes one: `document.createElement` and the
+     * parser call this with nothing, which is why writing attributes here is allowed.
+     */
+    constructor(props?: AdwAlertDialogProps);
     static get observedAttributes(): string[];
     get heading(): string;
     set heading(value: string);
@@ -54,24 +92,46 @@ export declare class AdwAlertDialog extends HTMLElement {
      */
     private _adoptResponse;
     attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    /** Present the dialog. `parent` is accepted for API parity; unused. */
+    /**
+     * Present the dialog (`adw_dialog_present`). A detached dialog is attached to the document
+     * first and detached again when it closes; `parent` names the window it belongs to, and the
+     * page is that window's root here, so it does not change where the dialog goes.
+     */
     present(_parent?: unknown): void;
-    addResponse(id: string, label: string): void;
-    /** Adds multiple responses at once — id/label pairs (Adw.add_responses parity). */
-    addResponses(...idLabelPairs: string[]): void;
-    removeResponse(id: string): void;
-    hasResponse(id: string): boolean;
-    getResponseLabel(id: string): string | null;
-    setResponseLabel(id: string, label: string): void;
-    getResponseAppearance(id: string): AdwResponseAppearance | null;
-    setResponseAppearance(id: string, appearance: AdwResponseAppearance): void;
-    getResponseEnabled(id: string): boolean;
-    /** Sets whether a response is enabled (disabled buttons can't be activated). */
-    setResponseEnabled(id: string, enabled: boolean): void;
-    /** Sets the default response — its button is highlighted as the suggested one. */
-    setDefaultResponse(id: string | null): void;
-    /** Sets the close response — emitted on dismissal (Escape / scrim click). */
-    setCloseResponse(id: string): void;
+    /** `adw_alert_dialog_add_response`: a duplicate id is refused, as libadwaita's g_critical does. */
+    add_response(id: string, label: string): void;
+    /** `adw_alert_dialog_remove_response`. */
+    remove_response(id: string): void;
+    /** `adw_alert_dialog_has_response`. */
+    has_response(id: string): boolean;
+    /** `adw_alert_dialog_get_response_label`; `null` for an unknown id, as the C returns NULL. */
+    get_response_label(id: string): string | null;
+    /** `adw_alert_dialog_set_response_label`. */
+    set_response_label(id: string, label: string): void;
+    /** `adw_alert_dialog_get_response_appearance`; `null` for an unknown id. */
+    get_response_appearance(id: string): AdwResponseAppearance | null;
+    /** `adw_alert_dialog_set_response_appearance`. */
+    set_response_appearance(id: string, appearance: AdwResponseAppearance): void;
+    /** `adw_alert_dialog_get_response_enabled`; `false` for an unknown id, as the C returns FALSE. */
+    get_response_enabled(id: string): boolean;
+    /** `adw_alert_dialog_set_response_enabled`: a disabled button cannot be activated. */
+    set_response_enabled(id: string, enabled: boolean): void;
+    /** `adw_alert_dialog_get_default_response`. */
+    get_default_response(): string | null;
+    /** `adw_alert_dialog_set_default_response`: its button is highlighted and takes the focus. */
+    set_default_response(id: string | null): void;
+    /** `adw_alert_dialog_get_close_response`. */
+    get_close_response(): string;
+    /** `adw_alert_dialog_set_close_response`: emitted on dismissal (Escape / scrim click). */
+    set_close_response(id: string): void;
+    /** `adw_alert_dialog_get_heading`. */
+    get_heading(): string;
+    /** `adw_alert_dialog_set_heading`. */
+    set_heading(heading: string): void;
+    /** `adw_alert_dialog_get_body`. */
+    get_body(): string;
+    /** `adw_alert_dialog_set_body`. */
+    set_body(body: string): void;
     private _activateResponse;
     /** Dismissal (Escape / scrim) — close, then emit the close-response. */
     private _dismiss;

package/lib/types/elements/adw-toast-overlay.d.ts

@@ -1,26 +1,14 @@
-import { AdwToast } from '@gjsify/adwaita-core';
-import type { ToastScheduler } from '@gjsify/adwaita-core';
+import type { Toast, ToastScheduler } from '@gjsify/adwaita-core';
 export type { ToastScheduler, ToastTimerHandle } from '@gjsify/adwaita-core';
-/** Options for {@link AdwToastOverlay.addToast}, mirroring Adw.Toast's properties. */
-export interface AdwToastOptions {
-    /** Seconds before the toast auto-dismisses; `0` keeps it until dismissed. Mirrors Adw.Toast:timeout (default 5). */
-    timeout?: number;
-    /** Label for the action button; omitted/empty means no button. Mirrors Adw.Toast:button-label. */
-    buttonLabel?: string;
-    /** Invoked when the action button is pressed. Mirrors the activation of Adw.Toast:action-name. */
-    onAction?: () => void;
-}
 export declare class AdwToastOverlay extends HTMLElement {
     private _toasts;
     private _initialized;
-    /** The headless one-at-a-time + FIFO + auto-dismiss state machine (ADR 0004). */
+    /** The headless queue of `adw-toast-overlay.c` (ADR 0004). */
     private readonly _queue;
     /** The timing source the queue's auto-dismiss runs on — swappable, see {@link scheduler}. */
     private _scheduler;
-    /** The strip currently mounted for {@link AdwToastQueue.current}, if any. */
+    /** The strip currently mounted for {@link ToastOverlayQueue.current}, if any. */
     private _currentEl;
-    /** Per-toast action callbacks (the core toast descriptor carries only the label). */
-    private readonly _actions;
     constructor();
     connectedCallback(): void;
     /**
@@ -32,22 +20,13 @@ export declare class AdwToastOverlay extends HTMLElement {
     get scheduler(): ToastScheduler;
     set scheduler(scheduler: ToastScheduler);
     /** The toast currently on screen, or `null` when nothing is shown. */
-    get currentToast(): AdwToast | null;
+    get currentToast(): Toast | null;
     /** Number of toasts queued behind the visible one. */
     get pendingToasts(): number;
-    /**
-     * Show a toast — the web equivalent of Adw.ToastOverlay.add_toast() with a
-     * freshly-built Adw.Toast. Only ONE toast is visible at a time; this one shows
-     * immediately when the slot is free, otherwise it waits its turn.
-     *
-     * `options` is either an {@link AdwToastOptions} bag or, as a legacy shorthand, a
-     * timeout in MILLISECONDS.
-     */
-    addToast(title: string, options?: number | AdwToastOptions): void;
-    /** Dismiss the visible toast early; the next queued toast takes its place. */
-    dismiss(): void;
-    /** Dismiss the visible toast and discard everything still queued behind it. */
-    clearToasts(): void;
+    /** `adw_toast_overlay_add_toast`: show `toast` now, or queue it by its priority. */
+    add_toast(toast: Toast): void;
+    /** `adw_toast_overlay_dismiss_all`: dismiss every queued toast, then the visible one. */
+    dismiss_all(): void;
     /** Build + attach the strip for `toast` — the DOM half of the queue's `onShow`. */
     private _mountToast;
     /**

package/lib/types/elements/adw-window-features.d.ts

@@ -1,4 +1,10 @@
 import { AdwBreakpoint } from '@gjsify/adwaita-core';
+/**
+ * A maximized or fullscreen `Gtk.Window` ignores its default size and fills the monitor's work
+ * area (gtkwindow.c: the default size is only the RESTORED size). The page's work area is the
+ * frame's containing block, which the skin sizes from these two attributes.
+ */
+export declare function fillsContainingBlock(host: HTMLElement): boolean;
 export declare class AdwWindowFeatures {
     private readonly _host;
     private _contentEl;
@@ -39,6 +45,8 @@ export declare class AdwWindowFeatures {
      * size; `width-request`/`height-request` override it). `default-width/height` is only
      * a default: an authored size is the box, and an absent one leaves the box to the
      * stylesheet, which fills the viewport — a page has no window manager to pick a size.
+     * While maximized or fullscreened the default size is not applied at all: the stylesheet
+     * fills the containing block, and the minimum still holds.
      */
     applySizeRequest(): void;
 }

package/lib/types/elements/gtk-application-window.d.ts

@@ -1,11 +1,8 @@
-import type { ActionLike } from '@gjsify/adwaita-core';
-import type { GtkApplication } from '../application.js';
+import { type ActionLike } from '@gjsify/adwaita-core';
 import type { DispatchedSignals } from '../signals.js';
 import type { AdwSlot } from '../slotted-children.js';
 import { GtkWindow } from './gtk-window.js';
 export declare class GtkApplicationWindow extends GtkWindow {
-    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
-    application: GtkApplication | null;
     /** `Gio.ActionMap.add_action`: installed by `installActionMap`; the action is reachable as `win.<name>`. */
     add_action: (action: ActionLike) => void;
     /** `Gio.ActionMap.lookup_action`: the window's own action, or `null`. */

package/lib/types/elements/gtk-emoji-chooser.d.ts

@@ -17,6 +17,8 @@ export declare class GtkEmojiChooser extends GtkPopover {
      * events themselves — which is what `gdk_device_get_modifier_state` answers.
      */
     private _ctrl;
+    /** The chooser's template is the child (gtkemojichooser.ui). */
+    protected takesChild(): boolean;
     connectedCallback(): void;
     /** The emoji picked most recently, newest first — what `recently-used-emoji` holds. */
     get recentEmoji(): EmojiEntry[];

package/lib/types/elements/gtk-popover-menu.d.ts

@@ -38,6 +38,8 @@ export declare class GtkPopoverMenu extends GtkPopover {
      */
     get visibleSubmenu(): string;
     set visibleSubmenu(value: string);
+    /** The menu's own stack is the child (gtkpopovermenu.c `gtk_popover_menu_init`). */
+    protected takesChild(): boolean;
     connectedCallback(): void;
     attributeChangedCallback(name?: string, previous?: string | null, value?: string | null): void;
     /** `gtk_popover_menu_open_submenu` — switch to the named page. */

package/lib/types/elements/gtk-popover.d.ts

@@ -67,6 +67,11 @@ export declare class GtkPopover extends HTMLElement {
     /** Subscribe to open-state changes. Returns an unsubscribe function. */
     subscribe(listener: (open: boolean) => void): () => void;
     connectedCallback(): void;
+    /**
+     * Whether `Gtk.Popover:child` is the author's to set. A subclass that builds its own
+     * content (GtkPopoverMenu, GtkEmojiChooser) sets the child itself, as their C does.
+     */
+    protected takesChild(): boolean;
     private _buildOnce;
     disconnectedCallback(): void;
     /**

package/lib/types/elements/gtk-stack-page.d.ts

@@ -0,0 +1,28 @@
+/** The attributes a record hands to its child on adoption — `GtkStackPage`'s string/boolean properties. */
+export declare const STACK_PAGE_ATTRIBUTES: readonly ["name", "title", "icon-name", "needs-attention", "use-underline"];
+export declare class GtkStackPage extends HTMLElement {
+    static get observedAttributes(): ("title" | "name" | "icon-name" | "use-underline" | "needs-attention")[];
+    /** `GtkStackPage:name` — what `visible-child-name` selects by. */
+    get name(): string;
+    set name(value: string | null);
+    /** `GtkStackPage:icon-name`. */
+    get iconName(): string | null;
+    set iconName(value: string | null);
+    /** `GtkStackPage:needs-attention`. */
+    get needsAttention(): boolean;
+    set needsAttention(value: boolean);
+    /** `GtkStackPage:use-underline`. */
+    get useUnderline(): boolean;
+    set useUnderline(value: boolean);
+    /** `GtkStackPage:visible` — `hidden`, as on the child the stack reads it from. */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /** `GtkStackPage:child` — the element the stack shows for this page, while not yet adopted. */
+    get child(): HTMLElement | null;
+    connectedCallback(): void;
+}
+/**
+ * The one element a record holds: its `slot="child"` child or its only element child. A record
+ * with none, or with more than one, is refused by name — GtkStackPage has exactly one `child`.
+ */
+export declare function pageChildOf(page: HTMLElement): HTMLElement | null;

package/lib/types/elements/gtk-stack.d.ts

@@ -118,7 +118,18 @@ export declare class GtkStack extends HTMLElement {
     private _page;
     /** `set_visible_child`'s "pick first visible" scan (gtkstack.c:1437-1450). */
     private _firstVisible;
+    /**
+     * A `<gtk-stack-page>` record, adopted: its child takes the record's place and its properties
+     * as the attributes this element reads, the way `<adw-view-stack>` adopts a declared page.
+     * Any other child is already the page and is handed back as it is.
+     */
+    private _adopt;
     private _initChild;
+    /**
+     * The observer watches the subtree, so an attribute record can come from anything below a
+     * page; only a direct child is a page of THIS stack (a nested stack's pages are its own).
+     */
+    private _isPage;
     private _onChildMutations;
     /** C's NULL page name is an ABSENT attribute, not the empty string (gtkstack.c:2216). */
     private _nameOrNull;

package/lib/types/elements/gtk-window.d.ts

@@ -1,3 +1,4 @@
+import { type GtkApplication } from '../application.js';
 import type { DispatchedSignals } from '../signals.js';
 import { type AdwSlot } from '../slotted-children.js';
 import './gtk-window-controls.js';
@@ -26,6 +27,10 @@ export declare class GtkWindow extends HTMLElement {
      * A `close-request` handler that returns true is `preventDefault()`.
      */
     static readonly signals: DispatchedSignals;
+    /** `Gtk.Window:application`: setting it is `add_window` (ADR 0098), set by `defineWindowApplication`. */
+    application: GtkApplication | null;
+    get_application: () => GtkApplication | null;
+    set_application: (application: GtkApplication | null) => void;
     /** `GObject.Object.connect`: installed per instance by `installElementApi`; refuses an undeclared signal. */
     connect: (signal: string, handler: (emitter: this, ...args: any[]) => unknown) => number;
     /** `GObject.Object.disconnect`: throws for an id that is not connected. */
@@ -55,6 +60,9 @@ export declare class GtkWindow extends HTMLElement {
     /** `Gtk.Window:maximized` — square corners and the restore glyph. */
     get maximized(): boolean;
     set maximized(value: boolean);
+    /** `Gtk.Window:fullscreened` — square corners, and the frame fills its containing block. */
+    get fullscreened(): boolean;
+    set fullscreened(value: boolean);
     /** `Gtk.Window:resizable` — whether the maximize button may appear. */
     get resizable(): boolean;
     set resizable(value: boolean);
@@ -112,7 +120,8 @@ export declare class GtkWindow extends HTMLElement {
     private _render;
     /**
      * The frame's box from `default-width` / `default-height`; an absent one clears it. A subclass
-     * with a size request of its own (`Adw.Window`'s 360×200) replaces this.
+     * with a size request of its own (`Adw.Window`'s 360×200) replaces this. A maximized or
+     * fullscreened frame carries no inline size: the skin fills its containing block.
      */
     protected renderFrameSize(): void;
     /**
@@ -170,4 +179,10 @@ export declare class GtkWindow extends HTMLElement {
     maximize(): void;
     /** `gtk_window_unmaximize`, with the same caveat as {@link maximize}. */
     unmaximize(): void;
+    /** `gtk_window_is_fullscreen`: the FRAME's state, like {@link is_maximized}. */
+    is_fullscreen(): boolean;
+    /** `gtk_window_fullscreen`; asynchronous in GTK, so the property is written directly. */
+    fullscreen(): void;
+    /** `gtk_window_unfullscreen`, with the same caveat as {@link fullscreen}. */
+    unfullscreen(): void;
 }

package/lib/types/gobject-elements.d.ts

@@ -13,6 +13,15 @@ export declare function dispatchElement(el: HTMLElement, signal: string, args: r
  * declares `sensitive` (`<adw-toggle-group>`) keeps its own.
  */
 export declare function installSensitive(el: HTMLElement): void;
+/** Whether `installVisible` gave `el` its `visible` (an element with its own keeps its own). */
+export declare function hasInstalledVisible(el: Element): boolean;
+/**
+ * `Gtk.Widget:visible` for an element that has no member of that name: `gtk_widget_get_visible`
+ * and `gtk_widget_set_visible` over the DOM's `hidden` attribute, TRUE until hidden as GtkWidget's
+ * default is. It notifies only where the element declares `notify::visible`. An element that already declares `visible` (`<gtk-stack-page>`, `<adw-sidebar>`)
+ * keeps its own, and so does a registered class whose prototype has the port's members.
+ */
+export declare function installVisible(el: HTMLElement): void;
 /** Gives `el` the instance API of a registered class, over the events it declares. */
 export declare function installElementApi(el: HTMLElement): void;
 /**

package/lib/types/index.d.ts

@@ -5,8 +5,8 @@ export { adwaitaAccentSource, applyDesktopAppearance, applySystemAccent, followD
 export type { AdwAccentSource } from './appearance.js';
 export { AdwScrollShading } from './scroll-shading.js';
 export type { AdwUndershootEdges } from './scroll-shading.js';
-export { buildSharedTree, mountSharedTree } from './shared-tree-builder.js';
-export type { MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
+export { buildSharedTree, buildWithSiblings, mountSharedTree } from './shared-tree-builder.js';
+export type { BuildOptions, BuiltTree, MountOptions, MountedSharedTree, SizeSource } from './shared-tree-builder.js';
 export { registerTemplateClass } from './template-classes.js';
 export { isIconAvailable, registerIcon } from './icon-registry.js';
 export { registerColorIcon } from './icon-theme.js';

package/lib/types/learn6502-window.spec.d.ts

@@ -0,0 +1 @@
+export declare const AdwLearn6502WindowTest: () => Promise<void>;

package/lib/types/namespace/adw.d.ts

@@ -56,4 +56,4 @@ export { AdwWindowTitle as WindowTitle } from '../elements/adw-window-title.js';
 export { AdwWrapBox as WrapBox } from '../elements/adw-wrap-box.js';
 export { AdwApplication as Application } from '../application.js';
 export { AdwStyleManager as StyleManager } from '../style-manager.js';
-export { ColorScheme } from '@gjsify/adwaita-core';
+export { ColorScheme, Toast, ToastPriority } from '@gjsify/adwaita-core';

package/lib/types/namespace/gtk.d.ts

@@ -62,6 +62,7 @@ export { GtkSeparator as Separator } from '../elements/gtk-separator.js';
 export { GtkSpinButton as SpinButton } from '../elements/gtk-spin-button.js';
 export { GtkSpinner as Spinner } from '../elements/gtk-spinner.js';
 export { GtkStack as Stack } from '../elements/gtk-stack.js';
+export { GtkStackPage as StackPage } from '../elements/gtk-stack-page.js';
 export { GtkStackSidebar as StackSidebar } from '../elements/gtk-stack-sidebar.js';
 export { GtkStackSwitcher as StackSwitcher } from '../elements/gtk-stack-switcher.js';
 export { GtkStringList as StringList } from '@gjsify/adwaita-core';
@@ -76,6 +77,7 @@ export type { WindowCommon } from '@gjsify/adwaita-core';
 export { GtkWindowControls as WindowControls } from '../elements/gtk-window-controls.js';
 export { GtkViewport as Viewport } from '../elements/gtk-viewport.js';
 export { GtkWindowHandle as WindowHandle } from '../elements/gtk-window-handle.js';
+export { ApplicationInhibitFlags } from '@gjsify/adwaita-core';
 export { GtkApplication as Application } from '../application.js';
 export { STYLE_PROVIDER_PRIORITY_APPLICATION, STYLE_PROVIDER_PRIORITY_FALLBACK, STYLE_PROVIDER_PRIORITY_SETTINGS, STYLE_PROVIDER_PRIORITY_THEME, STYLE_PROVIDER_PRIORITY_USER, } from '@gjsify/adwaita-core';
 export { CssProvider, EventControllerKey, IconTheme, show_uri, StyleContext, Settings } from './gtk-platform.js';

package/lib/types/shared-tree-builder.d.ts

@@ -77,6 +77,37 @@ interface PendingBind {
  * upgraded has declared no slots yet, so the refusal below belongs to the mount.
  */
 export declare function buildSharedTree(node: SharedTreeNode, record?: BuildRecord): HTMLElement;
+/** What {@link buildWithSiblings} hands back: the root element and the objects built beside it. */
+export interface BuiltTree {
+    /** The element the tree roots at, as {@link buildSharedTree} returns it. */
+    root: HTMLElement;
+    /**
+     * The sibling objects by id — `Adw.AlertDialog unsavedChangesDialog { }` or `$Learn learn { }`
+     * written after the template. A sibling is built in the root's id scope (a setter or a bind
+     * may name it) but is no child of the root: the code beside the file decides where, or
+     * whether, it is placed.
+     */
+    siblings: ReadonlyMap<string, HTMLElement>;
+    /** Every element the tree names by id, siblings included: what `GtkBuilder.get_object` answers for. */
+    objects: ReadonlyMap<string, HTMLElement>;
+}
+/** What {@link buildWithSiblings} takes beside the tree. */
+export interface BuildOptions {
+    /** The object a handler NAME is looked up on (ADR 0093 § 3). */
+    scope?: Readonly<Record<string, unknown>>;
+    /** The size source a `breakpoints` node is driven from. */
+    observeSize?: SizeSource;
+}
+/**
+ * A tree with sibling roots (ADR 0093): the root element, and each sibling by id, all DETACHED
+ * like {@link buildSharedTree}'s result.
+ *
+ * {@link buildSharedTree}, {@link mountSharedTree} and {@link buildTemplateTree} refuse such a
+ * tree by name, because they return one element and the siblings would be built and then thrown
+ * away. A sibling with no id is refused too: nothing could ever ask for it, which is how a
+ * dropped object looks finished.
+ */
+export declare function buildWithSiblings(node: SharedTreeNode, options?: BuildOptions): BuiltTree;
 /**
  * One authored property, written as the element reads it; a breakpoint setter takes the same door.
  *