@gtkx/ffi 0.1.5 → 0.1.6

package/dist/generated/glib/variant-type.js

@@ -0,0 +1,362 @@
+import { call } from "@gtkx/native";
+export class VariantType {
+    ptr;
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
+    }
+    static typeNewArray(element) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_new_array", [
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: element,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "VariantType" });
+        const instance = Object.create(VariantType.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static typeNewDictEntry(key, value) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_new_dict_entry", [
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: key,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: value,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "VariantType" });
+        const instance = Object.create(VariantType.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static typeNewMaybe(element) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_new_maybe", [
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: element,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "VariantType" });
+        const instance = Object.create(VariantType.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static typeNewTuple(items, length) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_new_tuple", [
+            {
+                type: {
+                    type: "array",
+                    itemType: {
+                        type: "boxed",
+                        innerType: "GVariantType",
+                        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    },
+                },
+                value: items,
+            },
+            {
+                type: { type: "int", size: 32, unsigned: false },
+                value: length,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "VariantType" });
+        const instance = Object.create(VariantType.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    createPtr(_args) {
+        const [typeString] = _args;
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_new", [
+            {
+                type: { type: "string" },
+                value: typeString,
+            },
+        ], { type: "boxed", borrowed: true, innerType: "GVariantType" });
+    }
+    static checked_(typeString) {
+        const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_checked_", [
+            {
+                type: { type: "string" },
+                value: typeString,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+        const instance = Object.create(VariantType.prototype);
+        instance.ptr = ptr;
+        return instance;
+    }
+    static stringGetDepth_(typeString) {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_string_get_depth_", [
+            {
+                type: { type: "string" },
+                value: typeString,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    static stringIsValid(typeString) {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_string_is_valid", [
+            {
+                type: { type: "string" },
+                value: typeString,
+            },
+        ], { type: "boolean" });
+    }
+    static stringScan(string, limit, endptr) {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_string_scan", [
+            {
+                type: { type: "string" },
+                value: string,
+            },
+            {
+                type: { type: "string" },
+                value: limit,
+            },
+            {
+                type: { type: "ref", innerType: { type: "string" } },
+                value: endptr,
+            },
+        ], { type: "boolean" });
+    }
+    copy() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_copy", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+    dupString() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_dup_string", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    element() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_element", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+    equal(type2) {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_equal", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: type2,
+            },
+        ], { type: "boolean" });
+    }
+    first() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_first", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+    free() {
+        call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_free", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "undefined" });
+    }
+    getStringLength() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_get_string_length", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    hash() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_hash", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "int", size: 32, unsigned: true });
+    }
+    isArray() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_array", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isBasic() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_basic", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isContainer() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_container", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isDefinite() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_definite", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isDictEntry() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_dict_entry", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isMaybe() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_maybe", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isSubtypeOf(supertype) {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_subtype_of", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                },
+                value: supertype,
+            },
+        ], { type: "boolean" });
+    }
+    isTuple() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_tuple", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    isVariant() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_is_variant", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "boolean" });
+    }
+    key() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_key", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+    nItems() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_n_items", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
+    next() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_next", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+    peekString() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_peek_string", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], { type: "string" });
+    }
+    value() {
+        return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_type_value", [
+            {
+                type: { type: "gobject" },
+                value: this.ptr,
+            },
+        ], {
+            type: "boxed",
+            borrowed: true,
+            innerType: "GVariantType",
+            lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+        });
+    }
+}

package/dist/generated/glib/variant.d.ts

@@ -0,0 +1,102 @@
+import { Ref } from "@gtkx/native";
+import { VariantClass } from "./enums.js";
+import type { Bytes } from "./bytes.js";
+import type { GError } from "./error.js";
+import type { String } from "./string.js";
+import type { VariantType } from "./variant-type.js";
+export declare class Variant {
+    ptr: unknown;
+    constructor(nChildren: unknown, childType?: VariantType, children?: Variant[]);
+    constructor(_args: unknown[]);
+    static new(formatString: string): Variant;
+    static newBoolean(value: boolean): Variant;
+    static newByte(value: number): Variant;
+    static newBytestring(string: number[]): Variant;
+    static newBytestringArray(strv: string[], length: unknown): Variant;
+    static newDictEntry(key: Variant, value: Variant): Variant;
+    static newDouble(value: number): Variant;
+    static newFixedArray(elementType: VariantType, nElements: unknown, elementSize: unknown, elements?: unknown): Variant;
+    static newFromBytes(type: VariantType, bytes: Bytes, trusted: boolean): Variant;
+    static newFromData(type: VariantType, data: number[], size: unknown, trusted: boolean, notify: unknown, userData?: unknown): Variant;
+    static newHandle(value: number): Variant;
+    static newInt16(value: number): Variant;
+    static newInt32(value: number): Variant;
+    static newInt64(value: number): Variant;
+    static newMaybe(childType?: VariantType, child?: Variant): Variant;
+    static newObjectPath(objectPath: string): Variant;
+    static newObjv(strv: string[], length: unknown): Variant;
+    static newParsed(format: string): Variant;
+    static newParsedVa(format: string, app: unknown): Variant;
+    static newPrintf(formatString: string): Variant;
+    static newSignature(signature: string): Variant;
+    static newString(string: string): Variant;
+    static newStrv(strv: string[], length: unknown): Variant;
+    static newTakeString(string: string): Variant;
+    static newTuple(children: Variant[], nChildren: unknown): Variant;
+    static newUint16(value: number): Variant;
+    static newUint32(value: number): Variant;
+    static newUint64(value: number): Variant;
+    static newVa(formatString: string, app: unknown, endptr?: string): Variant;
+    static newVariant(value: Variant): Variant;
+    protected createPtr(_args: unknown[]): unknown;
+    static isObjectPath(string: string): boolean;
+    static isSignature(string: string): boolean;
+    static parse(text: string, type?: VariantType, limit?: string, endptr?: string): Variant;
+    static parseErrorPrintContext(error: GError, sourceStr: string): string;
+    static parseErrorQuark(): number;
+    static parserGetErrorQuark(): number;
+    byteswap(): Variant;
+    checkFormatString(formatString: string, copyOnly: boolean): boolean;
+    classify(): VariantClass;
+    compare(two: Variant): number;
+    dupBytestring(length?: Ref<unknown>): number[];
+    dupBytestringArray(length?: Ref<unknown>): string[];
+    dupObjv(length?: Ref<unknown>): string[];
+    dupString(length: Ref<unknown>): string;
+    dupStrv(length?: Ref<unknown>): string[];
+    equal(two: Variant): boolean;
+    get(formatString: string): void;
+    getBoolean(): boolean;
+    getByte(): number;
+    getBytestring(): number[];
+    getBytestringArray(length?: Ref<unknown>): string[];
+    getChild(index_: unknown, formatString: string): void;
+    getChildValue(index_: unknown): Variant;
+    getData(): unknown;
+    getDataAsBytes(): Bytes;
+    getDouble(): number;
+    getFixedArray(nElements: Ref<unknown>, elementSize: unknown): unknown[];
+    getHandle(): number;
+    getInt16(): number;
+    getInt32(): number;
+    getInt64(): number;
+    getMaybe(): Variant;
+    getNormalForm(): Variant;
+    getObjv(length?: Ref<unknown>): string[];
+    getSize(): unknown;
+    getString(length?: Ref<unknown>): string;
+    getStrv(length?: Ref<unknown>): string[];
+    getType(): VariantType;
+    getTypeString(): string;
+    getUint16(): number;
+    getUint32(): number;
+    getUint64(): number;
+    getVa(formatString: string, app: unknown, endptr?: string): void;
+    getVariant(): Variant;
+    hash(): number;
+    isContainer(): boolean;
+    isFloating(): boolean;
+    isNormalForm(): boolean;
+    isOfType(type: VariantType): boolean;
+    iterNew(): unknown;
+    lookup(key: string, formatString: string): boolean;
+    lookupValue(key: string, expectedType?: VariantType): Variant;
+    nChildren(): unknown;
+    print(typeAnnotate: boolean): string;
+    printString(typeAnnotate: boolean, string?: String): String;
+    ref(): Variant;
+    refSink(): Variant;
+    store(data: unknown): void;
+    takeRef(): Variant;
+    unref(): void;
+}