@ts-for-gir/lib 3.3.0 → 4.0.0-beta.2

package/lib/generators/dts/glib.js

@@ -0,0 +1,514 @@
+export function override(node) {
+    // We provide manually written versions of these types below.
+    node.assertClass("Variant").noEmit();
+    node.assertClass("VariantType").noEmit();
+    node.assertClass("VariantBuilder").noEmit();
+    node.assertClass("VariantDict").noEmit();
+    return `
+    // Variant parsing inspired by https://jamie.build/ slightly infamous JSON-in-TypeScript parsing.
+
+    type CreateIndexType<Key extends string, Value extends any> =
+        Key extends \`s\` | \`o\` | \`g\` ? { [key: string]: Value } :
+        Key extends \`n\` | \`q\` | \`t\` | \`d\` | \`u\` | \`i\` | \`x\` | \`y\` ? { [key: number]: Value } : never;
+
+    type VariantTypeError<T extends string> = { error: true } & T;
+    
+    /**
+     * Handles the {kv} of a{kv} where k is a basic type and v is any possible variant type string.
+     */
+    type $ParseDeepVariantDict<State extends string, Memo extends Record<string, any> = {}> =
+        string extends State
+        ? VariantTypeError<"$ParseDeepVariantDict: 'string' is not a supported type.">
+        // Hitting the first '}' indicates the dictionary type is complete
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        // This separates the key (basic type) from the rest of the remaining expression.
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseDeepVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [CreateIndexType<Key, Value>, State]
+        : VariantTypeError<\`$ParseDeepVariantDict encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseDeepVariantValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseDeepVariantDict encountered an invalid variant string: \${State} (2)\`>;
+    
+    /**
+     * Handles parsing values within a tuple (e.g. (vvv)) where v is any possible variant type string.
+     */
+    type $ParseDeepVariantArray<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseDeepVariantArray: 'string' is not a supported type.">
+        : State extends \`)\${infer State}\`
+        ? [Memo, State]
+        : $ParseDeepVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`\${infer NextValue})\${infer NextState}\`
+        ? $ParseDeepVariantArray<State, [...Memo, Value]>
+        : State extends \`)\${infer State}\`
+        ? [[...Memo, Value], State]
+        : VariantTypeError<\`1: $ParseDeepVariantArray encountered an invalid variant string: \${State}\`>
+        : VariantTypeError<\`2: $ParseDeepVariantValue returned unexpected value for: \${State}\`>;
+    
+    /**
+     * Handles parsing {kv} without an 'a' prefix (key-value pair) where k is a basic type
+     * and v is any possible variant type string.
+     */
+    type $ParseDeepVariantKeyValue<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseDeepVariantKeyValue: 'string' is not a supported type.">
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseDeepVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [[...Memo, $ParseVariant<Key>, Value], State]
+        : VariantTypeError<\`$ParseDeepVariantKeyValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseDeepVariantKeyValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseDeepVariantKeyValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    /**
+     * Handles parsing any variant 'value' or base unit.
+     * 
+     * - ay - Array of bytes (Uint8Array)
+     * - a* - Array of type *
+     * - a{k*} - Dictionary
+     * - {k*} - KeyValue
+     * - (**) - tuple
+     * - s | o | g - string types
+     * - n | q | t | d | u | i | x | y - number types
+     * - b - boolean type
+     * - v - unknown Variant type
+     * - h | ? - unknown types
+     */
+    type $ParseDeepVariantValue<State extends string> =
+        string extends State
+        ? unknown
+        : State extends \`\${\`s\` | \`o\` | \`g\`}\${infer State}\`
+        ? [string, State]
+        : State extends \`\${\`n\` | \`q\` | \`t\` | \`d\` | \`u\` | \`i\` | \`x\` | \`y\`}\${infer State}\`
+        ? [number, State]
+        : State extends \`b\${infer State}\`
+        ? [boolean, State]
+        : State extends \`v\${infer State}\`
+        ? [Variant, State]
+        : State extends \`\${'h' | '?'}\${infer State}\`
+        ? [unknown, State]
+        : State extends \`(\${infer State}\`
+        ? $ParseDeepVariantArray<State>
+        : State extends \`a{\${infer State}\`
+        ? $ParseDeepVariantDict<State>
+        : State extends \`{\${infer State}\`
+        ? $ParseDeepVariantKeyValue<State>
+        : State extends \`ay\${infer State}\` ?
+        [Uint8Array, State]
+        : State extends \`m\${infer State}\`
+        ? $ParseDeepVariantValue<State> extends [infer Value, \`\${infer State}\`]
+          ? [Value | null, State]
+          : VariantTypeError<\`$ParseDeepVariantValue encountered an invalid variant string: \${State} (3)\`>
+        : State extends \`a\${infer State}\` ?
+        $ParseDeepVariantValue<State> extends [infer Value, \`\${infer State}\`] ?
+        [Value[], State]
+        : VariantTypeError<\`$ParseDeepVariantValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseDeepVariantValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseDeepVariant<T extends string> =
+        $ParseDeepVariantValue<T> extends infer Result
+        ? Result extends [infer Value, string]
+        ? Value
+        : Result extends VariantTypeError<any>
+        ? Result
+        : VariantTypeError<"$ParseDeepVariantValue returned unexpected Result">
+        : VariantTypeError<"$ParseDeepVariantValue returned uninferrable Result">;
+    
+    type $ParseRecursiveVariantDict<State extends string, Memo extends Record<string, any> = {}> =
+        string extends State
+        ? VariantTypeError<"$ParseRecursiveVariantDict: 'string' is not a supported type.">
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseRecursiveVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [CreateIndexType<Key, Value>, State]
+        : VariantTypeError<\`$ParseRecursiveVariantDict encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseRecursiveVariantValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseRecursiveVariantDict encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseRecursiveVariantArray<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseRecursiveVariantArray: 'string' is not a supported type.">
+        : State extends \`)\${infer State}\`
+        ? [Memo, State]
+        : $ParseRecursiveVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`\${infer NextValue})\${infer NextState}\`
+        ? $ParseRecursiveVariantArray<State, [...Memo, Value]>
+        : State extends \`)\${infer State}\`
+        ? [[...Memo, Value], State]
+        : VariantTypeError<\`$ParseRecursiveVariantArray encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseRecursiveVariantValue returned unexpected value for: \${State} (2)\`>;
+    
+    type $ParseRecursiveVariantKeyValue<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseRecursiveVariantKeyValue: 'string' is not a supported type.">
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseRecursiveVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [[...Memo, Key, Value], State]
+        : VariantTypeError<\`$ParseRecursiveVariantKeyValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseRecursiveVariantKeyValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseRecursiveVariantKeyValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseRecursiveVariantValue<State extends string> =
+        string extends State
+        ? unknown
+        : State extends \`\${\`s\` | \`o\` | \`g\`}\${infer State}\`
+        ? [string, State]
+        : State extends \`\${\`n\` | \`q\` | \`t\` | \`d\` | \`u\` | \`i\` | \`x\` | \`y\`}\${infer State}\`
+        ? [number, State]
+        : State extends \`b\${infer State}\`
+        ? [boolean, State]
+        : State extends \`v\${infer State}\`
+        ? [unknown, State]
+        : State extends \`\${'h' | '?'}\${infer State}\`
+        ? [unknown, State]
+        : State extends \`(\${infer State}\`
+        ? $ParseRecursiveVariantArray<State>
+        : State extends \`a{\${infer State}\`
+        ? $ParseRecursiveVariantDict<State>
+        : State extends \`{\${infer State}\`
+        ? $ParseRecursiveVariantKeyValue<State>
+        : State extends \`ay\${infer State}\` ?
+        [Uint8Array, State]
+        : State extends \`m\${infer State}\`
+        ? $ParseRecursiveVariantValue<State> extends [infer Value, \`\${infer State}\`]
+          ? [Value | null, State]
+          : VariantTypeError<\`$ParseRecursiveVariantValue encountered an invalid variant string: \${State} (3)\`>
+        : State extends \`a\${infer State}\` ?
+        $ParseRecursiveVariantValue<State> extends [infer Value, \`\${infer State}\`] ?
+        [Value[], State]
+        : VariantTypeError<\`$ParseRecursiveVariantValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseRecursiveVariantValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseRecursiveVariant<T extends string> =
+        $ParseRecursiveVariantValue<T> extends infer Result
+        ? Result extends [infer Value, string]
+        ? Value
+        : Result extends VariantTypeError<any>
+        ? Result
+        : never
+        : never;
+    
+    type $ParseVariantDict<State extends string, Memo extends Record<string, any> = {}> =
+        string extends State
+        ? VariantTypeError<"$ParseVariantDict: 'string' is not a supported type.">
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [CreateIndexType<Key, Variant<Value extends string ? Value : any>>, State]
+        : VariantTypeError<\`$ParseVariantDict encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseVariantValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseVariantDict encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseVariantArray<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseVariantArray: 'string' is not a supported type.">
+        : State extends \`)\${infer State}\`
+        ? [Memo, State]
+        : $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`\${infer NextValue})\${infer NextState}\`
+        ? $ParseVariantArray<State, [...Memo, Variant<Value extends string ? Value : any>]>
+        : State extends \`)\${infer State}\`
+        ? [[...Memo, Variant<Value extends string ? Value : any>], State]
+        : VariantTypeError<\`$ParseVariantArray encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseVariantValue returned unexpected value for: \${State} (2)\`>;
+    
+    type $ParseVariantKeyValue<State extends string, Memo extends any[] = []> =
+        string extends State
+        ? VariantTypeError<"$ParseVariantKeyValue: 'string' is not a supported type.">
+        : State extends \`}\${infer State}\`
+        ? [Memo, State]
+        : State extends \`\${infer Key}\${''}\${infer State}\`
+        ? $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`]
+        ? State extends \`}\${infer State}\`
+        ? [[...Memo, Variant<Key>, Variant<Value extends string ? Value: any>], State]
+        : VariantTypeError<\`$ParseVariantKeyValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseVariantKeyValue returned unexpected value for: \${State}\`>
+        : VariantTypeError<\`$ParseVariantKeyValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseShallowRootVariantValue<State extends string> =
+        string extends State
+        ? unknown
+        : State extends \`\${\`s\` | \`o\` | \`g\`}\${infer State}\`
+        ? [string, State]
+        : State extends \`\${\`n\` | \`q\` | \`t\` | \`d\` | \`u\` | \`i\` | \`x\` | \`y\`}\${infer State}\`
+        ? [number, State]
+        : State extends \`b\${infer State}\`
+        ? [boolean, State]
+        : State extends \`v\${infer State}\`
+        ? [Variant, State]
+        : State extends \`h\${infer State}\`
+        ? [unknown, State]
+        : State extends \`?\${infer State}\`
+        ? [unknown, State]
+        : State extends \`(\${infer State}\`
+        ? $ParseVariantArray<State>
+        : State extends \`a{\${infer State}\`
+        ? $ParseVariantDict<State>
+        : State extends \`{\${infer State}\`
+        ? $ParseVariantKeyValue<State>
+        : State extends \`ay\${infer State}\` ?
+        [Uint8Array, State]
+        : State extends \`m\${infer State}\`
+        ? $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`]
+          ? [Value | null, State]
+          : VariantTypeError<\`$ParseShallowRootVariantValue encountered an invalid variant string: \${State} (2)\`>
+        : State extends \`a\${infer State}\` ?
+        [Variant<State>[], State]
+        : VariantTypeError<\`$ParseShallowRootVariantValue encountered an invalid variant string: \${State} (1)\`>;
+    
+    type $ParseVariantValue<State extends string> =
+        string extends State
+        ? unknown
+        : State extends \`s\${infer State}\`
+        ? ['s', State]
+        : State extends \`o\${infer State}\`
+        ? ['o', State]
+        : State extends \`g\${infer State}\`
+        ? ['g', State]
+        : State extends \`n\${infer State}\`
+        ? ["n", State]
+        : State extends \`q\${infer State}\`
+        ? ["q", State]
+        : State extends \`t\${infer State}\`
+        ? ["t", State]
+        : State extends \`d\${infer State}\`
+        ? ["d", State]
+        : State extends \`u\${infer State}\`
+        ? ["u", State]
+        : State extends \`i\${infer State}\`
+        ? ["i", State]
+        : State extends \`x\${infer State}\`
+        ? ["x", State]
+        : State extends \`y\${infer State}\`
+        ? ["y", State]
+        : State extends \`b\${infer State}\`
+        ? ['b', State]
+        : State extends \`v\${infer State}\`
+        ? ['v', State]
+        : State extends \`h\${infer State}\`
+        ? ['h', State]
+        : State extends \`?\${infer State}\`
+        ? ['?', State]
+        : State extends \`(\${infer State}\`
+        ? $ParseVariantArray<State>
+        : State extends \`a{\${infer State}\`
+        ? $ParseVariantDict<State>
+        : State extends \`{\${infer State}\`
+        ? $ParseVariantKeyValue<State>
+        : State extends \`ay\${infer State}\` ?
+        [Uint8Array, State]
+        : State extends \`m\${infer State}\`
+        ? $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`]
+          ? [Value | null, State]
+          : VariantTypeError<\`$ParseVariantValue encountered an invalid variant string: \${State} (3)\`>
+        : State extends \`a\${infer State}\` ?
+        $ParseVariantValue<State> extends [infer Value, \`\${infer State}\`] ?
+        [Value[], State]
+        : VariantTypeError<\`$ParseVariantValue encountered an invalid variant string: \${State} (1)\`>
+        : VariantTypeError<\`$ParseVariantValue encountered an invalid variant string: \${State} (2)\`>;
+    
+    type $ParseVariant<T extends string> =
+        $ParseShallowRootVariantValue<T> extends infer Result
+        ? Result extends [infer Value, string]
+        ? Value
+        : Result extends VariantTypeError<any>
+        ? Result
+        : never
+        : never;
+    
+    type $VariantTypeToString<T extends VariantType> = T extends VariantType<infer S> ? S : never;
+
+    export class Variant<S extends string = any> {
+        static $gtype: GObject.GType<Variant>;
+        constructor(sig: S, value: $ParseDeepVariant<typeof sig>);
+        constructor(copy: Variant<S>);
+        _init(sig: S, value: any): Variant<S>;
+        // Constructors
+        static ["new"]<S extends string>(sig: S, value: $ParseDeepVariant<typeof sig>): Variant<S>;
+        static _new_internal<S extends string>(sig: S, value: $ParseDeepVariant<typeof sig>): Variant<S>;
+        static new_array<C extends string = "a?">(
+            child_type: VariantType<C> | null,
+            children: typeof child_type extends VariantType<any>
+              ? Variant<$VariantTypeToString<typeof child_type>>[]
+              : Variant<C>[]
+          ): Variant<\`a\${C}\`>;
+        static new_boolean(value: boolean): Variant<'b'>;
+        static new_byte(value: number): Variant<'y'>;
+        static new_bytestring(string: Uint8Array | string): Variant<'ay'>;
+        static new_bytestring_array(strv: string[]): Variant<'aay'>;
+        static new_dict_entry(key: Variant, value: Variant): Variant<'{vv}'>;
+        static new_double(value: number): Variant<'d'>;
+        static new_fixed_array<C extends string = 'a?'>(element_type: VariantType<C>, elements: Variant<$VariantTypeToString<typeof element_type>>[] | null, n_elements: number, element_size: number): Variant<\`a\${C}\`>;
+        static new_from_bytes<C extends string>(type: VariantType<C>, bytes: Bytes | Uint8Array, trusted: boolean): Variant<C>;
+        static new_from_data<C extends string>(type: VariantType<C>, data: Uint8Array | string, trusted: boolean, user_data?: any | null): Variant<C>;
+        static new_handle(value: number): Variant<'h'>;
+        static new_int16(value: number): Variant<'n'>;
+        static new_int32(value: number): Variant<'i'>;
+        static new_int64(value: number): Variant<'x'>;
+        static new_maybe(child_type?: VariantType | null, child?: Variant | null): Variant<'mv'>;
+        static new_object_path(object_path: string): Variant<'o'>;
+        static new_objv(strv: string[]): Variant<'ao'>;
+        static new_signature(signature: string): Variant<'g'>;
+        static new_string(string: string): Variant<'s'>;
+        static new_strv(strv: string[]): Variant<'as'>;
+        static new_tuple<Items extends (ReadonlyArray<VariantType> | readonly [VariantType])>(children: Items): Variant<\`(\${$ToTuple<Items>})\`>;
+        static new_uint16(value: number): Variant<'q'>;
+        static new_uint32(value: number): Variant<'u'>;
+        static new_uint64(value: number): Variant<'t'>;
+        static new_variant(value: Variant): Variant<'v'>;
+        // Members
+        byteswap(): Variant;
+        check_format_string(format_string: string, copy_only: boolean): boolean;
+        classify(): VariantClass;
+        compare(two: Variant): number;
+        dup_bytestring(): Uint8Array;
+        dup_bytestring_array(): string[];
+        dup_objv(): string[];
+        dup_string(): [string, number];
+        dup_strv(): string[];
+        equal(two: Variant): boolean;
+        get_boolean(): boolean;
+        get_byte(): number;
+        get_bytestring(): Uint8Array;
+        get_bytestring_array(): string[];
+        get_child_value(index_: number): Variant;
+        get_data(): any | null;
+        get_data_as_bytes(): Bytes;
+        get_double(): number;
+        get_handle(): number;
+        get_int16(): number;
+        get_int32(): number;
+        get_int64(): number;
+        get_maybe(): Variant | null;
+        get_normal_form(): Variant;
+        get_objv(): string[];
+        get_size(): number;
+        get_string(): [string, number | null];
+        get_strv(): string[];
+        get_type(): VariantType<S>;
+        get_type_string(): string;
+        get_uint16(): number;
+        get_uint32(): number;
+        get_uint64(): number;
+        get_variant(): Variant;
+        hash(): number;
+        is_container(): boolean;
+        is_floating(): boolean;
+        is_normal_form(): boolean;
+        is_of_type(type: VariantType): boolean;
+        lookup_value(key: string, expected_type?: VariantType | null): Variant;
+        n_children(): number;
+        print(type_annotate: boolean): string;
+        ref(): Variant;
+        ref_sink(): Variant;
+        store(data: any): void;
+        take_ref(): Variant;
+        unref(): void;
+        static is_object_path(string: string): boolean;
+        static is_signature(string: string): boolean;
+        static parse(type: VariantType | null, text: string, limit?: string | null, endptr?: string | null): Variant;
+        static parse_error_print_context(error: Error, source_str: string): string;
+        static parse_error_quark(): Quark;
+        static parser_get_error_quark(): Quark;
+        unpack(): $ParseVariant<S>;
+        deepUnpack(): $ParseDeepVariant<S>;
+        deep_unpack(): $ParseDeepVariant<S>;
+        recursiveUnpack(): $ParseRecursiveVariant<S>;
+    }
+    
+    type $ElementSig<E extends any> =
+        E extends [infer Element] ? Element :
+        E extends [infer Element, ...infer Elements] ? Element | $ElementSig<Elements> :
+        E extends globalThis.Array<infer Element> ? Element : never;
+    
+    export class VariantBuilder<S extends string = 'a*'> {
+        static $gtype: GObject.GType<VariantBuilder>;
+        constructor(type: VariantType<S>);
+        constructor(copy: VariantBuilder<S>);
+        // Constructors
+        static ["new"]<S extends string = 'a*'>(type: VariantType<S>): VariantBuilder<S>;
+        // Members
+        add_value(value: $ElementSig<$ParseDeepVariant<S>>): void;
+        close(): void;
+        end(): Variant<S>;
+        open(type: VariantType): void;
+        ref(): VariantBuilder;
+        unref(): void;
+    }
+    
+    export class VariantDict {
+        static $gtype: GObject.GType<VariantDict>;
+        constructor(from_asv?: Variant | null);
+        constructor(copy: VariantDict);
+        // Constructors
+        static ["new"](from_asv?: Variant | null): VariantDict;
+        // Members
+        clear(): void;
+        contains(key: string): boolean;
+        end(): Variant;
+        insert_value(key: string, value: Variant): void;
+        lookup_value(key: string, expected_type?: VariantType | null): Variant;
+        ref(): VariantDict;
+        remove(key: string): boolean;
+        unref(): void;
+        lookup(key: any, variantType?: any, deep?: boolean): any;
+    }
+    
+    type $ToTuple<T extends readonly VariantType[]> =
+        T extends [] ? '' :
+        T extends [VariantType<infer S>] ? \`\${S}\` :
+        T extends [VariantType<infer S>, ...infer U] ? (
+            U extends [...VariantType[]] ? \`\${S}\${$ToTuple<U>}\` : never) :
+        '?';
+    
+    export class VariantType<S extends string = any> {
+        static $gtype: GObject.GType<VariantType>;
+        constructor(type_string: S);
+        constructor(copy: VariantType<S>);
+        // Constructors
+        static ["new"]<S extends string>(type_string: S): VariantType<S>;
+        static new_array<S extends string>(element: VariantType<S>): VariantType<\`a\${S}\`>;
+        static new_dict_entry<K extends string, V extends string>(key: VariantType<K>, value: VariantType<V>): VariantType<\`{\${K}\${V}}\`>;
+        static new_maybe<S extends string>(element: VariantType<S>): VariantType<\`m\${S}\`>;
+        static new_tuple<Items extends (ReadonlyArray<VariantType> | readonly [VariantType])>(items: Items): VariantType<\`(\${$ToTuple<Items>})\`>;
+        // Members
+        copy(): VariantType<S>;
+        dup_string(): string;
+        element(): VariantType;
+        equal(type2: VariantType): boolean;
+        first(): VariantType;
+        free(): void;
+        get_string_length(): number;
+        hash(): number;
+        is_array(): boolean;
+        is_basic(): boolean;
+        is_container(): boolean;
+        is_definite(): boolean;
+        is_dict_entry(): boolean;
+        is_maybe(): boolean;
+        is_subtype_of(supertype: VariantType): boolean;
+        is_tuple(): boolean;
+        is_variant(): boolean;
+        key(): VariantType;
+        n_items(): number;
+        next(): VariantType;
+        value(): VariantType;
+        static checked_(arg0: string): VariantType;
+        static string_get_depth_(type_string: string): number;
+        static string_is_valid(type_string: string): boolean;
+        static string_scan(string: string, limit?: string | null): [boolean, string | null];
+    }
+    `;
+}
+//# sourceMappingURL=glib.js.map

package/lib/generators/dts/glib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glib.js","sourceRoot":"","sources":["../../../src/generators/dts/glib.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,QAAQ,CAAC,IAA2B;IAChD,6DAA6D;IAC7D,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;IACrC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;IACzC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,MAAM,EAAE,CAAC;IAC5C,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;IAEzC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyfN,CAAC;AACN,CAAC"}

package/lib/generators/dts/gobject.d.ts

@@ -0,0 +1,2 @@
+import { IntrospectedNamespace } from "../../gir/namespace.js";
+export declare function override(node: IntrospectedNamespace): string;

package/lib/generators/dts/gobject.js

@@ -0,0 +1,117 @@
+import { GirDirection } from "@gi.ts/parser";
+import { NativeType, NeverType } from "../../gir.js";
+import { IntrospectedClassFunction, IntrospectedFunctionParameter } from "../../gir/function.js";
+export function override(node) {
+    const ParamSpec = node.assertClass("ParamSpec");
+    // We only inject __type__ for .d.ts files.
+    const type_function = new IntrospectedClassFunction({
+        name: "__type__",
+        parent: ParamSpec,
+        parameters: [
+            new IntrospectedFunctionParameter({
+                name: "arg",
+                type: NeverType,
+                direction: GirDirection.In
+            })
+        ],
+        return_type: new NativeType("A")
+        // TODO: Add support for generic native type replacement.
+        // return_type: UnknownType
+    });
+    ParamSpec.members.push(type_function.copy());
+    return `
+// GJS OVERRIDES
+
+export function registerClass<
+    P extends {},
+    T extends new (...args: any[]) => P,
+    >(
+        klass: T
+    ): RegisteredClass<T, {}, []>;
+
+export type Property<K extends ParamSpec> = K extends ParamSpec<infer T>
+    ? T
+    : any;
+
+export type Properties<
+    Prototype extends {},
+    Properties extends { [key: string]: ParamSpec }
+    > = Omit<{
+        [key in (keyof Properties | keyof Prototype)]: key extends keyof Prototype ? never :
+        key extends keyof Properties ? Property<Properties[key]> : never;
+    }, keyof Prototype>;
+
+export type SignalDefinition = {
+    param_types?: readonly GType[];
+    [key: string]: any;
+};
+
+type UnionToIntersection<T> =
+    (T extends any ? (x: T) => any : never) extends
+    (x: infer R) => any ? R : never
+
+type IFaces<Interfaces extends { $gtype: GType<any> }[]> = { [key in keyof Interfaces]: Interfaces[key] extends { $gtype: GType<infer I> } ? I : never };
+
+export type RegisteredPrototype<P extends {}, Props extends { [key: string]: ParamSpec }, Interfaces extends any[]> =
+    Properties<P, SnakeToCamel<Props> & SnakeToUnderscore<Props>> & UnionToIntersection<Interfaces[number]> & P;
+
+type SnakeToUnderscoreCase<S extends string> =
+    S extends \`\${infer T}-\${infer U}\` ? \`\${T}_\${SnakeToUnderscoreCase<U>}\` :
+    S extends \`\${infer T}\` ? \`\${T}\` :
+    never;
+
+type SnakeToCamelCase<S extends string> =
+    S extends \`\${infer T}-\${infer U}\` ? \`\${Lowercase<T>}\${SnakeToPascalCase<U>}\` :
+    S extends \`\${infer T}\` ? \`\${Lowercase<T>}\` :
+    SnakeToPascalCase<S>;
+
+type SnakeToPascalCase<S extends string> =
+    string extends S ? string :
+    S extends \`\${infer T}-\${infer U}\` ? \`\${Capitalize<Lowercase<T>>}\${SnakeToPascalCase<U>}\` :
+    S extends \`\${infer T}\` ? \`\${Capitalize<Lowercase<T>>}\` :
+    never;
+
+type SnakeToCamel<T> = { [P in keyof T as P extends string ? SnakeToCamelCase<P> : P]: T[P] };
+type SnakeToUnderscore<T> = { [P in keyof T as P extends string ? SnakeToUnderscoreCase<P> : P]: T[P] };
+
+type Ctor = new (...a: any[]) => object;
+
+type Init = { _init(...args: any[]): void };
+
+export type RegisteredClass<
+    T extends Ctor,
+    Props extends { [key: string]: ParamSpec },
+    Interfaces extends { $gtype: GType<any> }[]
+    > = T extends { prototype: infer P } ? {
+        $gtype: GType<RegisteredClass<T, Props, IFaces<Interfaces>>>;
+        new(...args: P extends Init ? Parameters<P["_init"]> : [void]): RegisteredPrototype<P, Props, IFaces<Interfaces>>;
+        prototype: RegisteredPrototype<P, Props, IFaces<Interfaces>>;
+    } : never;
+
+export function registerClass<
+    T extends Ctor,
+    Props extends { [key: string]: ParamSpec },
+    Interfaces extends { $gtype: GType }[],
+    Sigs extends {
+        [key: string]: {
+            param_types?: readonly GType[];
+            [key: string]: any;
+        }
+    }
+>(
+    options: {
+        GTypeName?: string;
+        GTypeFlags?: TypeFlags;
+        Properties?: Props;
+        Signals?: Sigs;
+        Implements?: Interfaces;
+        CssName?: string;
+        Template?: string;
+        Children?: string[];
+        InternalChildren?: string[];
+    },
+    klass: T
+): RegisteredClass<T, Props, Interfaces>;
+`;
+}
+//# sourceMappingURL=gobject.js.map

package/lib/generators/dts/gobject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gobject.js","sourceRoot":"","sources":["../../../src/generators/dts/gobject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAGjG,MAAM,UAAU,QAAQ,CAAC,IAA2B;IAChD,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IAEhD,2CAA2C;IAC3C,MAAM,aAAa,GAAG,IAAI,yBAAyB,CAAC;QAChD,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,SAAS;QACjB,UAAU,EAAE;YACR,IAAI,6BAA6B,CAAC;gBAC9B,IAAI,EAAE,KAAK;gBACX,IAAI,EAAE,SAAS;gBACf,SAAS,EAAE,YAAY,CAAC,EAAE;aAC7B,CAAC;SACL;QACD,WAAW,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC;QAChC,yDAAyD;QACzD,2BAA2B;KAC9B,CAAC,CAAC;IAEH,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC;IAE7C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6FV,CAAC;AACF,CAAC"}

package/lib/generators/dts-inline.d.ts

@@ -0,0 +1,8 @@
+import { IntrospectedNamespace } from "../gir/namespace.js";
+import { GenerationOptions } from "../types.js";
+import { DtsGenerator } from "./dts.js";
+export declare class DtsInlineGenerator extends DtsGenerator {
+    constructor(namespace: IntrospectedNamespace, options: GenerationOptions);
+    generateNamespace(node: IntrospectedNamespace): Promise<string | null>;
+    stringifyNamespace(node: IntrospectedNamespace): Promise<string | null>;
+}