@girs/cogl-8 4.2.0 → 4.4.0

package/cogl-8.d.ts

@@ -1720,27 +1720,32 @@ export namespace Cogl {
          * Parses an image file enough to extract the width and height
          * of the bitmap.
          * @param filename the file to check
+         * @since 1.0
          */
         static get_size_from_file(filename: string): [boolean, number, number];
 
         // Methods
         /**
          * @returns the {@link Cogl.PixelFormat} that the data for the bitmap is in.
+         * @since 1.10
          */
         get_format(): PixelFormat;
 
         /**
          * @returns the height of the bitmap
+         * @since 1.10
          */
         get_height(): number;
 
         /**
          * @returns the rowstride of the bitmap. This is the number of   bytes between the address of start of one row to the address of the   next row in the image.
+         * @since 1.10
          */
         get_rowstride(): number;
 
         /**
          * @returns the width of the bitmap
+         * @since 1.10
          */
         get_width(): number;
     }
@@ -1830,6 +1835,7 @@ export namespace Cogl {
          * Gets the frame counter for the {@link Cogl.Onscreen} that corresponds
          * to this frame.
          * @returns The frame counter value
+         * @since 1.14
          */
         get_frame_counter(): number;
 
@@ -1845,6 +1851,7 @@ export namespace Cogl {
          * <note>Some buggy Mesa drivers up to 9.0.1 may
          * incorrectly report non-monotonic timestamps.</note>
          * @returns the presentation time for the frame
+         * @since 1.14
          */
         get_presentation_time_us(): number;
 
@@ -1858,6 +1865,7 @@ export namespace Cogl {
          * more reliable than using `cogl_frame_info_get_output()` followed by
          * `cogl_output_get_refresh_rate()`.</note>
          * @returns the refresh rate in Hertz
+         * @since 1.14
          */
         get_refresh_rate(): number;
 
@@ -1958,6 +1966,7 @@ export namespace Cogl {
          * used.  The disadvantage of relying on automatic allocation is that the
          * program will abort with an error message if there is an error during
          * automatic allocation.</note>
+         * @since 1.8
          * @virtual
          */
         vfunc_allocate(): boolean;
@@ -1980,6 +1989,7 @@ export namespace Cogl {
          * program will abort with an error message if there is an error during
          * automatic allocation.</note>
          * @returns `true` if there were no error allocating the framebuffer, else `false`.
+         * @since 1.8
          */
         allocate(): boolean;
 
@@ -1988,6 +1998,7 @@ export namespace Cogl {
          * that includes the color buffer then the specified `color` is used.
          * @param buffers A mask of {@link Cogl.BufferBit}<!-- -->'s identifying which auxiliary   buffers to clear
          * @param color The color to clear the color buffer too if specified in         `buffers`.
+         * @since 1.8
          */
         clear(buffers: bigint | number, color: Color): void;
 
@@ -1999,6 +2010,7 @@ export namespace Cogl {
          * @param green The green component of color to clear the color buffer too if         specified in `buffers`.
          * @param blue The blue component of color to clear the color buffer too if        specified in `buffers`.
          * @param alpha The alpha component of color to clear the color buffer too if         specified in `buffers`.
+         * @since 1.8
          */
         clear4f(buffers: bigint | number, red: number, green: number, blue: number, alpha: number): void;
 
@@ -2020,6 +2032,7 @@ export namespace Cogl {
          * framebuffer, and it's not meaningful to try and discard the color buffer of
          * a {@link Cogl.Offscreen} framebuffer since they are single-buffered.
          * @param buffers A {@link Cogl.BufferBit} mask of which ancillary buffers you want           to discard.
+         * @since 1.8
          */
         discard_buffers(buffers: bigint | number): void;
 
@@ -2069,6 +2082,7 @@ export namespace Cogl {
          * @param y_2 y coordinate lower right on screen.
          * @param tex_coords An array containing groups of   4 float values: [s_1, t_1, s_2, t_2] that are interpreted as two texture   coordinates; one for the top left texel, and one for the bottom right   texel. Each value should be between 0.0 and 1.0, where the coordinate   (0.0, 0.0) represents the top left of the texture, and (1.0, 1.0) the   bottom right.
          * @param tex_coords_len The length of the `tex_coords` array. (For one layer   and one group of texture coordinates, this would be 4)
+         * @since 1.10
          */
         draw_multitextured_rectangle(pipeline: Pipeline, x_1: number, y_1: number, x_2: number, y_2: number, tex_coords: number[], tex_coords_len: number): void;
 
@@ -2089,6 +2103,7 @@ export namespace Cogl {
          * @param y_1 Y coordinate of the top-left corner
          * @param x_2 X coordinate of the bottom-right corner
          * @param y_2 Y coordinate of the bottom-right corner
+         * @since 1.10
          */
         draw_rectangle(pipeline: Pipeline, x_1: number, y_1: number, x_2: number, y_2: number): void;
 
@@ -2115,6 +2130,7 @@ export namespace Cogl {
          * @param pipeline A {@link Cogl.Pipeline} state object
          * @param coordinates an array of coordinates   containing groups of 4 float values: [x_1, y_1, x_2, y_2] that are   interpreted as two position coordinates; one for the top left of   the rectangle (x1, y1), and one for the bottom right of the   rectangle (x2, y2).
          * @param n_rectangles number of rectangles defined in `coordinates`.
+         * @since 1.10
          */
         draw_rectangles(pipeline: Pipeline, coordinates: number[], n_rectangles: number): void;
 
@@ -2154,6 +2170,7 @@ export namespace Cogl {
          * @param t_1 T texture coordinate of the top-left coorner
          * @param s_2 S texture coordinate of the bottom-right coorner
          * @param t_2 T texture coordinate of the bottom-right coorner
+         * @since 1.10
          */
         draw_textured_rectangle(pipeline: Pipeline, x_1: number, y_1: number, x_2: number, y_2: number, s_1: number, t_1: number, s_2: number, t_2: number): void;
 
@@ -2195,6 +2212,7 @@ export namespace Cogl {
          * @param pipeline A {@link Cogl.Pipeline} state object
          * @param coordinates an array containing   groups of 8 float values: [x_1, y_1, x_2, y_2, s_1, t_1, s_2, t_2]   that have the same meaning as the arguments for   `cogl_framebuffer_draw_textured_rectangle()`.
          * @param n_rectangles number of rectangles to `coordinates` to draw
+         * @since 1.10
          */
         draw_textured_rectangles(pipeline: Pipeline, coordinates: number[], n_rectangles: number): void;
 
@@ -2208,6 +2226,7 @@ export namespace Cogl {
          * One example might be for benchmarking purposes to be sure timing
          * measurements reflect the time that the GPU is busy for not just the time it
          * takes to queue rendering commands.
+         * @since 1.10
          */
         finish(): void;
 
@@ -2229,18 +2248,21 @@ export namespace Cogl {
          * @param top Y position of the top clipping plane where it intersects   the near clipping plane
          * @param z_near The distance to the near clipping plane (Must be positive)
          * @param z_far The distance to the far clipping plane (Must be positive)
+         * @since 1.10
          */
         frustum(left: number, right: number, bottom: number, top: number, z_near: number, z_far: number): void;
 
         /**
          * Retrieves the number of alpha bits of `framebuffer`
          * @returns the number of bits
+         * @since 1.8
          */
         get_alpha_bits(): number;
 
         /**
          * Retrieves the number of blue bits of `framebuffer`
          * @returns the number of bits
+         * @since 1.8
          */
         get_blue_bits(): number;
 
@@ -2249,12 +2271,14 @@ export namespace Cogl {
          * instantiated within. This is the {@link Cogl.Context} that was passed to
          * `cogl_onscreen_new()` for example.
          * @returns The {@link Cogl.Context} that the given               `framebuffer` was instantiated within.
+         * @since 1.8
          */
         get_context(): Context;
 
         /**
          * Retrieves the number of depth bits of `framebuffer`
          * @returns the number of bits
+         * @since 2.0
          */
         get_depth_bits(): number;
 
@@ -2262,6 +2286,7 @@ export namespace Cogl {
          * Queries whether depth buffer writing is enabled for `framebuffer`. This
          * can be controlled via `cogl_framebuffer_set_depth_write_enabled()`.
          * @returns `true` if depth writing is enabled or `false` if not.
+         * @since 1.18
          */
         get_depth_write_enabled(): boolean;
 
@@ -2273,18 +2298,21 @@ export namespace Cogl {
          * display pipeline does not support dithering. This value only represents
          * the user's request for dithering.</note>
          * @returns `true` if dithering has been requested or `false` if not.
+         * @since 1.8
          */
         get_dither_enabled(): boolean;
 
         /**
          * Retrieves the number of green bits of `framebuffer`
          * @returns the number of bits
+         * @since 1.8
          */
         get_green_bits(): number;
 
         /**
          * Queries the current height of the given `framebuffer`.
          * @returns The height of `framebuffer`.
+         * @since 1.8
          */
         get_height(): number;
 
@@ -2292,17 +2320,20 @@ export namespace Cogl {
 
         /**
          * Stores the current model-view matrix in `matrix`.
+         * @since 1.10
          */
         get_modelview_matrix(): Graphene.Matrix;
 
         /**
          * Stores the current projection matrix in `matrix`.
+         * @since 1.10
          */
         get_projection_matrix(): Graphene.Matrix;
 
         /**
          * Retrieves the number of red bits of `framebuffer`
          * @returns the number of bits
+         * @since 1.8
          */
         get_red_bits(): number;
 
@@ -2320,6 +2351,7 @@ export namespace Cogl {
          * framebuffer has been allocated the value will reflect the actual
          * number of samples that will be made by the GPU.
          * @returns The number of point samples made per pixel when          rasterizing geometry or 0 if single-sample rendering          has been chosen.
+         * @since 1.10
          */
         get_samples_per_pixel(): number;
 
@@ -2327,6 +2359,7 @@ export namespace Cogl {
          * Gets the current {@link Cogl.StereoMode}, which defines which stereo buffers
          * should be drawn to. See `cogl_framebuffer_set_stereo_mode()`.
          * @returns A {@link Cogl.StereoMode}
+         * @since 1.20
          */
         get_stereo_mode(): StereoMode;
 
@@ -2335,6 +2368,7 @@ export namespace Cogl {
          * using `cogl_framebuffer_set_viewport()` or the default values which are 0, 0,
          * framebuffer_width and framebuffer_height.  The values are written into the
          * given `viewport` array.
+         * @since 1.8
          */
         get_viewport4fv(): number[];
 
@@ -2342,6 +2376,7 @@ export namespace Cogl {
          * Queries the height of the viewport as set using `cogl_framebuffer_set_viewport()`
          * or the default value which is the height of the framebuffer.
          * @returns The height of the viewport.
+         * @since 1.8
          */
         get_viewport_height(): number;
 
@@ -2349,6 +2384,7 @@ export namespace Cogl {
          * Queries the width of the viewport as set using `cogl_framebuffer_set_viewport()`
          * or the default value which is the width of the framebuffer.
          * @returns The width of the viewport.
+         * @since 1.8
          */
         get_viewport_width(): number;
 
@@ -2356,6 +2392,7 @@ export namespace Cogl {
          * Queries the x coordinate of the viewport origin as set using `cogl_framebuffer_set_viewport()`
          * or the default value which is 0.
          * @returns The x coordinate of the viewport origin.
+         * @since 1.8
          */
         get_viewport_x(): number;
 
@@ -2363,17 +2400,20 @@ export namespace Cogl {
          * Queries the y coordinate of the viewport origin as set using `cogl_framebuffer_set_viewport()`
          * or the default value which is 0.
          * @returns The y coordinate of the viewport origin.
+         * @since 1.8
          */
         get_viewport_y(): number;
 
         /**
          * Queries the current width of the given `framebuffer`.
          * @returns The width of `framebuffer`.
+         * @since 1.8
          */
         get_width(): number;
 
         /**
          * Resets the current model-view matrix to the identity matrix.
+         * @since 1.10
          */
         identity_matrix(): void;
 
@@ -2386,6 +2426,7 @@ export namespace Cogl {
          * @param y_2 The y coordinate for the second horizontal clipping plane
          * @param near The <emphasis>distance</emphasis> to the near clipping   plane (will be <emphasis>negative</emphasis> if the plane is   behind the viewer)
          * @param far The <emphasis>distance</emphasis> to the far clipping   plane (will be <emphasis>negative</emphasis> if the plane is   behind the viewer)
+         * @since 1.10
          */
         orthographic(x_1: number, y_1: number, x_2: number, y_2: number, near: number, far: number): void;
 
@@ -2401,6 +2442,7 @@ export namespace Cogl {
          * @param aspect The (width over height) aspect ratio for display
          * @param z_near The distance to the near clipping plane (Must be positive,   and must not be 0)
          * @param z_far The distance to the far clipping plane (Must be positive)
+         * @since 1.10
          */
         perspective(fov_y: number, aspect: number, z_near: number, z_far: number): void;
 
@@ -2408,17 +2450,20 @@ export namespace Cogl {
          * Reverts the clipping region to the state before the last call to
          * `cogl_framebuffer_push_scissor_clip()`, `cogl_framebuffer_push_rectangle_clip()`
          * `cogl_framebuffer_push_path_clip()`, or `cogl_framebuffer_push_primitive_clip()`.
+         * @since 1.10
          */
         pop_clip(): void;
 
         /**
          * Restores the model-view matrix on the top of the matrix stack.
+         * @since 1.10
          */
         pop_matrix(): void;
 
         /**
          * Copies the current model-view matrix onto the matrix stack. The matrix
          * can later be restored with `cogl_framebuffer_pop_matrix()`.
+         * @since 1.10
          */
         push_matrix(): void;
 
@@ -2435,6 +2480,7 @@ export namespace Cogl {
          * @param y_1 y coordinate for top left corner of the clip rectangle
          * @param x_2 x coordinate for bottom right corner of the clip rectangle
          * @param y_2 y coordinate for bottom right corner of the clip rectangle
+         * @since 1.10
          */
         push_rectangle_clip(x_1: number, y_1: number, x_2: number, y_2: number): void;
 
@@ -2456,6 +2502,7 @@ export namespace Cogl {
          * @param y top edge of the clip rectangle in window coordinates
          * @param width width of the clip rectangle
          * @param height height of the clip rectangle
+         * @since 1.10
          */
         push_scissor_clip(x: number, y: number, width: number, height: number): void;
 
@@ -2493,6 +2540,7 @@ export namespace Cogl {
          * @param format The pixel format to store the data in
          * @param pixels The address of the buffer to store the data in
          * @returns `true` if the read succeeded or `false` otherwise.
+         * @since 1.10
          */
         read_pixels(x: number, y: number, width: number, height: number, format: PixelFormat, pixels: number): boolean;
 
@@ -2512,6 +2560,7 @@ export namespace Cogl {
          * @param source Identifies which auxiliary buffer you want to read          (only COGL_READ_PIXELS_COLOR_BUFFER supported currently)
          * @param bitmap The bitmap to store the results in.
          * @returns `true` if the read succeeded or `false` otherwise. The  function is only likely to fail if the bitmap points to a pixel  buffer and it could not be mapped.
+         * @since 1.10
          */
         read_pixels_into_bitmap(x: number, y: number, source: ReadPixelsFlags, bitmap: Bitmap): boolean;
 
@@ -2536,6 +2585,7 @@ export namespace Cogl {
          * If you are performing incremental updates to a framebuffer you
          * should consider using `cogl_framebuffer_resolve_samples_region()`
          * instead to avoid resolving redundant pixels.
+         * @since 1.8
          */
         resolve_samples(): void;
 
@@ -2565,6 +2615,7 @@ export namespace Cogl {
          * @param y top-left y coordinate of region to resolve
          * @param width width of region to resolve
          * @param height height of region to resolve
+         * @since 1.8
          */
         resolve_samples_region(x: number, y: number, width: number, height: number): void;
 
@@ -2578,6 +2629,7 @@ export namespace Cogl {
          * @param x X-component of vertex to rotate around.
          * @param y Y-component of vertex to rotate around.
          * @param z Z-component of vertex to rotate around.
+         * @since 1.10
          */
         rotate(angle: number, x: number, y: number, z: number): void;
 
@@ -2585,6 +2637,7 @@ export namespace Cogl {
          * Multiplies the current model-view matrix by one that rotates
          * according to the rotation described by `euler`.
          * @param euler A {@link Graphene.Euler}
+         * @since 2.0
          */
         rotate_euler(euler: Graphene.Euler): void;
 
@@ -2594,6 +2647,7 @@ export namespace Cogl {
          * @param x Amount to scale along the x-axis
          * @param y Amount to scale along the y-axis
          * @param z Amount to scale along the z-axis
+         * @since 1.10
          */
         scale(x: number, y: number, z: number): void;
 
@@ -2605,6 +2659,7 @@ export namespace Cogl {
          * 
          * Depth buffer writing is enabled by default.
          * @param depth_write_enabled `true` to enable depth writing or `false` to disable
+         * @since 1.18
          */
         set_depth_write_enabled(depth_write_enabled: boolean): void;
 
@@ -2623,18 +2678,21 @@ export namespace Cogl {
          * 
          * Dithering is enabled by default.
          * @param dither_enabled `true` to enable dithering or `false` to disable
+         * @since 1.8
          */
         set_dither_enabled(dither_enabled: boolean): void;
 
         /**
          * Sets `matrix` as the new model-view matrix.
          * @param matrix the new model-view matrix
+         * @since 1.10
          */
         set_modelview_matrix(matrix: Graphene.Matrix): void;
 
         /**
          * Sets `matrix` as the new projection matrix.
          * @param matrix the new projection matrix
+         * @since 1.10
          */
         set_projection_matrix(matrix: Graphene.Matrix): void;
 
@@ -2672,6 +2730,7 @@ export namespace Cogl {
          * framebuffer has changed this can lead to redundant work being
          * done.</note>
          * @param samples_per_pixel The minimum number of samples per pixel
+         * @since 1.8
          */
         set_samples_per_pixel(samples_per_pixel: number): void;
 
@@ -2684,6 +2743,7 @@ export namespace Cogl {
          * enabled. (See `cogl_onscreen_template_set_stereo_enabled()`,
          * `cogl_framebuffer_get_is_stereo()`.)
          * @param stereo_mode A {@link Cogl.StereoMode} specifying which stereo buffers               should be drawn tow.
+         * @since 1.20
          */
         set_stereo_mode(stereo_mode: StereoMode): void;
 
@@ -2707,12 +2767,14 @@ export namespace Cogl {
          * @param y The top-left y coordinate of the viewport origin (only integers     supported currently)
          * @param width The width of the viewport (only integers supported currently)
          * @param height The height of the viewport (only integers supported currently)
+         * @since 1.8
          */
         set_viewport(x: number, y: number, width: number, height: number): void;
 
         /**
          * Multiplies the current model-view matrix by the given matrix.
          * @param matrix the matrix to multiply with the current model-view
+         * @since 1.10
          */
         transform(matrix: Graphene.Matrix): void;
 
@@ -2722,6 +2784,7 @@ export namespace Cogl {
          * @param x Distance to translate along the x-axis
          * @param y Distance to translate along the y-axis
          * @param z Distance to translate along the z-axis
+         * @since 1.10
          */
         translate(x: number, y: number, z: number): void;
     }
@@ -2895,6 +2958,7 @@ export namespace Cogl {
          * explicitly checked to determine if Cogl is currently tracking the
          * age of {@link Cogl.Onscreen} back buffer contents. If this feature is
          * missing then this function will always return 0.</note>
+         * @since 1.14
          * @virtual
          */
         vfunc_get_buffer_age(): number;
@@ -2940,6 +3004,7 @@ export namespace Cogl {
          * @param rectangles An array of integer 4-tuples representing damaged              rectangles as (x, y, width, height) tuples.
          * @param n_rectangles The number of 4-tuples to be read from `rectangles`
          * @param info 
+         * @since 1.16
          * @virtual
          */
         vfunc_swap_buffers_with_damage(rectangles: number, n_rectangles: number, info: FrameInfo): void;
@@ -2957,6 +3022,7 @@ export namespace Cogl {
          * @param rectangles An array of integer 4-tuples representing rectangles as              (x, y, width, height) tuples.
          * @param n_rectangles The number of 4-tuples to be read from `rectangles`
          * @param info 
+         * @since 1.10
          * @virtual
          */
         vfunc_swap_region(rectangles: number, n_rectangles: number, info: FrameInfo): void;
@@ -2982,6 +3048,7 @@ export namespace Cogl {
          * @param callback A callback function to call for dirty events
          * @param destroy An optional callback to destroy `user_data` when the           `callback` is removed or `onscreen` is freed.
          * @returns a {@link Cogl.OnscreenDirtyClosure} pointer that can be used to               remove the callback and associated `user_data` later.
+         * @since 1.16
          */
         add_dirty_callback(callback: OnscreenDirtyCallback, destroy: UserDataDestroyCallback | null): OnscreenDirtyClosure;
 
@@ -3012,6 +3079,7 @@ export namespace Cogl {
          * @param callback A callback function to call for frame events
          * @param destroy An optional callback to destroy `user_data`           when the `callback` is removed or `onscreen` is freed.
          * @returns a {@link Cogl.FrameClosure} pointer that can be used to               remove the callback and associated `user_data` later.
+         * @since 1.14
          */
         add_frame_callback(callback: FrameCallback, destroy: UserDataDestroyCallback | null): FrameClosure;
 
@@ -3055,6 +3123,7 @@ export namespace Cogl {
          * age of {@link Cogl.Onscreen} back buffer contents. If this feature is
          * missing then this function will always return 0.</note>
          * @returns The age of the buffer contents or 0 when the buffer               contents are undefined.
+         * @since 1.14
          */
         get_buffer_age(): number;
 
@@ -3064,6 +3133,7 @@ export namespace Cogl {
          * `cogl_onscreen_swap_buffers()` or `cogl_onscreen_swap_region()`
          * is called.
          * @returns the current frame counter value
+         * @since 1.14
          */
         get_frame_counter(): number;
 
@@ -3082,6 +3152,7 @@ export namespace Cogl {
          * requests e.g. to show an already visible window. This also means
          * that it's acceptable to alternatively use native APIs to show and
          * hide windows without confusing Cogl.</note>
+         * @since 2.0
          */
         hide(): void;
 
@@ -3093,6 +3164,7 @@ export namespace Cogl {
          * `cogl_onscreen_add_dirty_callback()` to destroy the user data then
          * this will also get called.
          * @param closure A {@link Cogl.OnscreenDirtyClosure} returned from           `cogl_onscreen_add_dirty_callback()`
+         * @since 1.16
          */
         remove_dirty_callback(closure: OnscreenDirtyClosure): void;
 
@@ -3104,6 +3176,7 @@ export namespace Cogl {
          * `cogl_onscreen_add_frame_callback()` to destroy the user data then
          * this will get called.
          * @param closure A {@link Cogl.FrameClosure} returned from           `cogl_onscreen_add_frame_callback()`
+         * @since 1.14
          */
         remove_frame_callback(closure: FrameClosure): void;
 
@@ -3128,6 +3201,7 @@ export namespace Cogl {
          * requests e.g. to show an already visible window. This also means
          * that it's acceptable to alternatively use native APIs to show and
          * hide windows without confusing Cogl.</note>
+         * @since 2.0
          */
         show(): void;
 
@@ -3147,6 +3221,7 @@ export namespace Cogl {
          * render a full buffer for every frame.</note>
          * @param frame_info 
          * @param user_data 
+         * @since 1.10
          */
         swap_buffers(frame_info: FrameInfo, user_data: null): void;
 
@@ -3192,6 +3267,7 @@ export namespace Cogl {
          * @param n_rectangles The number of 4-tuples to be read from `rectangles`
          * @param info 
          * @param user_data 
+         * @since 1.16
          */
         swap_buffers_with_damage(rectangles: number, n_rectangles: number, info: FrameInfo, user_data: null): void;
 
@@ -3209,6 +3285,7 @@ export namespace Cogl {
          * @param n_rectangles The number of 4-tuples to be read from `rectangles`
          * @param info 
          * @param user_data 
+         * @since 1.10
          */
         swap_region(rectangles: number, n_rectangles: number, info: FrameInfo, user_data: null): void;
     }
@@ -3254,32 +3331,38 @@ export namespace Cogl {
          * keep track of a pipelines ancestry which we may use to help minimize GPU
          * state changes.
          * @returns a pointer to the newly allocated {@link Cogl.Pipeline}
+         * @since 2.0
          */
         copy(): Pipeline;
 
         /**
          * Iterates all the layer indices of the given `pipeline`.
          * @param callback A {@link Cogl.PipelineLayerCallback} to be            called for each layer index
+         * @since 2.0
          */
         foreach_layer(callback: PipelineLayerCallback): void;
 
         /**
          * @returns The alpha test function of `pipeline`.
+         * @since 2.0
          */
         get_alpha_test_function(): PipelineAlphaFunc;
 
         /**
          * @returns The alpha test reference value of `pipeline`.
+         * @since 2.0
          */
         get_alpha_test_reference(): number;
 
         /**
          * Retrieves the current pipeline color.
+         * @since 2.0
          */
         get_color(): Color;
 
         /**
          * @returns the cull face mode that was previously set with `cogl_pipeline_set_cull_face_mode()`. Status: Unstable
+         * @since 2.0
          */
         get_cull_face_mode(): PipelineCullFaceMode;
 
@@ -3292,6 +3375,7 @@ export namespace Cogl {
          * {@link Cogl.Winding.CLOCKWISE} sets them to be clockwise. The default is
          * {@link Cogl.Winding.COUNTER_CLOCKWISE}.
          * @returns The `pipeline` front face winding Status: Unstable
+         * @since 2.0
          */
         get_front_face_winding(): Winding;
 
@@ -3304,6 +3388,7 @@ export namespace Cogl {
          * changed using `cogl_pipeline_set_layer_filters()`.
          * @param layer_index the layer number to change.
          * @returns The magnification {@link Cogl.PipelineFilter} for the               specified layer.
+         * @since 1.10
          */
         get_layer_mag_filter(layer_index: number): PipelineFilter;
 
@@ -3316,6 +3401,7 @@ export namespace Cogl {
          * changed using `cogl_pipeline_set_layer_filters()`.
          * @param layer_index the layer number to change.
          * @returns The minification {@link Cogl.PipelineFilter} for the               specified layer.
+         * @since 1.10
          */
         get_layer_min_filter(layer_index: number): PipelineFilter;
 
@@ -3324,12 +3410,14 @@ export namespace Cogl {
          * texture layer.
          * @param layer_index the layer number to check.
          * @returns whether the texture coordinates will be replaced with point sprite coordinates.
+         * @since 2.0
          */
         get_layer_point_sprite_coords_enabled(layer_index: number): boolean;
 
         /**
          * @param layer_index the index of the layer
          * @returns the texture that was set for the   given layer of the pipeline or `null` if no texture was set.
+         * @since 1.10
          */
         get_layer_texture(layer_index: number): Texture;
 
@@ -3338,6 +3426,7 @@ export namespace Cogl {
          * layer.
          * @param layer_index the layer number to change.
          * @returns the wrap mode for the 's' coordinate of texture lookups on this layer.
+         * @since 1.6
          */
         get_layer_wrap_mode_s(layer_index: number): PipelineWrapMode;
 
@@ -3346,17 +3435,20 @@ export namespace Cogl {
          * layer.
          * @param layer_index the layer number to change.
          * @returns the wrap mode for the 't' coordinate of texture lookups on this layer.
+         * @since 1.6
          */
         get_layer_wrap_mode_t(layer_index: number): PipelineWrapMode;
 
         /**
          * Retrieves the number of layers defined for the given `pipeline`
          * @returns the number of layers
+         * @since 2.0
          */
         get_n_layers(): number;
 
         /**
          * @returns `true` if the pipeline has per-vertex point size   enabled or `false` otherwise. The per-vertex point size can be   enabled with `cogl_pipeline_set_per_vertex_point_size()`.
+         * @since 2.0
          */
         get_per_vertex_point_size(): boolean;
 
@@ -3364,6 +3456,7 @@ export namespace Cogl {
          * Get the size of points drawn when {@link Cogl.VerticesMode.POINTS} is
          * used with the vertex buffer API.
          * @returns the point size of the `pipeline`.
+         * @since 2.0
          */
         get_point_size(): number;
 
@@ -3379,6 +3472,7 @@ export namespace Cogl {
          * before calling this function.
          * @param uniform_name The name of a uniform
          * @returns A integer representing the location of the given uniform.
+         * @since 2.0
          */
         get_uniform_location(uniform_name: string): number;
 
@@ -3386,12 +3480,14 @@ export namespace Cogl {
          * Queries what user program has been associated with the given
          * `pipeline` using `cogl_pipeline_set_user_program()`.
          * @returns The current user program or `null`.
+         * @since 2.0
          */
         get_user_program(): Handle;
 
         /**
          * This function removes a layer from your pipeline
          * @param layer_index Specifies the layer you want to remove
+         * @since 1.10
          */
         remove_layer(layer_index: number): void;
 
@@ -3405,6 +3501,7 @@ export namespace Cogl {
          * The default is {@link Cogl.PipelineAlphaFunc.ALWAYS}
          * @param alpha_func A `CoglPipelineAlphaFunc` constant
          * @param alpha_reference A reference point that the chosen alpha function uses   to compare incoming fragments to.
+         * @since 2.0
          */
         set_alpha_test_function(alpha_func: PipelineAlphaFunc, alpha_reference: number): void;
 
@@ -3476,6 +3573,7 @@ export namespace Cogl {
          * is in premultiplied form.
          * @param blend_string A <link linkend="cogl-Blend-Strings">Cogl blend string</link>   describing the desired blend function.
          * @returns `true` if the blend string was successfully parsed, and the   described blending is supported by the underlying driver/hardware. If   there was an error, `false` is returned and `error` is set accordingly (if   present).
+         * @since 2.0
          */
         set_blend(blend_string: string): boolean;
 
@@ -3483,6 +3581,7 @@ export namespace Cogl {
          * When blending is setup to reference a CONSTANT blend factor then
          * blending will depend on the constant set with this function.
          * @param constant_color The constant color you want
+         * @since 2.0
          */
         set_blend_constant(constant_color: Color): void;
 
@@ -3496,6 +3595,7 @@ export namespace Cogl {
          * 
          * The default value is (1.0, 1.0, 1.0, 1.0)
          * @param color The components of the color
+         * @since 2.0
          */
         set_color(color: Color): void;
 
@@ -3507,6 +3607,7 @@ export namespace Cogl {
          * @param green The green component
          * @param blue The blue component
          * @param alpha The alpha component
+         * @since 2.0
          */
         set_color4f(red: number, green: number, blue: number, alpha: number): void;
 
@@ -3518,6 +3619,7 @@ export namespace Cogl {
          * @param green The green component
          * @param blue The blue component
          * @param alpha The alpha component
+         * @since 2.0
          */
         set_color4ub(red: number, green: number, blue: number, alpha: number): void;
 
@@ -3537,6 +3639,7 @@ export namespace Cogl {
          * 
          * Status: Unstable
          * @param cull_face_mode The new mode to set
+         * @since 2.0
          */
         set_cull_face_mode(cull_face_mode: PipelineCullFaceMode): void;
 
@@ -3551,6 +3654,7 @@ export namespace Cogl {
          * 
          * Status: Unstable
          * @param front_winding the winding order
+         * @since 2.0
          */
         set_front_face_winding(front_winding: Winding): void;
 
@@ -3634,6 +3738,7 @@ export namespace Cogl {
          * @param layer_index Specifies the layer you want define a combine function for
          * @param blend_string A <link linkend="cogl-Blend-Strings">Cogl blend string</link>    describing the desired texture combine function.
          * @returns `true` if the blend string was successfully parsed, and the   described texture combining is supported by the underlying driver and   or hardware. On failure, `false` is returned and `error` is set
+         * @since 2.0
          */
         set_layer_combine(layer_index: number, blend_string: string): boolean;
 
@@ -3642,6 +3747,7 @@ export namespace Cogl {
          * description then you can use this function to define its value.
          * @param layer_index Specifies the layer you want to specify a constant used               for texture combining
          * @param constant The constant color you want
+         * @since 2.0
          */
         set_layer_combine_constant(layer_index: number, constant: Color): void;
 
@@ -3656,6 +3762,7 @@ export namespace Cogl {
          * @param layer_index the layer number to change.
          * @param min_filter the filter used when scaling a texture down.
          * @param mag_filter the filter used when magnifying a texture.
+         * @since 1.10
          */
         set_layer_filters(layer_index: number, min_filter: PipelineFilter, mag_filter: PipelineFilter): void;
 
@@ -3664,6 +3771,7 @@ export namespace Cogl {
          * and rotate a single layer of a pipeline used to fill your geometry.
          * @param layer_index the index for the layer inside `pipeline`
          * @param matrix the transformation matrix for the layer
+         * @since 1.10
          */
         set_layer_matrix(layer_index: number, matrix: Graphene.Matrix): void;
 
@@ -3683,6 +3791,7 @@ export namespace Cogl {
          * specify the texture type so that any pipeline copies can share the
          * internal texture type state for efficiency.
          * @param layer_index The layer number to modify
+         * @since 1.10
          */
         set_layer_null_texture(layer_index: number): void;
 
@@ -3696,6 +3805,7 @@ export namespace Cogl {
          * @param layer_index the layer number to change.
          * @param enable whether to enable point sprite coord generation.
          * @returns `true` if the function succeeds, `false` otherwise.
+         * @since 2.0
          */
         set_layer_point_sprite_coords_enabled(layer_index: number, enable: boolean): boolean;
 
@@ -3712,6 +3822,7 @@ export namespace Cogl {
          * `cogl_pipeline_set_layer_wrap_mode_t()` separately.
          * @param layer_index the layer number to change.
          * @param mode the new wrap mode
+         * @since 2.0
          */
         set_layer_wrap_mode(layer_index: number, mode: PipelineWrapMode): void;
 
@@ -3719,6 +3830,7 @@ export namespace Cogl {
          * Sets the wrap mode for the 's' coordinate of texture lookups on this layer.
          * @param layer_index the layer number to change.
          * @param mode the new wrap mode
+         * @since 2.0
          */
         set_layer_wrap_mode_s(layer_index: number, mode: PipelineWrapMode): void;
 
@@ -3726,6 +3838,7 @@ export namespace Cogl {
          * Sets the wrap mode for the 't' coordinate of texture lookups on this layer.
          * @param layer_index the layer number to change.
          * @param mode the new wrap mode
+         * @since 2.0
          */
         set_layer_wrap_mode_t(layer_index: number, mode: PipelineWrapMode): void;
 
@@ -3742,6 +3855,7 @@ export namespace Cogl {
          * undefined.
          * @param enable whether to enable per-vertex point size
          * @returns `true` if the change succeeded or `false` otherwise
+         * @since 2.0
          */
         set_per_vertex_point_size(enable: boolean): boolean;
 
@@ -3759,6 +3873,7 @@ export namespace Cogl {
          * if an application wants to draw points it must make sure to use a
          * pipeline that has an explicit point size set on it.
          * @param point_size the new point size.
+         * @since 2.0
          */
         set_point_size(point_size: number): void;
 
@@ -3775,6 +3890,7 @@ export namespace Cogl {
          * uniform.
          * @param uniform_location The uniform's location identifier
          * @param value The new value for the uniform
+         * @since 2.0
          */
         set_uniform_1f(uniform_location: number, value: number): void;
 
@@ -3791,6 +3907,7 @@ export namespace Cogl {
          * uniform or a sampler uniform.
          * @param uniform_location The uniform's location identifier
          * @param value The new value for the uniform
+         * @since 2.0
          */
         set_uniform_1i(uniform_location: number, value: number): void;
 
@@ -3811,6 +3928,7 @@ export namespace Cogl {
          * @param n_components The number of components in the corresponding uniform's type
          * @param count The number of values to set
          * @param value Pointer to the new values to set
+         * @since 2.0
          */
         set_uniform_float(uniform_location: number, n_components: number, count: number, value: number): void;
 
@@ -3831,6 +3949,7 @@ export namespace Cogl {
          * @param n_components The number of components in the corresponding uniform's type
          * @param count The number of values to set
          * @param value Pointer to the new values to set
+         * @since 2.0
          */
         set_uniform_int(uniform_location: number, n_components: number, count: number, value: number): void;
 
@@ -3857,6 +3976,7 @@ export namespace Cogl {
          * @param count The number of values to set
          * @param transpose Whether to transpose the matrix
          * @param value Pointer to the new values to set
+         * @since 2.0
          */
         set_uniform_matrix(uniform_location: number, dimensions: number, count: number, transpose: boolean, value: number): void;
 
@@ -3897,6 +4017,7 @@ export namespace Cogl {
          * meantime we hope this will handle most practical GLSL and ARBfp
          * requirements.
          * @param program A {@link Cogl.Handle} to a linked CoglProgram
+         * @since 2.0
          */
         set_user_program(program: Handle): void;
     }
@@ -3963,6 +4084,7 @@ export namespace Cogl {
          * is {@link Cogl.TextureComponents.RGBA}. The other constructors which take
          * a %CoglBitmap or a data pointer default to the same components as
          * the pixel format of the data.
+         * @since 1.18
          */
         get_components(): TextureComponents;
 
@@ -4009,6 +4131,7 @@ export namespace Cogl {
          * 
          * By default the pre-multipled state is `TRUE`.
          * @returns `true` if red, green and blue components are               internally stored pre-multiplied by the alpha               value or `false` if not.
+         * @since 1.18
          */
         get_premultiplied(): boolean;
 
@@ -4041,6 +4164,8 @@ export namespace Cogl {
          * @param sub_width Width in pixels of the subregion
          * @param sub_height Height in pixels of the subregion
          * @returns A newly created {@link Cogl.Texture} or               `null` on failure
+         * @since 1.2
+         * @deprecated since 1.18: Use `cogl_sub_texture_new()`
          */
         new_from_sub_texture(sub_x: number, sub_y: number, sub_width: number, sub_height: number): Texture;
 
@@ -4065,6 +4190,7 @@ export namespace Cogl {
          * an image format as long as {@link Cogl.TextureComponents.RG} isn't used
          * as the texture's components.
          * @param components 
+         * @since 1.18
          */
         set_components(components: TextureComponents): void;
 
@@ -4142,6 +4268,7 @@ export namespace Cogl {
          * 
          * By default the `premultipled` state is `TRUE`.
          * @param premultiplied Whether any internally stored red, green or blue                 components are pre-multiplied by an alpha                 component.
+         * @since 1.18
          */
         set_premultiplied(premultiplied: boolean): void;
 
@@ -4179,6 +4306,7 @@ export namespace Cogl {
          * @param dst_height height of destination region to write. (Must be less   than or equal to the bitmap height)
          * @param bitmap The source bitmap to read from
          * @returns `true` if the subregion upload was successful, and   `false` otherwise
+         * @since 1.8
          */
         set_region_from_bitmap(src_x: number, src_y: number, dst_x: number, dst_y: number, dst_width: number, dst_height: number, bitmap: Bitmap): boolean;
     }
@@ -4237,6 +4365,7 @@ export namespace Cogl {
          * is {@link Cogl.TextureComponents.RGBA}. The other constructors which take
          * a %CoglBitmap or a data pointer default to the same components as
          * the pixel format of the data.
+         * @since 1.18
          */
         get_components(): TextureComponents;
 
@@ -4283,6 +4412,7 @@ export namespace Cogl {
          * 
          * By default the pre-multipled state is `TRUE`.
          * @returns `true` if red, green and blue components are               internally stored pre-multiplied by the alpha               value or `false` if not.
+         * @since 1.18
          */
         get_premultiplied(): boolean;
 
@@ -4315,6 +4445,8 @@ export namespace Cogl {
          * @param sub_width Width in pixels of the subregion
          * @param sub_height Height in pixels of the subregion
          * @returns A newly created {@link Cogl.Texture} or               `null` on failure
+         * @since 1.2
+         * @deprecated since 1.18: Use `cogl_sub_texture_new()`
          */
         new_from_sub_texture(sub_x: number, sub_y: number, sub_width: number, sub_height: number): Texture;
 
@@ -4339,6 +4471,7 @@ export namespace Cogl {
          * an image format as long as {@link Cogl.TextureComponents.RG} isn't used
          * as the texture's components.
          * @param components 
+         * @since 1.18
          */
         set_components(components: TextureComponents): void;
 
@@ -4416,6 +4549,7 @@ export namespace Cogl {
          * 
          * By default the `premultipled` state is `TRUE`.
          * @param premultiplied Whether any internally stored red, green or blue                 components are pre-multiplied by an alpha                 component.
+         * @since 1.18
          */
         set_premultiplied(premultiplied: boolean): void;
 
@@ -4453,6 +4587,7 @@ export namespace Cogl {
          * @param dst_height height of destination region to write. (Must be less   than or equal to the bitmap height)
          * @param bitmap The source bitmap to read from
          * @returns `true` if the subregion upload was successful, and   `false` otherwise
+         * @since 1.8
          */
         set_region_from_bitmap(src_x: number, src_y: number, dst_x: number, dst_y: number, dst_width: number, dst_height: number, bitmap: Bitmap): boolean;
     }
@@ -4481,6 +4616,7 @@ export namespace Cogl {
          * parameter, when using {@link Cogl.Color}<!-- -->s as keys in a {@link GLib.HashTable}.
          * @param v1 a {@link Cogl.Color}
          * @param v2 a {@link Cogl.Color}
+         * @since 1.0
          */
         static equal(v1: null, v2: null): boolean;
 
@@ -4490,6 +4626,7 @@ export namespace Cogl {
          * @param hue hue value, in the 0 .. 360 range
          * @param saturation saturation value, in the 0 .. 1 range
          * @param luminance luminance value, in the 0 .. 1 range
+         * @since 1.16
          */
         static init_from_hsl(hue: number, saturation: number, luminance: number): Color;
 
@@ -4497,11 +4634,13 @@ export namespace Cogl {
         /**
          * Creates a copy of `color`
          * @returns a newly-allocated {@link Cogl.Color}. Use `cogl_color_free()`   to free the allocate resources
+         * @since 1.0
          */
         copy(): Color;
 
         /**
          * Frees the resources allocated by `cogl_color_new()` and `cogl_color_copy()`
+         * @since 1.0
          */
         free(): void;
 
@@ -4509,6 +4648,7 @@ export namespace Cogl {
          * Retrieves the alpha channel of `color` as a fixed point
          * value between 0 and 1.0.
          * @returns the alpha channel of the passed color
+         * @since 1.0
          */
         get_alpha(): number;
 
@@ -4516,6 +4656,7 @@ export namespace Cogl {
          * Retrieves the alpha channel of `color` as a byte value
          * between 0 and 255
          * @returns the alpha channel of the passed color
+         * @since 1.0
          */
         get_alpha_byte(): number;
 
@@ -4523,6 +4664,7 @@ export namespace Cogl {
          * Retrieves the alpha channel of `color` as a floating point
          * value between 0.0 and 1.0
          * @returns the alpha channel of the passed color
+         * @since 1.0
          */
         get_alpha_float(): number;
 
@@ -4530,6 +4672,7 @@ export namespace Cogl {
          * Retrieves the blue channel of `color` as a fixed point
          * value between 0 and 1.0.
          * @returns the blue channel of the passed color
+         * @since 1.0
          */
         get_blue(): number;
 
@@ -4537,6 +4680,7 @@ export namespace Cogl {
          * Retrieves the blue channel of `color` as a byte value
          * between 0 and 255
          * @returns the blue channel of the passed color
+         * @since 1.0
          */
         get_blue_byte(): number;
 
@@ -4544,6 +4688,7 @@ export namespace Cogl {
          * Retrieves the blue channel of `color` as a floating point
          * value between 0.0 and 1.0
          * @returns the blue channel of the passed color
+         * @since 1.0
          */
         get_blue_float(): number;
 
@@ -4551,6 +4696,7 @@ export namespace Cogl {
          * Retrieves the green channel of `color` as a fixed point
          * value between 0 and 1.0.
          * @returns the green channel of the passed color
+         * @since 1.0
          */
         get_green(): number;
 
@@ -4558,6 +4704,7 @@ export namespace Cogl {
          * Retrieves the green channel of `color` as a byte value
          * between 0 and 255
          * @returns the green channel of the passed color
+         * @since 1.0
          */
         get_green_byte(): number;
 
@@ -4565,6 +4712,7 @@ export namespace Cogl {
          * Retrieves the green channel of `color` as a floating point
          * value between 0.0 and 1.0
          * @returns the green channel of the passed color
+         * @since 1.0
          */
         get_green_float(): number;
 
@@ -4572,6 +4720,7 @@ export namespace Cogl {
          * Retrieves the red channel of `color` as a fixed point
          * value between 0 and 1.0.
          * @returns the red channel of the passed color
+         * @since 1.0
          */
         get_red(): number;
 
@@ -4579,6 +4728,7 @@ export namespace Cogl {
          * Retrieves the red channel of `color` as a byte value
          * between 0 and 255
          * @returns the red channel of the passed color
+         * @since 1.0
          */
         get_red_byte(): number;
 
@@ -4586,6 +4736,7 @@ export namespace Cogl {
          * Retrieves the red channel of `color` as a floating point
          * value between 0.0 and 1.0
          * @returns the red channel of the passed color
+         * @since 1.0
          */
         get_red_float(): number;
 
@@ -4595,12 +4746,14 @@ export namespace Cogl {
          * @param green value of the green channel, between 0 and 1.0
          * @param blue value of the blue channel, between 0 and 1.0
          * @param alpha value of the alpha channel, between 0 and 1.0
+         * @since 1.4
          */
         init_from_4f(red: number, green: number, blue: number, alpha: number): void;
 
         /**
          * Sets the values of the passed channels into a {@link Cogl.Color}
          * @param color_array a pointer to an array of 4 float color components
+         * @since 1.4
          */
         init_from_4fv(color_array: number): void;
 
@@ -4610,6 +4763,7 @@ export namespace Cogl {
          * @param green value of the green channel, between 0 and 255
          * @param blue value of the blue channel, between 0 and 255
          * @param alpha value of the alpha channel, between 0 and 255
+         * @since 1.4
          */
         init_from_4ub(red: number, green: number, blue: number, alpha: number): void;
 
@@ -4617,78 +4771,91 @@ export namespace Cogl {
          * Converts a non-premultiplied color to a pre-multiplied color. For
          * example, semi-transparent red is (1.0, 0, 0, 0.5) when non-premultiplied
          * and (0.5, 0, 0, 0.5) when premultiplied.
+         * @since 1.0
          */
         premultiply(): void;
 
         /**
          * Sets the alpha channel of `color` to `alpha`.
          * @param alpha a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_alpha(alpha: number): void;
 
         /**
          * Sets the alpha channel of `color` to `alpha`.
          * @param alpha a byte value between 0 and 255
+         * @since 1.4
          */
         set_alpha_byte(alpha: number): void;
 
         /**
          * Sets the alpha channel of `color` to `alpha`.
          * @param alpha a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_alpha_float(alpha: number): void;
 
         /**
          * Sets the blue channel of `color` to `blue`.
          * @param blue a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_blue(blue: number): void;
 
         /**
          * Sets the blue channel of `color` to `blue`.
          * @param blue a byte value between 0 and 255
+         * @since 1.4
          */
         set_blue_byte(blue: number): void;
 
         /**
          * Sets the blue channel of `color` to `blue`.
          * @param blue a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_blue_float(blue: number): void;
 
         /**
          * Sets the green channel of `color` to `green`.
          * @param green a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_green(green: number): void;
 
         /**
          * Sets the green channel of `color` to `green`.
          * @param green a byte value between 0 and 255
+         * @since 1.4
          */
         set_green_byte(green: number): void;
 
         /**
          * Sets the green channel of `color` to `green`.
          * @param green a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_green_float(green: number): void;
 
         /**
          * Sets the red channel of `color` to `red`.
          * @param red a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_red(red: number): void;
 
         /**
          * Sets the red channel of `color` to `red`.
          * @param red a byte value between 0 and 255
+         * @since 1.4
          */
         set_red_byte(red: number): void;
 
         /**
          * Sets the red channel of `color` to `red`.
          * @param red a float value between 0.0f and 1.0f
+         * @since 1.4
          */
         set_red_float(red: number): void;
 
@@ -4697,6 +4864,7 @@ export namespace Cogl {
          * 
          * The `hue` value is in the 0 .. 360 range. The `luminance` and
          * `saturation` values are in the 0 .. 1 range.
+         * @since 1.16
          */
         to_hsl(): [number, number, number];
 
@@ -4704,6 +4872,7 @@ export namespace Cogl {
          * Converts a pre-multiplied color to a non-premultiplied color. For
          * example, semi-transparent red is (0.5, 0, 0, 0.5) when premultiplied
          * and (1.0, 0, 0, 0.5) when non-premultiplied.
+         * @since 1.4
          */
         unpremultiply(): void;
     }
@@ -4773,6 +4942,8 @@ export namespace Cogl {
          * The default is {@link Cogl.MaterialAlphaFunc.ALWAYS}
          * @param alpha_func A `CoglMaterialAlphaFunc` constant
          * @param alpha_reference A reference point that the chosen alpha function uses   to compare incoming fragments to.
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_alpha_test_function()` instead
          */
         set_alpha_test_function(alpha_func: MaterialAlphaFunc, alpha_reference: number): void;
 
@@ -4847,6 +5018,8 @@ export namespace Cogl {
          * is in premultiplied form.
          * @param blend_string A <link linkend="cogl-Blend-Strings">Cogl blend string</link>   describing the desired blend function.
          * @returns `true` if the blend string was successfully parsed, and the   described blending is supported by the underlying driver/hardware. If   there was an error, `false` is returned and `error` is set accordingly (if   present).
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_blend()` instead
          */
         set_blend(blend_string: string): boolean;
 
@@ -4854,6 +5027,8 @@ export namespace Cogl {
          * When blending is setup to reference a CONSTANT blend factor then
          * blending will depend on the constant set with this function.
          * @param constant_color The constant color you want
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_blend_constant()` instead
          */
         set_blend_constant(constant_color: Color): void;
 
@@ -4867,6 +5042,8 @@ export namespace Cogl {
          * 
          * The default value is (1.0, 1.0, 1.0, 1.0)
          * @param color The components of the color
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_color()` instead
          */
         set_color(color: Color): void;
 
@@ -4878,6 +5055,8 @@ export namespace Cogl {
          * @param green The green component
          * @param blue The blue component
          * @param alpha The alpha component
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_color4ub()` instead
          */
         set_color4ub(red: number, green: number, blue: number, alpha: number): void;
 
@@ -4894,6 +5073,8 @@ export namespace Cogl {
          * as purely GLSL based layers.</note>
          * @param layer_index the index of the layer
          * @param texture a {@link Cogl.Handle} for the layer object
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer()` instead
          */
         set_layer(layer_index: number, texture: Handle): void;
 
@@ -4976,6 +5157,8 @@ export namespace Cogl {
          * @param layer_index Specifies the layer you want define a combine function for
          * @param blend_string A <link linkend="cogl-Blend-Strings">Cogl blend string</link>    describing the desired texture combine function.
          * @returns `true` if the blend string was successfully parsed, and the   described texture combining is supported by the underlying driver and   or hardware. On failure, `false` is returned and `error` is set
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer_combine()` instead
          */
         set_layer_combine(layer_index: number, blend_string: string): boolean;
 
@@ -4984,6 +5167,8 @@ export namespace Cogl {
          * description then you can use this function to define its value.
          * @param layer_index Specifies the layer you want to specify a constant used               for texture combining
          * @param constant The constant color you want
+         * @since 1.0
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer_combine_constant()` instead
          */
         set_layer_combine_constant(layer_index: number, constant: Color): void;
 
@@ -4993,6 +5178,7 @@ export namespace Cogl {
          * @param layer_index the layer number to change.
          * @param min_filter the filter used when scaling a texture down.
          * @param mag_filter the filter used when magnifying a texture.
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer_filters()` instead
          */
         set_layer_filters(layer_index: number, min_filter: MaterialFilter, mag_filter: MaterialFilter): void;
 
@@ -5001,6 +5187,7 @@ export namespace Cogl {
          * and rotate a single layer of a material used to fill your geometry.
          * @param layer_index the index for the layer inside `material`
          * @param matrix the transformation matrix for the layer
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer_matrix()` instead
          */
         set_layer_matrix(layer_index: number, matrix: Graphene.Matrix): void;
 
@@ -5014,6 +5201,8 @@ export namespace Cogl {
          * @param layer_index the layer number to change.
          * @param enable whether to enable point sprite coord generation.
          * @returns `true` if the function succeeds, `false` otherwise.
+         * @since 1.4
+         * @deprecated since 1.16: Use `cogl_pipeline_set_layer_point_sprite_coords_enabled()`                  instead
          */
         set_layer_point_sprite_coords_enabled(layer_index: number, enable: boolean): boolean;
 
@@ -5026,6 +5215,8 @@ export namespace Cogl {
          * screen space so it will be the same regardless of any
          * transformations. The default point size is 1.0.
          * @param point_size the new point size.
+         * @since 1.4
+         * @deprecated since 1.16: Use `cogl_pipeline_set_point_size()` instead
          */
         set_point_size(point_size: number): void;
 
@@ -5066,6 +5257,8 @@ export namespace Cogl {
          * meantime we hope this will handle most practical GLSL and ARBfp
          * requirements.
          * @param program A {@link Cogl.Handle} to a linked CoglProgram
+         * @since 1.4
+         * @deprecated since 1.16: Use `CoglSnippet` api instead instead
          */
         set_user_program(program: Handle): void;
     }
@@ -5328,6 +5521,7 @@ export namespace Cogl {
          * is {@link Cogl.TextureComponents.RGBA}. The other constructors which take
          * a %CoglBitmap or a data pointer default to the same components as
          * the pixel format of the data.
+         * @since 1.18
          */
         get_components(): TextureComponents;
 
@@ -5374,6 +5568,7 @@ export namespace Cogl {
          * 
          * By default the pre-multipled state is `TRUE`.
          * @returns `true` if red, green and blue components are               internally stored pre-multiplied by the alpha               value or `false` if not.
+         * @since 1.18
          */
         get_premultiplied(): boolean;
 
@@ -5406,6 +5601,8 @@ export namespace Cogl {
          * @param sub_width Width in pixels of the subregion
          * @param sub_height Height in pixels of the subregion
          * @returns A newly created {@link Cogl.Texture} or               `null` on failure
+         * @since 1.2
+         * @deprecated since 1.18: Use `cogl_sub_texture_new()`
          */
         new_from_sub_texture(sub_x: number, sub_y: number, sub_width: number, sub_height: number): Texture;
 
@@ -5430,6 +5627,7 @@ export namespace Cogl {
          * an image format as long as {@link Cogl.TextureComponents.RG} isn't used
          * as the texture's components.
          * @param components 
+         * @since 1.18
          */
         set_components(components: TextureComponents): void;
 
@@ -5507,6 +5705,7 @@ export namespace Cogl {
          * 
          * By default the `premultipled` state is `TRUE`.
          * @param premultiplied Whether any internally stored red, green or blue                 components are pre-multiplied by an alpha                 component.
+         * @since 1.18
          */
         set_premultiplied(premultiplied: boolean): void;
 
@@ -5544,6 +5743,7 @@ export namespace Cogl {
          * @param dst_height height of destination region to write. (Must be less   than or equal to the bitmap height)
          * @param bitmap The source bitmap to read from
          * @returns `true` if the subregion upload was successful, and   `false` otherwise
+         * @since 1.8
          */
         set_region_from_bitmap(src_x: number, src_y: number, dst_x: number, dst_y: number, dst_width: number, dst_height: number, bitmap: Bitmap): boolean;
     }