raylib/src/generated/node-raylib.d.ts

Node.js bindings for raylib.

// GENERATED CODE: DO NOT MODIFY
declare module "raylib" {
  /** Vector2, 2 components */
  export interface Vector2 {
    /** Vector x component. (float) */
    x: number
    /** Vector y component. (float) */
    y: number
  }
  /** Vector3, 3 components */
  export interface Vector3 {
    /** Vector x component. (float) */
    x: number
    /** Vector y component. (float) */
    y: number
    /** Vector z component. (float) */
    z: number
  }
  /** Vector4, 4 components */
  export interface Vector4 {
    /** Vector x component. (float) */
    x: number
    /** Vector y component. (float) */
    y: number
    /** Vector z component. (float) */
    z: number
    /** Vector w component. (float) */
    w: number
  }
  /** Matrix, 4x4 components, column major, OpenGL style, right-handed */
  export interface Matrix {
    /** Matrix first row (4 components). (float) */
    m0: number
    /** Matrix first row (4 components). (float) */
    m4: number
    /** Matrix first row (4 components). (float) */
    m8: number
    /** Matrix first row (4 components). (float) */
    m12: number
    /** Matrix second row (4 components). (float) */
    m1: number
    /** Matrix second row (4 components). (float) */
    m5: number
    /** Matrix second row (4 components). (float) */
    m9: number
    /** Matrix second row (4 components). (float) */
    m13: number
    /** Matrix third row (4 components). (float) */
    m2: number
    /** Matrix third row (4 components). (float) */
    m6: number
    /** Matrix third row (4 components). (float) */
    m10: number
    /** Matrix third row (4 components). (float) */
    m14: number
    /** Matrix fourth row (4 components). (float) */
    m3: number
    /** Matrix fourth row (4 components). (float) */
    m7: number
    /** Matrix fourth row (4 components). (float) */
    m11: number
    /** Matrix fourth row (4 components). (float) */
    m15: number
  }
  /** Color, 4 components, R8G8B8A8 (32bit) */
  export interface Color {
    /** Color red value. (unsigned char) */
    r: number
    /** Color green value. (unsigned char) */
    g: number
    /** Color blue value. (unsigned char) */
    b: number
    /** Color alpha value. (unsigned char) */
    a: number
  }
  /** Rectangle, 4 components */
  export interface Rectangle {
    /** Rectangle top-left corner position x. (float) */
    x: number
    /** Rectangle top-left corner position y. (float) */
    y: number
    /** Rectangle width. (float) */
    width: number
    /** Rectangle height. (float) */
    height: number
  }
  /** Image, pixel data stored in CPU memory (RAM) */
  export interface Image {
    /** Image raw data. (void *) */
    data: number
    /** Image base width. (int) */
    width: number
    /** Image base height. (int) */
    height: number
    /** Mipmap levels, 1 by default. (int) */
    mipmaps: number
    /** Data format (PixelFormat type). (int) */
    format: number
  }
  /** Texture, tex data stored in GPU memory (VRAM) */
  export interface Texture {
    /** OpenGL texture id. (unsigned int) */
    id: number
    /** Texture base width. (int) */
    width: number
    /** Texture base height. (int) */
    height: number
    /** Mipmap levels, 1 by default. (int) */
    mipmaps: number
    /** Data format (PixelFormat type). (int) */
    format: number
  }
  /** RenderTexture, fbo for texture rendering */
  export interface RenderTexture {
    /** OpenGL framebuffer object id. (unsigned int) */
    id: number
    /** Color buffer attachment texture. (Texture) */
    texture: Texture
    /** Depth buffer attachment texture. (Texture) */
    depth: Texture
  }
  /** NPatchInfo, n-patch layout info */
  export interface NPatchInfo {
    /** Texture source rectangle. (Rectangle) */
    source: Rectangle
    /** Left border offset. (int) */
    left: number
    /** Top border offset. (int) */
    top: number
    /** Right border offset. (int) */
    right: number
    /** Bottom border offset. (int) */
    bottom: number
    /** Layout of the n-patch: 3x3, 1x3 or 3x1. (int) */
    layout: number
  }
  /** GlyphInfo, font characters glyphs info */
  export interface GlyphInfo {
    /** Character value (Unicode). (int) */
    value: number
    /** Character offset X when drawing. (int) */
    offsetX: number
    /** Character offset Y when drawing. (int) */
    offsetY: number
    /** Character advance position X. (int) */
    advanceX: number
    /** Character image data. (Image) */
    image: Image
  }
  /** Font, font texture and GlyphInfo array data */
  export interface Font {
    /** Base size (default chars height). (int) */
    baseSize: number
    /** Number of glyph characters. (int) */
    glyphCount: number
    /** Padding around the glyph characters. (int) */
    glyphPadding: number
    /** Texture atlas containing the glyphs. (Texture) */
    texture: Texture
    /** Rectangles in texture for the glyphs. (Rectangle *) */
    recs: number
    /** Glyphs info data. (GlyphInfo *) */
    glyphs: number
  }
  /** Camera, defines position/orientation in 3d space */
  export interface Camera3D {
    /** Camera position. (Vector3) */
    position: Vector3
    /** Camera target it looks-at. (Vector3) */
    target: Vector3
    /** Camera up vector (rotation over its axis). (Vector3) */
    up: Vector3
    /** Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic. (float) */
    fovy: number
    /** Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC. (int) */
    projection: number
  }
  /** Camera2D, defines position/orientation in 2d space */
  export interface Camera2D {
    /** Camera offset (displacement from target). (Vector2) */
    offset: Vector2
    /** Camera target (rotation and zoom origin). (Vector2) */
    target: Vector2
    /** Camera rotation in degrees. (float) */
    rotation: number
    /** Camera zoom (scaling), should be 1.0f by default. (float) */
    zoom: number
  }
  /** Mesh, vertex data and vao/vbo */
  export interface Mesh {
    /** Number of vertices stored in arrays. (int) */
    vertexCount: number
    /** Number of triangles stored (indexed or not). (int) */
    triangleCount: number
    /** Vertex position (XYZ - 3 components per vertex) (shader-location = 0). (float *) */
    vertices: number
    /** Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1). (float *) */
    texcoords: number
    /** Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5). (float *) */
    texcoords2: number
    /** Vertex normals (XYZ - 3 components per vertex) (shader-location = 2). (float *) */
    normals: number
    /** Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4). (float *) */
    tangents: number
    /** Vertex colors (RGBA - 4 components per vertex) (shader-location = 3). (unsigned char *) */
    colors: Buffer
    /** Vertex indices (in case vertex data comes indexed). (unsigned short *) */
    indices: number
    /** Animated vertex positions (after bones transformations). (float *) */
    animVertices: number
    /** Animated normals (after bones transformations). (float *) */
    animNormals: number
    /** Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning). (unsigned char *) */
    boneIds: Buffer
    /** Vertex bone weight, up to 4 bones influence by vertex (skinning). (float *) */
    boneWeights: number
    /** OpenGL Vertex Array Object id. (unsigned int) */
    vaoId: number
    /** OpenGL Vertex Buffer Objects id (default vertex data). (unsigned int *) */
    vboId: number
  }
  /** Shader */
  export interface Shader {
    /** Shader program id. (unsigned int) */
    id: number
    /** Shader locations array (RL_MAX_SHADER_LOCATIONS). (int *) */
    locs: number
  }
  /** MaterialMap */
  export interface MaterialMap {
    /** Material map texture. (Texture) */
    texture: Texture
    /** Material map color. (Color) */
    color: Color
    /** Material map value. (float) */
    value: number
  }
  /** Material, includes shader and maps */
  export interface Material {
    /** Material shader. (Shader) */
    shader: Shader
    /** Material maps array (MAX_MATERIAL_MAPS). (MaterialMap *) */
    maps: number
    /** Material generic parameters (if required). (float[4]) */
    params: number
  }
  /** Transform, vertex transformation data */
  export interface Transform {
    /** Translation. (Vector3) */
    translation: Vector3
    /** Rotation. (Vector4) */
    rotation: Vector4
    /** Scale. (Vector3) */
    scale: Vector3
  }
  /** Bone, skeletal animation bone */
  export interface BoneInfo {
    /** Bone name. (char) */
    name: string
    /** Bone parent. (char) */
    parent: string
  }
  /** Model, meshes, materials and animation data */
  export interface Model {
    /** Local transform matrix. (Matrix) */
    transform: Matrix
    /** Number of meshes. (int) */
    meshCount: number
    /** Number of materials. (int) */
    materialCount: number
    /** Meshes array. (Mesh *) */
    meshes: number
    /** Materials array. (Material *) */
    materials: number
    /** Mesh material number. (int *) */
    meshMaterial: number
    /** Number of bones. (int) */
    boneCount: number
    /** Bones information (skeleton). (BoneInfo *) */
    bones: number
    /** Bones base transformation (pose). (Transform *) */
    bindPose: number
  }
  /** ModelAnimation */
  export interface ModelAnimation {
    /** Number of bones. (int) */
    boneCount: number
    /** Number of animation frames. (int) */
    frameCount: number
    /** Bones information (skeleton). (BoneInfo *) */
    bones: number
    /** Poses array by frame. (Transform **) */
    framePoses: number
  }
  /** Ray, ray for raycasting */
  export interface Ray {
    /** Ray position (origin). (Vector3) */
    position: Vector3
    /** Ray direction. (Vector3) */
    direction: Vector3
  }
  /** RayCollision, ray hit information */
  export interface RayCollision {
    /** Did the ray hit something?. (bool) */
    hit: boolean
    /** Distance to the nearest hit. (float) */
    distance: number
    /** Point of the nearest hit. (Vector3) */
    point: Vector3
    /** Surface normal of hit. (Vector3) */
    normal: Vector3
  }
  /** BoundingBox */
  export interface BoundingBox {
    /** Minimum vertex box-corner. (Vector3) */
    min: Vector3
    /** Maximum vertex box-corner. (Vector3) */
    max: Vector3
  }
  /** Wave, audio wave data */
  export interface Wave {
    /** Total number of frames (considering channels). (unsigned int) */
    frameCount: number
    /** Frequency (samples per second). (unsigned int) */
    sampleRate: number
    /** Bit depth (bits per sample): 8, 16, 32 (24 not supported). (unsigned int) */
    sampleSize: number
    /** Number of channels (1-mono, 2-stereo, ...). (unsigned int) */
    channels: number
    /** Buffer data pointer. (void *) */
    data: number
  }
  /** AudioStream, custom audio stream */
  export interface AudioStream {
    /** Pointer to internal data used by the audio system. (rAudioBuffer *) */
    buffer: number
    /** Pointer to internal data processor, useful for audio effects. (rAudioProcessor *) */
    processor: number
    /** Frequency (samples per second). (unsigned int) */
    sampleRate: number
    /** Bit depth (bits per sample): 8, 16, 32 (24 not supported). (unsigned int) */
    sampleSize: number
    /** Number of channels (1-mono, 2-stereo, ...). (unsigned int) */
    channels: number
  }
  /** Sound */
  export interface Sound {
    /** Audio stream. (AudioStream) */
    stream: AudioStream
    /** Total number of frames (considering channels). (unsigned int) */
    frameCount: number
  }
  /** Music, audio stream, anything longer than ~10 seconds should be streamed */
  export interface Music {
    /** Audio stream. (AudioStream) */
    stream: AudioStream
    /** Total number of frames (considering channels). (unsigned int) */
    frameCount: number
    /** Music looping enable. (bool) */
    looping: boolean
    /** Type of music context (audio filetype). (int) */
    ctxType: number
    /** Audio context data, depends on type. (void *) */
    ctxData: number
  }
  /** VrDeviceInfo, Head-Mounted-Display device parameters */
  export interface VrDeviceInfo {
    /** Horizontal resolution in pixels. (int) */
    hResolution: number
    /** Vertical resolution in pixels. (int) */
    vResolution: number
    /** Horizontal size in meters. (float) */
    hScreenSize: number
    /** Vertical size in meters. (float) */
    vScreenSize: number
    /** Screen center in meters. (float) */
    vScreenCenter: number
    /** Distance between eye and display in meters. (float) */
    eyeToScreenDistance: number
    /** Lens separation distance in meters. (float) */
    lensSeparationDistance: number
    /** IPD (distance between pupils) in meters. (float) */
    interpupillaryDistance: number
    /** Lens distortion constant parameters. (float[4]) */
    lensDistortionValues: number
    /** Chromatic aberration correction parameters. (float[4]) */
    chromaAbCorrection: number
  }
  /** VrStereoConfig, VR stereo rendering configuration for simulator */
  export interface VrStereoConfig {
    /** VR projection matrices (per eye). (Matrix[2]) */
    projection: number
    /** VR view offset matrices (per eye). (Matrix[2]) */
    viewOffset: number
    /** VR left lens center. (float[2]) */
    leftLensCenter: number
    /** VR right lens center. (float[2]) */
    rightLensCenter: number
    /** VR left screen center. (float[2]) */
    leftScreenCenter: number
    /** VR right screen center. (float[2]) */
    rightScreenCenter: number
    /** VR distortion scale. (float[2]) */
    scale: number
    /** VR distortion scale in. (float[2]) */
    scaleIn: number
  }
  /** File path list */
  export interface FilePathList {
    /** Filepaths max entries. (unsigned int) */
    capacity: number
    /** Filepaths entries count. (unsigned int) */
    count: number
    /** Filepaths entries. (char **) */
    paths: number
  }
  /** Dynamic vertex buffers (position + texcoords + colors + indices arrays) */
  export interface rlVertexBuffer {
    /** Number of elements in the buffer (QUADS). (int) */
    elementCount: number
    /** Vertex position (XYZ - 3 components per vertex) (shader-location = 0). (float *) */
    vertices: number
    /** Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1). (float *) */
    texcoords: number
    /** Vertex colors (RGBA - 4 components per vertex) (shader-location = 3). (unsigned char *) */
    colors: Buffer
    /** Vertex indices (in case vertex data comes indexed) (6 indices per quad). (unsigned int *) */
    indices: number
    /** OpenGL Vertex Array Object id. (unsigned int) */
    vaoId: number
    /** OpenGL Vertex Buffer Objects id (4 types of vertex data). (unsigned int[4]) */
    vboId: number
  }
  /** of those state-change happens (this is done in core module) */
  export interface rlDrawCall {
    /** Drawing mode: LINES, TRIANGLES, QUADS. (int) */
    mode: number
    /** Number of vertex of the draw. (int) */
    vertexCount: number
    /** Number of vertex required for index alignment (LINES, TRIANGLES). (int) */
    vertexAlignment: number
    /** Texture id to be used on the draw -> Use to create new draw call if changes. (unsigned int) */
    textureId: number
  }
  /** rlRenderBatch type */
  export interface rlRenderBatch {
    /** Number of vertex buffers (multi-buffering support). (int) */
    bufferCount: number
    /** Current buffer tracking in case of multi-buffering. (int) */
    currentBuffer: number
    /** Dynamic buffer(s) for vertex data. (rlVertexBuffer *) */
    vertexBuffer: number
    /** Draw calls array, depends on textureId. (rlDrawCall *) */
    draws: number
    /** Draw calls counter. (int) */
    drawCounter: number
    /** Current depth value for next draw. (float) */
    currentDepth: number
  }

  /** RenderTexture, fbo for texture rendering */
  export type RenderTexture2D = RenderTexture

  /** Texture, tex data stored in GPU memory (VRAM) */
  export type Texture2D = Texture

  /** Texture, tex data stored in GPU memory (VRAM) */
  export type TextureCubemap = Texture

  /** Camera, defines position/orientation in 3d space */
  export type Camera = Camera3D | Camera2D

  /** Quaternion, same as Vector4 */
  export type Quaternion = Vector4
  /** Initialize window and OpenGL context */
  export function InitWindow(width: number, height: number, title: string): void
  
  /** Check if KEY_ESCAPE pressed or Close icon pressed */
  export function WindowShouldClose(): boolean
  
  /** Close window and unload OpenGL context */
  export function CloseWindow(): void
  
  /** Check if window has been initialized successfully */
  export function IsWindowReady(): boolean
  
  /** Check if window is currently fullscreen */
  export function IsWindowFullscreen(): boolean
  
  /** Check if window is currently hidden (only PLATFORM_DESKTOP) */
  export function IsWindowHidden(): boolean
  
  /** Check if window is currently minimized (only PLATFORM_DESKTOP) */
  export function IsWindowMinimized(): boolean
  
  /** Check if window is currently maximized (only PLATFORM_DESKTOP) */
  export function IsWindowMaximized(): boolean
  
  /** Check if window is currently focused (only PLATFORM_DESKTOP) */
  export function IsWindowFocused(): boolean
  
  /** Check if window has been resized last frame */
  export function IsWindowResized(): boolean
  
  /** Check if one specific window flag is enabled */
  export function IsWindowState(flag: number): boolean
  
  /** Set window configuration state using flags (only PLATFORM_DESKTOP) */
  export function SetWindowState(flags: number): void
  
  /** Clear window configuration state flags */
  export function ClearWindowState(flags: number): void
  
  /** Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) */
  export function ToggleFullscreen(): void
  
  /** Set window state: maximized, if resizable (only PLATFORM_DESKTOP) */
  export function MaximizeWindow(): void
  
  /** Set window state: minimized, if resizable (only PLATFORM_DESKTOP) */
  export function MinimizeWindow(): void
  
  /** Set window state: not minimized/maximized (only PLATFORM_DESKTOP) */
  export function RestoreWindow(): void
  
  /** Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) */
  export function SetWindowIcon(image: Image): void
  
  /** Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) */
  export function SetWindowIcons(images: number, count: number): void
  
  /** Set title for window (only PLATFORM_DESKTOP) */
  export function SetWindowTitle(title: string): void
  
  /** Set window position on screen (only PLATFORM_DESKTOP) */
  export function SetWindowPosition(x: number, y: number): void
  
  /** Set monitor for the current window (fullscreen mode) */
  export function SetWindowMonitor(monitor: number): void
  
  /** Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) */
  export function SetWindowMinSize(width: number, height: number): void
  
  /** Set window dimensions */
  export function SetWindowSize(width: number, height: number): void
  
  /** Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) */
  export function SetWindowOpacity(opacity: number): void
  
  /** Get native window handle */
  export function GetWindowHandle(): number
  
  /** Get current screen width */
  export function GetScreenWidth(): number
  
  /** Get current screen height */
  export function GetScreenHeight(): number
  
  /** Get current render width (it considers HiDPI) */
  export function GetRenderWidth(): number
  
  /** Get current render height (it considers HiDPI) */
  export function GetRenderHeight(): number
  
  /** Get number of connected monitors */
  export function GetMonitorCount(): number
  
  /** Get current connected monitor */
  export function GetCurrentMonitor(): number
  
  /** Get specified monitor position */
  export function GetMonitorPosition(monitor: number): Vector2
  
  /** Get specified monitor width (current video mode used by monitor) */
  export function GetMonitorWidth(monitor: number): number
  
  /** Get specified monitor height (current video mode used by monitor) */
  export function GetMonitorHeight(monitor: number): number
  
  /** Get specified monitor physical width in millimetres */
  export function GetMonitorPhysicalWidth(monitor: number): number
  
  /** Get specified monitor physical height in millimetres */
  export function GetMonitorPhysicalHeight(monitor: number): number
  
  /** Get specified monitor refresh rate */
  export function GetMonitorRefreshRate(monitor: number): number
  
  /** Get window position XY on monitor */
  export function GetWindowPosition(): Vector2
  
  /** Get window scale DPI factor */
  export function GetWindowScaleDPI(): Vector2
  
  /** Get the human-readable, UTF-8 encoded name of the primary monitor */
  export function GetMonitorName(monitor: number): string
  
  /** Set clipboard text content */
  export function SetClipboardText(text: string): void
  
  /** Get clipboard text content */
  export function GetClipboardText(): string
  
  /** Enable waiting for events on EndDrawing(), no automatic event polling */
  export function EnableEventWaiting(): void
  
  /** Disable waiting for events on EndDrawing(), automatic events polling */
  export function DisableEventWaiting(): void
  
  /** Swap back buffer with front buffer (screen drawing) */
  export function SwapScreenBuffer(): void
  
  /** Register all input events */
  export function PollInputEvents(): void
  
  /** Wait for some time (halt program execution) */
  export function WaitTime(seconds: number): void
  
  /** Shows cursor */
  export function ShowCursor(): void
  
  /** Hides cursor */
  export function HideCursor(): void
  
  /** Check if cursor is not visible */
  export function IsCursorHidden(): boolean
  
  /** Enables cursor (unlock cursor) */
  export function EnableCursor(): void
  
  /** Disables cursor (lock cursor) */
  export function DisableCursor(): void
  
  /** Check if cursor is on the screen */
  export function IsCursorOnScreen(): boolean
  
  /** Set background color (framebuffer clear color) */
  export function ClearBackground(color: Color): void
  
  /** Setup canvas (framebuffer) to start drawing */
  export function BeginDrawing(): void
  
  /** End canvas drawing and swap buffers (double buffering) */
  export function EndDrawing(): void
  
  /** Begin 2D mode with custom camera (2D) */
  export function BeginMode2D(camera: Camera2D): void
  
  /** Ends 2D mode with custom camera */
  export function EndMode2D(): void
  
  /** Begin 3D mode with custom camera (3D) */
  export function BeginMode3D(camera: Camera3D): void
  
  /** Ends 3D mode and returns to default 2D orthographic mode */
  export function EndMode3D(): void
  
  /** Begin drawing to render texture */
  export function BeginTextureMode(target: RenderTexture): void
  
  /** Ends drawing to render texture */
  export function EndTextureMode(): void
  
  /** Begin custom shader drawing */
  export function BeginShaderMode(shader: Shader): void
  
  /** End custom shader drawing (use default shader) */
  export function EndShaderMode(): void
  
  /** Begin blending mode (alpha, additive, multiplied, subtract, custom) */
  export function BeginBlendMode(mode: number): void
  
  /** End blending mode (reset to default: alpha blending) */
  export function EndBlendMode(): void
  
  /** Begin scissor mode (define screen area for following drawing) */
  export function BeginScissorMode(x: number, y: number, width: number, height: number): void
  
  /** End scissor mode */
  export function EndScissorMode(): void
  
  /** End stereo rendering (requires VR simulator) */
  export function EndVrStereoMode(): void
  
  /** Load shader from files and bind default locations */
  export function LoadShader(vsFileName: string, fsFileName: string): Shader
  
  /** Load shader from code strings and bind default locations */
  export function LoadShaderFromMemory(vsCode: string, fsCode: string): Shader
  
  /** Check if a shader is ready */
  export function IsShaderReady(shader: Shader): boolean
  
  /** Get shader uniform location */
  export function GetShaderLocation(shader: Shader, uniformName: string): number
  
  /** Get shader attribute location */
  export function GetShaderLocationAttrib(shader: Shader, attribName: string): number
  
  /** Set shader uniform value (matrix 4x4) */
  export function SetShaderValueMatrix(shader: Shader, locIndex: number, mat: Matrix): void
  
  /** Set shader uniform value for texture (sampler2d) */
  export function SetShaderValueTexture(shader: Shader, locIndex: number, texture: Texture): void
  
  /** Unload shader from GPU memory (VRAM) */
  export function UnloadShader(shader: Shader): void
  
  /** Get a ray trace from mouse position */
  export function GetMouseRay(mousePosition: Vector2, camera: Camera3D): Ray
  
  /** Get camera transform matrix (view matrix) */
  export function GetCameraMatrix(camera: Camera3D): Matrix
  
  /** Get camera 2d transform matrix */
  export function GetCameraMatrix2D(camera: Camera2D): Matrix
  
  /** Get the screen space position for a 3d world space position */
  export function GetWorldToScreen(position: Vector3, camera: Camera3D): Vector2
  
  /** Get the world space position for a 2d camera screen space position */
  export function GetScreenToWorld2D(position: Vector2, camera: Camera2D): Vector2
  
  /** Get size position for a 3d world space position */
  export function GetWorldToScreenEx(position: Vector3, camera: Camera3D, width: number, height: number): Vector2
  
  /** Get the screen space position for a 2d camera world space position */
  export function GetWorldToScreen2D(position: Vector2, camera: Camera2D): Vector2
  
  /** Set target FPS (maximum) */
  export function SetTargetFPS(fps: number): void
  
  /** Get current FPS */
  export function GetFPS(): number
  
  /** Get time in seconds for last frame drawn (delta time) */
  export function GetFrameTime(): number
  
  /** Get elapsed time in seconds since InitWindow() */
  export function GetTime(): number
  
  /** Get a random value between min and max (both included) */
  export function GetRandomValue(min: number, max: number): number
  
  /** Set the seed for the random number generator */
  export function SetRandomSeed(seed: number): void
  
  /** Takes a screenshot of current screen (filename extension defines format) */
  export function TakeScreenshot(fileName: string): void
  
  /** Setup init configuration flags (view FLAGS) */
  export function SetConfigFlags(flags: number): void
  
  /** Set the current threshold (minimum) log level */
  export function SetTraceLogLevel(logLevel: number): void
  
  /** Internal memory allocator */
  export function MemAlloc(size: number): number
  
  /** Internal memory reallocator */
  export function MemRealloc(ptr: number, size: number): number
  
  /** Internal memory free */
  export function MemFree(ptr: number): void
  
  /** Open URL with default system browser (if available) */
  export function OpenURL(url: string): void
  
  /** Load file data as byte array (read) */
  export function LoadFileData(fileName: string, bytesRead: number): Buffer
  
  /** Unload file data allocated by LoadFileData() */
  export function UnloadFileData(data: Buffer): void
  
  /** Save data to file from byte array (write), returns true on success */
  export function SaveFileData(fileName: string, data: number, bytesToWrite: number): boolean
  
  /** Export data to code (.h), returns true on success */
  export function ExportDataAsCode(data: Buffer, size: number, fileName: string): boolean
  
  /** Load text data from file (read), returns a '\0' terminated string */
  export function LoadFileText(fileName: string): string
  
  /** Unload file text data allocated by LoadFileText() */
  export function UnloadFileText(text: string): void
  
  /** Save text data to file (write), string must be '\0' terminated, returns true on success */
  export function SaveFileText(fileName: string, text: string): boolean
  
  /** Check if file exists */
  export function FileExists(fileName: string): boolean
  
  /** Check if a directory path exists */
  export function DirectoryExists(dirPath: string): boolean
  
  /** Check file extension (including point: .png, .wav) */
  export function IsFileExtension(fileName: string, ext: string): boolean
  
  /** Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) */
  export function GetFileLength(fileName: string): number
  
  /** Get pointer to extension for a filename string (includes dot: '.png') */
  export function GetFileExtension(fileName: string): string
  
  /** Get pointer to filename for a path string */
  export function GetFileName(filePath: string): string
  
  /** Get filename string without extension (uses static string) */
  export function GetFileNameWithoutExt(filePath: string): string
  
  /** Get full path for a given fileName with path (uses static string) */
  export function GetDirectoryPath(filePath: string): string
  
  /** Get previous directory path for a given path (uses static string) */
  export function GetPrevDirectoryPath(dirPath: string): string
  
  /** Get current working directory (uses static string) */
  export function GetWorkingDirectory(): string
  
  /** Get the directory if the running application (uses static string) */
  export function GetApplicationDirectory(): string
  
  /** Change working directory, return true on success */
  export function ChangeDirectory(dir: string): boolean
  
  /** Check if a given path is a file or a directory */
  export function IsPathFile(path: string): boolean
  
  /** Load directory filepaths */
  export function LoadDirectoryFiles(dirPath: string): FilePathList
  
  /** Load directory filepaths with extension filtering and recursive directory scan */
  export function LoadDirectoryFilesEx(basePath: string, filter: string, scanSubdirs: boolean): FilePathList
  
  /** Unload filepaths */
  export function UnloadDirectoryFiles(files: FilePathList): void
  
  /** Check if a file has been dropped into window */
  export function IsFileDropped(): boolean
  
  /** Load dropped filepaths */
  export function LoadDroppedFiles(): FilePathList
  
  /** Unload dropped filepaths */
  export function UnloadDroppedFiles(files: FilePathList): void
  
  /** Get file modification time (last write time) */
  export function GetFileModTime(fileName: string): number
  
  /** Compress data (DEFLATE algorithm), memory must be MemFree() */
  export function CompressData(data: Buffer, dataSize: number, compDataSize: number): Buffer
  
  /** Decompress data (DEFLATE algorithm), memory must be MemFree() */
  export function DecompressData(compData: Buffer, compDataSize: number, dataSize: number): Buffer
  
  /** Encode data to Base64 string, memory must be MemFree() */
  export function EncodeDataBase64(data: Buffer, dataSize: number, outputSize: number): string
  
  /** Decode Base64 string data, memory must be MemFree() */
  export function DecodeDataBase64(data: Buffer, outputSize: number): Buffer
  
  /** Check if a key has been pressed once */
  export function IsKeyPressed(key: number): boolean
  
  /** Check if a key is being pressed */
  export function IsKeyDown(key: number): boolean
  
  /** Check if a key has been released once */
  export function IsKeyReleased(key: number): boolean
  
  /** Check if a key is NOT being pressed */
  export function IsKeyUp(key: number): boolean
  
  /** Set a custom key to exit program (default is ESC) */
  export function SetExitKey(key: number): void
  
  /** Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty */
  export function GetKeyPressed(): number
  
  /** Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty */
  export function GetCharPressed(): number
  
  /** Check if a gamepad is available */
  export function IsGamepadAvailable(gamepad: number): boolean
  
  /** Get gamepad internal name id */
  export function GetGamepadName(gamepad: number): string
  
  /** Check if a gamepad button has been pressed once */
  export function IsGamepadButtonPressed(gamepad: number, button: number): boolean
  
  /** Check if a gamepad button is being pressed */
  export function IsGamepadButtonDown(gamepad: number, button: number): boolean
  
  /** Check if a gamepad button has been released once */
  export function IsGamepadButtonReleased(gamepad: number, button: number): boolean
  
  /** Check if a gamepad button is NOT being pressed */
  export function IsGamepadButtonUp(gamepad: number, button: number): boolean
  
  /** Get the last gamepad button pressed */
  export function GetGamepadButtonPressed(): number
  
  /** Get gamepad axis count for a gamepad */
  export function GetGamepadAxisCount(gamepad: number): number
  
  /** Get axis movement value for a gamepad axis */
  export function GetGamepadAxisMovement(gamepad: number, axis: number): number
  
  /** Set internal gamepad mappings (SDL_GameControllerDB) */
  export function SetGamepadMappings(mappings: string): number
  
  /** Check if a mouse button has been pressed once */
  export function IsMouseButtonPressed(button: number): boolean
  
  /** Check if a mouse button is being pressed */
  export function IsMouseButtonDown(button: number): boolean
  
  /** Check if a mouse button has been released once */
  export function IsMouseButtonReleased(button: number): boolean
  
  /** Check if a mouse button is NOT being pressed */
  export function IsMouseButtonUp(button: number): boolean
  
  /** Get mouse position X */
  export function GetMouseX(): number
  
  /** Get mouse position Y */
  export function GetMouseY(): number
  
  /** Get mouse position XY */
  export function GetMousePosition(): Vector2
  
  /** Get mouse delta between frames */
  export function GetMouseDelta(): Vector2
  
  /** Set mouse position XY */
  export function SetMousePosition(x: number, y: number): void
  
  /** Set mouse offset */
  export function SetMouseOffset(offsetX: number, offsetY: number): void
  
  /** Set mouse scaling */
  export function SetMouseScale(scaleX: number, scaleY: number): void
  
  /** Get mouse wheel movement for X or Y, whichever is larger */
  export function GetMouseWheelMove(): number
  
  /** Get mouse wheel movement for both X and Y */
  export function GetMouseWheelMoveV(): Vector2
  
  /** Set mouse cursor */
  export function SetMouseCursor(cursor: number): void
  
  /** Get touch position X for touch point 0 (relative to screen size) */
  export function GetTouchX(): number
  
  /** Get touch position Y for touch point 0 (relative to screen size) */
  export function GetTouchY(): number
  
  /** Get touch position XY for a touch point index (relative to screen size) */
  export function GetTouchPosition(index: number): Vector2
  
  /** Get touch point identifier for given index */
  export function GetTouchPointId(index: number): number
  
  /** Get number of touch points */
  export function GetTouchPointCount(): number
  
  /** Enable a set of gestures using flags */
  export function SetGesturesEnabled(flags: number): void
  
  /** Check if a gesture have been detected */
  export function IsGestureDetected(gesture: number): boolean
  
  /** Get latest detected gesture */
  export function GetGestureDetected(): number
  
  /** Get gesture hold time in milliseconds */
  export function GetGestureHoldDuration(): number
  
  /** Get gesture drag vector */
  export function GetGestureDragVector(): Vector2
  
  /** Get gesture drag angle */
  export function GetGestureDragAngle(): number
  
  /** Get gesture pinch delta */
  export function GetGesturePinchVector(): Vector2
  
  /** Get gesture pinch angle */
  export function GetGesturePinchAngle(): number
  
  /** Update camera position for selected mode */
  export function UpdateCamera(camera: Camera3D, mode: number): void
  
  /** Update camera movement/rotation */
  export function UpdateCameraPro(camera: number, movement: Vector3, rotation: Vector3, zoom: number): void
  
  /** Set texture and rectangle to be used on shapes drawing */
  export function SetShapesTexture(texture: Texture, source: Rectangle): void
  
  /** Draw a pixel */
  export function DrawPixel(posX: number, posY: number, color: Color): void
  
  /** Draw a pixel (Vector version) */
  export function DrawPixelV(position: Vector2, color: Color): void
  
  /** Draw a line */
  export function DrawLine(startPosX: number, startPosY: number, endPosX: number, endPosY: number, color: Color): void
  
  /** Draw a line (Vector version) */
  export function DrawLineV(startPos: Vector2, endPos: Vector2, color: Color): void
  
  /** Draw a line defining thickness */
  export function DrawLineEx(startPos: Vector2, endPos: Vector2, thick: number, color: Color): void
  
  /** Draw a line using cubic-bezier curves in-out */
  export function DrawLineBezier(startPos: Vector2, endPos: Vector2, thick: number, color: Color): void
  
  /** Draw line using quadratic bezier curves with a control point */
  export function DrawLineBezierQuad(startPos: Vector2, endPos: Vector2, controlPos: Vector2, thick: number, color: Color): void
  
  /** Draw line using cubic bezier curves with 2 control points */
  export function DrawLineBezierCubic(startPos: Vector2, endPos: Vector2, startControlPos: Vector2, endControlPos: Vector2, thick: number, color: Color): void
  
  /** Draw lines sequence */
  export function DrawLineStrip(points: number, pointCount: number, color: Color): void
  
  /** Draw a color-filled circle */
  export function DrawCircle(centerX: number, centerY: number, radius: number, color: Color): void
  
  /** Draw a piece of a circle */
  export function DrawCircleSector(center: Vector2, radius: number, startAngle: number, endAngle: number, segments: number, color: Color): void
  
  /** Draw circle sector outline */
  export function DrawCircleSectorLines(center: Vector2, radius: number, startAngle: number, endAngle: number, segments: number, color: Color): void
  
  /** Draw a gradient-filled circle */
  export function DrawCircleGradient(centerX: number, centerY: number, radius: number, color1: Color, color2: Color): void
  
  /** Draw a color-filled circle (Vector version) */
  export function DrawCircleV(center: Vector2, radius: number, color: Color): void
  
  /** Draw circle outline */
  export function DrawCircleLines(centerX: number, centerY: number, radius: number, color: Color): void
  
  /** Draw ellipse */
  export function DrawEllipse(centerX: number, centerY: number, radiusH: number, radiusV: number, color: Color): void
  
  /** Draw ellipse outline */
  export function DrawEllipseLines(centerX: number, centerY: number, radiusH: number, radiusV: number, color: Color): void
  
  /** Draw ring */
  export function DrawRing(center: Vector2, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, segments: number, color: Color): void
  
  /** Draw ring outline */
  export function DrawRingLines(center: Vector2, innerRadius: number, outerRadius: number, startAngle: number, endAngle: number, segments: number, color: Color): void
  
  /** Draw a color-filled rectangle */
  export function DrawRectangle(posX: number, posY: number, width: number, height: number, color: Color): void
  
  /** Draw a color-filled rectangle (Vector version) */
  export function DrawRectangleV(position: Vector2, size: Vector2, color: Color): void
  
  /** Draw a color-filled rectangle */
  export function DrawRectangleRec(rec: Rectangle, color: Color): void
  
  /** Draw a color-filled rectangle with pro parameters */
  export function DrawRectanglePro(rec: Rectangle, origin: Vector2, rotation: number, color: Color): void
  
  /** Draw a vertical-gradient-filled rectangle */
  export function DrawRectangleGradientV(posX: number, posY: number, width: number, height: number, color1: Color, color2: Color): void
  
  /** Draw a horizontal-gradient-filled rectangle */
  export function DrawRectangleGradientH(posX: number, posY: number, width: number, height: number, color1: Color, color2: Color): void
  
  /** Draw a gradient-filled rectangle with custom vertex colors */
  export function DrawRectangleGradientEx(rec: Rectangle, col1: Color, col2: Color, col3: Color, col4: Color): void
  
  /** Draw rectangle outline */
  export function DrawRectangleLines(posX: number, posY: number, width: number, height: number, color: Color): void
  
  /** Draw rectangle outline with extended parameters */
  export function DrawRectangleLinesEx(rec: Rectangle, lineThick: number, color: Color): void
  
  /** Draw rectangle with rounded edges */
  export function DrawRectangleRounded(rec: Rectangle, roundness: number, segments: number, color: Color): void
  
  /** Draw rectangle with rounded edges outline */
  export function DrawRectangleRoundedLines(rec: Rectangle, roundness: number, segments: number, lineThick: number, color: Color): void
  
  /** Draw a color-filled triangle (vertex in counter-clockwise order!) */
  export function DrawTriangle(v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void
  
  /** Draw triangle outline (vertex in counter-clockwise order!) */
  export function DrawTriangleLines(v1: Vector2, v2: Vector2, v3: Vector2, color: Color): void
  
  /** Draw a triangle fan defined by points (first vertex is the center) */
  export function DrawTriangleFan(points: number, pointCount: number, color: Color): void
  
  /** Draw a triangle strip defined by points */
  export function DrawTriangleStrip(points: number, pointCount: number, color: Color): void
  
  /** Draw a regular polygon (Vector version) */
  export function DrawPoly(center: Vector2, sides: number, radius: number, rotation: number, color: Color): void
  
  /** Draw a polygon outline of n sides */
  export function DrawPolyLines(center: Vector2, sides: number, radius: number, rotation: number, color: Color): void
  
  /** Draw a polygon outline of n sides with extended parameters */
  export function DrawPolyLinesEx(center: Vector2, sides: number, radius: number, rotation: number, lineThick: number, color: Color): void
  
  /** Check collision between two rectangles */
  export function CheckCollisionRecs(rec1: Rectangle, rec2: Rectangle): boolean
  
  /** Check collision between two circles */
  export function CheckCollisionCircles(center1: Vector2, radius1: number, center2: Vector2, radius2: number): boolean
  
  /** Check collision between circle and rectangle */
  export function CheckCollisionCircleRec(center: Vector2, radius: number, rec: Rectangle): boolean
  
  /** Check if point is inside rectangle */
  export function CheckCollisionPointRec(point: Vector2, rec: Rectangle): boolean
  
  /** Check if point is inside circle */
  export function CheckCollisionPointCircle(point: Vector2, center: Vector2, radius: number): boolean
  
  /** Check if point is inside a triangle */
  export function CheckCollisionPointTriangle(point: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): boolean
  
  /** Check if point is within a polygon described by array of vertices */
  export function CheckCollisionPointPoly(point: Vector2, points: number, pointCount: number): boolean
  
  /** Check the collision between two lines defined by two points each, returns collision point by reference */
  export function CheckCollisionLines(startPos1: Vector2, endPos1: Vector2, startPos2: Vector2, endPos2: Vector2, collisionPoint: number): boolean
  
  /** Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] */
  export function CheckCollisionPointLine(point: Vector2, p1: Vector2, p2: Vector2, threshold: number): boolean
  
  /** Get collision rectangle for two rectangles collision */
  export function GetCollisionRec(rec1: Rectangle, rec2: Rectangle): Rectangle
  
  /** Load image from file into CPU memory (RAM) */
  export function LoadImage(fileName: string): Image
  
  /** Load image from RAW file data */
  export function LoadImageRaw(fileName: string, width: number, height: number, format: number, headerSize: number): Image
  
  /** Load image sequence from file (frames appended to image.data) */
  export function LoadImageAnim(fileName: string, frames: number): Image
  
  /** Load image from memory buffer, fileType refers to extension: i.e. '.png' */
  export function LoadImageFromMemory(fileType: string, fileData: Buffer, dataSize: number): Image
  
  /** Load image from GPU texture data */
  export function LoadImageFromTexture(texture: Texture): Image
  
  /** Load image from screen buffer and (screenshot) */
  export function LoadImageFromScreen(): Image
  
  /** Check if an image is ready */
  export function IsImageReady(image: Image): boolean
  
  /** Unload image from CPU memory (RAM) */
  export function UnloadImage(image: Image): void
  
  /** Export image data to file, returns true on success */
  export function ExportImage(image: Image, fileName: string): boolean
  
  /** Export image as code file defining an array of bytes, returns true on success */
  export function ExportImageAsCode(image: Image, fileName: string): boolean
  
  /** Generate image: plain color */
  export function GenImageColor(width: number, height: number, color: Color): Image
  
  /** Generate image: vertical gradient */
  export function GenImageGradientV(width: number, height: number, top: Color, bottom: Color): Image
  
  /** Generate image: horizontal gradient */
  export function GenImageGradientH(width: number, height: number, left: Color, right: Color): Image
  
  /** Generate image: radial gradient */
  export function GenImageGradientRadial(width: number, height: number, density: number, inner: Color, outer: Color): Image
  
  /** Generate image: checked */
  export function GenImageChecked(width: number, height: number, checksX: number, checksY: number, col1: Color, col2: Color): Image
  
  /** Generate image: white noise */
  export function GenImageWhiteNoise(width: number, height: number, factor: number): Image
  
  /** Generate image: perlin noise */
  export function GenImagePerlinNoise(width: number, height: number, offsetX: number, offsetY: number, scale: number): Image
  
  /** Generate image: cellular algorithm, bigger tileSize means bigger cells */
  export function GenImageCellular(width: number, height: number, tileSize: number): Image
  
  /** Generate image: grayscale image from text data */
  export function GenImageText(width: number, height: number, text: string): Image
  
  /** Create an image duplicate (useful for transformations) */
  export function ImageCopy(image: Image): Image
  
  /** Create an image from another image piece */
  export function ImageFromImage(image: Image, rec: Rectangle): Image
  
  /** Create an image from text (default font) */
  export function ImageText(text: string, fontSize: number, color: Color): Image
  
  /** Create an image from text (custom sprite font) */
  export function ImageTextEx(font: Font, text: string, fontSize: number, spacing: number, tint: Color): Image
  
  /** Convert image data to desired format */
  export function ImageFormat(image: Image, newFormat: number): void
  
  /** Convert image to POT (power-of-two) */
  export function ImageToPOT(image: Image, fill: Color): void
  
  /** Crop an image to a defined rectangle */
  export function ImageCrop(image: Image, crop: Rectangle): void
  
  /** Crop image depending on alpha value */
  export function ImageAlphaCrop(image: Image, threshold: number): void
  
  /** Clear alpha channel to desired color */
  export function ImageAlphaClear(image: Image, color: Color, threshold: number): void
  
  /** Apply alpha mask to image */
  export function ImageAlphaMask(image: Image, alphaMask: Image): void
  
  /** Premultiply alpha channel */
  export function ImageAlphaPremultiply(image: Image): void
  
  /** Apply Gaussian blur using a box blur approximation */
  export function ImageBlurGaussian(image: number, blurSize: number): void
  
  /** Resize image (Bicubic scaling algorithm) */
  export function ImageResize(image: Image, newWidth: number, newHeight: number): void
  
  /** Resize image (Nearest-Neighbor scaling algorithm) */
  export function ImageResizeNN(image: Image, newWidth: number, newHeight: number): void
  
  /** Resize canvas and fill with color */
  export function ImageResizeCanvas(image: Image, newWidth: number, newHeight: number, offsetX: number, offsetY: number, fill: Color): void
  
  /** Compute all mipmap levels for a provided image */
  export function ImageMipmaps(image: Image): void
  
  /** Dither image data to 16bpp or lower (Floyd-Steinberg dithering) */
  export function ImageDither(image: Image, rBpp: number, gBpp: number, bBpp: number, aBpp: number): void
  
  /** Flip image vertically */
  export function ImageFlipVertical(image: Image): void
  
  /** Flip image horizontally */
  export function ImageFlipHorizontal(image: Image): void
  
  /** Rotate image clockwise 90deg */
  export function ImageRotateCW(image: Image): void
  
  /** Rotate image counter-clockwise 90deg */
  export function ImageRotateCCW(image: Image): void
  
  /** Modify image color: tint */
  export function ImageColorTint(image: Image, color: Color): void
  
  /** Modify image color: invert */
  export function ImageColorInvert(image: Image): void
  
  /** Modify image color: grayscale */
  export function ImageColorGrayscale(image: Image): void
  
  /** Modify image color: contrast (-100 to 100) */
  export function ImageColorContrast(image: Image, contrast: number): void