@gjsify/adwaita-web 0.53.0 → 0.55.0

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

@@ -0,0 +1,159 @@
+import { type AdwCalendarCell, type AdwCalendarDate } from '@gjsify/adwaita-core';
+export declare class GtkCalendar extends HTMLElement {
+    private _headerEl;
+    private _monthEl;
+    private _yearEl;
+    private _arrowEls;
+    private _gridEl;
+    private _dayNameEls;
+    private _weekNumberEls;
+    private _cellEls;
+    private _marked;
+    private _date;
+    /** `focus_row` / `focus_col` collapsed into one index into the 42 cells, -1 for neither. */
+    private _focus;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /**
+     * `GtkCalendar:date` — the selected date as `YYYY-MM-DD`, `GDateTime`'s own ISO form.
+     *
+     * Unset means TODAY, which is what `gtk_calendar_init` seeds it with
+     * (`g_date_time_new_now_local`, gtkcalendar.c:851) — so the getter answers today when no
+     * attribute is present, rather than the epoch the C starts from before its first select.
+     */
+    get date(): string;
+    set date(value: string);
+    /** `GtkCalendar:year` — DEPRECATED in 4.20 in favour of `date` (:396-403). */
+    get year(): number;
+    set year(value: number);
+    /**
+     * `GtkCalendar:month` — DEPRECATED in 4.20, and 0-11, not 1-12 (:405-417). The one place
+     * this element is not in `GDateTime`'s own numbering, and it is the attribute that says so.
+     */
+    get month(): number;
+    set month(value: number);
+    /** `GtkCalendar:day` — DEPRECATED in 4.20 in favour of `date` (:419-428). */
+    get day(): number;
+    set day(value: number);
+    /** Default TRUE (:441-443), so the attribute is the OFF switch. */
+    get showHeading(): boolean;
+    set showHeading(value: boolean);
+    /** Default TRUE (:450-452), read the same way. */
+    get showDayNames(): boolean;
+    set showDayNames(value: boolean);
+    /** Default FALSE (:458-460), read the same way. */
+    get showWeekNumbers(): boolean;
+    set showWeekNumbers(value: boolean);
+    /**
+     * Which day the grid's first column is — `calendar->week_start`, PORT-ONLY.
+     *
+     * The C reads it out of the locale (`_NL_TIME_FIRST_WEEKDAY` plus `_NL_TIME_WEEK_1STDAY`,
+     * gtkcalendar.c:700-718) and has no property for it, and this port does the same by
+     * default through `Intl.Locale.getWeekInfo()`. The ATTRIBUTE is the addition, and it is
+     * what makes a gallery preview reproducible: a grid whose leading blanks follow the
+     * machine's locale is a screenshot that differs per reader, and the C's own
+     * `calendar:week_start:0` translatable string (gtkcalendar.c:712-719) is the same
+     * override upstream.
+     *
+     * 0 is Sunday and 6 is Saturday — `GDateTime`'s own numbering, so it is the value
+     * `calendarDays` subtracts with and the value every vector table carries.
+     */
+    get weekStart(): number;
+    set weekStart(value: number);
+    /** The 31-slot table — `gtk_calendar_get_day_is_marked`, so a mark does not change state. */
+    get markedDays(): number[];
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /** `gtk_calendar_mark_day` (:1650-1666). */
+    markDay(day: number): void;
+    /** `gtk_calendar_unmark_day` (:1686-1704). */
+    unmarkDay(day: number): void;
+    /** `gtk_calendar_get_day_is_marked` (:1668-1682). */
+    dayIsMarked(day: number): boolean;
+    /** `gtk_calendar_clear_marks` (:1589-1613). */
+    clearMarks(): void;
+    /** The six rows of seven, as the C's `day[row][col]` pair. */
+    get cells(): readonly AdwCalendarCell[];
+    /** The date every write resolves against. */
+    get selectedDate(): AdwCalendarDate;
+    private _buildHeader;
+    private _buildGrid;
+    /**
+     * Resolve the attributes into the one date they all name.
+     *
+     * THE ATTRIBUTE THAT CHANGED WINS, which is the C's own rule:
+     * `gtk_calendar_set_year` builds a new `GDateTime` from the same day in the new year and
+     * hands it to the same `calendar_select_day_internal` (gtkcalendar.c:860-880), so a write
+     * to a deprecated half AFTER a `date` write MOVES the date rather than being ignored for
+     * one being on the element. Reading `date` unconditionally would pin the element to its
+     * first write.
+     *
+     * At connect no attribute has "changed" and `date` wins, because it is the one the three
+     * halves are deprecated IN FAVOUR of. With none of them the answer is today, which is what
+     * `gtk_calendar_init` seeds (:849-851).
+     */
+    private _adoptAttributes;
+    /**
+     * Repaint everything the date decides: the heading, the 42 cells' text and classes, the six
+     * week numbers and the four arrows' sensitivity.
+     *
+     * The cells are NOT rebuilt — the same 42 buttons are reused and re-pointed, so a focus
+     * cell and its scroll position survive a month change, which is what `calendar_queue_refresh`
+     * gets from the widget layer upstream.
+     */
+    private _render;
+    /**
+     * The six week numbers — `week_of_year` of the LAST cell of each row, which is the C's own
+     * rule (gtkcalendar.c:1143-1165): the row's week is the week its Sunday-through-Saturday
+     * run belongs to, and the row's last cell is its Saturday.
+     */
+    private _paintWeekNumbers;
+    /** The per-cell state flags `calendar_update_day_labels` raises (:979-1053). */
+    private _paintStates;
+    /** `calendar_update_navigation_buttons` (:1055-1084). */
+    private _paintArrows;
+    private _paintDayNames;
+    /**
+     * `show_heading`, `show_day_names` and `show_week_numbers` — the three visibility flags
+     * `gtk_calendar_init` and the setters flip (gtkcalendar.c:815-816, :1690-1700,
+     * :1756-1762). One of them hides the whole header BOX and the other two a row of labels,
+     * which is why they are one method rather than three writes.
+     */
+    private _paintVisibility;
+    private _onArrow;
+    /**
+     * `calendar_set_month_prev` and its three siblings: step the date, select it WITHOUT
+     * `emit_day_signal`, then emit the arrow's own signal (:868-919).
+     */
+    private _navigate;
+    /**
+     * The C's tail, line for line (:1169-1190): `::day-selected` and the `day` notify INSIDE
+     * `if (day_changed)`, the `month` and `year` notifies each inside its own, and `date`
+     * unconditionally — because the function that got here changed something.
+     */
+    private _emitDaySelected;
+    /**
+     * A click on a cell — `calendar_select_and_focus_day` reached from
+     * `gtk_calendar_button_press` (:1311-1353).
+     *
+     * A cell from another month PAGES first: that is the `MONTH_PREV` / `MONTH_NEXT` branch of
+     * the Space handler (:1521-1534), and a click lands on the same cell either way.
+     */
+    private _onCellClick;
+    /**
+     * `calendar_select_and_focus_day` (:1195-1213) — the date, WITH `::day-selected`, and the
+     * cursor on it.
+     */
+    private _selectDate;
+    /**
+     * The key table: arrows move the cursor (`move_focus`, :1386-1452) and Space selects the
+     * cell it is on; `Ctrl` with any arrow is the MONTH and YEAR walk (:1454-1534).
+     */
+    private _onKeyDown;
+    /**
+     * `move_focus` (:1386-1452) over the 6x7 grid, wrapping at the edges exactly as the C does
+     * (`focus_row < 0 → 5`, `focus_col < 0 → 6`).
+     */
+    private _moveFocus;
+}

package/lib/types/elements/gtk-center-box.d.ts

@@ -0,0 +1,39 @@
+/** `Gtk.BaselinePosition`'s three nicks, in the order GTK measures them (gtkcenterbox.c:267-271). */
+declare const BASELINE_POSITIONS: {
+    readonly top: 0;
+    readonly center: 0.5;
+    readonly bottom: 1;
+};
+export type BaselinePosition = keyof typeof BASELINE_POSITIONS;
+export declare class GtkCenterBox extends HTMLElement {
+    static get observedAttributes(): string[];
+    /**
+     * `Gtk.CenterBox:baseline-position` — `top`, `center` (the pspec default) or `bottom`.
+     * An unknown nick is the default, the same answer an enum nick GTK does not know gets.
+     */
+    get baselinePosition(): BaselinePosition;
+    set baselinePosition(value: BaselinePosition);
+    /**
+     * `Gtk.CenterBox:shrink-center-last` — TRUE (the pspec default, gtkcenterbox.c:330-333)
+     * shrinks the start and end children before the centre; FALSE shrinks the centre first.
+     * The default is the AFFIRMATIVE one, so it is the ABSENCE of the attribute — a bare
+     * `<gtk-center-box>` is a TRUE box, and `shrink-center-last="false"` is what turns it off.
+     */
+    get shrinkCenterLast(): boolean;
+    set shrinkCenterLast(value: boolean);
+    /** `Gtk.CenterBox:start-widget` — the child pinned to the start. */
+    get startWidget(): HTMLElement | null;
+    set startWidget(value: HTMLElement | null);
+    /** `Gtk.CenterBox:center-widget` — the child that takes the space between the other two. */
+    get centerWidget(): HTMLElement | null;
+    set centerWidget(value: HTMLElement | null);
+    /** `Gtk.CenterBox:end-widget` — the child pinned to the end. */
+    get endWidget(): HTMLElement | null;
+    set endWidget(value: HTMLElement | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _assign;
+    private _sync;
+}
+export {};

package/lib/types/elements/gtk-color-dialog-button.d.ts

@@ -0,0 +1,69 @@
+/** A `GdkRGBA` — the four channels of `GtkColorDialogButton:rgba`, each 0…1. */
+export interface GdkRgbaValue {
+    red: number;
+    green: number;
+    blue: number;
+    alpha: number;
+}
+/**
+ * `GtkColorDialog`'s three parameters, under the property names. `filter` and `font-map`
+ * are font dialog's; the colour one holds exactly these.
+ */
+export interface ColorDialogParameters {
+    /** Whether the chooser is modal. Default `TRUE`, as in the GIR. */
+    modal?: boolean;
+    /** The chooser's title. Default `null`. */
+    title?: string | null;
+    /** Whether colours may carry alpha. Default `TRUE`, as in the GIR. */
+    withAlpha?: boolean;
+}
+export declare class GtkColorDialogButton extends HTMLElement {
+    private _buttonEl;
+    private _swatchEl;
+    private _inputEl;
+    private _dialog;
+    private _rgba;
+    /** `self->cancellable != NULL` — a chooser run is in progress (:396-419). */
+    private _pending;
+    private _initialized;
+    static get observedAttributes(): string[];
+    /** `GtkColorDialogButton:rgba` — the selected colour. */
+    get rgba(): GdkRgbaValue;
+    set rgba(value: string | GdkRgbaValue);
+    /** `GtkColorDialogButton:dialog` — the chooser this button opens, or `null` for none. */
+    get dialog(): ColorDialogParameters | null;
+    set dialog(value: ColorDialogParameters | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    /**
+     * The `::activate` action signal (:283-296), which `activated()` binds straight to
+     * `gtk_widget_activate (self->button)` (:378-382): pressing the button and activating
+     * the widget are the same thing, and both pop the chooser.
+     */
+    activate(): void;
+    /** `button_clicked` (:394-419) — the whole run, and it is one guard deep. */
+    private _choose;
+    /** `update_button_sensitivity` (:380-391), with the run guard explained in the header. */
+    private _renderSensitivity;
+    private _renderSwatch;
+}
+/** `gdk_rgba_equal` — four exact comparisons, so a write of the same colour is not one. */
+export declare function rgbaEqual(a: GdkRgbaValue, b: GdkRgbaValue): boolean;
+/**
+ * `scale_round` (:329-333) — `floor (value * scale + 0.5)`, clamped into 0…scale.
+ */
+export declare function scaleRound(value: number, scale: number): number;
+/** `accessible_color_name` (:334-347), with the Alpha clause only while it is translucent. */
+export declare function describeColor(color: GdkRgbaValue): string;
+/** `#rrggbb` for an opaque colour and `rgba(...)` for a translucent one — the two an author writes. */
+export declare function formatHex(color: GdkRgbaValue): string;
+/**
+ * Any CSS colour the browser understands → a `GdkRGBA`.
+ *
+ * The PARSE IS THE BROWSER'S, through CSSOM: an unrecognised value leaves
+ * `style.color` empty, and a recognised one comes back normalised to `rgb()`/`rgba()`.
+ * That is why `#abc`, `hsl()`, `color-mix()` and a named colour all work here without a
+ * second parser — and why the one thing that cannot be parsed is refused rather than
+ * guessed at, which is what the C's `G_IS_VALUE`/`gdk_rgba_parse` pair does.
+ */
+export declare function parseCssColor(value: string): GdkRgbaValue | null;

package/lib/types/elements/gtk-column-view.d.ts

@@ -0,0 +1,50 @@
+import { type AdwColumnViewColumn, type AdwColumnViewSort, type AdwListItemFactory } from '@gjsify/adwaita-core';
+import { GtkListView } from './gtk-list-view.js';
+/** A per-column renderer — `Gtk.ColumnViewColumn:factory`, keyed by the column's id. */
+export type GtkColumnViewFactories = Readonly<Record<string, AdwListItemFactory<Node>>>;
+export declare class GtkColumnView extends GtkListView {
+    private _headerEl;
+    private _columns;
+    private _factories;
+    private _sorter;
+    private _dragged;
+    static get observedAttributes(): string[];
+    /** `Gtk.ColumnView:columns`, as descriptors rather than as a read-only `Gio.ListModel`. */
+    get columns(): AdwColumnViewColumn[];
+    set columns(value: readonly AdwColumnViewColumn[] | null);
+    /** Per-column factories, keyed by `Gtk.ColumnViewColumn:id`. */
+    get columnFactories(): GtkColumnViewFactories;
+    set columnFactories(value: GtkColumnViewFactories | null);
+    /** `gtk_column_view_get_sorter`'s state — which column, which direction. */
+    get sorter(): AdwColumnViewSort | null;
+    set sorter(value: AdwColumnViewSort | null);
+    get showRowSeparators(): boolean;
+    set showRowSeparators(value: boolean);
+    get showColumnSeparators(): boolean;
+    set showColumnSeparators(value: boolean);
+    get reorderable(): boolean;
+    set reorderable(value: boolean);
+    connectedCallback(): void;
+    attributeChangedCallback(name?: string): void;
+    protected _applyAttributes(): void;
+    protected get _viewClass(): string;
+    protected get _rowClass(): string;
+    protected _createRow(position: number): HTMLElement | null;
+    /** One `cell`: the column's own factory, or the portable field its `key` names. */
+    private _createCell;
+    /** The header row — one button per visible column, with its sort indicator. */
+    private _renderHeader;
+    private _createHeaderCell;
+    /**
+     * Column reordering by dragging a header — `Gtk.ColumnView:reorderable`.
+     *
+     * The HTML drag-and-drop events rather than a pointer drag, because the header is a
+     * `<button>` and a pointer drag would have to suppress its own click; `draggable`
+     * suppresses it for us, which is also what keeps a drag from sorting the column it
+     * started on.
+     */
+    private _makeDraggable;
+    private _applySorter;
+    /** One track list for the header and every row, so the two cannot fall out of step. */
+    private _applyTracks;
+}

package/lib/types/elements/gtk-drag-icon.d.ts

@@ -0,0 +1,78 @@
+/** The `rgba()` string a `GdkRGBA` value paints, as the colour swatch shows it. */
+interface Rgba {
+    readonly red: number;
+    readonly green: number;
+    readonly blue: number;
+    readonly alpha?: number;
+}
+export declare class GtkDragIcon extends HTMLElement {
+    private _pointerX;
+    private _pointerY;
+    private _dragging;
+    /** The document listeners, released the moment the drag ends (see `_begin`). */
+    private _onDragOver;
+    private _onDragEnd;
+    /** The drag this icon is for: GTK destroys the icon when THAT drag ends (:57-58). */
+    private _transfer;
+    static get observedAttributes(): any[];
+    /**
+     * `gtk_drag_icon_get_for_drag` (:392-421), for a browser drag: the icon in use, or a
+     * new one. A declared `<gtk-drag-icon>` this drag can have is that one — see the header
+     * for when it cannot.
+     */
+    static getForDrag(event: DragEvent): GtkDragIcon;
+    /**
+     * `gtk_drag_icon_create_widget_for_value` (:529-556): the widget a drag shows for a
+     * value. The C answers for SIX types — a string is a `GtkLabel` (:531-534), a
+     * `GDK_TYPE_PAINTABLE` and a `G_TYPE_FILE` are `GtkImage`s with the `large-icons`
+     * class (:535-543, :554-573), a `GdkRGBA` is a `GtkColorSwatch` (:544-553), a
+     * `GtkTextBuffer` is a `GtkPicture` of its selection and a `GSK_TYPE_RENDER_NODE` an
+     * image of its bounds (:574-602) — and returns `NULL` for anything else (:603-605).
+     *
+     * TWO OF THE SIX HAVE AN ANSWER HERE, and the other four are NAMED rather than
+     * quietly folded into the `null`: a paintable and a file are a picture an icon theme
+     * picks, which a browser has no query for (`g_file_query_info (… "standard::icon")`
+     * is a file-system answer), and a text buffer's drag icon is a PAINTED selection
+     * (`gtk_text_util_create_rich_drag_icon`) that this package has no text view to take
+     * one from. `null` for those is the C's own answer for a value it cannot make a
+     * widget for, so the return type still means what it means in the C.
+     *
+     * The swatch is a painted div rather than a `<gtk-color-swatch>`: this package ships no
+     * colour-swatch element, and for a drag icon the swatch is nothing but the colour it
+     * carries — `set_can_drag`/`set_can_drop` FALSE (:546-547), so it takes no input and
+     * accepts none.
+     */
+    static createWidgetForValue(value: string | Rgba | null): Element | null;
+    /**
+     * `GtkDragIcon:child` — the widget displayed as the drag icon, `null` until set. GTK's
+     * setter unparents the old child, parents the new one and notifies (:468-490); the
+     * getter here is the light-DOM child, so an icon declared in markup with content needs
+     * no imperative call at all.
+     */
+    get child(): Element | null;
+    set child(node: Element | null);
+    /** `set_child` + `show` — the shape a drag source actually uses. */
+    setChild(node: Element | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * The drag has begun. The platform's own ghost is asked away with a transparent image,
+     * and from here the icon follows the pointer — `gtk_drag_icon_move_resize` (:138-150)
+     * on every `dragover`, which is the one event a browser delivers continuously while a
+     * drag is in flight.
+     */
+    beginDrag(event: DragEvent): void;
+    /** The drag ended: GTK destroys the icon, and this hides it instead. */
+    endDrag(): void;
+    /** Whether a drag is in flight — the C's mapped flag, and what `hidden` answers to. */
+    get dragging(): boolean;
+    private _observe;
+    private _unobserve;
+    /**
+     * `gtk_drag_icon_move_resize` (:138-150): the icon is moved to the pointer. Fixed
+     * positioning plus a transform is the one CSS door into the top layer a page has, and
+     * the hotspot is `(0, 0)` — see the header for why.
+     */
+    private _render;
+}
+export {};

package/lib/types/elements/gtk-drawing-area.d.ts

@@ -0,0 +1,95 @@
+/**
+ * `GtkDrawingAreaDrawFunc` with the `user_data` / `destroy` pair dropped — see the header.
+ *
+ * @param area the drawing area being painted, as the C's first argument
+ * @param cr a 2D context over the whole allocation, in logical pixels
+ * @param width the width of the allocation — NOT of `content-width`
+ * @param height the height of the allocation — NOT of `content-height`
+ */
+export type GtkDrawingAreaDrawFunc = (area: GtkDrawingArea, cr: CanvasRenderingContext2D, width: number, height: number) => void;
+export declare class GtkDrawingArea extends HTMLElement {
+    private _canvas;
+    private _context;
+    private _initialized;
+    private _drawFunc;
+    /** The last allocation the draw function was called with, as `::resize` sees it. */
+    private _width;
+    private _height;
+    /** The last device pixel ratio the backing store was built for. */
+    private _scale;
+    private _resize;
+    private _frame;
+    static get observedAttributes(): string[];
+    /** `Gtk.DrawingArea:content-width` — the minimum AND natural width. Defaults to 0. */
+    get contentWidth(): number;
+    set contentWidth(v: number);
+    /** `Gtk.DrawingArea:content-height` — the minimum AND natural height. Defaults to 0. */
+    get contentHeight(): number;
+    set contentHeight(v: number);
+    /**
+     * Every GObject setter here returns early when the value is already right
+     * (gtkdrawingarea.c:373, :423), while `setAttribute` runs the reaction for a write
+     * that changes nothing — so the guard that makes "notify only on a real change" true
+     * for the numeric half is the same one `<gtk-level-bar>` uses.
+     */
+    private _write;
+    /** `GtkDrawingAreaDrawFunc`, or `null` — GTK's default, which paints nothing (:251). */
+    get drawFunc(): GtkDrawingAreaDrawFunc | null;
+    set drawFunc(fn: GtkDrawingAreaDrawFunc | null);
+    /**
+     * `gtk_drawing_area_set_draw_func` (gtkdrawingarea.c:474-491): store the function and
+     * `queue_draw`, which is what repaints. Passing `null` clears it, and the next
+     * snapshot leaves the widget blank — the C's early return at :251.
+     */
+    setDrawFunc(fn: GtkDrawingAreaDrawFunc | null): void;
+    /**
+     * `gtk_widget_queue_draw` on this widget: the documented way to ask for the draw
+     * function to be called again (gtkdrawingarea.c:127-129).
+     *
+     * AND WHY IT IS NOT IMMEDIATE. `queue_draw` marks the window dirty and the frame clock
+     * draws it on the next frame, so a draw function that calls `queue_draw` keeps
+     * ANIMATING rather than recursing — and a 2D canvas drawn synchronously would turn the
+     * same application into a stack overflow. One animation frame is the browser's frame
+     * clock, and coalescing through it is what makes "paint from the function" a loop and
+     * not a crash. Several requests before the frame are one frame, as in the C.
+     */
+    queueDraw(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `measure` returns one number per axis as the minimum AND the natural size
+     * (gtkdrawingarea.c:210-231), and CSS has a property for each half — so the element
+     * publishes the number once and `_drawing.scss` reads it twice. A zero removes the
+     * property rather than declaring `0px`, because `var(--adw-drawing-width, auto)` is
+     * how "no intrinsic size" is spelled.
+     */
+    private _publishSize;
+    private _observe;
+    /**
+     * `gtk_drawing_area_size_allocate` (:233-238) emits `::resize` and does nothing else —
+     * the signal IS the allocation path. The browser learns the allocation from the
+     * observer instead, so the signal is emitted from here, and only when the allocation
+     * really changed: GTK reaches `size_allocate` on every layout pass, and the signal
+     * is documented as firing "each time the widget is changed" (:312-314).
+     */
+    private _allocated;
+    /**
+     * One frame. `gtk_drawing_area_snapshot` (:240-267) measures the ALLOCATION, not the
+     * properties, and calls the function with it; the browser gets the allocation from the
+     * observer instead of from the snapshot, and the drawing itself is the 2D context the
+     * canvas already owns.
+     */
+    private _draw;
+    /** The backing store is rebuilt when the display's ratio changes, not every frame. */
+    private _devicePixelRatio;
+    /** The `notify::` detail for `name`: the PROPERTY, parsed, not the raw attribute. */
+    private _notify;
+    /** The last allocation, as `::resize` reported it — the spec reads it back. */
+    get allocation(): {
+        width: number;
+        height: number;
+    };
+    /** The ratio the backing store was built at, as the header describes. */
+    get pixelScale(): number;
+}

package/lib/types/elements/gtk-editable-label.d.ts

@@ -0,0 +1,33 @@
+export declare class GtkEditableLabel extends HTMLElement {
+    private _label;
+    private _entry;
+    private _initialized;
+    private _grace;
+    static get observedAttributes(): string[];
+    /** `Gtk.Editable:text` — what the label shows, which is the committed draft. */
+    get text(): string;
+    set text(value: string);
+    /** `Gtk.Editable:editable` — defaults TRUE. FALSE refuses to start editing. */
+    get editable(): boolean;
+    set editable(value: boolean);
+    /**
+     * `GtkEditableLabel:editing` — TRUE while the entry is the stack's visible child, so it
+     * is the ATTRIBUTE as on every other boolean here. Setting it is what starts or stops
+     * editing, because the C's property setter does exactly that (gtkeditablelabel.c:406-411).
+     */
+    get editing(): boolean;
+    set editing(value: boolean);
+    /** `gtk_editable_label_start_editing` — refused while `editable` is FALSE, as in the C. */
+    startEditing(): void;
+    /**
+     * `gtk_editable_label_stop_editing` — `commit` decides whether the drafted text becomes
+     * the label's; FALSE resets the entry to the label instead (gtkeditablelabel.c:637-656).
+     */
+    stopEditing(commit?: boolean): void;
+    /** The inner native entry, for focus and selection. */
+    get entry(): HTMLInputElement;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    private _render;
+}

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

@@ -0,0 +1,84 @@
+import { type EmojiEntry } from '../emoji-data.js';
+import { GtkPopover } from './gtk-popover.js';
+export declare class GtkEmojiChooser extends GtkPopover {
+    private _built;
+    private _entry;
+    private _listEl;
+    private _emptyEl;
+    private _sections;
+    /** The entry a button was built from — `emoji-data` has no reverse lookup. */
+    private _entryOf;
+    /** `recently-used-emoji` — the GSettings key, held in memory here (see the header). */
+    private _recent;
+    /**
+     * The Ctrl state `should_close` reads off the keyboard (:433-448). A DOM event's
+     * `ctrlKey` says what the key that caused IT was, and a `click` synthesised from a
+     * keyboard activation carries no modifier at all, so the state is tracked from the key
+     * events themselves — which is what `gdk_device_get_modifier_state` answers.
+     */
+    private _ctrl;
+    connectedCallback(): void;
+    /** The emoji picked most recently, newest first — what `recently-used-emoji` holds. */
+    get recentEmoji(): EmojiEntry[];
+    /**
+     * Pick an entry the flow box's `child-activated` would have delivered — which is what
+     * a consumer inserting an emoji from elsewhere needs, and what a test drives the recents
+     * with. `fromRecent` is `emoji_activated`'s own half of the recent check: an entry
+     * picked out of the recent list is not recorded a second time.
+     */
+    pick(entry: EmojiEntry, fromRecent?: boolean): void;
+    /** The `.emoji-searchbar` box: the magnifying glyph and the search entry. */
+    private _buildSearchbar;
+    /** The `empty` stack page: the big glyph and the two lines under it. */
+    private _buildEmptyPage;
+    /** One flow box per category, each under its own heading label. */
+    private _buildSections;
+    /**
+     * The toolbar: one `.emoji-section` button per section, recent FIRST (the struct
+     * order), each with its own symbolic and the `.ui`'s tooltip.
+     *
+     * The icons are written out one call per section rather than looked up from a table:
+     * each name is USED there, which is what makes it a name this stylesheet has to be
+     * able to draw — `scripts/check-adwaita-icon-masks.mjs` reads exactly that.
+     */
+    private _buildToolbar;
+    /** `button.image-button.emoji-section` — flat, circular, 32px, with a tooltip. */
+    private _sectionButton;
+    /**
+     * One emoji: a `<button>` holding the glyph at `PANGO_SCALE_X_LARGE`, labelled with
+     * the English name — the name the search reads, so it is the accessible name too.
+     */
+    private _emojiButton;
+    /** `filter_func` + `match_tokens`: EVERY term must be a PREFIX of a token of the name
+     * or of one of the keywords. `g_str_tokenize_and_fold` case-folds, hence lower-casing
+     * both sides. */
+    private _matches;
+    /** `search_changed` — invalidate every section, then `update_headings`. */
+    private _filter;
+    /** `emoji_activated` — emit, remember, and pop down unless Ctrl is held. */
+    private _activate;
+    /** `add_recent_item` (:390) — newest first, no duplicates, at most `MAX_RECENT`. */
+    private _remember;
+    /** `populate_recent_section` (:366-388): the list, its visibility and its button. */
+    private _renderRecents;
+    /**
+     * `show_variations` (:508-548): the plain form and the five skin tones
+     * (`add_emoji (box, FALSE, emoji_data, 0, …)` then `1F3FB`…`1F3FF`), in a popover over
+     * the emoji — and only for an emoji that HAS them, which is `has_variations` (:489).
+     */
+    private _showVariations;
+    private _closeVariations;
+    /** `scroll_to_section` (:312-330) — to the heading, minus `BOX_SPACE`. */
+    private _scrollTo;
+    /** `gtk_emoji_chooser_scroll_section` (:1198) — Ctrl+N / Ctrl+P over the visible ones. */
+    private _scrollSection;
+    /** `activate_search` (:1019) — the first result of the first non-empty section. */
+    private _activateFirstResult;
+    /**
+     * `adj_value_changed` (:814-870): the section the scroll position is INSIDE is the
+     * checked one, so the toolbar follows the list without any interaction of its own.
+     */
+    private _sectionAt;
+    private _currentSection;
+    private _markSection;
+}

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

@@ -1,5 +1,11 @@
 export declare class GtkEntry extends HTMLElement {
-    private _input;
+    /**
+     * `protected`, not `private`: `GtkPasswordEntry` and `GtkSearchEntry` subclass this
+     * element and restyle or wrap the very input it builds (the password field's Caps Lock
+     * and peek listeners, the search field's leading icon and trailing clear button), so the
+     * inner node is theirs to reach as well as this class's.
+     */
+    protected _input: HTMLInputElement;
     private _initialized;
     private _maxLength;
     static get observedAttributes(): string[];
@@ -10,8 +16,21 @@ export declare class GtkEntry extends HTMLElement {
     set maxLength(value: number);
     /** `Gtk.Entry:text-length` — code points, not UTF-16 units. */
     get textLength(): number;
+    /**
+     * `Gtk.Entry:placeholder-text`, the name a Blueprint file and the gallery trees use.
+     * `placeholder` stays for markup written before the GTK spelling was read.
+     */
+    private placeholderAttribute;
+    /** `Gtk.Widget:width-request` — a minimum width in px; -1 or absent leaves the natural one. */
+    private applyWidthRequest;
     /** The inner native input (for focus/selection). */
     get input(): HTMLInputElement;
     connectedCallback(): void;
+    /**
+     * Declared so a subclass can override it and still reach the base: the custom-element
+     * lifecycle hooks a subclass chains (`super.disconnectedCallback()`) have to exist on
+     * the class it extends, and `GtkSearchEntry` drops its pending search timeout here.
+     */
+    disconnectedCallback(): void;
     attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
 }