@gtkx/ffi 0.6.0 → 0.7.0

package/dist/cairo/cairo.d.ts

@@ -2,6 +2,7 @@
  * Cairo drawing function bindings via libcairo.
  * These wrap Cairo calls for use in GtkDrawingArea draw callbacks.
  */
+import type { LineCap, LineJoin, Operator } from "../generated/cairo/enums.js";
 /**
  * Begin a new sub-path. After this call the current point will be (x, y).
  */
@@ -81,14 +82,12 @@ export declare function setSourceRgba(cr: unknown, red: number, green: number, b
 export declare function setLineWidth(cr: unknown, width: number): void;
 /**
  * Sets the current line cap style.
- * @param lineCap - 0 = BUTT, 1 = ROUND, 2 = SQUARE
  */
-export declare function setLineCap(cr: unknown, lineCap: number): void;
+export declare function setLineCap(cr: unknown, lineCap: LineCap): void;
 /**
  * Sets the current line join style.
- * @param lineJoin - 0 = MITER, 1 = ROUND, 2 = BEVEL
  */
-export declare function setLineJoin(cr: unknown, lineJoin: number): void;
+export declare function setLineJoin(cr: unknown, lineJoin: LineJoin): void;
 /**
  * Sets the dash pattern to be used by stroke.
  */
@@ -128,6 +127,5 @@ export declare function clipPreserve(cr: unknown): void;
 export declare function resetClip(cr: unknown): void;
 /**
  * Sets the compositing operator.
- * @param op - Operator constant (e.g., CAIRO_OPERATOR_OVER = 2)
  */
-export declare function setOperator(cr: unknown, op: number): void;
+export declare function setOperator(cr: unknown, op: Operator): void;

package/dist/cairo/cairo.js

@@ -173,7 +173,6 @@ export function setLineWidth(cr, width) {
 }
 /**
  * Sets the current line cap style.
- * @param lineCap - 0 = BUTT, 1 = ROUND, 2 = SQUARE
  */
 export function setLineCap(cr, lineCap) {
     call(LIB, "cairo_set_line_cap", [
@@ -183,7 +182,6 @@ export function setLineCap(cr, lineCap) {
 }
 /**
  * Sets the current line join style.
- * @param lineJoin - 0 = MITER, 1 = ROUND, 2 = BEVEL
  */
 export function setLineJoin(cr, lineJoin) {
     call(LIB, "cairo_set_line_join", [
@@ -264,7 +262,6 @@ export function resetClip(cr) {
 }
 /**
  * Sets the compositing operator.
- * @param op - Operator constant (e.g., CAIRO_OPERATOR_OVER = 2)
  */
 export function setOperator(cr, op) {
     call(LIB, "cairo_set_operator", [

package/dist/codegen/ffi-generator.d.ts

@@ -2,7 +2,7 @@ import type { GirNamespace, TypeRegistry } from "@gtkx/gir";
 /**
  * Configuration options for the FFI code generator.
  */
-interface GeneratorOptions {
+type GeneratorOptions = {
     /** Output directory for generated files. */
     outputDir: string;
     /** The namespace being generated (e.g., "Gtk"). */
@@ -13,7 +13,7 @@ interface GeneratorOptions {
     typeRegistry?: TypeRegistry;
     /** All parsed namespaces for cross-namespace parent method lookup. */
     allNamespaces?: Map<string, GirNamespace>;
-}
+};
 /**
  * Generates TypeScript FFI bindings from GIR namespace definitions.
  * Creates classes, methods, properties, and signal handlers that call
@@ -32,6 +32,8 @@ export declare class CodeGenerator {
     private usesAlloc;
     private usesNativeError;
     private usesGetObject;
+    private usesGetBoxed;
+    private usesGetInterface;
     private usesRegisterType;
     private usesSignalMeta;
     private usedEnums;
@@ -108,6 +110,7 @@ export declare class CodeGenerator {
     private generateFunctions;
     private generateFunction;
     private generateEnums;
+    private generateConstants;
     private generateIndex;
     private generateParameterList;
     private generateCallArguments;
@@ -120,8 +123,11 @@ export declare class CodeGenerator {
     private formatCode;
     private generateCyclicTypeReturn;
     /**
-     * Adds a catch-all signal handler overload.
-     * Uses `any` for TypeScript compatibility with typed overloads.
+     * Adds a catch-all signal handler overload for unknown signal types.
+     *
+     * Uses `any` because TypeScript overload resolution requires the catch-all
+     * signature to be compatible with all typed overloads. Using `unknown` would
+     * prevent passing typed handlers to this overload.
      */
     private addSignalCatchAllOverload;
 }

package/dist/codegen/ffi-generator.js

@@ -205,6 +205,8 @@ export class CodeGenerator {
     usesAlloc = false;
     usesNativeError = false;
     usesGetObject = false;
+    usesGetBoxed = false;
+    usesGetInterface = false;
     usesRegisterType = false;
     usesSignalMeta = false;
     usedEnums = new Set();
@@ -262,6 +264,9 @@ export class CodeGenerator {
         if (standaloneFunctions.length > 0) {
             files.set("functions.ts", await this.generateFunctions(standaloneFunctions, namespace.sharedLibrary));
         }
+        if (namespace.constants.length > 0) {
+            files.set("constants.ts", await this.generateConstants(namespace.constants));
+        }
         files.set("index.ts", await this.generateIndex(files.keys()));
         return files;
     }
@@ -329,6 +334,8 @@ export class CodeGenerator {
         this.usesAlloc = false;
         this.usesNativeError = false;
         this.usesGetObject = false;
+        this.usesGetBoxed = false;
+        this.usesGetInterface = false;
         this.usesRegisterType = false;
         this.usesSignalMeta = false;
         this.usedEnums.clear();
@@ -373,7 +380,17 @@ export class CodeGenerator {
         const seenInterfaceMethodNames = new Set();
         const interfaceMethods = [];
         for (const ifaceName of cls.implements) {
-            const iface = interfaceMap.get(ifaceName);
+            let iface;
+            if (ifaceName.includes(".")) {
+                const [ns, ifaceClassName] = ifaceName.split(".", 2);
+                const ifaceNs = this.options.allNamespaces?.get(ns ?? "");
+                if (ifaceNs && ifaceClassName) {
+                    iface = ifaceNs.interfaces.find((i) => i.name === ifaceClassName);
+                }
+            }
+            else {
+                iface = interfaceMap.get(ifaceName);
+            }
             if (!iface)
                 continue;
             for (const method of iface.methods) {
@@ -724,19 +741,28 @@ ${args ? `${args},` : ""}
         const args = this.generateCallArguments(ctor.parameters);
         const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
         const borrowed = ctor.returnType.transferOwnership !== "full";
+        const errorArg = ctor.throws ? this.generateErrorArgument() : "";
+        const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
         this.usesGetObject = true;
-        return `${ctorDoc}  static ${methodName}(${params}): ${className} {
-    const ptr = call(
+        const lines = [];
+        lines.push(`${ctorDoc}  static ${methodName}(${params}): ${className} {`);
+        if (ctor.throws) {
+            lines.push(`    const error = { value: null as unknown };`);
+        }
+        lines.push(`    const ptr = call(
       "${sharedLibrary}",
       "${ctor.cIdentifier}",
       [
-${args}
+${allArgs}
       ],
       { type: "gobject", borrowed: ${borrowed} }
-    );
-    return getObject(ptr) as ${className};
-  }
-`;
+    );`);
+        if (ctor.throws) {
+            lines.push(this.generateErrorCheck());
+        }
+        lines.push(`    return getObject(ptr) as ${className};`);
+        lines.push(`  }`);
+        return `${lines.join("\n")}\n`;
     }
     generateStaticFunctions(functions, sharedLibrary, className) {
         const sections = [];
@@ -934,8 +960,11 @@ ${allArgs ? `${allArgs},` : ""}
     buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary, isNullable = false) {
         const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
         const hasMainReturn = returnTypeMapping.ts !== "void";
-        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
-            returnTypeMapping.ts !== "unknown";
+        const isInterface = returnTypeMapping.kind === "interface";
+        const needsGObjectWrap = returnTypeMapping.ffi.type === "gobject" && returnTypeMapping.ts !== "unknown" && !isInterface;
+        const needsBoxedWrap = returnTypeMapping.ffi.type === "boxed" && returnTypeMapping.ts !== "unknown" && !isInterface;
+        const needsInterfaceWrap = returnTypeMapping.ffi.type === "gobject" && returnTypeMapping.ts !== "unknown" && isInterface;
+        const needsObjectWrap = needsGObjectWrap || needsBoxedWrap || needsInterfaceWrap;
         const lines = [];
         for (const param of outputParams) {
             const paramName = toValidIdentifier(toCamelCase(param.name));
@@ -995,7 +1024,22 @@ ${allArgs ? `${allArgs},` : ""}
         }
         if (outputParams.length === 0) {
             if (hasMainReturn) {
-                if (needsObjectWrap) {
+                if (needsBoxedWrap) {
+                    this.usesGetBoxed = true;
+                    const boxedTypeName = finishReturnType.ffi.innerType;
+                    if (isNullable) {
+                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
+                    }
+                    lines.push(`          resolve(getBoxed(ptr, "${boxedTypeName}") as ${finishReturnType.ts});`);
+                }
+                else if (needsInterfaceWrap) {
+                    this.usesGetInterface = true;
+                    if (isNullable) {
+                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
+                    }
+                    lines.push(`          resolve(getInterface(ptr, ${finishReturnType.ts})!);`);
+                }
+                else if (needsGObjectWrap) {
                     this.usesGetObject = true;
                     if (isNullable) {
                         lines.push(`          if (ptr === null) { resolve(null); return; }`);
@@ -1013,7 +1057,26 @@ ${allArgs ? `${allArgs},` : ""}
         else {
             const resolveFields = [];
             if (hasMainReturn) {
-                if (needsObjectWrap) {
+                if (needsBoxedWrap) {
+                    this.usesGetBoxed = true;
+                    const boxedTypeName = finishReturnType.ffi.innerType;
+                    if (isNullable) {
+                        lines.push(`          const result = (ptr === null ? null : getBoxed(ptr, "${boxedTypeName}")) as ${finishReturnType.ts} | null;`);
+                    }
+                    else {
+                        lines.push(`          const result = getBoxed(ptr, "${boxedTypeName}") as ${finishReturnType.ts};`);
+                    }
+                }
+                else if (needsInterfaceWrap) {
+                    this.usesGetInterface = true;
+                    if (isNullable) {
+                        lines.push(`          const result = ptr === null ? null : getInterface(ptr, ${finishReturnType.ts});`);
+                    }
+                    else {
+                        lines.push(`          const result = getInterface(ptr, ${finishReturnType.ts})!;`);
+                    }
+                }
+                else if (needsGObjectWrap) {
                     this.usesGetObject = true;
                     if (isNullable) {
                         lines.push(`          const result = (ptr === null ? null : getObject(ptr)) as ${finishReturnType.ts} | null;`);
@@ -1090,9 +1153,16 @@ ${allArgs ? `${allArgs},` : ""}
         const returnTypeAnnotation = tsReturnType !== "void" ? `: ${tsReturnType}` : "";
         const hasResultParam = method.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+        const needsGObjectWrap = returnTypeMapping.ffi.type === "gobject" &&
+            baseReturnType !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
+        const needsBoxedWrap = returnTypeMapping.ffi.type === "boxed" &&
             baseReturnType !== "unknown" &&
             returnTypeMapping.kind !== "interface";
+        const needsInterfaceWrap = returnTypeMapping.ffi.type === "gobject" &&
+            baseReturnType !== "unknown" &&
+            returnTypeMapping.kind === "interface";
+        const needsObjectWrap = needsGObjectWrap || needsBoxedWrap || needsInterfaceWrap;
         const needsArrayWrap = returnTypeMapping.ffi.type === "array" &&
             returnTypeMapping.ffi.itemType?.type === "gobject" &&
             baseReturnType.endsWith("[]");
@@ -1137,6 +1207,15 @@ ${allArgs ? `${allArgs},` : ""}
             if (isCyclic) {
                 lines.push(this.generateCyclicTypeReturn(baseReturnType));
             }
+            else if (needsBoxedWrap) {
+                this.usesGetBoxed = true;
+                const boxedTypeName = returnTypeMapping.ffi.innerType;
+                lines.push(`    return getBoxed(ptr, "${boxedTypeName}") as ${baseReturnType};`);
+            }
+            else if (needsInterfaceWrap) {
+                this.usesGetInterface = true;
+                lines.push(`    return getInterface(ptr, ${baseReturnType})!;`);
+            }
             else {
                 this.usesGetObject = true;
                 lines.push(`    return getObject(ptr) as ${baseReturnType};`);
@@ -1723,9 +1802,16 @@ ${args}
         const tsReturnType = fullReturnType === "void" ? "" : `: ${fullReturnType}`;
         const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
-        const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
+        const needsGObjectWrap = returnTypeMapping.ffi.type === "gobject" &&
             returnTypeMapping.ts !== "unknown" &&
             returnTypeMapping.kind !== "interface";
+        const needsBoxedWrap = returnTypeMapping.ffi.type === "boxed" &&
+            returnTypeMapping.ts !== "unknown" &&
+            returnTypeMapping.kind !== "interface";
+        const needsInterfaceWrap = returnTypeMapping.ffi.type === "gobject" &&
+            returnTypeMapping.ts !== "unknown" &&
+            returnTypeMapping.kind === "interface";
+        const needsObjectWrap = needsGObjectWrap || needsBoxedWrap || needsInterfaceWrap;
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const gtkAllocatesRefs = this.identifyGtkAllocatesRefs(func.parameters);
         const lines = [];
@@ -1742,7 +1828,6 @@ ${args}
         const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
         const refRewrapCode = this.generateRefRewrapCode(gtkAllocatesRefs).map((line) => line.replace(/^ {4}/, "  "));
         if (needsObjectWrap && hasReturnValue) {
-            this.usesGetObject = true;
             lines.push(`  const ptr = call("${sharedLibrary}", "${func.cIdentifier}", [
 ${allArgs ? `${allArgs},` : ""}
   ], ${this.generateTypeDescriptor(returnTypeMapping.ffi)});`);
@@ -1753,7 +1838,19 @@ ${allArgs ? `${allArgs},` : ""}
             if (isNullable) {
                 lines.push(`  if (ptr === null) return null;`);
             }
-            lines.push(`  return getObject(ptr) as ${baseReturnType};`);
+            if (needsBoxedWrap) {
+                this.usesGetBoxed = true;
+                const boxedTypeName = returnTypeMapping.ffi.innerType;
+                lines.push(`  return getBoxed(ptr, "${boxedTypeName}") as ${baseReturnType};`);
+            }
+            else if (needsInterfaceWrap) {
+                this.usesGetInterface = true;
+                lines.push(`  return getInterface(ptr, ${baseReturnType})!;`);
+            }
+            else {
+                this.usesGetObject = true;
+                lines.push(`  return getObject(ptr) as ${baseReturnType};`);
+            }
         }
         else {
             const hasRefRewrap = gtkAllocatesRefs.length > 0;
@@ -1795,6 +1892,22 @@ ${allArgs ? `${allArgs},` : ""}
         });
         return this.formatCode(`${sections.join("\n\n")}\n`);
     }
+    async generateConstants(constants) {
+        const seen = new Set();
+        const sections = [];
+        for (const constant of constants) {
+            const constName = constant.name;
+            if (seen.has(constName)) {
+                continue;
+            }
+            seen.add(constName);
+            const isStringType = constant.type.name === "utf8" || constant.type.name === "filename";
+            const constValue = isStringType ? `"${constant.value}"` : constant.value;
+            const constDoc = constant.doc ? formatDoc(constant.doc) : "";
+            sections.push(`${constDoc}export const ${constName} = ${constValue};`);
+        }
+        return this.formatCode(`${sections.join("\n\n")}\n`);
+    }
     async generateIndex(fileNames) {
         const exports = Array.from(fileNames)
             .filter((f) => f !== "index.ts")
@@ -1838,10 +1951,16 @@ ${allArgs ? `${allArgs},` : ""}
                 typeof mapped.ffi.innerType === "object" &&
                 (mapped.ffi.innerType.type === "boxed" || mapped.ffi.innerType.type === "gobject")) {
                 const innerTsType = mapped.ts.slice(4, -1);
+                const isBoxed = mapped.ffi.innerType.type === "boxed";
+                const boxedTypeName = isBoxed
+                    ? mapped.ffi.innerType.innerType
+                    : undefined;
                 return {
                     paramName: toValidIdentifier(toCamelCase(param.name)),
                     innerType: innerTsType,
                     nullable: this.typeMapper.isNullable(param),
+                    isBoxed,
+                    boxedTypeName,
                 };
             }
             return null;
@@ -1852,10 +1971,18 @@ ${allArgs ? `${allArgs},` : ""}
         if (gtkAllocatesRefs.length === 0) {
             return [];
         }
-        this.usesGetObject = true;
-        return gtkAllocatesRefs.map((ref) => ref.nullable
-            ? `    if (${ref.paramName}) ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`
-            : `    ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`);
+        return gtkAllocatesRefs.map((ref) => {
+            if (ref.isBoxed && ref.boxedTypeName) {
+                this.usesGetBoxed = true;
+                return ref.nullable
+                    ? `    if (${ref.paramName}) ${ref.paramName}.value = getBoxed(${ref.paramName}.value, "${ref.boxedTypeName}") as ${ref.innerType};`
+                    : `    ${ref.paramName}.value = getBoxed(${ref.paramName}.value, "${ref.boxedTypeName}") as ${ref.innerType};`;
+            }
+            this.usesGetObject = true;
+            return ref.nullable
+                ? `    if (${ref.paramName}) ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`
+                : `    ${ref.paramName}.value = getObject(${ref.paramName}.value) as ${ref.innerType};`;
+        });
     }
     generateErrorArgument(indent = "      ") {
         return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } },\n${indent}    value: error,\n${indent}  }`;
@@ -1941,6 +2068,10 @@ ${indent}  }`;
             ffiImports.push("NativeError");
         if (this.usesGetObject)
             ffiImports.push("getObject");
+        if (this.usesGetBoxed)
+            ffiImports.push("getBoxed");
+        if (this.usesGetInterface)
+            ffiImports.push("getInterface");
         if (this.usesInstantiating)
             ffiImports.push("isInstantiating", "setInstantiating");
         if (this.usesRegisterType)
@@ -2033,8 +2164,11 @@ ${indent}  }`;
         return `    return { id: ptr } as unknown as ${baseReturnType};`;
     }
     /**
-     * Adds a catch-all signal handler overload.
-     * Uses `any` for TypeScript compatibility with typed overloads.
+     * Adds a catch-all signal handler overload for unknown signal types.
+     *
+     * Uses `any` because TypeScript overload resolution requires the catch-all
+     * signature to be compatible with all typed overloads. Using `unknown` would
+     * prevent passing typed handlers to this overload.
      */
     addSignalCatchAllOverload(signalOverloads, methodName) {
         signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);

package/dist/generated/adw/application-window.js

@@ -1,4 +1,5 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gio from "../gio/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A freeform application window.
@@ -123,7 +124,7 @@ export class ApplicationWindow extends Gtk.ApplicationWindow {
                 value: this.id,
             },
         ], { type: "gobject", borrowed: true });
-        return getObject(ptr);
+        return getInterface(ptr, Gio.ListModel);
     }
     /**
      * Returns the currently visible dialog in @self, if there's one.

package/dist/generated/adw/avatar.js

@@ -1,4 +1,5 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getInterface, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import * as Gdk from "../gdk/index.js";
 import * as Gtk from "../gtk/index.js";
 /**
  * A widget displaying an image, with a generated fallback.
@@ -92,7 +93,7 @@ export class Avatar extends Gtk.Widget {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getObject(ptr);
+        return getInterface(ptr, Gdk.Paintable);
     }
     /**
      * Gets the name of an icon to use as a fallback.

package/dist/generated/adw/banner.d.ts

@@ -1,4 +1,5 @@
 import { BannerButtonStyle } from "./enums.js";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 import * as Gtk from "../gtk/index.js";
 export declare class Banner extends Gtk.Widget {
@@ -65,6 +66,62 @@ export declare class Banner extends Gtk.Widget {
      * @param useMarkup - whether to use markup
      */
     setUseMarkup(useMarkup: boolean): void;
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName(): string | null;
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue(): GLib.Variant | null;
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName?: string | null): void;
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue?: GLib.Variant | null): void;
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName: string): void;
     connect(signal: "button-clicked", handler: (self: Banner) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Banner, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/adw/banner.js

@@ -1,4 +1,4 @@
-import { call, getObject, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
 import * as Gtk from "../gtk/index.js";
 /**
  * A bar with contextual information.
@@ -199,6 +199,124 @@ export class Banner extends Gtk.Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the action name for @actionable.
+     */
+    getActionName() {
+        return call("libadwaita-1.so.0", "gtk_actionable_get_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], { type: "string", borrowed: true });
+    }
+    /**
+     * Gets the current target value of @actionable.
+     */
+    getActionTargetValue() {
+        const ptr = call("libadwaita-1.so.0", "gtk_actionable_get_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariant",
+            lib: "libadwaita-1.so.0",
+        });
+        if (ptr === null)
+            return null;
+        return getBoxed(ptr, "GVariant");
+    }
+    /**
+     * Specifies the name of the action with which this widget should be
+     * associated.
+     *
+     * If `action_name` is %NULL then the widget will be unassociated from
+     * any previous action.
+     *
+     * Usually this function is used when the widget is located (or will be
+     * located) within the hierarchy of a `GtkApplicationWindow`.
+     *
+     * Names are of the form “win.save” or “app.quit” for actions on the
+     * containing [class@ApplicationWindow] or its associated [class@Application],
+     * respectively. This is the same form used for actions in the [class@Gio.Menu]
+     * associated with the window.
+     * @param actionName - an action name
+     */
+    setActionName(actionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: actionName,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the target value of an actionable widget.
+     *
+     * If `target_value` is %NULL then the target value is unset.
+     *
+     * The target value has two purposes. First, it is used as the parameter
+     * to activation of the action associated with the `GtkActionable` widget.
+     * Second, it is used to determine if the widget should be rendered as
+     * “active” — the widget is active if the state is equal to the given target.
+     *
+     * Consider the example of associating a set of buttons with a [iface@Gio.Action]
+     * with string state in a typical “radio button” situation. Each button
+     * will be associated with the same action, but with a different target
+     * value for that action. Clicking on a particular button will activate
+     * the action with the target of that button, which will typically cause
+     * the action’s state to change to that value. Since the action’s state
+     * is now equal to the target value of the button, the button will now
+     * be rendered as active (and the other buttons, with different targets,
+     * rendered inactive).
+     * @param targetValue - a [struct@GLib.Variant] to set as the target value
+     */
+    setActionTargetValue(targetValue) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_action_target_value", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    borrowed: true,
+                    innerType: "GVariant",
+                    lib: "libadwaita-1.so.0",
+                },
+                value: targetValue?.id ?? targetValue,
+                optional: true,
+            },
+        ], { type: "undefined" });
+    }
+    /**
+     * Sets the action-name and associated string target value of an
+     * actionable widget.
+     *
+     * `detailed_action_name` is a string in the format accepted by
+     * [func@Gio.Action.parse_detailed_name].
+     * @param detailedActionName - the detailed action name
+     */
+    setDetailedActionName(detailedActionName) {
+        call("libadwaita-1.so.0", "gtk_actionable_set_detailed_action_name", [
+            {
+                type: { type: "gobject" },
+                value: this.id,
+            },
+            {
+                type: { type: "string" },
+                value: detailedActionName,
+            },
+        ], { type: "undefined" });
+    }
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };

package/dist/generated/adw/breakpoint-condition.js

@@ -1,4 +1,4 @@
-import { call, getObject, registerType } from "@gtkx/ffi";
+import { call, getObject, getBoxed, registerType } from "@gtkx/ffi";
 /** Describes condition for an [class@Breakpoint]. */
 export class BreakpointCondition {
     static glibTypeName = "AdwBreakpointCondition";
@@ -195,7 +195,7 @@ export class BreakpointCondition {
             innerType: "AdwBreakpointCondition",
             lib: "libadwaita-1.so.0",
         });
-        return getObject(ptr);
+        return getBoxed(ptr, "AdwBreakpointCondition");
     }
     /**
      * Frees @self.