@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gst/element.js

@@ -4,8 +4,8 @@ import { getNativeObject } from "../../native/object.js";
 import { registerNativeClass } from "../../registry.js";
 import { Context } from "./context.js";
 import { Iterator } from "./iterator.js";
-import * as GObject from "../gobject/index.js";
 import { GstObject } from "./object.js";
+import * as GLib from "../glib/index.js";
 /**
  * GstElement is the abstract base class needed to construct an element that
  * can be used in a GStreamer pipeline. Please refer to the plugin writers
@@ -57,53 +57,36 @@ import { GstObject } from "./object.js";
  * toplevel #GstPipeline so the clock functions are only to be used in very
  * specific situations.
  */
-const SIGNAL_META = {
-    "no-more-pads": { params: [], returnType: { type: "undefined" } },
-    "pad-added": {
-        params: [{ type: "gobject", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-    "pad-removed": {
-        params: [{ type: "gobject", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-    "deep-notify": {
-        params: [
-            { type: "gobject", borrowed: true },
-            { type: "gparam", borrowed: false },
-        ],
-        returnType: { type: "undefined" },
-    },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
 export class Element extends GstObject {
     static glibTypeName = "GstElement";
     static objectType = "gobject";
     constructor() {
         super();
     }
-    /**
-     * Creates an element for handling the given URI.
-     * @param type - Whether to create a source or a sink
-     * @param uri - URI to create an element for
-     * @param elementname - Name of created element, can be %NULL.
-     */
+    /** Creates an element for handling the given URI. */
     static makeFromUri(type, uri, elementname) {
         const error = { value: null };
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_make_from_uri", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: type,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: uri,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: elementname,
                 optional: true,
             },
@@ -112,70 +95,94 @@ export class Element extends GstObject {
                     type: "ref",
                     innerType: {
                         type: "boxed",
+                        ownership: "full",
                         innerType: "GError",
-                        lib: "libglib-2.0.so.0",
+                        lib: "libgobject-2.0.so.0",
                     },
                 },
                 value: error,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (error.value !== null) {
-            throw new NativeError(error.value);
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
         }
         return getNativeObject(ptr, Element);
     }
     /**
      * Create a new elementfactory capable of instantiating objects of the
      * `type` and add the factory to `plugin`.
-     * @param plugin - #GstPlugin to register the element with, or %NULL for
-     * @param name - name of elements of this type
-     * @param rank - rank of element (higher rank means more importance when autoplugging)
-     * @param type - GType of element to register
      */
     static register(name, rank, type, plugin) {
         return call("libgstreamer-1.0.so.0", "gst_element_register", [
             {
-                type: { type: "gobject", borrowed: true },
-                value: plugin?.id ?? plugin,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: plugin?.id,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: rank,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: type,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Gets a string representing the given state change result.
-     * @param stateRet - a #GstStateChangeReturn to get the name of.
-     */
+    /** Gets a string representing the given state change result. */
     static stateChangeReturnGetName(stateRet) {
         return call("libgstreamer-1.0.so.0", "gst_element_state_change_return_get_name", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: stateRet,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
-    /**
-     * Gets a string representing the given state.
-     * @param state - a #GstState to get the name of.
-     */
+    /** Gets a string representing the given state. */
     static stateGetName(state) {
         return call("libgstreamer-1.0.so.0", "gst_element_state_get_name", [
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: state,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
     /**
      * Marks `type` as "documentation should be skipped".
@@ -195,15 +202,20 @@ export class Element extends GstObject {
      * gst_element_type_set_skip_documentation (my_type);
      * gst_element_register (plugin, "my-plugin-feature-name", rank, my_type);
      * ```
-     * @param type - a #GType of element
      */
     static typeSetSkipDocumentation(type) {
         call("libgstreamer-1.0.so.0", "gst_element_type_set_skip_documentation", [
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: type,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Abort the state change of the element. This function is used
@@ -217,10 +229,15 @@ export class Element extends GstObject {
     abortState() {
         call("libgstreamer-1.0.so.0", "gst_element_abort_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Adds a pad (link point) to `element`. `pad`'s parent will be set to `element`;
@@ -232,80 +249,113 @@ export class Element extends GstObject {
      * The pad and the element should be unlocked when calling this function.
      *
      * This function will emit the #GstElement::pad-added signal on the element.
-     * @param pad - the #GstPad to add to the element.
      */
     addPad(pad) {
         return call("libgstreamer-1.0.so.0", "gst_element_add_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: pad?.id ?? pad,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: pad.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * @param propertyName - name of property to watch for changes, or
-     * @param includeValue - whether to include the new property value in the message
-     */
     addPropertyDeepNotifyWatch(includeValue, propertyName) {
         return call("libgstreamer-1.0.so.0", "gst_element_add_property_deep_notify_watch", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: propertyName,
                 optional: true,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: includeValue,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
-    /**
-     * @param propertyName - name of property to watch for changes, or
-     * @param includeValue - whether to include the new property value in the message
-     */
     addPropertyNotifyWatch(includeValue, propertyName) {
         return call("libgstreamer-1.0.so.0", "gst_element_add_property_notify_watch", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: propertyName,
                 optional: true,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: includeValue,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Perform `transition` on `element`.
      *
      * This function must be called with STATE_LOCK held and is mainly used
      * internally.
-     * @param transition - the requested transition
      */
     changeState(transition) {
         return call("libgstreamer-1.0.so.0", "gst_element_change_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: transition,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Commit the state change of the element and proceed to the next
@@ -321,19 +371,29 @@ export class Element extends GstObject {
      * or applications.
      *
      * This function must be called with STATE_LOCK held.
-     * @param ret - The previous state return value
      */
     continueState(ret) {
         return call("libgstreamer-1.0.so.0", "gst_element_continue_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: ret,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Creates a pad for each pad template that is always available.
@@ -343,10 +403,15 @@ export class Element extends GstObject {
     createAllPads() {
         call("libgstreamer-1.0.so.0", "gst_element_create_all_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Creates a stream-id for `element` by combining the upstream information with
@@ -362,19 +427,27 @@ export class Element extends GstObject {
      * Since stream IDs are sorted alphabetically, any numbers in the stream ID
      * should be printed with a fixed number of characters, preceded by 0's, such as
      * by using the format \%03u instead of \%u.
-     * @param streamId - The stream-id
      */
     decorateStreamId(streamId) {
         return call("libgstreamer-1.0.so.0", "gst_element_decorate_stream_id", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: streamId,
             },
-        ], { type: "string" });
+        ], {
+            type: "string",
+            ownership: "full",
+        });
     }
     /**
      * Returns the base time of the element. The base time is the
@@ -385,10 +458,17 @@ export class Element extends GstObject {
     getBaseTime() {
         return call("libgstreamer-1.0.so.0", "gst_element_get_base_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns the bus of the element. Note that only a #GstPipeline will provide a
@@ -397,10 +477,16 @@ export class Element extends GstObject {
     getBus() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_bus", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -415,10 +501,16 @@ export class Element extends GstObject {
     getClock() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_clock", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -431,31 +523,38 @@ export class Element extends GstObject {
      * This function will first attempt to find a compatible unlinked ALWAYS pad,
      * and if none can be found, it will request a compatible REQUEST pad by looking
      * at the templates of `element`.
-     * @param pad - the #GstPad to find a compatible one for.
-     * @param caps - the #GstCaps to use as a filter.
      */
     getCompatiblePad(pad, caps) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_compatible_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: pad?.id ?? pad,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: pad.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstCaps",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_caps_get_type",
                 },
-                value: caps?.id ?? caps,
+                value: caps?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -463,19 +562,27 @@ export class Element extends GstObject {
     /**
      * Retrieves a pad template from `element` that is compatible with `compattempl`.
      * Pads from compatible templates can be linked together.
-     * @param compattempl - the #GstPadTemplate to find a compatible
      */
     getCompatiblePadTemplate(compattempl) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_compatible_pad_template", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: compattempl?.id ?? compattempl,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: compattempl.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -484,21 +591,26 @@ export class Element extends GstObject {
      * Gets the context with `context_type` set on the element or NULL.
      *
      * MT safe.
-     * @param contextType - a name of a context to retrieve
      */
     getContext(contextType) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_context", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: contextType,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstContext",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_context_get_type",
@@ -507,23 +619,26 @@ export class Element extends GstObject {
             return null;
         return getNativeObject(ptr, Context);
     }
-    /**
-     * Gets the context with `context_type` set on the element or NULL.
-     * @param contextType - a name of a context to retrieve
-     */
+    /** Gets the context with `context_type` set on the element or NULL. */
     getContextUnlocked(contextType) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_context_unlocked", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: contextType,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstContext",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_context_get_type",
@@ -538,23 +653,27 @@ export class Element extends GstObject {
      * MT safe.
      */
     getContexts() {
-        return call("libgstreamer-1.0.so.0", "gst_element_get_contexts", [
+        const arr = call("libgstreamer-1.0.so.0", "gst_element_get_contexts", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "array",
             itemType: {
                 type: "boxed",
-                borrowed: true,
+                ownership: "full",
                 innerType: "GstContext",
                 lib: "libgstreamer-1.0.so.0",
                 getTypeFn: "gst_context_get_type",
             },
             listType: "glist",
-            borrowed: true,
+            ownership: "full",
         });
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * Returns the current clock time of the element, as in, the time of the
@@ -563,10 +682,17 @@ export class Element extends GstObject {
     getCurrentClockTime() {
         return call("libgstreamer-1.0.so.0", "gst_element_get_current_clock_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Returns the running time of the element. The running time is the
@@ -576,56 +702,79 @@ export class Element extends GstObject {
     getCurrentRunningTime() {
         return call("libgstreamer-1.0.so.0", "gst_element_get_current_running_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
-    /**
-     * Retrieves the factory that was used to create this element.
-     */
+    /** Retrieves the factory that was used to create this element. */
     getFactory() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_factory", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
     }
-    /**
-     * Get metadata with `key` in `klass`.
-     * @param key - the key to get
-     */
+    /** Get metadata with `key` in `klass`. */
     getMetadata(key) {
         return call("libgstreamer-1.0.so.0", "gst_element_get_metadata", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: key,
             },
-        ], { type: "string", borrowed: true });
+        ], {
+            type: "string",
+            ownership: "none",
+        });
     }
-    /**
-     * Retrieves a padtemplate from `element` with the given name.
-     * @param name - the name of the #GstPadTemplate to get.
-     */
+    /** Retrieves a padtemplate from `element` with the given name. */
     getPadTemplate(name) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_pad_template", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -635,36 +784,50 @@ export class Element extends GstObject {
      * list must not be modified by the calling code.
      */
     getPadTemplateList() {
-        const ptrs = call("libgstreamer-1.0.so.0", "gst_element_get_pad_template_list", [
+        const arr = call("libgstreamer-1.0.so.0", "gst_element_get_pad_template_list", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "array",
-            itemType: { type: "gobject", borrowed: true },
+            itemType: {
+                type: "gobject",
+                ownership: "none",
+            },
             listType: "glist",
-            borrowed: true,
+            ownership: "none",
         });
-        return ptrs.map((ptr) => getNativeObject(ptr));
+        return arr.map((item) => getNativeObject(item));
     }
     /**
      * The name of this function is confusing to people learning GStreamer.
      * gst_element_request_pad_simple() aims at making it more explicit it is
      * a simplified gst_element_request_pad().
-     * @param name - the name of the request #GstPad to retrieve.
      */
     getRequestPad(name) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_request_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -681,10 +844,17 @@ export class Element extends GstObject {
     getStartTime() {
         return call("libgstreamer-1.0.so.0", "gst_element_get_start_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Gets the state of the element.
@@ -707,20 +877,24 @@ export class Element extends GstObject {
      * some sink elements might not be able to complete their state change because
      * an element is not producing data to complete the preroll. When setting the
      * element to playing, the preroll will complete and playback will start.
-     * @param state - a pointer to #GstState to hold the state.
-     * @param pending - a pointer to #GstState to hold the pending
-     * @param timeout - a #GstClockTime to specify the timeout for an async
      */
     getState(timeout, state, pending) {
         return call("libgstreamer-1.0.so.0", "gst_element_get_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: state,
                 optional: true,
@@ -728,33 +902,53 @@ export class Element extends GstObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
                 },
                 value: pending,
                 optional: true,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: timeout,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Retrieves a pad from `element` by name. This version only retrieves
      * already-existing (i.e. 'static') pads.
-     * @param name - the name of the static #GstPad to retrieve.
      */
     getStaticPad(name) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_get_static_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -771,10 +965,15 @@ export class Element extends GstObject {
     isLockedState() {
         return call("libgstreamer-1.0.so.0", "gst_element_is_locked_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Retrieves an iterator of `element`'s pads. The iterator should
@@ -787,12 +986,15 @@ export class Element extends GstObject {
     iteratePads() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_iterate_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstIterator",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_iterator_get_type",
@@ -808,12 +1010,15 @@ export class Element extends GstObject {
     iterateSinkPads() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_iterate_sink_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstIterator",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_iterator_get_type",
@@ -829,12 +1034,15 @@ export class Element extends GstObject {
     iterateSrcPads() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_iterate_src_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstIterator",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_iterator_get_type",
@@ -850,19 +1058,26 @@ export class Element extends GstObject {
      *
      * Make sure you have added your elements to a bin or pipeline with
      * gst_bin_add() before trying to link them.
-     * @param dest - the #GstElement containing the destination pad.
      */
     link(dest) {
         return call("libgstreamer-1.0.so.0", "gst_element_link", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Links `src` to `dest` using the given caps as filtercaps.
@@ -873,105 +1088,132 @@ export class Element extends GstObject {
      *
      * Make sure you have added your elements to a bin or pipeline with
      * gst_bin_add() before trying to link them.
-     * @param dest - the #GstElement containing the destination pad.
-     * @param filter - the #GstCaps to filter the link,
      */
     linkFiltered(dest, filter) {
         return call("libgstreamer-1.0.so.0", "gst_element_link_filtered", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstCaps",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_caps_get_type",
                 },
-                value: filter?.id ?? filter,
+                value: filter?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Links the two named pads of the source and destination elements.
      * Side effect is that if one of the pads has no parent, it becomes a
      * child of the parent of the other element.  If they have different
      * parents, the link fails.
-     * @param srcpadname - the name of the #GstPad in source element
-     * @param dest - the #GstElement containing the destination pad.
-     * @param destpadname - the name of the #GstPad in destination element,
      */
     linkPads(dest, srcpadname, destpadname) {
         return call("libgstreamer-1.0.so.0", "gst_element_link_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: srcpadname,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: destpadname,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Links the two named pads of the source and destination elements. Side effect
      * is that if one of the pads has no parent, it becomes a child of the parent of
      * the other element. If they have different parents, the link fails. If `caps`
      * is not %NULL, makes sure that the caps of the link is a subset of `caps`.
-     * @param srcpadname - the name of the #GstPad in source element
-     * @param dest - the #GstElement containing the destination pad.
-     * @param destpadname - the name of the #GstPad in destination element
-     * @param filter - the #GstCaps to filter the link,
      */
     linkPadsFiltered(dest, srcpadname, destpadname, filter) {
         return call("libgstreamer-1.0.so.0", "gst_element_link_pads_filtered", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: srcpadname,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: destpadname,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstCaps",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_caps_get_type",
                 },
-                value: filter?.id ?? filter,
+                value: filter?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Links the two named pads of the source and destination elements.
@@ -984,36 +1226,50 @@ export class Element extends GstObject {
      * linking pads with safety checks applied.
      *
      * This is a convenience function for gst_pad_link_full().
-     * @param srcpadname - the name of the #GstPad in source element
-     * @param dest - the #GstElement containing the destination pad.
-     * @param destpadname - the name of the #GstPad in destination element,
-     * @param flags - the #GstPadLinkCheck to be performed when linking pads.
      */
     linkPadsFull(dest, flags, srcpadname, destpadname) {
         return call("libgstreamer-1.0.so.0", "gst_element_link_pads_full", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: srcpadname,
                 optional: true,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: destpadname,
                 optional: true,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Brings the element to the lost state. The current state of the
@@ -1036,10 +1292,15 @@ export class Element extends GstObject {
     lostState() {
         call("libgstreamer-1.0.so.0", "gst_element_lost_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Post an error, warning or info message on the bus from inside an element.
@@ -1048,122 +1309,172 @@ export class Element extends GstObject {
      * #GST_MESSAGE_INFO.
      *
      * MT safe.
-     * @param type - the #GstMessageType
-     * @param domain - the GStreamer GError domain this message belongs to
-     * @param code - the GError code belonging to the domain
-     * @param text - an allocated text string to be used
-     * @param debug - an allocated debug message to be
-     * @param file - the source code file where the error was generated
-     * @param _function - the source code function where the error was generated
-     * @param line - the source code line where the error was generated
      */
-    messageFull(type, domain, code, file, _function, line, text, debug) {
+    messageFull(type, domain, code, file, function_, line, text, debug) {
         call("libgstreamer-1.0.so.0", "gst_element_message_full", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: type,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: domain,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: code,
             },
             {
-                type: { type: "string" },
+                type: {
+                    type: "string",
+                    ownership: "full",
+                },
                 value: text,
                 optional: true,
             },
             {
-                type: { type: "string" },
+                type: {
+                    type: "string",
+                    ownership: "full",
+                },
                 value: debug,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: file,
             },
             {
-                type: { type: "string", borrowed: true },
-                value: _function,
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: function_,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: line,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Post an error, warning or info message on the bus from inside an element.
      *
      * `type` must be of #GST_MESSAGE_ERROR, #GST_MESSAGE_WARNING or
      * #GST_MESSAGE_INFO.
-     * @param type - the #GstMessageType
-     * @param domain - the GStreamer GError domain this message belongs to
-     * @param code - the GError code belonging to the domain
-     * @param text - an allocated text string to be used
-     * @param debug - an allocated debug message to be
-     * @param file - the source code file where the error was generated
-     * @param _function - the source code function where the error was generated
-     * @param line - the source code line where the error was generated
-     * @param structure - optional details structure
      */
-    messageFullWithDetails(type, domain, code, file, _function, line, structure, text, debug) {
+    messageFullWithDetails(type, domain, code, file, function_, line, structure, text, debug) {
         call("libgstreamer-1.0.so.0", "gst_element_message_full_with_details", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: type,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: domain,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: code,
             },
             {
-                type: { type: "string" },
+                type: {
+                    type: "string",
+                    ownership: "full",
+                },
                 value: text,
                 optional: true,
             },
             {
-                type: { type: "string" },
+                type: {
+                    type: "string",
+                    ownership: "full",
+                },
                 value: debug,
                 optional: true,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: file,
             },
             {
-                type: { type: "string", borrowed: true },
-                value: _function,
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: function_,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: line,
             },
             {
                 type: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GstStructure",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_structure_get_type",
                 },
-                value: structure?.id ?? structure,
+                value: structure.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Use this function to signal that the element does not expect any more pads
@@ -1179,33 +1490,43 @@ export class Element extends GstObject {
     noMorePads() {
         call("libgstreamer-1.0.so.0", "gst_element_no_more_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Post a message on the element's #GstBus. This function takes ownership of the
      * message; if you want to access the message after this call, you should add an
      * additional reference before calling.
-     * @param message - a #GstMessage to post
      */
     postMessage(message) {
         return call("libgstreamer-1.0.so.0", "gst_element_post_message", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GstMessage",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_message_get_type",
                 },
-                value: message?.id ?? message,
+                value: message.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Get the clock provided by the given element.
@@ -1215,10 +1536,16 @@ export class Element extends GstObject {
     provideClock() {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_provide_clock", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -1231,59 +1558,78 @@ export class Element extends GstObject {
      * random linked sinkpad of this element.
      *
      * Please note that some queries might need a running pipeline to work.
-     * @param query - the #GstQuery.
      */
     query(query) {
         return call("libgstreamer-1.0.so.0", "gst_element_query", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstQuery",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_query_get_type",
                 },
-                value: query?.id ?? query,
+                value: query.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Queries an element to convert `src_val` in `src_format` to `dest_format`.
-     * @param srcFormat - a #GstFormat to convert from.
-     * @param srcVal - a value to convert.
-     * @param destFormat - the #GstFormat to convert to.
-     * @param destVal - a pointer to the result.
-     */
+    /** Queries an element to convert `src_val` in `src_format` to `dest_format`. */
     queryConvert(srcFormat, srcVal, destFormat, destVal) {
         return call("libgstreamer-1.0.so.0", "gst_element_query_convert", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: srcFormat,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: srcVal,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: destFormat,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
                 },
                 value: destVal,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Queries an element (usually top-level pipeline or playbin element) for the
@@ -1294,28 +1640,39 @@ export class Element extends GstObject {
      * If the duration changes for some reason, you will get a DURATION_CHANGED
      * message on the pipeline bus, in which case you should re-query the duration
      * using this function.
-     * @param format - the #GstFormat requested
-     * @param duration - A location in which to store the total duration, or %NULL.
      */
     queryDuration(format, duration) {
         return call("libgstreamer-1.0.so.0", "gst_element_query_duration", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
                 },
                 value: duration,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Queries an element (usually top-level pipeline or playbin element) for the
@@ -1327,28 +1684,39 @@ export class Element extends GstObject {
      *
      * If one repeatedly calls this function one can also create a query and reuse
      * it in gst_element_query().
-     * @param format - the #GstFormat requested
-     * @param cur - a location in which to store the current
      */
     queryPosition(format, cur) {
         return call("libgstreamer-1.0.so.0", "gst_element_query_position", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: false },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: false,
+                    },
                 },
                 value: cur,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Makes the element free the previously requested pad as obtained
@@ -1359,19 +1727,26 @@ export class Element extends GstObject {
      * followed by gst_object_unref() to free the `pad`.
      *
      * MT safe.
-     * @param pad - the #GstPad to release.
      */
     releaseRequestPad(pad) {
         call("libgstreamer-1.0.so.0", "gst_element_release_request_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: pad?.id ?? pad,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: pad.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Removes `pad` from `element`. `pad` will be destroyed if it has not been
@@ -1390,34 +1765,47 @@ export class Element extends GstObject {
      * The pad and the element should be unlocked when calling this function.
      *
      * This function will emit the #GstElement::pad-removed signal on the element.
-     * @param pad - the #GstPad to remove from the element.
      */
     removePad(pad) {
         return call("libgstreamer-1.0.so.0", "gst_element_remove_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: pad?.id ?? pad,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: pad.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * @param watchId - watch id to remove
-     */
     removePropertyNotifyWatch(watchId) {
         call("libgstreamer-1.0.so.0", "gst_element_remove_property_notify_watch", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: watchId,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Retrieves a request pad from the element according to the provided template.
@@ -1425,37 +1813,46 @@ export class Element extends GstObject {
      * gst_element_factory_get_static_pad_templates().
      *
      * The pad should be released with gst_element_release_request_pad().
-     * @param templ - a #GstPadTemplate of which we want a pad of.
-     * @param name - the name of the request #GstPad
-     * @param caps - the caps of the pad we want to
      */
     requestPad(templ, name, caps) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_request_pad", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: templ?.id ?? templ,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: templ.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
                 optional: true,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstCaps",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_caps_get_type",
                 },
-                value: caps?.id ?? caps,
+                value: caps?.id,
                 optional: true,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -1473,19 +1870,27 @@ export class Element extends GstObject {
      * a better name to gst_element_get_request_pad(). Prior to 1.20, users
      * should use gst_element_get_request_pad() which provides the same
      * functionality.
-     * @param name - the name of the request #GstPad to retrieve.
      */
     requestPadSimple(name) {
         const ptr = call("libgstreamer-1.0.so.0", "gst_element_request_pad_simple", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: name,
             },
-        ], { type: "gobject", borrowed: true });
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
         if (ptr === null)
             return null;
         return getNativeObject(ptr);
@@ -1496,49 +1901,74 @@ export class Element extends GstObject {
      * gst_element_send_event().
      *
      * MT safe.
-     * @param rate - The new playback rate
-     * @param format - The format of the seek values
-     * @param flags - The optional seek flags.
-     * @param startType - The type and flags for the new start position
-     * @param start - The value of the new start position
-     * @param stopType - The type and flags for the new stop position
-     * @param stop - The value of the new stop position
      */
     seek(rate, format, flags, startType, start, stopType, stop) {
         return call("libgstreamer-1.0.so.0", "gst_element_seek", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "float", size: 64 },
+                type: {
+                    type: "float",
+                    size: 64,
+                },
                 value: rate,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: flags,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: startType,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: start,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: stopType,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: stop,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Simple API to perform a seek on the given element, meaning it just seeks
@@ -1555,29 +1985,43 @@ export class Element extends GstObject {
      * case they will store the seek event and execute it when they are put to
      * PAUSED. If the element supports seek in READY, it will always return %TRUE when
      * it receives the event in the READY state.
-     * @param format - a #GstFormat to execute the seek in, such as #GST_FORMAT_TIME
-     * @param seekFlags - seek options; playback applications will usually want to use
-     * @param seekPos - position to seek to (relative to the start); if you are doing
      */
     seekSimple(format, seekFlags, seekPos) {
         return call("libgstreamer-1.0.so.0", "gst_element_seek_simple", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 32, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
                 value: seekFlags,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: seekPos,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sends an event to an element. If the element doesn't implement an
@@ -1588,105 +2032,136 @@ export class Element extends GstObject {
      * gst_event_ref() it if you want to reuse the event after this call.
      *
      * MT safe.
-     * @param event - the #GstEvent to send to the element.
      */
     sendEvent(event) {
         return call("libgstreamer-1.0.so.0", "gst_element_send_event", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
+                    ownership: "full",
                     innerType: "GstEvent",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_event_get_type",
                 },
-                value: event?.id ?? event,
+                value: event.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Set the base time of an element. See gst_element_get_base_time().
      *
      * MT safe.
-     * @param time - the base time to set.
      */
     setBaseTime(time) {
         call("libgstreamer-1.0.so.0", "gst_element_set_base_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: time,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the bus of the element. Increases the refcount on the bus.
      * For internal use only, unless you're testing elements.
      *
      * MT safe.
-     * @param bus - the #GstBus to set.
      */
     setBus(bus) {
         call("libgstreamer-1.0.so.0", "gst_element_set_bus", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: bus?.id ?? bus,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: bus?.id,
                 optional: true,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the clock for the element. This function increases the
      * refcount on the clock. Any previously set clock on the object
      * is unreffed.
-     * @param clock - the #GstClock to set for the element.
      */
     setClock(clock) {
         return call("libgstreamer-1.0.so.0", "gst_element_set_clock", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: clock?.id ?? clock,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: clock?.id,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Sets the context of the element. Increases the refcount of the context.
      *
      * MT safe.
-     * @param context - the #GstContext to set.
      */
     setContext(context) {
         call("libgstreamer-1.0.so.0", "gst_element_set_context", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstContext",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_context_get_type",
                 },
-                value: context?.id ?? context,
+                value: context.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Locks the state of an element, so state changes of the parent don't affect
@@ -1697,19 +2172,25 @@ export class Element extends GstObject {
      * next step proceed to change the child element's state.
      *
      * MT safe.
-     * @param lockedState - %TRUE to lock the element's state
      */
     setLockedState(lockedState) {
         return call("libgstreamer-1.0.so.0", "gst_element_set_locked_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "boolean" },
+                type: {
+                    type: "boolean",
+                },
                 value: lockedState,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Set the start time of an element. The start time of the element is the
@@ -1724,19 +2205,27 @@ export class Element extends GstObject {
      * pipelines, and you can also ensure that the pipelines have the same clock.
      *
      * MT safe.
-     * @param time - the base time to set.
      */
     setStartTime(time) {
         call("libgstreamer-1.0.so.0", "gst_element_set_start_time", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: time,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Sets the state of the element. This function will try to set the
@@ -1752,19 +2241,29 @@ export class Element extends GstObject {
      *
      * State changes to %GST_STATE_READY or %GST_STATE_NULL never return
      * #GST_STATE_CHANGE_ASYNC.
-     * @param state - the element's new #GstState.
      */
     setState(state) {
         return call("libgstreamer-1.0.so.0", "gst_element_set_state", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: state,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Tries to change the state of the element to the same as its parent.
@@ -1773,10 +2272,15 @@ export class Element extends GstObject {
     syncStateWithParent() {
         return call("libgstreamer-1.0.so.0", "gst_element_sync_state_with_parent", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Unlinks all source pads of the source element with all sink pads
@@ -1784,79 +2288,146 @@ export class Element extends GstObject {
      *
      * If the link has been made using gst_element_link(), it could have created an
      * requestpad, which has to be released using gst_element_release_request_pad().
-     * @param dest - the sink #GstElement to unlink.
      */
     unlink(dest) {
         call("libgstreamer-1.0.so.0", "gst_element_unlink", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Unlinks the two named pads of the source and destination elements.
      *
      * This is a convenience function for gst_pad_unlink().
-     * @param srcpadname - the name of the #GstPad in source element.
-     * @param dest - a #GstElement containing the destination pad.
-     * @param destpadname - the name of the #GstPad in destination element.
      */
     unlinkPads(srcpadname, dest, destpadname) {
         call("libgstreamer-1.0.so.0", "gst_element_unlink_pads", [
             {
-                type: { type: "gobject" },
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
                 value: this.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: srcpadname,
             },
             {
-                type: { type: "gobject", borrowed: true },
-                value: dest?.id ?? dest,
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: dest.id,
             },
             {
-                type: { type: "string", borrowed: true },
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
                 value: destpadname,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     connect(signal, handler, after = false) {
-        const meta = SIGNAL_META[signal];
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
-        const returnType = meta?.returnType;
-        const wrappedHandler = (...args) => {
-            const self = getNativeObject(args[0]);
-            const callbackArgs = args.slice(1);
-            if (!meta)
-                return handler(self, ...callbackArgs);
-            const wrapped = meta.params.map((t, i) => {
-                if (t?.type === "gobject" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i]);
-                }
-                if (t?.type === "gparam" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libgstreamer-1.0.so.0", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
+        switch (signal) {
+            case "no-more-pads": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]));
+                };
+                return call("libgstreamer-1.0.so.0", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [{ type: "gobject", ownership: "none" }],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "pad-added": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1]));
+                };
+                return call("libgstreamer-1.0.so.0", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            case "pad-removed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), getNativeObject(args[1]));
+                };
+                return call("libgstreamer-1.0.so.0", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
     }
 }
 registerNativeClass(Element);