@girs/gom-1.0 1.0.0-4.0.0

package/README.md

@@ -0,0 +1,104 @@
+
+# Gom-1.0
+
+![version](https://img.shields.io/npm/v/@girs/gom-1.0)
+![downloads/week](https://img.shields.io/npm/dw/@girs/gom-1.0)
+
+
+GJS TypeScript type definitions for Gom-1.0, generated from library version 1.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0.
+
+
+## Install
+
+To use this type definitions, install them with NPM:
+```bash
+npm install @girs/gom-1.0
+```
+
+## Usage
+
+You can import this package into your project like this:
+```ts
+import Gom from '@girs/gom-1.0';
+```
+
+Or if you prefer CommonJS, you can also use this:
+```ts
+const Gom = require('@girs/gom-1.0');
+```
+
+### Ambient Modules
+
+You can also use [ambient modules](https://github.com/gjsify/ts-for-gir/tree/main/packages/cli#ambient-modules) to import this module like you would do this in JavaScript.
+For this you need to include `@girs/gom-1.0` or `@girs/gom-1.0/ambient` in your `tsconfig` or entry point Typescript file:
+
+`index.ts`:
+```ts
+import '@girs/gom-1.0'
+```
+
+`tsconfig.json`:
+```json
+{
+  "compilerOptions": {
+    ...
+  },
+  "include": ["@girs/gom-1.0"],
+  ...
+}
+```
+
+Now you can import the ambient module with TypeScript support: 
+
+```ts
+import Gom from 'gi://Gom?version=1.0';
+```
+
+### Global import
+
+You can also import the module with Typescript support using the global `imports.gi` object of GJS.
+For this you need to include `@girs/gom-1.0` or `@girs/gom-1.0/import` in your `tsconfig` or entry point Typescript file:
+
+`index.ts`:
+```ts
+import '@girs/gom-1.0'
+```
+
+`tsconfig.json`:
+```json
+{
+  "compilerOptions": {
+    ...
+  },
+  "include": ["@girs/gom-1.0"],
+  ...
+}
+```
+
+Now you have also type support for this, too:
+
+```ts
+const Gom = imports.gi.Gom;
+```
+
+
+### ESM vs. CommonJS
+
+GJS supports two different import syntaxes. The new modern ESM syntax and the old global imports syntax.
+
+In TypeScript projects for GJS and GNOME Shell extensions, you have the flexibility to use `ESM` syntax and then decide the import syntax for your bundled file. If your bundler is configured to use `CommonJS`, it will convert to the GJS-specific global imports syntax, like `const moduleName = imports.gi[moduleName]`. This is different from the traditional `require` syntax seen in Node.js. The global imports syntax is chosen because it aligns with the CommonJS format supported by NPM, which is used for the generated type definitions and this package.
+
+On the other hand, if you configure your bundler to use ESM, it will retain the ESM import syntax. It's crucial to ensure that your bundler is set up to correctly translate and bundle these imports into either CommonJS or ESM format, depending on your project's requirements.
+
+This approach is particularly important due to the `@girs` types, which include both `*.cjs `files, using the GJS global imports syntax, and `*.js` files, which utilize the ESM syntax. By appropriately setting up your bundler, you can control which syntax—CommonJS or ESM—is used in your project. The choice of CommonJS in this context is also due to the similarity between the GJS-specific global imports and CommonJS syntax, allowing for easier management and bundling in these specific types of projects.
+
+Since GNOME Shell 45, you should only use ESM, even for GNOME Shell extensions. Before that, extensions had to use the global import syntax, unlike normal GJS applications, where ESM has been available for some time.
+
+### Bundle
+
+Depending on your project configuration, it is recommended to use a bundler like [esbuild](https://esbuild.github.io/). You can find examples using different bundlers [here](https://github.com/gjsify/ts-for-gir/tree/main/examples).
+
+## Other packages
+
+All existing pre-generated packages can be found on [gjsify/types](https://github.com/gjsify/types).
+

package/gom-1.0-ambient.d.ts

@@ -0,0 +1,12 @@
+
+declare module 'gi://Gom?version=1.0' {
+    import Gom from '@girs/gom-1.0';
+    export default Gom;
+}
+
+declare module 'gi://Gom' {
+    import Gom10 from 'gi://Gom?version=1.0';
+    export default Gom10;
+}
+
+

package/gom-1.0-ambient.js

@@ -0,0 +1,2 @@
+export {}
+

package/gom-1.0-import.d.ts

@@ -0,0 +1,12 @@
+
+import Gom10 from '@girs/gom-1.0';
+
+declare global {
+    export interface GjsGiImports {
+        Gom: typeof Gom10;
+    }
+}
+
+export default GjsGiImports;
+
+

package/gom-1.0-import.js

@@ -0,0 +1,3 @@
+const gi = globalThis.imports?.gi || {};
+export default gi;
+

package/gom-1.0.d.ts

@@ -0,0 +1,784 @@
+/*
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ */
+
+import './gom-1.0-ambient.d.ts';
+
+/**
+ * Gom-1.0
+ */
+
+import type Gio from '@girs/gio-2.0';
+import type GObject from '@girs/gobject-2.0';
+import type GLib from '@girs/glib-2.0';
+
+export namespace Gom {
+    class Error extends GLib.Error {
+        static $gtype: GObject.GType<Error>;
+
+        // Static fields of Gom.Error
+
+        static ADAPTER_OPEN: number;
+        static COMMAND_NO_SQL: number;
+        static COMMAND_SQLITE: number;
+        static REPOSITORY_EMPTY_RESULT: number;
+        static RESOURCE_CURSOR: number;
+
+        // Constructors of Gom.Error
+
+        constructor(options: { message: string; code: number });
+        _init(...args: any[]): void;
+
+        // Own static methods of Gom.Error
+
+        static quark(): GLib.Quark;
+    }
+
+    enum FilterMode {
+        SQL,
+        OR,
+        AND,
+        EQ,
+        NEQ,
+        GT,
+        GTE,
+        LT,
+        LTE,
+        LIKE,
+        GLOB,
+        IS_NULL,
+        IS_NOT_NULL,
+    }
+    enum SortingMode {
+        ASCENDING,
+        DESCENDING,
+    }
+    function error_quark(): GLib.Quark;
+    interface AdapterCallback {
+        (adapter: Adapter): void;
+    }
+    interface RepositoryMigrator {
+        (repository: Repository, adapter: Adapter, version: number): boolean;
+    }
+    interface ResourceFromBytesFunc {
+        (bytes: GLib.Bytes | Uint8Array, value: GObject.Value | any): void;
+    }
+    interface ResourceToBytesFunc {
+        (value: GObject.Value | any): GLib.Bytes;
+    }
+    module Adapter {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {}
+    }
+
+    class Adapter extends GObject.Object {
+        static $gtype: GObject.GType<Adapter>;
+
+        // Constructors of Gom.Adapter
+
+        constructor(properties?: Partial<Adapter.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        static ['new'](): Adapter;
+
+        // Own methods of Gom.Adapter
+
+        close_async(callback?: Gio.AsyncReadyCallback<this> | null): void;
+        close_finish(result: Gio.AsyncResult): boolean;
+        close_sync(): boolean;
+        /**
+         * This is a helper function to make simple execution of SQL easier.
+         * It is primarily meant for things like "BEGIN;" and "COMMIT;".
+         *
+         * This MUST be called from within a write transaction using
+         * gom_adapter_queue_write().
+         * @param sql SQL to execute.
+         * @returns %TRUE if successful;
+         */
+        execute_sql(sql: string): boolean;
+        /**
+         * Fetches the sqlite3 structure used by the adapter.
+         * @returns A handle to the #sqlite3 structure. Side effects: None.
+         */
+        get_handle(): any | null;
+        /**
+         * Opens the database pointed to by `uri`. `uri` can be in any format understood
+         * by SQLite. See <ulink type="http" url="http://www.sqlite.org/c3ref/open.html">http://www.sqlite.org/c3ref/open.html</ulink>
+         * for details.
+         * @param uri a URI understood by SQLite
+         * @param callback the function to call when the operation finished, or %NULL
+         */
+        open_async(uri: string, callback?: Gio.AsyncReadyCallback<this> | null): void;
+        open_finish(result: Gio.AsyncResult): boolean;
+        open_sync(uri: string): boolean;
+        /**
+         * Queues a callback to be executed within the SQLite thread. The callback is
+         * expected to perform reads only.
+         * @param callback A callback to execute read queries on SQLite.
+         */
+        queue_read(callback: AdapterCallback): void;
+        /**
+         * Queues a callback to be executed within the SQLite thwrite. The callback can
+         * perform reads and writes.
+         * @param callback A callback to execute write queries on SQLite.
+         */
+        queue_write(callback: AdapterCallback): void;
+    }
+
+    module Command {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            adapter: Adapter;
+            sql: string;
+        }
+    }
+
+    class Command extends GObject.Object {
+        static $gtype: GObject.GType<Command>;
+
+        // Own properties of Gom.Command
+
+        get adapter(): Adapter;
+        set sql(val: string);
+
+        // Constructors of Gom.Command
+
+        constructor(properties?: Partial<Command.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own methods of Gom.Command
+
+        execute(cursor: Cursor): boolean;
+        get_param_index(param_name: string): number;
+        reset(): void;
+        set_param(param: number, value: GObject.Value | any): void;
+        set_param_double(param: number, value: number): void;
+        set_param_float(param: number, value: number): void;
+        set_param_int(param: number, value: number): void;
+        set_param_int64(param: number, value: number): void;
+        set_param_string(param: number, value: string): void;
+        set_param_uint(param: number, value: number): void;
+        set_param_uint64(param: number, value: number): void;
+        set_sql(sql: string): void;
+    }
+
+    module CommandBuilder {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            adapter: Adapter;
+            filter: Filter;
+            limit: number;
+            m2m_table: string;
+            m2mTable: string;
+            m2m_type: GObject.GType;
+            m2mType: GObject.GType;
+            offset: number;
+            resource_type: GObject.GType;
+            resourceType: GObject.GType;
+            sorting: Sorting;
+        }
+    }
+
+    class CommandBuilder extends GObject.Object {
+        static $gtype: GObject.GType<CommandBuilder>;
+
+        // Own properties of Gom.CommandBuilder
+
+        get adapter(): Adapter;
+        get filter(): Filter;
+        set filter(val: Filter);
+        get limit(): number;
+        set limit(val: number);
+        get m2m_table(): string;
+        get m2mTable(): string;
+        get m2m_type(): GObject.GType;
+        get m2mType(): GObject.GType;
+        get offset(): number;
+        set offset(val: number);
+        get resource_type(): GObject.GType;
+        set resource_type(val: GObject.GType);
+        get resourceType(): GObject.GType;
+        set resourceType(val: GObject.GType);
+        get sorting(): Sorting;
+        set sorting(val: Sorting);
+
+        // Constructors of Gom.CommandBuilder
+
+        constructor(properties?: Partial<CommandBuilder.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own methods of Gom.CommandBuilder
+
+        /**
+         * Builds a new command that will count the number of rows matching the
+         * current query parameters.
+         * @returns A #GomCommand.
+         */
+        build_count(): Command;
+        /**
+         * Builds a list of #GomCommand to update the table for the
+         * resource_type associated with `builder` up to `version`.
+         * @param version the version of the database.
+         * @returns A #GList of #GomCommand.
+         */
+        build_create(version: number): Command[];
+        /**
+         * Builds a new #GomCommand to delete the rows matching the current query
+         * params.
+         * @returns A #GomCommand.
+         */
+        build_delete(): Command;
+        /**
+         * Builds a new #GomCommand that will insert the parameters of the resource
+         * into the underlying database.
+         * @param resource a #GomResource
+         * @returns A #GomCommand.
+         */
+        build_insert(resource: Resource): Command;
+        /**
+         * Builds a #GomCommand that will select all the rows matching the current
+         * query params.
+         * @returns A #GomCommand.
+         */
+        build_select(): Command;
+        /**
+         * Builds a new #GomCommand that will update the contents stored for `resource`
+         * in the underlying database.
+         * @param resource a #GomResource
+         * @returns A #GomCommand.
+         */
+        build_update(resource: Resource): Command;
+    }
+
+    module Cursor {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            statement: any;
+        }
+    }
+
+    class Cursor extends GObject.Object {
+        static $gtype: GObject.GType<Cursor>;
+
+        // Own properties of Gom.Cursor
+
+        get statement(): any;
+
+        // Constructors of Gom.Cursor
+
+        constructor(properties?: Partial<Cursor.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own methods of Gom.Cursor
+
+        get_column(column: number, value: GObject.Value | any): void;
+        get_column_boolean(column: number): boolean;
+        get_column_double(column: number): number;
+        get_column_float(column: number): number;
+        get_column_int(column: number): number;
+        get_column_int64(column: number): number;
+        get_column_name(column: number): string;
+        get_column_string(column: number): string;
+        get_column_uint(column: number): number;
+        get_column_uint64(column: number): number;
+        get_n_columns(): number;
+        next(): boolean;
+    }
+
+    module Filter {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
+            mode: FilterMode;
+            sql: string;
+        }
+    }
+
+    class Filter extends GObject.InitiallyUnowned {
+        static $gtype: GObject.GType<Filter>;
+
+        // Own properties of Gom.Filter
+
+        get mode(): FilterMode;
+        set sql(val: string);
+
+        // Constructors of Gom.Filter
+
+        constructor(properties?: Partial<Filter.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        static new_and(left: Filter, right: Filter): Filter;
+
+        static new_and_fullv(filter_array: Filter): Filter;
+
+        static new_eq(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_glob(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_gt(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_gte(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_is_not_null(resource_type: GObject.GType, property_name: string): Filter;
+
+        static new_is_null(resource_type: GObject.GType, property_name: string): Filter;
+
+        static new_like(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_lt(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_lte(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_neq(resource_type: GObject.GType, property_name: string, value: GObject.Value | any): Filter;
+
+        static new_or(left: Filter, right: Filter): Filter;
+
+        static new_or_fullv(filter_array: Filter): Filter;
+
+        static new_sql(sql: string, values: (GObject.Value | any)[]): Filter;
+
+        // Own methods of Gom.Filter
+
+        get_sql(table_map: { [key: string]: any } | GLib.HashTable<any, any>): string;
+        /**
+         * Fetches the list of values that should be applied in order when building
+         * the #GomCommand.
+         * @returns An array of values for the SQL.
+         */
+        get_values(): unknown[];
+    }
+
+    module Repository {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            adapter: Adapter;
+        }
+    }
+
+    class Repository extends GObject.Object {
+        static $gtype: GObject.GType<Repository>;
+
+        // Own properties of Gom.Repository
+
+        get adapter(): Adapter;
+
+        // Constructors of Gom.Repository
+
+        constructor(properties?: Partial<Repository.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        static ['new'](adapter: Adapter): Repository;
+
+        // Own methods of Gom.Repository
+
+        /**
+         * Performs an automatic migration on the underlying database. See
+         * gom_repository_automatic_migrate_sync() for details.
+         *
+         * Upon completion, `callback` will be executed and it must call
+         * gom_repository_automatic_migrate_finish().
+         * @param version The version to migrate to.
+         * @param object_types a #GList of #GType
+         * @param callback A callback to execute upon completion.
+         */
+        automatic_migrate_async(
+            version: number,
+            object_types: GObject.GType[],
+            callback?: Gio.AsyncReadyCallback<this> | null,
+        ): void;
+        automatic_migrate_finish(result: Gio.AsyncResult): boolean;
+        /**
+         * Performs an automatic migration on the underlying database. For
+         * each of the #GType passed in `object_types,` the table will be
+         * created if necessary, and each of the columns corresponding to
+         * properties will be added if needed.
+         * @param version The version to migrate to.
+         * @param object_types a #GList of #GType
+         * @returns #TRUE in case of success.
+         */
+        automatic_migrate_sync(version: number, object_types: GObject.GType[]): boolean;
+        find_async(resource_type: GObject.GType, filter: Filter, callback?: Gio.AsyncReadyCallback<this> | null): void;
+        /**
+         * Completes an asynchronous request to fetch a group of resources.
+         * @param result A #GAsyncResult.
+         * @returns A #GomResourceGroup.
+         */
+        find_finish(result: Gio.AsyncResult): ResourceGroup;
+        find_one_async(
+            resource_type: GObject.GType,
+            filter: Filter,
+            callback?: Gio.AsyncReadyCallback<this> | null,
+        ): void;
+        /**
+         * Completes an asynchronous request to find a single resource in the
+         * repository. See gom_repository_find_one_async() for more info.
+         * @param result A #GAsyncResult.
+         * @returns A #GomResource if successful, otherwise %NULL.
+         */
+        find_one_finish(result: Gio.AsyncResult): Resource;
+        /**
+         * Synchronous version of gom_repository_find_async().
+         * @param resource_type A #GType of the resource to lookup.
+         * @param filter A #GomFilter to apply to your search.
+         * @returns A #GomResource or %NULL.
+         */
+        find_one_sync(resource_type: GObject.GType, filter?: Filter | null): Resource;
+        find_sorted_async(
+            resource_type: GObject.GType,
+            filter: Filter,
+            sorting: Sorting,
+            callback?: Gio.AsyncReadyCallback<this> | null,
+        ): void;
+        /**
+         * Synchronously queries the #GomRepository for objects matching the
+         * requested query. This must only be run from a callback provided to
+         * gom_adapter_queue_read().
+         * @param resource_type The #GType of the resources to query.
+         * @param filter An optional filter for the query.
+         * @param sorting An optional #GomSorting to order the query                              results.
+         * @returns A #GomResourceGroup or %NULL.
+         */
+        find_sorted_sync(resource_type: GObject.GType, filter?: Filter | null, sorting?: Sorting | null): ResourceGroup;
+        /**
+         * Synchronously queries the #GomRepository for objects matching the
+         * requested query. This must only be run from a callback provided to
+         * gom_adapter_queue_read().
+         * @param resource_type The #GType of the resources to query.
+         * @param filter An optional filter for the query.
+         * @returns A #GomResourceGroup or %NULL.
+         */
+        find_sync(resource_type: GObject.GType, filter?: Filter | null): ResourceGroup;
+        /**
+         * Fetches the underlying adapter.
+         * @returns A #GomAdapter.
+         */
+        get_adapter(): Adapter;
+        /**
+         * Asynchronously performs a migration on the underlying database. This will
+         * call `migrator` from the SQLite thread for each migration to perform.
+         *
+         * Upon completion, `callback` will be executed and it must call
+         * gom_repository_migrate_finish().
+         * @param version The version to migrate to.
+         * @param migrator A function to perform the migrations.
+         * @param callback A callback to execute upon completion.
+         */
+        migrate_async(
+            version: number,
+            migrator: RepositoryMigrator,
+            callback?: Gio.AsyncReadyCallback<this> | null,
+        ): void;
+        migrate_finish(result: Gio.AsyncResult): boolean;
+        /**
+         * Performs a migration on the underlying database. This will
+         * call `migrator` from the SQLite thread for each migration to perform.
+         * @param version The version to migrate to.
+         * @param migrator A function to perform the migrations.
+         * @returns #TRUE in case of success.
+         */
+        migrate_sync(version: number, migrator: RepositoryMigrator): boolean;
+    }
+
+    module Resource {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            repository: Repository;
+        }
+    }
+
+    abstract class Resource extends GObject.Object {
+        static $gtype: GObject.GType<Resource>;
+
+        // Own properties of Gom.Resource
+
+        get repository(): Repository;
+        set repository(val: Repository);
+
+        // Constructors of Gom.Resource
+
+        constructor(properties?: Partial<Resource.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own static methods of Gom.Resource
+
+        static from_bytes_func_quark(): GLib.Quark;
+        static new_in_version_quark(): GLib.Quark;
+        static not_mapped_quark(): GLib.Quark;
+        static notnull(): GLib.Quark;
+        static ref_property_name(): GLib.Quark;
+        static ref_table_class(): GLib.Quark;
+        static to_bytes_func_quark(): GLib.Quark;
+        static unique(): GLib.Quark;
+        static set_notnull(property_name: string): void;
+        static set_primary_key(primary_key: string): void;
+        static set_property_from_bytes(property_name: string, from_bytes_func: ResourceFromBytesFunc): void;
+        static set_property_new_in_version(property_name: string, version: number): void;
+        static set_property_set_mapped(property_name: string, is_mapped: boolean): void;
+        static set_property_to_bytes(property_name: string, to_bytes_func: ResourceToBytesFunc): void;
+        static set_reference(property_name: string, ref_table_name: string, ref_property_name: string): void;
+        static set_table(table: string): void;
+        static set_unique(property_name: string): void;
+
+        // Own methods of Gom.Resource
+
+        delete_async(callback?: Gio.AsyncReadyCallback<this> | null): void;
+        delete_finish(result: Gio.AsyncResult): boolean;
+        /**
+         * Synchronously deletes a resource. This may only be called from inside a
+         * callback to gom_adapter_queue_write().
+         * @returns %TRUE if successful; otherwise %FALSE and @error is set.
+         */
+        delete_sync(): boolean;
+        fetch_m2m_async(
+            resource_type: GObject.GType,
+            m2m_table: string,
+            filter: Filter,
+            callback?: Gio.AsyncReadyCallback<this> | null,
+        ): void;
+        /**
+         * Completes the asynchronous request to fetch a group of resources that
+         * are related to the resource through a many-to-many table.
+         * @param result A #GAsyncResult.
+         * @returns A #GomResourceGroup.
+         */
+        fetch_m2m_finish(result: Gio.AsyncResult): ResourceGroup;
+        save_async(callback?: Gio.AsyncReadyCallback<this> | null): void;
+        save_finish(result: Gio.AsyncResult): boolean;
+        save_sync(): boolean;
+    }
+
+    module ResourceGroup {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            count: number;
+            filter: Filter;
+            is_writable: boolean;
+            isWritable: boolean;
+            m2m_table: string;
+            m2mTable: string;
+            m2m_type: GObject.GType;
+            m2mType: GObject.GType;
+            repository: Repository;
+            resource_type: GObject.GType;
+            resourceType: GObject.GType;
+            sorting: Sorting;
+        }
+    }
+
+    class ResourceGroup extends GObject.Object {
+        static $gtype: GObject.GType<ResourceGroup>;
+
+        // Own properties of Gom.ResourceGroup
+
+        get count(): number;
+        get filter(): Filter;
+        get is_writable(): boolean;
+        get isWritable(): boolean;
+        get m2m_table(): string;
+        get m2mTable(): string;
+        get m2m_type(): GObject.GType;
+        get m2mType(): GObject.GType;
+        get repository(): Repository;
+        get resource_type(): GObject.GType;
+        get resourceType(): GObject.GType;
+        get sorting(): Sorting;
+
+        // Constructors of Gom.ResourceGroup
+
+        constructor(properties?: Partial<ResourceGroup.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        static ['new'](repository: Repository): ResourceGroup;
+
+        // Own methods of Gom.ResourceGroup
+
+        append(resource: Resource): boolean;
+        delete_async(callback?: Gio.AsyncReadyCallback<this> | null): void;
+        delete_finish(result: Gio.AsyncResult): boolean;
+        delete_sync(): boolean;
+        fetch_async(index_: number, count: number, callback?: Gio.AsyncReadyCallback<this> | null): void;
+        fetch_finish(result: Gio.AsyncResult): boolean;
+        /**
+         * Fetches a sequence of resources from the group synchronously. This must
+         * be called from an adapter read callback using gom_adapter_queue_read().
+         * @param index_ The first index to fetch.
+         * @param count The number of indexes to fetch.
+         * @returns %TRUE if successful; otherwise %FALSE and @error is set.
+         */
+        fetch_sync(index_: number, count: number): boolean;
+        get_count(): number;
+        /**
+         * Fetches the resource at `index_`. You must have loaded that resource by
+         * calling gom_resource_group_fetch_async() with a range inclusive of the
+         * index.
+         * @param index_ The index of the resource.
+         * @returns A #GomResource.
+         */
+        get_index(index_: number): Resource;
+        get_m2m_table(): string;
+        write_async(callback?: Gio.AsyncReadyCallback<this> | null): void;
+        write_finish(result: Gio.AsyncResult): boolean;
+        write_sync(): boolean;
+    }
+
+    module Sorting {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {}
+    }
+
+    class Sorting extends GObject.InitiallyUnowned {
+        static $gtype: GObject.GType<Sorting>;
+
+        // Constructors of Gom.Sorting
+
+        constructor(properties?: Partial<Sorting.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own methods of Gom.Sorting
+
+        /**
+         * Add a new ORDER BY clause to the sorting object.
+         *
+         * This allows chaining ORDER BY clauses, adding them one at a time, rather
+         * than passing them all to the constructor.
+         *
+         * Example:
+         *
+         * ```c
+         *     GomSorting *sorting = g_object_new (GOM_TYPE_SORTING, NULL);
+         *     gom_sorting_add (sorting, EPISODE_TYPE_RESOURCE, "season-number",
+         *                      GOM_SORTING_DESCENDING);
+         *     gom_sorting_add (sorting, EPISODE_TYPE_RESOURCE, "episode-number",
+         *                      GOM_SORTING_ASCENDING);
+         * ```
+         *
+         *
+         * The above example maps to the following SQL statement:
+         *
+         * ```<!-- language="SQL" -->
+         *     ORDER BY 'episodes'.'season-number' DESC, 'episodes'.'episode-number'
+         * ```
+         *
+         * @param resource_type A subclass of #GomResource.
+         * @param property_name A string.
+         * @param sorting_mode A #GomSortingMode.
+         */
+        add(resource_type: GObject.GType, property_name: string, sorting_mode: SortingMode): void;
+        get_sql(table_map: { [key: string]: any } | GLib.HashTable<any, any>): string;
+    }
+
+    type AdapterClass = typeof Adapter;
+    abstract class AdapterPrivate {
+        static $gtype: GObject.GType<AdapterPrivate>;
+
+        // Constructors of Gom.AdapterPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type CommandBuilderClass = typeof CommandBuilder;
+    abstract class CommandBuilderPrivate {
+        static $gtype: GObject.GType<CommandBuilderPrivate>;
+
+        // Constructors of Gom.CommandBuilderPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type CommandClass = typeof Command;
+    abstract class CommandPrivate {
+        static $gtype: GObject.GType<CommandPrivate>;
+
+        // Constructors of Gom.CommandPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type CursorClass = typeof Cursor;
+    abstract class CursorPrivate {
+        static $gtype: GObject.GType<CursorPrivate>;
+
+        // Constructors of Gom.CursorPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type FilterClass = typeof Filter;
+    abstract class FilterPrivate {
+        static $gtype: GObject.GType<FilterPrivate>;
+
+        // Constructors of Gom.FilterPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type RepositoryClass = typeof Repository;
+    abstract class RepositoryPrivate {
+        static $gtype: GObject.GType<RepositoryPrivate>;
+
+        // Constructors of Gom.RepositoryPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type ResourceClass = typeof Resource;
+    type ResourceGroupClass = typeof ResourceGroup;
+    abstract class ResourceGroupPrivate {
+        static $gtype: GObject.GType<ResourceGroupPrivate>;
+
+        // Constructors of Gom.ResourceGroupPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    abstract class ResourcePrivate {
+        static $gtype: GObject.GType<ResourcePrivate>;
+
+        // Constructors of Gom.ResourcePrivate
+
+        _init(...args: any[]): void;
+    }
+
+    type SortingClass = typeof Sorting;
+    abstract class SortingPrivate {
+        static $gtype: GObject.GType<SortingPrivate>;
+
+        // Constructors of Gom.SortingPrivate
+
+        _init(...args: any[]): void;
+    }
+
+    /**
+     * Name of the imported GIR library
+     * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+     */
+    const __name__: string;
+    /**
+     * Version of the imported GIR library
+     * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+     */
+    const __version__: string;
+}
+
+export default Gom;
+// END

package/gom-1.0.js

@@ -0,0 +1,6 @@
+
+  // @ts-expect-error
+  import Gom from 'gi://Gom?version=1.0';
+  export { Gom };
+  export default Gom;
+

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@girs/gom-1.0",
+  "version": "1.0.0-4.0.0",
+  "description": "GJS TypeScript type definitions for Gom-1.0, generated from library version 1.0.0",
+  "type": "module",
+  "module": "gom-1.0.js",
+  "main": "gom-1.0.js",
+  "exports": {
+    "./ambient": {
+      "types": "./gom-1.0-ambient.d.ts",
+      "import": "./gom-1.0-ambient.js",
+      "default": "./gom-1.0-ambient.js"
+    },
+    "./import": {
+      "types": "./gom-1.0-import.d.ts",
+      "import": "./gom-1.0-import.js",
+      "default": "./gom-1.0-import.js"
+    },
+    ".": {
+      "types": "./gom-1.0.d.ts",
+      "import": "./gom-1.0.js",
+      "default": "./gom-1.0.js"
+    }
+  },
+  "scripts": {
+    "test": "NODE_OPTIONS=--max_old_space_size=9216 tsc --noEmit gom-1.0.d.ts"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "^2.77.0-4.0.0-beta.1",
+    "@girs/gjs": "^4.0.0-beta.1",
+    "@girs/glib-2.0": "^2.77.0-4.0.0-beta.1",
+    "@girs/gobject-2.0": "^2.77.0-4.0.0-beta.1"
+  },
+  "devDependencies": {
+    "typescript": "*"
+  },
+  "keywords": [
+    "Gir",
+    "TypeScript",
+    "types",
+    "GObject-Introspection",
+    "GJS",
+    "Gom-1.0"
+  ],
+  "author": "ts-for-gir",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gjsify/ts-for-gir.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gjsify/ts-for-gir/issues"
+  },
+  "homepage": "https://github.com/gjsify/types/tree/main/gom-1.0#readme"
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    // General settings for code interpretation
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext"],
+    "types": [],
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noEmitOnError": false,
+    "baseUrl": "./",
+    "rootDir": ".",
+    // General settings for code generation
+    "removeComments": false,
+    "inlineSourceMap": false,
+    "inlineSources": false,
+    "newLine": "LF"
+  },
+  "include": ["./gom-1.0.d.ts"]
+}
+
+

package/typedoc.json

@@ -0,0 +1,7 @@
+{
+    "entryPoints": ["./gom-1.0.d.ts"],
+    "readme": "./README.md",
+    "name": "Gom-1.0",
+    "tsconfig": "./tsconfig.json"
+}
+