@girs/cogl-9 4.3.0 → 4.5.0

package/cogl-9.d.ts

@@ -33,25 +33,25 @@ export namespace Cogl {
         /**
          * Data is the same size of a byte
          */
-        BYTE,
+        BYTE = 5120,
         /**
          * Data is the same size of an
          *   unsigned byte
          */
-        UNSIGNED_BYTE,
+        UNSIGNED_BYTE = 5121,
         /**
          * Data is the same size of a short integer
          */
-        SHORT,
+        SHORT = 5122,
         /**
          * Data is the same size of
          *   an unsigned short integer
          */
-        UNSIGNED_SHORT,
+        UNSIGNED_SHORT = 5123,
         /**
          * Data is the same size of a float
          */
-        FLOAT,
+        FLOAT = 5126,
     }
 
 
@@ -69,15 +69,15 @@ export namespace Cogl {
          * Generic failure code, something went
          *   wrong.
          */
-        FAILED,
+        FAILED = 0,
         /**
          * Unknown image type.
          */
-        UNKNOWN_TYPE,
+        UNKNOWN_TYPE = 1,
         /**
          * An image file was broken somehow.
          */
-        CORRUPT_IMAGE,
+        CORRUPT_IMAGE = 2,
     }
 
 
@@ -90,20 +90,20 @@ export namespace Cogl {
         /**
          * Generic parse error
          */
-        PARSE_ERROR,
+        PARSE_ERROR = 0,
         /**
          * Argument parse error
          */
-        ARGUMENT_PARSE_ERROR,
+        ARGUMENT_PARSE_ERROR = 1,
         /**
          * Internal parser error
          */
-        INVALID_ERROR,
+        INVALID_ERROR = 2,
         /**
          * Blend string not
          *   supported by the GPU
          */
-        GPU_UNSUPPORTED_ERROR,
+        GPU_UNSUPPORTED_ERROR = 3,
     }
 
 
@@ -121,41 +121,41 @@ export namespace Cogl {
         /**
          * Never passes.
          */
-        NEVER,
+        NEVER = 512,
         /**
          * Passes if the fragment's depth
          * value is less than the value currently in the depth buffer.
          */
-        LESS,
+        LESS = 513,
         /**
          * Passes if the fragment's depth
          * value is equal to the value currently in the depth buffer.
          */
-        EQUAL,
+        EQUAL = 514,
         /**
          * Passes if the fragment's depth
          * value is less or equal to the value currently in the depth buffer.
          */
-        LEQUAL,
+        LEQUAL = 515,
         /**
          * Passes if the fragment's depth
          * value is greater than the value currently in the depth buffer.
          */
-        GREATER,
+        GREATER = 516,
         /**
          * Passes if the fragment's depth
          * value is not equal to the value currently in the depth buffer.
          */
-        NOTEQUAL,
+        NOTEQUAL = 517,
         /**
          * Passes if the fragment's depth
          * value greater than or equal to the value currently in the depth buffer.
          */
-        GEQUAL,
+        GEQUAL = 518,
         /**
          * Always passes.
          */
-        ALWAYS,
+        ALWAYS = 519,
     }
 
 
@@ -172,38 +172,38 @@ export namespace Cogl {
          *     {@link Cogl.IndicesType.INT} is supported in
          *     `cogl_indices_new()`.
          */
-        OGL_FEATURE_ID_UNSIGNED_INT_INDICES,
+        OGL_FEATURE_ID_UNSIGNED_INT_INDICES = 0,
         /**
          * Whether `cogl_buffer_map()` is
          *     supported with CoglBufferAccess including read support.
          */
-        OGL_FEATURE_ID_MAP_BUFFER_FOR_READ,
+        OGL_FEATURE_ID_MAP_BUFFER_FOR_READ = 1,
         /**
          * Whether `cogl_buffer_map()` is
          *     supported with CoglBufferAccess including write support.
          */
-        OGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE,
-        OGL_FEATURE_ID_FENCE,
+        OGL_FEATURE_ID_MAP_BUFFER_FOR_WRITE = 2,
+        OGL_FEATURE_ID_FENCE = 3,
         /**
          * Support for
          *    {@link Cogl.TextureComponents.RG} as the internal components of a
          *    texture.
          */
-        OGL_FEATURE_ID_TEXTURE_RG,
+        OGL_FEATURE_ID_TEXTURE_RG = 4,
         /**
          * Available if the age of {@link Cogl.Onscreen} back
          *    buffers are tracked and so `cogl_onscreen_get_buffer_age()` can be
          *    expected to return age values other than 0.
          */
-        OGL_FEATURE_ID_BUFFER_AGE,
-        OGL_FEATURE_ID_TEXTURE_EGL_IMAGE_EXTERNAL,
+        OGL_FEATURE_ID_BUFFER_AGE = 5,
+        OGL_FEATURE_ID_TEXTURE_EGL_IMAGE_EXTERNAL = 6,
         /**
          * Whether blitting using
          *    `cogl_blit_framebuffer()` is supported.
          */
-        OGL_FEATURE_ID_BLIT_FRAMEBUFFER,
-        OGL_FEATURE_ID_TIMESTAMP_QUERY,
-        OGL_FEATURE_ID_GET_GPU_TIME,
+        OGL_FEATURE_ID_BLIT_FRAMEBUFFER = 7,
+        OGL_FEATURE_ID_TIMESTAMP_QUERY = 8,
+        OGL_FEATURE_ID_GET_GPU_TIME = 9,
     }
 
 
@@ -216,11 +216,11 @@ export namespace Cogl {
          * The event was not handled, continues the
          *                        processing
          */
-        CONTINUE,
+        CONTINUE = 0,
         /**
          * Remove the event, stops the processing
          */
-        REMOVE,
+        REMOVE = 1,
     }
 
 
@@ -248,7 +248,7 @@ export namespace Cogl {
          *                         acknowledged a frame and is ready for a
          *                         new frame to be created.
          */
-        SYNC,
+        SYNC = 1,
         /**
          * Notifies that a frame has ended. This
          *                             is a good time for applications to
@@ -258,7 +258,7 @@ export namespace Cogl {
          *                             events should be expected after a
          *                             `COGL_FRAME_EVENT_COMPLETE` event.
          */
-        COMPLETE,
+        COMPLETE = 2,
     }
 
 
@@ -266,7 +266,7 @@ export namespace Cogl {
      * @gir-type Enum
      */
     enum FramebufferError {
-        FRAMEBUFFER_ERROR_ALLOCATE,
+        FRAMEBUFFER_ERROR_ALLOCATE = 0,
     }
 
 
@@ -278,11 +278,11 @@ export namespace Cogl {
      * @gir-type Enum
      */
     enum GraphicsResetStatus {
-        NO_ERROR,
-        GUILTY_CONTEXT_RESET,
-        INNOCENT_CONTEXT_RESET,
-        UNKNOWN_CONTEXT_RESET,
-        PURGED_CONTEXT_RESET,
+        NO_ERROR = 0,
+        GUILTY_CONTEXT_RESET = 1,
+        INNOCENT_CONTEXT_RESET = 2,
+        UNKNOWN_CONTEXT_RESET = 3,
+        PURGED_CONTEXT_RESET = 4,
     }
 
 
@@ -302,15 +302,15 @@ export namespace Cogl {
         /**
          * Your indices are unsigned bytes
          */
-        BYTE,
+        BYTE = 0,
         /**
          * Your indices are unsigned shorts
          */
-        SHORT,
+        SHORT = 1,
         /**
          * Your indices are unsigned ints
          */
-        INT,
+        INT = 2,
     }
 
 
@@ -325,41 +325,41 @@ export namespace Cogl {
         /**
          * Never let the fragment through.
          */
-        NEVER,
+        NEVER = 512,
         /**
          * Let the fragment through if the incoming
          *   alpha value is less than the reference alpha value
          */
-        LESS,
+        LESS = 513,
         /**
          * Let the fragment through if the incoming
          *   alpha value equals the reference alpha value
          */
-        EQUAL,
+        EQUAL = 514,
         /**
          * Let the fragment through if the incoming
          *   alpha value is less than or equal to the reference alpha value
          */
-        LEQUAL,
+        LEQUAL = 515,
         /**
          * Let the fragment through if the incoming
          *   alpha value is greater than the reference alpha value
          */
-        GREATER,
+        GREATER = 516,
         /**
          * Let the fragment through if the incoming
          *   alpha value does not equal the reference alpha value
          */
-        NOTEQUAL,
+        NOTEQUAL = 517,
         /**
          * Let the fragment through if the incoming
          *   alpha value is greater than or equal to the reference alpha value.
          */
-        GEQUAL,
+        GEQUAL = 518,
         /**
          * Always let the fragment through.
          */
-        ALWAYS,
+        ALWAYS = 519,
     }
 
 
@@ -376,38 +376,38 @@ export namespace Cogl {
          * Measuring in manhatten distance from the,
          *   current pixel center, use the nearest texture texel
          */
-        NEAREST,
+        NEAREST = 9728,
         /**
          * Use the weighted average of the 4 texels
          *   nearest the current pixel center
          */
-        LINEAR,
+        LINEAR = 9729,
         /**
          * Select the mimap level whose
          *   texel size most closely matches the current pixel, and use the
          *   {@link Cogl.MaterialFilter.NEAREST} criterion
          */
-        NEAREST_MIPMAP_NEAREST,
+        NEAREST_MIPMAP_NEAREST = 9984,
         /**
          * Select the mimap level whose
          *   texel size most closely matches the current pixel, and use the
          *   {@link Cogl.MaterialFilter.LINEAR} criterion
          */
-        LINEAR_MIPMAP_NEAREST,
+        LINEAR_MIPMAP_NEAREST = 9985,
         /**
          * Select the two mimap levels
          *   whose texel size most closely matches the current pixel, use
          *   the {@link Cogl.MaterialFilter.NEAREST} criterion on each one and take
          *   their weighted average
          */
-        NEAREST_MIPMAP_LINEAR,
+        NEAREST_MIPMAP_LINEAR = 9986,
         /**
          * Select the two mimap levels
          *   whose texel size most closely matches the current pixel, use
          *   the {@link Cogl.MaterialFilter.LINEAR} criterion on each one and take
          *   their weighted average
          */
-        LINEAR_MIPMAP_LINEAR,
+        LINEAR_MIPMAP_LINEAR = 9987,
     }
 
 
@@ -428,14 +428,14 @@ export namespace Cogl {
          * The texture will be repeated. This
          *   is useful for example to draw a tiled background.
          */
-        REPEAT,
+        REPEAT = 10497,
         /**
          * The coordinates outside the
          *   range 0→1 will sample copies of the edge pixels of the
          *   texture. This is useful to avoid artifacts if only one copy of
          *   the texture is being rendered.
          */
-        CLAMP_TO_EDGE,
+        CLAMP_TO_EDGE = 33071,
         /**
          * Cogl will try to automatically
          *   decide which of the above two to use. For `cogl_rectangle()`, it
@@ -446,7 +446,7 @@ export namespace Cogl {
          *   layers that have point sprite coordinate generation enabled. This
          *   is the default value.
          */
-        AUTOMATIC,
+        AUTOMATIC = 519,
     }
 
 
@@ -461,41 +461,41 @@ export namespace Cogl {
         /**
          * Never let the fragment through.
          */
-        NEVER,
+        NEVER = 512,
         /**
          * Let the fragment through if the incoming
          *   alpha value is less than the reference alpha value
          */
-        LESS,
+        LESS = 513,
         /**
          * Let the fragment through if the incoming
          *   alpha value equals the reference alpha value
          */
-        EQUAL,
+        EQUAL = 514,
         /**
          * Let the fragment through if the incoming
          *   alpha value is less than or equal to the reference alpha value
          */
-        LEQUAL,
+        LEQUAL = 515,
         /**
          * Let the fragment through if the incoming
          *   alpha value is greater than the reference alpha value
          */
-        GREATER,
+        GREATER = 516,
         /**
          * Let the fragment through if the incoming
          *   alpha value does not equal the reference alpha value
          */
-        NOTEQUAL,
+        NOTEQUAL = 517,
         /**
          * Let the fragment through if the incoming
          *   alpha value is greater than or equal to the reference alpha value.
          */
-        GEQUAL,
+        GEQUAL = 518,
         /**
          * Always let the fragment through.
          */
-        ALWAYS,
+        ALWAYS = 519,
     }
 
 
@@ -509,19 +509,19 @@ export namespace Cogl {
          * Neither face will be
          *  culled. This is the default.
          */
-        NONE,
+        NONE = 0,
         /**
          * Front faces will be culled.
          */
-        FRONT,
+        FRONT = 1,
         /**
          * Back faces will be culled.
          */
-        BACK,
+        BACK = 2,
         /**
          * All faces will be culled.
          */
-        BOTH,
+        BOTH = 3,
     }
 
 
@@ -538,38 +538,38 @@ export namespace Cogl {
          * Measuring in manhatten distance from the,
          *   current pixel center, use the nearest texture texel
          */
-        NEAREST,
+        NEAREST = 9728,
         /**
          * Use the weighted average of the 4 texels
          *   nearest the current pixel center
          */
-        LINEAR,
+        LINEAR = 9729,
         /**
          * Select the mimap level whose
          *   texel size most closely matches the current pixel, and use the
          *   {@link Cogl.PipelineFilter.NEAREST} criterion
          */
-        NEAREST_MIPMAP_NEAREST,
+        NEAREST_MIPMAP_NEAREST = 9984,
         /**
          * Select the mimap level whose
          *   texel size most closely matches the current pixel, and use the
          *   {@link Cogl.PipelineFilter.LINEAR} criterion
          */
-        LINEAR_MIPMAP_NEAREST,
+        LINEAR_MIPMAP_NEAREST = 9985,
         /**
          * Select the two mimap levels
          *   whose texel size most closely matches the current pixel, use
          *   the {@link Cogl.PipelineFilter.NEAREST} criterion on each one and take
          *   their weighted average
          */
-        NEAREST_MIPMAP_LINEAR,
+        NEAREST_MIPMAP_LINEAR = 9986,
         /**
          * Select the two mimap levels
          *   whose texel size most closely matches the current pixel, use
          *   the {@link Cogl.PipelineFilter.LINEAR} criterion on each one and take
          *   their weighted average
          */
-        LINEAR_MIPMAP_LINEAR,
+        LINEAR_MIPMAP_LINEAR = 9987,
     }
 
 
@@ -590,15 +590,15 @@ export namespace Cogl {
          * The texture will be repeated. This
          *   is useful for example to draw a tiled background.
          */
-        REPEAT,
-        MIRRORED_REPEAT,
+        REPEAT = 10497,
+        MIRRORED_REPEAT = 33648,
         /**
          * The coordinates outside the
          *   range 0→1 will sample copies of the edge pixels of the
          *   texture. This is useful to avoid artifacts if only one copy of
          *   the texture is being rendered.
          */
-        CLAMP_TO_EDGE,
+        CLAMP_TO_EDGE = 33071,
         /**
          * Cogl will try to automatically
          *   decide which of the above two to use. For `cogl_rectangle()`, it
@@ -609,7 +609,7 @@ export namespace Cogl {
          *   layers that have point sprite coordinate generation enabled. This
          *   is the default value.
          */
-        AUTOMATIC,
+        AUTOMATIC = 519,
     }
 
 
@@ -617,8 +617,8 @@ export namespace Cogl {
      * @gir-type Enum
      */
     enum RendererError {
-        XLIB_DISPLAY_OPEN,
-        BAD_CONSTRAINT,
+        XLIB_DISPLAY_OPEN = 0,
+        BAD_CONSTRAINT = 1,
     }
 
 
@@ -645,11 +645,11 @@ export namespace Cogl {
         /**
          * A program for processing vertices
          */
-        VERTEX,
+        VERTEX = 0,
         /**
          * A program for processing fragments
          */
-        FRAGMENT,
+        FRAGMENT = 1,
     }
 
 
@@ -662,15 +662,15 @@ export namespace Cogl {
         /**
          * draw to both stereo buffers
          */
-        BOTH,
+        BOTH = 0,
         /**
          * draw only to the left stereo buffer
          */
-        LEFT,
+        LEFT = 1,
         /**
          * draw only to the left stereo buffer
          */
-        RIGHT,
+        RIGHT = 2,
     }
 
 
@@ -700,12 +700,12 @@ export namespace Cogl {
          * You tried to use a feature or
          *    configuration not currently available.
          */
-        UNSUPPORTED,
+        UNSUPPORTED = 0,
         /**
          * You tried to allocate a resource
          *    such as a texture and there wasn't enough memory.
          */
-        NO_MEMORY,
+        NO_MEMORY = 1,
     }
 
 
@@ -718,25 +718,25 @@ export namespace Cogl {
         /**
          * Only the alpha component
          */
-        A,
+        A = 1,
         /**
          * Red and green components. Note that
          *   this can only be used if the {@link Cogl.FeatureID.OGL_FEATURE_ID_TEXTURE_RG} feature
          *   is advertised.
          */
-        RG,
+        RG = 2,
         /**
          * Red, green and blue components
          */
-        RGB,
+        RGB = 3,
         /**
          * Red, green, blue and alpha components
          */
-        RGBA,
+        RGBA = 4,
         /**
          * Only a depth component
          */
-        DEPTH,
+        DEPTH = 5,
     }
 
 
@@ -749,17 +749,17 @@ export namespace Cogl {
         /**
          * Unsupported size
          */
-        SIZE,
+        SIZE = 0,
         /**
          * Unsupported format
          */
-        FORMAT,
-        BAD_PARAMETER,
+        FORMAT = 1,
+        BAD_PARAMETER = 2,
         /**
          * A primitive texture type that is
          *   unsupported by the driver was used
          */
-        TYPE,
+        TYPE = 3,
     }
 
 
@@ -773,35 +773,35 @@ export namespace Cogl {
          * FIXME, equivalent to
          * <constant>GL_POINTS</constant>
          */
-        POINTS,
+        POINTS = 0,
         /**
          * FIXME, equivalent to <constant>GL_LINES</constant>
          */
-        LINES,
+        LINES = 1,
         /**
          * FIXME, equivalent to
          * <constant>GL_LINE_LOOP</constant>
          */
-        LINE_LOOP,
+        LINE_LOOP = 2,
         /**
          * FIXME, equivalent to
          * <constant>GL_LINE_STRIP</constant>
          */
-        LINE_STRIP,
+        LINE_STRIP = 3,
         /**
          * FIXME, equivalent to
          * <constant>GL_TRIANGLES</constant>
          */
-        TRIANGLES,
+        TRIANGLES = 4,
         /**
          * FIXME, equivalent to
          * <constant>GL_TRIANGLE_STRIP</constant>
          */
-        TRIANGLE_STRIP,
+        TRIANGLE_STRIP = 5,
         /**
          * FIXME, equivalent to <constant>GL_TRIANGLE_FAN</constant>
          */
-        TRIANGLE_FAN,
+        TRIANGLE_FAN = 6,
     }
 
 
@@ -815,11 +815,11 @@ export namespace Cogl {
         /**
          * Vertices are in a clockwise order
          */
-        CLOCKWISE,
+        CLOCKWISE = 0,
         /**
          * Vertices are in a counter-clockwise order
          */
-        COUNTER_CLOCKWISE,
+        COUNTER_CLOCKWISE = 1,
     }
 
 
@@ -827,38 +827,60 @@ export namespace Cogl {
      * @gir-type Enum
      */
     enum WinsysFeature {
-        MULTIPLE_ONSCREEN,
-        VBLANK_COUNTER,
-        VBLANK_WAIT,
-        TEXTURE_FROM_PIXMAP,
-        SWAP_BUFFERS_EVENT,
-        SWAP_REGION,
-        SWAP_REGION_THROTTLE,
-        SWAP_REGION_SYNCHRONIZED,
-        BUFFER_AGE,
-        SYNC_AND_COMPLETE_EVENT,
-        N_FEATURES,
+        MULTIPLE_ONSCREEN = 0,
+        VBLANK_COUNTER = 1,
+        VBLANK_WAIT = 2,
+        TEXTURE_FROM_PIXMAP = 3,
+        SWAP_BUFFERS_EVENT = 4,
+        SWAP_REGION = 5,
+        SWAP_REGION_THROTTLE = 6,
+        SWAP_REGION_SYNCHRONIZED = 7,
+        BUFFER_AGE = 8,
+        SYNC_AND_COMPLETE_EVENT = 9,
+        N_FEATURES = 10,
     }
 
 
+    /**
+     * @default 64
+     */
     const AFIRST_BIT: number;
 
+    /**
+     * @default 16
+     */
     const A_BIT: number;
 
+    /**
+     * @default 32
+     */
     const BGR_BIT: number;
 
+    /**
+     * @default 256
+     */
     const DEPTH_BIT: number;
 
     /**
      * The maximum number of planes of a pixel format (see also
      * `cogl_pixel_format_get_planes()`).
+     * @default 4
      */
     const PIXEL_FORMAT_MAX_PLANES: number;
 
+    /**
+     * @default 128
+     */
     const PREMULT_BIT: number;
 
+    /**
+     * @default 512
+     */
     const STENCIL_BIT: number;
 
+    /**
+     * @default 127
+     */
     const TEXTURE_MAX_WASTE: number;
 
     function blend_string_error_quark(): number;
@@ -911,6 +933,7 @@ export namespace Cogl {
      * @param dst_y Destination y position
      * @param width Width of region to copy
      * @param height Height of region to copy
+     * @throws GLib.Error
      */
     function blit_framebuffer(framebuffer: Framebuffer, dst: Framebuffer, src_x: number, src_y: number, dst_x: number, dst_y: number, width: number, height: number): boolean;
 
@@ -1359,6 +1382,7 @@ export namespace Cogl {
      * @returns A newly created {@link Cogl.Texture} or               `null` on failure
      * @since 0.8
      * @deprecated since 1.18: Use specific constructors such as                   `cogl_texture_2d_new_from_file()`
+     * @throws GLib.Error
      */
     function texture_new_from_file(filename: string, flags: TextureFlags, internal_format: PixelFormat): Texture;
 
@@ -1436,15 +1460,15 @@ export namespace Cogl {
         /**
          * Selects the primary color buffer
          */
-        COLOR,
+        COLOR = 1,
         /**
          * Selects the depth buffer
          */
-        DEPTH,
+        DEPTH = 2,
         /**
          * Selects the stencil buffer
          */
-        STENCIL,
+        STENCIL = 4,
     }
 
 
@@ -1457,11 +1481,11 @@ export namespace Cogl {
         /**
          * FIXME
          */
-        WINDOW_BUFFER,
+        WINDOW_BUFFER = 2,
         /**
          * FIXME
          */
-        OFFSCREEN_BUFFER,
+        OFFSCREEN_BUFFER = 4,
     }
 
 
@@ -1469,8 +1493,8 @@ export namespace Cogl {
      * @gir-type Flags
      */
     enum EglImageFlags {
-        NONE,
-        NO_GET_DATA,
+        NONE = 0,
+        NO_GET_DATA = 1,
     }
 
 
@@ -1500,152 +1524,152 @@ export namespace Cogl {
         /**
          * Any format
          */
-        ANY,
+        ANY = 0,
         /**
          * 8 bits alpha mask
          */
-        A_8,
+        A_8 = 17,
         /**
          * RGB, 16 bits
          */
-        RGB_565,
+        RGB_565 = 4,
         /**
          * RGBA, 16 bits
          */
-        RGBA_4444,
+        RGBA_4444 = 21,
         /**
          * RGBA, 16 bits
          */
-        RGBA_5551,
+        RGBA_5551 = 22,
         /**
          * Not currently supported
          */
-        YUV,
+        YUV = 7,
         /**
          * Single luminance component
          */
-        G_8,
+        G_8 = 8,
         /**
          * RG, 16 bits. Note that red-green textures
          *   are only available if {@link Cogl.FeatureID.OGL_FEATURE_ID_TEXTURE_RG} is advertised.
          *   See `cogl_texture_set_components()` for details.
          */
-        RG_88,
+        RG_88 = 9,
         /**
          * RGB, 24 bits
          */
-        RGB_888,
+        RGB_888 = 2,
         /**
          * BGR, 24 bits
          */
-        BGR_888,
+        BGR_888 = 34,
         /**
          * RGBA, 32 bits
          */
-        RGBA_8888,
+        RGBA_8888 = 19,
         /**
          * BGRA, 32 bits
          */
-        BGRA_8888,
+        BGRA_8888 = 51,
         /**
          * ARGB, 32 bits
          */
-        ARGB_8888,
+        ARGB_8888 = 83,
         /**
          * ABGR, 32 bits
          */
-        ABGR_8888,
+        ABGR_8888 = 115,
         /**
          * RGBA, 32 bits, 10 bpc
          */
-        RGBA_1010102,
+        RGBA_1010102 = 29,
         /**
          * BGRA, 32 bits, 10 bpc
          */
-        BGRA_1010102,
+        BGRA_1010102 = 61,
         /**
          * ARGB, 32 bits, 10 bpc
          */
-        ARGB_2101010,
+        ARGB_2101010 = 93,
         /**
          * ABGR, 32 bits, 10 bpc
          */
-        ABGR_2101010,
+        ABGR_2101010 = 125,
         /**
          * RGBA half floating point, 64 bit
          */
-        RGBA_FP_16161616,
+        RGBA_FP_16161616 = 27,
         /**
          * BGRA half floating point, 64 bit
          */
-        BGRA_FP_16161616,
+        BGRA_FP_16161616 = 59,
         /**
          * ARGB half floating point, 64 bit
          */
-        ARGB_FP_16161616,
+        ARGB_FP_16161616 = 91,
         /**
          * ABGR half floating point, 64 bit
          */
-        ABGR_FP_16161616,
+        ABGR_FP_16161616 = 123,
         /**
          * Premultiplied RGBA, 32 bits
          */
-        RGBA_8888_PRE,
+        RGBA_8888_PRE = 147,
         /**
          * Premultiplied BGRA, 32 bits
          */
-        BGRA_8888_PRE,
+        BGRA_8888_PRE = 179,
         /**
          * Premultiplied ARGB, 32 bits
          */
-        ARGB_8888_PRE,
+        ARGB_8888_PRE = 211,
         /**
          * Premultiplied ABGR, 32 bits
          */
-        ABGR_8888_PRE,
+        ABGR_8888_PRE = 243,
         /**
          * Premultiplied RGBA, 16 bits
          */
-        RGBA_4444_PRE,
+        RGBA_4444_PRE = 149,
         /**
          * Premultiplied RGBA, 16 bits
          */
-        RGBA_5551_PRE,
+        RGBA_5551_PRE = 150,
         /**
          * Premultiplied RGBA, 32 bits, 10 bpc
          */
-        RGBA_1010102_PRE,
+        RGBA_1010102_PRE = 157,
         /**
          * Premultiplied BGRA, 32 bits, 10 bpc
          */
-        BGRA_1010102_PRE,
+        BGRA_1010102_PRE = 189,
         /**
          * Premultiplied ARGB, 32 bits, 10 bpc
          */
-        ARGB_2101010_PRE,
+        ARGB_2101010_PRE = 221,
         /**
          * Premultiplied ABGR, 32 bits, 10 bpc
          */
-        ABGR_2101010_PRE,
+        ABGR_2101010_PRE = 253,
         /**
          * Premultiplied RGBA half floating point, 64 bit
          */
-        RGBA_FP_16161616_PRE,
+        RGBA_FP_16161616_PRE = 155,
         /**
          * Premultiplied BGRA half floating point, 64 bit
          */
-        BGRA_FP_16161616_PRE,
+        BGRA_FP_16161616_PRE = 187,
         /**
          * Premultiplied ARGB half floating point, 64 bit
          */
-        ARGB_FP_16161616_PRE,
+        ARGB_FP_16161616_PRE = 219,
         /**
          * Premultiplied ABGR half floating point, 64 bit
          */
-        ABGR_FP_16161616_PRE,
-        DEPTH_16,
-        DEPTH_32,
-        DEPTH_24_STENCIL_8,
+        ABGR_FP_16161616_PRE = 251,
+        DEPTH_16 = 265,
+        DEPTH_32 = 259,
+        DEPTH_24_STENCIL_8 = 771,
     }
 
 
@@ -1658,7 +1682,7 @@ export namespace Cogl {
         /**
          * Read from the color buffer
          */
-        READ_PIXELS_COLOR_BUFFER,
+        READ_PIXELS_COLOR_BUFFER = 1,
     }
 
 
@@ -1671,7 +1695,7 @@ export namespace Cogl {
         /**
          * No flags specified
          */
-        NONE,
+        NONE = 0,
         /**
          * Disables the automatic generation of
          *   the mipmap pyramid from the base level image whenever it is
@@ -1679,16 +1703,16 @@ export namespace Cogl {
          *   rendered with a mipmap filter so it should be free to leave out
          *   this flag when using other filtering modes
          */
-        NO_AUTO_MIPMAP,
+        NO_AUTO_MIPMAP = 1,
         /**
          * Disables the slicing of the texture
          */
-        NO_SLICING,
+        NO_SLICING = 2,
         /**
          * Disables the insertion of the texture inside
          *   the texture atlas used by Cogl
          */
-        NO_ATLAS,
+        NO_ATLAS = 4,
     }
 
 
@@ -1728,27 +1752,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;
     }
@@ -1855,6 +1884,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;
 
@@ -1870,6 +1900,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;
 
@@ -1883,6 +1914,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;
 
@@ -1987,6 +2019,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;
@@ -2009,6 +2042,8 @@ 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
+         * @throws GLib.Error
          */
         allocate(): boolean;
 
@@ -2017,6 +2052,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;
 
@@ -2028,6 +2064,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;
 
@@ -2049,6 +2086,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;
 
@@ -2098,6 +2136,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;
 
@@ -2118,6 +2157,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;
 
@@ -2144,6 +2184,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;
 
@@ -2183,6 +2224,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;
 
@@ -2224,6 +2266,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;
 
@@ -2237,6 +2280,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;
 
@@ -2258,18 +2302,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;
 
@@ -2278,12 +2325,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;
 
@@ -2291,6 +2340,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;
 
@@ -2302,18 +2352,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;
 
@@ -2321,17 +2374,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;
 
@@ -2349,6 +2405,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;
 
@@ -2356,6 +2413,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;
 
@@ -2364,6 +2422,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[];
 
@@ -2371,6 +2430,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;
 
@@ -2378,6 +2438,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;
 
@@ -2385,6 +2446,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;
 
@@ -2392,17 +2454,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;
 
@@ -2415,6 +2480,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;
 
@@ -2430,6 +2496,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;
 
@@ -2437,17 +2504,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;
 
@@ -2464,6 +2534,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;
 
@@ -2485,6 +2556,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;
 
@@ -2522,6 +2594,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;
 
@@ -2541,6 +2614,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;
 
@@ -2565,6 +2639,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;
 
@@ -2594,6 +2669,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;
 
@@ -2607,6 +2683,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;
 
@@ -2614,6 +2691,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;
 
@@ -2623,6 +2701,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;
 
@@ -2634,6 +2713,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;
 
@@ -2652,18 +2732,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;
 
@@ -2701,6 +2784,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;
 
@@ -2713,6 +2797,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;
 
@@ -2736,12 +2821,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;
 
@@ -2751,6 +2838,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;
     }
@@ -2924,6 +3012,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;
@@ -2969,6 +3058,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;
@@ -2986,6 +3076,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;
@@ -3011,6 +3102,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;
 
@@ -3041,6 +3133,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;
 
@@ -3084,6 +3177,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;
 
@@ -3093,6 +3187,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;
 
@@ -3111,6 +3206,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;
 
@@ -3122,6 +3218,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;
 
@@ -3133,6 +3230,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;
 
@@ -3157,6 +3255,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;
 
@@ -3176,6 +3275,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;
 
@@ -3221,6 +3321,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;
 
@@ -3238,6 +3339,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;
     }
@@ -3283,32 +3385,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;
 
@@ -3321,6 +3429,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;
 
@@ -3333,6 +3442,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;
 
@@ -3345,6 +3455,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;
 
@@ -3353,12 +3464,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;
 
@@ -3367,6 +3480,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;
 
@@ -3375,17 +3489,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;
 
@@ -3393,6 +3510,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;
 
@@ -3408,6 +3526,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;
 
@@ -3415,12 +3534,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;
 
@@ -3434,6 +3555,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;
 
@@ -3505,6 +3627,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 2.0
+         * @throws GLib.Error
          */
         set_blend(blend_string: string): boolean;
 
@@ -3512,6 +3636,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;
 
@@ -3525,6 +3650,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;
 
@@ -3536,6 +3662,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;
 
@@ -3547,6 +3674,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;
 
@@ -3566,6 +3694,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;
 
@@ -3580,6 +3709,7 @@ export namespace Cogl {
          * 
          * Status: Unstable
          * @param front_winding the winding order
+         * @since 2.0
          */
         set_front_face_winding(front_winding: Winding): void;
 
@@ -3663,6 +3793,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 2.0
+         * @throws GLib.Error
          */
         set_layer_combine(layer_index: number, blend_string: string): boolean;
 
@@ -3671,6 +3803,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;
 
@@ -3685,6 +3818,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;
 
@@ -3693,6 +3827,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;
 
@@ -3712,6 +3847,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;
 
@@ -3725,6 +3861,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 2.0
+         * @throws GLib.Error
          */
         set_layer_point_sprite_coords_enabled(layer_index: number, enable: boolean): boolean;
 
@@ -3741,6 +3879,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;
 
@@ -3748,6 +3887,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;
 
@@ -3755,6 +3895,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;
 
@@ -3771,6 +3912,8 @@ 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
+         * @throws GLib.Error
          */
         set_per_vertex_point_size(enable: boolean): boolean;
 
@@ -3788,6 +3931,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;
 
@@ -3804,6 +3948,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;
 
@@ -3820,6 +3965,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;
 
@@ -3840,6 +3986,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;
 
@@ -3860,6 +4007,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;
 
@@ -3886,6 +4034,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;
 
@@ -3926,6 +4075,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;
     }
@@ -3981,6 +4131,7 @@ export namespace Cogl {
          * the texture, or if the texture is attached to a {@link Cogl.Offscreen}
          * framebuffer and rendered too.</note>
          * @returns `true` if the texture was successfully allocated,               otherwise `false` and `error` will be updated if it               wasn't `null`.
+         * @throws GLib.Error
          */
         allocate(): boolean;
 
@@ -3992,6 +4143,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;
 
@@ -4038,6 +4190,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;
 
@@ -4070,6 +4223,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;
 
@@ -4094,6 +4249,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;
 
@@ -4145,6 +4301,7 @@ export namespace Cogl {
          * @param data the source data, pointing to the first top-left pixel to set
          * @param level The mipmap level to update (Normally 0 for the largest,         base texture)
          * @returns `true` if the data upload was successful, and               `false` otherwise
+         * @throws GLib.Error
          */
         set_data(format: PixelFormat, rowstride: number, data: Uint8Array | string, level: number): boolean;
 
@@ -4171,6 +4328,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;
 
@@ -4208,6 +4366,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;
     }
@@ -4255,6 +4414,7 @@ export namespace Cogl {
          * the texture, or if the texture is attached to a {@link Cogl.Offscreen}
          * framebuffer and rendered too.</note>
          * @returns `true` if the texture was successfully allocated,               otherwise `false` and `error` will be updated if it               wasn't `null`.
+         * @throws GLib.Error
          */
         allocate(): boolean;
 
@@ -4266,6 +4426,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;
 
@@ -4312,6 +4473,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;
 
@@ -4344,6 +4506,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;
 
@@ -4368,6 +4532,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;
 
@@ -4419,6 +4584,7 @@ export namespace Cogl {
          * @param data the source data, pointing to the first top-left pixel to set
          * @param level The mipmap level to update (Normally 0 for the largest,         base texture)
          * @returns `true` if the data upload was successful, and               `false` otherwise
+         * @throws GLib.Error
          */
         set_data(format: PixelFormat, rowstride: number, data: Uint8Array | string, level: number): boolean;
 
@@ -4445,6 +4611,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;
 
@@ -4482,6 +4649,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;
     }
@@ -4510,6 +4678,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;
 
@@ -4519,6 +4688,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;
 
@@ -4526,11 +4696,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;
 
@@ -4538,6 +4710,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;
 
@@ -4545,6 +4718,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;
 
@@ -4552,6 +4726,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;
 
@@ -4559,6 +4734,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;
 
@@ -4566,6 +4742,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;
 
@@ -4573,6 +4750,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;
 
@@ -4580,6 +4758,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;
 
@@ -4587,6 +4766,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;
 
@@ -4594,6 +4774,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;
 
@@ -4601,6 +4782,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;
 
@@ -4608,6 +4790,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;
 
@@ -4615,6 +4798,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;
 
@@ -4624,12 +4808,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;
 
@@ -4639,6 +4825,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;
 
@@ -4646,78 +4833,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;
 
@@ -4726,6 +4926,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];
 
@@ -4733,6 +4934,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;
     }
@@ -4802,6 +5004,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;
 
@@ -4876,6 +5080,9 @@ 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
+         * @throws GLib.Error
          */
         set_blend(blend_string: string): boolean;
 
@@ -4883,6 +5090,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;
 
@@ -4896,6 +5105,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;
 
@@ -4907,6 +5118,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;
 
@@ -4923,6 +5136,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;
 
@@ -5005,6 +5220,9 @@ 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
+         * @throws GLib.Error
          */
         set_layer_combine(layer_index: number, blend_string: string): boolean;
 
@@ -5013,6 +5231,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;
 
@@ -5022,6 +5242,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;
 
@@ -5030,6 +5251,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;
 
@@ -5043,6 +5265,9 @@ 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
+         * @throws GLib.Error
          */
         set_layer_point_sprite_coords_enabled(layer_index: number, enable: boolean): boolean;
 
@@ -5055,6 +5280,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;
 
@@ -5095,6 +5322,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;
     }
@@ -5356,6 +5585,7 @@ export namespace Cogl {
          * the texture, or if the texture is attached to a {@link Cogl.Offscreen}
          * framebuffer and rendered too.</note>
          * @returns `true` if the texture was successfully allocated,               otherwise `false` and `error` will be updated if it               wasn't `null`.
+         * @throws GLib.Error
          */
         allocate(): boolean;
 
@@ -5367,6 +5597,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;
 
@@ -5413,6 +5644,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;
 
@@ -5445,6 +5677,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;
 
@@ -5469,6 +5703,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;
 
@@ -5520,6 +5755,7 @@ export namespace Cogl {
          * @param data the source data, pointing to the first top-left pixel to set
          * @param level The mipmap level to update (Normally 0 for the largest,         base texture)
          * @returns `true` if the data upload was successful, and               `false` otherwise
+         * @throws GLib.Error
          */
         set_data(format: PixelFormat, rowstride: number, data: Uint8Array | string, level: number): boolean;
 
@@ -5546,6 +5782,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;
 
@@ -5583,6 +5820,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;
     }