@gtkx/ffi 0.1.3 → 0.1.4

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

@@ -24,6 +24,8 @@ export declare class CodeGenerator {
     private generateConstructor;
     private generateCreatePtr;
     private generateStaticFactoryMethod;
+    private generateStaticFunctions;
+    private generateStaticFunction;
     private generateMethods;
     private generateMethod;
     private generateProperties;

package/dist/codegen/ffi-generator.js

@@ -222,8 +222,9 @@ export class CodeGenerator {
         this.resetState();
         this.usesRef =
             cls.methods.some((m) => hasOutParameter(m.parameters)) ||
-                cls.constructors.some((c) => hasOutParameter(c.parameters));
-        this.usesCall = cls.methods.length > 0 || cls.constructors.length > 0 || cls.signals.length > 0;
+                cls.constructors.some((c) => hasOutParameter(c.parameters)) ||
+                cls.functions.some((f) => hasOutParameter(f.parameters));
+        this.usesCall = cls.methods.length > 0 || cls.constructors.length > 0 || cls.functions.length > 0 || cls.signals.length > 0;
         const className = normalizeClassName(cls.name);
         const hasParent = !!(cls.parent && classMap.has(cls.parent));
         const parentClassName = cls.parent ? normalizeClassName(cls.parent) : "";
@@ -242,6 +243,7 @@ export class CodeGenerator {
         }
         sections.push(this.generateConstructors(cls, sharedLibrary, hasParent));
         sections.push(this.generateCreatePtr(cls, sharedLibrary, hasParent));
+        sections.push(this.generateStaticFunctions(cls.functions, sharedLibrary, className));
         sections.push(this.generateMethods(cls.methods, sharedLibrary, cls.name));
         sections.push(this.generateProperties(cls.properties, cls.methods));
         if (cls.signals.length > 0) {
@@ -362,6 +364,78 @@ ${args}
   }
 `;
     }
+    generateStaticFunctions(functions, sharedLibrary, className) {
+        const sections = [];
+        for (const func of functions) {
+            sections.push(this.generateStaticFunction(func, sharedLibrary, className));
+        }
+        return sections.join("\n");
+    }
+    generateStaticFunction(func, sharedLibrary, className) {
+        const funcName = toValidIdentifier(toCamelCase(func.name));
+        const params = this.generateParameterList(func.parameters);
+        const returnTypeMapping = this.typeMapper.mapType(func.returnType, true);
+        const returnsOwnClass = func.returnType.name === className || func.returnType.name?.endsWith(`.${className}`);
+        const rawReturnType = returnsOwnClass ? className : returnTypeMapping.ts;
+        const tsReturnType = rawReturnType === "void" ? "" : `: ${rawReturnType}`;
+        const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
+        const resultVarName = hasResultParam ? "_result" : "result";
+        const needsCast = rawReturnType !== "void" && rawReturnType !== "unknown";
+        const hasReturnValue = rawReturnType !== "void";
+        const lines = [];
+        const funcDoc = formatMethodDoc(func.doc, func.parameters);
+        if (funcDoc) {
+            lines.push(funcDoc.trimEnd());
+        }
+        lines.push(`  static ${funcName}(${params})${tsReturnType} {`);
+        if (func.throws) {
+            lines.push(`    const error = { value: null as unknown };`);
+        }
+        const args = this.generateCallArguments(func.parameters);
+        const errorArg = func.throws ? this.generateErrorArgument() : "";
+        const allArgs = errorArg ? args + (args ? ",\n" : "") + errorArg : args;
+        if (returnsOwnClass) {
+            lines.push(`    const ptr = call(
+      "${sharedLibrary}",
+      "${func.cIdentifier}",
+      [
+${allArgs ? `${allArgs},` : ""}
+      ],
+      ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
+    );`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck());
+            }
+            lines.push(`    const instance = Object.create(${className}.prototype) as ${className} & { ptr: unknown };
+    instance.ptr = ptr;
+    return instance;`);
+        }
+        else {
+            const callPrefix = func.throws
+                ? hasReturnValue
+                    ? `const ${resultVarName} = `
+                    : ""
+                : hasReturnValue
+                    ? "return "
+                    : "";
+            lines.push(`    ${callPrefix}call(
+      "${sharedLibrary}",
+      "${func.cIdentifier}",
+      [
+${allArgs ? `${allArgs},` : ""}
+      ],
+      ${this.generateTypeDescriptor(returnTypeMapping.ffi)}
+    )${needsCast ? ` as ${rawReturnType}` : ""};`);
+            if (func.throws) {
+                lines.push(this.generateErrorCheck());
+                if (hasReturnValue) {
+                    lines.push(`    return ${resultVarName};`);
+                }
+            }
+        }
+        lines.push(`  }`);
+        return `${lines.join("\n")}\n`;
+    }
     generateMethods(methods, sharedLibrary, className) {
         const generatedMethods = new Set();
         const sections = [];

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

@@ -2,6 +2,7 @@ export declare class DisplayManager {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static get(): DisplayManager;
     getDefaultDisplay(): unknown;
     listDisplays(): unknown;
     openDisplay(name?: string): unknown;

package/dist/generated/gdk/display-manager.js

@@ -8,6 +8,15 @@ export class DisplayManager {
     createPtr(_args) {
         return null;
     }
+    static get() {
+        const ptr = call("libgtk-4.so.1", "gdk_display_manager_get", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(DisplayManager.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     getDefaultDisplay() {
         return call("libgtk-4.so.1", "gdk_display_manager_get_default_display", [
             {

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

@@ -4,6 +4,8 @@ export declare class Display {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static getDefault(): Display;
+    static open(displayName?: string): Display;
     beep(): void;
     close(): void;
     createGlContext(): unknown;

package/dist/generated/gdk/display.js

@@ -8,6 +8,26 @@ export class Display {
     createPtr(_args) {
         return null;
     }
+    static getDefault() {
+        const ptr = call("libgtk-4.so.1", "gdk_display_get_default", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(Display.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static open(displayName) {
+        const ptr = call("libgtk-4.so.1", "gdk_display_open", [
+            {
+                type: { type: "string" },
+                value: displayName,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(Display.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     beep() {
         call("libgtk-4.so.1", "gdk_display_beep", [
             {

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

@@ -3,6 +3,7 @@ export declare class Drag {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static begin(surface: unknown, device: unknown, content: unknown, actions: DragAction, dx: number, dy: number): Drag;
     dropDone(success: boolean): void;
     getActions(): DragAction;
     getContent(): unknown;

package/dist/generated/gdk/drag.js

@@ -7,6 +7,37 @@ export class Drag {
     createPtr(_args) {
         return null;
     }
+    static begin(surface, device, content, actions, dx, dy) {
+        const ptr = call("libgtk-4.so.1", "gdk_drag_begin", [
+            {
+                type: { type: "gobject" },
+                value: surface,
+            },
+            {
+                type: { type: "gobject" },
+                value: device,
+            },
+            {
+                type: { type: "gobject" },
+                value: content,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: actions,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: dx,
+            },
+            {
+                type: { type: "float", size: 64 },
+                value: dy,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(Drag.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     dropDone(success) {
         call("libgtk-4.so.1", "gdk_drag_drop_done", [
             {

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

@@ -4,6 +4,8 @@ import { DrawContext } from "./draw-context.js";
 export declare class GLContext extends DrawContext {
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static clearCurrent(): void;
+    static getCurrent(): GLContext;
     getAllowedApis(): GLAPI;
     getApi(): GLAPI;
     getDebugEnabled(): boolean;

package/dist/generated/gdk/glcontext.js

@@ -7,6 +7,20 @@ export class GLContext extends DrawContext {
     createPtr(_args) {
         return null;
     }
+    static clearCurrent() {
+        call("libgtk-4.so.1", "gdk_gl_context_clear_current", [], {
+            type: "undefined",
+        });
+    }
+    static getCurrent() {
+        const ptr = call("libgtk-4.so.1", "gdk_gl_context_get_current", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(GLContext.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     getAllowedApis() {
         return call("libgtk-4.so.1", "gdk_gl_context_get_allowed_apis", [
             {

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

@@ -1,9 +1,10 @@
 import { Ref } from "@gtkx/native";
-import { ScrollDirection, ScrollUnit } from "./enums.js";
+import { ScrollDirection, ScrollRelativeDirection, ScrollUnit } from "./enums.js";
 import { Event } from "./event.js";
 export declare class ScrollEvent extends Event {
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static getRelativeDirection(event: unknown): ScrollRelativeDirection;
     getDeltas(deltaX: Ref<number>, deltaY: Ref<number>): void;
     getDirection(): ScrollDirection;
     getUnit(): ScrollUnit;

package/dist/generated/gdk/scroll-event.js

@@ -7,6 +7,14 @@ export class ScrollEvent extends Event {
     createPtr(_args) {
         return null;
     }
+    static getRelativeDirection(event) {
+        return call("libgtk-4.so.1", "gdk_scroll_event_get_relative_direction", [
+            {
+                type: { type: "gobject" },
+                value: event,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
     getDeltas(deltaX, deltaY) {
         call("libgtk-4.so.1", "gdk_scroll_event_get_deltas", [
             {

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

@@ -6,6 +6,7 @@ export declare class PixbufAnimation {
     static animationNewFromStream(stream: unknown, cancellable?: unknown): PixbufAnimation;
     static animationNewFromStreamFinish(asyncResult: unknown): PixbufAnimation;
     protected createPtr(_args: unknown[]): unknown;
+    static newFromStreamAsync(stream: unknown, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
     getHeight(): number;
     getIter(startTime?: unknown): unknown;
     getStaticImage(): unknown;

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

@@ -51,6 +51,26 @@ export class PixbufAnimation {
             },
         ], { type: "gobject", borrowed: true });
     }
+    static newFromStreamAsync(stream, cancellable, callback, userData) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_new_from_stream_async", [
+            {
+                type: { type: "gobject" },
+                value: stream,
+            },
+            {
+                type: { type: "gobject" },
+                value: cancellable,
+            },
+            {
+                type: { type: "gobject" },
+                value: callback,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "undefined" });
+    }
     getHeight() {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_animation_get_height", [
             {

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

@@ -17,6 +17,15 @@ export declare class Pixbuf {
     static newFromStreamFinish(asyncResult: unknown): Pixbuf;
     static newFromXpmData(data: string[]): Pixbuf;
     protected createPtr(_args: unknown[]): unknown;
+    static calculateRowstride(colorspace: Colorspace, hasAlpha: boolean, bitsPerSample: number, width: number, height: number): number;
+    static getFileInfo(filename: string, width?: Ref<number>, height?: Ref<number>): unknown;
+    static getFileInfoAsync(filename: string, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
+    static getFileInfoFinish(asyncResult: unknown, width: Ref<number>, height: Ref<number>): unknown;
+    static getFormats(): unknown;
+    static initModules(path: string): boolean;
+    static newFromStreamAsync(stream: unknown, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
+    static newFromStreamAtScaleAsync(stream: unknown, width: number, height: number, preserveAspectRatio: boolean, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
+    static saveToStreamFinish(asyncResult: unknown): boolean;
     addAlpha(substituteColor: boolean, r: number, g: number, b: number): unknown;
     applyEmbeddedOrientation(): unknown;
     composite(dest: unknown, destX: number, destY: number, destWidth: number, destHeight: number, offsetX: number, offsetY: number, scaleX: number, scaleY: number, interpType: InterpType, overallAlpha: number): void;

package/dist/generated/gdkpixbuf/pixbuf.js

@@ -284,6 +284,201 @@ export class Pixbuf {
             },
         ], { type: "gobject", borrowed: true });
     }
+    static calculateRowstride(colorspace, hasAlpha, bitsPerSample, width, height) {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_calculate_rowstride", [
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: colorspace,
+            },
+            {
+                type: { type: "boolean" },
+                value: hasAlpha,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: bitsPerSample,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: width,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: height,
+            },
+        ], { type: "int", size: 32, unsigned: false });
+    }
+    static getFileInfo(filename, width, height) {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info", [
+            {
+                type: { type: "string" },
+                value: filename,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: width,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: height,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    static getFileInfoAsync(filename, cancellable, callback, userData) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info_async", [
+            {
+                type: { type: "string" },
+                value: filename,
+            },
+            {
+                type: { type: "gobject" },
+                value: cancellable,
+            },
+            {
+                type: { type: "gobject" },
+                value: callback,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "undefined" });
+    }
+    static getFileInfoFinish(asyncResult, width, height) {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_file_info_finish", [
+            {
+                type: { type: "gobject" },
+                value: asyncResult,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: width,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: { type: "int", size: 32, unsigned: false },
+                },
+                value: height,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "gobject", borrowed: true });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
+    static getFormats() {
+        return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_get_formats", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+    }
+    static initModules(path) {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_init_modules", [
+            {
+                type: { type: "string" },
+                value: path,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
+    static newFromStreamAsync(stream, cancellable, callback, userData) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_async", [
+            {
+                type: { type: "gobject" },
+                value: stream,
+            },
+            {
+                type: { type: "gobject" },
+                value: cancellable,
+            },
+            {
+                type: { type: "gobject" },
+                value: callback,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "undefined" });
+    }
+    static newFromStreamAtScaleAsync(stream, width, height, preserveAspectRatio, cancellable, callback, userData) {
+        call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_new_from_stream_at_scale_async", [
+            {
+                type: { type: "gobject" },
+                value: stream,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: width,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: height,
+            },
+            {
+                type: { type: "boolean" },
+                value: preserveAspectRatio,
+            },
+            {
+                type: { type: "gobject" },
+                value: cancellable,
+            },
+            {
+                type: { type: "gobject" },
+                value: callback,
+            },
+            {
+                type: { type: "gobject" },
+                value: userData,
+            },
+        ], { type: "undefined" });
+    }
+    static saveToStreamFinish(asyncResult) {
+        const error = { value: null };
+        const result = call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_save_to_stream_finish", [
+            {
+                type: { type: "gobject" },
+                value: asyncResult,
+            },
+            {
+                type: { type: "ref", innerType: { type: "gobject" } },
+                value: error,
+            },
+        ], { type: "boolean" });
+        if (error.value !== null) {
+            const jsError = new Error("GLib Error occurred");
+            jsError.gError = error.value;
+            throw jsError;
+        }
+        return result;
+    }
     addAlpha(substituteColor, r, g, b) {
         return call("libgdk_pixbuf-2.0.so.0", "gdk_pixbuf_add_alpha", [
             {

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

@@ -2,5 +2,6 @@ export declare class AppInfoMonitor {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static get(): AppInfoMonitor;
     connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

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

@@ -7,6 +7,15 @@ export class AppInfoMonitor {
     createPtr(_args) {
         return null;
     }
+    static get() {
+        const ptr = call("libgio-2.0.so.0", "g_app_info_monitor_get", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(AppInfoMonitor.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     connect(signal, handler, after = false) {
         const signalMeta = {
             changed: [],

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

@@ -4,6 +4,8 @@ export declare class Application {
     constructor(flags: ApplicationFlags, applicationId?: string);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static getDefault(): Application;
+    static idIsValid(applicationId: string): boolean;
     activate(): void;
     addMainOption(longName: string, shortName: number, flags: unknown, arg: unknown, description: string, argDescription?: string): void;
     addMainOptionEntries(entries: unknown[]): void;

package/dist/generated/gio/application.js

@@ -19,6 +19,23 @@ export class Application {
             },
         ], { type: "gobject", borrowed: true });
     }
+    static getDefault() {
+        const ptr = call("libgio-2.0.so.0", "g_application_get_default", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(Application.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static idIsValid(applicationId) {
+        return call("libgio-2.0.so.0", "g_application_id_is_valid", [
+            {
+                type: { type: "string" },
+                value: applicationId,
+            },
+        ], { type: "boolean" });
+    }
     activate() {
         call("libgio-2.0.so.0", "g_application_activate", [
             {

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

@@ -2,6 +2,7 @@ export declare class Cancellable {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static getCurrent(): Cancellable;
     cancel(): void;
     connect(callback: unknown, data?: unknown, dataDestroyFunc?: unknown): number;
     disconnect(handlerId: number): void;

package/dist/generated/gio/cancellable.js

@@ -10,6 +10,15 @@ export class Cancellable {
             borrowed: true,
         });
     }
+    static getCurrent() {
+        const ptr = call("libgio-2.0.so.0", "g_cancellable_get_current", [], {
+            type: "gobject",
+            borrowed: true,
+        });
+        const instance = Object.create(Cancellable.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
     cancel() {
         call("libgio-2.0.so.0", "g_cancellable_cancel", [
             {

package/dist/generated/gio/dbus-action-group.d.ts

@@ -2,4 +2,5 @@ export declare class DBusActionGroup {
     ptr: unknown;
     constructor(_args?: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    static get(connection: unknown, objectPath: string, busName?: string): DBusActionGroup;
 }

package/dist/generated/gio/dbus-action-group.js

@@ -1,3 +1,4 @@
+import { call } from "@gtkx/native";
 export class DBusActionGroup {
     ptr;
     constructor(_args = []) {
@@ -6,4 +7,23 @@ export class DBusActionGroup {
     createPtr(_args) {
         return null;
     }
+    static get(connection, objectPath, busName) {
+        const ptr = call("libgio-2.0.so.0", "g_dbus_action_group_get", [
+            {
+                type: { type: "gobject" },
+                value: connection,
+            },
+            {
+                type: { type: "string" },
+                value: busName,
+            },
+            {
+                type: { type: "string" },
+                value: objectPath,
+            },
+        ], { type: "gobject", borrowed: true });
+        const instance = Object.create(DBusActionGroup.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
 }

package/dist/generated/gio/dbus-connection.d.ts

@@ -8,6 +8,8 @@ export declare class DBusConnection {
     static connectionNewForAddressSync(address: string, flags: DBusConnectionFlags, observer?: unknown, cancellable?: unknown): DBusConnection;
     static connectionNewSync(stream: unknown, flags: DBusConnectionFlags, guid?: string, observer?: unknown, cancellable?: unknown): DBusConnection;
     protected createPtr(_args: unknown[]): unknown;
+    static _new(stream: unknown, flags: DBusConnectionFlags, guid?: string, observer?: unknown, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
+    static newForAddress(address: string, flags: DBusConnectionFlags, observer?: unknown, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
     addFilter(filterFunction: unknown, userDataFreeFunc: unknown, userData?: unknown): number;
     call(objectPath: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string, parameters?: unknown, replyType?: unknown, cancellable?: unknown, callback?: unknown, userData?: unknown): void;
     callFinish(res: unknown): unknown;