/// <reference path="./gstvideo-1.0.d.ts" />
/// <reference path="./gstbase-1.0.d.ts" />
/// <reference path="./gst-1.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />

/**
 * Type Definitions for Gjs (https://gjs.guide/)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
 *
 * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
 */

declare module 'gi://GstVa?version=1.0' {
    // Module dependencies
    import type GstVideo from 'gi://GstVideo?version=1.0';
    import type GstBase from 'gi://GstBase?version=1.0';
    import type Gst from 'gi://Gst?version=1.0';
    import type GObject from 'gi://GObject?version=2.0';
    import type GLib from 'gi://GLib?version=2.0';
    import type GModule from 'gi://GModule?version=2.0';

    export namespace GstVa {
        /**
         * GstVa-1.0
         */

        export namespace VaFeature {
            export const $gtype: GObject.GType<VaFeature>;
        }

        enum VaFeature {
            /**
             * The feature is disabled.
             */
            DISABLED,
            /**
             * The feature is enabled.
             */
            ENABLED,
            /**
             * The feature is enabled automatically.
             */
            AUTO,
        }
        /**
         * Types of different VA API implemented drivers. These are the typical and
         * the most widely used VA drivers.
         */

        /**
         * Types of different VA API implemented drivers. These are the typical and
         * the most widely used VA drivers.
         */
        export namespace VaImplementation {
            export const $gtype: GObject.GType<VaImplementation>;
        }

        enum VaImplementation {
            /**
             * The mesa gallium implementation.
             */
            MESA_GALLIUM,
            /**
             * The legacy i965 intel implementation.
             */
            INTEL_I965,
            /**
             * The iHD intel implementation.
             */
            INTEL_IHD,
            /**
             * Other implementation.
             */
            OTHER,
            /**
             * Invalid implementation.
             */
            INVALID,
        }
        const ALLOCATOR_VASURFACE: string;
        const CAPS_FEATURE_MEMORY_VA: string;
        /**
         * Flag indicating that we should map the VASurfaceID instead of to
         * system memory, so users can use libva primitives to operate with
         * that surface.
         */
        const MAP_VA: number;
        const VA_DISPLAY_HANDLE_CONTEXT_TYPE_STR: string;
        /**
         * Video alignment is not handled as expected by VA since it uses
         * opaque surfaces, not directly mappable memory. Still, decoders
         * might need to request bigger surfaces for coded size rather than
         * display sizes. This method will set the coded size to bufferpool's
         * configuration, out of the typical video aligment.
         * @param config the #GstStructure with the pool's configuration.
         * @param align a #GstVideoAlignment
         */
        function buffer_pool_config_set_va_alignment(config: Gst.Structure, align: GstVideo.VideoAlignment): void;
        /**
         * Sets the usage hint for the buffers handled by the buffer pool.
         * @param config the #GstStructure with the pool's configuration.
         * @param usage_hint the VA usage hint for new VASurfaceID.
         * @param use_derived a #GstVaFeature for derived mapping (only used when     VA allocator).
         */
        function buffer_pool_config_set_va_allocation_params(
            config: Gst.Structure,
            usage_hint: number,
            use_derived: VaFeature | null,
        ): void;
        function context_get_va_display(
            context: Gst.Context,
            type_name: string,
            render_device_path: string,
        ): [boolean, VaDisplay];
        /**
         * Set the `display` in the `context`
         * @param context a #GstContext
         * @param display the #GstVaDisplay we want to set
         */
        function context_set_va_display(context: Gst.Context, display: VaDisplay): void;
        /**
         * Creates a new VASurfaceID with `buffer'`s allocator and attached it
         * to it.
         *
         * *This method is used only by plugin's internal VA decoder.*
         * @param buffer a #GstBuffer
         * @returns %TRUE if the new VASurfaceID is attached to @buffer     correctly; %FALSE, otherwise.
         */
        function va_buffer_create_aux_surface(buffer: Gst.Buffer): boolean;
        function va_buffer_peek_display(buffer: Gst.Buffer): VaDisplay;
        /**
         * Query the specified context type name.
         * @param element a #GstElement
         * @param context_type the #gchar string specify the context type name
         */
        function va_context_query(element: Gst.Element, context_type: string): void;
        /**
         * Get the underlying modifier for specified `format` and `usage_hint`.
         * @param display a #GstVaDisplay
         * @param format a #GstVideoFormat
         * @param usage_hint VA usage hint
         * @returns the underlying modifier.
         */
        function va_dmabuf_get_modifier_for_format(
            display: VaDisplay,
            format: GstVideo.VideoFormat | null,
            usage_hint: number,
        ): number;
        /**
         * It imports the array of `mem,` representing a single frame, into a
         * VASurfaceID and it's attached into every `mem`.
         * @param display a #GstVaDisplay
         * @param drm_info a #GstVideoInfoDmaDrm
         * @param mem Memories. One     per plane.
         * @param fds array of     DMABuf file descriptors.
         * @param offset array of memory     offsets.
         * @param usage_hint VA usage hint.
         * @returns %TRUE if frame is imported correctly into a VASurfaceID; %FALSE otherwise.
         */
        function va_dmabuf_memories_setup(
            display: VaDisplay,
            drm_info: GstVideo.VideoInfoDmaDrm,
            mem: Gst.Memory[],
            fds: never[],
            offset: number[],
            usage_hint: number,
        ): boolean;
        /**
         * Propagate `display` by posting it as #GstContext in the pipeline's bus.
         * @param element a #GstElement
         * @param display the #GstVaDisplay to propagate
         */
        function va_element_propagate_display_context(element: Gst.Element, display: VaDisplay): void;
        /**
         * Called by the va element to ensure a valid #GstVaDisplay.
         * @param element a #GstElement
         * @param render_device_path the #gchar string of render device path
         * @returns whether a #GstVaDisplay exists in @display_ptr
         */
        function va_ensure_element_data(element: any | null, render_device_path: string): [boolean, VaDisplay];
        /**
         * Used by elements when processing their pad's queries, propagating
         * element's #GstVaDisplay if the processed query requests it.
         * @param element a #GstElement
         * @param query a #GstQuery to query the context
         * @param display a #GstVaDisplay to answer the query
         * @returns whether we can handle the context query successfully
         */
        function va_handle_context_query(element: Gst.Element, query: Gst.Query, display: VaDisplay): boolean;
        /**
         * Called by elements in their #GstElementClass::set_context vmethod.
         * It gets a valid #GstVaDisplay if `context` has it.
         * @param element a #GstElement
         * @param context a #GstContext may contain the display
         * @param render_device_path the #gchar string of render device path
         * @returns whether the @display_ptr could be successfully set to a valid #GstVaDisplay in the @context
         */
        function va_handle_set_context(
            element: Gst.Element,
            context: Gst.Context,
            render_device_path: string,
        ): [boolean, VaDisplay];
        function va_memory_peek_display(mem: Gst.Memory): VaDisplay;
        namespace VaAllocator {
            // Constructor properties interface

            interface ConstructorProps extends Gst.Allocator.ConstructorProps {}
        }

        /**
         * There are two types of VA allocators:
         *
         * * #GstVaAllocator
         * * #GstVaDmabufAllocator
         */
        class VaAllocator extends Gst.Allocator {
            static $gtype: GObject.GType<VaAllocator>;

            // Constructors

            constructor(properties?: Partial<VaAllocator.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](display: VaDisplay, surface_formats: number[]): VaAllocator;

            // Static methods

            /**
             * Allocate a new VASurfaceID backed #GstMemory.
             * @param allocator a #GstAllocator
             */
            static alloc(allocator: Gst.Allocator): Gst.Memory;
            /**
             * Removes all the memories in `allocator'`s pool.
             * @param allocator a #GstAllocator
             */
            static flush(allocator: Gst.Allocator): void;
            /**
             * Gets current internal configuration of `allocator`.
             * @param allocator a #GstAllocator
             */
            static get_format(allocator: Gst.Allocator): [boolean, GstVideo.VideoInfo | null, number, boolean];
            static peek_display(allocator: Gst.Allocator): VaDisplay;
            /**
             * This method will populate `buffer` with pooled VASurfaceID
             * memories. It doesn't allocate new VASurfacesID.
             * @param allocator a #GstAllocator
             * @param buffer an empty #GstBuffer
             */
            static prepare_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
            /**
             * Sets the configuration defined by `info,` `usage_hint` and
             * `use_derived` for `allocator,` and it tries the configuration, if
             * `allocator` has not allocated memories yet.
             *
             * If `allocator` has memory allocated already, and frame size and
             * format in `info` are the same as currently configured in `allocator,`
             * the rest of `info` parameters are updated internally.
             * @param allocator a #GstAllocator
             * @param info a #GstVideoInfo
             * @param usage_hint VA usage hint
             * @param feat_use_derived a #GstVaFeature
             */
            static set_format(
                allocator: Gst.Allocator,
                info: GstVideo.VideoInfo,
                usage_hint: number,
                feat_use_derived: VaFeature,
            ): [boolean, GstVideo.VideoInfo];
            /**
             * Populates an empty `buffer` with a VASuface backed #GstMemory.
             * @param allocator a #GstAllocator
             * @param buffer a #GstBuffer
             */
            static setup_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
        }

        namespace VaDisplay {
            // Constructor properties interface

            interface ConstructorProps extends Gst.Object.ConstructorProps {
                description: string;
                va_display: any;
                vaDisplay: any;
            }
        }

        /**
         * It is a generic wrapper for VADisplay. To create new instances
         * subclasses are required, depending on the display type to use
         * (v.gr. DRM, X11, Wayland, etc.).
         *
         * The purpose of this class is to be shared among pipelines via
         * #GstContext so all the VA processing elements will use the same
         * display entry. Application developers can create their own
         * subclass, based on their display, and shared it via the synced bus
         * message for the application.
         */
        class VaDisplay extends Gst.Object {
            static $gtype: GObject.GType<VaDisplay>;

            // Properties

            get description(): string;
            get va_display(): any;
            get vaDisplay(): any;

            // Constructors

            constructor(properties?: Partial<VaDisplay.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Virtual methods

            /**
             * This is called when the subclass has to create the internal
             * VADisplay.
             */
            vfunc_create_va_display(): any | null;

            // Methods

            check_version(major: number, minor: number): boolean;
            /**
             * Get the the #GstVaImplementation type of `self`.
             * @returns #GstVaImplementation.
             */
            get_implementation(): VaImplementation;
            /**
             * Get the VA display handle of the `self`.
             * @returns the VA display handle.
             */
            get_va_dpy(): any | null;
            /**
             * If the display is set by the user (foreign) it is assumed that the
             * driver is already initialized, thus this function is noop.
             *
             * If the display is opened internally, this function will initialize
             * the driver and it will set driver's message callbacks.
             *
             * NOTE: this function is supposed to be private, only used by
             * GstVaDisplay descendants.
             * @returns %TRUE if the VA driver can be initialized; %FALSE     otherwise
             */
            initialize(): boolean;
        }

        namespace VaDisplayDrm {
            // Constructor properties interface

            interface ConstructorProps extends VaDisplay.ConstructorProps {
                path: string;
            }
        }

        /**
         * This is a #GstVaDisplay subclass to instantiate with DRM devices.
         */
        class VaDisplayDrm extends VaDisplay {
            static $gtype: GObject.GType<VaDisplayDrm>;

            // Properties

            get path(): string;

            // Constructors

            constructor(properties?: Partial<VaDisplayDrm.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_from_path(path: string): VaDisplayDrm;
        }

        namespace VaDisplayWrapped {
            // Constructor properties interface

            interface ConstructorProps extends VaDisplay.ConstructorProps {}
        }

        /**
         * This is a #GstVaDisplay instantiaton subclass for custom created
         * VADisplay, such as X11 or Wayland, wrapping it.
         */
        class VaDisplayWrapped extends VaDisplay {
            static $gtype: GObject.GType<VaDisplayWrapped>;

            // Constructors

            constructor(properties?: Partial<VaDisplayWrapped.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](handle?: any | null): VaDisplayWrapped;
        }

        namespace VaDmabufAllocator {
            // Constructor properties interface

            interface ConstructorProps extends Gst.Allocator.ConstructorProps {}
        }

        /**
         * A pooled memory allocator backed by the DMABufs exported from a
         * VASurfaceID. Also it is possible to import DMAbufs into a
         * VASurfaceID.
         */
        class VaDmabufAllocator extends Gst.Allocator {
            static $gtype: GObject.GType<VaDmabufAllocator>;

            // Constructors

            constructor(properties?: Partial<VaDmabufAllocator.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](display: VaDisplay): VaDmabufAllocator;

            // Static methods

            /**
             * Removes all the memories in `allocator'`s pool.
             * @param allocator a #GstAllocator
             */
            static flush(allocator: Gst.Allocator): void;
            /**
             * Gets current internal configuration of `allocator`.
             * @param allocator a #GstAllocator
             */
            static get_format(allocator: Gst.Allocator): [boolean, GstVideo.VideoInfoDmaDrm | null, number];
            /**
             * This method will populate `buffer` with pooled VASurfaceID/DMABuf
             * memories. It doesn't allocate new VASurfacesID.
             * @param allocator a #GstAllocator
             * @param buffer an empty #GstBuffer
             */
            static prepare_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
            /**
             * Sets the configuration defined by `info` and `usage_hint` for
             * `allocator,` and it tries the configuration, if `allocator` has not
             * allocated memories yet.
             *
             * If `allocator` has memory allocated already, and frame size, format
             * and modifier in `info` are the same as currently configured in
             * `allocator,` the rest of `info` parameters are updated internally.
             * @param allocator a #GstAllocator
             * @param usage_hint VA usage hint
             */
            static set_format(allocator: Gst.Allocator, usage_hint: number): [boolean, GstVideo.VideoInfoDmaDrm];
            /**
             * This function creates a new VASurfaceID and exposes its DMABufs,
             * later it populates the `buffer` with those DMABufs.
             * @param allocator a #GstAllocator
             * @param buffer an empty #GstBuffer
             */
            static setup_buffer(allocator: Gst.Allocator, buffer: Gst.Buffer): boolean;
        }

        namespace VaPool {
            // Constructor properties interface

            interface ConstructorProps extends Gst.BufferPool.ConstructorProps {}
        }

        /**
         * `GstVaPool` is a buffer pool for VA allocators.
         */
        class VaPool extends Gst.BufferPool {
            static $gtype: GObject.GType<VaPool>;

            // Constructors

            constructor(properties?: Partial<VaPool.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): VaPool;

            static new_with_config(
                caps: Gst.Caps,
                min_buffers: number,
                max_buffers: number,
                usage_hint: number,
                use_derived: VaFeature,
                allocator: Gst.Allocator,
                alloc_params: Gst.AllocationParams,
            ): VaPool;

            // Static methods

            /**
             * Helper function to retrieve the VA surface size provided by `pool`.
             * @param pool a #GstBufferPool
             */
            static get_buffer_size(pool: Gst.BufferPool): [boolean, number];
            /**
             * Retuns: %TRUE if `pool` always add #GstVideoMeta to its
             *     buffers. Otherwise, %FALSE.
             * @param pool the #GstBufferPool
             */
            static requires_video_meta(pool: Gst.BufferPool): boolean;
        }

        type VaDisplayClass = typeof VaDisplay;
        type VaDisplayDrmClass = typeof VaDisplayDrm;
        type VaDisplayWrappedClass = typeof VaDisplayWrapped;
        /**
         * Name of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
         */
        const __name__: string;
        /**
         * Version of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
         */
        const __version__: string;
    }

    export default GstVa;
}

declare module 'gi://GstVa' {
    import GstVa10 from 'gi://GstVa?version=1.0';
    export default GstVa10;
}
// END