@gjsify/adwaita-web 0.54.0 → 0.56.0

package/lib/types/elements/gtk-about-dialog.d.ts

@@ -0,0 +1,146 @@
+import { AdwDialog } from './adw-dialog.js';
+/**
+ * GTK's licence preamble (`gtk_about_dialog_set_license_type`, :2301) — NOT
+ * libadwaita's `ADW_LICENSE_WARRANTY_TEMPLATE`, which says "This application" and has no
+ * newline. Both strings are translatable and they are not translations of each other.
+ * The C template is `'This program comes with absolutely no warranty.\nSee the
+ * <a href="%s">%s</a> for details.'`; `_licenseMarkup` composes the same three runs —
+ * text, link, text — as DOM, because the scan it uses for plain licence text would read
+ * the `<a href>` as an email address.
+ */
+export declare class GtkAboutDialog extends AdwDialog {
+    private _built;
+    private _logo;
+    private _switcherEl;
+    private _stackEl;
+    private _pages;
+    private _populated;
+    private _authors;
+    private _documenters;
+    private _artists;
+    private _creditSections;
+    static get observedAttributes(): string[];
+    /** The program name; unset falls back to the document's own title (`g_get_application_name`). */
+    get programName(): string;
+    set programName(value: string);
+    get version(): string;
+    set version(value: string);
+    get copyright(): string;
+    set copyright(value: string);
+    get comments(): string;
+    set comments(value: string);
+    get license(): string;
+    set license(value: string);
+    /** The `GtkLicense` nick — `unknown`, `custom`, `mit-x11`, … */
+    get licenseType(): string;
+    set licenseType(value: string);
+    get systemInformation(): string;
+    set systemInformation(value: string);
+    get website(): string;
+    set website(value: string);
+    get websiteLabel(): string;
+    set websiteLabel(value: string);
+    get translatorCredits(): string;
+    set translatorCredits(value: string);
+    /** The named-icon logo; overrides {@link logo}, as in the C. */
+    get logoIconName(): string;
+    set logoIconName(value: string);
+    /** Whether the License page's text view WRAPS (`populate_license_page`, :2157). */
+    get wrapLicense(): boolean;
+    set wrapLicense(value: boolean);
+    /**
+     * A logo URL, drawn as an `<img>`.
+     *
+     * `GtkAboutDialog:logo` is a `GdkPaintable`, which is the one GObject property here
+     * an attribute could have carried and cannot: there is no paintable in a document.
+     * A URL is the honest browser stand-in and the override order is the C's.
+     */
+    get logo(): string;
+    set logo(value: string);
+    /** The people whose names the Credits page shows — `GtkAboutDialog:authors`. */
+    get authors(): string[];
+    set authors(value: readonly string[]);
+    get documenters(): string[];
+    set documenters(value: readonly string[]);
+    get artists(): string[];
+    set artists(value: readonly string[]);
+    /** `gtk_about_dialog_add_credit_section` — an extra titled group on the Credits page. */
+    addCreditSection(name: string, people: readonly string[]): void;
+    private _creditsChanged;
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * The headerbar carries the stack switcher and nothing else, exactly as
+     * `gtkaboutdialog.ui` declares it (`title-widget` → the switcher, no title).
+     */
+    protected decorateHeader(header: HTMLElement): void;
+    /** Which stack page is showing — `gtk_stack_get_visible_child_name`. */
+    get visiblePage(): string;
+    /**
+     * Show a page of the stack — `gtk_stack_set_visible_child_name`. The switcher buttons
+     * call it, and it is the one way the stack's lazy population (`stack_visible_child_notify`)
+     * runs: a page is built the first time it is shown, not before.
+     */
+    showPage(name: string): void;
+    private _build;
+    private _renderAbout;
+    /** The three visibility rules, one predicate each, as in the C. */
+    private _pageVisible;
+    /** `add_credits_section`'s input, in `populate_credits_page`'s order. */
+    private _creditsPeople;
+    /** Whether the stack switcher has anything to show (`update_stack_switcher_visibility`). */
+    private _visiblePages;
+    private _renderSwitcher;
+    private _renderLogo;
+    /** The main page: version, comments, website, copyright, licence — in `.ui` order. */
+    private _renderMain;
+    /**
+     * The licence label: the text `license` holds, with its `<…>` and bare-URL links
+     * turned into spans — or, for a known type, the warranty preamble `set_license_type`
+     * composes. The preamble keeps its `<a href>` markup and is read with
+     * `gtk_label_set_markup` (:2354), a REAL link: it never goes through the
+     * `text_buffer_new` scan below, which would read `<a href="…">` as an email
+     * address. Same split here.
+     */
+    private _licenseMarkup;
+    /** The License page — a text view whose wrap mode is `wrap-license`. */
+    private _populateLicense;
+    /** The System page — a text view with no wrap mode of its own. */
+    private _populateSystem;
+    /** The Credits page — the scrolled, framed grid `populate_credits_page` fills. */
+    private _populateCredits;
+    /**
+     * `stack_visible_child_notify` (:297-333): each of the three pages is built the first
+     * time the stack SHOWS it, and never rebuilt after. A credits grid for three hundred
+     * authors is not work a dialog nobody opened it for.
+     */
+    private _populatePage;
+    /** The framed scrolled window the three extra pages sit in (`has-frame`). */
+    private _frame;
+    private _link;
+    /**
+     * `text_buffer_new` (:1903-2028 of `gtkaboutdialog.c`) for the plain-DOM case: split
+     * the string into literal runs and links. A `<…>` run is an email when it carries no
+     * scheme and a URL when it does; a bare `http://` or `https://` run ends at the first
+     * of space, newline, tab or `>`, which is `strpbrk (r1, " \n\t>")`.
+     */
+    private _fillWithLinks;
+    /**
+     * `emit_activate_link` (:646-655): the `BOOLEAN__STRING` accumulator. A handler that
+     * returns TRUE says it took over, which is `preventDefault()` here — and only then
+     * does the default `Gtk.UriLauncher` navigation not happen.
+     */
+    private _activateLink;
+}
+/** One run of `text_buffer_new`'s output: literal text, or a link with its URI. */
+interface LinkPart {
+    readonly text: string;
+    readonly uri: string | null;
+}
+/**
+ * `text_buffer_new`'s scan, in order: the first `<` and the first `>` after it, the
+ * earliest bare `http://` or `https://` and where it ends, and the C's own precedence —
+ * a URL that starts AT or just after the `<` wins, which leaves the bracket in the text.
+ */
+export declare function splitLinks(text: string): LinkPart[];
+export {};

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

@@ -0,0 +1,34 @@
+import type { AdwSlot } from '../slotted-children.js';
+import { GtkWindow } from './gtk-window.js';
+export declare class GtkApplicationWindow extends GtkWindow {
+    private _menubar;
+    private _menubarObserver;
+    static get observedAttributes(): string[];
+    /** `Gtk.ApplicationWindow:show-menubar` — whether the window shows a menubar of its own. */
+    get showMenubar(): boolean;
+    set showMenubar(value: boolean);
+    /**
+     * The menubar strip, created once and reused: `strips()` and `extraSlots()` both ask for
+     * it, so whichever runs first builds it and the other finds it.
+     */
+    private menubarSection;
+    /**
+     * Titlebar, then menubar, then content — the order `update_menubar` parents the bar at
+     * (:418) inside a window whose titlebar sits above its own child.
+     */
+    protected strips(): Node[];
+    /** The `menubar` slot, which is where a `GtkPopoverMenuBar` goes. */
+    protected extraSlots(): AdwSlot[];
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    /**
+     * `update_menubar`'s visibility rule (gtkapplicationwindow.c:400-402), BOTH halves: the
+     * property AND at least one item in the section. This element has no `GMenuModel` to ask,
+     * so the second half is the SLOT — an empty `menubar` slot is an empty `menubar_section`.
+     * The observer is what makes the second half live: `bindSlottedChildren` adopts a
+     * `slot="menubar"` child after connect, and a bar that appeared then must appear.
+     */
+    private _followMenubar;
+    private _renderMenubar;
+}

package/lib/types/elements/gtk-aspect-frame.d.ts

@@ -0,0 +1,27 @@
+export declare class GtkAspectFrame extends HTMLElement {
+    static get observedAttributes(): string[];
+    /** `Gtk.AspectFrame:ratio` — the width/height of the child. Ignored under `obey-child`. */
+    get ratio(): number;
+    set ratio(value: number);
+    /** `Gtk.AspectFrame:xalign` — where the child sits horizontally. `0.5` is the centre. */
+    get xalign(): number;
+    set xalign(value: number);
+    /** `Gtk.AspectFrame:yalign` — where the child sits vertically. `0.5` is the centre. */
+    get yalign(): number;
+    set yalign(value: number);
+    /**
+     * `Gtk.AspectFrame:obey-child` — TRUE (the pspec default, and therefore the ABSENCE of
+     * the attribute) takes the ratio from the child and ignores `ratio`. Spelled as
+     * `obey-child="false"` rather than as an inverted attribute, because the default is the
+     * affirmative one and every other boolean on every other element here means "present".
+     */
+    get obeyChild(): boolean;
+    set obeyChild(value: boolean);
+    /** `Gtk.AspectFrame:child` — the single widget the frame shapes. */
+    get child(): HTMLElement | null;
+    set child(value: HTMLElement | null);
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _normalized;
+    private _sync;
+}

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

@@ -1,4 +1,7 @@
+import type { DispatchedSignals } from '../signals.js';
 export declare class GtkButton extends HTMLElement {
+    /** The GTK signals this element dispatches, each with the DOM event it arrives as (ADR 0093). */
+    static readonly signals: DispatchedSignals;
     private _button;
     private _label;
     private _initialized;
@@ -10,4 +13,10 @@ export declare class GtkButton extends HTMLElement {
     connectedCallback(): void;
     attributeChangedCallback(): void;
     private _render;
+    /**
+     * Last step of every render, after the class and the content are written. A subclass
+     * adds its own state to the inner button here, because `_render` resets `className` and
+     * anything set earlier would be gone with it.
+     */
+    protected decorate(_button: HTMLButtonElement): void;
 }

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 {};