@girs/gda-5.0 5.0.0-4.0.0-beta.2 → 5.0.0-4.0.0-beta.3

package/README.md

@@ -5,7 +5,7 @@
 ![downloads/week](https://img.shields.io/npm/dw/@girs/gda-5.0)
 
 
-GJS TypeScript type definitions for Gda-5.0, generated from library version 5.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0-beta.2.
+GJS TypeScript type definitions for Gda-5.0, generated from library version 5.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0-beta.3.
 
 
 ## Install
@@ -22,11 +22,6 @@ You can import this package into your project like this:
 import Gda from '@girs/gda-5.0';
 ```
 
-Or if you prefer CommonJS, you can also use this:
-```ts
-const Gda = require('@girs/gda-5.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.
@@ -81,19 +76,6 @@ Now you have also type support for this, too:
 const Gda = imports.gi.Gda;
 ```
 
-
-### 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).

package/gda-5.0.d.ts

@@ -3318,7 +3318,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -4491,7 +4491,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -5672,7 +5672,1084 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
+         *                                              0, 100,
+         *                                              50,
+         *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+         *     g_object_class_install_property (gobject_class,
+         *                                      PROP_FOO,
+         *                                      properties[PROP_FOO]);
+         *   }
+         * ```
+         *
+         *
+         * and then notify a change on the "foo" property with:
+         *
+         *
+         * ```c
+         *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+         * ```
+         *
+         * @param pspec the #GParamSpec of a property installed on the class of @object.
+         */
+        notify_by_pspec(pspec: GObject.ParamSpec): void;
+        /**
+         * Increases the reference count of `object`.
+         *
+         * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+         * of `object` will be propagated to the return type (using the GCC typeof()
+         * extension), so any casting the caller needs to do on the return type must be
+         * explicit.
+         * @returns the same @object
+         */
+        ref(): GObject.Object;
+        /**
+         * Increase the reference count of `object,` and possibly remove the
+         * [floating][floating-ref] reference, if `object` has a floating reference.
+         *
+         * In other words, if the object is floating, then this call "assumes
+         * ownership" of the floating reference, converting it to a normal
+         * reference by clearing the floating flag while leaving the reference
+         * count unchanged.  If the object is not floating, then this call
+         * adds a new normal reference increasing the reference count by one.
+         *
+         * Since GLib 2.56, the type of `object` will be propagated to the return type
+         * under the same conditions as for g_object_ref().
+         * @returns @object
+         */
+        ref_sink(): GObject.Object;
+        /**
+         * Releases all references to other objects. This can be used to break
+         * reference cycles.
+         *
+         * This function should only be called from object system implementations.
+         */
+        run_dispose(): void;
+        /**
+         * Each object carries around a table of associations from
+         * strings to pointers.  This function lets you set an association.
+         *
+         * If the object already had an association with that name,
+         * the old association will be destroyed.
+         *
+         * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+         * This means a copy of `key` is kept permanently (even after `object` has been
+         * finalized) — so it is recommended to only use a small, bounded set of values
+         * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+         * @param key name of the key
+         * @param data data to associate with that key
+         */
+        set_data(key: string, data?: any | null): void;
+        set_property(property_name: string, value: any): void;
+        /**
+         * Remove a specified datum from the object's data associations,
+         * without invoking the association's destroy handler.
+         * @param key name of the key
+         * @returns the data if found, or %NULL          if no such data exists.
+         */
+        steal_data(key: string): any | null;
+        /**
+         * This function gets back user data pointers stored via
+         * g_object_set_qdata() and removes the `data` from object
+         * without invoking its destroy() function (if any was
+         * set).
+         * Usually, calling this function is only required to update
+         * user data pointers with a destroy notifier, for example:
+         *
+         * ```c
+         * void
+         * object_add_to_user_list (GObject     *object,
+         *                          const gchar *new_string)
+         * {
+         *   // the quark, naming the object data
+         *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+         *   // retrieve the old string list
+         *   GList *list = g_object_steal_qdata (object, quark_string_list);
+         *
+         *   // prepend new string
+         *   list = g_list_prepend (list, g_strdup (new_string));
+         *   // this changed 'list', so we need to set it again
+         *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+         * }
+         * static void
+         * free_string_list (gpointer data)
+         * {
+         *   GList *node, *list = data;
+         *
+         *   for (node = list; node; node = node->next)
+         *     g_free (node->data);
+         *   g_list_free (list);
+         * }
+         * ```
+         *
+         * Using g_object_get_qdata() in the above example, instead of
+         * g_object_steal_qdata() would have left the destroy function set,
+         * and thus the partial string list would have been freed upon
+         * g_object_set_qdata_full().
+         * @param quark A #GQuark, naming the user data pointer
+         * @returns The user data pointer set, or %NULL
+         */
+        steal_qdata(quark: GLib.Quark): any | null;
+        /**
+         * Reverts the effect of a previous call to
+         * g_object_freeze_notify(). The freeze count is decreased on `object`
+         * and when it reaches zero, queued "notify" signals are emitted.
+         *
+         * Duplicate notifications for each property are squashed so that at most one
+         * #GObject::notify signal is emitted for each property, in the reverse order
+         * in which they have been queued.
+         *
+         * It is an error to call this function when the freeze count is zero.
+         */
+        thaw_notify(): void;
+        /**
+         * Decreases the reference count of `object`. When its reference count
+         * drops to 0, the object is finalized (i.e. its memory is freed).
+         *
+         * If the pointer to the #GObject may be reused in future (for example, if it is
+         * an instance variable of another object), it is recommended to clear the
+         * pointer to %NULL rather than retain a dangling pointer to a potentially
+         * invalid #GObject instance. Use g_clear_object() for this.
+         */
+        unref(): void;
+        /**
+         * This function essentially limits the life time of the `closure` to
+         * the life time of the object. That is, when the object is finalized,
+         * the `closure` is invalidated by calling g_closure_invalidate() on
+         * it, in order to prevent invocations of the closure with a finalized
+         * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+         * added as marshal guards to the `closure,` to ensure that an extra
+         * reference count is held on `object` during invocation of the
+         * `closure`.  Usually, this function will be called on closures that
+         * use this `object` as closure data.
+         * @param closure #GClosure to watch
+         */
+        watch_closure(closure: GObject.Closure): void;
+        vfunc_constructed(): void;
+        vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+        vfunc_dispose(): void;
+        vfunc_finalize(): void;
+        vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+        /**
+         * Emits a "notify" signal for the property `property_name` on `object`.
+         *
+         * When possible, eg. when signaling a property change from within the class
+         * that registered the property, you should use g_object_notify_by_pspec()
+         * instead.
+         *
+         * Note that emission of the notify signal may be blocked with
+         * g_object_freeze_notify(). In this case, the signal emissions are queued
+         * and will be emitted (in reverse order) when g_object_thaw_notify() is
+         * called.
+         * @param pspec
+         */
+        vfunc_notify(pspec: GObject.ParamSpec): void;
+        vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+        disconnect(id: number): void;
+        set(properties: { [key: string]: any }): void;
+        block_signal_handler(id: number): any;
+        unblock_signal_handler(id: number): any;
+        stop_emission_by_name(detailedName: string): any;
+    }
+
+    module DataModelBdb {
+        // Constructor properties interface
+
+        interface ConstructorProps extends GObject.Object.ConstructorProps, DataModel.ConstructorProps {
+            db_name: string;
+            dbName: string;
+            filename: string;
+        }
+    }
+
+    class DataModelBdb extends GObject.Object implements DataModel {
+        static $gtype: GObject.GType<DataModelBdb>;
+
+        // Own properties of Gda.DataModelBdb
+
+        get db_name(): string;
+        get dbName(): string;
+        get filename(): string;
+
+        // Own fields of Gda.DataModelBdb
+
+        object: GObject.Object;
+
+        // Constructors of Gda.DataModelBdb
+
+        constructor(properties?: Partial<DataModelBdb.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        // Own static methods of Gda.DataModelBdb
+
+        /**
+         * Creates a new #GdaDataModel object to access the contents of the Berkeley DB file `file,`
+         * for the database `db_name` if not %NULL
+         * @param filename name of the file containing the database
+         * @param db_name the name of the database within @filename, or %NULL
+         */
+        static ['new'](filename: string, db_name?: string | null): DataModel;
+
+        // Own virtual methods of Gda.DataModelBdb
+
+        vfunc_get_data_part(data: any | null, length: number, part: number): unknown;
+        vfunc_get_key_part(data: any | null, length: number, part: number): unknown;
+        vfunc_update_data_part(data: any | null, length: number, part: number, value: GObject.Value | any): boolean;
+        vfunc_update_key_part(data: any | null, length: number, part: number, value: GObject.Value | any): boolean;
+
+        // Own methods of Gda.DataModelBdb
+
+        /**
+         * Reset the list of errors which have occurred while using `model`
+         */
+        clean_errors(): void;
+        /**
+         * Get the list of errors which have occurred while using `model`
+         * @returns a read-only list of #GError pointers, or %NULL if no error has occurred
+         */
+        get_errors(): GLib.Error[];
+
+        // Inherited methods
+        /**
+         * Adds the data from an XML node to the given data model (see the DTD for that node
+         * in the $prefix/share/libgda/dtd/libgda-array.dtd file).
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param node an XML node representing a &lt;gda_array_data&gt; XML node.
+         * @returns %TRUE if successful, %FALSE otherwise.
+         */
+        add_data_from_xml_node(node: libxml2.NodePtr): boolean;
+        /**
+         * Appends a row to the data model (the new row will possibly have NULL values for all columns,
+         * or some other values depending on the data model implementation)
+         *
+         * Upon errors -1 will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @returns the number of the added row, or -1 if an error occurred
+         */
+        append_row(): number;
+        /**
+         * Appends a row to the given data model. If any value in `values` is actually %NULL, then
+         * it is considered as a default value. If `values` is %NULL then all values are set to their default value.
+         *
+         * Upon errors -1 will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param values #GList of #GValue* representing the row to add.  The          length must match model's column count.  These #GValue     are value-copied (the user is still responsible for freeing them).
+         * @returns the number of the added row, or -1 if an error occurred
+         */
+        append_values(values?: GObject.Value[] | null): number;
+        /**
+         * Makes a copy of `src` into a new #GdaDataModelArray object
+         * @returns a new data model, or %NULL if an error occurred
+         */
+        array_copy_model(): DataModelArray | null;
+        /**
+         * Like gda_data_model_array_copy_model(), makes a copy of `src,` but copies only some
+         * columns.
+         * @param cols array of @src's columns to copy into the new array, not %NULL
+         * @returns a new data model, or %NULL if an error occurred
+         */
+        array_copy_model_ext(cols: number[]): DataModelArray | null;
+        /**
+         * Creates a new iterator object #GdaDataModelIter object which can be used to iterate through
+         * rows in `model`. The new #GdaDataModelIter does not hold any reference to `model` (ie. if `model`
+         * is destroyed at some point, the new iterator will become useless but in any case it will not prevent
+         * the data model from being destroyed).
+         *
+         * Depending on the data model's implementation, a new #GdaDataModelIter object may be created,
+         * or a reference to an already existing #GdaDataModelIter may be returned. For example if `model` only
+         * supports being accessed using a forward moving cursor (say a the result of a SELECT executed by SQLite
+         * with a cursor access mode specified), then this method will always return the same iterator.
+         *
+         * If a new #GdaDataModelIter is created, then the row it represents is undefined.
+         *
+         * For models which can be accessed
+         * randomly, any row can be set using gda_data_model_iter_move_to_row(),
+         * and for models which are accessible sequentially only then use
+         * gda_data_model_iter_move_next() (and gda_data_model_iter_move_prev() if
+         * supported).
+         *
+         * Note: for the #GdaDataProxy data model (which proxies any #GdaDataModel for modifications and
+         * has twice the number of columns of the proxied data model), this method will create an iterator
+         * in which only the columns of the proxied data model appear. If you need to have a #GdaDataModelIter
+         * in which all the proxy's columns appear, create it using:
+         * <programlisting><![CDATA[iter = g_object_new (GDA_TYPE_DATA_MODEL_ITER, "data-model", proxy, NULL);]]></programlisting>
+         * @returns a #GdaDataModelIter object, or %NULL if an error occurred
+         */
+        create_iter(): DataModelIter;
+        /**
+         * Queries the underlying data model implementation for a description
+         * of a given column. That description is returned in the form of
+         * a #GdaColumn structure, which contains all the information
+         * about the given column in the data model.
+         *
+         * WARNING: the returned #GdaColumn object belongs to the `model` model and
+         * and should not be destroyed; any modification will affect the whole data model.
+         * @param col column number.
+         * @returns the description of the column.
+         */
+        describe_column(col: number): Column | null;
+        /**
+         * Dumps a textual representation of the `model` to the `to_stream` stream
+         *
+         * The following environment variables can affect the resulting output:
+         * <itemizedlist>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_ROW_NUMBERS: if set, the first column of the output will contain row numbers</para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_ATTRIBUTES: if set, also dump the data model's columns' types and value's attributes</para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_TITLE: if set, also dump the data model's title</para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_NULL_AS_EMPTY: if set, replace the 'NULL' string with an empty string for NULL values </para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_TRUNCATE: if set to a numeric value, truncates the output to the width specified by the value. If the value is -1 then the actual terminal size (if it can be determined) is used</para></listitem>
+         * </itemizedlist>
+         * @param to_stream where to dump the data model
+         */
+        dump(to_stream?: any | null): void;
+        /**
+         * Dumps a textual representation of the `model` into a new string. The main differences with gda_data_model_export_to_string() are that
+         * the formatting options are passed using environment variables, and that the data is dumped regardless of the user locale (e.g. dates
+         * are not formatted according to the locale).
+         *
+         * The following environment variables can affect the resulting output:
+         * <itemizedlist>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_ROW_NUMBERS: if set, the first column of the output will contain row numbers</para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_TITLE: if set, also dump the data model's title</para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_NULL_AS_EMPTY: if set, replace the 'NULL' string with an empty string for NULL values </para></listitem>
+         *   <listitem><para>GDA_DATA_MODEL_DUMP_TRUNCATE: if set to a numeric value, truncates the output to the width specified by the value. If the value is -1 then the actual terminal size (if it can be determined) is used</para></listitem>
+         * </itemizedlist>
+         * @returns a new string.
+         */
+        dump_as_string(): string;
+        /**
+         * Exports data contained in `model` to the `file` file; the format is specified using the `format` argument. Note that
+         * the date format used is the one used by the connection from which the data model has been made (as the result of a
+         * SELECT statement), or, for other kinds of data models, the default format (refer to gda_data_handler_get_default()) unless
+         * the "cnc" property has been set and points to a #GdaConnection to use that connection's date format.
+         *
+         * Specifically, the parameters in the `options` list can be:
+         * <itemizedlist>
+         *   <listitem><para>"SEPARATOR": a string value of which the first character is used as a separator in case of CSV export
+         *             </para></listitem>
+         *   <listitem><para>"QUOTE": a string value of which the first character is used as a quote character in case of CSV export. The
+         *             default if not specified is the double quote character</para></listitem>
+         *   <listitem><para>"FIELD_QUOTE": a boolean value which can be set to FALSE if no quote around the individual fields
+         *             is requeted, in case of CSV export</para></listitem>
+         *   <listitem><para>"NAMES_ON_FIRST_LINE": a boolean value which, if set to %TRUE and in case of a CSV or %GDA_DATA_MODEL_IO_TEXT_TABLE export, will add a first line with the name each exported field (note that "FIELDS_NAME" is also accepted as a synonym)</para></listitem>
+         *   <listitem><para>"NAME": a string value used to name the exported data if the export format is XML or %GDA_DATA_MODEL_IO_TEXT_TABLE</para></listitem>
+         *   <listitem><para>"OVERWRITE": a boolean value which tells if the file must be over-written if it already exists.</para></listitem>
+         *   <listitem><para>"NULL_AS_EMPTY": a boolean value which, if set to %TRUE and in case of a CSV or %GDA_DATA_MODEL_IO_TEXT_TABLE export, will render and NULL value as the empty string (instead of the 'NULL' string)</para></listitem>
+         *   <listitem><para>"INVALID_AS_NULL": a boolean value which, if set to %TRUE, considers any invalid data (for example for the date related values) as NULL</para></listitem>
+         *   <listitem><para>"COLUMN_SEPARATORS": a boolean value which, if set to %TRUE, adds a separators lines between each column, if the export format is %GDA_DATA_MODEL_IO_TEXT_TABLE
+         *             </para></listitem>
+         *   <listitem><para>"SEPARATOR_LINE": a boolean value which, if set to %TRUE, adds an horizontal line between column titles and values, if the export format is %GDA_DATA_MODEL_IO_TEXT_TABLE
+         *             </para></listitem>
+         *   <listitem><para>"ROW_NUMBERS": a boolean value which, if set to %TRUE, prepends a column with row numbers, if the export format is %GDA_DATA_MODEL_IO_TEXT_TABLE
+         *             </para></listitem>
+         *   <listitem><para>"MAX_WIDTH": an integer value which, if greater than 0, makes all the lines truncated to have at most that number of characters, if the export format is %GDA_DATA_MODEL_IO_TEXT_TABLE
+         *             </para></listitem>
+         * </itemizedlist>
+         *
+         * Warning: this function uses a #GdaDataModelIter iterator, and if `model` does not offer a random access
+         * (check using gda_data_model_get_access_flags()), the iterator will be the same as normally used
+         * to access data in `model` previously to calling this method, and this iterator will be moved (point to
+         * another row).
+         *
+         * Upon errors %FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param format the format in which to export data
+         * @param file the filename to export to
+         * @param cols an array containing which columns of @model will be exported, or %NULL for all columns
+         * @param rows an array containing which rows of @model will be exported, or %NULL for all rows
+         * @param options list of options for the export
+         * @returns TRUE if no error occurred
+         */
+        export_to_file(
+            format: DataModelIOFormat,
+            file: string,
+            cols: number[] | null,
+            rows: number[] | null,
+            options: Set,
+        ): boolean;
+        /**
+         * Exports data contained in `model` to a string; the format is specified using the `format` argument, see the
+         * gda_data_model_export_to_file() documentation for more information about the `options` argument (except for the
+         * "OVERWRITE" option).
+         *
+         * Warning: this function uses a #GdaDataModelIter iterator, and if `model` does not offer a random access
+         * (check using gda_data_model_get_access_flags()), the iterator will be the same as normally used
+         * to access data in `model` previously to calling this method, and this iterator will be moved (point to
+         * another row).
+         *
+         * See also gda_data_model_dump_as_string();
+         * @param format the format in which to export data
+         * @param cols an array containing which columns of @model will be exported, or %NULL for all columns
+         * @param rows an array containing which rows of @model will be exported, or %NULL for all rows
+         * @param options list of options for the export
+         * @returns a new string, use g_free() when no longer needed
+         */
+        export_to_string(format: DataModelIOFormat, cols: number[] | null, rows: number[] | null, options: Set): string;
+        /**
+         * Disables notifications of changes on the given data model. To
+         * re-enable notifications again, you should call the
+         * #gda_data_model_thaw function.
+         */
+        freeze(): void;
+        /**
+         * Get the attributes of `model` such as how to access the data it contains if it's modifiable, etc.
+         * @returns an ORed value of #GdaDataModelAccessFlags flags
+         */
+        get_access_flags(): DataModelAccessFlags;
+        /**
+         * Get the attributes of the value stored at (row, col) in `model,` which
+         * is an ORed value of #GdaValueAttribute flags. As a special case, if
+         * `row` is -1, then the attributes returned correspond to a "would be" value
+         * if a row was added to `model`.
+         * @param col a valid column number
+         * @param row a valid row number, or -1
+         * @returns the attributes as an ORed value of #GdaValueAttribute
+         */
+        get_attributes_at(col: number, row: number): ValueAttribute;
+        /**
+         * Get the index of the first column named `name` in `model`.
+         * @param name a column name
+         * @returns the column index, or -1 if no column named @name was found
+         */
+        get_column_index(name: string): number;
+        get_column_name(col: number): string;
+        get_column_title(col: number): string;
+        /**
+         * Get the global data model exception(s) that occurred when using `model`.
+         * This is useful for example for the LDAP related
+         * data models where some rows may be missing because the LDAP search has reached a limit
+         * imposed by the LDAP server.
+         * @returns a pointer to a %NULL terminated array of #GError, or %NULL.
+         */
+        get_exceptions(): GLib.Error[];
+        get_n_columns(): number;
+        get_n_rows(): number;
+        /**
+         * Returns the status of notifications changes on the given data model.
+         */
+        get_notify(): boolean;
+        /**
+         * Returns the first row where all the values in `values` at the columns identified at
+         * `cols_index` match. If the row can't be identified, then returns -1;
+         *
+         * NOTE: the `cols_index` array MUST contain a column index for each value in `values`
+         * @param values a list of #GValue values (no %NULL is allowed)
+         * @param cols_index an array of #gint containing the column number to match each value of @values
+         * @returns the requested row number, of -1 if not found
+         */
+        get_row_from_values(values: (GObject.Value | any)[], cols_index: number[]): number;
+        /**
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         *
+         * This method is similar to gda_data_model_get_value_at(), except that it also allows one to specify the expected
+         * #GType of the value to get: if the data model returned a #GValue of a type different than the expected one, then
+         * this method returns %NULL and an error code.
+         *
+         * Note: the same limitations and usage instructions apply as for gda_data_model_get_value_at().
+         *
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param col a valid column number.
+         * @param row a valid row number.
+         * @param expected_type the expected data type of the returned value
+         * @param nullok if TRUE, then NULL values (value of type %GDA_TYPE_NULL) will not generate any error
+         * @returns a #GValue containing the value stored in the given position, or %NULL on error (out-of-bound position, wrong data type, etc).
+         */
+        get_typed_value_at(
+            col: number,
+            row: number,
+            expected_type: GObject.GType,
+            nullok: boolean,
+        ): GObject.Value | null;
+        /**
+         * Retrieves the data stored in the given position (identified by
+         * the `col` and `row` parameters) on a data model.
+         *
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         *
+         * This is the main function for accessing data in a model which allows random access to its data.
+         * To access data in a data model using a cursor, use a #GdaDataModelIter object, obtained using
+         * gda_data_model_create_iter().
+         *
+         * Note1: the returned #GValue must not be modified directly (unexpected behaviours may
+         * occur if you do so).
+         *
+         * Note2: the returned value may become invalid as soon as any Libgda part is executed again,
+         * which means if you want to keep the value, a copy must be made, however it will remain valid
+         * as long as the only Libgda usage is calling gda_data_model_get_value_at() for different values
+         * of the same row.
+         *
+         * If you want to modify a value stored in a #GdaDataModel, use the gda_data_model_set_value_at() or
+         * gda_data_model_set_values() methods.
+         *
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param col a valid column number.
+         * @param row a valid row number.
+         * @returns a #GValue containing the value stored in the given position, or %NULL on error (out-of-bound position, etc).
+         */
+        get_value_at(col: number, row: number): GObject.Value | null;
+        /**
+         * Imports data contained in the `file` file into `model;` the format is detected.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param file the filename to import from
+         * @param cols_trans a #GHashTable for columns translating, or %NULL, see gda_data_model_import_from_model()
+         * @param options list of options for the export
+         * @returns TRUE if no error occurred
+         */
+        import_from_file(file: string, cols_trans: GLib.HashTable<number, number> | null, options: Set): boolean;
+        /**
+         * Copy the contents of the `from` data model to the `to` data model. The copy stops as soon as an error
+         * orrurs.
+         *
+         * The `cols_trans` is a hash table for which keys are `to` columns numbers and the values are
+         * the corresponding column numbers in the `from` data model. To set the values of a column in `to` to NULL,
+         * create an entry in the hash table with a negative value. For example:
+         * <programlisting><![CDATA[GHashTable *hash;
+         * gint *ptr;
+         * hash = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, NULL);
+         * ptr = g_new (gint, 1);
+         * *ptr = 2;
+         * g_hash_table_insert (hash, ptr, GINT_TO_POINTER (3));
+         * gda_data_model_import_from_model (...);
+         * g_hash_table_free (hash);
+         * ]]></programlisting>
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param from the source #GdaDataModel
+         * @param overwrite TRUE if @to is completely overwritten by @from's data, and FALSE if @from's data is appended to @to
+         * @param cols_trans a #GHashTable for columns translating, or %NULL
+         * @returns TRUE if no error occurred.
+         */
+        import_from_model(
+            from: DataModel,
+            overwrite: boolean,
+            cols_trans?: GLib.HashTable<number, number> | null,
+        ): boolean;
+        /**
+         * Loads the data from `string` into `model`.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param string the string to import data from
+         * @param cols_trans a hash table containing which columns of @model will be imported, or %NULL for all columns, see gda_data_model_import_from_model()
+         * @param options list of options for the export
+         * @returns TRUE if no error occurred.
+         */
+        import_from_string(string: string, cols_trans: GLib.HashTable<number, number> | null, options: Set): boolean;
+        /**
+         * Moves `iter` to the row number given by `row`.
+         * @param iter a #GdaDataModelIter object.
+         * @param row a row to point to with @iter
+         */
+        iter_at_row(iter: DataModelIter, row: number): boolean;
+        /**
+         * Moves `iter` to the next row in `model`.
+         * @param iter a #GdaDataModelIter object.
+         */
+        iter_next(iter: DataModelIter): boolean;
+        /**
+         * Moves `iter` to the next row in `model`.
+         * @param iter a #GdaDataModelIter object.
+         */
+        iter_prev(iter: DataModelIter): boolean;
+        /**
+         * Set `value` to the given `column` and row pointed by `iter` in the given `model`.
+         * @param iter a #GdaDataModelIter object.
+         * @param col the number of column to set value to
+         * @param value the to use to set on
+         */
+        iter_set_value(iter: DataModelIter, col: number, value: GObject.Value | any): boolean;
+        /**
+         * Removes a row from the data model.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param row the row number to be removed.
+         * @returns %TRUE if successful, %FALSE otherwise.
+         */
+        remove_row(row: number): boolean;
+        /**
+         * Emits the 'reset' and 'changed' signal on `model`.
+         */
+        reset(): void;
+        /**
+         * Emits the 'row_inserted' and 'changed' signals on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been inserted.
+         * @param row row number.
+         */
+        row_inserted(row: number): void;
+        /**
+         * Emits the 'row_removed' and 'changed' signal on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been removed
+         * @param row row number.
+         */
+        row_removed(row: number): void;
+        /**
+         * Emits the 'row_updated' and 'changed' signals on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been updated.
+         * @param row row number.
+         */
+        row_updated(row: number): void;
+        /**
+         * Sends a hint to the data model. The hint may or may not be handled by the data
+         * model, depending on its implementation
+         * @param hint a hint to send to the model
+         * @param hint_value an optional value to specify the hint, or %NULL
+         */
+        send_hint(hint: DataModelHint, hint_value?: GObject.Value | null): void;
+        /**
+         * Sets the `name` of the given `col` in `model,` and if its title is not set, also sets the
+         * title to `name`.
+         * @param col column number
+         * @param name name for the given column.
+         */
+        set_column_name(col: number, name: string): void;
+        /**
+         * Sets the `title` of the given `col` in `model`.
+         * @param col column number
+         * @param title title for the given column.
+         */
+        set_column_title(col: number, title: string): void;
+        /**
+         * Enable or disable notifications changes on the given data model.
+         * @param do_notify_changes Set to TRUE if you require notifications.
+         */
+        set_notify(do_notify_changes: boolean): void;
+        /**
+         * Modifies a value in `model,` at (`col,` `row)`.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param col column number.
+         * @param row row number.
+         * @param value a #GValue (not %NULL)
+         * @returns TRUE if the value in the data model has been updated and no error occurred
+         */
+        set_value_at(col: number, row: number, value: GObject.Value | any): boolean;
+        /**
+         * In a similar way to gda_data_model_set_value_at(), this method modifies a data model's contents
+         * by setting several values at once.
+         *
+         * If any value in `values` is actually %NULL, then the value in the corresponding column is left
+         * unchanged.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param row row number.
+         * @param values a list of #GValue (or %NULL), one for at most the number of columns of @model
+         * @returns %TRUE if the value in the data model has been updated and no error occurred
+         */
+        set_values(row: number, values?: GObject.Value[] | null): boolean;
+        /**
+         * Re-enables notifications of changes on the given data model.
+         */
+        thaw(): void;
+        vfunc_access_changed(): void;
+        vfunc_changed(): void;
+        /**
+         * Appends a row to the data model (the new row will possibly have NULL values for all columns,
+         * or some other values depending on the data model implementation)
+         *
+         * Upon errors -1 will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         */
+        vfunc_i_append_row(): number;
+        /**
+         * Appends a row to the given data model. If any value in `values` is actually %NULL, then
+         * it is considered as a default value. If `values` is %NULL then all values are set to their default value.
+         *
+         * Upon errors -1 will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param values #GList of #GValue* representing the row to add.  The          length must match model's column count.  These #GValue     are value-copied (the user is still responsible for freeing them).
+         */
+        vfunc_i_append_values(values?: GObject.Value[] | null): number;
+        /**
+         * Creates a new iterator object #GdaDataModelIter object which can be used to iterate through
+         * rows in `model`. The new #GdaDataModelIter does not hold any reference to `model` (ie. if `model`
+         * is destroyed at some point, the new iterator will become useless but in any case it will not prevent
+         * the data model from being destroyed).
+         *
+         * Depending on the data model's implementation, a new #GdaDataModelIter object may be created,
+         * or a reference to an already existing #GdaDataModelIter may be returned. For example if `model` only
+         * supports being accessed using a forward moving cursor (say a the result of a SELECT executed by SQLite
+         * with a cursor access mode specified), then this method will always return the same iterator.
+         *
+         * If a new #GdaDataModelIter is created, then the row it represents is undefined.
+         *
+         * For models which can be accessed
+         * randomly, any row can be set using gda_data_model_iter_move_to_row(),
+         * and for models which are accessible sequentially only then use
+         * gda_data_model_iter_move_next() (and gda_data_model_iter_move_prev() if
+         * supported).
+         *
+         * Note: for the #GdaDataProxy data model (which proxies any #GdaDataModel for modifications and
+         * has twice the number of columns of the proxied data model), this method will create an iterator
+         * in which only the columns of the proxied data model appear. If you need to have a #GdaDataModelIter
+         * in which all the proxy's columns appear, create it using:
+         * <programlisting><![CDATA[iter = g_object_new (GDA_TYPE_DATA_MODEL_ITER, "data-model", proxy, NULL);]]></programlisting>
+         */
+        vfunc_i_create_iter(): DataModelIter;
+        /**
+         * Queries the underlying data model implementation for a description
+         * of a given column. That description is returned in the form of
+         * a #GdaColumn structure, which contains all the information
+         * about the given column in the data model.
+         *
+         * WARNING: the returned #GdaColumn object belongs to the `model` model and
+         * and should not be destroyed; any modification will affect the whole data model.
+         * @param col column number.
+         */
+        vfunc_i_describe_column(col: number): Column | null;
+        /**
+         * Returns the first row where all the values in `values` at the columns identified at
+         * `cols_index` match. If the row can't be identified, then returns -1;
+         *
+         * NOTE: the `cols_index` array MUST contain a column index for each value in `values`
+         * @param values a list of #GValue values (no %NULL is allowed)
+         * @param cols_index an array of #gint containing the column number to match each value of @values
+         */
+        vfunc_i_find_row(values: (GObject.Value | any)[], cols_index: number[]): number;
+        /**
+         * Get the attributes of `model` such as how to access the data it contains if it's modifiable, etc.
+         */
+        vfunc_i_get_access_flags(): DataModelAccessFlags;
+        /**
+         * Get the attributes of the value stored at (row, col) in `model,` which
+         * is an ORed value of #GdaValueAttribute flags. As a special case, if
+         * `row` is -1, then the attributes returned correspond to a "would be" value
+         * if a row was added to `model`.
+         * @param col a valid column number
+         * @param row a valid row number, or -1
+         */
+        vfunc_i_get_attributes_at(col: number, row: number): ValueAttribute;
+        /**
+         * Get the global data model exception(s) that occurred when using `model`.
+         * This is useful for example for the LDAP related
+         * data models where some rows may be missing because the LDAP search has reached a limit
+         * imposed by the LDAP server.
+         */
+        vfunc_i_get_exceptions(): GLib.Error[];
+        vfunc_i_get_n_columns(): number;
+        vfunc_i_get_n_rows(): number;
+        /**
+         * Returns the status of notifications changes on the given data model.
+         */
+        vfunc_i_get_notify(): boolean;
+        /**
+         * Retrieves the data stored in the given position (identified by
+         * the `col` and `row` parameters) on a data model.
+         *
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         *
+         * This is the main function for accessing data in a model which allows random access to its data.
+         * To access data in a data model using a cursor, use a #GdaDataModelIter object, obtained using
+         * gda_data_model_create_iter().
+         *
+         * Note1: the returned #GValue must not be modified directly (unexpected behaviours may
+         * occur if you do so).
+         *
+         * Note2: the returned value may become invalid as soon as any Libgda part is executed again,
+         * which means if you want to keep the value, a copy must be made, however it will remain valid
+         * as long as the only Libgda usage is calling gda_data_model_get_value_at() for different values
+         * of the same row.
+         *
+         * If you want to modify a value stored in a #GdaDataModel, use the gda_data_model_set_value_at() or
+         * gda_data_model_set_values() methods.
+         *
+         * Upon errors %NULL will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param col a valid column number.
+         * @param row a valid row number.
+         */
+        vfunc_i_get_value_at(col: number, row: number): GObject.Value | null;
+        /**
+         * Moves `iter` to the row number given by `row`.
+         * @param iter a #GdaDataModelIter object.
+         * @param row a row to point to with @iter
+         */
+        vfunc_i_iter_at_row(iter: DataModelIter, row: number): boolean;
+        /**
+         * Moves `iter` to the next row in `model`.
+         * @param iter a #GdaDataModelIter object.
+         */
+        vfunc_i_iter_next(iter: DataModelIter): boolean;
+        /**
+         * Moves `iter` to the next row in `model`.
+         * @param iter a #GdaDataModelIter object.
+         */
+        vfunc_i_iter_prev(iter: DataModelIter): boolean;
+        /**
+         * Set `value` to the given `column` and row pointed by `iter` in the given `model`.
+         * @param iter a #GdaDataModelIter object.
+         * @param col the number of column to set value to
+         * @param value the to use to set on
+         */
+        vfunc_i_iter_set_value(iter: DataModelIter, col: number, value: GObject.Value | any): boolean;
+        /**
+         * Removes a row from the data model.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param row the row number to be removed.
+         */
+        vfunc_i_remove_row(row: number): boolean;
+        /**
+         * Sends a hint to the data model. The hint may or may not be handled by the data
+         * model, depending on its implementation
+         * @param hint a hint to send to the model
+         * @param hint_value an optional value to specify the hint, or %NULL
+         */
+        vfunc_i_send_hint(hint: DataModelHint, hint_value?: GObject.Value | null): void;
+        /**
+         * Enable or disable notifications changes on the given data model.
+         * @param do_notify_changes Set to TRUE if you require notifications.
+         */
+        vfunc_i_set_notify(do_notify_changes: boolean): void;
+        /**
+         * Modifies a value in `model,` at (`col,` `row)`.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param col column number.
+         * @param row row number.
+         * @param value a #GValue (not %NULL)
+         */
+        vfunc_i_set_value_at(col: number, row: number, value: GObject.Value | any): boolean;
+        /**
+         * In a similar way to gda_data_model_set_value_at(), this method modifies a data model's contents
+         * by setting several values at once.
+         *
+         * If any value in `values` is actually %NULL, then the value in the corresponding column is left
+         * unchanged.
+         *
+         * Upon errors FALSE will be returned and `error` will be assigned a
+         * #GError from the #GDA_DATA_MODEL_ERROR domain.
+         * @param row row number.
+         * @param values a list of #GValue (or %NULL), one for at most the number of columns of @model
+         */
+        vfunc_i_set_values(row: number, values?: GObject.Value[] | null): boolean;
+        /**
+         * Emits the 'reset' and 'changed' signal on `model`.
+         */
+        vfunc_reset(): void;
+        /**
+         * Emits the 'row_inserted' and 'changed' signals on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been inserted.
+         * @param row row number.
+         */
+        vfunc_row_inserted(row: number): void;
+        /**
+         * Emits the 'row_removed' and 'changed' signal on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been removed
+         * @param row row number.
+         */
+        vfunc_row_removed(row: number): void;
+        /**
+         * Emits the 'row_updated' and 'changed' signals on `model`.
+         *
+         * This method should only be used by #GdaDataModel implementations to
+         * signal that a row has been updated.
+         * @param row row number.
+         */
+        vfunc_row_updated(row: number): void;
+        /**
+         * Creates a binding between `source_property` on `source` and `target_property`
+         * on `target`.
+         *
+         * Whenever the `source_property` is changed the `target_property` is
+         * updated using the same value. For instance:
+         *
+         *
+         * ```c
+         *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+         * ```
+         *
+         *
+         * Will result in the "sensitive" property of the widget #GObject instance to be
+         * updated with the same value of the "active" property of the action #GObject
+         * instance.
+         *
+         * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+         * if `target_property` on `target` changes then the `source_property` on `source`
+         * will be updated as well.
+         *
+         * The binding will automatically be removed when either the `source` or the
+         * `target` instances are finalized. To remove the binding without affecting the
+         * `source` and the `target` you can just call g_object_unref() on the returned
+         * #GBinding instance.
+         *
+         * Removing the binding by calling g_object_unref() on it must only be done if
+         * the binding, `source` and `target` are only used from a single thread and it
+         * is clear that both `source` and `target` outlive the binding. Especially it
+         * is not safe to rely on this if the binding, `source` or `target` can be
+         * finalized from different threads. Keep another reference to the binding and
+         * use g_binding_unbind() instead to be on the safe side.
+         *
+         * A #GObject can have multiple bindings.
+         * @param source_property the property on @source to bind
+         * @param target the target #GObject
+         * @param target_property the property on @target to bind
+         * @param flags flags to pass to #GBinding
+         * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+         */
+        bind_property(
+            source_property: string,
+            target: GObject.Object,
+            target_property: string,
+            flags: GObject.BindingFlags,
+        ): GObject.Binding;
+        /**
+         * Complete version of g_object_bind_property().
+         *
+         * Creates a binding between `source_property` on `source` and `target_property`
+         * on `target,` allowing you to set the transformation functions to be used by
+         * the binding.
+         *
+         * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+         * if `target_property` on `target` changes then the `source_property` on `source`
+         * will be updated as well. The `transform_from` function is only used in case
+         * of bidirectional bindings, otherwise it will be ignored
+         *
+         * The binding will automatically be removed when either the `source` or the
+         * `target` instances are finalized. This will release the reference that is
+         * being held on the #GBinding instance; if you want to hold on to the
+         * #GBinding instance, you will need to hold a reference to it.
+         *
+         * To remove the binding, call g_binding_unbind().
+         *
+         * A #GObject can have multiple bindings.
+         *
+         * The same `user_data` parameter will be used for both `transform_to`
+         * and `transform_from` transformation functions; the `notify` function will
+         * be called once, when the binding is removed. If you need different data
+         * for each transformation function, please use
+         * g_object_bind_property_with_closures() instead.
+         * @param source_property the property on @source to bind
+         * @param target the target #GObject
+         * @param target_property the property on @target to bind
+         * @param flags flags to pass to #GBinding
+         * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+         * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+         * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+         * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+         */
+        bind_property_full(
+            source_property: string,
+            target: GObject.Object,
+            target_property: string,
+            flags: GObject.BindingFlags,
+            transform_to?: GObject.BindingTransformFunc | null,
+            transform_from?: GObject.BindingTransformFunc | null,
+            notify?: GLib.DestroyNotify | null,
+        ): GObject.Binding;
+        // Conflicted with GObject.Object.bind_property_full
+        bind_property_full(...args: never[]): any;
+        /**
+         * This function is intended for #GObject implementations to re-enforce
+         * a [floating][floating-ref] object reference. Doing this is seldom
+         * required: all #GInitiallyUnowneds are created with a floating reference
+         * which usually just needs to be sunken by calling g_object_ref_sink().
+         */
+        force_floating(): void;
+        /**
+         * Increases the freeze count on `object`. If the freeze count is
+         * non-zero, the emission of "notify" signals on `object` is
+         * stopped. The signals are queued until the freeze count is decreased
+         * to zero. Duplicate notifications are squashed so that at most one
+         * #GObject::notify signal is emitted for each property modified while the
+         * object is frozen.
+         *
+         * This is necessary for accessors that modify multiple properties to prevent
+         * premature notification while the object is still being modified.
+         */
+        freeze_notify(): void;
+        /**
+         * Gets a named field from the objects table of associations (see g_object_set_data()).
+         * @param key name of the key for that association
+         * @returns the data if found,          or %NULL if no such data exists.
+         */
+        get_data(key: string): any | null;
+        get_property(property_name: string): any;
+        /**
+         * This function gets back user data pointers stored via
+         * g_object_set_qdata().
+         * @param quark A #GQuark, naming the user data pointer
+         * @returns The user data pointer set, or %NULL
+         */
+        get_qdata(quark: GLib.Quark): any | null;
+        /**
+         * Gets `n_properties` properties for an `object`.
+         * Obtained properties will be set to `values`. All properties must be valid.
+         * Warnings will be emitted and undefined behaviour may result if invalid
+         * properties are passed in.
+         * @param names the names of each property to get
+         * @param values the values of each property to get
+         */
+        getv(names: string[], values: (GObject.Value | any)[]): void;
+        /**
+         * Checks whether `object` has a [floating][floating-ref] reference.
+         * @returns %TRUE if @object has a floating reference
+         */
+        is_floating(): boolean;
+        /**
+         * Emits a "notify" signal for the property `property_name` on `object`.
+         *
+         * When possible, eg. when signaling a property change from within the class
+         * that registered the property, you should use g_object_notify_by_pspec()
+         * instead.
+         *
+         * Note that emission of the notify signal may be blocked with
+         * g_object_freeze_notify(). In this case, the signal emissions are queued
+         * and will be emitted (in reverse order) when g_object_thaw_notify() is
+         * called.
+         * @param property_name the name of a property installed on the class of @object.
+         */
+        notify(property_name: string): void;
+        /**
+         * Emits a "notify" signal for the property specified by `pspec` on `object`.
+         *
+         * This function omits the property name lookup, hence it is faster than
+         * g_object_notify().
+         *
+         * One way to avoid using g_object_notify() from within the
+         * class that registered the properties, and using g_object_notify_by_pspec()
+         * instead, is to store the GParamSpec used with
+         * g_object_class_install_property() inside a static array, e.g.:
+         *
+         *
+         * ```c
+         *   typedef enum
+         *   {
+         *     PROP_FOO = 1,
+         *     PROP_LAST
+         *   } MyObjectProperty;
+         *
+         *   static GParamSpec *properties[PROP_LAST];
+         *
+         *   static void
+         *   my_object_class_init (MyObjectClass *klass)
+         *   {
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -6736,7 +7813,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -7883,7 +8960,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -9180,7 +10257,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -10284,7 +11361,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -11663,7 +12740,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -12927,7 +14004,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -13442,7 +14519,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -13957,7 +15034,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -14472,7 +15549,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -14994,7 +16071,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -15566,7 +16643,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -16081,7 +17158,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -16859,7 +17936,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -19118,7 +20195,7 @@ export namespace Gda {
          *   static void
          *   my_object_class_init (MyObjectClass *klass)
          *   {
-         *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+         *     properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "The foo",
          *                                              0, 100,
          *                                              50,
          *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
@@ -20568,6 +21645,15 @@ export namespace Gda {
         _init(...args: any[]): void;
     }
 
+    type DataModelBdbClass = typeof DataModelBdb;
+    abstract class DataModelBdbPrivate {
+        static $gtype: GObject.GType<DataModelBdbPrivate>;
+
+        // Constructors of Gda.DataModelBdbPrivate
+
+        _init(...args: any[]): void;
+    }
+
     type DataModelDirClass = typeof DataModelDir;
     abstract class DataModelDirPrivate {
         static $gtype: GObject.GType<DataModelDirPrivate>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girs/gda-5.0",
-  "version": "5.0.0-4.0.0-beta.2",
+  "version": "5.0.0-4.0.0-beta.3",
   "description": "GJS TypeScript type definitions for Gda-5.0, generated from library version 5.0.0",
   "type": "module",
   "module": "gda-5.0.js",
@@ -26,10 +26,10 @@
     "test": "NODE_OPTIONS=--max_old_space_size=9216 tsc --noEmit gda-5.0.d.ts"
   },
   "dependencies": {
-    "@girs/gjs": "^4.0.0-beta.2",
-    "@girs/glib-2.0": "^2.80.0-4.0.0-beta.2",
-    "@girs/gobject-2.0": "^2.80.0-4.0.0-beta.2",
-    "@girs/libxml2-2.0": "^2.0.0-4.0.0-beta.2"
+    "@girs/gjs": "^4.0.0-beta.3",
+    "@girs/glib-2.0": "^2.80.0-4.0.0-beta.3",
+    "@girs/gobject-2.0": "^2.80.0-4.0.0-beta.3",
+    "@girs/libxml2-2.0": "^2.0.0-4.0.0-beta.3"
   },
   "devDependencies": {
     "typescript": "*"