@girs/panel-1 4.1.0 → 4.3.0

package/README.md

@@ -5,25 +5,25 @@
 ![downloads/week](https://img.shields.io/npm/dw/@girs/panel-1)
 
 
-GJS TypeScript type definitions for Panel-1, generated from library version 1.10.4 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.1.0.
+GJS TypeScript type definitions for Panel-1, generated from library version 1.10.4 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.3.0.
 
 ## Install
 
-To use this type definitions, install them with NPM:
+Install the type definitions with npm:
 ```bash
 npm install @girs/panel-1
 ```
 
 ## Usage
 
-You can import this package into your project like this:
+Import it like any other module:
 ```ts
 import Panel from '@girs/panel-1';
 ```
 
 ### Ambient Modules
 
-You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
+[Ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) let you write the same import you would in plain JavaScript.
 For this you need to include `@girs/panel-1` or `@girs/panel-1/ambient` in your `tsconfig` or entry point Typescript file:
 
 `index.ts`:
@@ -42,7 +42,7 @@ import '@girs/panel-1'
 }
 ```
 
-Now you can import the ambient module with TypeScript support: 
+The ambient module now resolves with types:
 
 ```ts
 import Panel from 'gi://Panel?version=1';
@@ -50,7 +50,7 @@ import Panel from 'gi://Panel?version=1';
 
 ### Global import
 
-You can also import the module with Typescript support using the global `imports.gi` object of GJS.
+GJS's global `imports.gi` works too, with types.
 For this you need to include `@girs/panel-1` or `@girs/panel-1/import` in your `tsconfig` or entry point Typescript file:
 
 `index.ts`:
@@ -69,7 +69,7 @@ import '@girs/panel-1'
 }
 ```
 
-Now you have also type support for this, too:
+That form carries types as well:
 
 ```ts
 const Panel = imports.gi.Panel;
@@ -77,7 +77,7 @@ const Panel = imports.gi.Panel;
 
 ### Bundle
 
-Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).
+Most projects want a bundler. [esbuild](https://esbuild.github.io/) is the smallest thing that works; the [examples directory](https://github.com/gjsify/ts-for-gir/tree/main/examples) has setups for several others.
 
 ## Other packages
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@girs/panel-1",
-    "version": "4.1.0",
+    "version": "4.3.0",
     "libraryVersion": "1.10.4",
     "description": "GJS TypeScript type definitions for Panel-1, generated from library version 1.10.4",
     "type": "module",
@@ -17,6 +17,11 @@
         "import": "./panel-1-import.js",
         "default": "./panel-1-import.js"
       },
+      "./surface": {
+        "types": "./panel-1-surface.d.ts",
+        "import": "./panel-1-surface.js",
+        "default": "./panel-1-surface.js"
+      },
       "./panel-1": {
         "types": "./panel-1.d.ts",
         "import": "./panel-1.js",
@@ -32,22 +37,22 @@
       "test": "tsc --project tsconfig.json"
     },
     "dependencies": {
-      "@girs/gjs": "^4.1.0",
-      "@girs/gtk-4.0": "^4.1.0",
-      "@girs/gsk-4.0": "^4.1.0",
-      "@girs/graphene-1.0": "^4.1.0",
-      "@girs/gobject-2.0": "^4.1.0",
-      "@girs/glib-2.0": "^4.1.0",
-      "@girs/gdk-4.0": "^4.1.0",
-      "@girs/cairo-1.0": "^4.1.0",
-      "@girs/pangocairo-1.0": "^4.1.0",
-      "@girs/pango-1.0": "^4.1.0",
-      "@girs/harfbuzz-0.0": "^4.1.0",
-      "@girs/freetype2-2.0": "^4.1.0",
-      "@girs/gio-2.0": "^4.1.0",
-      "@girs/gmodule-2.0": "^4.1.0",
-      "@girs/gdkpixbuf-2.0": "^4.1.0",
-      "@girs/adw-1": "^4.1.0"    },
+      "@girs/gjs": "^4.3.0",
+      "@girs/gtk-4.0": "^4.3.0",
+      "@girs/gsk-4.0": "^4.3.0",
+      "@girs/graphene-1.0": "^4.3.0",
+      "@girs/gobject-2.0": "^4.3.0",
+      "@girs/glib-2.0": "^4.3.0",
+      "@girs/gdk-4.0": "^4.3.0",
+      "@girs/cairo-1.0": "^4.3.0",
+      "@girs/pangocairo-1.0": "^4.3.0",
+      "@girs/pango-1.0": "^4.3.0",
+      "@girs/harfbuzz-0.0": "^4.3.0",
+      "@girs/freetype2-2.0": "^4.3.0",
+      "@girs/gio-2.0": "^4.3.0",
+      "@girs/gmodule-2.0": "^4.3.0",
+      "@girs/gdkpixbuf-2.0": "^4.3.0",
+      "@girs/adw-1": "^4.3.0"    },
     "devDependencies": {
       "typescript": "*"
     },

package/panel-1-surface.d.ts

@@ -0,0 +1,424 @@
+/**
+ * The GIR-derived widget VOCABULARY for Panel-1.
+ *
+ * GENERATED — do not edit. Provenance: Panel-1 — library 1.10.4 — dropped empty base(s): GObject.InitiallyUnowned GObject.Object Gio.ActionGroup Gio.ActionMap
+ *
+ * 17 concrete widgets, 18 declarations, 1 enum nick unions, 6 slot candidates.
+ *
+ * Module-scoped exports only. There is no `JSX` namespace here, no tag spelling and
+ * no `on<Signal>` prop name: those are DIALECT, and every framework answers them
+ * differently. The shape to avoid is the GLOBAL AUGMENT — a `declare global` on
+ * `React.JSX` collides with every other library on a shared tag — while a
+ * module-scoped `JSX` behind a `jsxImportSource` does not. This package is used by
+ * projects that want nothing to do with JSX, so it emits neither; a consumer declaring
+ * a module-scoped namespace over these names is doing it right.
+ *
+ * Three things this is and `ConstructorProps` is not: WRITABLE-only (measured on
+ * Gtk-4.0, `ConstructorProps` offers 150 read-only properties across 68 classes as
+ * settable, and GTK's failure mode for writing one is exit 0), OPTIONAL, and keyed
+ * by the name GObject actually REGISTERED — the dashed spelling `g_object_set`,
+ * GtkBuilder XML and Blueprint all use.
+ *
+ * Signal handler types are not re-derived: `X.SignalSignatures`, which this package
+ * already emits for every class with the parent chain, every implemented interface
+ * and the `notify::` keys folded in, is what `Widgets[G]['signals']` points at.
+ */
+
+import type Gio from '@girs/gio-2.0';
+import type Gtk from '@girs/gtk-4.0';
+import type Panel from './panel-1.js';
+import type { AdwAlertDialogConstructOnly, AdwAlertDialogProps, AdwApplicationWindowConstructOnly, AdwApplicationWindowProps, AdwDialogConstructOnly, AdwDialogProps, AdwMessageDialogConstructOnly, AdwMessageDialogProps } from '@girs/adw-1/surface';
+import type { GtkAccessibleConstructOnly, GtkAccessibleProps, GtkActionableConstructOnly, GtkActionableProps, GtkApplicationWindowConstructOnly, GtkApplicationWindowProps, GtkBuildableConstructOnly, GtkBuildableProps, GtkConstraintTargetConstructOnly, GtkConstraintTargetProps, GtkNativeConstructOnly, GtkNativeProps, GtkOrientableConstructOnly, GtkOrientableProps, GtkRootConstructOnly, GtkRootProps, GtkShortcutManagerConstructOnly, GtkShortcutManagerProps, GtkWidgetConstructOnly, GtkWidgetProps, GtkWindowConstructOnly, GtkWindowProps } from '@girs/gtk-4.0/surface';
+
+// ---------------------------------------------------------------------------
+// Enum nicks — the string vocabulary GObject registered, from GIR's `glib:nick`.
+//
+// Not derived from the member name. Substituting underscores for dashes is not a law:
+// some nicks keep an underscore the substitution would have replaced, and only the
+// attribute knows which. Gtk-4.0 and Adw-1 contradict no derivation at all, which is
+// how a derived nick passes review and breaks elsewhere.
+// Re-measure with `scripts/check-nick-derivation.mjs` in ts-for-gir.
+// ---------------------------------------------------------------------------
+
+export type PanelAreaNick = 'start' | 'end' | 'top' | 'bottom' | 'center';
+
+// ---------------------------------------------------------------------------
+// Property surfaces — one interface per GIR DECLARATION, mirroring GIR's own
+// inheritance rather than flattening per widget.
+//
+// The interfaces are load-bearing, not tidiness: `GtkBox` declares four properties
+// of its own and `orientation` is not among them — it lives on `Gtk.Orientable`,
+// because GObject installs interface properties on the implementor at runtime while
+// GIR keeps them once, on the interface.
+// ---------------------------------------------------------------------------
+
+export interface PanelChangesDialogProps extends AdwAlertDialogProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkShortcutManagerProps {
+    /** This property requests that the widget close after saving. */
+    'close-after-save'?: boolean;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelChangesDialogConstructOnly = AdwAlertDialogConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkShortcutManagerConstructOnly;
+
+/** The #PanelDock is a widget designed to contain widgets that can be docked. */
+export interface PanelDockProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+    'bottom-height'?: number;
+    'end-width'?: number;
+    'reveal-bottom'?: boolean;
+    'reveal-end'?: boolean;
+    'reveal-start'?: boolean;
+    'reveal-top'?: boolean;
+    'start-width'?: number;
+    'top-height'?: number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelDockConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+export interface PanelDocumentWorkspaceProps extends PanelWorkspaceProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkNativeProps, GtkRootProps, GtkShortcutManagerProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelDocumentWorkspaceConstructOnly = PanelWorkspaceConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkNativeConstructOnly | GtkRootConstructOnly | GtkShortcutManagerConstructOnly;
+
+/** The #PanelFrame is a widget containing panels to display in an area. */
+export interface PanelFrameProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkOrientableProps {
+    placeholder?: Gtk.Widget | null;
+    'visible-child'?: Panel.Widget | null;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelFrameConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkOrientableConstructOnly;
+
+/** An interface implemented by the header of a #PanelFrame. */
+export interface PanelFrameHeaderProps extends GtkWidgetProps {
+    /** The frame the header is attached to, or %NULL. */
+    frame?: Panel.Frame | null;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelFrameHeaderConstructOnly = GtkWidgetConstructOnly;
+
+/** A header bar for #PanelFrame. */
+export interface PanelFrameHeaderBarProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, PanelFrameHeaderProps {
+    /** Whether to show the icon or not. */
+    'show-icon'?: boolean;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelFrameHeaderBarConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | PanelFrameHeaderConstructOnly;
+
+/** A #PanelFrameSwitcher is a #PanelFrameHeader that shows a row of buttons to switch between #GtkStack pages, not disimilar to a #GtkStackSwitcher. */
+export interface PanelFrameSwitcherProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkOrientableProps, PanelFrameHeaderProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelFrameSwitcherConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkOrientableConstructOnly | PanelFrameHeaderConstructOnly;
+
+/** A #PanelFrameHeader that implements switching between tab views in a #PanelFrame. */
+export interface PanelFrameTabBarProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, PanelFrameHeaderProps {
+    /** Whether the tabs automatically hide. */
+    autohide?: boolean;
+    /** Whether tabs expand to full width. */
+    'expand-tabs'?: boolean;
+    /** Whether tabs use inverted layout. */
+    inverted?: boolean;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelFrameTabBarConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | PanelFrameHeaderConstructOnly;
+
+/** The #PanelGrid is a widget used to layout the dock item in the center area. */
+export interface PanelGridProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelGridConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+export interface PanelGridColumnProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelGridColumnConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+/** A multi-use widget for user interaction in the window header bar. */
+export interface PanelOmniBarProps extends GtkWidgetProps, GtkAccessibleProps, GtkActionableProps, GtkBuildableProps, GtkConstraintTargetProps {
+    /** The tooltip for the action. */
+    'action-tooltip'?: string;
+    /** The name of the icon to use. */
+    'icon-name'?: string;
+    /** The menu model of the omni bar menu. */
+    'menu-model'?: Gio.MenuModel;
+    /** The popover to show. */
+    popover?: Gtk.Popover | null;
+    /** The current progress value. */
+    progress?: number;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelOmniBarConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkActionableConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+/** A #PanelPaned is the concrete widget for a panel area. */
+export interface PanelPanedProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkOrientableProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelPanedConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkOrientableConstructOnly;
+
+export interface PanelSaveDialogProps extends AdwMessageDialogProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkNativeProps, GtkRootProps, GtkShortcutManagerProps {
+    /** This property requests that the widget close after saving. */
+    'close-after-save'?: boolean;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelSaveDialogConstructOnly = AdwMessageDialogConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkNativeConstructOnly | GtkRootConstructOnly | GtkShortcutManagerConstructOnly;
+
+/** A panel status bar is meant to be displayed at the bottom of the window. */
+export interface PanelStatusbarProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelStatusbarConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+/** A widget that allow selecting theme preference between "dark", "light" and "follow" the system preference. */
+export interface PanelThemeSelectorProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+    /** The name of the action activated on activation. */
+    'action-name'?: string;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelThemeSelectorConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+/** The `PanelToggleButton` is a button used to toggle the visibility of a [class@Panel.Dock] area. */
+export interface PanelToggleButtonProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+    /** The area this button will reveal. */
+    area?: PanelAreaNick | Panel.Area;
+    /** The associated [class@Panel.Dock] */
+    dock?: Panel.Dock;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelToggleButtonConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | 'area';
+
+/** PanelWidget is the base widget class for widgets added to a #PanelFrame. */
+export interface PanelWidgetProps extends GtkWidgetProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps {
+    'can-maximize'?: boolean;
+    /** The child inside this widget. */
+    child?: Gtk.Widget | null;
+    /** The icon for this widget. */
+    icon?: Gio.Icon | null;
+    /** The icon name for this widget. */
+    'icon-name'?: string | null;
+    id?: string;
+    kind?: string;
+    /** A menu model to display additional options for the page to the user via menus. */
+    'menu-model'?: Gio.MenuModel | null;
+    modified?: boolean;
+    'needs-attention'?: boolean;
+    reorderable?: boolean;
+    /** The save delegate attached to this widget. */
+    'save-delegate'?: Panel.SaveDelegate | null;
+    /** The title for this widget. */
+    title?: string | null;
+    /**
+     * The tooltip to display in tabs for the widget.
+     * @since 1.2
+     */
+    tooltip?: string | null;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelWidgetConstructOnly = GtkWidgetConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly;
+
+export interface PanelWorkspaceProps extends AdwApplicationWindowProps, GtkAccessibleProps, GtkBuildableProps, GtkConstraintTargetProps, GtkNativeProps, GtkRootProps, GtkShortcutManagerProps {
+    /**
+     * The "id" of the workspace.
+     * @since 1.4
+     */
+    id?: string;
+}
+/** Settable only at construction — a renderer must REBUILD, not patch. */
+export type PanelWorkspaceConstructOnly = AdwApplicationWindowConstructOnly | GtkAccessibleConstructOnly | GtkBuildableConstructOnly | GtkConstraintTargetConstructOnly | GtkNativeConstructOnly | GtkRootConstructOnly | GtkShortcutManagerConstructOnly;
+
+// ---------------------------------------------------------------------------
+// The GType-keyed widget map.
+//
+// Keyed by GType because that is also the GtkBuilder XML key and the typelib key. A
+// consumer maps GTypes to tags in ITS convention — kebab for JSX intrinsics, Pascal
+// for a Vue `GlobalComponents`, the class itself for a renderer whose element type
+// is the class. None of those is baked in here.
+//
+// `slotCandidates` is a candidate list and never an answer: derived from methods
+// taking exactly one widget argument. The GIR cannot tell adoption from reference —
+// `set_title_widget` parents its argument and `set_activatable_widget` does not, and
+// both are `void f(GtkWidget*)` at `transfer-ownership="none"`. Curation decides;
+// this is what notices when a release adds a candidate.
+// ---------------------------------------------------------------------------
+
+export interface Widgets {
+    PanelChangesDialog: {
+        class: Panel.ChangesDialog;
+        props: PanelChangesDialogProps;
+        signals: Panel.ChangesDialog.SignalSignatures;
+        constructOnly: PanelChangesDialogConstructOnly;
+        slotCandidates: {};
+    };
+    PanelDock: {
+        class: Panel.Dock;
+        props: PanelDockProps;
+        signals: Panel.Dock.SignalSignatures;
+        constructOnly: PanelDockConstructOnly;
+        slotCandidates: {};
+    };
+    PanelDocumentWorkspace: {
+        class: Panel.DocumentWorkspace;
+        props: PanelDocumentWorkspaceProps;
+        signals: Panel.DocumentWorkspace.SignalSignatures;
+        constructOnly: PanelDocumentWorkspaceConstructOnly;
+        slotCandidates: {
+        'titlebar': 'set_titlebar';
+        };
+    };
+    PanelFrame: {
+        class: Panel.Frame;
+        props: PanelFrameProps;
+        signals: Panel.Frame.SignalSignatures;
+        constructOnly: PanelFrameConstructOnly;
+        slotCandidates: {
+        'header': 'set_header';
+        'placeholder': 'set_placeholder';
+        'visible-child': 'set_visible_child';
+        };
+    };
+    PanelFrameHeaderBar: {
+        class: Panel.FrameHeaderBar;
+        props: PanelFrameHeaderBarProps;
+        signals: Panel.FrameHeaderBar.SignalSignatures;
+        constructOnly: PanelFrameHeaderBarConstructOnly;
+        slotCandidates: {};
+    };
+    PanelFrameSwitcher: {
+        class: Panel.FrameSwitcher;
+        props: PanelFrameSwitcherProps;
+        signals: Panel.FrameSwitcher.SignalSignatures;
+        constructOnly: PanelFrameSwitcherConstructOnly;
+        slotCandidates: {};
+    };
+    PanelFrameTabBar: {
+        class: Panel.FrameTabBar;
+        props: PanelFrameTabBarProps;
+        signals: Panel.FrameTabBar.SignalSignatures;
+        constructOnly: PanelFrameTabBarConstructOnly;
+        slotCandidates: {};
+    };
+    PanelGrid: {
+        class: Panel.Grid;
+        props: PanelGridProps;
+        signals: Panel.Grid.SignalSignatures;
+        constructOnly: PanelGridConstructOnly;
+        slotCandidates: {};
+    };
+    PanelGridColumn: {
+        class: Panel.GridColumn;
+        props: PanelGridColumnProps;
+        signals: Panel.GridColumn.SignalSignatures;
+        constructOnly: PanelGridColumnConstructOnly;
+        slotCandidates: {};
+    };
+    PanelOmniBar: {
+        class: Panel.OmniBar;
+        props: PanelOmniBarProps;
+        signals: Panel.OmniBar.SignalSignatures;
+        constructOnly: PanelOmniBarConstructOnly;
+        slotCandidates: {
+        'popover': 'set_popover';
+        };
+    };
+    PanelPaned: {
+        class: Panel.Paned;
+        props: PanelPanedProps;
+        signals: Panel.Paned.SignalSignatures;
+        constructOnly: PanelPanedConstructOnly;
+        slotCandidates: {};
+    };
+    PanelSaveDialog: {
+        class: Panel.SaveDialog;
+        props: PanelSaveDialogProps;
+        signals: Panel.SaveDialog.SignalSignatures;
+        constructOnly: PanelSaveDialogConstructOnly;
+        slotCandidates: {};
+    };
+    PanelStatusbar: {
+        class: Panel.Statusbar;
+        props: PanelStatusbarProps;
+        signals: Panel.Statusbar.SignalSignatures;
+        constructOnly: PanelStatusbarConstructOnly;
+        slotCandidates: {};
+    };
+    PanelThemeSelector: {
+        class: Panel.ThemeSelector;
+        props: PanelThemeSelectorProps;
+        signals: Panel.ThemeSelector.SignalSignatures;
+        constructOnly: PanelThemeSelectorConstructOnly;
+        slotCandidates: {};
+    };
+    PanelToggleButton: {
+        class: Panel.ToggleButton;
+        props: PanelToggleButtonProps;
+        signals: Panel.ToggleButton.SignalSignatures;
+        constructOnly: PanelToggleButtonConstructOnly;
+        slotCandidates: {};
+    };
+    PanelWidget: {
+        class: Panel.Widget;
+        props: PanelWidgetProps;
+        signals: Panel.Widget.SignalSignatures;
+        constructOnly: PanelWidgetConstructOnly;
+        slotCandidates: {
+        'child': 'set_child';
+        };
+    };
+    PanelWorkspace: {
+        class: Panel.Workspace;
+        props: PanelWorkspaceProps;
+        signals: Panel.Workspace.SignalSignatures;
+        constructOnly: PanelWorkspaceConstructOnly;
+        slotCandidates: {};
+    };
+}
+
+/** Every GType this namespace can create. A consumer derives its own tag map. */
+export type WidgetGType = keyof Widgets;
+
+/** The writable, optional, GObject-keyed property surface of one GType. */
+export type PropsOf<G extends WidgetGType> = Widgets[G]['props'];
+
+/** The signal table this package already emits, reached by GType. */
+export type SignalsOf<G extends WidgetGType> = Widgets[G]['signals'];
+
+/** The instance type — what a `ref`-shaped prop should infer. */
+export type InstanceOf<G extends WidgetGType> = Widgets[G]['class'];
+
+/** Property names that can only be set at construction. */
+export type ConstructOnlyOf<G extends WidgetGType> = Widgets[G]['constructOnly'];
+
+/** Candidate child slots — see the note above; curation decides. */
+export type SlotCandidatesOf<G extends WidgetGType> = keyof Widgets[G]['slotCandidates'];
+
+/**
+ * The same facts as runtime data, for a consumer that CHECKS them.
+ *
+ * Types are erased, so a spec that asks the installed GTK whether every property
+ * here is a writable ParamSpec, every signal resolvable by `GObject.signal_lookup`
+ * and every nick resolvable through an enum lookup cannot read the interfaces
+ * above. Emitted headlessly with no GTK present, which is exactly why the checking
+ * belongs to the consumer and the DATA belongs here.
+ */
+export const SURFACE_PROVENANCE: string;
+
+/** Declaration GType -> its own settable properties, as GObject registered them. */
+export const OWN_PROPS: Readonly<Record<string, readonly string[]>>;
+
+/** Widget GType -> its own signals. */
+export const OWN_SIGNALS: Readonly<Record<string, readonly string[]>>;
+
+/** Widget GType -> every declaration its members come from, self first. */
+export const DECLS: Readonly<Record<string, readonly string[]>>;
+
+/** Enum GType -> the nicks this surface offers. */
+export const ENUM_NICKS: Readonly<Record<string, readonly string[]>>;
+
+/** Widget GType -> slot name -> the method that may adopt a child there. */
+export const SLOT_CANDIDATES: Readonly<Record<string, Readonly<Record<string, string>>>>;
+
+/**
+ * `Type.property` -> the release that introduced it.
+ *
+ * What keeps a runtime cross-check honest across a version gap without an
+ * allowlist: a member the installed library lacks is a defect UNLESS the version
+ * here is newer than the one running.
+ */
+export const SINCE: Readonly<Record<string, string>>;

package/panel-1-surface.js

@@ -0,0 +1,78 @@
+// The widget vocabulary of Panel-1 as runtime data.
+//
+// GENERATED — do not edit. Provenance: Panel-1 — library 1.10.4 — dropped empty base(s): GObject.InitiallyUnowned GObject.Object Gio.ActionGroup Gio.ActionMap
+//
+// The type half of this subpath is the sibling `.d.ts`. This file exists because
+// types are erased: a consumer that wants to ask the installed library whether every
+// name here is real needs values, not declarations.
+
+export const SURFACE_PROVENANCE = 'Panel-1 — library 1.10.4 — dropped empty base(s): GObject.InitiallyUnowned GObject.Object Gio.ActionGroup Gio.ActionMap';
+
+export const OWN_PROPS = {
+    PanelChangesDialog: ['close-after-save'],
+    PanelDock: ['bottom-height', 'end-width', 'reveal-bottom', 'reveal-end', 'reveal-start', 'reveal-top', 'start-width', 'top-height'],
+    PanelFrame: ['placeholder', 'visible-child'],
+    PanelFrameHeader: ['frame'],
+    PanelFrameHeaderBar: ['show-icon'],
+    PanelFrameTabBar: ['autohide', 'expand-tabs', 'inverted'],
+    PanelOmniBar: ['action-tooltip', 'icon-name', 'menu-model', 'popover', 'progress'],
+    PanelSaveDialog: ['close-after-save'],
+    PanelThemeSelector: ['action-name'],
+    PanelToggleButton: ['area', 'dock'],
+    PanelWidget: ['can-maximize', 'child', 'icon', 'icon-name', 'id', 'kind', 'menu-model', 'modified', 'needs-attention', 'reorderable', 'save-delegate', 'title', 'tooltip'],
+    PanelWorkspace: ['id'],
+};
+
+export const OWN_SIGNALS = {
+    PanelDock: ['adopt-widget', 'create-frame', 'panel-drag-begin', 'panel-drag-end'],
+    PanelDocumentWorkspace: ['add-widget', 'create-frame'],
+    PanelFrame: ['adopt-widget', 'page-closed'],
+    PanelGrid: ['create-frame'],
+    PanelWidget: ['get-default-focus', 'presented'],
+};
+
+export const DECLS = {
+    PanelChangesDialog: ['PanelChangesDialog', 'AdwAlertDialog', 'AdwDialog', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkShortcutManager'],
+    PanelDock: ['PanelDock', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelDocumentWorkspace: ['PanelDocumentWorkspace', 'PanelWorkspace', 'AdwApplicationWindow', 'GtkApplicationWindow', 'GtkWindow', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkNative', 'GtkRoot', 'GtkShortcutManager'],
+    PanelFrame: ['PanelFrame', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkOrientable'],
+    PanelFrameHeaderBar: ['PanelFrameHeaderBar', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'PanelFrameHeader'],
+    PanelFrameSwitcher: ['PanelFrameSwitcher', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkOrientable', 'PanelFrameHeader'],
+    PanelFrameTabBar: ['PanelFrameTabBar', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'PanelFrameHeader'],
+    PanelGrid: ['PanelGrid', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelGridColumn: ['PanelGridColumn', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelOmniBar: ['PanelOmniBar', 'GtkWidget', 'GtkAccessible', 'GtkActionable', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelPaned: ['PanelPaned', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkOrientable'],
+    PanelSaveDialog: ['PanelSaveDialog', 'AdwMessageDialog', 'GtkWindow', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkNative', 'GtkRoot', 'GtkShortcutManager'],
+    PanelStatusbar: ['PanelStatusbar', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelThemeSelector: ['PanelThemeSelector', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelToggleButton: ['PanelToggleButton', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelWidget: ['PanelWidget', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget'],
+    PanelWorkspace: ['PanelWorkspace', 'AdwApplicationWindow', 'GtkApplicationWindow', 'GtkWindow', 'GtkWidget', 'GtkAccessible', 'GtkBuildable', 'GtkConstraintTarget', 'GtkNative', 'GtkRoot', 'GtkShortcutManager'],
+};
+
+export const ENUM_NICKS = {
+    PanelArea: ['start', 'end', 'top', 'bottom', 'center'],
+};
+
+export const SLOT_CANDIDATES = {
+    PanelDocumentWorkspace: {
+        'titlebar': 'set_titlebar',
+    },
+    PanelFrame: {
+        'header': 'set_header',
+        'placeholder': 'set_placeholder',
+        'visible-child': 'set_visible_child',
+    },
+    PanelOmniBar: {
+        'popover': 'set_popover',
+    },
+    PanelWidget: {
+        'child': 'set_child',
+    },
+};
+
+export const SINCE = {
+    'PanelWidget.tooltip': '1.2',
+    'PanelWorkspace.id': '1.4',
+};

package/panel-1.d.ts

@@ -702,11 +702,9 @@ export namespace Panel {
         interface SignalSignatures extends Adw.Application.SignalSignatures {
             "notify::style-manager": (pspec: GObject.ParamSpec) => void;
             "notify::active-window": (pspec: GObject.ParamSpec) => void;
-            "notify::autosave-interval": (pspec: GObject.ParamSpec) => void;
             "notify::menubar": (pspec: GObject.ParamSpec) => void;
             "notify::register-session": (pspec: GObject.ParamSpec) => void;
             "notify::screensaver-active": (pspec: GObject.ParamSpec) => void;
-            "notify::support-save": (pspec: GObject.ParamSpec) => void;
             "notify::action-group": (pspec: GObject.ParamSpec) => void;
             "notify::application-id": (pspec: GObject.ParamSpec) => void;
             "notify::flags": (pspec: GObject.ParamSpec) => void;
@@ -1705,7 +1703,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -2537,7 +2535,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -2552,7 +2550,7 @@ export namespace Panel {
 
         /**
          * Sets the orientation of the `orientable`.
-         * @param orientation the orientable’s new orientation
+         * @param orientation the orientable’s new orientation
          */
         set_orientation(orientation: Gtk.Orientation): void;
     }
@@ -3027,7 +3025,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -3547,7 +3545,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -3562,7 +3560,7 @@ export namespace Panel {
 
         /**
          * Sets the orientation of the `orientable`.
-         * @param orientation the orientable’s new orientation
+         * @param orientation the orientable’s new orientation
          */
         set_orientation(orientation: Gtk.Orientation): void;
 
@@ -4143,7 +4141,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -5246,7 +5244,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -5697,7 +5695,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -6612,7 +6610,7 @@ export namespace Panel {
          * Usually this function is used when the widget is located (or will be
          * located) within the hierarchy of a {@link Gtk.ApplicationWindow}.
          * 
-         * Names are of the form “win.save” or “app.quit” for actions on the
+         * Names are of the form “win.save” or “app.quit” for actions on the
          * containing {@link ApplicationWindow} or its associated {@link Application},
          * respectively. This is the same form used for actions in the {@link Gio.Menu}
          * associated with the window.
@@ -6628,14 +6626,14 @@ export namespace Panel {
          * The target value has two purposes. First, it is used as the parameter
          * to activation of the action associated with the {@link Gtk.Actionable} widget.
          * Second, it is used to determine if the widget should be rendered as
-         * “active” — the widget is active if the state is equal to the given target.
+         * “active” — the widget is active if the state is equal to the given target.
          * 
          * Consider the example of associating a set of buttons with a {@link Gio.Action}
-         * with string state in a typical “radio button” situation. Each button
+         * with string state in a typical “radio button” situation. Each button
          * will be associated with the same action, but with a different target
          * value for that action. Clicking on a particular button will activate
          * the action with the target of that button, which will typically cause
-         * the action’s state to change to that value. Since the action’s state
+         * the action’s state to change to that value. Since the action’s state
          * is now equal to the target value of the button, the button will now
          * be rendered as active (and the other buttons, with different targets,
          * rendered inactive).
@@ -6675,7 +6673,7 @@ export namespace Panel {
          * Usually this function is used when the widget is located (or will be
          * located) within the hierarchy of a {@link Gtk.ApplicationWindow}.
          * 
-         * Names are of the form “win.save” or “app.quit” for actions on the
+         * Names are of the form “win.save” or “app.quit” for actions on the
          * containing {@link ApplicationWindow} or its associated {@link Application},
          * respectively. This is the same form used for actions in the {@link Gio.Menu}
          * associated with the window.
@@ -6692,14 +6690,14 @@ export namespace Panel {
          * The target value has two purposes. First, it is used as the parameter
          * to activation of the action associated with the {@link Gtk.Actionable} widget.
          * Second, it is used to determine if the widget should be rendered as
-         * “active” — the widget is active if the state is equal to the given target.
+         * “active” — the widget is active if the state is equal to the given target.
          * 
          * Consider the example of associating a set of buttons with a {@link Gio.Action}
-         * with string state in a typical “radio button” situation. Each button
+         * with string state in a typical “radio button” situation. Each button
          * will be associated with the same action, but with a different target
          * value for that action. Clicking on a particular button will activate
          * the action with the target of that button, which will typically cause
-         * the action’s state to change to that value. Since the action’s state
+         * the action’s state to change to that value. Since the action’s state
          * is now equal to the target value of the button, the button will now
          * be rendered as active (and the other buttons, with different targets,
          * rendered inactive).
@@ -6799,7 +6797,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -7288,7 +7286,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -7303,7 +7301,7 @@ export namespace Panel {
 
         /**
          * Sets the orientation of the `orientable`.
-         * @param orientation the orientable’s new orientation
+         * @param orientation the orientable’s new orientation
          */
         set_orientation(orientation: Gtk.Orientation): void;
     }
@@ -9514,7 +9512,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -9983,7 +9981,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -10439,7 +10437,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual
@@ -11278,7 +11276,7 @@ export namespace Panel {
         /**
          * Stores the id attribute given in the {@link Gtk.Builder} UI definition.
          *   {@link Gtk.Widget} stores the name as object data. Implement this method if your
-         *   object has some notion of “ID” and it makes sense to map the XML id
+         *   object has some notion of “ID” and it makes sense to map the XML id
          *   attribute to it.
          * @param id 
          * @virtual

package/tsconfig.json

@@ -68,7 +68,7 @@
       ]
 }
   },
-  "include": ["./panel-1.d.ts"]
+  "include": ["./panel-1.d.ts","./panel-1-surface.d.ts"]
 }