@girs/gjs 4.0.0-beta.21 → 4.0.0-beta.23

package/cairo.d.ts

@@ -1,488 +1,843 @@
 // Cairo 1.0
-import type Cairo from '@girs/cairo-1.0';
+import Cairo from '@girs/cairo-1.0';
 import type GObject from '@girs/gobject-2.0';
 
 declare namespace giCairo {
-    // Add overrides here
-    // See
-    // - https://gitlab.gnome.org/GNOME/gjs/-/blob/master/doc/cairo.md
-    // - https://gitlab.gnome.org/GNOME/gjs/-/blob/master/installed-tests/js/testCairoModule.js
-    // - https://gitlab.gnome.org/GNOME/gjs/-/blob/master/installed-tests/js/testCairo.js
-    // - https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/cairo-context.cpp
-
-    // START Re-exported enums, copied from cairo-1.0.d.ts
-    export namespace Status {
-        export const $gtype: GObject.GType<Status>;
-    }
-
-    enum Status {
-        SUCCESS,
-        NO_MEMORY,
-        INVALID_RESTORE,
-        INVALID_POP_GROUP,
-        NO_CURRENT_POINT,
-        INVALID_MATRIX,
-        INVALID_STATUS,
-        NULL_POINTER,
-        INVALID_STRING,
-        INVALID_PATH_DATA,
-        READ_ERROR,
-        WRITE_ERROR,
-        SURFACE_FINISHED,
-        SURFACE_TYPE_MISMATCH,
-        PATTERN_TYPE_MISMATCH,
-        INVALID_CONTENT,
-        INVALID_FORMAT,
-        INVALID_VISUAL,
-        FILE_NOT_FOUND,
-        INVALID_DASH,
-        INVALID_DSC_COMMENT,
-        INVALID_INDEX,
-        CLIP_NOT_REPRESENTABLE,
-        TEMP_FILE_ERROR,
-        INVALID_STRIDE,
-        FONT_TYPE_MISMATCH,
-        USER_FONT_IMMUTABLE,
-        USER_FONT_ERROR,
-        NEGATIVE_COUNT,
-        INVALID_CLUSTERS,
-        INVALID_SLANT,
-        INVALID_WEIGHT,
-        INVALID_SIZE,
-        USER_FONT_NOT_IMPLEMENTED,
-        DEVICE_TYPE_MISMATCH,
-        DEVICE_ERROR,
-        INVALID_MESH_CONSTRUCTION,
-        DEVICE_FINISHED,
-        JBIG2_GLOBAL_MISSING,
-    }
-
-    export namespace Content {
-        export const $gtype: GObject.GType<Content>;
-    }
-
-    enum Content {
-        COLOR,
-        ALPHA,
-        COLOR_ALPHA,
-    }
-
-    export namespace Operator {
-        export const $gtype: GObject.GType<Operator>;
-    }
-
-    enum Operator {
-        CLEAR,
-        SOURCE,
-        OVER,
-        IN,
-        OUT,
-        ATOP,
-        DEST,
-        DEST_OVER,
-        DEST_IN,
-        DEST_OUT,
-        DEST_ATOP,
-        XOR,
-        ADD,
-        SATURATE,
-        MULTIPLY,
-        SCREEN,
-        OVERLAY,
-        DARKEN,
-        LIGHTEN,
-        COLOR_DODGE,
-        COLOR_BURN,
-        HARD_LIGHT,
-        SOFT_LIGHT,
-        DIFFERENCE,
-        EXCLUSION,
-        HSL_HUE,
-        HSL_SATURATION,
-        HSL_COLOR,
-        HSL_LUMINOSITY,
-    }
-
-    export namespace Antialias {
-        export const $gtype: GObject.GType<Antialias>;
-    }
-
-    enum Antialias {
-        DEFAULT,
-        NONE,
-        GRAY,
-        SUBPIXEL,
-        FAST,
-        GOOD,
-        BEST,
-    }
-
-    export namespace FillRule {
-        export const $gtype: GObject.GType<FillRule>;
-    }
-
-    enum FillRule {
-        WINDING,
-        EVEN_ODD,
-    }
-
-    export namespace LineCap {
-        export const $gtype: GObject.GType<LineCap>;
-    }
-
-    enum LineCap {
-        BUTT,
-        ROUND,
-        SQUARE,
-    }
-
-    export namespace LineJoin {
-        export const $gtype: GObject.GType<LineJoin>;
-    }
-
-    enum LineJoin {
-        MITER,
-        ROUND,
-        BEVEL,
-    }
-
-    export namespace TextClusterFlags {
-        export const $gtype: GObject.GType<TextClusterFlags>;
-    }
-
-    enum TextClusterFlags {
-        BACKWARD,
-    }
-
-    export namespace FontSlant {
-        export const $gtype: GObject.GType<FontSlant>;
-    }
-
-    enum FontSlant {
-        NORMAL,
-        ITALIC,
-        OBLIQUE,
-    }
-
-    export namespace FontWeight {
-        export const $gtype: GObject.GType<FontWeight>;
-    }
-
-    enum FontWeight {
-        NORMAL,
-        BOLD,
-    }
-
-    export namespace SubpixelOrder {
-        export const $gtype: GObject.GType<SubpixelOrder>;
-    }
-
-    enum SubpixelOrder {
-        DEFAULT,
-        RGB,
-        BGR,
-        VRGB,
-        VBGR,
-    }
-
-    export namespace HintStyle {
-        export const $gtype: GObject.GType<HintStyle>;
-    }
-
-    enum HintStyle {
-        DEFAULT,
-        NONE,
-        SLIGHT,
-        MEDIUM,
-        FULL,
-    }
-
-    export namespace HintMetrics {
-        export const $gtype: GObject.GType<HintMetrics>;
-    }
-
-    enum HintMetrics {
-        DEFAULT,
-        OFF,
-        ON,
-    }
-
-    export namespace FontType {
-        export const $gtype: GObject.GType<FontType>;
-    }
-
-    enum FontType {
-        TOY,
-        FT,
-        WIN32,
-        QUARTZ,
-        USER,
-    }
-
-    export namespace PathDataType {
-        export const $gtype: GObject.GType<PathDataType>;
-    }
-
-    enum PathDataType {
-        MOVE_TO,
-        LINE_TO,
-        CURVE_TO,
-        CLOSE_PATH,
-    }
-
-    export namespace DeviceType {
-        export const $gtype: GObject.GType<DeviceType>;
-    }
-
-    enum DeviceType {
-        DRM,
-        GL,
-        SCRIPT,
-        XCB,
-        XLIB,
-        XML,
-        COGL,
-        WIN32,
-        INVALID,
-    }
-
-    export namespace SurfaceType {
-        export const $gtype: GObject.GType<SurfaceType>;
-    }
-
-    enum SurfaceType {
-        IMAGE,
-        PDF,
-        PS,
-        XLIB,
-        XCB,
-        GLITZ,
-        QUARTZ,
-        WIN32,
-        BEOS,
-        DIRECTFB,
-        SVG,
-        OS2,
-        WIN32_PRINTING,
-        QUARTZ_IMAGE,
-        SCRIPT,
-        QT,
-        RECORDING,
-        VG,
-        GL,
-        DRM,
-        TEE,
-        XML,
-        SKIA,
-        SUBSURFACE,
-        COGL,
-    }
-
-    export namespace Format {
-        export const $gtype: GObject.GType<Format>;
-    }
-
-    enum Format {
-        INVALID,
-        ARGB32,
-        RGB24,
-        A8,
-        A1,
-        RGB16_565,
-        RGB30,
-    }
-
-    export namespace PatternType {
-        export const $gtype: GObject.GType<PatternType>;
-    }
-
-    enum PatternType {
-        SOLID,
-        SURFACE,
-        LINEAR,
-        RADIAL,
-        MESH,
-        RASTER_SOURCE,
-    }
-
-    export namespace Extend {
-        export const $gtype: GObject.GType<Extend>;
-    }
-
-    enum Extend {
-        NONE,
-        REPEAT,
-        REFLECT,
-        PAD,
-    }
-
-    export namespace Filter {
-        export const $gtype: GObject.GType<Filter>;
-    }
-
-    enum Filter {
-        FAST,
-        GOOD,
-        BEST,
-        NEAREST,
-        BILINEAR,
-        GAUSSIAN,
-    }
-
-    export namespace RegionOverlap {
-        export const $gtype: GObject.GType<RegionOverlap>;
-    }
-
-    enum RegionOverlap {
-        IN,
-        OUT,
-        PART,
+    // Re-export enums directly from Cairo
+    export import Status = Cairo.Status;
+    export import Content = Cairo.Content;
+    export import Operator = Cairo.Operator;
+    export import Antialias = Cairo.Antialias;
+    export import FillRule = Cairo.FillRule;
+    export import LineCap = Cairo.LineCap;
+    export import LineJoin = Cairo.LineJoin;
+    export import TextClusterFlags = Cairo.TextClusterFlags;
+    export import FontSlant = Cairo.FontSlant;
+    export import FontWeight = Cairo.FontWeight;
+    export import SubpixelOrder = Cairo.SubpixelOrder;
+    export import HintStyle = Cairo.HintStyle;
+    export import HintMetrics = Cairo.HintMetrics;
+    export import FontType = Cairo.FontType;
+    export import PathDataType = Cairo.PathDataType;
+    export import DeviceType = Cairo.DeviceType;
+    export import SurfaceType = Cairo.SurfaceType;
+    export import Format = Cairo.Format;
+    export import PatternType = Cairo.PatternType;
+    export import Extend = Cairo.Extend;
+    export import Filter = Cairo.Filter;
+    export import RegionOverlap = Cairo.RegionOverlap;
+
+    /**
+     * Describes the metrics of a string of text
+     */
+    export interface TextExtents {
+        /** The horizontal distance from the origin to the leftmost part of the text */
+        xBearing: number;
+        /** The vertical distance from the origin to the topmost part of the text */
+        yBearing: number;
+        /** The width of the text */
+        width: number;
+        /** The height of the text */
+        height: number;
+        /** The distance to advance horizontally after drawing the text */
+        xAdvance: number;
+        /** The distance to advance vertically after drawing the text */
+        yAdvance: number;
     }
 
-    // END Re-exported enums, copied from cairo-1.0.d.ts
-
+    /**
+     * The main Cairo drawing context
+     *
+     * A Cairo context is used to draw to surfaces and perform drawing operations.
+     * When you're done with a context, you must call $dispose() to free memory.
+     */
     export class Context extends Cairo.Context {
+        /**
+         * Creates a new Cairo context for drawing to the given surface
+         * @param surface The surface to draw on
+         */
         constructor(surface: Surface);
 
+        /**
+         * Free a Cairo.Context and all associated memory
+         *
+         * Unlike other objects in GJS, Cairo contexts must be explicitly disposed
+         * to avoid memory leaks.
+         */
+        $dispose(): void;
+
+        /**
+         * Adds a circular arc of the given radius to the current path
+         * @param xc X coordinate of the center of the arc
+         * @param yc Y coordinate of the center of the arc
+         * @param radius Radius of the arc
+         * @param angle1 Starting angle in radians
+         * @param angle2 End angle in radians
+         */
         arc(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+
+        /**
+         * Adds a circular arc of the given radius to the current path, but draws
+         * the arc in the opposite direction from arc()
+         * @param xc X coordinate of the center of the arc
+         * @param yc Y coordinate of the center of the arc
+         * @param radius Radius of the arc
+         * @param angle1 Starting angle in radians
+         * @param angle2 End angle in radians
+         */
         arcNegative(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+
+        /**
+         * Adds a cubic Bézier spline to the current path
+         * @param x1 X coordinate of the first control point
+         * @param y1 Y coordinate of the first control point
+         * @param x2 X coordinate of the second control point
+         * @param y2 Y coordinate of the second control point
+         * @param x3 X coordinate of the end point
+         * @param y3 Y coordinate of the end point
+         */
         curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+
+        /**
+         * Establishes a new clip region by intersecting the current clip region
+         * with the current path, then clearing the current path
+         */
         clip(): void;
+
+        /**
+         * Like clip() but preserves the current path
+         */
         clipPreserve(): void;
+
+        /**
+         * Returns the current clip extents as [x1, y1, x2, y2]
+         * @returns An array with [x1, y1, x2, y2] clip extents
+         */
         clipExtents(): [number, number, number, number];
+
+        /**
+         * Closes the current path by drawing a line to the beginning of the current subpath
+         */
         closePath(): void;
+
+        /**
+         * Emits the current page, but doesn't clear it
+         */
         copyPage(): void;
+
+        /**
+         * Transforms a coordinate from device space to user space
+         * @param x X coordinate
+         * @param y Y coordinate
+         * @returns An array with [x, y] transformed coordinates
+         */
         deviceToUser(x: number, y: number): [number, number];
+
+        /**
+         * Transforms a distance vector from device space to user space
+         * @param x X component of the distance vector
+         * @param y Y component of the distance vector
+         * @returns An array with [x, y] transformed distance vector
+         */
         deviceToUserDistance(x: number, y: number): [number, number];
+
+        /**
+         * Fills the current path using the current fill rule, then clears the path
+         */
         fill(): void;
+
+        /**
+         * Fills the current path using the current fill rule, but doesn't clear the path
+         */
         fillPreserve(): void;
+
+        /**
+         * Returns the current fill extents as [x1, y1, x2, y2]
+         * @returns An array with [x1, y1, x2, y2] fill extents
+         */
         fillExtents(): [number, number, number, number];
+
+        /**
+         * Gets the current antialiasing mode
+         * @returns The current antialiasing mode
+         */
         getAntialias(): Antialias;
+
+        /**
+         * Gets the current point of the current path
+         * @returns An array with [x, y] coordinates of the current point
+         */
         getCurrentPoint(): [number, number];
+
+        /**
+         * Gets the current dash count
+         * @returns The number of elements in the current dash pattern
+         */
         getDashCount(): number;
+
+        /**
+         * Gets the current fill rule
+         * @returns The current fill rule
+         */
         getFillRule(): FillRule;
+
+        /**
+         * Gets the current line cap style
+         * @returns The current line cap style
+         */
         getLineCap(): LineCap;
+
+        /**
+         * Gets the current line join style
+         * @returns The current line join style
+         */
         getLineJoin(): LineJoin;
+
+        /**
+         * Gets the current line width
+         * @returns The current line width
+         */
         getLineWidth(): number;
+
+        /**
+         * Gets the current miter limit
+         * @returns The current miter limit
+         */
         getMiterLimit(): number;
+
+        /**
+         * Gets the current compositing operator
+         * @returns The current compositing operator
+         */
         getOperator(): Operator;
+
+        /**
+         * Gets the current source pattern
+         * @returns The current source pattern
+         */
+        getSource(): Pattern;
+
+        /**
+         * Gets the surface the Cairo context is drawing on
+         * @returns The target surface
+         */
+        getTarget(): Surface;
+
+        /**
+         * Gets the current tolerance value
+         * @returns The current tolerance value
+         */
         getTolerance(): number;
+
+        /**
+         * Checks if there is a current point defined
+         * @returns True if there is a current point
+         */
         hasCurrentPoint(): boolean;
+
+        /**
+         * Resets the current transformation matrix to the identity matrix
+         */
         identityMatrix(): void;
+
+        /**
+         * Tests whether the given point is inside the area filled by the current path
+         * @param x X coordinate of the point to test
+         * @param y Y coordinate of the point to test
+         * @returns True if the point is inside the path
+         */
         inFill(x: number, y: number): boolean;
+
+        /**
+         * Tests whether the given point is inside the area that would be inked
+         * by the current path with the current line width and stroke parameters
+         * @param x X coordinate of the point to test
+         * @param y Y coordinate of the point to test
+         * @returns True if the point would be inked
+         */
         inStroke(x: number, y: number): boolean;
+
+        /**
+         * Adds a line to the current path from the current point to the given point
+         * @param x X coordinate of the end point
+         * @param y Y coordinate of the end point
+         */
         lineTo(x: number, y: number): void;
+
+        /**
+         * Sets the current mask pattern used for painting operations
+         * @param pattern A pattern to use as mask
+         */
+        mask(pattern: Pattern): void;
+
+        /**
+         * Sets the current mask to a surface
+         * @param surface A surface to use as mask
+         * @param x X coordinate at which to place the origin of the surface
+         * @param y Y coordinate at which to place the origin of the surface
+         */
+        maskSurface(surface: Surface, x: number, y: number): void;
+
+        /**
+         * Begins a new subpath at the given point
+         * @param x X coordinate of the new position
+         * @param y Y coordinate of the new position
+         */
         moveTo(x: number, y: number): void;
+
+        /**
+         * Clears the current path and begins a new path
+         */
         newPath(): void;
+
+        /**
+         * Begins a new subpath without changing the current point
+         */
         newSubPath(): void;
+
+        /**
+         * Paints the current source everywhere within the current clip region
+         */
         paint(): void;
+
+        /**
+         * Paints the current source everywhere within the current clip region
+         * using the given alpha value
+         * @param alpha Alpha value to use, between 0 and 1
+         */
         paintWithAlpha(alpha: number): void;
+
+        /**
+         * Returns the current path extents as [x1, y1, x2, y2]
+         * @returns An array with [x1, y1, x2, y2] path extents
+         */
         pathExtents(): [number, number, number, number];
+
+        /**
+         * Terminates the current pattern group and returns a new pattern
+         * representing everything drawn to the group
+         * @returns A new pattern representing the group
+         */
         popGroup(): Pattern;
+
+        /**
+         * Terminates the current pattern group and makes it the current source pattern
+         */
         popGroupToSource(): void;
+
+        /**
+         * Temporarily redirects drawing to an intermediate surface
+         */
         pushGroup(): void;
+
+        /**
+         * Temporarily redirects drawing to an intermediate surface with the given content
+         * @param content The content type for the group
+         */
         pushGroupWithContent(content: Content): void;
+
+        /**
+         * Adds a rectangle to the current path
+         * @param x X coordinate of the top-left corner
+         * @param y Y coordinate of the top-left corner
+         * @param width Width of the rectangle
+         * @param height Height of the rectangle
+         */
         rectangle(x: number, y: number, width: number, height: number): void;
+
+        /**
+         * Adds a cubic Bézier spline to the current path using relative coordinates
+         * @param dx1 X offset to the first control point from current point
+         * @param dy1 Y offset to the first control point from current point
+         * @param dx2 X offset to the second control point from current point
+         * @param dy2 Y offset to the second control point from current point
+         * @param dx3 X offset to the end point from current point
+         * @param dy3 Y offset to the end point from current point
+         */
         relCurveTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): void;
+
+        /**
+         * Adds a line to the current path relative to the current point
+         * @param dx X offset from the current point
+         * @param dy Y offset from the current point
+         */
         relLineTo(dx: number, dy: number): void;
+
+        /**
+         * Begins a new subpath relative to the current point
+         * @param dx X offset from the current point
+         * @param dy Y offset from the current point
+         */
         relMoveTo(dx: number, dy: number): void;
+
+        /**
+         * Resets the current clip region to its original, unrestricted state
+         */
         resetClip(): void;
+
+        /**
+         * Restores the context state from the stack
+         */
         restore(): void;
+
+        /**
+         * Rotates the current transformation matrix
+         * @param angle Angle of rotation in radians
+         */
         rotate(angle: number): void;
+
+        /**
+         * Saves the current context state to the stack
+         */
         save(): void;
+
+        /**
+         * Scales the current transformation matrix
+         * @param sx Scale factor for the X dimension
+         * @param sy Scale factor for the Y dimension
+         */
         scale(sx: number, sy: number): void;
+
+        /**
+         * Selects a font face
+         * @param family A font family name
+         * @param slant A font slant
+         * @param weight A font weight
+         */
         selectFontFace(family: string, slant: number, weight: number): void;
+
+        /**
+         * Sets the antialiasing mode
+         * @param antialias The new antialiasing mode
+         */
         setAntialias(antialias: Antialias): void;
+
+        /**
+         * Sets the dash pattern to be used by stroke()
+         * @param dashes Array of dash lengths
+         * @param offset Offset into the dash pattern
+         */
         setDash(dashes: number[], offset: number): void;
+
+        /**
+         * Sets the current font size in user space units
+         * @param size Font size in user space units
+         */
         setFontSize(size: number): void;
+
+        /**
+         * Sets the current fill rule
+         * @param fillRule The new fill rule
+         */
         setFillRule(fillRule: FillRule): void;
+
+        /**
+         * Sets the current line cap style
+         * @param lineCap The new line cap style
+         */
         setLineCap(lineCap: LineCap): void;
+
+        /**
+         * Sets the current line join style
+         * @param lineJoin The new line join style
+         */
         setLineJoin(lineJoin: LineJoin): void;
+
+        /**
+         * Sets the current line width
+         * @param width The new line width
+         */
         setLineWidth(width: number): void;
+
+        /**
+         * Sets the current miter limit
+         * @param limit The new miter limit
+         */
         setMiterLimit(limit: number): void;
+
+        /**
+         * Sets the current compositing operator
+         * @param op The new compositing operator
+         */
         setOperator(op: Operator): void;
+
+        /**
+         * Sets the current source pattern
+         * @param pattern The new source pattern
+         */
         setSource(pattern: Pattern): void;
+
+        /**
+         * Sets the source pattern to an RGB opaque color
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         */
         setSourceRGB(red: number, green: number, blue: number): void;
+
+        /**
+         * Sets the source pattern to an RGBA color
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         * @param alpha Alpha component, between 0 and 1
+         */
         setSourceRGBA(red: number, green: number, blue: number, alpha: number): void;
+
+        /**
+         * Sets the source pattern to the given surface
+         * @param surface The new source surface
+         * @param x X coordinate where to place the surface origin
+         * @param y Y coordinate where to place the surface origin
+         */
         setSourceSurface(surface: Surface, x: number, y: number): void;
+
+        /**
+         * Sets the tolerance used when converting paths to trapezoids
+         * @param tolerance The new tolerance value
+         */
         setTolerance(tolerance: number): void;
+
+        /**
+         * Emits the current page and clears it
+         */
         showPage(): void;
+
+        /**
+         * Draws text at the current position
+         * @param utf8 A string of text encoded in UTF-8
+         */
         showText(utf8: string): void;
+
+        /**
+         * Strokes the current path using the current line width, line join,
+         * line cap, and dash settings, then clears the path
+         */
         stroke(): void;
+
+        /**
+         * Like stroke() but preserves the current path
+         */
         strokePreserve(): void;
+
+        /**
+         * Returns the current stroke extents as [x1, y1, x2, y2]
+         * @returns An array with [x1, y1, x2, y2] stroke extents
+         */
         strokeExtents(): [number, number, number, number];
+
+        /**
+         * Gets the extents of the given text if it were drawn at the current point
+         * @param utf8 A string of text encoded in UTF-8
+         * @returns Text extents information
+         */
         textExtents(utf8: string): TextExtents;
+
+        /**
+         * Translates the current transformation matrix
+         * @param tx Translation in the X direction
+         * @param ty Translation in the Y direction
+         */
         translate(tx: number, ty: number): void;
+
+        /**
+         * Transforms a coordinate from user space to device space
+         * @param x X coordinate
+         * @param y Y coordinate
+         * @returns An array with [x, y] transformed coordinates
+         */
         userToDevice(x: number, y: number): [number, number];
+
+        /**
+         * Transforms a distance vector from user space to device space
+         * @param x X component of the distance vector
+         * @param y Y component of the distance vector
+         * @returns An array with [x, y] transformed distance vector
+         */
         userToDeviceDistance(x: number, y: number): [number, number];
-    }
 
-    export abstract class Surface extends Cairo.Surface {
-        // TODO
+        /**
+         * Creates a copy of the current path and returns it
+         * @returns A copy of the current path
+         */
+        copyPath(): Path;
+
+        /**
+         * Appends a path to the current path
+         * @param path A path to append
+         */
+        appendPath(path: Path): void;
     }
 
+    /**
+     * Base class for all Cairo surfaces
+     */
+    export abstract class Surface extends Cairo.Surface {
+        /**
+         * Gets the device scale of the surface
+         * @returns An array with [x, y] device scale
+         */
+        getDeviceScale(): [number, number];
+
+        /**
+         * Sets the device scale of the surface
+         * @param x X scale factor
+         * @param y Y scale factor
+         */
+        setDeviceScale(x: number, y: number): void;
+
+        /**
+         * Gets the device offset of the surface
+         * @returns An array with [x, y] device offset
+         */
+        getDeviceOffset(): [number, number];
+
+        /**
+         * Sets the device offset of the surface
+         * @param x X offset
+         * @param y Y offset
+         */
+        setDeviceOffset(x: number, y: number): void;
+
+        /**
+         * Performs all pending drawing operations
+         */
+        flush(): void;
+
+        /**
+         * Finishes the surface and drops all references to external resources
+         */
+        finish(): void;
+    }
+
+    /**
+     * A surface that uses in-memory image data buffers
+     */
     export class ImageSurface extends Surface {
+        /**
+         * Creates a new image surface
+         * @param format The format of pixels in the surface
+         * @param width Width of the surface in pixels
+         * @param height Height of the surface in pixels
+         */
         constructor(format: Format, width: number, height: number);
 
+        /**
+         * Creates a new image surface from a PNG file
+         * @param filename Path to a PNG file
+         * @returns A new image surface
+         */
         static createFromPNG(filename: string): ImageSurface;
 
-        // TODO
-    }
-
+        /**
+         * Gets the format of the surface
+         * @returns The format of the surface
+         */
+        getFormat(): Format;
+
+        /**
+         * Gets the width of the surface in pixels
+         * @returns The width of the surface
+         */
+        getWidth(): number;
+
+        /**
+         * Gets the height of the surface in pixels
+         * @returns The height of the surface
+         */
+        getHeight(): number;
+
+        /**
+         * Writes the contents of the surface to a PNG file
+         * @param filename Path to the PNG file to write
+         */
+        writeToPNG(filename: string): void;
+    }
+
+    /**
+     * A surface that produces output in the PDF format
+     */
     export class PDFSurface extends Surface {
+        /**
+         * Creates a new PDF surface
+         * @param filename Path to the PDF file to write to
+         * @param width Width of the surface in points (1 point = 1/72 inch)
+         * @param height Height of the surface in points (1 point = 1/72 inch)
+         */
         constructor(filename: string, width: number, height: number);
-
-        // TODO
     }
 
+    /**
+     * A surface that produces output in the PostScript format
+     */
     export class PSSurface extends Surface {
+        /**
+         * Creates a new PostScript surface
+         * @param filename Path to the PostScript file to write to
+         * @param width Width of the surface in points (1 point = 1/72 inch)
+         * @param height Height of the surface in points (1 point = 1/72 inch)
+         */
         constructor(filename: string, width: number, height: number);
-
-        // TODO
     }
 
+    /**
+     * A surface that produces output in the SVG format
+     */
     export class SVGSurface extends Surface {
+        /**
+         * Creates a new SVG surface
+         * @param filename Path to the SVG file to write to
+         * @param width Width of the surface in points (1 point = 1/72 inch)
+         * @param height Height of the surface in points (1 point = 1/72 inch)
+         */
         constructor(filename: string, width: number, height: number);
-
-        // TODO
     }
 
-    export class Pattern extends Cairo.Pattern {
-        // TODO
-    }
+    /**
+     * Base class for all Cairo patterns
+     */
+    export class Pattern extends Cairo.Pattern {}
 
+    /**
+     * Base class for all gradient patterns
+     */
     export class Gradient extends Pattern {
-        // TODO
-    }
-
+        /**
+         * Adds a color stop to the gradient at the given offset
+         * @param offset Offset position of the stop, between 0 and 1
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         * @param alpha Alpha component, between 0 and 1
+         */
+        addColorStopRGBA(offset: number, red: number, green: number, blue: number, alpha: number): void;
+
+        /**
+         * Adds an opaque color stop to the gradient at the given offset
+         * @param offset Offset position of the stop, between 0 and 1
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         */
+        addColorStopRGB(offset: number, red: number, green: number, blue: number): void;
+    }
+
+    /**
+     * A pattern for linear gradients
+     */
     export class LinearGradient extends Gradient {
-        // TODO
-    }
-
+        /**
+         * Creates a new linear gradient pattern
+         * @param x0 X coordinate of the start point
+         * @param y0 Y coordinate of the start point
+         * @param x1 X coordinate of the end point
+         * @param y1 Y coordinate of the end point
+         */
+        constructor(x0: number, y0: number, x1: number, y1: number);
+    }
+
+    /**
+     * A pattern for radial gradients
+     */
     export class RadialGradient extends Gradient {
-        // TODO
-    }
-
+        /**
+         * Creates a new radial gradient pattern
+         * @param cx0 X coordinate of the start circle
+         * @param cy0 Y coordinate of the start circle
+         * @param radius0 Radius of the start circle
+         * @param cx1 X coordinate of the end circle
+         * @param cy1 Y coordinate of the end circle
+         * @param radius1 Radius of the end circle
+         */
+        constructor(cx0: number, cy0: number, radius0: number, cx1: number, cy1: number, radius1: number);
+    }
+
+    /**
+     * A pattern that uses a surface as its source
+     */
     export class SurfacePattern extends Pattern {
-        // TODO
+        /**
+         * Creates a new pattern for the given surface
+         * @param surface The surface to use
+         */
+        constructor(surface: Surface);
     }
 
+    /**
+     * A pattern for solid colors
+     */
     export class SolidPattern extends Pattern {
-        // TODO
-    }
-
-    export class Path extends Cairo.Path {
-        // TODO
-    }
-
-    export interface TextExtents {
-        xBearing: number;
-        yBearing: number;
-        width: number;
-        height: number;
-        xAdvance: number;
-        yAdvance: number;
-    }
+        /**
+         * Creates a new solid pattern with an opaque color
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         * @returns A new solid pattern
+         */
+        static createRGB(red: number, green: number, blue: number): SolidPattern;
+
+        /**
+         * Creates a new solid pattern with a transparent color
+         * @param red Red component, between 0 and 1
+         * @param green Green component, between 0 and 1
+         * @param blue Blue component, between 0 and 1
+         * @param alpha Alpha component, between 0 and 1
+         * @returns A new solid pattern
+         */
+        static createRGBA(red: number, green: number, blue: number, alpha: number): SolidPattern;
+    }
+
+    export class Path extends Cairo.Path {}
+
+    /**
+     * A rectangle
+     */
+    export class Rectangle extends Cairo.Rectangle {}
+
+    /**
+     * A rectangle integer
+     */
+    export class RectangleInt extends Cairo.RectangleInt {}
+
+    /**
+     * A region object used for representing a set of pixels
+     */
+    export class Region extends Cairo.Region {}
+
+    /**
+     * A matrix object used for transforming coordinates
+     */
+    export class Matrix extends Cairo.Matrix {}
+
+    /**
+     * A font face object used for storing and manipulating font faces
+     */
+    export class FontFace extends Cairo.FontFace {}
+
+    /**
+     * A scaled font object used for storing and manipulating scaled fonts
+     */
+    export class ScaledFont extends Cairo.ScaledFont {}
+
+    /**
+     * A glyph object used for storing and manipulating glyphs
+     */
+    export class Glyph extends Cairo.Glyph {}
+
+    /**
+     * A text cluster object used for storing and manipulating text clusters
+     */
+    export class TextCluster extends Cairo.TextCluster {}
+
+    /**
+     * A font options object used for storing and manipulating font options
+     */
+    export class FontOptions extends Cairo.FontOptions {}
+
+    /**
+     * A device object used for storing and manipulating devices
+     */
+    export class Device extends Cairo.Device {}
 }
 
 export default giCairo;