@gtkx/react 0.1.11

package/dist/generated/jsx.d.ts

@@ -0,0 +1,1598 @@
+import type { ReactNode, Ref } from "react";
+import type * as Gdk from "@gtkx/ffi/gdk";
+import type * as Gio from "@gtkx/ffi/gio";
+import type * as Gtk from "@gtkx/ffi/gtk";
+import type { GridChildProps, ItemProps, SlotProps } from "../types.js";
+export { SlotProps, GridChildProps, ItemProps };
+export interface WidgetProps {
+    canFocus?: boolean;
+    canTarget?: boolean;
+    cssClasses?: string[];
+    cssName?: string;
+    cursor?: unknown;
+    focusOnClick?: boolean;
+    focusable?: boolean;
+    halign?: Gtk.Align;
+    hasDefault?: boolean;
+    hasFocus?: boolean;
+    hasTooltip?: boolean;
+    heightRequest?: number;
+    hexpand?: boolean;
+    hexpandSet?: boolean;
+    layoutManager?: Gtk.LayoutManager;
+    limitEvents?: boolean;
+    marginBottom?: number;
+    marginEnd?: number;
+    marginStart?: number;
+    marginTop?: number;
+    name?: string;
+    opacity?: number;
+    overflow?: Gtk.Overflow;
+    parent?: Gtk.Widget;
+    receivesDefault?: boolean;
+    root?: Gtk.Root;
+    scaleFactor?: number;
+    sensitive?: boolean;
+    tooltipMarkup?: string;
+    tooltipText?: string;
+    valign?: Gtk.Align;
+    vexpand?: boolean;
+    vexpandSet?: boolean;
+    visible?: boolean;
+    widthRequest?: number;
+    onDestroy?: () => void;
+    onDirectionChanged?: (previousDirection: Gtk.TextDirection) => void;
+    onHide?: () => void;
+    onKeynavFailed?: (direction: Gtk.DirectionType) => boolean;
+    onMap?: () => void;
+    onMnemonicActivate?: (groupCycling: boolean) => boolean;
+    onMoveFocus?: (direction: Gtk.DirectionType) => void;
+    onQueryTooltip?: (x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
+    onRealize?: () => void;
+    onShow?: () => void;
+    onStateFlagsChanged?: (flags: Gtk.StateFlags) => void;
+    onUnmap?: () => void;
+    onUnrealize?: () => void;
+    children?: ReactNode;
+}
+export interface WindowProps extends WidgetProps {
+    application?: Gtk.Application;
+    decorated?: boolean;
+    defaultHeight?: number;
+    defaultWidth?: number;
+    deletable?: boolean;
+    destroyWithParent?: boolean;
+    display?: unknown;
+    focusVisible?: boolean;
+    fullscreened?: boolean;
+    gravity?: Gtk.WindowGravity;
+    handleMenubarAccel?: boolean;
+    hideOnClose?: boolean;
+    iconName?: string;
+    isActive?: boolean;
+    maximized?: boolean;
+    mnemonicsVisible?: boolean;
+    modal?: boolean;
+    resizable?: boolean;
+    startupId?: string;
+    suspended?: boolean;
+    title?: string;
+    onActivateDefault?: () => void;
+    onActivateFocus?: () => void;
+    onCloseRequest?: () => boolean;
+    onEnableDebugging?: (toggle: boolean) => boolean;
+    onKeysChanged?: () => void;
+    ref?: Ref<Gtk.Window>;
+}
+export interface AboutDialogProps extends WindowProps {
+    artists?: string[];
+    authors?: string[];
+    comments?: string;
+    copyright?: string;
+    documenters?: string[];
+    license?: string;
+    licenseType?: Gtk.License;
+    logo?: unknown;
+    logoIconName?: string;
+    programName?: string;
+    systemInformation?: string;
+    translatorCredits?: string;
+    version?: string;
+    website?: string;
+    websiteLabel?: string;
+    wrapLicense?: boolean;
+    onActivateLink?: (uri: string) => boolean;
+    ref?: Ref<Gtk.AboutDialog>;
+}
+export interface ActionBarProps extends WidgetProps {
+    revealed?: boolean;
+    ref?: Ref<Gtk.ActionBar>;
+}
+export interface AppChooserButtonProps extends WidgetProps {
+    heading?: string;
+    modal?: boolean;
+    showDefaultItem?: boolean;
+    showDialogItem?: boolean;
+    contentType: string;
+    onActivate?: () => void;
+    onChanged?: () => void;
+    onCustomItemActivated?: (itemName: string) => void;
+    ref?: Ref<Gtk.AppChooserButton>;
+}
+export interface AppChooserDialogProps extends DialogProps {
+    gfile: unknown;
+    heading?: string;
+    contentType?: string;
+    ref?: Ref<Gtk.AppChooserDialog>;
+}
+export interface AppChooserWidgetProps extends WidgetProps {
+    defaultText?: string;
+    showAll?: boolean;
+    showDefault?: boolean;
+    showFallback?: boolean;
+    showOther?: boolean;
+    showRecommended?: boolean;
+    contentType: string;
+    onApplicationActivated?: (application: Gio.AppInfo) => void;
+    onApplicationSelected?: (application: Gio.AppInfo) => void;
+    ref?: Ref<Gtk.AppChooserWidget>;
+}
+export interface ApplicationWindowProps extends WindowProps {
+    showMenubar?: boolean;
+    ref?: Ref<Gtk.ApplicationWindow>;
+}
+export interface AspectFrameProps extends WidgetProps {
+    obeyChild: boolean;
+    ratio: number;
+    xalign: number;
+    yalign: number;
+    ref?: Ref<Gtk.AspectFrame>;
+}
+export interface AssistantProps extends WindowProps {
+    pages?: unknown;
+    useHeaderBar?: number;
+    onApply?: () => void;
+    onCancel?: () => void;
+    onClose?: () => void;
+    onEscape?: () => void;
+    onPrepare?: (page: Gtk.Widget) => void;
+    ref?: Ref<Gtk.Assistant>;
+}
+export interface BoxProps extends WidgetProps {
+    baselineChild?: number;
+    baselinePosition?: Gtk.BaselinePosition;
+    homogeneous?: boolean;
+    spacing: number;
+    orientation: Gtk.Orientation;
+    ref?: Ref<Gtk.Box>;
+}
+export interface ButtonProps extends WidgetProps {
+    canShrink?: boolean;
+    hasFrame?: boolean;
+    iconName?: string;
+    label?: string;
+    useUnderline?: boolean;
+    actionName?: string;
+    actionTarget?: unknown;
+    onActivate?: () => void;
+    onClicked?: () => void;
+    ref?: Ref<Gtk.Button>;
+}
+export interface CalendarProps extends WidgetProps {
+    date?: unknown;
+    day?: number;
+    month?: number;
+    showDayNames?: boolean;
+    showHeading?: boolean;
+    showWeekNumbers?: boolean;
+    year?: number;
+    onDaySelected?: () => void;
+    onNextMonth?: () => void;
+    onNextYear?: () => void;
+    onPrevMonth?: () => void;
+    onPrevYear?: () => void;
+    ref?: Ref<Gtk.Calendar>;
+}
+export interface CellViewProps extends WidgetProps {
+    cellArea: Gtk.CellArea;
+    cellAreaContext: Gtk.CellAreaContext;
+    drawSensitive?: boolean;
+    fitModel?: boolean;
+    model?: Gtk.TreeModel;
+    orientation?: Gtk.Orientation;
+    ref?: Ref<Gtk.CellView>;
+}
+export interface CenterBoxProps extends WidgetProps {
+    baselinePosition?: Gtk.BaselinePosition;
+    shrinkCenterLast?: boolean;
+    orientation?: Gtk.Orientation;
+    ref?: Ref<Gtk.CenterBox>;
+}
+export interface CheckButtonProps extends WidgetProps {
+    active?: boolean;
+    inconsistent?: boolean;
+    label?: string;
+    useUnderline?: boolean;
+    actionName?: string;
+    actionTarget?: unknown;
+    onActivate?: () => void;
+    onToggled?: () => void;
+    ref?: Ref<Gtk.CheckButton>;
+}
+export interface ColorButtonProps extends WidgetProps {
+    modal?: boolean;
+    showEditor?: boolean;
+    title?: string;
+    rgba?: unknown;
+    useAlpha?: boolean;
+    onActivate?: () => void;
+    onColorSet?: () => void;
+    onColorActivated?: (color: Gdk.RGBA) => void;
+    ref?: Ref<Gtk.ColorButton>;
+}
+export interface ColorChooserDialogProps extends DialogProps {
+    showEditor?: boolean;
+    rgba?: unknown;
+    useAlpha?: boolean;
+    onColorActivated?: (color: Gdk.RGBA) => void;
+    ref?: Ref<Gtk.ColorChooserDialog>;
+}
+export interface ColorChooserWidgetProps extends WidgetProps {
+    showEditor?: boolean;
+    rgba?: unknown;
+    useAlpha?: boolean;
+    onColorActivated?: (color: Gdk.RGBA) => void;
+    ref?: Ref<Gtk.ColorChooserWidget>;
+}
+export interface ColorDialogButtonProps extends WidgetProps {
+    dialog?: Gtk.ColorDialog;
+    rgba?: unknown;
+    onActivate?: () => void;
+    ref?: Ref<Gtk.ColorDialogButton>;
+}
+export interface ColumnViewProps extends WidgetProps {
+    columns?: unknown;
+    enableRubberband?: boolean;
+    headerFactory?: Gtk.ListItemFactory;
+    model?: Gtk.SelectionModel;
+    reorderable?: boolean;
+    rowFactory?: Gtk.ListItemFactory;
+    showColumnSeparators?: boolean;
+    showRowSeparators?: boolean;
+    singleClickActivate?: boolean;
+    sorter?: Gtk.Sorter;
+    tabBehavior?: Gtk.ListTabBehavior;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    onActivate?: (position: number) => void;
+    renderItem?: (item: any) => Gtk.Widget;
+    ref?: Ref<Gtk.ColumnView>;
+}
+export interface ComboBoxProps extends WidgetProps {
+    active?: number;
+    activeId?: string;
+    buttonSensitivity?: Gtk.SensitivityType;
+    entryTextColumn?: number;
+    hasEntry?: boolean;
+    hasFrame?: boolean;
+    idColumn?: number;
+    model?: Gtk.TreeModel;
+    popupFixedWidth?: boolean;
+    popupShown?: boolean;
+    editingCanceled?: boolean;
+    onActivate?: () => void;
+    onChanged?: () => void;
+    onFormatEntryText?: (path: string) => string;
+    onMoveActive?: (scrollType: Gtk.ScrollType) => void;
+    onPopdown?: () => boolean;
+    onPopup?: () => void;
+    onEditingDone?: () => void;
+    onRemoveWidget?: () => void;
+    ref?: Ref<Gtk.ComboBox>;
+}
+export interface ComboBoxTextProps extends ComboBoxProps {
+    ref?: Ref<Gtk.ComboBoxText>;
+}
+export interface DialogProps extends WindowProps {
+    useHeaderBar?: number;
+    onClose?: () => void;
+    onResponse?: (responseId: number) => void;
+    ref?: Ref<Gtk.Dialog>;
+}
+export interface DragIconProps extends WidgetProps {
+    ref?: Ref<Gtk.DragIcon>;
+}
+export interface DrawingAreaProps extends WidgetProps {
+    contentHeight?: number;
+    contentWidth?: number;
+    onResize?: (width: number, height: number) => void;
+    ref?: Ref<Gtk.DrawingArea>;
+}
+export interface DropDownProps extends WidgetProps {
+    enableSearch?: boolean;
+    expression?: Gtk.Expression;
+    factory?: Gtk.ListItemFactory;
+    headerFactory?: Gtk.ListItemFactory;
+    listFactory?: Gtk.ListItemFactory;
+    model?: unknown;
+    searchMatchMode?: Gtk.StringFilterMatchMode;
+    selected?: number;
+    selectedItem?: unknown;
+    showArrow?: boolean;
+    onActivate?: () => void;
+    itemLabel?: (item: any) => string;
+    onSelectionChanged?: (item: any, index: number) => void;
+    ref?: Ref<Gtk.DropDown>;
+}
+export interface EditableLabelProps extends WidgetProps {
+    editing?: boolean;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.EditableLabel>;
+}
+export interface EmojiChooserProps extends PopoverProps {
+    onEmojiPicked?: (text: string) => void;
+    ref?: Ref<Gtk.EmojiChooser>;
+}
+export interface EntryProps extends WidgetProps {
+    activatesDefault?: boolean;
+    attributes?: unknown;
+    buffer?: Gtk.EntryBuffer;
+    completion?: Gtk.EntryCompletion;
+    enableEmojiCompletion?: boolean;
+    extraMenu?: unknown;
+    hasFrame?: boolean;
+    imModule?: string;
+    inputHints?: Gtk.InputHints;
+    inputPurpose?: Gtk.InputPurpose;
+    invisibleChar?: number;
+    invisibleCharSet?: boolean;
+    maxLength?: number;
+    menuEntryIconPrimaryText?: string;
+    menuEntryIconSecondaryText?: string;
+    overwriteMode?: boolean;
+    placeholderText?: string;
+    primaryIconActivatable?: boolean;
+    primaryIconGicon?: unknown;
+    primaryIconName?: string;
+    primaryIconPaintable?: unknown;
+    primaryIconSensitive?: boolean;
+    primaryIconStorageType?: Gtk.ImageType;
+    primaryIconTooltipMarkup?: string;
+    primaryIconTooltipText?: string;
+    progressFraction?: number;
+    progressPulseStep?: number;
+    scrollOffset?: number;
+    secondaryIconActivatable?: boolean;
+    secondaryIconGicon?: unknown;
+    secondaryIconName?: string;
+    secondaryIconPaintable?: unknown;
+    secondaryIconSensitive?: boolean;
+    secondaryIconStorageType?: Gtk.ImageType;
+    secondaryIconTooltipMarkup?: string;
+    secondaryIconTooltipText?: string;
+    showEmojiIcon?: boolean;
+    tabs?: unknown;
+    textLength?: number;
+    truncateMultiline?: boolean;
+    visibility?: boolean;
+    editingCanceled?: boolean;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    onActivate?: () => void;
+    onIconPress?: (iconPos: Gtk.EntryIconPosition) => void;
+    onIconRelease?: (iconPos: Gtk.EntryIconPosition) => void;
+    onEditingDone?: () => void;
+    onRemoveWidget?: () => void;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.Entry>;
+}
+export interface ExpanderProps extends WidgetProps {
+    expanded?: boolean;
+    label?: string;
+    resizeToplevel?: boolean;
+    useMarkup?: boolean;
+    useUnderline?: boolean;
+    onActivate?: () => void;
+    ref?: Ref<Gtk.Expander>;
+}
+export interface FileChooserDialogProps extends DialogProps {
+    action?: Gtk.FileChooserAction;
+    createFolders?: boolean;
+    filter?: Gtk.FileFilter;
+    filters?: unknown;
+    selectMultiple?: boolean;
+    shortcutFolders?: unknown;
+    ref?: Ref<Gtk.FileChooserDialog>;
+}
+export interface FileChooserWidgetProps extends WidgetProps {
+    searchMode?: boolean;
+    showTime?: boolean;
+    subtitle?: string;
+    action: Gtk.FileChooserAction;
+    createFolders?: boolean;
+    filter?: Gtk.FileFilter;
+    filters?: unknown;
+    selectMultiple?: boolean;
+    shortcutFolders?: unknown;
+    onDesktopFolder?: () => void;
+    onDownFolder?: () => void;
+    onHomeFolder?: () => void;
+    onLocationPopup?: (path: string) => void;
+    onLocationPopupOnPaste?: () => void;
+    onLocationTogglePopup?: () => void;
+    onPlacesShortcut?: () => void;
+    onQuickBookmark?: (bookmarkIndex: number) => void;
+    onRecentShortcut?: () => void;
+    onSearchShortcut?: () => void;
+    onShowHidden?: () => void;
+    onUpFolder?: () => void;
+    ref?: Ref<Gtk.FileChooserWidget>;
+}
+export interface FixedProps extends WidgetProps {
+    ref?: Ref<Gtk.Fixed>;
+}
+export interface FlowBoxProps extends WidgetProps {
+    acceptUnpairedRelease?: boolean;
+    activateOnSingleClick?: boolean;
+    columnSpacing?: number;
+    homogeneous?: boolean;
+    maxChildrenPerLine?: number;
+    minChildrenPerLine?: number;
+    rowSpacing?: number;
+    selectionMode?: Gtk.SelectionMode;
+    orientation?: Gtk.Orientation;
+    onActivateCursorChild?: () => void;
+    onChildActivated?: (child: Gtk.FlowBoxChild) => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extend: boolean, modify: boolean) => boolean;
+    onSelectAll?: () => void;
+    onSelectedChildrenChanged?: () => void;
+    onToggleCursorChild?: () => void;
+    onUnselectAll?: () => void;
+    ref?: Ref<Gtk.FlowBox>;
+}
+export interface FlowBoxChildProps extends WidgetProps {
+    onActivate?: () => void;
+    ref?: Ref<Gtk.FlowBoxChild>;
+}
+export interface FontButtonProps extends WidgetProps {
+    modal?: boolean;
+    title?: string;
+    useFont?: boolean;
+    useSize?: boolean;
+    font?: string;
+    fontDesc?: unknown;
+    fontFeatures?: string;
+    language?: string;
+    level?: Gtk.FontChooserLevel;
+    previewText?: string;
+    showPreviewEntry?: boolean;
+    onActivate?: () => void;
+    onFontSet?: () => void;
+    onFontActivated?: (fontname: string) => void;
+    ref?: Ref<Gtk.FontButton>;
+}
+export interface FontChooserDialogProps extends DialogProps {
+    font?: string;
+    fontDesc?: unknown;
+    fontFeatures?: string;
+    language?: string;
+    level?: Gtk.FontChooserLevel;
+    previewText?: string;
+    showPreviewEntry?: boolean;
+    onFontActivated?: (fontname: string) => void;
+    ref?: Ref<Gtk.FontChooserDialog>;
+}
+export interface FontChooserWidgetProps extends WidgetProps {
+    tweakAction?: unknown;
+    font?: string;
+    fontDesc?: unknown;
+    fontFeatures?: string;
+    language?: string;
+    level?: Gtk.FontChooserLevel;
+    previewText?: string;
+    showPreviewEntry?: boolean;
+    onFontActivated?: (fontname: string) => void;
+    ref?: Ref<Gtk.FontChooserWidget>;
+}
+export interface FontDialogButtonProps extends WidgetProps {
+    dialog?: Gtk.FontDialog;
+    fontDesc?: unknown;
+    fontFeatures?: string;
+    language?: unknown;
+    level?: Gtk.FontLevel;
+    useFont?: boolean;
+    useSize?: boolean;
+    onActivate?: () => void;
+    ref?: Ref<Gtk.FontDialogButton>;
+}
+export interface FrameProps extends WidgetProps {
+    label?: string;
+    labelXalign?: number;
+    ref?: Ref<Gtk.Frame>;
+}
+export interface GLAreaProps extends WidgetProps {
+    allowedApis?: unknown;
+    api?: unknown;
+    autoRender?: boolean;
+    context?: unknown;
+    hasDepthBuffer?: boolean;
+    hasStencilBuffer?: boolean;
+    useEs?: boolean;
+    onCreateContext?: () => unknown;
+    onRender?: (context: Gdk.GLContext) => boolean;
+    onResize?: (width: number, height: number) => void;
+    ref?: Ref<Gtk.GLArea>;
+}
+export interface GraphicsOffloadProps extends WidgetProps {
+    blackBackground?: boolean;
+    enabled?: Gtk.GraphicsOffloadEnabled;
+    ref?: Ref<Gtk.GraphicsOffload>;
+}
+export interface GridProps extends WidgetProps {
+    baselineRow?: number;
+    columnHomogeneous?: boolean;
+    columnSpacing?: number;
+    rowHomogeneous?: boolean;
+    rowSpacing?: number;
+    orientation?: Gtk.Orientation;
+    ref?: Ref<Gtk.Grid>;
+}
+export interface GridViewProps extends ListBaseProps {
+    enableRubberband?: boolean;
+    factory?: Gtk.ListItemFactory;
+    maxColumns?: number;
+    minColumns?: number;
+    model?: Gtk.SelectionModel;
+    singleClickActivate?: boolean;
+    tabBehavior?: Gtk.ListTabBehavior;
+    onActivate?: (position: number) => void;
+    renderItem?: (item: any) => Gtk.Widget;
+    ref?: Ref<Gtk.GridView>;
+}
+export interface HeaderBarProps extends WidgetProps {
+    decorationLayout?: string;
+    showTitleButtons?: boolean;
+    useNativeControls?: boolean;
+    ref?: Ref<Gtk.HeaderBar>;
+}
+export interface IconViewProps extends WidgetProps {
+    activateOnSingleClick?: boolean;
+    cellArea: Gtk.CellArea;
+    columnSpacing?: number;
+    columns?: number;
+    itemOrientation?: Gtk.Orientation;
+    itemPadding?: number;
+    itemWidth?: number;
+    margin?: number;
+    markupColumn?: number;
+    model?: Gtk.TreeModel;
+    pixbufColumn?: number;
+    reorderable?: boolean;
+    rowSpacing?: number;
+    selectionMode?: Gtk.SelectionMode;
+    spacing?: number;
+    textColumn?: number;
+    tooltipColumn?: number;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    onActivateCursorItem?: () => boolean;
+    onItemActivated?: (path: Gtk.TreePath) => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extend: boolean, modify: boolean) => boolean;
+    onSelectAll?: () => void;
+    onSelectCursorItem?: () => void;
+    onSelectionChanged?: () => void;
+    onToggleCursorItem?: () => void;
+    onUnselectAll?: () => void;
+    ref?: Ref<Gtk.IconView>;
+}
+export interface ImageProps extends WidgetProps {
+    file?: string;
+    gicon?: unknown;
+    iconName?: string;
+    iconSize?: Gtk.IconSize;
+    paintable?: unknown;
+    pixelSize?: number;
+    resource?: string;
+    storageType?: Gtk.ImageType;
+    useFallback?: boolean;
+    ref?: Ref<Gtk.Image>;
+}
+export interface InfoBarProps extends WidgetProps {
+    messageType?: Gtk.MessageType;
+    revealed?: boolean;
+    showCloseButton?: boolean;
+    onClose?: () => void;
+    onResponse?: (responseId: number) => void;
+    ref?: Ref<Gtk.InfoBar>;
+}
+export interface InscriptionProps extends WidgetProps {
+    attributes?: unknown;
+    markup?: string;
+    minChars?: number;
+    minLines?: number;
+    natChars?: number;
+    natLines?: number;
+    text?: string;
+    textOverflow?: Gtk.InscriptionOverflow;
+    wrapMode?: unknown;
+    xalign?: number;
+    yalign?: number;
+    ref?: Ref<Gtk.Inscription>;
+}
+export interface LabelProps extends WidgetProps {
+    attributes?: unknown;
+    ellipsize?: unknown;
+    extraMenu?: unknown;
+    justify?: Gtk.Justification;
+    label?: string;
+    lines?: number;
+    maxWidthChars?: number;
+    mnemonicKeyval?: number;
+    naturalWrapMode?: Gtk.NaturalWrapMode;
+    selectable?: boolean;
+    singleLineMode?: boolean;
+    tabs?: unknown;
+    useMarkup?: boolean;
+    useUnderline?: boolean;
+    widthChars?: number;
+    wrap?: boolean;
+    wrapMode?: unknown;
+    xalign?: number;
+    yalign?: number;
+    onActivateCurrentLink?: () => void;
+    onActivateLink?: (uri: string) => boolean;
+    onCopyClipboard?: () => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extendSelection: boolean) => void;
+    ref?: Ref<Gtk.Label>;
+}
+export interface LevelBarProps extends WidgetProps {
+    inverted?: boolean;
+    maxValue?: number;
+    minValue?: number;
+    mode?: Gtk.LevelBarMode;
+    value?: number;
+    orientation?: Gtk.Orientation;
+    onOffsetChanged?: (name: string) => void;
+    ref?: Ref<Gtk.LevelBar>;
+}
+export interface LinkButtonProps extends ButtonProps {
+    uri: string;
+    visited?: boolean;
+    onActivateLink?: () => boolean;
+    ref?: Ref<Gtk.LinkButton>;
+}
+export interface ListBaseProps extends WidgetProps {
+    orientation?: Gtk.Orientation;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    ref?: Ref<Gtk.ListBase>;
+}
+export interface ListBoxProps extends WidgetProps {
+    acceptUnpairedRelease?: boolean;
+    activateOnSingleClick?: boolean;
+    selectionMode?: Gtk.SelectionMode;
+    showSeparators?: boolean;
+    tabBehavior?: Gtk.ListTabBehavior;
+    onActivateCursorRow?: () => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extend: boolean, modify: boolean) => void;
+    onRowActivated?: (row: Gtk.ListBoxRow) => void;
+    onRowSelected?: (row: Gtk.ListBoxRow) => void;
+    onSelectAll?: () => void;
+    onSelectedRowsChanged?: () => void;
+    onToggleCursorRow?: () => void;
+    onUnselectAll?: () => void;
+    ref?: Ref<Gtk.ListBox>;
+}
+export interface ListBoxRowProps extends WidgetProps {
+    activatable?: boolean;
+    selectable?: boolean;
+    actionName?: string;
+    actionTarget?: unknown;
+    onActivate?: () => void;
+    ref?: Ref<Gtk.ListBoxRow>;
+}
+export interface ListViewProps extends ListBaseProps {
+    enableRubberband?: boolean;
+    factory?: Gtk.ListItemFactory;
+    headerFactory?: Gtk.ListItemFactory;
+    model?: Gtk.SelectionModel;
+    showSeparators?: boolean;
+    singleClickActivate?: boolean;
+    tabBehavior?: Gtk.ListTabBehavior;
+    onActivate?: (position: number) => void;
+    renderItem?: (item: any) => Gtk.Widget;
+    ref?: Ref<Gtk.ListView>;
+}
+export interface LockButtonProps extends ButtonProps {
+    permission?: unknown;
+    textLock?: string;
+    textUnlock?: string;
+    tooltipLock?: string;
+    tooltipNotAuthorized?: string;
+    tooltipUnlock?: string;
+    ref?: Ref<Gtk.LockButton>;
+}
+export interface MediaControlsProps extends WidgetProps {
+    mediaStream?: Gtk.MediaStream;
+    ref?: Ref<Gtk.MediaControls>;
+}
+export interface MenuButtonProps extends WidgetProps {
+    active?: boolean;
+    alwaysShowArrow?: boolean;
+    canShrink?: boolean;
+    direction?: Gtk.ArrowType;
+    hasFrame?: boolean;
+    iconName?: string;
+    label?: string;
+    menuModel?: unknown;
+    primary?: boolean;
+    useUnderline?: boolean;
+    onActivate?: () => void;
+    ref?: Ref<Gtk.MenuButton>;
+}
+export interface MessageDialogProps extends DialogProps {
+    buttons?: Gtk.ButtonsType;
+    messageArea?: Gtk.Widget;
+    messageType?: Gtk.MessageType;
+    secondaryText?: string;
+    secondaryUseMarkup?: boolean;
+    text?: string;
+    useMarkup?: boolean;
+    ref?: Ref<Gtk.MessageDialog>;
+}
+export interface NotebookProps extends WidgetProps {
+    enablePopup?: boolean;
+    groupName?: string;
+    page?: number;
+    pages?: unknown;
+    scrollable?: boolean;
+    showBorder?: boolean;
+    showTabs?: boolean;
+    tabPos?: Gtk.PositionType;
+    onChangeCurrentPage?: (page: number) => boolean;
+    onCreateWindow?: (page: Gtk.Widget) => Gtk.Notebook;
+    onFocusTab?: (tab: Gtk.NotebookTab) => boolean;
+    onMoveFocusOut?: (direction: Gtk.DirectionType) => void;
+    onPageAdded?: (child: Gtk.Widget, pageNum: number) => void;
+    onPageRemoved?: (child: Gtk.Widget, pageNum: number) => void;
+    onPageReordered?: (child: Gtk.Widget, pageNum: number) => void;
+    onReorderTab?: (direction: Gtk.DirectionType, moveToLast: boolean) => boolean;
+    onSelectPage?: (moveFocus: boolean) => boolean;
+    onSwitchPage?: (page: Gtk.Widget, pageNum: number) => void;
+    ref?: Ref<Gtk.Notebook>;
+}
+export interface OverlayProps extends WidgetProps {
+    onGetChildPosition?: (widget: Gtk.Widget, allocation: Gdk.Rectangle) => boolean;
+    ref?: Ref<Gtk.Overlay>;
+}
+export interface PageSetupUnixDialogProps extends DialogProps {
+    ref?: Ref<Gtk.PageSetupUnixDialog>;
+}
+export interface PanedProps extends WidgetProps {
+    maxPosition?: number;
+    minPosition?: number;
+    position?: number;
+    positionSet?: boolean;
+    resizeEndChild?: boolean;
+    resizeStartChild?: boolean;
+    shrinkEndChild?: boolean;
+    shrinkStartChild?: boolean;
+    wideHandle?: boolean;
+    orientation: Gtk.Orientation;
+    onAcceptPosition?: () => boolean;
+    onCancelPosition?: () => boolean;
+    onCycleChildFocus?: (reversed: boolean) => boolean;
+    onCycleHandleFocus?: (reversed: boolean) => boolean;
+    onMoveHandle?: (scrollType: Gtk.ScrollType) => boolean;
+    onToggleHandleFocus?: () => boolean;
+    ref?: Ref<Gtk.Paned>;
+}
+export interface PasswordEntryProps extends WidgetProps {
+    activatesDefault?: boolean;
+    extraMenu?: unknown;
+    placeholderText?: string;
+    showPeekIcon?: boolean;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    onActivate?: () => void;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.PasswordEntry>;
+}
+export interface PictureProps extends WidgetProps {
+    alternativeText?: string;
+    canShrink?: boolean;
+    contentFit?: Gtk.ContentFit;
+    file?: unknown;
+    keepAspectRatio?: boolean;
+    paintable?: unknown;
+    ref?: Ref<Gtk.Picture>;
+}
+export interface PopoverProps extends WidgetProps {
+    autohide?: boolean;
+    cascadePopdown?: boolean;
+    hasArrow?: boolean;
+    mnemonicsVisible?: boolean;
+    pointingTo?: unknown;
+    position?: Gtk.PositionType;
+    onActivateDefault?: () => void;
+    onClosed?: () => void;
+    ref?: Ref<Gtk.Popover>;
+}
+export interface PopoverMenuProps extends PopoverProps {
+    flags?: Gtk.PopoverMenuFlags;
+    menuModel?: unknown;
+    visibleSubmenu?: string;
+    ref?: Ref<Gtk.PopoverMenu>;
+}
+export interface PopoverMenuBarProps extends WidgetProps {
+    menuModel?: unknown;
+    ref?: Ref<Gtk.PopoverMenuBar>;
+}
+export interface PrintUnixDialogProps extends DialogProps {
+    currentPage?: number;
+    embedPageSetup?: boolean;
+    hasSelection?: boolean;
+    manualCapabilities?: Gtk.PrintCapabilities;
+    pageSetup?: Gtk.PageSetup;
+    printSettings?: Gtk.PrintSettings;
+    selectedPrinter?: Gtk.Printer;
+    supportSelection?: boolean;
+    ref?: Ref<Gtk.PrintUnixDialog>;
+}
+export interface ProgressBarProps extends WidgetProps {
+    ellipsize?: unknown;
+    fraction?: number;
+    inverted?: boolean;
+    pulseStep?: number;
+    showText?: boolean;
+    text?: string;
+    orientation?: Gtk.Orientation;
+    ref?: Ref<Gtk.ProgressBar>;
+}
+export interface RangeProps extends WidgetProps {
+    adjustment?: Gtk.Adjustment;
+    fillLevel?: number;
+    inverted?: boolean;
+    restrictToFillLevel?: boolean;
+    roundDigits?: number;
+    showFillLevel?: boolean;
+    orientation?: Gtk.Orientation;
+    onAdjustBounds?: (value: number) => void;
+    onChangeValue?: (scroll: Gtk.ScrollType, value: number) => boolean;
+    onMoveSlider?: (step: Gtk.ScrollType) => void;
+    onValueChanged?: () => void;
+    ref?: Ref<Gtk.Range>;
+}
+export interface RevealerProps extends WidgetProps {
+    childRevealed?: boolean;
+    revealChild?: boolean;
+    transitionDuration?: number;
+    transitionType?: Gtk.RevealerTransitionType;
+    ref?: Ref<Gtk.Revealer>;
+}
+export interface ScaleProps extends RangeProps {
+    digits?: number;
+    drawValue?: boolean;
+    hasOrigin?: boolean;
+    valuePos?: Gtk.PositionType;
+    orientation: Gtk.Orientation;
+    ref?: Ref<Gtk.Scale>;
+}
+export interface ScaleButtonProps extends WidgetProps {
+    active?: boolean;
+    adjustment?: Gtk.Adjustment;
+    hasFrame?: boolean;
+    icons?: string[];
+    value?: number;
+    orientation?: Gtk.Orientation;
+    onPopdown?: () => void;
+    onPopup?: () => void;
+    onValueChanged?: (value: number) => void;
+    ref?: Ref<Gtk.ScaleButton>;
+}
+export interface ScrollbarProps extends WidgetProps {
+    adjustment?: Gtk.Adjustment;
+    orientation: Gtk.Orientation;
+    ref?: Ref<Gtk.Scrollbar>;
+}
+export interface ScrolledWindowProps extends WidgetProps {
+    hadjustment?: Gtk.Adjustment;
+    hasFrame?: boolean;
+    hscrollbarPolicy?: Gtk.PolicyType;
+    kineticScrolling?: boolean;
+    maxContentHeight?: number;
+    maxContentWidth?: number;
+    minContentHeight?: number;
+    minContentWidth?: number;
+    overlayScrolling?: boolean;
+    propagateNaturalHeight?: boolean;
+    propagateNaturalWidth?: boolean;
+    vadjustment?: Gtk.Adjustment;
+    vscrollbarPolicy?: Gtk.PolicyType;
+    windowPlacement?: Gtk.CornerType;
+    onEdgeOvershot?: (pos: Gtk.PositionType) => void;
+    onEdgeReached?: (pos: Gtk.PositionType) => void;
+    onMoveFocusOut?: (directionType: Gtk.DirectionType) => void;
+    onScrollChild?: (scroll: Gtk.ScrollType, horizontal: boolean) => boolean;
+    ref?: Ref<Gtk.ScrolledWindow>;
+}
+export interface SearchBarProps extends WidgetProps {
+    searchModeEnabled?: boolean;
+    showCloseButton?: boolean;
+    ref?: Ref<Gtk.SearchBar>;
+}
+export interface SearchEntryProps extends WidgetProps {
+    activatesDefault?: boolean;
+    inputHints?: Gtk.InputHints;
+    inputPurpose?: Gtk.InputPurpose;
+    placeholderText?: string;
+    searchDelay?: number;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    onActivate?: () => void;
+    onNextMatch?: () => void;
+    onPreviousMatch?: () => void;
+    onSearchChanged?: () => void;
+    onSearchStarted?: () => void;
+    onStopSearch?: () => void;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.SearchEntry>;
+}
+export interface SeparatorProps extends WidgetProps {
+    orientation: Gtk.Orientation;
+    ref?: Ref<Gtk.Separator>;
+}
+export interface ShortcutLabelProps extends WidgetProps {
+    accelerator: string;
+    disabledText?: string;
+    ref?: Ref<Gtk.ShortcutLabel>;
+}
+export interface ShortcutsGroupProps extends BoxProps {
+    accelSizeGroup?: Gtk.SizeGroup;
+    height?: number;
+    title?: string;
+    titleSizeGroup?: Gtk.SizeGroup;
+    view?: string;
+    ref?: Ref<Gtk.ShortcutsGroup>;
+}
+export interface ShortcutsSectionProps extends BoxProps {
+    maxHeight?: number;
+    sectionName?: string;
+    title?: string;
+    viewName?: string;
+    onChangeCurrentPage?: (offset: number) => boolean;
+    ref?: Ref<Gtk.ShortcutsSection>;
+}
+export interface ShortcutsShortcutProps extends WidgetProps {
+    accelSizeGroup?: Gtk.SizeGroup;
+    accelerator?: string;
+    actionName?: string;
+    direction?: Gtk.TextDirection;
+    icon?: unknown;
+    iconSet?: boolean;
+    shortcutType?: Gtk.ShortcutType;
+    subtitle?: string;
+    subtitleSet?: boolean;
+    title?: string;
+    titleSizeGroup?: Gtk.SizeGroup;
+    ref?: Ref<Gtk.ShortcutsShortcut>;
+}
+export interface ShortcutsWindowProps extends WindowProps {
+    sectionName?: string;
+    viewName?: string;
+    onClose?: () => void;
+    onSearch?: () => void;
+    ref?: Ref<Gtk.ShortcutsWindow>;
+}
+export interface SpinButtonProps extends WidgetProps {
+    activatesDefault?: boolean;
+    adjustment?: Gtk.Adjustment;
+    climbRate: number;
+    digits: number;
+    numeric?: boolean;
+    snapToTicks?: boolean;
+    updatePolicy?: Gtk.SpinButtonUpdatePolicy;
+    value?: number;
+    wrap?: boolean;
+    editingCanceled?: boolean;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    orientation?: Gtk.Orientation;
+    onActivate?: () => void;
+    onChangeValue?: (scroll: Gtk.ScrollType) => void;
+    onInput?: (newValue: Ref<number>) => number;
+    onOutput?: () => boolean;
+    onValueChanged?: () => void;
+    onWrapped?: () => void;
+    onEditingDone?: () => void;
+    onRemoveWidget?: () => void;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.SpinButton>;
+}
+export interface SpinnerProps extends WidgetProps {
+    spinning?: boolean;
+    ref?: Ref<Gtk.Spinner>;
+}
+export interface StackProps extends WidgetProps {
+    hhomogeneous?: boolean;
+    interpolateSize?: boolean;
+    pages?: Gtk.SelectionModel;
+    transitionDuration?: number;
+    transitionRunning?: boolean;
+    transitionType?: Gtk.StackTransitionType;
+    vhomogeneous?: boolean;
+    visibleChildName?: string;
+    ref?: Ref<Gtk.Stack>;
+}
+export interface StackSidebarProps extends WidgetProps {
+    ref?: Ref<Gtk.StackSidebar>;
+}
+export interface StackSwitcherProps extends WidgetProps {
+    orientation?: Gtk.Orientation;
+    ref?: Ref<Gtk.StackSwitcher>;
+}
+export interface StatusbarProps extends WidgetProps {
+    onTextPopped?: (contextId: number, text: string) => void;
+    onTextPushed?: (contextId: number, text: string) => void;
+    ref?: Ref<Gtk.Statusbar>;
+}
+export interface SwitchProps extends WidgetProps {
+    active?: boolean;
+    state?: boolean;
+    actionName?: string;
+    actionTarget?: unknown;
+    onActivate?: () => void;
+    onStateSet?: (state: boolean) => boolean;
+    ref?: Ref<Gtk.Switch>;
+}
+export interface TextProps extends WidgetProps {
+    activatesDefault?: boolean;
+    attributes?: unknown;
+    buffer?: Gtk.EntryBuffer;
+    enableEmojiCompletion?: boolean;
+    extraMenu?: unknown;
+    imModule?: string;
+    inputHints?: Gtk.InputHints;
+    inputPurpose?: Gtk.InputPurpose;
+    invisibleChar?: number;
+    invisibleCharSet?: boolean;
+    maxLength?: number;
+    overwriteMode?: boolean;
+    placeholderText?: string;
+    propagateTextWidth?: boolean;
+    scrollOffset?: number;
+    tabs?: unknown;
+    truncateMultiline?: boolean;
+    visibility?: boolean;
+    cursorPosition?: number;
+    editable?: boolean;
+    enableUndo?: boolean;
+    maxWidthChars?: number;
+    selectionBound?: number;
+    text?: string;
+    widthChars?: number;
+    xalign?: number;
+    onActivate?: () => void;
+    onBackspace?: () => void;
+    onCopyClipboard?: () => void;
+    onCutClipboard?: () => void;
+    onDeleteFromCursor?: (type: Gtk.DeleteType, count: number) => void;
+    onInsertAtCursor?: (string: string) => void;
+    onInsertEmoji?: () => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extend: boolean) => void;
+    onPasteClipboard?: () => void;
+    onPreeditChanged?: (preedit: string) => void;
+    onToggleOverwrite?: () => void;
+    onChanged?: () => void;
+    onDeleteText?: (startPos: number, endPos: number) => void;
+    onInsertText?: (text: string, length: number, position: Ref<number>) => void;
+    ref?: Ref<Gtk.Text>;
+}
+export interface TextViewProps extends WidgetProps {
+    acceptsTab?: boolean;
+    bottomMargin?: number;
+    buffer?: Gtk.TextBuffer;
+    cursorVisible?: boolean;
+    editable?: boolean;
+    extraMenu?: unknown;
+    imModule?: string;
+    indent?: number;
+    inputHints?: Gtk.InputHints;
+    inputPurpose?: Gtk.InputPurpose;
+    justification?: Gtk.Justification;
+    leftMargin?: number;
+    monospace?: boolean;
+    overwrite?: boolean;
+    pixelsAboveLines?: number;
+    pixelsBelowLines?: number;
+    pixelsInsideWrap?: number;
+    rightMargin?: number;
+    tabs?: unknown;
+    topMargin?: number;
+    wrapMode?: Gtk.WrapMode;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    onBackspace?: () => void;
+    onCopyClipboard?: () => void;
+    onCutClipboard?: () => void;
+    onDeleteFromCursor?: (type: Gtk.DeleteType, count: number) => void;
+    onExtendSelection?: (granularity: Gtk.TextExtendSelection, location: Gtk.TextIter, start: Gtk.TextIter, end: Gtk.TextIter) => boolean;
+    onInsertAtCursor?: (string: string) => void;
+    onInsertEmoji?: () => void;
+    onMoveCursor?: (step: Gtk.MovementStep, count: number, extendSelection: boolean) => void;
+    onMoveViewport?: (step: Gtk.ScrollStep, count: number) => void;
+    onPasteClipboard?: () => void;
+    onPreeditChanged?: (preedit: string) => void;
+    onSelectAll?: (select: boolean) => void;
+    onSetAnchor?: () => void;
+    onToggleCursorVisible?: () => void;
+    onToggleOverwrite?: () => void;
+    ref?: Ref<Gtk.TextView>;
+}
+export interface ToggleButtonProps extends ButtonProps {
+    active?: boolean;
+    onToggled?: () => void;
+    ref?: Ref<Gtk.ToggleButton>;
+}
+export interface TreeExpanderProps extends WidgetProps {
+    hideExpander?: boolean;
+    indentForDepth?: boolean;
+    indentForIcon?: boolean;
+    item?: unknown;
+    listRow?: Gtk.TreeListRow;
+    ref?: Ref<Gtk.TreeExpander>;
+}
+export interface TreeViewProps extends WidgetProps {
+    activateOnSingleClick?: boolean;
+    enableGridLines?: Gtk.TreeViewGridLines;
+    enableSearch?: boolean;
+    enableTreeLines?: boolean;
+    expanderColumn?: Gtk.TreeViewColumn;
+    fixedHeightMode?: boolean;
+    headersClickable?: boolean;
+    headersVisible?: boolean;
+    hoverExpand?: boolean;
+    hoverSelection?: boolean;
+    levelIndentation?: number;
+    model?: Gtk.TreeModel;
+    reorderable?: boolean;
+    rubberBanding?: boolean;
+    searchColumn?: number;
+    showExpanders?: boolean;
+    tooltipColumn?: number;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    onColumnsChanged?: () => void;
+    onCursorChanged?: () => void;
+    onExpandCollapseCursorRow?: (object: boolean, p0: boolean, p1: boolean) => boolean;
+    onMoveCursor?: (step: Gtk.MovementStep, direction: number, extend: boolean, modify: boolean) => boolean;
+    onRowActivated?: (path: Gtk.TreePath, column: Gtk.TreeViewColumn) => void;
+    onRowCollapsed?: (iter: Gtk.TreeIter, path: Gtk.TreePath) => void;
+    onRowExpanded?: (iter: Gtk.TreeIter, path: Gtk.TreePath) => void;
+    onSelectAll?: () => boolean;
+    onSelectCursorParent?: () => boolean;
+    onSelectCursorRow?: (object: boolean) => boolean;
+    onStartInteractiveSearch?: () => boolean;
+    onTestCollapseRow?: (iter: Gtk.TreeIter, path: Gtk.TreePath) => boolean;
+    onTestExpandRow?: (iter: Gtk.TreeIter, path: Gtk.TreePath) => boolean;
+    onToggleCursorRow?: () => boolean;
+    onUnselectAll?: () => boolean;
+    ref?: Ref<Gtk.TreeView>;
+}
+export interface VideoProps extends WidgetProps {
+    autoplay?: boolean;
+    file?: unknown;
+    graphicsOffload?: Gtk.GraphicsOffloadEnabled;
+    loop?: boolean;
+    mediaStream?: Gtk.MediaStream;
+    ref?: Ref<Gtk.Video>;
+}
+export interface ViewportProps extends WidgetProps {
+    scrollToFocus?: boolean;
+    hadjustment?: Gtk.Adjustment;
+    hscrollPolicy?: Gtk.ScrollablePolicy;
+    vadjustment?: Gtk.Adjustment;
+    vscrollPolicy?: Gtk.ScrollablePolicy;
+    ref?: Ref<Gtk.Viewport>;
+}
+export interface VolumeButtonProps extends ScaleButtonProps {
+    useSymbolic?: boolean;
+    ref?: Ref<Gtk.VolumeButton>;
+}
+export interface WindowControlsProps extends WidgetProps {
+    decorationLayout?: string;
+    empty?: boolean;
+    side: Gtk.PackType;
+    useNativeControls?: boolean;
+    ref?: Ref<Gtk.WindowControls>;
+}
+export interface WindowHandleProps extends WidgetProps {
+    ref?: Ref<Gtk.WindowHandle>;
+}
+export declare const CONSTRUCTOR_PARAMS: Record<string, {
+    name: string;
+    hasDefault: boolean;
+}[]>;
+export declare const Widget: "Widget";
+export declare const Window: {
+    Root: "Window.Root";
+    Child: "Window.Child";
+    DefaultWidget: "Window.DefaultWidget";
+    FocusWidget: "Window.FocusWidget";
+    Titlebar: "Window.Titlebar";
+    TransientFor: "Window.TransientFor";
+};
+export declare const AboutDialog: "AboutDialog";
+export declare const ActionBar: "ActionBar";
+export declare const AppChooserButton: "AppChooserButton";
+export declare const AppChooserDialog: "AppChooserDialog";
+export declare const AppChooserWidget: "AppChooserWidget";
+export declare const ApplicationWindow: "ApplicationWindow";
+export declare const AspectFrame: "AspectFrame";
+export declare const Assistant: "Assistant";
+export declare const Box: "Box";
+export declare const Button: "Button";
+export declare const Calendar: "Calendar";
+export declare const CellView: "CellView";
+export declare const CenterBox: {
+    Root: "CenterBox.Root";
+    CenterWidget: "CenterBox.CenterWidget";
+    EndWidget: "CenterBox.EndWidget";
+    StartWidget: "CenterBox.StartWidget";
+};
+export declare const CheckButton: {
+    Root: "CheckButton.Root";
+    Child: "CheckButton.Child";
+    Group: "CheckButton.Group";
+};
+export declare const ColorButton: "ColorButton";
+export declare const ColorChooserDialog: "ColorChooserDialog";
+export declare const ColorChooserWidget: "ColorChooserWidget";
+export declare const ColorDialogButton: "ColorDialogButton";
+export declare const ColumnView: {
+    Root: "ColumnView.Root";
+    Item: "ColumnView.Item";
+};
+export declare const ComboBox: "ComboBox";
+export declare const ComboBoxText: "ComboBoxText";
+export declare const Dialog: "Dialog";
+export declare const DragIcon: "DragIcon";
+export declare const DrawingArea: "DrawingArea";
+export declare const DropDown: {
+    Root: "DropDown.Root";
+    Item: "DropDown.Item";
+};
+export declare const EditableLabel: "EditableLabel";
+export declare const EmojiChooser: "EmojiChooser";
+export declare const Entry: "Entry";
+export declare const Expander: {
+    Root: "Expander.Root";
+    Child: "Expander.Child";
+    LabelWidget: "Expander.LabelWidget";
+};
+export declare const FileChooserDialog: "FileChooserDialog";
+export declare const FileChooserWidget: "FileChooserWidget";
+export declare const Fixed: "Fixed";
+export declare const FlowBox: "FlowBox";
+export declare const FlowBoxChild: "FlowBoxChild";
+export declare const FontButton: "FontButton";
+export declare const FontChooserDialog: "FontChooserDialog";
+export declare const FontChooserWidget: "FontChooserWidget";
+export declare const FontDialogButton: "FontDialogButton";
+export declare const Frame: {
+    Root: "Frame.Root";
+    Child: "Frame.Child";
+    LabelWidget: "Frame.LabelWidget";
+};
+export declare const GLArea: "GLArea";
+export declare const GraphicsOffload: "GraphicsOffload";
+export declare const Grid: {
+    Root: "Grid.Root";
+    Child: "Grid.Child";
+};
+export declare const GridView: {
+    Root: "GridView.Root";
+    Item: "GridView.Item";
+};
+export declare const HeaderBar: {
+    Root: "HeaderBar.Root";
+    TitleWidget: "HeaderBar.TitleWidget";
+};
+export declare const IconView: "IconView";
+export declare const Image: "Image";
+export declare const InfoBar: "InfoBar";
+export declare const Inscription: "Inscription";
+export declare const Label: {
+    Root: "Label.Root";
+    MnemonicWidget: "Label.MnemonicWidget";
+};
+export declare const LevelBar: "LevelBar";
+export declare const LinkButton: "LinkButton";
+export declare const ListBase: "ListBase";
+export declare const ListBox: "ListBox";
+export declare const ListBoxRow: "ListBoxRow";
+export declare const ListView: {
+    Root: "ListView.Root";
+    Item: "ListView.Item";
+};
+export declare const LockButton: "LockButton";
+export declare const MediaControls: "MediaControls";
+export declare const MenuButton: {
+    Root: "MenuButton.Root";
+    Child: "MenuButton.Child";
+    Popover: "MenuButton.Popover";
+};
+export declare const MessageDialog: "MessageDialog";
+export declare const Notebook: "Notebook";
+export declare const Overlay: "Overlay";
+export declare const PageSetupUnixDialog: "PageSetupUnixDialog";
+export declare const Paned: {
+    Root: "Paned.Root";
+    EndChild: "Paned.EndChild";
+    StartChild: "Paned.StartChild";
+};
+export declare const PasswordEntry: "PasswordEntry";
+export declare const Picture: "Picture";
+export declare const Popover: {
+    Root: "Popover.Root";
+    Child: "Popover.Child";
+    DefaultWidget: "Popover.DefaultWidget";
+};
+export declare const PopoverMenu: "PopoverMenu";
+export declare const PopoverMenuBar: "PopoverMenuBar";
+export declare const PrintUnixDialog: "PrintUnixDialog";
+export declare const ProgressBar: "ProgressBar";
+export declare const Range: "Range";
+export declare const Revealer: "Revealer";
+export declare const Scale: "Scale";
+export declare const ScaleButton: "ScaleButton";
+export declare const Scrollbar: "Scrollbar";
+export declare const ScrolledWindow: "ScrolledWindow";
+export declare const SearchBar: {
+    Root: "SearchBar.Root";
+    Child: "SearchBar.Child";
+    KeyCaptureWidget: "SearchBar.KeyCaptureWidget";
+};
+export declare const SearchEntry: "SearchEntry";
+export declare const Separator: "Separator";
+export declare const ShortcutLabel: "ShortcutLabel";
+export declare const ShortcutsGroup: "ShortcutsGroup";
+export declare const ShortcutsSection: "ShortcutsSection";
+export declare const ShortcutsShortcut: "ShortcutsShortcut";
+export declare const ShortcutsWindow: "ShortcutsWindow";
+export declare const SpinButton: "SpinButton";
+export declare const Spinner: "Spinner";
+export declare const Stack: {
+    Root: "Stack.Root";
+    VisibleChild: "Stack.VisibleChild";
+};
+export declare const StackSidebar: {
+    Root: "StackSidebar.Root";
+    Stack: "StackSidebar.Stack";
+};
+export declare const StackSwitcher: {
+    Root: "StackSwitcher.Root";
+    Stack: "StackSwitcher.Stack";
+};
+export declare const Statusbar: "Statusbar";
+export declare const Switch: "Switch";
+export declare const Text: "Text";
+export declare const TextView: "TextView";
+export declare const ToggleButton: {
+    Root: "ToggleButton.Root";
+    Group: "ToggleButton.Group";
+};
+export declare const TreeExpander: "TreeExpander";
+export declare const TreeView: "TreeView";
+export declare const Video: "Video";
+export declare const Viewport: "Viewport";
+export declare const VolumeButton: "VolumeButton";
+export declare const WindowControls: "WindowControls";
+export declare const WindowHandle: "WindowHandle";
+declare module "react" {
+    namespace JSX {
+        interface IntrinsicElements {
+            "Window.Root": WindowProps;
+            "Window.Child": SlotProps;
+            "Window.DefaultWidget": SlotProps;
+            "Window.FocusWidget": SlotProps;
+            "Window.Titlebar": SlotProps;
+            "Window.TransientFor": SlotProps;
+            AboutDialog: AboutDialogProps;
+            ActionBar: ActionBarProps;
+            AppChooserButton: AppChooserButtonProps;
+            AppChooserDialog: AppChooserDialogProps;
+            AppChooserWidget: AppChooserWidgetProps;
+            ApplicationWindow: ApplicationWindowProps;
+            AspectFrame: AspectFrameProps;
+            "AspectFrame.Child": SlotProps;
+            Assistant: AssistantProps;
+            Box: BoxProps;
+            Button: ButtonProps;
+            "Button.Child": SlotProps;
+            Calendar: CalendarProps;
+            CellView: CellViewProps;
+            "CenterBox.Root": CenterBoxProps;
+            "CenterBox.CenterWidget": SlotProps;
+            "CenterBox.EndWidget": SlotProps;
+            "CenterBox.StartWidget": SlotProps;
+            "CheckButton.Root": CheckButtonProps;
+            "CheckButton.Child": SlotProps;
+            "CheckButton.Group": SlotProps;
+            ColorButton: ColorButtonProps;
+            ColorChooserDialog: ColorChooserDialogProps;
+            ColorChooserWidget: ColorChooserWidgetProps;
+            ColorDialogButton: ColorDialogButtonProps;
+            "ColumnView.Root": ColumnViewProps;
+            "ColumnView.Item": ItemProps<any>;
+            ComboBox: ComboBoxProps;
+            "ComboBox.Child": SlotProps;
+            ComboBoxText: ComboBoxTextProps;
+            Dialog: DialogProps;
+            DragIcon: DragIconProps;
+            "DragIcon.Child": SlotProps;
+            DrawingArea: DrawingAreaProps;
+            "DropDown.Root": DropDownProps;
+            "DropDown.Item": ItemProps<any>;
+            EditableLabel: EditableLabelProps;
+            EmojiChooser: EmojiChooserProps;
+            Entry: EntryProps;
+            "Expander.Root": ExpanderProps;
+            "Expander.Child": SlotProps;
+            "Expander.LabelWidget": SlotProps;
+            FileChooserDialog: FileChooserDialogProps;
+            FileChooserWidget: FileChooserWidgetProps;
+            Fixed: FixedProps;
+            FlowBox: FlowBoxProps;
+            FlowBoxChild: FlowBoxChildProps;
+            "FlowBoxChild.Child": SlotProps;
+            FontButton: FontButtonProps;
+            FontChooserDialog: FontChooserDialogProps;
+            FontChooserWidget: FontChooserWidgetProps;
+            FontDialogButton: FontDialogButtonProps;
+            "Frame.Root": FrameProps;
+            "Frame.Child": SlotProps;
+            "Frame.LabelWidget": SlotProps;
+            GLArea: GLAreaProps;
+            GraphicsOffload: GraphicsOffloadProps;
+            "GraphicsOffload.Child": SlotProps;
+            "Grid.Root": GridProps;
+            "Grid.Child": GridChildProps;
+            "GridView.Root": GridViewProps;
+            "GridView.Item": ItemProps<any>;
+            "HeaderBar.Root": HeaderBarProps;
+            "HeaderBar.TitleWidget": SlotProps;
+            IconView: IconViewProps;
+            Image: ImageProps;
+            InfoBar: InfoBarProps;
+            Inscription: InscriptionProps;
+            "Label.Root": LabelProps;
+            "Label.MnemonicWidget": SlotProps;
+            LevelBar: LevelBarProps;
+            LinkButton: LinkButtonProps;
+            ListBase: ListBaseProps;
+            ListBox: ListBoxProps;
+            ListBoxRow: ListBoxRowProps;
+            "ListBoxRow.Child": SlotProps;
+            "ListView.Root": ListViewProps;
+            "ListView.Item": ItemProps<any>;
+            LockButton: LockButtonProps;
+            MediaControls: MediaControlsProps;
+            "MenuButton.Root": MenuButtonProps;
+            "MenuButton.Child": SlotProps;
+            "MenuButton.Popover": SlotProps;
+            MessageDialog: MessageDialogProps;
+            Notebook: NotebookProps;
+            Overlay: OverlayProps;
+            "Overlay.Child": SlotProps;
+            PageSetupUnixDialog: PageSetupUnixDialogProps;
+            "Paned.Root": PanedProps;
+            "Paned.EndChild": SlotProps;
+            "Paned.StartChild": SlotProps;
+            PasswordEntry: PasswordEntryProps;
+            Picture: PictureProps;
+            "Popover.Root": PopoverProps;
+            "Popover.Child": SlotProps;
+            "Popover.DefaultWidget": SlotProps;
+            PopoverMenu: PopoverMenuProps;
+            PopoverMenuBar: PopoverMenuBarProps;
+            PrintUnixDialog: PrintUnixDialogProps;
+            ProgressBar: ProgressBarProps;
+            Range: RangeProps;
+            Revealer: RevealerProps;
+            "Revealer.Child": SlotProps;
+            Scale: ScaleProps;
+            ScaleButton: ScaleButtonProps;
+            Scrollbar: ScrollbarProps;
+            ScrolledWindow: ScrolledWindowProps;
+            "ScrolledWindow.Child": SlotProps;
+            "SearchBar.Root": SearchBarProps;
+            "SearchBar.Child": SlotProps;
+            "SearchBar.KeyCaptureWidget": SlotProps;
+            SearchEntry: SearchEntryProps;
+            Separator: SeparatorProps;
+            ShortcutLabel: ShortcutLabelProps;
+            ShortcutsGroup: ShortcutsGroupProps;
+            ShortcutsSection: ShortcutsSectionProps;
+            ShortcutsShortcut: ShortcutsShortcutProps;
+            ShortcutsWindow: ShortcutsWindowProps;
+            SpinButton: SpinButtonProps;
+            Spinner: SpinnerProps;
+            "Stack.Root": StackProps;
+            "Stack.VisibleChild": SlotProps;
+            "StackSidebar.Root": StackSidebarProps;
+            "StackSidebar.Stack": SlotProps;
+            "StackSwitcher.Root": StackSwitcherProps;
+            "StackSwitcher.Stack": SlotProps;
+            Statusbar: StatusbarProps;
+            Switch: SwitchProps;
+            Text: TextProps;
+            TextView: TextViewProps;
+            "ToggleButton.Root": ToggleButtonProps;
+            "ToggleButton.Group": SlotProps;
+            TreeExpander: TreeExpanderProps;
+            "TreeExpander.Child": SlotProps;
+            TreeView: TreeViewProps;
+            Video: VideoProps;
+            Viewport: ViewportProps;
+            "Viewport.Child": SlotProps;
+            VolumeButton: VolumeButtonProps;
+            WindowControls: WindowControlsProps;
+            WindowHandle: WindowHandleProps;
+            "WindowHandle.Child": SlotProps;
+        }
+    }
+}
+export {};