@gtkx/react 0.17.2 → 0.18.0

package/dist/jsx.d.ts

@@ -1,19 +1,288 @@
 import type * as Adw from "@gtkx/ffi/adw";
+import type * as cairo from "@gtkx/ffi/cairo";
+import type * as Gdk from "@gtkx/ffi/gdk";
 import type * as Gsk from "@gtkx/ffi/gsk";
 import type * as Gtk from "@gtkx/ffi/gtk";
+import type * as GtkSource from "@gtkx/ffi/gtksource";
+import type * as Pango from "@gtkx/ffi/pango";
 import type { ReactElement, ReactNode } from "react";
-import type { AnimationProps } from "./animation/types.js";
-import type { GtkGridViewProps as GeneratedGtkGridViewProps, GtkListViewProps as GeneratedGtkListViewProps, WidgetSlotNames } from "./generated/jsx.js";
-import type { RenderItemFn } from "./nodes/internal/list-item-renderer.js";
-import type { TreeRenderItemFn } from "./nodes/internal/tree-list-item-renderer.js";
-import type { ShortcutProps as ShortcutNodeProps } from "./nodes/shortcut.js";
-import type { TextAnchorProps } from "./nodes/text-anchor.js";
-import type { TextPaintableProps } from "./nodes/text-paintable.js";
-import type { TextTagProps } from "./nodes/text-tag.js";
-export type { AnimatableProperties, AnimationMode, AnimationProps, SpringTransition, TimedTransition, } from "./animation/types.js";
-export type { TextAnchorProps } from "./nodes/text-anchor.js";
-export type { TextPaintableProps } from "./nodes/text-paintable.js";
-export type { TextTagProps } from "./nodes/text-tag.js";
+import type { WidgetSlotNames } from "./generated/jsx.js";
+/**
+ * CSS properties that can be animated on a widget.
+ *
+ * All transforms are applied via GTK CSS and rendered through the widget's style context.
+ */
+export type AnimatableProperties = {
+    /** Opacity from 0 (fully transparent) to 1 (fully opaque) */
+    opacity?: number;
+    /** Horizontal translation in pixels (positive moves right) */
+    translateX?: number;
+    /** Vertical translation in pixels (positive moves down) */
+    translateY?: number;
+    /** Uniform scale factor (1 = original size, 2 = double size) */
+    scale?: number;
+    /** Horizontal scale factor */
+    scaleX?: number;
+    /** Vertical scale factor */
+    scaleY?: number;
+    /** Rotation angle in degrees (positive rotates clockwise) */
+    rotate?: number;
+    /** Horizontal skew angle in degrees */
+    skewX?: number;
+    /** Vertical skew angle in degrees */
+    skewY?: number;
+};
+/**
+ * Transition configuration for timed (duration-based) animations.
+ *
+ * @see {@link https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/class.TimedAnimation.html Adw.TimedAnimation}
+ */
+export type TimedTransition = {
+    /** Discriminant: duration-based animation with easing curves */
+    mode: "timed";
+    /** Animation duration in milliseconds (default: 300) */
+    duration?: number;
+    /** Easing function for the animation curve (default: EASE_OUT_CUBIC) */
+    easing?: Adw.Easing;
+    /** Delay before starting the animation in milliseconds */
+    delay?: number;
+    /** Number of times to repeat the animation (0 = no repeat, -1 = infinite) */
+    repeat?: number;
+    /** Whether to play the animation in reverse */
+    reverse?: boolean;
+    /** Whether to alternate direction on each repeat */
+    alternate?: boolean;
+};
+/**
+ * Transition configuration for spring (physics-based) animations.
+ *
+ * Spring animations simulate a mass attached to a spring, providing natural-feeling motion.
+ * The animation settles when the spring reaches equilibrium.
+ *
+ * @see {@link https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/class.SpringAnimation.html Adw.SpringAnimation}
+ */
+export type SpringTransition = {
+    /** Discriminant: physics-based spring animation */
+    mode: "spring";
+    /** Damping ratio controlling oscillation decay (default: 1, critically damped) */
+    damping?: number;
+    /** Spring stiffness in N/m affecting animation speed (default: 100) */
+    stiffness?: number;
+    /** Virtual mass in kg affecting momentum (default: 1) */
+    mass?: number;
+    /** Initial velocity to apply at animation start */
+    initialVelocity?: number;
+    /** Whether to clamp the animation value to prevent overshooting */
+    clamp?: boolean;
+    /** Delay before starting the animation in milliseconds */
+    delay?: number;
+};
+/**
+ * Discriminated union of all transition configurations.
+ *
+ * The `mode` field determines the animation type:
+ * - `"timed"`: Duration-based animation with easing curves (uses {@link Adw.TimedAnimation})
+ * - `"spring"`: Physics-based spring animation (uses {@link Adw.SpringAnimation})
+ */
+export type AnimationTransition = TimedTransition | SpringTransition;
+/**
+ * Props for the Animation component.
+ *
+ * Provides a declarative API for animating widget properties using either
+ * timed (duration-based) or spring (physics-based) animations.
+ *
+ * @example
+ * ```tsx
+ * <x.Animation
+ *   initial={{ opacity: 0, translateY: -20 }}
+ *   animate={{ opacity: 1, translateY: 0 }}
+ *   exit={{ opacity: 0, translateY: 20 }}
+ *   transition={{ mode: "spring", damping: 0.8, stiffness: 200 }}
+ *   animateOnMount
+ * >
+ *   <GtkLabel label="Animated content" />
+ * </x.Animation>
+ * ```
+ */
+export type AnimationProps = {
+    /** Initial property values before animation starts, or `false` to skip initial state */
+    initial?: AnimatableProperties | false;
+    /** Target property values to animate towards */
+    animate?: AnimatableProperties;
+    /** Property values to animate to when the component unmounts */
+    exit?: AnimatableProperties;
+    /** Transition configuration including animation mode and parameters */
+    transition?: AnimationTransition;
+    /** Whether to animate from `initial` to `animate` when first mounted (default: false) */
+    animateOnMount?: boolean;
+    /** Callback fired when an animation begins */
+    onAnimationStart?: () => void;
+    /** Callback fired when an animation completes */
+    onAnimationComplete?: () => void;
+    /** The child widget to animate (must be a single GTK widget) */
+    children?: ReactNode;
+};
+/**
+ * Props for the Shortcut virtual element.
+ *
+ * Defines a keyboard shortcut. Must be a child of `x.ShortcutController`.
+ *
+ * @example
+ * ```tsx
+ * <x.ShortcutController>
+ *     <x.Shortcut trigger="<Control>s" onActivate={save} />
+ *     <x.Shortcut trigger={["F5", "<Control>r"]} onActivate={refresh} />
+ *     <x.Shortcut trigger="Escape" onActivate={cancel} disabled={!canCancel} />
+ * </x.ShortcutController>
+ * ```
+ */
+export type ShortcutProps = {
+    /** The trigger string(s) using GTK accelerator format (e.g., "\<Control\>s", "F1") */
+    trigger: string | string[];
+    /**
+     * Called when the shortcut is activated.
+     * Return false to indicate the shortcut was not handled; otherwise it is considered handled.
+     */
+    onActivate: () => boolean | void;
+    /** Whether the shortcut is disabled */
+    disabled?: boolean;
+};
+/**
+ * Props for the TextAnchor virtual element.
+ *
+ * Used to declaratively embed widgets within text content in a TextBuffer.
+ * The anchor is placed at the current position in the text flow.
+ *
+ * @example
+ * ```tsx
+ * <GtkTextView>
+ *     <x.TextBuffer>
+ *         Click here: <x.TextAnchor>
+ *             <GtkButton label="Click me" />
+ *         </x.TextAnchor> to continue.
+ *     </x.TextBuffer>
+ * </GtkTextView>
+ * ```
+ */
+export type TextAnchorProps = {
+    /** The widget to embed at this anchor position */
+    children?: ReactNode;
+};
+/**
+ * Props for the TextPaintable virtual element.
+ *
+ * Used to embed inline images or icons within text content in a GtkTextView.
+ */
+export type TextPaintableProps = {
+    /** The paintable (image, icon, etc.) to embed inline with the text */
+    paintable: Gdk.Paintable;
+};
+/**
+ * Props for the TextTag virtual element.
+ *
+ * Used to declaratively define and apply text formatting to content within a TextBuffer.
+ *
+ * @example
+ * ```tsx
+ * <GtkTextView>
+ *     <x.TextBuffer>
+ *         Hello <x.TextTag id="bold" weight={Pango.Weight.BOLD}>bold</x.TextTag> world
+ *     </x.TextBuffer>
+ * </GtkTextView>
+ * ```
+ */
+export type TextTagProps = {
+    /** Unique identifier for this tag in the tag table */
+    id: string;
+    /** Priority of this tag (higher wins when multiple tags affect same property) */
+    priority?: number;
+    /** Background color as a string (e.g., "red", "#ff0000") */
+    background?: string;
+    /** Whether the background fills the entire line height */
+    backgroundFullHeight?: boolean;
+    /** Foreground (text) color as a string */
+    foreground?: string;
+    /** Font family name (e.g., "Sans", "Monospace") */
+    family?: string;
+    /** Font description string (e.g., "Sans Italic 12") */
+    font?: string;
+    /** Font size in points */
+    sizePoints?: number;
+    /** Font size in Pango units */
+    size?: number;
+    /** Font size scale factor relative to default */
+    scale?: number;
+    /** Font weight (use Pango.Weight constants) */
+    weight?: Pango.Weight | number;
+    /** Font style (use Pango.Style constants) */
+    style?: Pango.Style;
+    /** Font stretch (use Pango.Stretch constants) */
+    stretch?: Pango.Stretch;
+    /** Font variant (use Pango.Variant constants) */
+    variant?: Pango.Variant;
+    /** Whether to strike through the text */
+    strikethrough?: boolean;
+    /** Underline style (use Pango.Underline constants) */
+    underline?: Pango.Underline;
+    /** Overline style (use Pango.Overline constants) */
+    overline?: Pango.Overline;
+    /** Offset of text above baseline in Pango units (negative = below) */
+    rise?: number;
+    /** Extra spacing between characters in Pango units */
+    letterSpacing?: number;
+    /** Factor to scale line height by */
+    lineHeight?: number;
+    /** Left margin in pixels */
+    leftMargin?: number;
+    /** Right margin in pixels */
+    rightMargin?: number;
+    /** Paragraph indent in pixels (negative = hanging) */
+    indent?: number;
+    /** Pixels of blank space above paragraphs */
+    pixelsAboveLines?: number;
+    /** Pixels of blank space below paragraphs */
+    pixelsBelowLines?: number;
+    /** Pixels of blank space between wrapped lines */
+    pixelsInsideWrap?: number;
+    /** Text justification */
+    justification?: Gtk.Justification;
+    /** Text direction */
+    direction?: Gtk.TextDirection;
+    /** Wrap mode for line breaks */
+    wrapMode?: Gtk.WrapMode;
+    /** Whether the text can be modified */
+    editable?: boolean;
+    /** Whether the text is invisible/hidden */
+    invisible?: boolean;
+    /** Whether breaks are allowed */
+    allowBreaks?: boolean;
+    /** Whether to insert hyphens at breaks */
+    insertHyphens?: boolean;
+    /** Whether font fallback is enabled */
+    fallback?: boolean;
+    /** Whether margins accumulate */
+    accumulativeMargin?: boolean;
+    /** Paragraph background color as a string */
+    paragraphBackground?: string;
+    /** How to render invisible characters */
+    showSpaces?: Pango.ShowFlags;
+    /** How to transform text for display */
+    textTransform?: Pango.TextTransform;
+    /** OpenType font features as a string */
+    fontFeatures?: string;
+    /** Language code (e.g., "en-US") */
+    language?: string;
+    /** Text content and nested TextTag children */
+    children?: ReactNode;
+};
+/** Props for the TextSegment virtual element.
+ *
+ * Represents a segment of text within a TextBuffer.
+ */
+export type TextSegmentProps = {
+    /** The text content of this segment */
+    text: string;
+};
 /**
  * Configuration for a mark on a GtkScale widget.
  *
@@ -57,29 +326,41 @@ export type SlotProps = {
     children?: ReactNode;
 };
 /**
- * Props for virtual child containers that don't expose slot id.
+ * Type mapping widgets to their valid container slot method names.
+ *
+ * Each key is a JSX element name and each value is a union of method names
+ * that can be used as the `id` prop on `x.ContainerSlot`.
  */
-export type VirtualSlotProps = {
-    /** Content to place in the slot */
-    children?: ReactNode;
+export type ContainerSlotNames = {
+    AdwActionRow: "addPrefix" | "addSuffix";
+    AdwEntryRow: "addPrefix" | "addSuffix";
+    AdwExpanderRow: "addPrefix" | "addSuffix" | "addRow" | "addAction";
+    AdwHeaderBar: "packStart" | "packEnd";
+    AdwToolbarView: "addTopBar" | "addBottomBar";
+    GtkActionBar: "packStart" | "packEnd";
+    GtkHeaderBar: "packStart" | "packEnd";
 };
 /**
- * Props for items in a {@link ListView} or {@link GridView}.
+ * Props for method-based container slot child positioning.
  *
- * @typeParam T - The type of data associated with this list item
+ * @see {@link x.ContainerSlot} for type-safe usage
  */
-export type ListItemProps<T = unknown> = {
-    /** Unique identifier for this item */
+export type ContainerSlotProps = {
+    /** The method name to call on the parent widget */
     id: string;
-    /** The data value for this item */
-    value: T;
+    /** Content to place in the container slot */
+    children?: ReactNode;
 };
 /**
- * Props for items in a {@link TreeListView}.
+ * Props for items in a GtkListView, GtkGridView, or GtkColumnView.
+ *
+ * When used inside a GtkListView, items can be nested to create tree hierarchies.
+ * Tree-specific props (`indentForDepth`, `indentForIcon`, `hideExpander`) only
+ * apply when items are used inside a GtkListView with nested children.
  *
- * @typeParam T - The type of data associated with this tree item
+ * @typeParam T - The type of data associated with this list item
  */
-export type TreeListItemProps<T = unknown> = {
+export type ListItemProps<T = unknown> = {
     /** Unique identifier for this item */
     id: string;
     /** The data value for this item */
@@ -90,26 +371,17 @@ export type TreeListItemProps<T = unknown> = {
     indentForIcon?: boolean;
     /** Whether to hide the expand/collapse arrow */
     hideExpander?: boolean;
-    /** Nested tree items (children of this item) */
+    /** Nested list items (children of this item in a tree) */
     children?: ReactNode;
 };
-/**
- * Props for string-based list items.
- *
- * Use with `SimpleListItem` for simple string lists.
- */
-export type StringListItemProps = {
-    /** Unique identifier for this item */
-    id: string;
-    /** The string value for this item */
-    value: string;
-};
 /**
  * Props for positioning children within a GtkGrid.
  *
  * @see {@link GridChild} for usage
  */
-export type GridChildProps = VirtualSlotProps & {
+export type GridChildProps = {
+    /** Content to place in the grid cell */
+    children?: ReactNode;
     /** Column index (0-based) */
     column?: number;
     /** Row index (0-based) */
@@ -124,7 +396,9 @@ export type GridChildProps = VirtualSlotProps & {
  *
  * @see {@link FixedChild} for usage
  */
-export type FixedChildProps = VirtualSlotProps & {
+export type FixedChildProps = {
+    /** Content to place in the fixed container */
+    children?: ReactNode;
     /** X coordinate in pixels */
     x?: number;
     /** Y coordinate in pixels */
@@ -132,15 +406,6 @@ export type FixedChildProps = VirtualSlotProps & {
     /** 3D transform to apply to the child (perspective, rotation, etc.) */
     transform?: Gsk.Transform;
 };
-/**
- * Props for custom list view rendering.
- *
- * @typeParam T - The type of items in the list
- */
-export type ListViewRenderProps<T = unknown> = {
-    /** Function to render each list item */
-    renderItem: RenderItemFn<T>;
-};
 /**
  * Props for defining a column in a ColumnView (table).
  *
@@ -164,25 +429,12 @@ export type ColumnViewColumnProps<T = unknown> = {
     /** Function to render the cell content for each row */
     renderCell: (item: T | null) => ReactNode;
 };
-/**
- * Props for the root ColumnView component.
- *
- * @typeParam C - String literal type for column IDs
- */
-export type ColumnViewRootProps<C extends string = string> = {
-    /** Currently sorted column ID, or null for no sorting */
-    sortColumn?: C | null;
-    /** Sort direction (ascending or descending) */
-    sortOrder?: Gtk.SortType;
-    /** Callback when sort changes */
-    onSortChanged?: (column: C | null, order: Gtk.SortType) => void;
-    /** Estimated row height in pixels for proper virtualization before content loads */
-    estimatedRowHeight?: number;
-};
 /**
  * Props for notebook (tabbed) pages.
  */
-export type NotebookPageProps = VirtualSlotProps & {
+export type NotebookPageProps = {
+    /** Content to place in the notebook page */
+    children?: ReactNode;
     /** Tab label text (optional when using Notebook.PageTab) */
     label?: string;
     /** Whether the tab should expand to fill available space */
@@ -193,20 +445,18 @@ export type NotebookPageProps = VirtualSlotProps & {
 /**
  * Props for custom notebook page tab widgets.
  */
-export type NotebookPageTabProps = VirtualSlotProps;
-/**
- * Props for the root Stack component.
- */
-export type StackRootProps = VirtualSlotProps & {
-    /** ID of the currently visible page */
-    page?: string;
+export type NotebookPageTabProps = {
+    /** Content to place in the notebook page tab */
+    children?: ReactNode;
 };
 /**
  * Props for pages within a Stack or ViewStack.
  *
  * @see {@link StackPage} for usage
  */
-export type StackPageProps = VirtualSlotProps & {
+export type StackPageProps = {
+    /** Content to place in the stack page */
+    children?: ReactNode;
     /** Unique identifier for this page (used with page prop) */
     id?: string;
     /** Display title shown in stack switchers */
@@ -260,7 +510,9 @@ export type MenuSubmenuProps = {
 /**
  * Props for children within an Overlay container.
  */
-export type OverlayChildProps = VirtualSlotProps & {
+export type OverlayChildProps = {
+    /** Content to place in the overlay child */
+    children?: ReactNode;
     /** Whether to include this child in size measurement */
     measure?: boolean;
     /** Whether to clip this overlay child to the main child bounds */
@@ -311,25 +563,14 @@ export type AlertDialogResponseProps = {
     /** Whether the response button is enabled */
     enabled?: boolean;
 };
-/**
- * Props for ExpanderRow child slots (Row and Action).
- */
-export type ExpanderRowChildProps = {
-    /** Children to add to this slot */
-    children?: ReactNode;
-};
 type NavigationPageBaseProps = {
+    /** Display title for the navigation page */
     title?: string;
+    /** Whether the page can be popped from the navigation stack */
     canPop?: boolean;
+    /** Page content */
     children?: ReactNode;
 };
-export type { GtkShortcutControllerProps as ShortcutControllerProps } from "./generated/jsx.js";
-/**
- * Props for the Shortcut element in JSX.
- *
- * @see {@link x.Shortcut} for usage examples
- */
-export type ShortcutProps = ShortcutNodeProps;
 /**
  * Props for the NavigationPage virtual element with type-safe targeting.
  *
@@ -364,47 +605,84 @@ export type NavigationPageProps = (NavigationPageBaseProps & {
     for: "AdwNavigationSplitView";
     id: WidgetSlotNames["AdwNavigationSplitView"];
 });
-export type { WidgetSlotNames };
 /**
- * Props for the ListView component.
+ * Props shared by text buffer hosts (GtkTextView, GtkSourceView).
  *
- * @typeParam T - The type of items in the list
+ * Provides undo control and buffer mutation callbacks.
  */
-export type ListViewProps<T = unknown> = Omit<GeneratedGtkListViewProps, "renderItem"> & {
-    /** Function to render each list item */
-    renderItem: (item: T | null) => ReactNode;
-    /** Estimated item height in pixels for proper virtualization before content loads */
+export type TextBufferProps = {
+    /** Whether undo/redo is enabled on the text buffer */
+    enableUndo?: boolean;
+    /** Callback fired when the buffer content changes */
+    onBufferChanged?: ((buffer: Gtk.TextBuffer) => void) | null;
+    /** Callback fired when text is inserted into the buffer */
+    onTextInserted?: ((buffer: Gtk.TextBuffer, offset: number, text: string) => void) | null;
+    /** Callback fired when text is deleted from the buffer */
+    onTextDeleted?: ((buffer: Gtk.TextBuffer, startOffset: number, endOffset: number) => void) | null;
+    /** Callback fired when the undo availability changes */
+    onCanUndoChanged?: ((canUndo: boolean) => void) | null;
+    /** Callback fired when the redo availability changes */
+    onCanRedoChanged?: ((canRedo: boolean) => void) | null;
+};
+type BaseListViewProps = {
+    /** Estimated item height in pixels for virtualization */
     estimatedItemHeight?: number;
+    /** Array of selected item IDs */
+    selected?: string[] | null;
+    /** Callback fired when the selection changes */
+    onSelectionChanged?: ((ids: string[]) => void) | null;
+    /** Selection behavior (single, multiple, none, etc.) */
+    selectionMode?: Gtk.SelectionMode | null;
+};
+export type ListViewProps = BaseListViewProps & {
+    /** Function to render each list item. The `row` parameter provides tree state for hierarchical lists. */
+    renderItem: (item: any, row?: Gtk.TreeListRow | null) => ReactNode;
+    /** Whether to automatically expand new tree rows (default: false) */
+    autoexpand?: boolean;
+};
+export type GridViewProps = BaseListViewProps & {
+    /** Function to render each grid item */
+    renderItem: (item: any) => ReactNode;
 };
 /**
- * Props for the GridView component.
- *
- * @typeParam T - The type of items in the grid
+ * Props shared by single-selection dropdown widgets (GtkDropDown, AdwComboRow).
  */
-export type GridViewProps<T = unknown> = Omit<GeneratedGtkGridViewProps, "renderItem"> & {
-    /** Function to render each grid item */
-    renderItem: (item: T | null) => ReactNode;
-    /** Estimated item height in pixels for proper virtualization before content loads */
-    estimatedItemHeight?: number;
+export type DropDownProps = {
+    /** ID of the currently selected item */
+    selectedId?: string | null;
+    /** Callback fired when the selected item changes */
+    onSelectionChanged?: ((id: string) => void) | null;
+};
+/**
+ * Props shared by dialog button widgets (GtkColorDialogButton, GtkFontDialogButton).
+ */
+export type DialogButtonProps = {
+    /** Title for the chooser dialog */
+    title?: string;
+    /** Whether the dialog is modal */
+    modal?: boolean;
 };
 /**
- * Props for the TreeListView component.
+ * Props for widgets backed by a GtkAdjustment.
  *
- * @typeParam T - The type of items in the tree
+ * Used by GtkRange, GtkScaleButton, GtkSpinButton, and AdwSpinRow
+ * to configure the adjustment bounds, increments, and value change callback.
  */
-export type TreeListViewProps<T = unknown> = Omit<GeneratedGtkListViewProps, "renderItem"> & {
-    /** Function to render each tree item */
-    renderItem: TreeRenderItemFn<T>;
-    /** Estimated item height in pixels for proper virtualization before content loads */
-    estimatedItemHeight?: number;
-    /** Whether to automatically expand new rows (default: false) */
-    autoexpand?: boolean;
-    /** Selection mode for the tree */
-    selectionMode?: Gtk.SelectionMode;
-    /** Currently selected item IDs */
-    selected?: string[];
-    /** Callback when selection changes */
-    onSelectionChanged?: (ids: string[]) => void;
+export type AdjustableProps = {
+    /** The current value of the adjustable */
+    value?: number;
+    /** The minimum allowed value */
+    lower?: number;
+    /** The maximum allowed value */
+    upper?: number;
+    /** The step increment for small adjustments */
+    stepIncrement?: number;
+    /** The page increment for larger adjustments */
+    pageIncrement?: number;
+    /** The size of the visible portion (for scrollbars) */
+    pageSize?: number;
+    /** Callback fired when the adjustable value changes */
+    onValueChanged?: ((value: number, self: Gtk.Range | Gtk.ScaleButton | Gtk.SpinButton | Adw.SpinRow) => void) | null;
 };
 /**
  * GTKX-specific intrinsic elements and components.
@@ -423,8 +701,8 @@ export type TreeListViewProps<T = unknown> = Omit<GeneratedGtkListViewProps, "re
  * </GtkHeaderBar>
  *
  * <GtkDropDown>
- *   <x.SimpleListItem id="opt1" value="Option 1" />
- *   <x.SimpleListItem id="opt2" value="Option 2" />
+ *   <x.ListItem id="opt1" value="Option 1" />
+ *   <x.ListItem id="opt2" value="Option 2" />
  * </GtkDropDown>
  * ```
  */
@@ -506,40 +784,26 @@ export declare const x: {
      */
     NotebookPageTab: "NotebookPageTab";
     /**
-     * Element type for items in a ListView or GridView.
+     * Element type for items in a GtkListView, GtkGridView, or GtkColumnView.
      *
-     * @example
-     * ```tsx
-     * <x.ListView renderItem={(item) => <GtkLabel label={item.name} />}>
-     *   <x.ListItem id="1" value={{ name: "Item 1" }} />
-     * </x.ListView>
-     * ```
-     */
-    ListItem: "ListItem";
-    /**
-     * Element type for items in a TreeListView.
+     * Items can be nested to create tree hierarchies inside a GtkListView.
      *
      * @example
      * ```tsx
-     * <x.TreeListView renderItem={(item) => <GtkLabel label={item.name} />}>
-     *   <x.TreeListItem id="parent" value={{ name: "Parent" }}>
-     *     <x.TreeListItem id="child" value={{ name: "Child" }} />
-     *   </x.TreeListItem>
-     * </x.TreeListView>
-     * ```
-     */
-    TreeListItem: "TreeListItem";
-    /**
-     * Element type for simple string-based list items.
+     * // Flat list
+     * <GtkListView renderItem={(item) => <GtkLabel label={item.name} />}>
+     *   <x.ListItem id="1" value={{ name: "Item 1" }} />
+     * </GtkListView>
      *
-     * @example
-     * ```tsx
-     * <GtkDropDown>
-     *   <x.SimpleListItem id="opt1" value="Option 1" />
-     * </GtkDropDown>
+     * // Tree list (nested items)
+     * <GtkListView renderItem={(item, row) => <GtkLabel label={item.name} />} autoexpand>
+     *   <x.ListItem id="parent" value={{ name: "Parent" }}>
+     *     <x.ListItem id="child" value={{ name: "Child" }} />
+     *   </x.ListItem>
+     * </GtkListView>
      * ```
      */
-    SimpleListItem: "SimpleListItem";
+    ListItem: "ListItem";
     /**
      * Component for defining columns in a ColumnView (table widget).
      *
@@ -557,118 +821,41 @@ export declare const x: {
      */
     ColumnViewColumn<T = unknown>(props: ColumnViewColumnProps<T>): ReactElement;
     /**
-     * Virtualized list component with custom item rendering.
+     * Type-safe container slot for placing children via parent widget methods.
      *
-     * @example
-     * ```tsx
-     * <x.ListView renderItem={(item) => <GtkLabel label={item?.name ?? ""} />}>
-     *   <x.ListItem id="1" value={{ name: "Apple" }} />
-     * </x.ListView>
-     * ```
-     */
-    ListView<T = unknown>(props: ListViewProps<T>): ReactElement;
-    /**
-     * Virtualized grid component with custom item rendering.
+     * Unlike `x.Slot` (which uses property setters for single-child slots),
+     * `x.ContainerSlot` calls attachment methods that support multiple children
+     * (e.g., `addPrefix()`, `packStart()`, `addTopBar()`).
      *
-     * @example
-     * ```tsx
-     * <x.GridView renderItem={(item) => <GtkImage iconName={item?.icon ?? ""} />}>
-     *   <x.ListItem id="1" value={{ icon: "folder" }} />
-     * </x.GridView>
-     * ```
-     */
-    GridView<T = unknown>(props: GridViewProps<T>): ReactElement;
-    /**
-     * Tree list component with hierarchical data and expand/collapse support.
+     * The `for` prop provides TypeScript type narrowing for the `id` prop
+     * and is not used at runtime.
      *
      * @example
      * ```tsx
-     * <x.TreeListView renderItem={(item, row) => <GtkLabel label={item.name} />}>
-     *   <x.TreeListItem id="root" value={{ name: "Root" }}>
-     *     <x.TreeListItem id="child" value={{ name: "Child" }} />
-     *   </x.TreeListItem>
-     * </x.TreeListView>
-     * ```
-     */
-    TreeListView<T = unknown>(props: TreeListViewProps<T>): ReactElement;
-    /**
-     * Place child as a prefix (left side) of AdwActionRow, AdwEntryRow, or AdwExpanderRow.
-     *
-     * @example
-     * ```tsx
-     * <AdwActionRow title="Setting">
-     *   <x.ActionRowPrefix>
-     *     <GtkCheckButton />
-     *   </x.ActionRowPrefix>
-     * </AdwActionRow>
-     * ```
-     */
-    ActionRowPrefix: "ActionRowPrefix";
-    /**
-     * Place child as a suffix (right side) of AdwActionRow, AdwEntryRow, or AdwExpanderRow.
-     *
-     * @example
-     * ```tsx
-     * <AdwActionRow title="Setting">
-     *   <x.ActionRowSuffix>
-     *     <GtkButton iconName="go-next-symbolic" />
-     *   </x.ActionRowSuffix>
-     * </AdwActionRow>
-     * ```
-     */
-    ActionRowSuffix: "ActionRowSuffix";
-    /**
-     * Place child at the start (left in LTR) of HeaderBar or ActionBar.
+     * <AdwToolbarView>
+     *   <x.ContainerSlot for={AdwToolbarView} id="addTopBar">
+     *     <AdwHeaderBar />
+     *   </x.ContainerSlot>
+     * </AdwToolbarView>
      *
-     * @example
-     * ```tsx
      * <GtkHeaderBar>
-     *   <x.PackStart>
+     *   <x.ContainerSlot for={GtkHeaderBar} id="packStart">
      *     <GtkButton label="Back" />
-     *   </x.PackStart>
-     * </GtkHeaderBar>
-     * ```
-     */
-    PackStart: "PackStart";
-    /**
-     * Place child at the end (right in LTR) of HeaderBar or ActionBar.
-     *
-     * @example
-     * ```tsx
-     * <GtkHeaderBar>
-     *   <x.PackEnd>
-     *     <GtkMenuButton />
-     *   </x.PackEnd>
+     *   </x.ContainerSlot>
      * </GtkHeaderBar>
-     * ```
-     */
-    PackEnd: "PackEnd";
-    /**
-     * Place toolbar at the top of AdwToolbarView.
-     *
-     * @example
-     * ```tsx
-     * <AdwToolbarView>
-     *   <x.ToolbarTop>
-     *     <AdwHeaderBar />
-     *   </x.ToolbarTop>
-     * </AdwToolbarView>
-     * ```
-     */
-    ToolbarTop: "ToolbarTop";
-    /**
-     * Place toolbar at the bottom of AdwToolbarView.
      *
-     * @example
-     * ```tsx
-     * <AdwToolbarView>
-     *   <x.ToolbarBottom>
-     *     <GtkActionBar />
-     *   </x.ToolbarBottom>
-     * </AdwToolbarView>
+     * <AdwActionRow title="Setting">
+     *   <x.ContainerSlot for={AdwActionRow} id="addPrefix">
+     *     <GtkCheckButton />
+     *   </x.ContainerSlot>
+     * </AdwActionRow>
      * ```
      */
-    ToolbarBottom: "ToolbarBottom";
+    ContainerSlot<W extends keyof ContainerSlotNames>(props: {
+        for: W;
+        id: ContainerSlotNames[W];
+        children?: ReactNode;
+    }): ReactElement;
     /**
      * Element type for overlay children positioned above the main content.
      *
@@ -792,33 +979,6 @@ export declare const x: {
      * ```
      */
     AlertDialogResponse: "AlertDialogResponse";
-    /**
-     * Nested rows container for AdwExpanderRow.
-     *
-     * @example
-     * ```tsx
-     * <AdwExpanderRow title="Settings">
-     *   <ExpanderRow.Row>
-     *     <AdwActionRow title="Option 1" />
-     *     <AdwActionRow title="Option 2" />
-     *   </ExpanderRow.Row>
-     * </AdwExpanderRow>
-     * ```
-     */
-    ExpanderRowRow: "ExpanderRowRow";
-    /**
-     * Action widget container for AdwExpanderRow header.
-     *
-     * @example
-     * ```tsx
-     * <AdwExpanderRow title="Group">
-     *   <ExpanderRow.Action>
-     *     <GtkButton iconName="emblem-system-symbolic" />
-     *   </ExpanderRow.Action>
-     * </AdwExpanderRow>
-     * ```
-     */
-    ExpanderRowAction: "ExpanderRowAction";
     /**
      * Type-safe page component for AdwNavigationView or AdwNavigationSplitView.
      *
@@ -847,22 +1007,6 @@ export declare const x: {
      * ```
      */
     NavigationPage: "NavigationPage";
-    /**
-     * Declarative keyboard shortcut controller.
-     *
-     * Attach keyboard shortcuts to a widget. Must contain `x.Shortcut` children.
-     *
-     * @example
-     * ```tsx
-     * <GtkBox>
-     *   <GtkShortcutController scope={Gtk.ShortcutScope.GLOBAL}>
-     *     <x.Shortcut trigger="<Control>f" onActivate={() => setSearchMode(s => !s)} />
-     *     <x.Shortcut trigger="<Control>q" onActivate={quit} />
-     *   </GtkShortcutController>
-     * </GtkBox>
-     * ```
-     */
-    ShortcutController: "GtkShortcutController";
     /**
      * A keyboard shortcut definition.
      *
@@ -884,9 +1028,9 @@ export declare const x: {
      * @example
      * ```tsx
      * <x.Animation
-     *   mode="spring"
      *   initial={{ opacity: 0, scale: 0.9 }}
      *   animate={{ opacity: 1, scale: 1 }}
+     *   transition={{ mode: "spring", damping: 0.8, stiffness: 200 }}
      *   animateOnMount
      * >
      *   <GtkButton label="Animated Button" />
@@ -895,17 +1039,18 @@ export declare const x: {
      */
     Animation: "Animation";
 };
+interface StackProps {
+    /** ID of the currently visible page */
+    page?: string | null;
+}
 declare global {
     namespace React {
         namespace JSX {
             interface IntrinsicElements {
-                ActionRowPrefix: VirtualSlotProps;
-                ActionRowSuffix: VirtualSlotProps;
                 AlertDialogResponse: AlertDialogResponseProps;
                 Animation: AnimationProps;
-                ColumnViewColumn: ColumnViewColumnProps<any>;
-                ExpanderRowAction: ExpanderRowChildProps;
-                ExpanderRowRow: ExpanderRowChildProps;
+                ContainerSlot: ContainerSlotProps;
+                ColumnViewColumn: ColumnViewColumnProps;
                 FixedChild: FixedChildProps;
                 GridChild: GridChildProps;
                 ListItem: ListItemProps;
@@ -913,23 +1058,155 @@ declare global {
                 MenuSection: MenuSectionProps;
                 MenuSubmenu: MenuSubmenuProps;
                 NotebookPage: NotebookPageProps;
-                NotebookPageTab: VirtualSlotProps;
+                NotebookPageTab: NotebookPageTabProps;
                 OverlayChild: OverlayChildProps;
-                PackEnd: VirtualSlotProps;
-                PackStart: VirtualSlotProps;
                 TextAnchor: TextAnchorProps;
                 TextPaintable: TextPaintableProps;
                 TextTag: TextTagProps;
-                SimpleListItem: StringListItemProps;
                 StackPage: StackPageProps;
                 Toggle: ToggleProps;
-                ToolbarBottom: VirtualSlotProps;
-                ToolbarTop: VirtualSlotProps;
-                TreeListItem: TreeListItemProps<any>;
                 NavigationPage: NavigationPageProps;
                 Shortcut: ShortcutProps;
             }
         }
     }
 }
+declare module "./generated/jsx.js" {
+    interface GtkRangeProps extends Omit<AdjustableProps, "onValueChanged"> {
+        /** Callback fired when the range value changes */
+        onValueChanged?: ((value: number, self: Gtk.Range) => void) | null;
+    }
+    interface GtkScaleProps {
+        /** Visual marks placed along the scale at specific values */
+        marks?: Array<{
+            value: number;
+            position?: Gtk.PositionType;
+            label?: string | null;
+        }> | null;
+    }
+    interface GtkScaleButtonProps extends Omit<AdjustableProps, "value" | "onValueChanged"> {
+        /** Callback fired when the scale button value changes */
+        onValueChanged?: ((value: number, self: Gtk.ScaleButton) => void) | null;
+    }
+    interface GtkSpinButtonProps extends Omit<AdjustableProps, "value" | "onValueChanged"> {
+        /** Callback fired when the spin button value changes */
+        onValueChanged?: ((value: number, self: Gtk.SpinButton) => void) | null;
+    }
+    interface AdwSpinRowProps extends Omit<AdjustableProps, "value" | "onValueChanged"> {
+        /** Callback fired when the spin row value changes */
+        onValueChanged?: ((value: number, self: Adw.SpinRow) => void) | null;
+    }
+    interface GtkCalendarProps {
+        /** Array of day numbers (1-31) to display as marked */
+        markedDays?: number[] | null;
+    }
+    interface GtkLevelBarProps {
+        /** Named offset thresholds that change the bar's appearance */
+        offsets?: Array<{
+            id: string;
+            value: number;
+        }> | null;
+    }
+    interface GtkTextViewProps extends TextBufferProps {
+    }
+    interface GtkSourceViewProps extends TextBufferProps {
+        /** Language for syntax highlighting (ID string or Language object) */
+        language?: string | GtkSource.Language;
+        /** Color scheme for syntax highlighting (ID string or StyleScheme object) */
+        styleScheme?: string | GtkSource.StyleScheme;
+        /** Whether syntax highlighting is enabled */
+        highlightSyntax?: boolean;
+        /** Whether matching brackets are highlighted */
+        highlightMatchingBrackets?: boolean;
+        /** Whether the buffer has an implicit trailing newline */
+        implicitTrailingNewline?: boolean;
+        /** Callback fired when the cursor position changes */
+        onCursorMoved?: (() => void) | null;
+        /** Callback fired when the highlighted region is updated */
+        onHighlightUpdated?: ((start: Gtk.TextIter, end: Gtk.TextIter) => void) | null;
+    }
+    interface GtkListViewProps extends ListViewProps {
+    }
+    interface GtkGridViewProps extends GridViewProps {
+    }
+    interface GtkColumnViewProps {
+        /** Array of selected row IDs */
+        selected?: string[] | null;
+        /** Callback fired when the selection changes */
+        onSelectionChanged?: ((ids: string[]) => void) | null;
+        /** Selection behavior (single, multiple, none, etc.) */
+        selectionMode?: Gtk.SelectionMode | null;
+        /** ID of the currently sorted column, or null for no sorting */
+        sortColumn?: string | null;
+        /** Sort direction (ascending or descending) */
+        sortOrder?: Gtk.SortType | null;
+        /** Callback fired when the sort column or order changes */
+        onSortChanged?: ((column: string | null, order: Gtk.SortType) => void) | null;
+        /** Estimated row height in pixels for virtualization */
+        estimatedRowHeight?: number | null;
+    }
+    interface GtkDropDownProps extends DropDownProps {
+    }
+    interface AdwComboRowProps extends DropDownProps {
+    }
+    interface GtkStackProps extends StackProps {
+        /** Callback fired when the visible page changes */
+        onPageChanged?: ((page: string | null, self: Gtk.Stack) => void) | null;
+    }
+    interface AdwViewStackProps extends StackProps {
+        /** Callback fired when the visible page changes */
+        onPageChanged?: ((page: string | null, self: Adw.ViewStack) => void) | null;
+    }
+    interface AdwNavigationViewProps {
+        /** Ordered list of page tags representing the navigation stack */
+        history?: string[] | null;
+        /** Callback fired when the navigation history changes */
+        onHistoryChanged?: ((history: string[]) => void) | null;
+    }
+    interface GtkWindowProps {
+        /** Callback fired when the window close button is clicked */
+        onClose?: (() => void) | null;
+    }
+    interface GtkDrawingAreaProps {
+        /** Callback fired when the drawing area needs to be redrawn */
+        onDraw?: ((self: Gtk.DrawingArea, cr: cairo.Context, width: number, height: number) => void) | null;
+    }
+    interface GtkColorDialogButtonProps extends DialogButtonProps {
+        /** Callback fired when the selected color changes */
+        onRgbaChanged?: ((rgba: Gdk.RGBA) => void) | null;
+        /** Whether to show an alpha (opacity) channel */
+        withAlpha?: boolean;
+    }
+    interface GtkFontDialogButtonProps extends DialogButtonProps {
+        /** Callback fired when the selected font changes */
+        onFontDescChanged?: ((fontDesc: Pango.FontDescription) => void) | null;
+    }
+    interface GtkAboutDialogProps {
+        /** Additional credit sections with names and lists of people */
+        creditSections?: Array<{
+            name: string;
+            people: string[];
+        }>;
+    }
+    interface GtkSearchBarProps {
+        /** Callback fired when search mode is toggled */
+        onSearchModeChanged?: ((searchMode: boolean) => void) | null;
+    }
+    interface AdwToggleGroupProps {
+        /** Callback fired when the active toggle changes */
+        onActiveChanged?: ((active: number, activeName: string | null) => void) | null;
+    }
+    interface GtkDragSourceProps {
+        /** Paintable to use as the drag icon */
+        icon?: Gdk.Paintable | null;
+        /** X offset of the hotspot within the drag icon */
+        iconHotX?: number;
+        /** Y offset of the hotspot within the drag icon */
+        iconHotY?: number;
+    }
+    interface GtkDropTargetProps {
+        /** GType values for accepted drop content types */
+        types?: number[];
+    }
+}
 export * from "./generated/jsx.js";