@gtkx/ffi 0.1.17 → 0.1.19

package/dist/cairo/cairo.d.ts

@@ -0,0 +1,30 @@
+export declare function moveTo(cr: unknown, x: number, y: number): void;
+export declare function lineTo(cr: unknown, x: number, y: number): void;
+export declare function curveTo(cr: unknown, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+export declare function arc(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+export declare function arcNegative(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+export declare function rectangle(cr: unknown, x: number, y: number, width: number, height: number): void;
+export declare function closePath(cr: unknown): void;
+export declare function newPath(cr: unknown): void;
+export declare function newSubPath(cr: unknown): void;
+export declare function stroke(cr: unknown): void;
+export declare function strokePreserve(cr: unknown): void;
+export declare function fill(cr: unknown): void;
+export declare function fillPreserve(cr: unknown): void;
+export declare function paint(cr: unknown): void;
+export declare function paintWithAlpha(cr: unknown, alpha: number): void;
+export declare function setSourceRgb(cr: unknown, red: number, green: number, blue: number): void;
+export declare function setSourceRgba(cr: unknown, red: number, green: number, blue: number, alpha: number): void;
+export declare function setLineWidth(cr: unknown, width: number): void;
+export declare function setLineCap(cr: unknown, lineCap: number): void;
+export declare function setLineJoin(cr: unknown, lineJoin: number): void;
+export declare function setDash(cr: unknown, dashes: number[], offset: number): void;
+export declare function save(cr: unknown): void;
+export declare function restore(cr: unknown): void;
+export declare function translate(cr: unknown, tx: number, ty: number): void;
+export declare function scale(cr: unknown, sx: number, sy: number): void;
+export declare function rotate(cr: unknown, angle: number): void;
+export declare function clip(cr: unknown): void;
+export declare function clipPreserve(cr: unknown): void;
+export declare function resetClip(cr: unknown): void;
+export declare function setOperator(cr: unknown, op: number): void;

package/dist/cairo/cairo.js

@@ -0,0 +1,171 @@
+import { call } from "@gtkx/native";
+const LIB = "libcairo.so.2";
+const CAIRO_T = { type: "int", size: 64, unsigned: true };
+export function moveTo(cr, x, y) {
+    call(LIB, "cairo_move_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+    ], { type: "undefined" });
+}
+export function lineTo(cr, x, y) {
+    call(LIB, "cairo_line_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+    ], { type: "undefined" });
+}
+export function curveTo(cr, x1, y1, x2, y2, x3, y3) {
+    call(LIB, "cairo_curve_to", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x1 },
+        { type: { type: "float", size: 64 }, value: y1 },
+        { type: { type: "float", size: 64 }, value: x2 },
+        { type: { type: "float", size: 64 }, value: y2 },
+        { type: { type: "float", size: 64 }, value: x3 },
+        { type: { type: "float", size: 64 }, value: y3 },
+    ], { type: "undefined" });
+}
+export function arc(cr, xc, yc, radius, angle1, angle2) {
+    call(LIB, "cairo_arc", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: xc },
+        { type: { type: "float", size: 64 }, value: yc },
+        { type: { type: "float", size: 64 }, value: radius },
+        { type: { type: "float", size: 64 }, value: angle1 },
+        { type: { type: "float", size: 64 }, value: angle2 },
+    ], { type: "undefined" });
+}
+export function arcNegative(cr, xc, yc, radius, angle1, angle2) {
+    call(LIB, "cairo_arc_negative", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: xc },
+        { type: { type: "float", size: 64 }, value: yc },
+        { type: { type: "float", size: 64 }, value: radius },
+        { type: { type: "float", size: 64 }, value: angle1 },
+        { type: { type: "float", size: 64 }, value: angle2 },
+    ], { type: "undefined" });
+}
+export function rectangle(cr, x, y, width, height) {
+    call(LIB, "cairo_rectangle", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: x },
+        { type: { type: "float", size: 64 }, value: y },
+        { type: { type: "float", size: 64 }, value: width },
+        { type: { type: "float", size: 64 }, value: height },
+    ], { type: "undefined" });
+}
+export function closePath(cr) {
+    call(LIB, "cairo_close_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function newPath(cr) {
+    call(LIB, "cairo_new_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function newSubPath(cr) {
+    call(LIB, "cairo_new_sub_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function stroke(cr) {
+    call(LIB, "cairo_stroke", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function strokePreserve(cr) {
+    call(LIB, "cairo_stroke_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function fill(cr) {
+    call(LIB, "cairo_fill", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function fillPreserve(cr) {
+    call(LIB, "cairo_fill_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function paint(cr) {
+    call(LIB, "cairo_paint", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function paintWithAlpha(cr, alpha) {
+    call(LIB, "cairo_paint_with_alpha", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: alpha },
+    ], { type: "undefined" });
+}
+export function setSourceRgb(cr, red, green, blue) {
+    call(LIB, "cairo_set_source_rgb", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: red },
+        { type: { type: "float", size: 64 }, value: green },
+        { type: { type: "float", size: 64 }, value: blue },
+    ], { type: "undefined" });
+}
+export function setSourceRgba(cr, red, green, blue, alpha) {
+    call(LIB, "cairo_set_source_rgba", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: red },
+        { type: { type: "float", size: 64 }, value: green },
+        { type: { type: "float", size: 64 }, value: blue },
+        { type: { type: "float", size: 64 }, value: alpha },
+    ], { type: "undefined" });
+}
+export function setLineWidth(cr, width) {
+    call(LIB, "cairo_set_line_width", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: width },
+    ], { type: "undefined" });
+}
+export function setLineCap(cr, lineCap) {
+    call(LIB, "cairo_set_line_cap", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: lineCap },
+    ], { type: "undefined" });
+}
+export function setLineJoin(cr, lineJoin) {
+    call(LIB, "cairo_set_line_join", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: lineJoin },
+    ], { type: "undefined" });
+}
+export function setDash(cr, dashes, offset) {
+    call(LIB, "cairo_set_dash", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "array", itemType: { type: "float", size: 64 } }, value: dashes },
+        { type: { type: "int", size: 32, unsigned: false }, value: dashes.length },
+        { type: { type: "float", size: 64 }, value: offset },
+    ], { type: "undefined" });
+}
+export function save(cr) {
+    call(LIB, "cairo_save", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function restore(cr) {
+    call(LIB, "cairo_restore", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function translate(cr, tx, ty) {
+    call(LIB, "cairo_translate", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: tx },
+        { type: { type: "float", size: 64 }, value: ty },
+    ], { type: "undefined" });
+}
+export function scale(cr, sx, sy) {
+    call(LIB, "cairo_scale", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: sx },
+        { type: { type: "float", size: 64 }, value: sy },
+    ], { type: "undefined" });
+}
+export function rotate(cr, angle) {
+    call(LIB, "cairo_rotate", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "float", size: 64 }, value: angle },
+    ], { type: "undefined" });
+}
+export function clip(cr) {
+    call(LIB, "cairo_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function clipPreserve(cr) {
+    call(LIB, "cairo_clip_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function resetClip(cr) {
+    call(LIB, "cairo_reset_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
+}
+export function setOperator(cr, op) {
+    call(LIB, "cairo_set_operator", [
+        { type: CAIRO_T, value: cr },
+        { type: { type: "int", size: 32, unsigned: false }, value: op },
+    ], { type: "undefined" });
+}

package/dist/cairo/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../generated/cairo/index.js";
+export * from "./cairo.js";

package/dist/cairo/index.js

@@ -0,0 +1,2 @@
+export * from "../generated/cairo/index.js";
+export * from "./cairo.js";

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

@@ -36,7 +36,6 @@ export declare class CodeGenerator {
     private buildClassMap;
     private registerInterfaces;
     private buildInterfaceMap;
-    private attachConstructorFunctions;
     private getStandaloneFunctions;
     private resetState;
     private generateClass;

package/dist/codegen/ffi-generator.js

@@ -245,7 +245,6 @@ export class CodeGenerator {
         this.registerInterfaces(namespace);
         const classMap = this.buildClassMap(namespace);
         const interfaceMap = this.buildInterfaceMap(namespace);
-        this.attachConstructorFunctions(namespace, classMap);
         const allEnums = [...namespace.enumerations, ...namespace.bitfields];
         if (allEnums.length > 0) {
             files.set("enums.ts", await this.generateEnums(allEnums));
@@ -262,7 +261,7 @@ export class CodeGenerator {
         for (const iface of namespace.interfaces) {
             files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
         }
-        const standaloneFunctions = this.getStandaloneFunctions(namespace, classMap);
+        const standaloneFunctions = this.getStandaloneFunctions(namespace);
         if (standaloneFunctions.length > 0) {
             files.set("functions.ts", await this.generateFunctions(standaloneFunctions, namespace.sharedLibrary));
         }
@@ -319,37 +318,8 @@ export class CodeGenerator {
         }
         return interfaceMap;
     }
-    attachConstructorFunctions(namespace, classMap) {
-        for (const func of namespace.functions) {
-            const match = func.cIdentifier?.match(/^[a-z_]+_([a-z_]+)_new(_.*)?$/);
-            if (!match?.[1] || !func.returnType.name)
-                continue;
-            const potentialClassName = match[1]
-                .split("_")
-                .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-                .join("");
-            const cls = classMap.get(potentialClassName);
-            if (cls) {
-                cls.constructors.push({
-                    name: func.name,
-                    cIdentifier: func.cIdentifier,
-                    returnType: func.returnType,
-                    parameters: func.parameters,
-                });
-            }
-        }
-    }
-    getStandaloneFunctions(namespace, classMap) {
-        return namespace.functions.filter((func) => {
-            const match = func.cIdentifier?.match(/^[a-z_]+_([a-z_]+)_new(_.*)?$/);
-            if (!match?.[1] || !func.returnType.name)
-                return true;
-            const potentialClassName = match[1]
-                .split("_")
-                .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-                .join("");
-            return !classMap.has(potentialClassName);
-        });
+    getStandaloneFunctions(namespace) {
+        return namespace.functions;
     }
     resetState() {
         this.usesRef = false;
@@ -1771,6 +1741,10 @@ ${indent}  }`;
             if (type.trampoline) {
                 parts.push(`trampoline: "${type.trampoline}"`);
             }
+            if (type.argTypes) {
+                const argTypesStr = type.argTypes.map((t) => this.generateTypeDescriptor(t)).join(", ");
+                parts.push(`argTypes: [${argTypesStr}]`);
+            }
             if (type.sourceType) {
                 parts.push(`sourceType: ${this.generateTypeDescriptor(type.sourceType)}`);
             }

package/dist/generated/gdk/cursor.d.ts

@@ -1,7 +1,7 @@
 import { Texture } from "./texture.js";
 import * as GObject from "../gobject/index.js";
 export declare class Cursor extends GObject.GObject {
-    constructor(callback: unknown, destroy: () => void, data?: number | null, fallback?: Cursor | null);
+    constructor(callback: (...args: unknown[]) => unknown, destroy: () => void, data?: number | null, fallback?: Cursor | null);
     constructor(...args: unknown[]);
     static newFromName(name: string, fallback?: Cursor | null): Cursor;
     static newFromTexture(texture: Texture, hotspotX: number, hotspotY: number, fallback?: Cursor | null): Cursor;

package/dist/generated/gdk/cursor.js

@@ -44,8 +44,8 @@ export class Cursor extends GObject.GObject {
         const [callback, data, destroy, fallback] = args;
         return call("libgtk-4.so.1", "gdk_cursor_new_from_callback", [
             {
-                type: { type: "gobject" },
-                value: callback?.ptr ?? callback,
+                type: { type: "callback" },
+                value: callback,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },

package/dist/generated/gdk/display.d.ts

@@ -35,8 +35,8 @@ export declare class Display extends GObject.GObject {
     isComposited(): boolean;
     isRgba(): boolean;
     listSeats(): Seat[];
-    mapKeycode(keycode: number, nEntries: Ref<number>, keys?: Ref<unknown[]> | null, keyvals?: Ref<number[]> | null): boolean;
-    mapKeyval(keyval: number, keys: Ref<unknown[]>, nKeys: Ref<number>): boolean;
+    mapKeycode(keycode: number, nEntries: Ref<number>, keys?: Ref<number[]> | null, keyvals?: Ref<number[]> | null): boolean;
+    mapKeyval(keyval: number, keys: Ref<number[]>, nKeys: Ref<number>): boolean;
     notifyStartupComplete(startupId: string): void;
     prepareGl(): boolean;
     putEvent(event: Event): void;

package/dist/generated/gdk/display.js

@@ -262,7 +262,10 @@ export class Display extends GObject.GObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "array", itemType: { type: "gobject" } },
+                    innerType: {
+                        type: "array",
+                        itemType: { type: "int", size: 64, unsigned: true },
+                    },
                 },
                 value: keys,
             },
@@ -298,7 +301,10 @@ export class Display extends GObject.GObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "array", itemType: { type: "gobject" } },
+                    innerType: {
+                        type: "array",
+                        itemType: { type: "int", size: 64, unsigned: true },
+                    },
                 },
                 value: keys,
             },

package/dist/generated/gdk/event.d.ts

@@ -20,7 +20,7 @@ export declare class Event {
     getDisplay(): Display | null;
     getEventSequence(): EventSequence;
     getEventType(): EventType;
-    getHistory(outNCoords: Ref<number>): unknown[] | null;
+    getHistory(outNCoords: Ref<number>): number[] | null;
     getModifierState(): ModifierType;
     getPointerEmulated(): boolean;
     getPosition(x: Ref<number>, y: Ref<number>): boolean;

package/dist/generated/gdk/event.js

@@ -172,7 +172,7 @@ export class Event {
                 },
                 value: outNCoords,
             },
-        ], { type: "array", itemType: { type: "gobject" } });
+        ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
     }
     getModifierState() {
         return call("libgtk-4.so.1", "gdk_event_get_modifier_state", [

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.d.ts

@@ -3,7 +3,7 @@ import * as GObject from "../gobject/index.js";
 export declare class PixbufAnimationIter extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    advance(currentTime?: unknown | null): boolean;
+    advance(currentTime?: number | null): boolean;
     getDelayTime(): number;
     getPixbuf(): Pixbuf;
     onCurrentlyLoadingFrame(): boolean;

package/dist/generated/gdkpixbuf/pixbuf-animation-iter.js

@@ -20,8 +20,8 @@ export class PixbufAnimationIter extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
-                value: currentTime?.ptr ?? currentTime,
+                type: { type: "int", size: 64, unsigned: true },
+                value: currentTime,
             },
         ], { type: "boolean" });
     }

package/dist/generated/gdkpixbuf/pixbuf-animation.d.ts

@@ -11,7 +11,7 @@ export declare class PixbufAnimation extends GObject.GObject {
     protected createPtr(args: unknown[]): unknown;
     static newFromStreamAsync(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null, callback?: (source: unknown, result: unknown) => void | null): void;
     getHeight(): number;
-    getIter(startTime?: unknown | null): PixbufAnimationIter;
+    getIter(startTime?: number | null): PixbufAnimationIter;
     getStaticImage(): Pixbuf;
     getWidth(): number;
     isStaticImage(): boolean;

package/dist/generated/gdkpixbuf/pixbuf-animation.js

@@ -83,8 +83,8 @@ export class PixbufAnimation extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
-                value: startTime?.ptr ?? startTime,
+                type: { type: "int", size: 64, unsigned: true },
+                value: startTime,
             },
         ], { type: "gobject", borrowed: true });
         return wrapPtr(ptr, PixbufAnimationIter);

package/dist/generated/gdkpixbuf/pixbuf-format.d.ts

@@ -19,7 +19,7 @@ export declare class PixbufFormat {
     isWritable(): boolean;
     setDisabled(disabled: boolean): void;
     get name(): string;
-    get signature(): unknown;
+    get signature(): number;
     get domain(): string;
     get description(): string;
     get mimeTypes(): string[];

package/dist/generated/gdkpixbuf/pixbuf-format.js

@@ -129,7 +129,7 @@ export class PixbufFormat {
         return read(this.ptr, { type: "string" }, 0);
     }
     get signature() {
-        return read(this.ptr, { type: "gobject" }, 8);
+        return read(this.ptr, { type: "int", size: 64, unsigned: true }, 8);
     }
     get domain() {
         return read(this.ptr, { type: "string" }, 16);

package/dist/generated/gdkpixbuf/pixbuf.d.ts

@@ -8,7 +8,7 @@ export declare class Pixbuf extends GObject.GObject {
     constructor(colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number);
     constructor(...args: unknown[]);
     static newFromBytes(data: GLib.Bytes, colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number): Pixbuf;
-    static newFromData(data: number[], colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number, destroyFn?: unknown | null, destroyFnData?: number | null): Pixbuf;
+    static newFromData(data: number[], colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number, rowstride: number, destroyFn?: (...args: unknown[]) => unknown | null, destroyFnData?: number | null): Pixbuf;
     static newFromFile(filename: string): Pixbuf;
     static newFromFileAtScale(filename: string, width: number, height: number, preserveAspectRatio: boolean): Pixbuf;
     static newFromFileAtSize(filename: string, width: number, height: number): Pixbuf;

package/dist/generated/gdkpixbuf/pixbuf.js

@@ -77,8 +77,8 @@ export class Pixbuf extends GObject.GObject {
                 value: rowstride,
             },
             {
-                type: { type: "gobject" },
-                value: destroyFn?.ptr ?? destroyFn,
+                type: { type: "callback" },
+                value: destroyFn,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },

package/dist/generated/gio/action-map.d.ts

@@ -4,8 +4,8 @@ export declare class ActionMap {
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): ActionMap;
     addAction(action: Action): void;
-    addActionEntries(entries: unknown[], nEntries: number, userData?: number | null): void;
+    addActionEntries(entries: number[], nEntries: number, userData?: number | null): void;
     lookupAction(actionName: string): Action | null;
     removeAction(actionName: string): void;
-    removeActionEntries(entries: unknown[], nEntries: number): void;
+    removeActionEntries(entries: number[], nEntries: number): void;
 }

package/dist/generated/gio/action-map.js

@@ -28,7 +28,10 @@ export class ActionMap {
                 value: this.ptr,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
                 value: entries,
             },
             {
@@ -75,7 +78,10 @@ export class ActionMap {
                 value: this.ptr,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
                 value: entries,
             },
             {

package/dist/generated/gio/app-info.d.ts

@@ -23,7 +23,7 @@ export declare class AppInfo {
     getSupportedTypes(): string[];
     launch(files?: File[] | null, context?: AppLaunchContext | null): boolean;
     launchUris(uris?: string[] | null, context?: AppLaunchContext | null): boolean;
-    launchUrisAsync(uris?: string[] | null, context?: AppLaunchContext | null, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
+    launchUrisAsync(uris?: string[] | null, context?: AppLaunchContext | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     launchUrisFinish(result: AsyncResult): boolean;
     removeSupportsType(contentType: string): boolean;
     setAsDefaultForExtension(extension: string): boolean;

package/dist/generated/gio/app-info.js

@@ -232,8 +232,8 @@ export class AppInfo {
                 value: cancellable?.ptr ?? cancellable,
             },
             {
-                type: { type: "gobject" },
-                value: callback?.ptr ?? callback,
+                type: { type: "callback" },
+                value: callback,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },

package/dist/generated/gio/application.d.ts

@@ -17,7 +17,7 @@ export declare class Application extends GObject.GObject {
     static idIsValid(applicationId: string): boolean;
     activate(): void;
     addMainOption(longName: string, shortName: number, flags: GLib.OptionFlags, arg: GLib.OptionArg, description: string, argDescription?: string | null): void;
-    addMainOptionEntries(entries: unknown[]): void;
+    addMainOptionEntries(entries: number[]): void;
     addOptionGroup(group: GLib.OptionGroup): void;
     bindBusyProperty(object: GObject.GObject, property: string): void;
     getApplicationId(): string | null;
@@ -66,10 +66,10 @@ export declare class Application extends GObject.GObject {
     listActions(): string[];
     queryAction(actionName: string, enabled: Ref<boolean>, parameterType?: Ref<GLib.VariantType> | null, stateType?: Ref<GLib.VariantType> | null, stateHint?: Ref<GLib.Variant> | null, state?: Ref<GLib.Variant> | null): boolean;
     addAction(action: Action): void;
-    addActionEntries(entries: unknown[], nEntries: number, userData?: number | null): void;
+    addActionEntries(entries: number[], nEntries: number, userData?: number | null): void;
     lookupAction(actionName: string): Action | null;
     removeAction(actionName: string): void;
-    removeActionEntries(entries: unknown[], nEntries: number): void;
+    removeActionEntries(entries: number[], nEntries: number): void;
     connect(signal: "activate", handler: (self: Application) => void, after?: boolean): number;
     connect(signal: "command-line", handler: (self: Application, commandLine: ApplicationCommandLine) => number, after?: boolean): number;
     connect(signal: "handle-local-options", handler: (self: Application, options: GLib.VariantDict) => number, after?: boolean): number;

package/dist/generated/gio/application.js

@@ -104,7 +104,10 @@ export class Application extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
                 value: entries,
             },
         ], { type: "undefined" });
@@ -779,7 +782,10 @@ export class Application extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
                 value: entries,
             },
             {
@@ -826,7 +832,10 @@ export class Application extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "array", itemType: { type: "gobject" } },
+                type: {
+                    type: "array",
+                    itemType: { type: "int", size: 64, unsigned: true },
+                },
                 value: entries,
             },
             {

package/dist/generated/gio/async-initable.d.ts

@@ -5,7 +5,7 @@ export declare class AsyncInitable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): AsyncInitable;
-    initAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
+    initAsync(ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     initFinish(res: AsyncResult): boolean;
     newFinish(res: AsyncResult): GObject.GObject;
 }

package/dist/generated/gio/async-initable.js

@@ -24,8 +24,8 @@ export class AsyncInitable {
                 value: cancellable?.ptr ?? cancellable,
             },
             {
-                type: { type: "gobject" },
-                value: callback?.ptr ?? callback,
+                type: { type: "callback" },
+                value: callback,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },

package/dist/generated/gio/buffered-input-stream.d.ts

@@ -10,7 +10,7 @@ export declare class BufferedInputStream extends FilterInputStream {
     static inputStreamNewSized(baseStream: InputStream, size: number): BufferedInputStream;
     protected createPtr(args: unknown[]): unknown;
     fill(count: number, cancellable?: Cancellable | null): number;
-    fillAsync(count: number, ioPriority: number, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
+    fillAsync(count: number, ioPriority: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     fillFinish(result: AsyncResult): number;
     getAvailable(): number;
     getBufferSize(): number;

package/dist/generated/gio/buffered-input-stream.js

@@ -78,8 +78,8 @@ export class BufferedInputStream extends FilterInputStream {
                 value: cancellable?.ptr ?? cancellable,
             },
             {
-                type: { type: "gobject" },
-                value: callback?.ptr ?? callback,
+                type: { type: "callback" },
+                value: callback,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },

package/dist/generated/gio/bytes-icon.d.ts

@@ -15,7 +15,7 @@ export declare class BytesIcon extends GObject.GObject {
     serialize(): GLib.Variant | null;
     toString(): string | null;
     load(size: number, type?: Ref<string> | null, cancellable?: Cancellable | null): InputStream;
-    loadAsync(size: number, cancellable?: Cancellable | null, callback?: unknown | null, userData?: number | null): void;
+    loadAsync(size: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
     loadFinish(res: AsyncResult, type?: Ref<string> | null): InputStream;
     connect(signal: "notify", handler: (self: BytesIcon, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/bytes-icon.js

@@ -125,8 +125,8 @@ export class BytesIcon extends GObject.GObject {
                 value: cancellable?.ptr ?? cancellable,
             },
             {
-                type: { type: "gobject" },
-                value: callback?.ptr ?? callback,
+                type: { type: "callback" },
+                value: callback,
             },
             {
                 type: { type: "int", size: 64, unsigned: true },