@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gst/segment.js

@@ -9,8 +9,8 @@ import { registerNativeClass } from "../../registry.js";
  *
  * The structure can be used for two purposes:
  *
- * * performing seeks (handling seek events)
- * * tracking playback regions (handling newsegment events)
+ *   * performing seeks (handling seek events)
+ *   * tracking playback regions (handling newsegment events)
  *
  * The segment is usually configured by the application with a seek event which
  * is propagated upstream and eventually handled by an element that performs the seek.
@@ -62,20 +62,14 @@ export class Segment extends NativeObject {
      */
     constructor() {
         super();
-        this.id = this.createPtr([]);
-    }
-    createPtr(_args) {
-        return call("libgstreamer-1.0.so.0", "gst_segment_new", [], {
+        this.id = call("libgstreamer-1.0.so.0", "gst_segment_new", [], {
             type: "boxed",
-            borrowed: true,
+            ownership: "none",
             innerType: "GstSegment",
+            lib: "libgstreamer-1.0.so.0",
+            getTypeFn: "gst_segment_get_type",
         });
     }
-    static fromPtr(ptr) {
-        const instance = Object.create(Segment.prototype);
-        instance.id = ptr;
-        return instance;
-    }
     /**
      * Clip the given `start` and `stop` values to the segment boundaries given
      * in `segment`. `start` and `stop` are compared and clipped to `segment`
@@ -90,39 +84,50 @@ export class Segment extends NativeObject {
      *
      * Note that when `stop` is -1, `clip_stop` will be set to the end of the
      * segment. Depending on the use case, this may or may not be what you want.
-     * @param format - the format of the segment.
-     * @param start - the start position in the segment
-     * @param stop - the stop position in the segment
-     * @param clipStart - the clipped start position in the segment
-     * @param clipStop - the clipped stop position in the segment
      */
     clip(format, start, stop, clipStart, clipStop) {
         return call("libgstreamer-1.0.so.0", "gst_segment_clip", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: start,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: stop,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: clipStart,
                 optional: true,
@@ -130,12 +135,18 @@ export class Segment extends NativeObject {
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: clipStop,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Create a copy of given `segment`.
@@ -147,7 +158,7 @@ export class Segment extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
@@ -155,23 +166,20 @@ export class Segment extends NativeObject {
             },
         ], {
             type: "boxed",
-            borrowed: true,
+            ownership: "full",
             innerType: "GstSegment",
             lib: "libgstreamer-1.0.so.0",
             getTypeFn: "gst_segment_get_type",
         });
         return getNativeObject(ptr, Segment);
     }
-    /**
-     * Copy the contents of `src` into `dest`.
-     * @param dest - a #GstSegment
-     */
+    /** Copy the contents of `src` into `dest`. */
     copyInto(dest) {
         call("libgstreamer-1.0.so.0", "gst_segment_copy_into", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
@@ -180,14 +188,16 @@ export class Segment extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_segment_get_type",
                 },
-                value: dest?.id ?? dest,
+                value: dest.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Update the segment structure with the field values of a seek event (see
@@ -217,76 +227,102 @@ export class Segment extends NativeObject {
      * `update` will be set to %TRUE if a seek should be performed to the segment
      * position field. This field can be %FALSE if, for example, only the `rate`
      * has been changed but not the playback position.
-     * @param rate - the rate of the segment.
-     * @param format - the format of the segment.
-     * @param flags - the segment flags for the segment
-     * @param startType - the seek method
-     * @param start - the seek start value
-     * @param stopType - the seek method
-     * @param stop - the seek stop value
-     * @param update - boolean holding whether position was updated.
      */
     doSeek(rate, format, flags, startType, start, stopType, stop, update) {
         return call("libgstreamer-1.0.so.0", "gst_segment_do_seek", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 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: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: start,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: stopType,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: stop,
             },
             {
-                type: { type: "ref", innerType: { type: "boolean" } },
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boolean",
+                    },
+                },
                 value: update,
                 optional: true,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
-    /**
-     * Free the allocated segment `segment`.
-     */
+    /** Free the allocated segment `segment`. */
     free() {
         call("libgstreamer-1.0.so.0", "gst_segment_free", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * The start/position fields are set to 0 and the stop/duration
@@ -294,36 +330,40 @@ export class Segment extends NativeObject {
      * flags are set.
      *
      * Initialize `segment` to its default values.
-     * @param format - the format of the segment.
      */
     init(format) {
         call("libgstreamer-1.0.so.0", "gst_segment_init", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
-        ], { type: "undefined" });
+        ], {
+            type: "undefined",
+        });
     }
     /**
      * Checks for two segments being equal. Equality here is defined
      * as perfect equality, including floating point values.
-     * @param s1 - a #GstSegment structure.
      */
     isEqual(s1) {
         return call("libgstreamer-1.0.so.0", "gst_segment_is_equal", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
@@ -332,68 +372,88 @@ export class Segment extends NativeObject {
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                     getTypeFn: "gst_segment_get_type",
                 },
-                value: s1?.id ?? s1,
+                value: s1.id,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Adjust the values in `segment` so that `offset` is applied to all
      * future running-time calculations.
-     * @param format - the format of the segment.
-     * @param offset - the offset to apply in the segment
      */
     offsetRunningTime(format, offset) {
         return call("libgstreamer-1.0.so.0", "gst_segment_offset_running_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: false,
+                },
                 value: offset,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Convert `running_time` into a position in the segment so that
      * gst_segment_to_running_time() with that position returns `running_time`.
-     * @param format - the format of the segment.
-     * @param runningTime - the running_time in the segment
      */
     positionFromRunningTime(format, runningTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_position_from_running_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: runningTime,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Translate `running_time` to the segment position using the currently configured
@@ -412,64 +472,87 @@ export class Segment extends NativeObject {
      * When this function returns -1, the returned `position` was < 0, and the value
      * in the position variable should be negated to get the real negative segment
      * position.
-     * @param format - the format of the segment.
-     * @param runningTime - the running-time
-     * @param position - the resulting position in the segment
      */
     positionFromRunningTimeFull(format, runningTime, position) {
         return call("libgstreamer-1.0.so.0", "gst_segment_position_from_running_time_full", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: runningTime,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: position,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Convert `stream_time` into a position in the segment so that
      * gst_segment_to_stream_time() with that position returns `stream_time`.
-     * @param format - the format of the segment.
-     * @param streamTime - the stream_time in the segment
      */
     positionFromStreamTime(format, streamTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_position_from_stream_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: streamTime,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Translate `stream_time` to the segment position using the currently configured
@@ -487,91 +570,122 @@ export class Segment extends NativeObject {
      *
      * When this function returns -1, the returned `position` should be negated
      * to get the real negative segment position.
-     * @param format - the format of the segment.
-     * @param streamTime - the stream-time
-     * @param position - the resulting position in the segment
      */
     positionFromStreamTimeFull(format, streamTime, position) {
         return call("libgstreamer-1.0.so.0", "gst_segment_position_from_stream_time_full", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: streamTime,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: position,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Adjust the start/stop and base values of `segment` such that the next valid
      * buffer will be one with `running_time`.
-     * @param format - the format of the segment.
-     * @param runningTime - the running_time in the segment
      */
     setRunningTime(format, runningTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_set_running_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: runningTime,
             },
-        ], { type: "boolean" });
+        ], {
+            type: "boolean",
+        });
     }
     /**
      * Convert `running_time` into a position in the segment so that
      * gst_segment_to_running_time() with that position returns `running_time`.
-     * @param format - the format of the segment.
-     * @param runningTime - the running_time in the segment
      */
     toPosition(format, runningTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_to_position", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: runningTime,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Translate `position` to the total running time using the currently configured
@@ -583,29 +697,39 @@ export class Segment extends NativeObject {
      * 0.
      *
      * This function returns -1 if the position is outside of `segment` start and stop.
-     * @param format - the format of the segment.
-     * @param position - the position in the segment
      */
     toRunningTime(format, position) {
         return call("libgstreamer-1.0.so.0", "gst_segment_to_running_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: position,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Translate `position` to the total running time using the currently configured
@@ -623,38 +747,51 @@ export class Segment extends NativeObject {
      *
      * When this function returns -1, the returned `running_time` should be negated
      * to get the real negative running time.
-     * @param format - the format of the segment.
-     * @param position - the position in the segment
-     * @param runningTime - result running-time
      */
     toRunningTimeFull(format, position, runningTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_to_running_time_full", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: position,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: runningTime,
                 optional: true,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /**
      * Translate `position` to stream time using the currently configured
@@ -667,29 +804,39 @@ export class Segment extends NativeObject {
      * clock time that one wants to convert to the stream time.
      * The stream time is always between 0 and the total duration of the
      * media stream.
-     * @param format - the format of the segment.
-     * @param position - the position in the segment
      */
     toStreamTime(format, position) {
         return call("libgstreamer-1.0.so.0", "gst_segment_to_stream_time", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: position,
             },
-        ], { type: "int", size: 64, unsigned: true });
+        ], {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        });
     }
     /**
      * Translate `position` to the total stream time using the currently configured
@@ -707,173 +854,262 @@ export class Segment extends NativeObject {
      *
      * When this function returns -1, the returned `stream_time` should be negated
      * to get the real negative stream time.
-     * @param format - the format of the segment.
-     * @param position - the position in the segment
-     * @param streamTime - result stream-time
      */
     toStreamTimeFull(format, position, streamTime) {
         return call("libgstreamer-1.0.so.0", "gst_segment_to_stream_time_full", [
             {
                 type: {
                     type: "boxed",
-                    borrowed: true,
+                    ownership: "none",
                     innerType: "GstSegment",
                     lib: "libgstreamer-1.0.so.0",
                 },
                 value: this.id,
             },
             {
-                type: { type: "int", size: 32, unsigned: false },
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
                 value: format,
             },
             {
-                type: { type: "int", size: 64, unsigned: true },
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
                 value: position,
             },
             {
                 type: {
                     type: "ref",
-                    innerType: { type: "int", size: 64, unsigned: true },
+                    innerType: {
+                        type: "int",
+                        size: 64,
+                        unsigned: true,
+                    },
                 },
                 value: streamTime,
             },
-        ], { type: "int", size: 32, unsigned: false });
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        });
     }
     /** flags for this segment */
     get flags() {
-        return read(this.id, { type: "int", size: 32, unsigned: true }, 0);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        }, 0);
     }
     /**
      * the playback rate of the segment is set in response to a seek
-     * event and, without any seek, the value should be `1.0`. This
-     * value is used by elements that synchronize buffer [running
-     * times](additional/design/synchronisation.md#running-time) on
-     * the clock (usually the sink elements), leading to consuming
-     * buffers faster (for a value `> 1.0`) or slower (for `0.0 <
-     * value < 1.0`) than normal playback speed. The rate also
-     * defines the playback direction, meaning that when the value is
-     * lower than `0.0`, the playback happens in reverse, and the
-     * [stream-time](additional/design/synchronisation.md#stream-time)
-     * is going backward. The `rate` value should never be `0.0`.
+     *                event and, without any seek, the value should be `1.0`. This
+     *                value is used by elements that synchronize buffer [running
+     *                times](additional/design/synchronisation.md#running-time) on
+     *                the clock (usually the sink elements), leading to consuming
+     *                buffers faster (for a value `> 1.0`) or slower (for `0.0 <
+     *                value < 1.0`) than normal playback speed. The rate also
+     *                defines the playback direction, meaning that when the value is
+     *                lower than `0.0`, the playback happens in reverse, and the
+     *                [stream-time](additional/design/synchronisation.md#stream-time)
+     *                is going backward. The `rate` value should never be `0.0`.
      */
     get rate() {
-        return read(this.id, { type: "float", size: 64 }, 8);
+        return read(this.id, {
+            type: "float",
+            size: 64,
+        }, 8);
     }
     set rate(value) {
-        write(this.id, { type: "float", size: 64 }, 8, value);
+        write(this.id, {
+            type: "float",
+            size: 64,
+        }, 8, value);
     }
     /**
      * The applied rate is the rate that has been applied to the stream.
-     * The effective/resulting playback rate of a stream is
-     * `rate * applied_rate`.
-     * The applied rate can be set by source elements when a server is
-     * sending the stream with an already modified playback speed
-     * rate. Filter elements that modify the stream in a way that
-     * modifies the playback speed should also modify the applied
-     * rate. For example the #videorate element when its
-     * #videorate:rate property is set will set the applied rate of
-     * the segment it pushed downstream. Also #scaletempo applies the
-     * input segment rate to the stream and outputs a segment with
-     * rate=1.0 and applied_rate=<inputsegment.rate>.
+     *                The effective/resulting playback rate of a stream is
+     *                `rate * applied_rate`.
+     *                The applied rate can be set by source elements when a server is
+     *                sending the stream with an already modified playback speed
+     *                rate. Filter elements that modify the stream in a way that
+     *                modifies the playback speed should also modify the applied
+     *                rate. For example the #videorate element when its
+     *                #videorate:rate property is set will set the applied rate of
+     *                the segment it pushed downstream. Also #scaletempo applies the
+     *                input segment rate to the stream and outputs a segment with
+     *                rate=1.0 and applied_rate=<inputsegment.rate>.
      */
     get appliedRate() {
-        return read(this.id, { type: "float", size: 64 }, 16);
+        return read(this.id, {
+            type: "float",
+            size: 64,
+        }, 16);
     }
     set appliedRate(value) {
-        write(this.id, { type: "float", size: 64 }, 16, value);
+        write(this.id, {
+            type: "float",
+            size: 64,
+        }, 16, value);
     }
     /** the unit used for all of the segment's values. */
     get format() {
-        return read(this.id, { type: "int", size: 32, unsigned: false }, 24);
+        return read(this.id, {
+            type: "int",
+            size: 32,
+            unsigned: false,
+        }, 24);
     }
     /**
      * the running time (plus elapsed time, see offset) of the
-     * segment [start](GstSegment.start) ([stop](GstSegment.stop) if
-     * rate < 0.0).
+     *                segment [start](GstSegment.start) ([stop](GstSegment.stop) if
+     *                rate < 0.0).
      */
     get base() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 32);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 32);
     }
     set base(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 32, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 32, value);
     }
     /**
      * the offset expresses the elapsed time (in buffer timestamps)
-     * before a seek with its start (stop if rate < 0.0) seek type
-     * set to #GST_SEEK_TYPE_NONE, the value is set to the position
-     * of the segment at the time of the seek.
+     *                before a seek with its start (stop if rate < 0.0) seek type
+     *                set to #GST_SEEK_TYPE_NONE, the value is set to the position
+     *                of the segment at the time of the seek.
      */
     get offset() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 40);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 40);
     }
     set offset(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 40, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 40, value);
     }
     /**
      * the start time of the segment (in buffer timestamps)
-     * [(PTS)](GstBuffer.pts), that is the timestamp of the first
-     * buffer to output inside the segment (last one during
-     * reverse playback). For example decoders will
-     * [clip](gst_segment_clip) out the buffers before the start
-     * time.
+     *                [(PTS)](GstBuffer.pts), that is the timestamp of the first
+     *                buffer to output inside the segment (last one during
+     *                reverse playback). For example decoders will
+     *                [clip](gst_segment_clip) out the buffers before the start
+     *                time.
      */
     get start() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 48);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 48);
     }
     set start(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 48, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 48, value);
     }
     /**
      * the stop time of the segment (in buffer timestamps)
-     * [(PTS)](GstBuffer.pts), that is the timestamp of the last
-     * buffer to output inside the segment (first one during
-     * reverse playback). For example decoders will
-     * [clip](gst_segment_clip) out buffers after the stop time.
+     *                [(PTS)](GstBuffer.pts), that is the timestamp of the last
+     *                buffer to output inside the segment (first one during
+     *                reverse playback). For example decoders will
+     *                [clip](gst_segment_clip) out buffers after the stop time.
      */
     get stop() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 56);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 56);
     }
     set stop(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 56, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 56, value);
     }
     /**
      * the stream time of the segment [start](GstSegment.start)
-     * ([stop](GstSegment.stop) if rate < 0.0).
+     *                ([stop](GstSegment.stop) if rate < 0.0).
      */
     get time() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 64);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 64);
     }
     set time(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 64, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 64, value);
     }
     /**
      * the buffer timestamp position in the segment is supposed to be
-     * updated by elements such as sources, demuxers or parsers to
-     * track progress by setting it to the last pushed buffer' end time
-     * ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
-     * specific segment. The position is used when reconfiguring the
-     * segment with #gst_segment_do_seek when the seek is only
-     * updating the segment (see [offset](GstSegment.offset)).
+     *                updated by elements such as sources, demuxers or parsers to
+     *                track progress by setting it to the last pushed buffer' end time
+     *                ([timestamp](GstBuffer.pts) + #GstBuffer.duration) for that
+     *                specific segment. The position is used when reconfiguring the
+     *                segment with #gst_segment_do_seek when the seek is only
+     *                updating the segment (see [offset](GstSegment.offset)).
      */
     get position() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 72);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 72);
     }
     set position(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 72, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 72, value);
     }
     /**
      * the duration of the segment is the maximum absolute difference
-     * between #GstSegment.start and #GstSegment.stop if stop is not
-     * set, otherwise it should be the difference between those
-     * two values. This should be set by elements that know the
-     * overall stream duration (like demuxers) and will be used when
-     * seeking with #GST_SEEK_TYPE_END.
+     *                between #GstSegment.start and #GstSegment.stop if stop is not
+     *                set, otherwise it should be the difference between those
+     *                two values. This should be set by elements that know the
+     *                overall stream duration (like demuxers) and will be used when
+     *                seeking with #GST_SEEK_TYPE_END.
      */
     get duration() {
-        return read(this.id, { type: "int", size: 64, unsigned: true }, 80);
+        return read(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 80);
     }
     set duration(value) {
-        write(this.id, { type: "int", size: 64, unsigned: true }, 80, value);
+        write(this.id, {
+            type: "int",
+            size: 64,
+            unsigned: true,
+        }, 80, value);
     }
 }
 registerNativeClass(Segment);