@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gst/message.d.ts

@@ -25,7 +25,7 @@ import * as GObject from "../gobject/index.js";
  *
  * The basic use pattern of posting a message on a #GstBus is as follows:
  * |[<!-- language="C" -->
- * gst_bus_post (bus, gst_message_new_eos());
+ *   gst_bus_post (bus, gst_message_new_eos());
  * ]|
  *
  * A #GstElement usually posts messages on the bus provided by the parent
@@ -37,26 +37,18 @@ export declare class Message extends NativeObject {
     /**
      * Create a new application-typed message. GStreamer will never create these
      * messages; they are a gift from us to you. Enjoy.
-     * @param src - The object originating the message.
-     * @param structure - the structure for the message. The message
      */
-    constructor(structure: Structure, src?: GstObject);
-    constructor(_args: unknown[]);
+    constructor(structure: Structure, src?: GstObject | null);
     /**
      * The message is posted when elements completed an ASYNC state change.
      * `running_time` contains the time of the desired running_time when this
      * elements goes to PLAYING. A value of #GST_CLOCK_TIME_NONE for `running_time`
      * means that the element has no clock interaction and thus doesn't care about
      * the running_time of the pipeline.
-     * @param src - The object originating the message.
-     * @param runningTime - the desired running_time
      */
-    static newAsyncDone(runningTime: number, src?: GstObject): Message;
-    /**
-     * This message is posted by elements when they start an ASYNC state change.
-     * @param src - The object originating the message.
-     */
-    static newAsyncStart(src?: GstObject): Message;
+    static newAsyncDone(runningTime: number, src?: GstObject | null): Message;
+    /** This message is posted by elements when they start an ASYNC state change. */
+    static newAsyncStart(src?: GstObject | null): Message;
     /**
      * Create a new buffering message. This message can be posted by an element that
      * needs to buffer data before it can continue processing. `percent` should be a
@@ -70,10 +62,8 @@ export declare class Message extends NativeObject {
      * completed prerolling.
      *
      * MT safe.
-     * @param src - The object originating the message.
-     * @param percent - The buffering percent
      */
-    static newBuffering(percent: number, src?: GstObject): Message;
+    static newBuffering(percent: number, src?: GstObject | null): Message;
     /**
      * Create a clock lost message. This message is posted whenever the
      * clock is not valid anymore.
@@ -81,10 +71,8 @@ export declare class Message extends NativeObject {
      * If this message is posted by the pipeline, the pipeline will
      * select a new clock again when it goes to PLAYING. It might therefore
      * be needed to set the pipeline to PAUSED and PLAYING again.
-     * @param src - The object originating the message.
-     * @param clock - the clock that was lost
      */
-    static newClockLost(clock: Clock, src?: GstObject): Message;
+    static newClockLost(clock: Clock, src?: GstObject | null): Message;
     /**
      * Create a clock provide message. This message is posted whenever an
      * element is ready to provide a clock or lost its ability to provide
@@ -92,113 +80,78 @@ export declare class Message extends NativeObject {
      *
      * This message is mainly used internally to manage the clock
      * selection.
-     * @param src - The object originating the message.
-     * @param clock - the clock it provides
-     * @param ready - %TRUE if the sender can provide a clock
      */
-    static newClockProvide(clock: Clock, ready: boolean, src?: GstObject): Message;
+    static newClockProvide(clock: Clock, ready: boolean, src?: GstObject | null): Message;
     /**
      * Create a new custom-typed message. This can be used for anything not
      * handled by other message-specific functions to pass a message to the
      * app. The structure field can be %NULL.
-     * @param type - The #GstMessageType to distinguish messages
-     * @param src - The object originating the message.
-     * @param structure - the structure for the
      */
-    static newCustom(type: MessageType, src?: GstObject, structure?: Structure): Message;
+    static newCustom(type: MessageType, src?: GstObject | null, structure?: Structure | null): Message;
     /**
      * Creates a new device-added message. The device-added message is produced by
      * #GstDeviceProvider or a #GstDeviceMonitor. They announce the appearance
      * of monitored devices.
-     * @param src - The #GstObject that created the message
-     * @param device - The new #GstDevice
      */
-    static newDeviceAdded(device: Device, src?: GstObject): Message;
+    static newDeviceAdded(device: Device, src?: GstObject | null): Message;
     /**
      * Creates a new device-changed message. The device-changed message is produced
      * by #GstDeviceProvider or a #GstDeviceMonitor. They announce that a device
      * properties has changed and `device` represent the new modified version of `changed_device`.
-     * @param src - The #GstObject that created the message
-     * @param device - The newly created device representing `changed_device`
-     * @param changedDevice - The old version of the device.
      */
-    static newDeviceChanged(device: Device, changedDevice: Device, src?: GstObject): Message;
+    static newDeviceChanged(device: Device, changedDevice: Device, src?: GstObject | null): Message;
     /**
      * Creates a new device-removed message. The device-removed message is produced
      * by #GstDeviceProvider or a #GstDeviceMonitor. They announce the
      * disappearance of monitored devices.
-     * @param src - The #GstObject that created the message
-     * @param device - The removed #GstDevice
      */
-    static newDeviceRemoved(device: Device, src?: GstObject): Message;
+    static newDeviceRemoved(device: Device, src?: GstObject | null): Message;
     /**
      * Create a new duration changed message. This message is posted by elements
      * that know the duration of a stream when the duration changes. This message
      * is received by bins and is used to calculate the total duration of a
      * pipeline.
-     * @param src - The object originating the message.
      */
-    static newDurationChanged(src?: GstObject): Message;
+    static newDurationChanged(src?: GstObject | null): Message;
     /**
      * Create a new element-specific message. This is meant as a generic way of
      * allowing one-way communication from an element to an application, for example
      * "the firewire cable was unplugged". The format of the message should be
      * documented in the element's documentation. The structure field can be %NULL.
-     * @param src - The object originating the message.
-     * @param structure - The structure for the
      */
-    static newElement(structure: Structure, src?: GstObject): Message;
+    static newElement(structure: Structure, src?: GstObject | null): Message;
     /**
      * Create a new eos message. This message is generated and posted in
      * the sink elements of a GstBin. The bin will only forward the EOS
      * message to the application if all sinks have posted an EOS message.
-     * @param src - The object originating the message.
      */
-    static newEos(src?: GstObject): Message;
+    static newEos(src?: GstObject | null): Message;
     /**
      * Create a new error message. The message will copy `error` and
      * `debug`. This message is posted by element when a fatal event
      * occurred. The pipeline will probably (partially) stop. The application
      * receiving this message should stop the pipeline.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
      */
-    static newError(error: GLib.GError, debug: string, src?: GstObject): Message;
+    static newError(error: GLib.GError, debug: string, src?: GstObject | null): Message;
     /**
      * Create a new error message. The message will copy `error` and
      * `debug`. This message is posted by element when a fatal event
      * occurred. The pipeline will probably (partially) stop. The application
      * receiving this message should stop the pipeline.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
-     * @param details - A GstStructure with details
      */
-    static newErrorWithDetails(error: GLib.GError, debug: string, src?: GstObject, details?: Structure): Message;
-    /**
-     * This message is posted when an element has a new local #GstContext.
-     * @param src - The object originating the message.
-     * @param context - the context
-     */
-    static newHaveContext(context: Context, src?: GstObject): Message;
+    static newErrorWithDetails(error: GLib.GError, debug: string, src?: GstObject | null, details?: Structure | null): Message;
+    /** This message is posted when an element has a new local #GstContext. */
+    static newHaveContext(context: Context, src?: GstObject | null): Message;
     /**
      * Create a new info message. The message will make copies of `error` and
      * `debug`.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
      */
-    static newInfo(error: GLib.GError, debug: string, src?: GstObject): Message;
+    static newInfo(error: GLib.GError, debug: string, src?: GstObject | null): Message;
     /**
      * Create a new info message. The message will make copies of `error` and
      * `debug`.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
-     * @param details - A GstStructure with details
      */
-    static newInfoWithDetails(error: GLib.GError, debug: string, src?: GstObject, details?: Structure): Message;
+    static newInfoWithDetails(error: GLib.GError, debug: string, src?: GstObject | null, details?: Structure | null): Message;
     /**
      * Creates a new instant-rate-request message. Elements handling the
      * instant-rate-change event must post this message. The message is
@@ -206,47 +159,29 @@ export declare class Message extends NativeObject {
      * running time when the rate change should happen and to send an
      * `GST_EVENT_INSTANT_RATE_SYNC_TIME` event to notify the elements
      * in the pipeline.
-     * @param src - The #GstObject that posted the message
-     * @param rateMultiplier - the rate multiplier factor that should be applied
      */
-    static newInstantRateRequest(rateMultiplier: number, src?: GstObject): Message;
+    static newInstantRateRequest(rateMultiplier: number, src?: GstObject | null): Message;
     /**
      * This message can be posted by elements when their latency requirements have
      * changed.
-     * @param src - The object originating the message.
      */
-    static newLatency(src?: GstObject): Message;
-    /**
-     * This message is posted when an element needs a specific #GstContext.
-     * @param src - The object originating the message.
-     * @param contextType - The context type that is needed
-     */
-    static newNeedContext(contextType: string, src?: GstObject): Message;
+    static newLatency(src?: GstObject | null): Message;
+    /** This message is posted when an element needs a specific #GstContext. */
+    static newNeedContext(contextType: string, src?: GstObject | null): Message;
     /**
      * Create a new clock message. This message is posted whenever the
      * pipeline selects a new clock for the pipeline.
-     * @param src - The object originating the message.
-     * @param clock - the new selected clock
      */
-    static newNewClock(clock: Clock, src?: GstObject): Message;
+    static newNewClock(clock: Clock, src?: GstObject | null): Message;
     /**
      * Progress messages are posted by elements when they use an asynchronous task
      * to perform actions triggered by a state change.
      *
      * `code` contains a well defined string describing the action.
      * `text` should contain a user visible string detailing the current action.
-     * @param src - The object originating the message.
-     * @param type - a #GstProgressType
-     * @param code - a progress code
-     * @param text - free, user visible text describing the progress
-     */
-    static newProgress(type: ProgressType, code: string, text: string, src?: GstObject): Message;
-    /**
-     * @param src - The #GstObject whose property changed (may or may not be a #GstElement)
-     * @param propertyName - name of the property that changed
-     * @param val - new property value, or %NULL
      */
-    static newPropertyNotify(src: GstObject, propertyName: string, val?: GObject.Value): Message;
+    static newProgress(type: ProgressType, code: string, text: string, src?: GstObject | null): Message;
+    static newPropertyNotify(src: GstObject, propertyName: string, val?: GObject.Value | null): Message;
     /**
      * A QOS message is posted on the bus whenever an element decides to drop a
      * buffer because of QoS reasons or whenever it changes its processing strategy
@@ -261,14 +196,8 @@ export declare class Message extends NativeObject {
      * respective running-time, stream-time, timestamp and duration of the (dropped)
      * buffer that generated the QoS event. Values can be left to
      * GST_CLOCK_TIME_NONE when unknown.
-     * @param src - The object originating the message.
-     * @param live - if the message was generated by a live element
-     * @param runningTime - the running time of the buffer that generated the message
-     * @param streamTime - the stream time of the buffer that generated the message
-     * @param timestamp - the timestamps of the buffer that generated the message
-     * @param duration - the duration of the buffer that generated the message
      */
-    static newQos(live: boolean, runningTime: number, streamTime: number, timestamp: number, duration: number, src?: GstObject): Message;
+    static newQos(live: boolean, runningTime: number, streamTime: number, timestamp: number, duration: number, src?: GstObject | null): Message;
     /**
      * Creates a new redirect message and adds a new entry to it. Redirect messages
      * are posted when an element detects that the actual data has to be retrieved
@@ -295,79 +224,52 @@ export declare class Message extends NativeObject {
      *
      * The specified location string is copied. However, ownership over the tag
      * list and structure are transferred to the message.
-     * @param src - The #GstObject whose property changed (may or may not be a #GstElement)
-     * @param location - location string for the new entry
-     * @param tagList - tag list for the new entry
-     * @param entryStruct - structure for the new entry
      */
-    static newRedirect(location: string, src?: GstObject, tagList?: TagList, entryStruct?: Structure): Message;
+    static newRedirect(location: string, src?: GstObject | null, tagList?: TagList | null, entryStruct?: Structure | null): Message;
     /**
      * This message can be posted by elements when they want to have their state
      * changed. A typical use case would be an audio server that wants to pause the
      * pipeline because a higher priority stream is being played.
-     * @param src - The object originating the message.
-     * @param state - The new requested state
      */
-    static newRequestState(state: State, src?: GstObject): Message;
+    static newRequestState(state: State, src?: GstObject | null): Message;
     /**
      * This message is posted when the pipeline running-time should be reset to
      * `running_time`, like after a flushing seek.
-     * @param src - The object originating the message.
-     * @param runningTime - the requested running-time
      */
-    static newResetTime(runningTime: number, src?: GstObject): Message;
+    static newResetTime(runningTime: number, src?: GstObject | null): Message;
     /**
      * Create a new segment done message. This message is posted by elements that
      * finish playback of a segment as a result of a segment seek. This message
      * is received by the application after all elements that posted a segment_start
      * have posted the segment_done.
-     * @param src - The object originating the message.
-     * @param format - The format of the position being done
-     * @param position - The position of the segment being done
      */
-    static newSegmentDone(format: Format, position: number, src?: GstObject): Message;
+    static newSegmentDone(format: Format, position: number, src?: GstObject | null): Message;
     /**
      * Create a new segment message. This message is posted by elements that
      * start playback of a segment as a result of a segment seek. This message
      * is not received by the application but is used for maintenance reasons in
      * container elements.
-     * @param src - The object originating the message.
-     * @param format - The format of the position being played
-     * @param position - The position of the segment being played
      */
-    static newSegmentStart(format: Format, position: number, src?: GstObject): Message;
+    static newSegmentStart(format: Format, position: number, src?: GstObject | null): Message;
     /**
      * Create a state change message. This message is posted whenever an element
      * changed its state.
-     * @param src - The object originating the message.
-     * @param oldstate - the previous state
-     * @param newstate - the new (current) state
-     * @param pending - the pending (target) state
      */
-    static newStateChanged(oldstate: State, newstate: State, pending: State, src?: GstObject): Message;
+    static newStateChanged(oldstate: State, newstate: State, pending: State, src?: GstObject | null): Message;
     /**
      * Create a state dirty message. This message is posted whenever an element
      * changed its state asynchronously and is used internally to update the
      * states of container objects.
-     * @param src - The object originating the message
      */
-    static newStateDirty(src?: GstObject): Message;
+    static newStateDirty(src?: GstObject | null): Message;
     /**
      * This message is posted by elements when they complete a part, when `intermediate` set
      * to %TRUE, or a complete step operation.
      *
      * `duration` will contain the amount of time (in GST_FORMAT_TIME) of the stepped
      * `amount` of media in format `format`.
-     * @param src - The object originating the message.
-     * @param format - the format of `amount`
-     * @param amount - the amount of stepped data
-     * @param rate - the rate of the stepped amount
-     * @param flush - is this an flushing step
-     * @param intermediate - is this an intermediate step
-     * @param duration - the duration of the data
-     * @param eos - the step caused EOS
      */
-    static newStepDone(format: Format, amount: number, rate: number, flush: boolean, intermediate: boolean, duration: number, eos: boolean, src?: GstObject): Message;
+    static newStepDone(format: Format, amount: number, rate: number, flush: boolean, intermediate: boolean, duration: number, eos: boolean, src?: GstObject | null): Message;
     /**
      * This message is posted by elements when they accept or activate a new step
      * event for `amount` in `format`.
@@ -379,37 +281,24 @@ export declare class Message extends NativeObject {
      * is now ready to start executing the step in the streaming thread. After this
      * message is emitted, the application can queue a new step operation in the
      * element.
-     * @param src - The object originating the message.
-     * @param active - if the step is active or queued
-     * @param format - the format of `amount`
-     * @param amount - the amount of stepped data
-     * @param rate - the rate of the stepped amount
-     * @param flush - is this an flushing step
-     * @param intermediate - is this an intermediate step
      */
-    static newStepStart(active: boolean, format: Format, amount: number, rate: number, flush: boolean, intermediate: boolean, src?: GstObject): Message;
+    static newStepStart(active: boolean, format: Format, amount: number, rate: number, flush: boolean, intermediate: boolean, src?: GstObject | null): Message;
     /**
      * Creates a new stream-collection message. The message is used to announce new
      * #GstStreamCollection
-     * @param src - The #GstObject that created the message
-     * @param collection - The #GstStreamCollection
      */
-    static newStreamCollection(collection: StreamCollection, src?: GstObject): Message;
+    static newStreamCollection(collection: StreamCollection, src?: GstObject | null): Message;
     /**
      * Create a new stream_start message. This message is generated and posted in
      * the sink elements of a GstBin. The bin will only forward the STREAM_START
      * message to the application if all sinks have posted an STREAM_START message.
-     * @param src - The object originating the message.
      */
-    static newStreamStart(src?: GstObject): Message;
+    static newStreamStart(src?: GstObject | null): Message;
     /**
      * Create a new stream status message. This message is posted when a streaming
      * thread is created/destroyed or when the state changed.
-     * @param src - The object originating the message.
-     * @param type - The stream status type.
-     * @param owner - the owner element of `src`.
      */
-    static newStreamStatus(type: StreamStatusType, owner: Element, src?: GstObject): Message;
+    static newStreamStatus(type: StreamStatusType, owner: Element, src?: GstObject | null): Message;
     /**
      * Creates a new steams-selected message. The message is used to announce
      * that an array of streams has been selected. This is generally in response
@@ -421,74 +310,49 @@ export declare class Message extends NativeObject {
      *
      * Users of gst_message_new_streams_selected() can add the selected streams with
      * gst_message_streams_selected_add().
-     * @param src - The #GstObject that created the message
-     * @param collection - The #GstStreamCollection
      */
-    static newStreamsSelected(collection: StreamCollection, src?: GstObject): Message;
+    static newStreamsSelected(collection: StreamCollection, src?: GstObject | null): Message;
     /**
      * Create a new structure change message. This message is posted when the
      * structure of a pipeline is in the process of being changed, for example
      * when pads are linked or unlinked.
      *
      * `src` should be the sinkpad that unlinked or linked.
-     * @param src - The object originating the message.
-     * @param type - The change type.
-     * @param owner - The owner element of `src`.
-     * @param busy - Whether the structure change is busy.
      */
-    static newStructureChange(type: StructureChangeType, owner: Element, busy: boolean, src?: GstObject): Message;
+    static newStructureChange(type: StructureChangeType, owner: Element, busy: boolean, src?: GstObject | null): Message;
     /**
      * Create a new tag message. The message will take ownership of the tag list.
      * The message is posted by elements that discovered a new taglist.
-     * @param src - The object originating the message.
-     * @param tagList - the tag list for the message.
      */
-    static newTag(tagList: TagList, src?: GstObject): Message;
+    static newTag(tagList: TagList, src?: GstObject | null): Message;
     /**
      * Create a new TOC message. The message is posted by elements
      * that discovered or updated a TOC.
-     * @param src - the object originating the message.
-     * @param toc - #GstToc structure for the message.
-     * @param updated - whether TOC was updated or not.
      */
-    static newToc(toc: Toc, updated: boolean, src?: GstObject): Message;
+    static newToc(toc: Toc, updated: boolean, src?: GstObject | null): Message;
     /**
      * Create a new warning message. The message will make copies of `error` and
      * `debug`.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
      */
-    static newWarning(error: GLib.GError, debug: string, src?: GstObject): Message;
+    static newWarning(error: GLib.GError, debug: string, src?: GstObject | null): Message;
     /**
      * Create a new warning message. The message will make copies of `error` and
      * `debug`.
-     * @param src - The object originating the message.
-     * @param error - The GError for this message.
-     * @param debug - A debugging string.
-     * @param details - A GstStructure with details
      */
-    static newWarningWithDetails(error: GLib.GError, debug: string, src?: GstObject, details?: Structure): Message;
-    protected createPtr(_args: unknown[]): unknown;
-    static fromPtr(ptr: unknown): Message;
+    static newWarningWithDetails(error: GLib.GError, debug: string, src?: GstObject | null, details?: Structure | null): Message;
     /**
      * Modifies a pointer to a #GstMessage to point to a different #GstMessage. This
      * function is similar to gst_message_replace() except that it takes ownership
      * of `new_message`.
-     * @param oldMessage - pointer to a pointer to a #GstMessage
-     * @param newMessage - pointer to a #GstMessage that
      */
-    static take(oldMessage: Ref<Message>, newMessage?: Message): boolean;
+    static take(oldMessage: Ref<Message>, newMessage?: Message | null): boolean;
     /**
      * Creates and appends a new entry.
      *
      * The specified location string is copied. However, ownership over the tag
      * list and structure are transferred to the message.
-     * @param location - location string for the new entry
-     * @param tagList - tag list for the new entry
-     * @param entryStruct - structure for the new entry
      */
-    addRedirectEntry(location: string, tagList?: TagList, entryStruct?: Structure): void;
+    addRedirectEntry(location: string, tagList?: TagList | null, entryStruct?: Structure | null): void;
     /**
      * Returns the optional details structure of the message. May be NULL if none.
      *
@@ -511,192 +375,145 @@ export declare class Message extends NativeObject {
      * that correspondence was made explicitly.
      */
     getSeqnum(): number;
-    /**
-     * Extracts the object managing the streaming thread from `message`.
-     */
+    /** Extracts the object managing the streaming thread from `message`. */
     getStreamStatusObject(): GObject.Value | null;
-    /**
-     * Access the structure of the message.
-     */
+    /** Access the structure of the message. */
     getStructure(): Structure | null;
     /**
      * Checks if `message` has the given `name`. This function is usually used to
      * check the name of a custom message.
-     * @param name - name to check
      */
     hasName(name: string): boolean;
     /**
      * Extract the running_time from the async_done message.
      *
      * MT safe.
-     * @param runningTime - Result location for the running_time or %NULL
      */
-    parseAsyncDone(runningTime?: Ref<number>): void;
+    parseAsyncDone(runningTime?: Ref<number> | null): void;
     /**
      * Extracts the buffering percent from the GstMessage. see also
      * gst_message_new_buffering().
      *
      * MT safe.
-     * @param percent - Return location for the percent.
-     */
-    parseBuffering(percent?: Ref<number>): void;
-    /**
-     * Extracts the buffering stats values from `message`.
-     * @param mode - a buffering mode, or %NULL
-     * @param avgIn - the average input rate, or %NULL
-     * @param avgOut - the average output rate, or %NULL
-     * @param bufferingLeft - amount of buffering time left in
      */
-    parseBufferingStats(mode?: Ref<BufferingMode>, avgIn?: Ref<number>, avgOut?: Ref<number>, bufferingLeft?: Ref<number>): void;
+    parseBuffering(percent?: Ref<number> | null): void;
+    /** Extracts the buffering stats values from `message`. */
+    parseBufferingStats(mode?: Ref<BufferingMode> | null, avgIn?: Ref<number> | null, avgOut?: Ref<number> | null, bufferingLeft?: Ref<number> | null): void;
     /**
      * Extracts the lost clock from the GstMessage.
      * The clock object returned remains valid until the message is freed.
      *
      * MT safe.
-     * @param clock - a pointer to hold the lost clock
      */
-    parseClockLost(clock?: Ref<Clock>): void;
+    parseClockLost(clock?: Ref<Clock> | null): void;
     /**
      * Extracts the clock and ready flag from the GstMessage.
      * The clock object returned remains valid until the message is freed.
      *
      * MT safe.
-     * @param clock - a pointer to  hold a clock
-     * @param ready - a pointer to hold the ready flag, or %NULL
      */
-    parseClockProvide(clock?: Ref<Clock>, ready?: Ref<boolean>): void;
-    /**
-     * Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message.
-     * @param contextType - the context type, or %NULL
-     */
-    parseContextType(contextType?: Ref<string>): boolean;
+    parseClockProvide(clock?: Ref<Clock> | null, ready?: Ref<boolean> | null): void;
+    /** Parse a context type from an existing GST_MESSAGE_NEED_CONTEXT message. */
+    parseContextType(contextType?: Ref<string> | null): boolean;
     /**
      * Parses a device-added message. The device-added message is produced by
      * #GstDeviceProvider or a #GstDeviceMonitor. It announces the appearance
      * of monitored devices.
-     * @param device - A location where to store a
      */
-    parseDeviceAdded(device?: Ref<Device>): void;
+    parseDeviceAdded(device?: Ref<Device> | null): void;
     /**
      * Parses a device-changed message. The device-changed message is produced by
      * #GstDeviceProvider or a #GstDeviceMonitor. It announces the
      * disappearance of monitored devices. * It announce that a device properties has
      * changed and `device` represents the new modified version of `changed_device`.
-     * @param device - A location where to store a
-     * @param changedDevice - A location where to store a
      */
-    parseDeviceChanged(device?: Ref<Device>, changedDevice?: Ref<Device>): void;
+    parseDeviceChanged(device?: Ref<Device> | null, changedDevice?: Ref<Device> | null): void;
     /**
      * Parses a device-removed message. The device-removed message is produced by
      * #GstDeviceProvider or a #GstDeviceMonitor. It announces the
      * disappearance of monitored devices.
-     * @param device - A location where to store a
      */
-    parseDeviceRemoved(device?: Ref<Device>): void;
+    parseDeviceRemoved(device?: Ref<Device> | null): void;
     /**
      * Extracts the GError and debug string from the GstMessage. The values returned
      * in the output arguments are copies; the caller must free them when done.
      *
      * Typical usage of this function might be:
      * |[<!-- language="C" -->
-     * ...
-     * switch (GST_MESSAGE_TYPE (msg)) {
-     * case GST_MESSAGE_ERROR: {
-     * GError *err = NULL;
-     * gchar *dbg_info = NULL;
-     *
-     * gst_message_parse_error (msg, &err, &dbg_info);
-     * g_printerr ("ERROR from element %s: %s\n",
-     * GST_OBJECT_NAME (msg->src), err->message);
-     * g_printerr ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none");
-     * g_error_free (err);
-     * g_free (dbg_info);
-     * break;
-     * }
-     * ...
-     * }
-     * ...
+     *   ...
+     *   switch (GST_MESSAGE_TYPE (msg)) {
+     *     case GST_MESSAGE_ERROR: {
+     *       GError *err = NULL;
+     *       gchar *dbg_info = NULL;
+     *
+     *       gst_message_parse_error (msg, &err, &dbg_info);
+     *       g_printerr ("ERROR from element %s: %s\n",
+     *           GST_OBJECT_NAME (msg->src), err->message);
+     *       g_printerr ("Debugging info: %s\n", (dbg_info) ? dbg_info : "none");
+     *       g_error_free (err);
+     *       g_free (dbg_info);
+     *       break;
+     *     }
+     *     ...
+     *   }
+     *   ...
      * ]|
      *
      * MT safe.
-     * @param gerror - location for the GError
-     * @param debug - location for the debug message,
      */
-    parseError(gerror?: Ref<GLib.GError>, debug?: Ref<string>): void;
+    parseError(gerror?: Ref<GLib.GError> | null, debug?: Ref<string> | null): void;
     /**
      * Returns the optional details structure, may be NULL if none.
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
      */
-    parseErrorDetails(structure?: Ref<Structure>): void;
+    parseErrorDetails(structure?: Ref<Structure> | null): void;
     /**
      * Returns the details structure if present or will create one if not present.
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
-     */
-    parseErrorWritableDetails(structure?: Ref<Structure>): void;
-    /**
-     * Extract the group from the STREAM_START message.
-     * @param groupId - Result location for the group id or
      */
-    parseGroupId(groupId?: Ref<number>): boolean;
+    parseErrorWritableDetails(structure?: Ref<Structure> | null): void;
+    /** Extract the group from the STREAM_START message. */
+    parseGroupId(groupId?: Ref<number> | null): boolean;
     /**
      * Extract the context from the HAVE_CONTEXT message.
      *
      * MT safe.
-     * @param context - Result location for the
      */
-    parseHaveContext(context?: Ref<Context>): void;
+    parseHaveContext(context?: Ref<Context> | null): void;
     /**
      * Extracts the GError and debug string from the GstMessage. The values returned
      * in the output arguments are copies; the caller must free them when done.
      *
      * MT safe.
-     * @param gerror - location for the GError
-     * @param debug - location for the debug message,
      */
-    parseInfo(gerror?: Ref<GLib.GError>, debug?: Ref<string>): void;
+    parseInfo(gerror?: Ref<GLib.GError> | null, debug?: Ref<string> | null): void;
     /**
      * Returns the optional details structure, may be NULL if none
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
      */
-    parseInfoDetails(structure?: Ref<Structure>): void;
+    parseInfoDetails(structure?: Ref<Structure> | null): void;
     /**
      * Returns the details structure if present or will create one if not present.
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
      */
-    parseInfoWritableDetails(structure?: Ref<Structure>): void;
-    /**
-     * Parses the rate_multiplier from the instant-rate-request message.
-     * @param rateMultiplier - return location for the rate, or %NULL
-     */
-    parseInstantRateRequest(rateMultiplier?: Ref<number>): void;
+    parseInfoWritableDetails(structure?: Ref<Structure> | null): void;
+    /** Parses the rate_multiplier from the instant-rate-request message. */
+    parseInstantRateRequest(rateMultiplier?: Ref<number> | null): void;
     /**
      * Extracts the new clock from the GstMessage.
      * The clock object returned remains valid until the message is freed.
      *
      * MT safe.
-     * @param clock - a pointer to hold the selected
      */
-    parseNewClock(clock?: Ref<Clock>): void;
-    /**
-     * Parses the progress `type`, `code` and `text`.
-     * @param type - location for the type
-     * @param code - location for the code
-     * @param text - location for the text
-     */
-    parseProgress(type?: Ref<ProgressType>, code?: Ref<string>, text?: Ref<string>): void;
+    parseNewClock(clock?: Ref<Clock> | null): void;
+    /** Parses the progress `type`, `code` and `text`. */
+    parseProgress(type?: Ref<ProgressType> | null, code?: Ref<string> | null, text?: Ref<string> | null): void;
     /**
      * Parses a property-notify message. These will be posted on the bus only
      * when set up with gst_element_add_property_notify_watch() or
      * gst_element_add_property_deep_notify_watch().
-     * @param object - location where to store a
-     * @param propertyName - return location for
-     * @param propertyValue - return location for
      */
-    parsePropertyNotify(object?: Ref<GstObject>, propertyName?: Ref<string>, propertyValue?: Ref<GObject.Value>): void;
+    parsePropertyNotify(object?: Ref<GstObject> | null, propertyName?: Ref<string> | null, propertyValue?: Ref<GObject.Value> | null): void;
     /**
      * Extract the timestamps and live status from the QoS message.
      *
@@ -705,13 +522,8 @@ export declare class Message extends NativeObject {
      * values.
      *
      * MT safe.
-     * @param live - if the message was generated by a live element
-     * @param runningTime - the running time of the buffer that
-     * @param streamTime - the stream time of the buffer that
-     * @param timestamp - the timestamps of the buffer that
-     * @param duration - the duration of the buffer that
      */
-    parseQos(live?: Ref<boolean>, runningTime?: Ref<number>, streamTime?: Ref<number>, timestamp?: Ref<number>, duration?: Ref<number>): void;
+    parseQos(live?: Ref<boolean> | null, runningTime?: Ref<number> | null, streamTime?: Ref<number> | null, timestamp?: Ref<number> | null, duration?: Ref<number> | null): void;
     /**
      * Extract the QoS stats representing the history of the current continuous
      * pipeline playback period.
@@ -720,166 +532,122 @@ export declare class Message extends NativeObject {
      * invalid. Values of -1 for either `processed` or `dropped` mean unknown values.
      *
      * MT safe.
-     * @param format - Units of the 'processed' and 'dropped' fields.
-     * @param processed - Total number of units correctly processed
-     * @param dropped - Total number of units dropped since the last
      */
-    parseQosStats(format?: Ref<Format>, processed?: Ref<number>, dropped?: Ref<number>): void;
+    parseQosStats(format?: Ref<Format> | null, processed?: Ref<number> | null, dropped?: Ref<number> | null): void;
     /**
      * Extract the QoS values that have been calculated/analysed from the QoS data
      *
      * MT safe.
-     * @param jitter - The difference of the running-time against
-     * @param proportion - Long term prediction of the ideal rate
-     * @param quality - An element dependent integer value that
      */
-    parseQosValues(jitter?: Ref<number>, proportion?: Ref<number>, quality?: Ref<number>): void;
+    parseQosValues(jitter?: Ref<number> | null, proportion?: Ref<number> | null, quality?: Ref<number> | null): void;
     /**
      * Parses the location and/or structure from the entry with the given index.
      * The index must be between 0 and gst_message_get_num_redirect_entries() - 1.
      * Returned pointers are valid for as long as this message exists.
-     * @param entryIndex - index of the entry to parse
-     * @param location - return location for
-     * @param tagList - return location for
-     * @param entryStruct - return location
      */
-    parseRedirectEntry(entryIndex: number, location?: Ref<string>, tagList?: Ref<TagList>, entryStruct?: Ref<Structure>): void;
+    parseRedirectEntry(entryIndex: number, location?: Ref<string> | null, tagList?: Ref<TagList> | null, entryStruct?: Ref<Structure> | null): void;
     /**
      * Extract the requested state from the request_state message.
      *
      * MT safe.
-     * @param state - Result location for the requested state or %NULL
      */
-    parseRequestState(state?: Ref<State>): void;
+    parseRequestState(state?: Ref<State> | null): void;
     /**
      * Extract the running-time from the RESET_TIME message.
      *
      * MT safe.
-     * @param runningTime - Result location for the running_time or
      */
-    parseResetTime(runningTime?: Ref<number>): void;
+    parseResetTime(runningTime?: Ref<number> | null): void;
     /**
      * Extracts the position and format from the segment done message.
      *
      * MT safe.
-     * @param format - Result location for the format, or %NULL
-     * @param position - Result location for the position, or %NULL
      */
-    parseSegmentDone(format?: Ref<Format>, position?: Ref<number>): void;
+    parseSegmentDone(format?: Ref<Format> | null, position?: Ref<number> | null): void;
     /**
      * Extracts the position and format from the segment start message.
      *
      * MT safe.
-     * @param format - Result location for the format, or %NULL
-     * @param position - Result location for the position, or %NULL
      */
-    parseSegmentStart(format?: Ref<Format>, position?: Ref<number>): void;
+    parseSegmentStart(format?: Ref<Format> | null, position?: Ref<number> | null): void;
     /**
      * Extracts the old and new states from the GstMessage.
      *
      * Typical usage of this function might be:
      * |[<!-- language="C" -->
-     * ...
-     * switch (GST_MESSAGE_TYPE (msg)) {
-     * case GST_MESSAGE_STATE_CHANGED: {
-     * GstState old_state, new_state;
-     *
-     * gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
-     * g_print ("Element %s changed state from %s to %s.\n",
-     * GST_OBJECT_NAME (msg->src),
-     * gst_element_state_get_name (old_state),
-     * gst_element_state_get_name (new_state));
-     * break;
-     * }
-     * ...
-     * }
-     * ...
+     *   ...
+     *   switch (GST_MESSAGE_TYPE (msg)) {
+     *     case GST_MESSAGE_STATE_CHANGED: {
+     *       GstState old_state, new_state;
+     *
+     *       gst_message_parse_state_changed (msg, &old_state, &new_state, NULL);
+     *       g_print ("Element %s changed state from %s to %s.\n",
+     *           GST_OBJECT_NAME (msg->src),
+     *           gst_element_state_get_name (old_state),
+     *           gst_element_state_get_name (new_state));
+     *       break;
+     *     }
+     *     ...
+     *   }
+     *   ...
      * ]|
      *
      * MT safe.
-     * @param oldstate - the previous state, or %NULL
-     * @param newstate - the new (current) state, or %NULL
-     * @param pending - the pending (target) state, or %NULL
      */
-    parseStateChanged(oldstate?: Ref<State>, newstate?: Ref<State>, pending?: Ref<State>): void;
+    parseStateChanged(oldstate?: Ref<State> | null, newstate?: Ref<State> | null, pending?: Ref<State> | null): void;
     /**
      * Extract the values the step_done message.
      *
      * MT safe.
-     * @param format - result location for the format
-     * @param amount - result location for the amount
-     * @param rate - result location for the rate
-     * @param flush - result location for the flush flag
-     * @param intermediate - result location for the intermediate flag
-     * @param duration - result location for the duration
-     * @param eos - result location for the EOS flag
      */
-    parseStepDone(format?: Ref<Format>, amount?: Ref<number>, rate?: Ref<number>, flush?: Ref<boolean>, intermediate?: Ref<boolean>, duration?: Ref<number>, eos?: Ref<boolean>): void;
+    parseStepDone(format?: Ref<Format> | null, amount?: Ref<number> | null, rate?: Ref<number> | null, flush?: Ref<boolean> | null, intermediate?: Ref<boolean> | null, duration?: Ref<number> | null, eos?: Ref<boolean> | null): void;
     /**
      * Extract the values from step_start message.
      *
      * MT safe.
-     * @param active - result location for the active flag
-     * @param format - result location for the format
-     * @param amount - result location for the amount
-     * @param rate - result location for the rate
-     * @param flush - result location for the flush flag
-     * @param intermediate - result location for the intermediate flag
      */
-    parseStepStart(active?: Ref<boolean>, format?: Ref<Format>, amount?: Ref<number>, rate?: Ref<number>, flush?: Ref<boolean>, intermediate?: Ref<boolean>): void;
-    /**
-     * Parses a stream-collection message.
-     * @param collection - A location where to store a
-     */
-    parseStreamCollection(collection?: Ref<StreamCollection>): void;
+    parseStepStart(active?: Ref<boolean> | null, format?: Ref<Format> | null, amount?: Ref<number> | null, rate?: Ref<number> | null, flush?: Ref<boolean> | null, intermediate?: Ref<boolean> | null): void;
+    /** Parses a stream-collection message. */
+    parseStreamCollection(collection?: Ref<StreamCollection> | null): void;
     /**
      * Extracts the stream status type and owner the GstMessage. The returned
      * owner remains valid for as long as the reference to `message` is valid and
      * should thus not be unreffed.
      *
      * MT safe.
-     * @param type - A pointer to hold the status type
-     * @param owner - The owner element of the message source
      */
     parseStreamStatus(type: Ref<StreamStatusType>, owner: Ref<Element>): void;
-    /**
-     * Parses a streams-selected message.
-     * @param collection - A location where to store a
-     */
-    parseStreamsSelected(collection?: Ref<StreamCollection>): void;
+    /** Parses a streams-selected message. */
+    parseStreamsSelected(collection?: Ref<StreamCollection> | null): void;
     /**
      * Extracts the change type and completion status from the GstMessage.
      *
      * MT safe.
-     * @param type - A pointer to hold the change type
-     * @param owner - The owner element of the
-     * @param busy - a pointer to hold whether the change is in
      */
-    parseStructureChange(type: Ref<StructureChangeType>, owner?: Ref<Element>, busy?: Ref<boolean>): void;
+    parseStructureChange(type: Ref<StructureChangeType>, owner?: Ref<Element> | null, busy?: Ref<boolean> | null): void;
     /**
      * Extracts the tag list from the GstMessage. The tag list returned in the
      * output argument is a copy; the caller must free it when done.
      *
      * Typical usage of this function might be:
      * |[<!-- language="C" -->
-     * ...
-     * switch (GST_MESSAGE_TYPE (msg)) {
-     * case GST_MESSAGE_TAG: {
-     * GstTagList *tags = NULL;
-     *
-     * gst_message_parse_tag (msg, &tags);
-     * g_print ("Got tags from element %s\n", GST_OBJECT_NAME (msg->src));
-     * handle_tags (tags);
-     * gst_tag_list_unref (tags);
-     * break;
-     * }
-     * ...
-     * }
-     * ...
+     *   ...
+     *   switch (GST_MESSAGE_TYPE (msg)) {
+     *     case GST_MESSAGE_TAG: {
+     *       GstTagList *tags = NULL;
+     *
+     *       gst_message_parse_tag (msg, &tags);
+     *       g_print ("Got tags from element %s\n", GST_OBJECT_NAME (msg->src));
+     *       handle_tags (tags);
+     *       gst_tag_list_unref (tags);
+     *       break;
+     *     }
+     *     ...
+     *   }
+     *   ...
      * ]|
      *
      * MT safe.
-     * @param tagList - return location for the tag-list.
      */
     parseTag(tagList: Ref<TagList>): void;
     /**
@@ -888,8 +656,6 @@ export declare class Message extends NativeObject {
      * gst_toc_unref() when done.
      *
      * MT safe.
-     * @param toc - return location for the TOC.
-     * @param updated - return location for the updated flag.
      */
     parseToc(toc: Ref<Toc>, updated: Ref<boolean>): void;
     /**
@@ -897,36 +663,25 @@ export declare class Message extends NativeObject {
      * in the output arguments are copies; the caller must free them when done.
      *
      * MT safe.
-     * @param gerror - location for the GError
-     * @param debug - location for the debug message,
      */
-    parseWarning(gerror?: Ref<GLib.GError>, debug?: Ref<string>): void;
+    parseWarning(gerror?: Ref<GLib.GError> | null, debug?: Ref<string> | null): void;
     /**
      * Returns the optional details structure, may be NULL if none
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
      */
-    parseWarningDetails(structure?: Ref<Structure>): void;
+    parseWarningDetails(structure?: Ref<Structure> | null): void;
     /**
      * Returns the details structure if present or will create one if not present.
      * The returned structure must not be freed.
-     * @param structure - A pointer to the returned details
-     */
-    parseWarningWritableDetails(structure?: Ref<Structure>): void;
-    /**
-     * Configures the buffering stats values in `message`.
-     * @param mode - a buffering mode
-     * @param avgIn - the average input rate
-     * @param avgOut - the average output rate
-     * @param bufferingLeft - amount of buffering time left in milliseconds
      */
+    parseWarningWritableDetails(structure?: Ref<Structure> | null): void;
+    /** Configures the buffering stats values in `message`. */
     setBufferingStats(mode: BufferingMode, avgIn: number, avgOut: number, bufferingLeft: number): void;
     /**
      * Add `details` to `message`. Will fail if the message already has details set on
      * it or if it is not writable.
-     * @param details - A GstStructure with details
      */
-    setDetails(details?: Structure): void;
+    setDetails(details?: Structure | null): void;
     /**
      * Sets the group id on the stream-start message.
      *
@@ -937,7 +692,6 @@ export declare class Message extends NativeObject {
      * each time a file is played for example.
      *
      * MT safe.
-     * @param groupId - the group id
      */
     setGroupId(groupId: number): void;
     /**
@@ -948,18 +702,12 @@ export declare class Message extends NativeObject {
      * invalid. Values of -1 for either `processed` or `dropped` mean unknown values.
      *
      * MT safe.
-     * @param format - Units of the 'processed' and 'dropped' fields. Video sinks and video
-     * @param processed - Total number of units correctly processed since the last state
-     * @param dropped - Total number of units dropped since the last state change to READY
      */
     setQosStats(format: Format, processed: number, dropped: number): void;
     /**
      * Set the QoS values that have been calculated/analysed from the QoS data
      *
      * MT safe.
-     * @param jitter - The difference of the running-time against the deadline.
-     * @param proportion - Long term prediction of the ideal rate relative to normal rate
-     * @param quality - An element dependent integer value that specifies the current
      */
     setQosValues(jitter: number, proportion: number, quality: number): void;
     /**
@@ -970,28 +718,18 @@ export declare class Message extends NativeObject {
      * for more information.
      *
      * MT safe.
-     * @param seqnum - A sequence number.
      */
     setSeqnum(seqnum: number): void;
     /**
      * Configures the object handling the streaming thread. This is usually a
      * GstTask object but other objects might be added in the future.
-     * @param object - the object controlling the streaming
      */
     setStreamStatusObject(object: GObject.Value): void;
-    /**
-     * Adds the `stream` to the `message`.
-     * @param stream - a #GstStream to add to `message`
-     */
+    /** Adds the `stream` to the `message`. */
     streamsSelectedAdd(stream: Stream): void;
-    /**
-     * Returns the number of streams contained in the `message`.
-     */
+    /** Returns the number of streams contained in the `message`. */
     streamsSelectedGetSize(): number;
-    /**
-     * Retrieves the #GstStream with index `index` from the `message`.
-     * @param idx - Index of the stream to retrieve
-     */
+    /** Retrieves the #GstStream with index `index` from the `message`. */
     streamsSelectedGetStream(idx: number): Stream | null;
     /**
      * Returns the details structure of the `message`. If not present it will be
@@ -1001,9 +739,7 @@ export declare class Message extends NativeObject {
      * The returned structure must not be freed.
      */
     writableDetails(): Structure;
-    /**
-     * Get a writable version of the structure.
-     */
+    /** Get a writable version of the structure. */
     writableStructure(): Structure;
     /** the parent structure */
     get miniObject(): MiniObject;