@gtkx/ffi 0.10.5 → 0.11.0

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

@@ -19,18 +19,18 @@ import { BufferPool } from "./buffer-pool.js";
  *
  * The following example shows how to query the duration of a pipeline:
  * |[<!-- language="C" -->
- * GstQuery *query;
- * gboolean res;
- * query = gst_query_new_duration (GST_FORMAT_TIME);
- * res = gst_element_query (pipeline, query);
- * if (res) {
- * gint64 duration;
- * gst_query_parse_duration (query, NULL, &duration);
- * g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));
- * } else {
- * g_print ("duration query failed...");
- * }
- * gst_query_unref (query);
+ *   GstQuery *query;
+ *   gboolean res;
+ *   query = gst_query_new_duration (GST_FORMAT_TIME);
+ *   res = gst_element_query (pipeline, query);
+ *   if (res) {
+ *     gint64 duration;
+ *     gst_query_parse_duration (query, NULL, &duration);
+ *     g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));
+ *   } else {
+ *     g_print ("duration query failed...");
+ *   }
+ *   gst_query_unref (query);
  * ]|
  */
 export declare class Query extends NativeObject {
@@ -40,18 +40,14 @@ export declare class Query extends NativeObject {
      * Constructs a new query object for querying if `caps` are accepted.
      *
      * Free-function: gst_query_unref()
-     * @param caps - a fixed #GstCaps
      */
     constructor(caps: Caps);
-    constructor(_args: unknown[]);
     /**
      * Constructs a new query object for querying the allocation properties.
      *
      * Free-function: gst_query_unref()
-     * @param caps - the negotiated caps
-     * @param needPool - return a pool
      */
-    static newAllocation(needPool: boolean, caps?: Caps): Query;
+    static newAllocation(needPool: boolean, caps?: Caps | null): Query;
     /**
      * Constructs a new query object for querying the bitrate.
      *
@@ -63,7 +59,6 @@ export declare class Query extends NativeObject {
      * a stream.
      *
      * Free-function: gst_query_unref()
-     * @param format - the default #GstFormat for the new query
      */
     static newBuffering(format: Format): Query;
     /**
@@ -87,14 +82,12 @@ export declare class Query extends NativeObject {
      * greatly reduce the amount of processing an element needs to do.
      *
      * Free-function: gst_query_unref()
-     * @param filter - a filter
      */
     static newCaps(filter: Caps): Query;
     /**
      * Constructs a new query object for querying the pipeline-local context.
      *
      * Free-function: gst_query_unref()
-     * @param contextType - Context type to query
      */
     static newContext(contextType: string): Query;
     /**
@@ -103,9 +96,6 @@ export declare class Query extends NativeObject {
      * one format and another.
      *
      * Free-function: gst_query_unref()
-     * @param srcFormat - the source #GstFormat for the new query
-     * @param value - the value to convert
-     * @param destFormat - the target #GstFormat
      */
     static newConvert(srcFormat: Format, value: number, destFormat: Format): Query;
     /**
@@ -113,10 +103,8 @@ export declare class Query extends NativeObject {
      * when done with it.
      *
      * Free-function: gst_query_unref()
-     * @param type - the query type
-     * @param structure - a structure for the query
      */
-    static newCustom(type: QueryType, structure?: Structure): Query;
+    static newCustom(type: QueryType, structure?: Structure | null): Query;
     /**
      * Constructs a new query object for querying the drain state.
      *
@@ -129,7 +117,6 @@ export declare class Query extends NativeObject {
      * total length of the stream.
      *
      * Free-function: gst_query_unref()
-     * @param format - the #GstFormat for this duration query
      */
     static newDuration(format: Format): Query;
     /**
@@ -154,7 +141,6 @@ export declare class Query extends NativeObject {
      * of playback in the streams, in some format.
      *
      * Free-function: gst_query_unref()
-     * @param format - the default #GstFormat for the new query
      */
     static newPosition(format: Format): Query;
     /**
@@ -168,7 +154,6 @@ export declare class Query extends NativeObject {
      * the stream.
      *
      * Free-function: gst_query_unref()
-     * @param format - the default #GstFormat for the new query
      */
     static newSeeking(format: Format): Query;
     /**
@@ -177,7 +162,6 @@ export declare class Query extends NativeObject {
      * currently configured segment for playback.
      *
      * Free-function: gst_query_unref()
-     * @param format - the #GstFormat for the new query
      */
     static newSegment(format: Format): Query;
     /**
@@ -194,58 +178,33 @@ export declare class Query extends NativeObject {
      * Free-function: gst_query_unref()
      */
     static newUri(): Query;
-    protected createPtr(_args: unknown[]): unknown;
-    static fromPtr(ptr: unknown): Query;
     /**
      * Modifies a pointer to a #GstQuery to point to a different #GstQuery. This
      * function is similar to gst_query_replace() except that it takes ownership of
      * `new_query`.
      *
      * Either `new_query` or the #GstQuery pointed to by `old_query` may be %NULL.
-     * @param oldQuery - pointer to a
-     * @param newQuery - pointer to a #GstQuery that will
      */
-    static take(oldQuery?: Ref<Query>, newQuery?: Query): boolean;
-    /**
-     * Add `api` with `params` as one of the supported metadata API to `query`.
-     * @param api - the metadata API
-     * @param params - API specific parameters
-     */
-    addAllocationMeta(api: number, params?: Structure): void;
-    /**
-     * Add `allocator` and its `params` as a supported memory allocator.
-     * @param allocator - the memory allocator
-     * @param params - a #GstAllocationParams
-     */
-    addAllocationParam(allocator?: Allocator, params?: AllocationParams): void;
-    /**
-     * Set the pool parameters in `query`.
-     * @param pool - the #GstBufferPool
-     * @param size - the buffer size
-     * @param minBuffers - the min buffers
-     * @param maxBuffers - the max buffers
-     */
-    addAllocationPool(size: number, minBuffers: number, maxBuffers: number, pool?: BufferPool): void;
+    static take(oldQuery?: Ref<Query> | null, newQuery?: Query | null): boolean;
+    /** Add `api` with `params` as one of the supported metadata API to `query`. */
+    addAllocationMeta(api: number, params?: Structure | null): void;
+    /** Add `allocator` and its `params` as a supported memory allocator. */
+    addAllocationParam(allocator?: Allocator | null, params?: AllocationParams | null): void;
+    /** Set the pool parameters in `query`. */
+    addAllocationPool(size: number, minBuffers: number, maxBuffers: number, pool?: BufferPool | null): void;
     /**
      * Set the buffering-ranges array field in `query`. The current last
      * start position of the array should be inferior to `start`.
-     * @param start - start position of the range
-     * @param stop - stop position of the range
      */
     addBufferingRange(start: number, stop: number): boolean;
-    /**
-     * Add `mode` as one of the supported scheduling modes to `query`.
-     * @param mode - a #GstPadMode
-     */
+    /** Add `mode` as one of the supported scheduling modes to `query`. */
     addSchedulingMode(mode: PadMode): void;
     /**
      * Check if `query` has metadata `api` set. When this function returns %TRUE,
      * `index` will contain the index where the requested API and the parameters
      * can be found.
-     * @param api - the metadata API
-     * @param index - the index
      */
-    findAllocationMeta(api: number, index?: Ref<number>): boolean;
+    findAllocationMeta(api: number, index?: Ref<number> | null): boolean;
     /**
      * Retrieve the number of values currently stored in the
      * meta API array of the query's structure.
@@ -276,9 +235,7 @@ export declare class Query extends NativeObject {
      * scheduling mode array of the query's structure.
      */
     getNSchedulingModes(): number;
-    /**
-     * Get the structure of a query.
-     */
+    /** Get the structure of a query. */
     getStructure(): Structure | null;
     /**
      * Check if `query` has scheduling mode set.
@@ -288,27 +245,20 @@ export declare class Query extends NativeObject {
      * > also want to check whether the scheduling flags returned by
      * > gst_query_parse_scheduling() have the seeking flag set (meaning
      * > random access is supported, not only sequential pulls).
-     * @param mode - the scheduling mode
      */
     hasSchedulingMode(mode: PadMode): boolean;
     /**
      * Check if `query` has scheduling mode set and `flags` is set in
      * query scheduling flags.
-     * @param mode - the scheduling mode
-     * @param flags - #GstSchedulingFlags
      */
     hasSchedulingModeWithFlags(mode: PadMode, flags: SchedulingFlags): boolean;
     /**
      * Get the caps from `query`. The caps remains valid as long as `query` remains
      * valid.
-     * @param caps - A pointer to the caps
      */
     parseAcceptCaps(caps: Ref<Caps>): void;
-    /**
-     * Parse the result from `query` and store in `result`.
-     * @param result - location for the result
-     */
-    parseAcceptCapsResult(result?: Ref<boolean>): void;
+    /** Parse the result from `query` and store in `result`. */
+    parseAcceptCapsResult(result?: Ref<boolean> | null): void;
     /**
      * Parse an allocation query, writing the requested caps in `caps` and
      * whether a pool is needed in `need_pool`, if the respective parameters
@@ -316,332 +266,179 @@ export declare class Query extends NativeObject {
      *
      * Pool details can be retrieved using gst_query_get_n_allocation_pools() and
      * gst_query_parse_nth_allocation_pool().
-     * @param caps - The #GstCaps
-     * @param needPool - Whether a #GstBufferPool is needed
      */
-    parseAllocation(caps?: Ref<Caps>, needPool?: Ref<boolean>): void;
-    /**
-     * Get the results of a bitrate query. See also gst_query_set_bitrate().
-     * @param nominalBitrate - The resulting bitrate in bits per second
-     */
-    parseBitrate(nominalBitrate?: Ref<number>): void;
+    parseAllocation(caps?: Ref<Caps> | null, needPool?: Ref<boolean> | null): void;
+    /** Get the results of a bitrate query. See also gst_query_set_bitrate(). */
+    parseBitrate(nominalBitrate?: Ref<number> | null): void;
     /**
      * Get the percentage of buffered data. This is a value between 0 and 100.
      * The `busy` indicator is %TRUE when the buffering is in progress.
-     * @param busy - if buffering is busy, or %NULL
-     * @param percent - a buffering percent, or %NULL
      */
-    parseBufferingPercent(busy?: Ref<boolean>, percent?: Ref<number>): void;
+    parseBufferingPercent(busy?: Ref<boolean> | null, percent?: Ref<number> | null): void;
     /**
      * Parse an available query, writing the format into `format`, and
      * other results into the passed parameters, if the respective parameters
      * are non-%NULL
-     * @param format - the format to set for the `segment_start`
-     * @param start - the start to set, or %NULL
-     * @param stop - the stop to set, or %NULL
-     * @param estimatedTotal - estimated total amount of download
-     */
-    parseBufferingRange(format?: Ref<Format>, start?: Ref<number>, stop?: Ref<number>, estimatedTotal?: Ref<number>): void;
-    /**
-     * Extracts the buffering stats values from `query`.
-     * @param mode - a buffering mode, or %NULL
-     * @param avgIn - the average input rate, or %NULL
-     * @param avgOut - the average output rat, or %NULL
-     * @param bufferingLeft - amount of buffering time left in
      */
-    parseBufferingStats(mode?: Ref<BufferingMode>, avgIn?: Ref<number>, avgOut?: Ref<number>, bufferingLeft?: Ref<number>): void;
+    parseBufferingRange(format?: Ref<Format> | null, start?: Ref<number> | null, stop?: Ref<number> | null, estimatedTotal?: Ref<number> | null): void;
+    /** Extracts the buffering stats values from `query`. */
+    parseBufferingStats(mode?: Ref<BufferingMode> | null, avgIn?: Ref<number> | null, avgOut?: Ref<number> | null, bufferingLeft?: Ref<number> | null): void;
     /**
      * Get the filter from the caps `query`. The caps remains valid as long as
      * `query` remains valid.
-     * @param filter - A pointer to the caps filter
      */
     parseCaps(filter: Ref<Caps>): void;
     /**
      * Get the caps result from `query`. The caps remains valid as long as
      * `query` remains valid.
-     * @param caps - A pointer to the caps
      */
-    parseCapsResult(caps?: Ref<Caps>): void;
+    parseCapsResult(caps?: Ref<Caps> | null): void;
     /**
      * Get the context from the context `query`. The context remains valid as long as
      * `query` remains valid.
-     * @param context - A pointer to store the #GstContext
      */
-    parseContext(context?: Ref<Context>): void;
-    /**
-     * Parse a context type from an existing GST_QUERY_CONTEXT query.
-     * @param contextType - the context type, or %NULL
-     */
-    parseContextType(contextType?: Ref<string>): boolean;
+    parseContext(context?: Ref<Context> | null): void;
+    /** Parse a context type from an existing GST_QUERY_CONTEXT query. */
+    parseContextType(contextType?: Ref<string> | null): boolean;
     /**
      * Parse a convert query answer. Any of `src_format`, `src_value`, `dest_format`,
      * and `dest_value` may be %NULL, in which case that value is omitted.
-     * @param srcFormat - the storage for the #GstFormat of the
-     * @param srcValue - the storage for the source value, or %NULL
-     * @param destFormat - the storage for the #GstFormat of the
-     * @param destValue - the storage for the destination value,
      */
-    parseConvert(srcFormat?: Ref<Format>, srcValue?: Ref<number>, destFormat?: Ref<Format>, destValue?: Ref<number>): void;
+    parseConvert(srcFormat?: Ref<Format> | null, srcValue?: Ref<number> | null, destFormat?: Ref<Format> | null, destValue?: Ref<number> | null): void;
     /**
      * Parse a duration query answer. Write the format of the duration into `format`,
      * and the value into `duration`, if the respective variables are non-%NULL.
-     * @param format - the storage for the #GstFormat of the duration
-     * @param duration - the storage for the total duration, or %NULL.
-     */
-    parseDuration(format?: Ref<Format>, duration?: Ref<number>): void;
-    /**
-     * Parse a latency query answer.
-     * @param live - storage for live or %NULL
-     * @param minLatency - the storage for the min latency or %NULL
-     * @param maxLatency - the storage for the max latency or %NULL
      */
-    parseLatency(live?: Ref<boolean>, minLatency?: Ref<number>, maxLatency?: Ref<number>): void;
-    /**
-     * Parse the number of formats in the formats `query`.
-     * @param nFormats - the number of formats in this query.
-     */
-    parseNFormats(nFormats?: Ref<number>): void;
+    parseDuration(format?: Ref<Format> | null, duration?: Ref<number> | null): void;
+    /** Parse a latency query answer. */
+    parseLatency(live?: Ref<boolean> | null, minLatency?: Ref<number> | null, maxLatency?: Ref<number> | null): void;
+    /** Parse the number of formats in the formats `query`. */
+    parseNFormats(nFormats?: Ref<number> | null): void;
     /**
      * Parse an available query and get the metadata API
      * at `index` of the metadata API array.
-     * @param index - position in the metadata API array to read
-     * @param params - API specific parameters
      */
-    parseNthAllocationMeta(index: number, params?: Ref<Structure>): number;
+    parseNthAllocationMeta(index: number, params?: Ref<Structure> | null): number;
     /**
      * Parse an available query and get the allocator and its params
      * at `index` of the allocator array.
-     * @param index - position in the allocator array to read
-     * @param allocator - variable to hold the result
-     * @param params - parameters for the allocator
      */
-    parseNthAllocationParam(index: number, allocator?: Ref<Allocator>, params?: AllocationParams): void;
+    parseNthAllocationParam(index: number, allocator?: Ref<Allocator> | null, params?: AllocationParams | null): void;
     /**
      * Get the pool parameters in `query`.
      *
      * Unref `pool` with gst_object_unref() when it's not needed any more.
-     * @param index - index to parse
-     * @param pool - the #GstBufferPool
-     * @param size - the buffer size
-     * @param minBuffers - the min buffers
-     * @param maxBuffers - the max buffers
      */
-    parseNthAllocationPool(index: number, pool?: Ref<BufferPool>, size?: Ref<number>, minBuffers?: Ref<number>, maxBuffers?: Ref<number>): void;
+    parseNthAllocationPool(index: number, pool?: Ref<BufferPool> | null, size?: Ref<number> | null, minBuffers?: Ref<number> | null, maxBuffers?: Ref<number> | null): void;
     /**
      * Parse an available query and get the start and stop values stored
      * at the `index` of the buffered ranges array.
-     * @param index - position in the buffered-ranges array to read
-     * @param start - the start position to set, or %NULL
-     * @param stop - the stop position to set, or %NULL
      */
-    parseNthBufferingRange(index: number, start?: Ref<number>, stop?: Ref<number>): boolean;
+    parseNthBufferingRange(index: number, start?: Ref<number> | null, stop?: Ref<number> | null): boolean;
     /**
      * Parse the format query and retrieve the `nth` format from it into
      * `format`. If the list contains less elements than `nth`, `format` will be
      * set to GST_FORMAT_UNDEFINED.
-     * @param nth - the nth format to retrieve.
-     * @param format - a pointer to store the nth format
      */
-    parseNthFormat(nth: number, format?: Ref<Format>): void;
+    parseNthFormat(nth: number, format?: Ref<Format> | null): void;
     /**
      * Parse an available query and get the scheduling mode
      * at `index` of the scheduling modes array.
-     * @param index - position in the scheduling modes array to read
      */
     parseNthSchedulingMode(index: number): PadMode;
     /**
      * Parse a position query, writing the format into `format`, and the position
      * into `cur`, if the respective parameters are non-%NULL.
-     * @param format - the storage for the #GstFormat of the
-     * @param cur - the storage for the current position (may be %NULL)
-     */
-    parsePosition(format?: Ref<Format>, cur?: Ref<number>): void;
-    /**
-     * Set the scheduling properties.
-     * @param flags - #GstSchedulingFlags
-     * @param minsize - the suggested minimum size of pull requests
-     * @param maxsize - the suggested maximum size of pull requests:
-     * @param align - the suggested alignment of pull requests
      */
-    parseScheduling(flags?: Ref<SchedulingFlags>, minsize?: Ref<number>, maxsize?: Ref<number>, align?: Ref<number>): void;
+    parsePosition(format?: Ref<Format> | null, cur?: Ref<number> | null): void;
+    /** Set the scheduling properties. */
+    parseScheduling(flags?: Ref<SchedulingFlags> | null, minsize?: Ref<number> | null, maxsize?: Ref<number> | null, align?: Ref<number> | null): void;
     /**
      * Parse a seeking query, writing the format into `format`, and
      * other results into the passed parameters, if the respective parameters
      * are non-%NULL
-     * @param format - the format to set for the `segment_start`
-     * @param seekable - the seekable flag to set, or %NULL
-     * @param segmentStart - the segment_start to set, or %NULL
-     * @param segmentEnd - the segment_end to set, or %NULL
      */
-    parseSeeking(format?: Ref<Format>, seekable?: Ref<boolean>, segmentStart?: Ref<number>, segmentEnd?: Ref<number>): void;
+    parseSeeking(format?: Ref<Format> | null, seekable?: Ref<boolean> | null, segmentStart?: Ref<number> | null, segmentEnd?: Ref<number> | null): void;
     /**
      * Parse a segment query answer. Any of `rate`, `format`, `start_value`, and
      * `stop_value` may be %NULL, which will cause this value to be omitted.
      *
      * See gst_query_set_segment() for an explanation of the function arguments.
-     * @param rate - the storage for the rate of the segment, or %NULL
-     * @param format - the storage for the #GstFormat of the values,
-     * @param startValue - the storage for the start value, or %NULL
-     * @param stopValue - the storage for the stop value, or %NULL
      */
-    parseSegment(rate?: Ref<number>, format?: Ref<Format>, startValue?: Ref<number>, stopValue?: Ref<number>): void;
-    /**
-     * Get the results of a selectable query. See also gst_query_set_selectable().
-     * @param selectable - The resulting stream selection capability
-     */
-    parseSelectable(selectable?: Ref<boolean>): void;
+    parseSegment(rate?: Ref<number> | null, format?: Ref<Format> | null, startValue?: Ref<number> | null, stopValue?: Ref<number> | null): void;
+    /** Get the results of a selectable query. See also gst_query_set_selectable(). */
+    parseSelectable(selectable?: Ref<boolean> | null): void;
     /**
      * Parse an URI query, writing the URI into `uri` as a newly
      * allocated string, if the respective parameters are non-%NULL.
      * Free the string with g_free() after usage.
-     * @param uri - the storage for the current URI
      */
-    parseUri(uri?: Ref<string>): void;
+    parseUri(uri?: Ref<string> | null): void;
     /**
      * Parse an URI query, writing the URI into `uri` as a newly
      * allocated string, if the respective parameters are non-%NULL.
      * Free the string with g_free() after usage.
-     * @param uri - the storage for the redirect URI
      */
-    parseUriRedirection(uri?: Ref<string>): void;
+    parseUriRedirection(uri?: Ref<string> | null): void;
     /**
      * Parse an URI query, and set `permanent` to %TRUE if there is a redirection
      * and it should be considered permanent. If a redirection is permanent,
      * applications should update their internal storage of the URI, otherwise
      * they should make all future requests to the original URI.
-     * @param permanent - if the URI redirection is permanent
-     */
-    parseUriRedirectionPermanent(permanent?: Ref<boolean>): void;
-    /**
-     * Increases the refcount of the given query by one.
      */
+    parseUriRedirectionPermanent(permanent?: Ref<boolean> | null): void;
+    /** Increases the refcount of the given query by one. */
     ref(): Query;
-    /**
-     * Remove the metadata API at `index` of the metadata API array.
-     * @param index - position in the metadata API array to remove
-     */
+    /** Remove the metadata API at `index` of the metadata API array. */
     removeNthAllocationMeta(index: number): void;
-    /**
-     * Remove the allocation param at `index` of the allocation param array.
-     * @param index - position in the allocation param array to remove
-     */
+    /** Remove the allocation param at `index` of the allocation param array. */
     removeNthAllocationParam(index: number): void;
-    /**
-     * Remove the allocation pool at `index` of the allocation pool array.
-     * @param index - position in the allocation pool array to remove
-     */
+    /** Remove the allocation pool at `index` of the allocation pool array. */
     removeNthAllocationPool(index: number): void;
-    /**
-     * Set `result` as the result for the `query`.
-     * @param result - the result to set
-     */
+    /** Set `result` as the result for the `query`. */
     setAcceptCapsResult(result: boolean): void;
     /**
      * Set the results of a bitrate query.  The nominal bitrate is the average
      * bitrate expected over the length of the stream as advertised in file
      * headers (or similar).
-     * @param nominalBitrate - the nominal bitrate in bits per second
      */
     setBitrate(nominalBitrate: number): void;
     /**
      * Set the percentage of buffered data. This is a value between 0 and 100.
      * The `busy` indicator is %TRUE when the buffering is in progress.
-     * @param busy - if buffering is busy
-     * @param percent - a buffering percent
      */
     setBufferingPercent(busy: boolean, percent: number): void;
-    /**
-     * Set the available query result fields in `query`.
-     * @param format - the format to set for the `start` and `stop` values
-     * @param start - the start to set
-     * @param stop - the stop to set
-     * @param estimatedTotal - estimated total amount of download time remaining in
-     */
+    /** Set the available query result fields in `query`. */
     setBufferingRange(format: Format, start: number, stop: number, estimatedTotal: number): void;
-    /**
-     * Configures the buffering stats values in `query`.
-     * @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
-     */
+    /** Configures the buffering stats values in `query`. */
     setBufferingStats(mode: BufferingMode, avgIn: number, avgOut: number, bufferingLeft: number): void;
-    /**
-     * Set the `caps` result in `query`.
-     * @param caps - A pointer to the caps
-     */
-    setCapsResult(caps?: Caps): void;
-    /**
-     * Answer a context query by setting the requested context.
-     * @param context - the requested #GstContext
-     */
-    setContext(context?: Context): void;
-    /**
-     * Answer a convert query by setting the requested values.
-     * @param srcFormat - the source #GstFormat
-     * @param srcValue - the source value
-     * @param destFormat - the destination #GstFormat
-     * @param destValue - the destination value
-     */
+    /** Set the `caps` result in `query`. */
+    setCapsResult(caps?: Caps | null): void;
+    /** Answer a context query by setting the requested context. */
+    setContext(context?: Context | null): void;
+    /** Answer a convert query by setting the requested values. */
     setConvert(srcFormat: Format, srcValue: number, destFormat: Format, destValue: number): void;
-    /**
-     * Answer a duration query by setting the requested value in the given format.
-     * @param format - the #GstFormat for the duration
-     * @param duration - the duration of the stream
-     */
+    /** Answer a duration query by setting the requested value in the given format. */
     setDuration(format: Format, duration: number): void;
     /**
      * Set the formats query result fields in `query`. The number of formats passed
      * in the `formats` array must be equal to `n_formats`.
-     * @param nFormats - the number of formats to set.
-     * @param formats - an array containing `n_formats`
      */
     setFormatsv(nFormats: number, formats: Format[]): void;
-    /**
-     * Answer a latency query by setting the requested values in the given format.
-     * @param live - if there is a live element upstream
-     * @param minLatency - the minimal latency of the upstream elements
-     * @param maxLatency - the maximal latency of the upstream elements
-     */
+    /** Answer a latency query by setting the requested values in the given format. */
     setLatency(live: boolean, minLatency: number, maxLatency: number): void;
     /**
      * Parse an available query and get the allocator and its params
      * at `index` of the allocator array.
-     * @param index - position in the allocator array to set
-     * @param allocator - new allocator to set
-     * @param params - parameters for the allocator
-     */
-    setNthAllocationParam(index: number, allocator?: Allocator, params?: AllocationParams): void;
-    /**
-     * Set the pool parameters in `query`.
-     * @param index - index to modify
-     * @param pool - the #GstBufferPool
-     * @param size - the buffer size
-     * @param minBuffers - the min buffers
-     * @param maxBuffers - the max buffers
-     */
-    setNthAllocationPool(index: number, size: number, minBuffers: number, maxBuffers: number, pool?: BufferPool): void;
-    /**
-     * Answer a position query by setting the requested value in the given format.
-     * @param format - the requested #GstFormat
-     * @param cur - the position to set
      */
+    setNthAllocationParam(index: number, allocator?: Allocator | null, params?: AllocationParams | null): void;
+    /** Set the pool parameters in `query`. */
+    setNthAllocationPool(index: number, size: number, minBuffers: number, maxBuffers: number, pool?: BufferPool | null): void;
+    /** Answer a position query by setting the requested value in the given format. */
     setPosition(format: Format, cur: number): void;
-    /**
-     * Set the scheduling properties.
-     * @param flags - #GstSchedulingFlags
-     * @param minsize - the suggested minimum size of pull requests
-     * @param maxsize - the suggested maximum size of pull requests
-     * @param align - the suggested alignment of pull requests
-     */
+    /** Set the scheduling properties. */
     setScheduling(flags: SchedulingFlags, minsize: number, maxsize: number, align: number): void;
-    /**
-     * Set the seeking query result fields in `query`.
-     * @param format - the format to set for the `segment_start` and `segment_end` values
-     * @param seekable - the seekable flag to set
-     * @param segmentStart - the segment_start to set
-     * @param segmentEnd - the segment_end to set
-     */
+    /** Set the seeking query result fields in `query`. */
     setSeeking(format: Format, seekable: boolean, segmentStart: number, segmentEnd: number): void;
     /**
      * Answer a segment query by setting the requested values. The normal
@@ -655,32 +452,20 @@ export declare class Query extends NativeObject {
      * `start_value` <= `stop_value`. `rate` will contain the playback rate. For
      * negative rates, playback will actually happen from `stop_value` to
      * `start_value`.
-     * @param rate - the rate of the segment
-     * @param format - the #GstFormat of the segment values (`start_value` and `stop_value`)
-     * @param startValue - the start value
-     * @param stopValue - the stop value
      */
     setSegment(rate: number, format: Format, startValue: number, stopValue: number): void;
     /**
      * Set the results of a selectable query. If the element answering the query can
      * handle stream selection, `selectable` should be set to %TRUE.
-     * @param selectable - Whether the element can handle stream selection.
      */
     setSelectable(selectable: boolean): void;
-    /**
-     * Answer a URI query by setting the requested URI.
-     * @param uri - the URI to set
-     */
-    setUri(uri?: string): void;
-    /**
-     * Answer a URI query by setting the requested URI redirection.
-     * @param uri - the URI to set
-     */
-    setUriRedirection(uri?: string): void;
+    /** Answer a URI query by setting the requested URI. */
+    setUri(uri?: string | null): void;
+    /** Answer a URI query by setting the requested URI redirection. */
+    setUriRedirection(uri?: string | null): void;
     /**
      * Answer a URI query by setting the requested URI redirection
      * to permanent or not.
-     * @param permanent - whether the redirect is permanent or not
      */
     setUriRedirectionPermanent(permanent: boolean): void;
     /**