@gjsify/adwaita-web 0.54.0 → 0.55.0

package/lib/types/elements/gtk-print-unix-dialog.d.ts

@@ -0,0 +1,167 @@
+import { type PageSetup } from '../page-setup.js';
+import { AdwDialog } from './adw-dialog.js';
+/** The `GtkPrintCapabilities` nicks, in enum order (the GIR's own spelling). */
+declare const CAPABILITY_NICKS: readonly ["collate", "copies", "generate-pdf", "generate-ps", "number-up", "number-up-layout", "page-set", "preview", "reverse", "scale"];
+/** One `GtkPrintCapabilities` nick. */
+export type PrintCapability = (typeof CAPABILITY_NICKS)[number];
+/** One row of the printer list — what `GtkPrinter` answers name / location / icon for. */
+export interface PrinterInfo {
+    readonly name: string;
+    readonly location?: string;
+    /** The `.ui`'s icon column, from the printer's own `icon-name`. */
+    readonly iconName?: string;
+    /** `gtk_printer_is_accepting_jobs` — what gates the Print button. */
+    readonly acceptsJobs?: boolean;
+    /** `gtk_printer_get_capabilities` — the second half of every sensitivity gate. */
+    readonly capabilities?: readonly PrintCapability[];
+    /** Whether the row passes `is_printer_active` (:1164-1186). */
+    readonly active?: boolean;
+}
+/** The `Gtk.PrintSettings` this dialog carries, in the keys its own UI sets. */
+export interface PrintSettingsData {
+    /** `format-for-printer` — the printer the settings belong to. */
+    readonly 'format-for-printer'?: string;
+    /** `copies` — a string, because `GtkPrintSettings` values are all strings. */
+    readonly copies?: string;
+    /** `collate` / `reverse` — `"0"` or `"1"`, as CUPS writes them. */
+    readonly collate?: string;
+    readonly reverse?: string;
+    /** `page-set` — `all` / `even` / `odd`, the index into `PAGE_SET_ITEMS`. */
+    readonly 'page-set'?: string;
+    /** `scale` — a percentage, as a string. */
+    readonly scale?: string;
+    /** `orientation` — `portrait` … `reverse-landscape`. */
+    readonly orientation?: string;
+    /** `print-at` — an ISO timestamp for the "At:" branch. */
+    readonly 'print-at'?: string;
+    /** `printer-setting-…` — the per-printer option groups of the Job tab. */
+    readonly [key: string]: string | undefined;
+}
+export declare class GtkPrintUnixDialog extends AdwDialog {
+    private _built;
+    private _printers;
+    private _selected;
+    private _settings;
+    private _pageSetup;
+    private _printerListEl;
+    private _switcherEl;
+    private _panelEl;
+    private _tabPages;
+    private _tab;
+    private _currentPage;
+    private _supportSelection;
+    private _hasSelection;
+    private _manual;
+    private _range;
+    private _printAt;
+    private _printButton;
+    private _previewButton;
+    private _conflictsEl;
+    private _capabilityControls;
+    private _collateCheck;
+    private _reverseCheck;
+    private _copiesInput;
+    private _paperDrop;
+    private _orientationDrop;
+    private _pageRangeInput;
+    private _selectionRadio;
+    private _currentPageRadio;
+    private _rangeRadios;
+    private _atInput;
+    static get observedAttributes(): string[];
+    /** `current-page`, in 0-based document pages; -1 disables "Current Page". */
+    get currentPage(): number;
+    set currentPage(value: number);
+    /** Whether the page-setup controls are EMBEDDED rather than in their own dialog. */
+    get embedPageSetup(): boolean;
+    set embedPageSetup(value: boolean);
+    /** Whether the application has a selection to print. */
+    get hasSelection(): boolean;
+    set hasSelection(value: boolean);
+    /** Whether the application supports printing a selection. */
+    get supportSelection(): boolean;
+    set supportSelection(value: boolean);
+    /** The capabilities the APPLICATION handles, as `GtkPrintCapabilities` nicks. */
+    get manualCapabilities(): PrintCapability[];
+    set manualCapabilities(value: readonly PrintCapability[]);
+    /** The chosen printer, or `null` — `gtk_print_unix_dialog_get_selected_printer`. */
+    get selectedPrinter(): PrinterInfo | null;
+    /** The page setup, as the plain `PageSetup` the value model defines. */
+    get pageSetup(): PageSetup;
+    set pageSetup(value: PageSetup);
+    /** The print settings, in the keys the dialog's own controls write. */
+    get printSettings(): PrintSettingsData;
+    set printSettings(value: PrintSettingsData);
+    /**
+     * Which of the four range buttons is active — the radio group the `.ui` calls the
+     * Range frame. GTK has no property for it either: the dialog READS whichever of the four
+     * `GtkCheckButton`s is active (`dialog_get_page_range`), and that is what this holds.
+     */
+    get range(): 'all' | 'current' | 'selection' | 'pages';
+    set range(value: 'all' | 'current' | 'selection' | 'pages');
+    /** The printers a print backend would have discovered. An INPUT here — see the header. */
+    get printers(): PrinterInfo[];
+    set printers(value: readonly PrinterInfo[]);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * `manual-capabilities` takes the nick SET the GIR generates, `|`-separated —
+     * `manual-capabilities="page-set|copies|collate|reverse|scale|preview"`. Unknown
+     * nicks are dropped, which is what the GIR-validated setter does with them.
+     */
+    private _readManual;
+    protected decorateHeader(header: HTMLElement): void;
+    private _build;
+    /**
+     * Every page of the notebook, built once and hidden but for the visible one —
+     * which is what `GtkNotebook` holds: all seven pages exist whether shown or not,
+     * so the capability pass can reach every control from the first render.
+     */
+    private _renderPanel;
+    private _buildTab;
+    /** General: the printer list, then Range and Copies. */
+    private _buildGeneral;
+    /** `page_collate_preview`: four thumbnails whose NUMBERS show the ordering. */
+    private _buildCollatePreview;
+    /** Page Setup: Layout and Paper beside the sheet preview. */
+    private _buildPageSetup;
+    /**
+     * `page_layout_preview` (:2683) + `draw_page` (:2283): the sheet at 110px on its long
+     * edge, divided by the number-up grid with each cell numbered in the number-up order.
+     * The ruler the C draws around it is decoration outside the sheet and is not painted.
+     */
+    private _buildSheetPreview;
+    /** Job: Job Details, Print Document, Add Cover Page. */
+    private _buildJob;
+    /**
+     * One of the four option pages: the scrolled viewport + grid the C's
+     * `GtkPrinterOptionWidget`s are added to. There are none without a backend, so the grid
+     * is empty and says so rather than inventing options.
+     */
+    private _buildOptionsPage;
+    /** The option grid, one row per option group the backend would offer. */
+    private _optionsGrid;
+    /** The conflicts action bar — hidden until `mark_conflicts` finds one (:3050-3060). */
+    private _buildConflicts;
+    /** Preview / Cancel / Print, in the `.ui`'s order and with its own response ids. */
+    private _buildActions;
+    private _respond;
+    /**
+     * One `frame_templateN`: a BOLD heading over a grid, which is the shape every group in
+     * the `.ui` has — `box > box > grid` with the heading's `weight=bold`.
+     */
+    private _group;
+    private _labelledRow;
+    private _dropDown;
+    private _radio;
+    private _check;
+    private _frame;
+    /** `selected_printer_changed` (:1821-1915) — the list and what selecting does. */
+    private _printerChanged;
+    private _paperChanged;
+    /** Every capability the dialog currently has: the manual half OR the printer's. */
+    private _capabilities;
+    /** `update_dialog_from_capabilities` (:1563-1592), every line of it. */
+    private _renderPrint;
+}
+export {};

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

@@ -0,0 +1,55 @@
+/** Every `GtkRevealerTransitionType` nick, in GIR order. */
+declare const TRANSITION_TYPES: readonly ["none", "crossfade", "slide-right", "slide-left", "slide-up", "slide-down", "swing-right", "swing-left", "swing-up", "swing-down", "fade-slide-right", "fade-slide-left", "fade-slide-up", "fade-slide-down"];
+export type RevealerTransitionType = (typeof TRANSITION_TYPES)[number];
+export declare class GtkRevealer extends HTMLElement {
+    private _clipEl;
+    private _initialized;
+    /** `current_pos` — 0 hidden, 1 shown. */
+    private _position;
+    /** `target_pos` — where the running animation is headed. */
+    private _target;
+    private _frame;
+    private _startedAt;
+    /** The child's own size — `child_width` / `child_height` in the C. */
+    private _naturalWidth;
+    private _naturalHeight;
+    private _resize;
+    static get observedAttributes(): string[];
+    /** `Gtk.Revealer:reveal-child` — whether the child should be revealed. */
+    get revealChild(): boolean;
+    set revealChild(value: boolean);
+    /** `Gtk.Revealer:child-revealed` — read-only; the header says why it inverts. */
+    get childRevealed(): boolean;
+    /** `Gtk.Revealer:transition-type`. An unknown nick leaves `slide-down` in place. */
+    get transitionType(): RevealerTransitionType;
+    set transitionType(value: RevealerTransitionType);
+    /** `Gtk.Revealer:transition-duration`, in ms. An unparseable one is the default. */
+    get transitionDuration(): number;
+    set transitionDuration(value: number);
+    /** `Gtk.Revealer:child` — the light-DOM node the clip box adopted. */
+    get child(): Element | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /**
+     * Point the measurement at the CHILD, not at the clip box.
+     *
+     * The C asks the child for its requisition (gtkrevealer.c:140) and scales the result,
+     * so the child is the subject; observing the clip box instead would report the ALREADY
+     * SCALED box, and the scale would then be applied twice.
+     */
+    private _observeChild;
+    /** `gtk_revealer_start_animation` (gtkrevealer.c:275-322). `@returns` whether it moved. */
+    private _animate;
+    /** `gtk_revealer_animate_cb` (gtkrevealer.c:255-272). */
+    private _tick;
+    private _finish;
+    /** `effective_transition` (gtkrevealer.c:121-141). */
+    private get effectiveTransition();
+    /** `get_child_size_scale` (gtkrevealer.c:144-186) for one axis. */
+    private _scale;
+    /** `gtk_revealer_set_position` (gtkrevealer.c:212-251). */
+    private _setPosition;
+    private _render;
+}
+export {};

package/lib/types/elements/gtk-scale-button.d.ts

@@ -0,0 +1,59 @@
+import './gtk-popover.js';
+export declare class GtkScaleButton extends HTMLElement {
+    private readonly _state;
+    private _buttonEl;
+    private _glyph;
+    private _dockEl;
+    private _rangeEl;
+    private _minusEl;
+    private _plusEl;
+    private _icons;
+    private _initialized;
+    /** Set while a render writes the range, so its `input` echo is not fed back. */
+    private _syncing;
+    static get observedAttributes(): string[];
+    /** `Gtk.ScaleButton:value` — always inside the adjustment's range. */
+    get value(): number;
+    set value(value: number);
+    /** `Gtk.ScaleButton:active` — read-only upstream, so read-only here. */
+    get active(): boolean;
+    /** `Gtk.ScaleButton:icons` — the icon names the value picks from. */
+    get icons(): string[];
+    set icons(value: string[]);
+    /** `Gtk.ScaleButton:has-frame` — false by default, which is a flat button here. */
+    get hasFrame(): boolean;
+    set hasFrame(value: boolean);
+    /** `GtkOrientable:orientation` — vertical by default, the GTK shape of the button. */
+    get orientation(): 'horizontal' | 'vertical';
+    set orientation(value: 'horizontal' | 'vertical');
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /** `cb_scale_value_changed` (:1092-1114) — the icon, the steppers, then the signals. */
+    private _applyValue;
+    /** The range, from GTK's default with whatever `adjustment` authored over it. */
+    private _syncAdjustment;
+    private _render;
+    private _stepButton;
+    private _toggleDock;
+    /** `gtk_scale_popup` (:940-948) — press the button in, which pops the dock up. */
+    private _dock;
+    /** The dock closing on its own — an outside click or Escape. */
+    private _renderDock;
+    /** `button_click` (:1000-1013): one PAGE increment, and the end of the range stops it. */
+    private _step;
+    /** Space / Return / Enter pop up, Escape pops down — the bindings `class_init` adds. */
+    private _onKeyDown;
+}
+/**
+ * `gtk_scale_button_update_icon` (:1040-1098) — which of the icon names the value picks.
+ * Transcribed including the arithmetic, because "spread evenly" is only true of the
+ * interior: `lower` and `upper` always take the first two names.
+ */
+export declare function selectIcon(icons: string[], value: number, lower: number, upper: number): string;
+/**
+ * The `icons` attribute, as the portable array a list-model property takes elsewhere
+ * (ADR 0046). Total in every failure mode, because malformed JSON is an author slip that
+ * must not stop the element upgrading — and an empty list has an answer of its own,
+ * `image-missing` (:1046-1050).
+ */
+export declare function parseIcons(raw: string | null | undefined): string[];

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

@@ -0,0 +1,98 @@
+import type { AdwAdjustment, AdwAdjustmentInput, BoxOrientation } from '@gjsify/adwaita-core';
+/** `Gtk.PositionType` nicks, as `GtkScale:value-pos` spells them. */
+declare const VALUE_POSITIONS: readonly ["left", "right", "top", "bottom"];
+/** `GtkScale:value-pos` in the order libadwaita lays the value out: default `top`. */
+type ValuePosition = (typeof VALUE_POSITIONS)[number];
+/**
+ * `gtk_scale_format_value`'s default arm plus `weed_out_neg_zero` (gtkscale.c:1230-1245).
+ *
+ * Exported for the widget's own spec; `<gtk-spin-button>` carries the SAME `g_strdup_printf
+ * ("%0.*f")` in its own C (`gtk_spin_button_format_for_value`, gtkspinbutton.c:1319-1326) with
+ * a different `digits` default, and reuses this rather than growing a second copy of it.
+ */
+export declare function formatScaleValue(value: number, digits: number): string;
+export declare class GtkScale extends HTMLElement {
+    /** The headless `Gtk.Adjustment`: the range, the clamp and the two signals (ADR 0004, ADR 0047). */
+    private readonly _range;
+    private _trough;
+    private _highlight;
+    private _fill;
+    private _slider;
+    private _value;
+    private _initialized;
+    private _pointerId;
+    static get observedAttributes(): string[];
+    /** `GtkOrientable:orientation` — `horizontal` (the default) or `vertical`. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    /** The numeric range — `Gtk.Range:adjustment`, as the portable value. Writes MERGE. */
+    get adjustment(): AdwAdjustment;
+    set adjustment(value: AdwAdjustmentInput | string);
+    /** `Gtk.Range:value` — always inside `adjustmentRange`. */
+    get value(): number;
+    set value(v: number);
+    /** `Gtk.Range:inverted`. */
+    get inverted(): boolean;
+    set inverted(value: boolean);
+    /** `GtkScale:draw-value` — whether the value is shown beside the slider. */
+    get drawValue(): boolean;
+    set drawValue(value: boolean);
+    /** `GtkScale:value-pos` — `left`, `right`, `top` (the default) or `bottom`. */
+    get valuePos(): ValuePosition;
+    set valuePos(value: ValuePosition);
+    /** `GtkScale:has-origin` — the default, so the highlight exists unless it is cleared. */
+    get hasOrigin(): boolean;
+    set hasOrigin(value: boolean);
+    /** `GtkScale:digits` — decimal places in the value text. */
+    get digits(): number;
+    set digits(value: number);
+    /** `Gtk.Range:fill-level` — the buffer level a media player would draw. */
+    get fillLevel(): number;
+    set fillLevel(value: number);
+    /** `Gtk.Range:show-fill-level` — no property by default, as `gtk_range_init` leaves it. */
+    get showFillLevel(): boolean;
+    set showFillLevel(value: boolean);
+    /** `Gtk.Range:restrict-to-fill-level`. */
+    get restrictToFillLevel(): boolean;
+    set restrictToFillLevel(value: boolean);
+    /** The knob, for a consumer that needs to measure it (`coord_to_value` needs its length). */
+    get slider(): HTMLElement;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `gtk_range_real_change_value`'s write, with the range's own clamp inside `SpinState`.
+     *
+     * `restrict-to-fill-level` and `round-digits` are `GtkRange`'s own two lines before the
+     * CLAMP (gtkrange.c:2873-2891), so they belong here rather than in the element's setter.
+     * `interactive` is what separates a drag from a programmatic write in `SpinState`.
+     */
+    private _setValue;
+    /**
+     * `coord_to_value` (gtkrange.c:1838-1878), which is `GtkScale`'s whole pointer mapping.
+     *
+     * A SCALE sets `slider_size_fixed`, so the fraction is `coord / trough_length` and the
+     * slider's own length does not shorten the track — the knob's CENTRE is the value. An
+     * equal-length degenerate trough answers 1.0, as C does.
+     */
+    private _valueAtCoord;
+    /**
+     * `should_invert` (gtkrange.c:1806-1818) for a scale, which is always `flippable`
+     * (`gtk_scale_init`, gtkscale.c:838).
+     *
+     * A horizontal scale in a RIGHT-TO-LEFT document is the case the `flippable` flag
+     * exists for: `inverted` false already reads backwards there, so the two cancel and
+     * the fraction is used as it comes.
+     */
+    private _shouldInvert;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    /**
+     * The keys `GtkScale` binds (gtkscale.c:745-800), and none of them is orientation-bound:
+     * the C says so in its own comment, because a blind user should not have to know which
+     * way the slider runs.
+     */
+    private _onKeyDown;
+    private _render;
+}
+export {};

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

@@ -0,0 +1,124 @@
+import { type AdwAdjustment, type AdwAdjustmentInput, type BoxOrientation } from '@gjsify/adwaita-core';
+/** `GtkScrollType`'s six kinds, which is what a `scroll-child` names. */
+export type GtkScrollType = 'step-backward' | 'step-forward' | 'page-backward' | 'page-forward' | 'start' | 'end';
+export declare class GtkScrollbar extends HTMLElement {
+    private _trough;
+    private _slider;
+    private _observer;
+    private _built;
+    private _adjustment;
+    /** `priv->slide_initial_slider_position` — the slider's position when the drag began. */
+    private _grabPosition;
+    /** `priv->slide_initial_coordinate_delta` — how far into the slider the pointer was. */
+    private _grabDelta;
+    /** `priv->zoom` — the fine adjustment, `.fine-tune` and all. */
+    private _zoom;
+    private _dragging;
+    static get observedAttributes(): string[];
+    /** `GtkOrientable:orientation` — HORIZONTAL in `gtk_scrollbar_init`; unknown is that. */
+    get orientation(): BoxOrientation;
+    set orientation(value: BoxOrientation);
+    /**
+     * `GtkScrollbar:adjustment` — the range this bar moves, as the portable value.
+     *
+     * NEVER `null`, which is the half of this property that is easy to get wrong: GTK's
+     * pspec default is NULL, but `gtk_range_set_adjustment` answers a NULL with the ZERO
+     * adjustment (gtkrange.c:687-688) and `gtk_range_get_adjustment` creates it on demand
+     * (gtkrange.c:658-659), so a bare `GtkScrollbar` reads back a real adjustment whose
+     * `upper` is 0. A read that could return null would be a property GTK's own does not
+     * have, and the slider geometry would have to carry a second "nothing here" case.
+     *
+     * A string is read as the JSON the attribute carries, so the property and the
+     * attribute are one write; a partial object MERGES, which is
+     * `gtk_adjustment_configure`'s own contract (gtkadjustment.c). Assigning `null` is
+     * `gtk_scrollbar_set_adjustment (self, NULL)`: the zero adjustment again, and the
+     * property is assigned rather than merged.
+     */
+    get adjustment(): AdwAdjustment;
+    set adjustment(value: AdwAdjustmentInput | string | null);
+    /** The position, which is the adjustment's own value (gtkrange.c:1168-1176). */
+    get value(): number;
+    /**
+     * `gtk_adjustment_set_value`: move the range, clamped, and announce it.
+     *
+     * A scrollbar is a VIEW of an adjustment it does not own, so the `value-changed`
+     * CustomEvent (bubbles, detail `{ adjustment }`) stands for `GtkAdjustment`'s signal —
+     * and `<gtk-scrolled-window>` is what listens, exactly as GTK reads the adjustment off
+     * the scrollbar it owns (`gtk_scrolled_window_scroll_child`, gtkscrolledwindow.c:3007).
+     *
+     * Over the zero adjustment `set_value` CLAMPS to 0 and reports no change, so a bar with
+     * no adjustment of its own is inert without being a special case anywhere.
+     */
+    set value(value: number);
+    /**
+     * The value one `GtkScrollType` moves by, which is `gtk_scrolled_window_scroll_child`'s
+     * switch.
+     *
+     * `scrollBy` is a platform method with a delta form, so both are here and the KIND of the
+     * argument decides — a `GtkScrollType` nick moves the adjustment, a number or a
+     * `ScrollToOptions` is the scrollport's own call, which a bar has none of (it is not a
+     * scrollport) and which therefore lands on no adjustment and does nothing.
+     */
+    scrollBy(kind: GtkScrollType): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    /** How far a wheel detent moves the value: `scroll_delta_to_value` on a WHEEL unit. */
+    scrollByWheel(deltaY: number, deltaMode: number): void;
+    /**
+     * `gtk_range_get_range_area`-ish: the length of the trough, which is what the slider
+     * is a fraction of. Read on demand so a caller can scale with the same numbers.
+     */
+    private get _troughLength();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _notify;
+    /**
+     * The trough's three rules and the slider's drag, at the settings default
+     * (`gtk_range_click_gesture_pressed`, gtkrange.c:2018-2138).
+     */
+    private _onPointerDown;
+    /**
+     * `update_slider_position`: the pointer's travel since the grab, scaled by the zoom,
+     * added to where the slider WAS — so the slider keeps the offset it was grabbed at.
+     */
+    private _onPointerMove;
+    private _onPointerEnd;
+    private _endDrag;
+    /**
+     * Keep the gesture alive past the bar's own edges, which is what `GtkGestureDrag` does
+     * upstream for as long as the button is held.
+     *
+     * `setPointerCapture` THROWS for a pointer id the platform is no longer tracking, and an
+     * exception here would abort the gesture before the warp or the page that follows it —
+     * which is not a state a scrollbar can be in. So a refused capture is a drag that ends at
+     * the bar's edge, and the synchronous move still happens.
+     */
+    private _capture;
+    /** The keys `GtkScrollbar`'s own doc names: the arrow keys step, Page Up/Down page. */
+    private _onKeyDown;
+    private _onWheel;
+    private _setZoom;
+    /** `update_slider_position`'s zoom: the trough per unit of range, or the fallback. */
+    private _zoomFactor;
+    /**
+     * `gtk_range_compute_slider_position`, in CSS pixels.
+     *
+     * The slider's length is a fraction of the WHOLE adjustment range and its position a
+     * fraction of the SCROLLABLE one, which is why the two denominators differ and why
+     * neither is a plain percentage of the trough. A range with nothing to scroll is the
+     * `trough_length == slider_length` case upstream and answers 1.0.
+     */
+    private _render;
+    /** Where the slider's START is along the trough, in pixels. */
+    private _sliderPosition;
+    /** The slider's own length, in pixels, from the last layout. */
+    private _sliderSize;
+    /**
+     * `coord_to_value` (gtkrange.c:1842-1886): a coordinate along the trough scaled by the
+     * FREE space — the trough less the slider — because the slider's centre has to reach
+     * both ends and not one of them twice over.
+     */
+    private _coordinateValue;
+    /** The pointer's coordinate along the trough, from the trough's own box. */
+    private _coordinate;
+}

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

@@ -0,0 +1,121 @@
+import { GtkViewport } from './gtk-viewport.js';
+/** `GtkPolicyType`'s four nicks; `automatic` is the pspec's default for both bars. */
+export type GtkPolicyType = 'always' | 'never' | 'automatic' | 'external';
+/** `GtkCornerType`'s four corners, `top-left` being the pspec's default. */
+export type GtkCornerType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+/** `Gtk.PositionType`'s four edges, as `edge-reached` and `edge-overshot` name them. */
+export type GtkPositionType = 'left' | 'right' | 'top' | 'bottom';
+/** `Gtk.DirectionType`'s two, as `move-focus-out` names them. */
+export type GtkDirectionType = 'forward' | 'backward';
+export declare class GtkScrolledWindow extends HTMLElement {
+    private _viewport;
+    private _bars;
+    private _shading;
+    private _observer;
+    private _hoverable;
+    private _fadeTimer;
+    private _built;
+    static get observedAttributes(): string[];
+    /** `GtkScrolledWindow:hscrollbar-policy` — `automatic` in the pspec. */
+    get hscrollbarPolicy(): GtkPolicyType;
+    set hscrollbarPolicy(value: GtkPolicyType);
+    /** `GtkScrolledWindow:vscrollbar-policy` — `automatic` in the pspec. */
+    get vscrollbarPolicy(): GtkPolicyType;
+    set vscrollbarPolicy(value: GtkPolicyType);
+    /** `GtkScrolledWindow:window-placement` — where the contents sit against the bars. */
+    get windowPlacement(): GtkCornerType;
+    set windowPlacement(value: GtkCornerType);
+    /** `GtkScrolledWindow:has-frame` — the `.frame` style class on the node, and nothing more. */
+    get hasFrame(): boolean;
+    set hasFrame(value: boolean);
+    /** `GtkScrolledWindow:overlay-scrolling` — TRUE in the pspec, and unknown is that. */
+    get overlayScrolling(): boolean;
+    set overlayScrolling(value: boolean);
+    /** `GtkScrolledWindow:min-content-width`, in px, or `null` for the pspec's -1. */
+    get minContentWidth(): number | null;
+    set minContentWidth(value: number | null);
+    /** `GtkScrolledWindow:min-content-height`, in px, or `null` for the pspec's -1. */
+    get minContentHeight(): number | null;
+    set minContentHeight(value: number | null);
+    /** `GtkScrolledWindow:max-content-width`, in px, or `null` for the pspec's -1. */
+    get maxContentWidth(): number | null;
+    set maxContentWidth(value: number | null);
+    /** `GtkScrolledWindow:max-content-height`, in px, or `null` for the pspec's -1. */
+    get maxContentHeight(): number | null;
+    set maxContentHeight(value: number | null);
+    /** `GtkScrolledWindow:propagate-natural-width` — FALSE in the pspec, so absent is that. */
+    get propagateNaturalWidth(): boolean;
+    set propagateNaturalWidth(value: boolean);
+    /** `GtkScrolledWindow:propagate-natural-height` — FALSE in the pspec, so absent is that. */
+    get propagateNaturalHeight(): boolean;
+    set propagateNaturalHeight(value: boolean);
+    /**
+     * `gtk_scrolled_window_get_hscrollbar` / `get_vscrollbar`, as METHODS and not getters.
+     *
+     * `connect-lifecycle.spec.ts` reads a get-only accessor returning an element as an
+     * invitation to append into it, and a scrollbar that is not visible is not an append
+     * point — which is the whole of what a getter here would be asking for.
+     */
+    hscrollbar(): HTMLElement | null;
+    vscrollbar(): HTMLElement | null;
+    /** The `<gtk-viewport>` the child sits in — the one GTK's `set_child` builds for itself. */
+    get viewport(): GtkViewport;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** The NORMALISED value a notify carries, which is the property and not the raw attribute. */
+    private _normalized;
+    private _writeSizeRequest;
+    /**
+     * `priv->use_indicators` — the AND of the property with the `gtk-overlay-scrolling`
+     * setting, whose browser spelling is whether a pointer that can hover exists at all.
+     */
+    private get _useIndicators();
+    /** Everything the pspec's own state decides: the classes, the bars, the sizes. */
+    private _sync;
+    private _size;
+    /** The viewport's adjustment for one axis, which is where GTK reads the scrollbar's. */
+    private _adjustment;
+    /**
+     * `may_hscroll` / `may_vscroll`: a bar that is DRAWN, or an EXTERNAL policy, which is a
+     * scrollbar this window does not show but can still be driven with.
+     */
+    private _mayScroll;
+    /**
+     * The viewport moved: hand the position to the bars, ask whether an edge was REACHED
+     * (`maybe_emit_edge_reached` fires whenever the adjustment lands exactly on `lower` or
+     * `upper - page_size`, gtkscrolledwindow.c:3629-3661) and fade the indicators in.
+     */
+    private _onViewportValue;
+    /**
+     * A bar moved: move the scrollport. GTK's direction is the other way round — the
+     * adjustment belongs to the scrollbar and the scrolled window reads it — which is why
+     * the bar is given the adjustment here instead of owning it: the numbers are the same
+     * either way, and one writer per side is what keeps them from fighting.
+     */
+    private _onBarValue;
+    private _edgeReached;
+    /**
+     * `_gtk_scrolled_window_set_adjustment_value`'s `EDGE_OVERSHOT`, from the shading
+     * controller's unclamped position: negative is the near edge, positive the far one,
+     * and `0` is the settled case the C returns without emitting — it is the value CLAMPED
+     * to `lower - MAX_OVERSHOOT_DISTANCE` and `upper - page_size + MAX_OVERSHOOT_DISTANCE`
+     * that the signal compares (gtkscrolledwindow.c:3306-3352).
+     */
+    private _edgeOvershot;
+    /** The keys of `gtk_scrolled_window_class_init`, and the two signals they emit. */
+    private _onKeyDown;
+    /**
+     * `indicator_start_fade(indicator, 1.0)` on every value change, and
+     * `maybe_hide_indicator`'s check `INDICATOR_FADE_OUT_DELAY` after the last one — a poll
+     * upstream, one timer here, and `!indicator->over` is the `.hovering` class (a pointer
+     * over the indicator holds it open).
+     */
+    private _fadeIn;
+    private _fadeOut;
+    private _clearFade;
+    private _onIndicatorOver;
+    private _onIndicatorOut;
+    private _onHoverableChange;
+    private _releaseHoverable;
+}

package/lib/types/elements/gtk-search-bar.d.ts

@@ -0,0 +1,39 @@
+export declare class GtkSearchBar extends HTMLElement {
+    private _box;
+    private _center;
+    private _close;
+    private _initialized;
+    private _capture;
+    private readonly _onCapturedKey;
+    private readonly _onInput;
+    static get observedAttributes(): string[];
+    /** `Gtk.SearchBar:search-mode-enabled` — the revealer's `reveal-child`. Defaults FALSE. */
+    get searchModeEnabled(): boolean;
+    set searchModeEnabled(value: boolean);
+    /** `Gtk.SearchBar:show-close-button` — the `.close` button at the end of the box. */
+    get showCloseButton(): boolean;
+    set showCloseButton(value: boolean);
+    /** `Gtk.SearchBar:key-capture-widget` — where printable keys start a search. */
+    get keyCaptureWidget(): HTMLElement | null;
+    set keyCaptureWidget(widget: HTMLElement | null);
+    /** The editable the C's `connect_entry` would have bound: the first field inside the bar. */
+    get entry(): HTMLInputElement | HTMLTextAreaElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, _value: string | null): void;
+    private _render;
+    /**
+     * `reveal_child_changed_cb` (gtksearchbar.c:183-205): revealing focuses the entry,
+     * hiding clears it. Run on a real CHANGE only — at init the C's own notify fires before
+     * the handler is connected, so a child that arrives with the bar is left alone.
+     */
+    private _applyReveal;
+    private _revealFromTyping;
+    /**
+     * The key-capture path (gtksearchbar.c:525-556): a printable key on the capture widget
+     * opens the bar and goes into the entry, which is what forwarding the event does in the C.
+     * Modified keys and the functional keys are left alone — GTK forwards them, but a bar
+     * that opened on every arrow key would not be a search bar.
+     */
+    private _captureKey;
+}