declare module 'picogl' {
  enum GL {
    DEPTH_BUFFER_BIT = 0x00000100,
    STENCIL_BUFFER_BIT = 0x00000400,
    COLOR_BUFFER_BIT = 0x00004000,
    POINTS = 0x0000,
    LINES = 0x0001,
    LINE_LOOP = 0x0002,
    LINE_STRIP = 0x0003,
    TRIANGLES = 0x0004,
    TRIANGLE_STRIP = 0x0005,
    TRIANGLE_FAN = 0x0006,
    ZERO = 0,
    ONE = 1,
    SRC_COLOR = 0x0300,
    ONE_MINUS_SRC_COLOR = 0x0301,
    SRC_ALPHA = 0x0302,
    ONE_MINUS_SRC_ALPHA = 0x0303,
    DST_ALPHA = 0x0304,
    ONE_MINUS_DST_ALPHA = 0x0305,
    DST_COLOR = 0x0306,
    ONE_MINUS_DST_COLOR = 0x0307,
    SRC_ALPHA_SATURATE = 0x0308,
    FUNC_ADD = 0x8006,
    BLEND_EQUATION = 0x8009,
    BLEND_EQUATION_RGB = 0x8009,
    BLEND_EQUATION_ALPHA = 0x883d,
    FUNC_SUBTRACT = 0x800a,
    FUNC_REVERSE_SUBTRACT = 0x800b,
    BLEND_DST_RGB = 0x80c8,
    BLEND_SRC_RGB = 0x80c9,
    BLEND_DST_ALPHA = 0x80ca,
    BLEND_SRC_ALPHA = 0x80cb,
    CONSTANT_COLOR = 0x8001,
    ONE_MINUS_CONSTANT_COLOR = 0x8002,
    CONSTANT_ALPHA = 0x8003,
    ONE_MINUS_CONSTANT_ALPHA = 0x8004,
    BLEND_COLOR = 0x8005,
    ARRAY_BUFFER = 0x8892,
    ELEMENT_ARRAY_BUFFER = 0x8893,
    ARRAY_BUFFER_BINDING = 0x8894,
    ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
    STREAM_DRAW = 0x88e0,
    STATIC_DRAW = 0x88e4,
    DYNAMIC_DRAW = 0x88e8,
    BUFFER_SIZE = 0x8764,
    BUFFER_USAGE = 0x8765,
    CURRENT_VERTEX_ATTRIB = 0x8626,
    FRONT = 0x0404,
    BACK = 0x0405,
    FRONT_AND_BACK = 0x0408,
    CULL_FACE = 0x0b44,
    BLEND = 0x0be2,
    DITHER = 0x0bd0,
    STENCIL_TEST = 0x0b90,
    DEPTH_TEST = 0x0b71,
    SCISSOR_TEST = 0x0c11,
    POLYGON_OFFSET_FILL = 0x8037,
    SAMPLE_ALPHA_TO_COVERAGE = 0x809e,
    SAMPLE_COVERAGE = 0x80a0,
    NO_ERROR = 0,
    INVALID_ENUM = 0x0500,
    INVALID_VALUE = 0x0501,
    INVALID_OPERATION = 0x0502,
    OUT_OF_MEMORY = 0x0505,
    CW = 0x0900,
    CCW = 0x0901,
    LINE_WIDTH = 0x0b21,
    ALIASED_POINT_SIZE_RANGE = 0x846d,
    ALIASED_LINE_WIDTH_RANGE = 0x846e,
    CULL_FACE_MODE = 0x0b45,
    FRONT_FACE = 0x0b46,
    DEPTH_RANGE = 0x0b70,
    DEPTH_WRITEMASK = 0x0b72,
    DEPTH_CLEAR_VALUE = 0x0b73,
    DEPTH_FUNC = 0x0b74,
    STENCIL_CLEAR_VALUE = 0x0b91,
    STENCIL_FUNC = 0x0b92,
    STENCIL_FAIL = 0x0b94,
    STENCIL_PASS_DEPTH_FAIL = 0x0b95,
    STENCIL_PASS_DEPTH_PASS = 0x0b96,
    STENCIL_REF = 0x0b97,
    STENCIL_VALUE_MASK = 0x0b93,
    STENCIL_WRITEMASK = 0x0b98,
    STENCIL_BACK_FUNC = 0x8800,
    STENCIL_BACK_FAIL = 0x8801,
    STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
    STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
    STENCIL_BACK_REF = 0x8ca3,
    STENCIL_BACK_VALUE_MASK = 0x8ca4,
    STENCIL_BACK_WRITEMASK = 0x8ca5,
    VIEWPORT = 0x0ba2,
    SCISSOR_BOX = 0x0c10,
    COLOR_CLEAR_VALUE = 0x0c22,
    COLOR_WRITEMASK = 0x0c23,
    UNPACK_ALIGNMENT = 0x0cf5,
    PACK_ALIGNMENT = 0x0d05,
    MAX_TEXTURE_SIZE = 0x0d33,
    MAX_VIEWPORT_DIMS = 0x0d3a,
    SUBPIXEL_BITS = 0x0d50,
    RED_BITS = 0x0d52,
    GREEN_BITS = 0x0d53,
    BLUE_BITS = 0x0d54,
    ALPHA_BITS = 0x0d55,
    DEPTH_BITS = 0x0d56,
    STENCIL_BITS = 0x0d57,
    POLYGON_OFFSET_UNITS = 0x2a00,
    POLYGON_OFFSET_FACTOR = 0x8038,
    TEXTURE_BINDING_2D = 0x8069,
    SAMPLE_BUFFERS = 0x80a8,
    SAMPLES = 0x80a9,
    SAMPLE_COVERAGE_VALUE = 0x80aa,
    SAMPLE_COVERAGE_INVERT = 0x80ab,
    COMPRESSED_TEXTURE_FORMATS = 0x86a3,
    DONT_CARE = 0x1100,
    FASTEST = 0x1101,
    NICEST = 0x1102,
    GENERATE_MIPMAP_HINT = 0x8192,
    BYTE = 0x1400,
    UNSIGNED_BYTE = 0x1401,
    SHORT = 0x1402,
    UNSIGNED_SHORT = 0x1403,
    INT = 0x1404,
    UNSIGNED_INT = 0x1405,
    FLOAT = 0x1406,
    DEPTH_COMPONENT = 0x1902,
    ALPHA = 0x1906,
    RGB = 0x1907,
    RGBA = 0x1908,
    LUMINANCE = 0x1909,
    LUMINANCE_ALPHA = 0x190a,
    UNSIGNED_SHORT_4_4_4_4 = 0x8033,
    UNSIGNED_SHORT_5_5_5_1 = 0x8034,
    UNSIGNED_SHORT_5_6_5 = 0x8363,
    FRAGMENT_SHADER = 0x8b30,
    VERTEX_SHADER = 0x8b31,
    MAX_VERTEX_ATTRIBS = 0x8869,
    MAX_VERTEX_UNIFORM_VECTORS = 0x8dfb,
    MAX_VARYING_VECTORS = 0x8dfc,
    MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8b4d,
    MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8b4c,
    MAX_TEXTURE_IMAGE_UNITS = 0x8872,
    MAX_FRAGMENT_UNIFORM_VECTORS = 0x8dfd,
    SHADER_TYPE = 0x8b4f,
    DELETE_STATUS = 0x8b80,
    LINK_STATUS = 0x8b82,
    VALIDATE_STATUS = 0x8b83,
    ATTACHED_SHADERS = 0x8b85,
    ACTIVE_UNIFORMS = 0x8b86,
    ACTIVE_ATTRIBUTES = 0x8b89,
    SHADING_LANGUAGE_VERSION = 0x8b8c,
    CURRENT_PROGRAM = 0x8b8d,
    NEVER = 0x0200,
    LESS = 0x0201,
    EQUAL = 0x0202,
    LEQUAL = 0x0203,
    GREATER = 0x0204,
    NOTEQUAL = 0x0205,
    GEQUAL = 0x0206,
    ALWAYS = 0x0207,
    KEEP = 0x1e00,
    REPLACE = 0x1e01,
    INCR = 0x1e02,
    DECR = 0x1e03,
    INVERT = 0x150a,
    INCR_WRAP = 0x8507,
    DECR_WRAP = 0x8508,
    VENDOR = 0x1f00,
    RENDERER = 0x1f01,
    VERSION = 0x1f02,
    NEAREST = 0x2600,
    LINEAR = 0x2601,
    NEAREST_MIPMAP_NEAREST = 0x2700,
    LINEAR_MIPMAP_NEAREST = 0x2701,
    NEAREST_MIPMAP_LINEAR = 0x2702,
    LINEAR_MIPMAP_LINEAR = 0x2703,
    TEXTURE_MAG_FILTER = 0x2800,
    TEXTURE_MIN_FILTER = 0x2801,
    TEXTURE_WRAP_S = 0x2802,
    TEXTURE_WRAP_T = 0x2803,
    TEXTURE_2D = 0x0de1,
    TEXTURE = 0x1702,
    TEXTURE_CUBE_MAP = 0x8513,
    TEXTURE_BINDING_CUBE_MAP = 0x8514,
    TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
    TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
    TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
    TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
    TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
    TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a,
    MAX_CUBE_MAP_TEXTURE_SIZE = 0x851c,
    TEXTURE0 = 0x84c0,
    TEXTURE1 = 0x84c1,
    TEXTURE2 = 0x84c2,
    TEXTURE3 = 0x84c3,
    TEXTURE4 = 0x84c4,
    TEXTURE5 = 0x84c5,
    TEXTURE6 = 0x84c6,
    TEXTURE7 = 0x84c7,
    TEXTURE8 = 0x84c8,
    TEXTURE9 = 0x84c9,
    TEXTURE10 = 0x84ca,
    TEXTURE11 = 0x84cb,
    TEXTURE12 = 0x84cc,
    TEXTURE13 = 0x84cd,
    TEXTURE14 = 0x84ce,
    TEXTURE15 = 0x84cf,
    TEXTURE16 = 0x84d0,
    TEXTURE17 = 0x84d1,
    TEXTURE18 = 0x84d2,
    TEXTURE19 = 0x84d3,
    TEXTURE20 = 0x84d4,
    TEXTURE21 = 0x84d5,
    TEXTURE22 = 0x84d6,
    TEXTURE23 = 0x84d7,
    TEXTURE24 = 0x84d8,
    TEXTURE25 = 0x84d9,
    TEXTURE26 = 0x84da,
    TEXTURE27 = 0x84db,
    TEXTURE28 = 0x84dc,
    TEXTURE29 = 0x84dd,
    TEXTURE30 = 0x84de,
    TEXTURE31 = 0x84df,
    ACTIVE_TEXTURE = 0x84e0,
    REPEAT = 0x2901,
    CLAMP_TO_EDGE = 0x812f,
    MIRRORED_REPEAT = 0x8370,
    FLOAT_VEC2 = 0x8b50,
    FLOAT_VEC3 = 0x8b51,
    FLOAT_VEC4 = 0x8b52,
    INT_VEC2 = 0x8b53,
    INT_VEC3 = 0x8b54,
    INT_VEC4 = 0x8b55,
    BOOL = 0x8b56,
    BOOL_VEC2 = 0x8b57,
    BOOL_VEC3 = 0x8b58,
    BOOL_VEC4 = 0x8b59,
    FLOAT_MAT2 = 0x8b5a,
    FLOAT_MAT3 = 0x8b5b,
    FLOAT_MAT4 = 0x8b5c,
    SAMPLER_2D = 0x8b5e,
    SAMPLER_CUBE = 0x8b60,
    VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
    VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
    VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
    VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
    VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886a,
    VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889f,
    IMPLEMENTATION_COLOR_READ_TYPE = 0x8b9a,
    IMPLEMENTATION_COLOR_READ_FORMAT = 0x8b9b,
    COMPILE_STATUS = 0x8b81,
    LOW_FLOAT = 0x8df0,
    MEDIUM_FLOAT = 0x8df1,
    HIGH_FLOAT = 0x8df2,
    LOW_INT = 0x8df3,
    MEDIUM_INT = 0x8df4,
    HIGH_INT = 0x8df5,
    FRAMEBUFFER = 0x8d40,
    RENDERBUFFER = 0x8d41,
    RGBA4 = 0x8056,
    RGB5_A1 = 0x8057,
    RGB565 = 0x8d62,
    DEPTH_COMPONENT16 = 0x81a5,
    STENCIL_INDEX = 0x1901,
    STENCIL_INDEX8 = 0x8d48,
    DEPTH_STENCIL = 0x84f9,
    RENDERBUFFER_WIDTH = 0x8d42,
    RENDERBUFFER_HEIGHT = 0x8d43,
    RENDERBUFFER_INTERNAL_FORMAT = 0x8d44,
    RENDERBUFFER_RED_SIZE = 0x8d50,
    RENDERBUFFER_GREEN_SIZE = 0x8d51,
    RENDERBUFFER_BLUE_SIZE = 0x8d52,
    RENDERBUFFER_ALPHA_SIZE = 0x8d53,
    RENDERBUFFER_DEPTH_SIZE = 0x8d54,
    RENDERBUFFER_STENCIL_SIZE = 0x8d55,
    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8cd0,
    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8cd1,
    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8cd2,
    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8cd3,
    COLOR_ATTACHMENT0 = 0x8ce0,
    DEPTH_ATTACHMENT = 0x8d00,
    STENCIL_ATTACHMENT = 0x8d20,
    DEPTH_STENCIL_ATTACHMENT = 0x821a,
    NONE = 0,
    FRAMEBUFFER_COMPLETE = 0x8cd5,
    FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8cd6,
    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8cd7,
    FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8cd9,
    FRAMEBUFFER_UNSUPPORTED = 0x8cdd,
    FRAMEBUFFER_BINDING = 0x8ca6,
    RENDERBUFFER_BINDING = 0x8ca7,
    MAX_RENDERBUFFER_SIZE = 0x84e8,
    INVALID_FRAMEBUFFER_OPERATION = 0x0506,
    UNPACK_FLIP_Y_WEBGL = 0x9240,
    UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241,
    CONTEXT_LOST_WEBGL = 0x9242,
    UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243,
    BROWSER_DEFAULT_WEBGL = 0x9244,
    READ_BUFFER = 0x0c02,
    UNPACK_ROW_LENGTH = 0x0cf2,
    UNPACK_SKIP_ROWS = 0x0cf3,
    UNPACK_SKIP_PIXELS = 0x0cf4,
    PACK_ROW_LENGTH = 0x0d02,
    PACK_SKIP_ROWS = 0x0d03,
    PACK_SKIP_PIXELS = 0x0d04,
    COLOR = 0x1800,
    DEPTH = 0x1801,
    STENCIL = 0x1802,
    RED = 0x1903,
    RGB8 = 0x8051,
    RGBA8 = 0x8058,
    RGB10_A2 = 0x8059,
    TEXTURE_BINDING_3D = 0x806a,
    UNPACK_SKIP_IMAGES = 0x806d,
    UNPACK_IMAGE_HEIGHT = 0x806e,
    TEXTURE_3D = 0x806f,
    TEXTURE_WRAP_R = 0x8072,
    MAX_3D_TEXTURE_SIZE = 0x8073,
    UNSIGNED_INT_2_10_10_10_REV = 0x8368,
    MAX_ELEMENTS_VERTICES = 0x80e8,
    MAX_ELEMENTS_INDICES = 0x80e9,
    TEXTURE_MIN_LOD = 0x813a,
    TEXTURE_MAX_LOD = 0x813b,
    TEXTURE_BASE_LEVEL = 0x813c,
    TEXTURE_MAX_LEVEL = 0x813d,
    MIN = 0x8007,
    MAX = 0x8008,
    DEPTH_COMPONENT24 = 0x81a6,
    MAX_TEXTURE_LOD_BIAS = 0x84fd,
    TEXTURE_COMPARE_MODE = 0x884c,
    TEXTURE_COMPARE_FUNC = 0x884d,
    CURRENT_QUERY = 0x8865,
    QUERY_RESULT = 0x8866,
    QUERY_RESULT_AVAILABLE = 0x8867,
    STREAM_READ = 0x88e1,
    STREAM_COPY = 0x88e2,
    STATIC_READ = 0x88e5,
    STATIC_COPY = 0x88e6,
    DYNAMIC_READ = 0x88e9,
    DYNAMIC_COPY = 0x88ea,
    MAX_DRAW_BUFFERS = 0x8824,
    DRAW_BUFFER0 = 0x8825,
    DRAW_BUFFER1 = 0x8826,
    DRAW_BUFFER2 = 0x8827,
    DRAW_BUFFER3 = 0x8828,
    DRAW_BUFFER4 = 0x8829,
    DRAW_BUFFER5 = 0x882a,
    DRAW_BUFFER6 = 0x882b,
    DRAW_BUFFER7 = 0x882c,
    DRAW_BUFFER8 = 0x882d,
    DRAW_BUFFER9 = 0x882e,
    DRAW_BUFFER10 = 0x882f,
    DRAW_BUFFER11 = 0x8830,
    DRAW_BUFFER12 = 0x8831,
    DRAW_BUFFER13 = 0x8832,
    DRAW_BUFFER14 = 0x8833,
    DRAW_BUFFER15 = 0x8834,
    MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8b49,
    MAX_VERTEX_UNIFORM_COMPONENTS = 0x8b4a,
    SAMPLER_3D = 0x8b5f,
    SAMPLER_2D_SHADOW = 0x8b62,
    FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8b8b,
    PIXEL_PACK_BUFFER = 0x88eb,
    PIXEL_UNPACK_BUFFER = 0x88ec,
    PIXEL_PACK_BUFFER_BINDING = 0x88ed,
    PIXEL_UNPACK_BUFFER_BINDING = 0x88ef,
    FLOAT_MAT2x3 = 0x8b65,
    FLOAT_MAT2x4 = 0x8b66,
    FLOAT_MAT3x2 = 0x8b67,
    FLOAT_MAT3x4 = 0x8b68,
    FLOAT_MAT4x2 = 0x8b69,
    FLOAT_MAT4x3 = 0x8b6a,
    SRGB = 0x8c40,
    SRGB8 = 0x8c41,
    SRGB8_ALPHA8 = 0x8c43,
    COMPARE_REF_TO_TEXTURE = 0x884e,
    RGBA32F = 0x8814,
    RGB32F = 0x8815,
    RGBA16F = 0x881a,
    RGB16F = 0x881b,
    VERTEX_ATTRIB_ARRAY_INTEGER = 0x88fd,
    MAX_ARRAY_TEXTURE_LAYERS = 0x88ff,
    MIN_PROGRAM_TEXEL_OFFSET = 0x8904,
    MAX_PROGRAM_TEXEL_OFFSET = 0x8905,
    MAX_VARYING_COMPONENTS = 0x8b4b,
    TEXTURE_2D_ARRAY = 0x8c1a,
    TEXTURE_BINDING_2D_ARRAY = 0x8c1d,
    R11F_G11F_B10F = 0x8c3a,
    UNSIGNED_INT_10F_11F_11F_REV = 0x8c3b,
    RGB9_E5 = 0x8c3d,
    UNSIGNED_INT_5_9_9_9_REV = 0x8c3e,
    TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8c7f,
    MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8c80,
    TRANSFORM_FEEDBACK_VARYINGS = 0x8c83,
    TRANSFORM_FEEDBACK_BUFFER_START = 0x8c84,
    TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8c85,
    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8c88,
    RASTERIZER_DISCARD = 0x8c89,
    MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8c8a,
    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8c8b,
    INTERLEAVED_ATTRIBS = 0x8c8c,
    SEPARATE_ATTRIBS = 0x8c8d,
    TRANSFORM_FEEDBACK_BUFFER = 0x8c8e,
    TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8c8f,
    RGBA32UI = 0x8d70,
    RGB32UI = 0x8d71,
    RGBA16UI = 0x8d76,
    RGB16UI = 0x8d77,
    RGBA8UI = 0x8d7c,
    RGB8UI = 0x8d7d,
    RGBA32I = 0x8d82,
    RGB32I = 0x8d83,
    RGBA16I = 0x8d88,
    RGB16I = 0x8d89,
    RGBA8I = 0x8d8e,
    RGB8I = 0x8d8f,
    RED_INTEGER = 0x8d94,
    RGB_INTEGER = 0x8d98,
    RGBA_INTEGER = 0x8d99,
    SAMPLER_2D_ARRAY = 0x8dc1,
    SAMPLER_2D_ARRAY_SHADOW = 0x8dc4,
    SAMPLER_CUBE_SHADOW = 0x8dc5,
    UNSIGNED_INT_VEC2 = 0x8dc6,
    UNSIGNED_INT_VEC3 = 0x8dc7,
    UNSIGNED_INT_VEC4 = 0x8dc8,
    INT_SAMPLER_2D = 0x8dca,
    INT_SAMPLER_3D = 0x8dcb,
    INT_SAMPLER_CUBE = 0x8dcc,
    INT_SAMPLER_2D_ARRAY = 0x8dcf,
    UNSIGNED_INT_SAMPLER_2D = 0x8dd2,
    UNSIGNED_INT_SAMPLER_3D = 0x8dd3,
    UNSIGNED_INT_SAMPLER_CUBE = 0x8dd4,
    UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8dd7,
    DEPTH_COMPONENT32F = 0x8cac,
    DEPTH32F_STENCIL8 = 0x8cad,
    FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8dad,
    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210,
    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211,
    FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212,
    FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213,
    FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214,
    FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215,
    FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216,
    FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217,
    FRAMEBUFFER_DEFAULT = 0x8218,
    UNSIGNED_INT_24_8 = 0x84fa,
    DEPTH24_STENCIL8 = 0x88f0,
    UNSIGNED_NORMALIZED = 0x8c17,
    DRAW_FRAMEBUFFER_BINDING = 0x8ca6,
    READ_FRAMEBUFFER = 0x8ca8,
    DRAW_FRAMEBUFFER = 0x8ca9,
    READ_FRAMEBUFFER_BINDING = 0x8caa,
    RENDERBUFFER_SAMPLES = 0x8cab,
    FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8cd4,
    MAX_COLOR_ATTACHMENTS = 0x8cdf,
    COLOR_ATTACHMENT1 = 0x8ce1,
    COLOR_ATTACHMENT2 = 0x8ce2,
    COLOR_ATTACHMENT3 = 0x8ce3,
    COLOR_ATTACHMENT4 = 0x8ce4,
    COLOR_ATTACHMENT5 = 0x8ce5,
    COLOR_ATTACHMENT6 = 0x8ce6,
    COLOR_ATTACHMENT7 = 0x8ce7,
    COLOR_ATTACHMENT8 = 0x8ce8,
    COLOR_ATTACHMENT9 = 0x8ce9,
    COLOR_ATTACHMENT10 = 0x8cea,
    COLOR_ATTACHMENT11 = 0x8ceb,
    COLOR_ATTACHMENT12 = 0x8cec,
    COLOR_ATTACHMENT13 = 0x8ced,
    COLOR_ATTACHMENT14 = 0x8cee,
    COLOR_ATTACHMENT15 = 0x8cef,
    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8d56,
    MAX_SAMPLES = 0x8d57,
    HALF_FLOAT = 0x140b,
    RG = 0x8227,
    RG_INTEGER = 0x8228,
    R8 = 0x8229,
    RG8 = 0x822b,
    R16F = 0x822d,
    R32F = 0x822e,
    RG16F = 0x822f,
    RG32F = 0x8230,
    R8I = 0x8231,
    R8UI = 0x8232,
    R16I = 0x8233,
    R16UI = 0x8234,
    R32I = 0x8235,
    R32UI = 0x8236,
    RG8I = 0x8237,
    RG8UI = 0x8238,
    RG16I = 0x8239,
    RG16UI = 0x823a,
    RG32I = 0x823b,
    RG32UI = 0x823c,
    VERTEX_ARRAY_BINDING = 0x85b5,
    R8_SNORM = 0x8f94,
    RG8_SNORM = 0x8f95,
    RGB8_SNORM = 0x8f96,
    RGBA8_SNORM = 0x8f97,
    SIGNED_NORMALIZED = 0x8f9c,
    COPY_READ_BUFFER = 0x8f36,
    COPY_WRITE_BUFFER = 0x8f37,
    COPY_READ_BUFFER_BINDING = 0x8f36,
    COPY_WRITE_BUFFER_BINDING = 0x8f37,
    UNIFORM_BUFFER = 0x8a11,
    UNIFORM_BUFFER_BINDING = 0x8a28,
    UNIFORM_BUFFER_START = 0x8a29,
    UNIFORM_BUFFER_SIZE = 0x8a2a,
    MAX_VERTEX_UNIFORM_BLOCKS = 0x8a2b,
    MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8a2d,
    MAX_COMBINED_UNIFORM_BLOCKS = 0x8a2e,
    MAX_UNIFORM_BUFFER_BINDINGS = 0x8a2f,
    MAX_UNIFORM_BLOCK_SIZE = 0x8a30,
    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8a31,
    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8a33,
    UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8a34,
    ACTIVE_UNIFORM_BLOCKS = 0x8a36,
    UNIFORM_TYPE = 0x8a37,
    UNIFORM_SIZE = 0x8a38,
    UNIFORM_BLOCK_INDEX = 0x8a3a,
    UNIFORM_OFFSET = 0x8a3b,
    UNIFORM_ARRAY_STRIDE = 0x8a3c,
    UNIFORM_MATRIX_STRIDE = 0x8a3d,
    UNIFORM_IS_ROW_MAJOR = 0x8a3e,
    UNIFORM_BLOCK_BINDING = 0x8a3f,
    UNIFORM_BLOCK_DATA_SIZE = 0x8a40,
    UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8a42,
    UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8a43,
    UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8a44,
    UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8a46,
    INVALID_INDEX = 0xffffffff,
    MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122,
    MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125,
    MAX_SERVER_WAIT_TIMEOUT = 0x9111,
    OBJECT_TYPE = 0x9112,
    SYNC_CONDITION = 0x9113,
    SYNC_STATUS = 0x9114,
    SYNC_FLAGS = 0x9115,
    SYNC_FENCE = 0x9116,
    SYNC_GPU_COMMANDS_COMPLETE = 0x9117,
    UNSIGNALED = 0x9118,
    SIGNALED = 0x9119,
    ALREADY_SIGNALED = 0x911a,
    TIMEOUT_EXPIRED = 0x911b,
    CONDITION_SATISFIED = 0x911c,
    WAIT_FAILED = 0x911d,
    SYNC_FLUSH_COMMANDS_BIT = 0x00000001,
    VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88fe,
    ANY_SAMPLES_PASSED = 0x8c2f,
    ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8d6a,
    SAMPLER_BINDING = 0x8919,
    RGB10_A2UI = 0x906f,
    INT_2_10_10_10_REV = 0x8d9f,
    TRANSFORM_FEEDBACK = 0x8e22,
    TRANSFORM_FEEDBACK_PAUSED = 0x8e23,
    TRANSFORM_FEEDBACK_ACTIVE = 0x8e24,
    TRANSFORM_FEEDBACK_BINDING = 0x8e25,
    TEXTURE_IMMUTABLE_FORMAT = 0x912f,
    MAX_ELEMENT_INDEX = 0x8d6b,
    TEXTURE_IMMUTABLE_LEVELS = 0x82df,
    TIMEOUT_IGNORED = -1,
    MAX_CLIENT_WAIT_TIMEOUT_WEBGL = 0x9247,

    QUERY_COUNTER_BITS_EXT = 0x8864,
    TIME_ELAPSED_EXT = 0x88bf,
    TIMESTAMP_EXT = 0x8e28,
    GPU_DISJOINT_EXT = 0x8fbb,

    TEXTURE_MAX_ANISOTROPY_EXT = 0x84fe,
    MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84ff,

    UNMASKED_VENDOR_WEBGL = 0x9245,
    UNMASKED_RENDERER_WEBGL = 0x9246,

    COMPLETION_STATUS_KHR = 0x91b1,

    COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83f0,
    COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83f1,
    COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83f2,
    COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83f3,

    COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8c4c,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8c4d,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8c4e,
    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8c4f,

    COMPRESSED_R11_EAC = 0x9270,
    COMPRESSED_SIGNED_R11_EAC = 0x9271,
    COMPRESSED_RG11_EAC = 0x9272,
    COMPRESSED_SIGNED_RG11_EAC = 0x9273,
    COMPRESSED_RGB8_ETC2 = 0x9274,
    COMPRESSED_SRGB8_ETC2 = 0x9275,
    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276,
    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277,
    COMPRESSED_RGBA8_ETC2_EAC = 0x9278,
    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279,

    COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8c00,
    COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8c01,
    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8c02,
    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8c03,

    COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93b0,
    COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93b1,
    COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93b2,
    COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93b3,
    COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93b4,
    COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93b5,
    COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93b6,
    COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93b7,
    COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93b8,
    COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93b9,
    COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93ba,
    COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93bb,
    COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93bc,
    COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93bd,
    COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93d0,
    COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93d1,
    COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93d2,
    COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93d3,
    COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93d4,
    COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93d5,
    COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93d6,
    COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93d7,
    COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93d8,
    COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93d9,
    COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93da,
    COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93db,
    COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93dc,
    COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93dd,
  }

  type WEBGL_INFO = {
    MAX_TEXTURE_UNITS: GLint
    MAX_UNIFORM_BUFFERS: GLint
    MAX_UNIFORMS: GLint
    SAMPLES: GLint
    VENDOR: string
    RENDERER: string

    FLOAT_RENDER_TARGETS: boolean
    LINEAR_FLOAT_TEXTURES: boolean
    S3TC_TEXTURES: boolean
    S3TC_SRGB_TEXTURES: boolean
    ETC_TEXTURES: boolean
    ASTC_TEXTURES: boolean
    PVRTC_TEXTURES: boolean
    LOSE_CONTEXT: boolean
    DEBUG_SHADERS: boolean
    GPU_TIMER: boolean

    TEXTURE_ANISOTROPY: boolean
    MAX_TEXTURE_ANISOTROPY: GLint

    DEBUG_RENDERER_INFO: boolean

    PARALLEL_SHADER_COMPILE: boolean
    MULTI_DRAW_INSTANCED: boolean
  }

  export const PicoGL: {
    readonly version: string
    /** Create a PicoGL app. The app is the primary entry point to PicoGL. It stores the canvas, the WebGL context and all WebGL state. */
    createApp(canvas: OffscreenCanvas | HTMLCanvasElement, attributes: WebGLContextAttributes): App
  } & Readonly<WEBGL_INFO> &
    {
      readonly [key in keyof typeof GL]: (typeof GL)[key]
    }
  export default PicoGL

  type GLReadPixelFormat = GL.STENCIL_INDEX | GL.DEPTH_COMPONENT | GL.RED | GL.ALPHA | GL.RGB | GL.RGBA | GL.LUMINANCE | GL.LUMINANCE_ALPHA
  type GLInternalFormat =
    | GL.R8
    | GL.R8UI
    | GL.R8I
    | GL.R16UI
    | GL.R16I
    | GL.R32UI
    | GL.R32I
    | GL.RG8
    | GL.RG8UI
    | GL.RG8I
    | GL.RG16UI
    | GL.RG16I
    | GL.RG32UI
    | GL.RG32I
    | GL.RGB8
    | GL.RGBA8
    | GL.SRGB8_ALPHA8
    | GL.RGBA4
    | GL.RGB565
    | GL.RGB5_A1
    | GL.RGB10_A2
    | GL.RGBA8UI
    | GL.RGBA8I
    | GL.RGB10_A2UI
    | GL.RGBA16UI
    | GL.RGBA16I
    | GL.RGBA32I
    | GL.RGBA32UI
    | GL.DEPTH_COMPONENT16
    | GL.DEPTH_COMPONENT24
    | GL.DEPTH_COMPONENT32F
    | GL.DEPTH_STENCIL
    | GL.DEPTH24_STENCIL8
    | GL.DEPTH32F_STENCIL8
    | GL.STENCIL_INDEX8
  type GLType =
    | GL.UNSIGNED_BYTE
    | GL.UNSIGNED_SHORT_5_6_5
    | GL.UNSIGNED_SHORT_4_4_4_4
    | GL.UNSIGNED_SHORT_5_5_5_1
    | GL.FLOAT
    | GL.BYTE
    | GL.UNSIGNED_INT_2_10_10_10_REV
    | GL.HALF_FLOAT
    | GL.SHORT
    | GL.UNSIGNED_SHORT
    | GL.INT
    | GL.UNSIGNED_INT
    | GL.UNSIGNED_INT_10F_11F_11F_REV
    | GL.UNSIGNED_INT_5_9_9_9_REV
  type GLMatrixType =
    | GL.FLOAT_MAT2
    | GL.FLOAT_MAT2x3
    | GL.FLOAT_MAT2x4
    | GL.FLOAT_MAT3
    | GL.FLOAT_MAT3x2
    | GL.FLOAT_MAT3x4
    | GL.FLOAT_MAT4
    | GL.FLOAT_MAT4x2
    | GL.FLOAT_MAT4x3
  type GLMagFilter = GL.NEAREST | GL.LINEAR
  type GLMinFilter = GLMagFilter | GL.NEAREST_MIPMAP_NEAREST | GL.LINEAR_MIPMAP_NEAREST | GL.NEAREST_MIPMAP_LINEAR | GL.LINEAR_MIPMAP_LINEAR
  type GLWrap = GL.CLAMP_TO_EDGE | GL.MIRRORED_REPEAT | GL.REPEAT
  type GLCompareMode = GL.NONE | GL.COMPARE_REF_TO_TEXTURE
  type GLCompareFunc = GL.LEQUAL | GL.GEQUAL | GL.LESS | GL.GREATER | GL.EQUAL | GL.NOTEQUAL | GL.ALWAYS | GL.NEVER
  type GLBlend =
    | GL.ZERO
    | GL.ONE
    | GL.SRC_COLOR
    | GL.ONE_MINUS_SRC_COLOR
    | GL.DST_COLOR
    | GL.ONE_MINUS_DST_COLOR
    | GL.SRC_ALPHA
    | GL.ONE_MINUS_SRC_ALPHA
    | GL.DST_ALPHA
    | GL.ONE_MINUS_DST_ALPHA
    | GL.CONSTANT_COLOR
    | GL.ONE_MINUS_CONSTANT_COLOR
    | GL.CONSTANT_ALPHA
    | GL.ONE_MINUS_CONSTANT_ALPHA
    | GL.SRC_ALPHA_SATURATE
  type GLFace = GL.FRONT | GL.BACK | GL.FRONT_AND_BACK
  type GLStencilOP = GL.KEEP | GL.ZERO | GL.REPLACE | GL.INCR | GL.INCR_WRAP | GL.DECR | GL.DECR_WRAP | GL.INVERT
  type GLShaderType = GL.VERTEX_SHADER | GL.FRAGMENT_SHADER
  type GLUsage =
    | GL.STREAM_DRAW
    | GL.STREAM_READ
    | GL.STREAM_COPY
    | GL.STATIC_DRAW
    | GL.STATIC_READ
    | GL.STATIC_COPY
    | GL.DYNAMIC_DRAW
    | GL.DYNAMIC_READ
    | GL.DYNAMIC_COPY
  type GLQueryType = GL.ANY_SAMPLES_PASSED | GL.ANY_SAMPLES_PASSED_CONSERVATIVE | GL.TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN
  type GLTextTarget =
    | GL.TEXTURE_2D
    | GL.TEXTURE_CUBE_MAP_POSITIVE_X
    | GL.TEXTURE_CUBE_MAP_NEGATIVE_X
    | GL.TEXTURE_CUBE_MAP_POSITIVE_Y
    | GL.TEXTURE_CUBE_MAP_NEGATIVE_Y
    | GL.TEXTURE_CUBE_MAP_POSITIVE_Z
    | GL.TEXTURE_CUBE_MAP_NEGATIVE_Z
  type GLFrameBufferStatus =
    | GL.FRAMEBUFFER_COMPLETE
    | GL.FRAMEBUFFER_INCOMPLETE_ATTACHMENT
    | GL.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
    | GL.FRAMEBUFFER_INCOMPLETE_DIMENSIONS
    | GL.FRAMEBUFFER_UNSUPPORTED
    | GL.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
    | GL.RENDERBUFFER_SAMPLES
  type GLBinding = GL.ARRAY_BUFFER | GL.ELEMENT_ARRAY_BUFFER
  type GLPrimitive = GL.POINTS | GL.LINE_STRIP | GL.LINE_LOOP | GL.LINES | GL.TRIANGLE_STRIP | GL.TRIANGLE_FAN | GL.TRIANGLES

  /** Blit options. */
  interface BlitFramebufferOptions {
    /** Source start x coordinate. */
    srcStartX?: number
    /** Source start y coordinate. */
    srcStartY?: number
    /** Source end x coordinate. */
    srcEndX?: number
    /** Source end y coordinate. */
    srcEndY?: number
    /** Destination start x coordinate. */
    dstStartX?: number
    /** Destination start y coordinate. */
    dstStartY?: number
    /** Destination end x coordinate. */
    dstEndX?: number
    /** Destination end y coordinate. */
    dstEndY?: number
    /** Sampling filter. */
    filter?: GLMagFilter
  }

  interface ReadPixelOptions {
    /** Type of data stored in the read framebuffer. */
    type?: GLType
    /** Read framebuffer data format. */
    format?: GLReadPixelFormat
  }

  /** Texture2D options. */
  interface Texture2DOptions {
    /** Texture data internal format. Must be a sized format.
     * @default PicoGL.RGBA8
     */
    internalFormat?: GLInternalFormat
    /** Type of data stored in the texture. Default based on **internalFormat**. */
    type?: GLType
    /** Whether the y-axis should be flipped when unpacking the texture.
     * @default false
     */
    flipY?: boolean
    /** Whether the alpha channel should be pre-multiplied when unpacking the texture.
     * @default false
     */
    premultiplyAlpha?: boolean
    /** Minification filter. Defaults to LINEAR_MIPMAP_NEAREST if image data is provided, NEAREST otherwise. */
    minFilter?: GLMinFilter
    /** Magnification filter. Defaults to LINEAR if image data is provided, NEAREST otherwise. */
    magFilter?: GLMagFilter
    /** Horizontal wrap mode.
     * @default PicoGL.REPEAT
     */
    wrapS?: GLWrap
    /** Vertical wrap mode.
     * @default PicoGL.REPEAT
     */
    wrapT?: GLWrap
    /** Comparison mode.
     * @default PicoGL.NONE
     */
    compareMode?: GLCompareMode
    /** Comparison function.
     * @default PicoGL.LEQUAL
     */
    compareFunc?: GLCompareFunc
    /** Base mipmap level. */
    baseLevel?: GLint
    /** Maximum mipmap level. */
    maxLevel?: GLint
    /** Mimimum level of detail. */
    minLOD?: GLfloat
    /** Maximum level of detail. */
    maxLOD?: GLfloat
    /** Maximum anisotropy in filtering. */
    maxAnisotropy?: GLfloat
  }

  interface Texture3DOptions extends Texture2DOptions {
    /** Depth wrap mode.
     * @default PicoGL.REPEAT
     */
    wrapR?: GLWrap
  }

  interface CubemapOptions extends Texture2DOptions {
    /** The image data for the negative X direction. Can be any format that would be accepted by texImage2D. */
    negX: CanvasImageSource | ArrayBufferView
    /** The image data for the positive X direction. Can be any format that would be accepted by texImage2D. */
    posX: CanvasImageSource | ArrayBufferView
    /** The image data for the negative Y direction. Can be any format that would be accepted by texImage2D. */
    negY: CanvasImageSource | ArrayBufferView
    /** The image data for the positive Y direction. Can be any format that would be accepted by texImage2D. */
    posY: CanvasImageSource | ArrayBufferView
    /** The image data for the negative Z direction. Can be any format that would be accepted by texImage2D. */
    negZ: CanvasImageSource | ArrayBufferView
    /** The image data for the positive Z direction. Can be any format that would be accepted by texImage2D. */
    posZ: CanvasImageSource | ArrayBufferView
    /** Cubemap side width. Defaults to the width of negX if negX is an image. */
    width?: number
    /** Cubemap side height. Defaults to the height of negX if negX is an image. */
    height?: number
  }

  /**
      Primary entry point to PicoGL. An app will store all parts of the WebGL state.
    */
  export interface App {
    /** The canvas on which this app drawing. */
    canvas: OffscreenCanvas | HTMLCanvasElement
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** The width of the drawing surface. */
    width: number
    /** The height of the drawing surface. */
    height: number
    /** Tracked GL state. */
    state: {
      // todo
    }
    /** Current clear mask to use with clear(). */
    clearBits: GLbitfield

    /**
     * Simulate context loss.
     * @method
     * @return {App} The App object.
     */
    loseContext(): this

    /**
     * Simulate context restoration.
     * @method
     * @return {App} The App object.
     */
    restoreContext(): this

    /**
     * Set function to handle context restoration after loss.
     * @method
     * @param {function} fn Context restored handler.
     * @return {App} The App object.
     */
    onContextRestored(fn: () => void): this

    /**
     * Set the color mask to selectively enable or disable particular color channels while rendering.
     * @method
     * @param {boolean} r Red channel.
     * @param {boolean} g Green channel.
     * @param {boolean} b Blue channel.
     * @param {boolean} a Alpha channel.
     * @return {App} The App object.
     */
    colorMask(r: number, g: number, b: number, a: number): this

    /**
     * Set the clear color.
     * @method
     * @param {number} r Red channel.
     * @param {number} g Green channel.
     * @param {number} b Blue channel.
     * @param {number} a Alpha channel.
     * @return {App} The App object.
     */
    clearColor(r: number, g: number, b: number, a: number): this

    /**
     * Set the clear mask bits to use when calling clear().
     * E.g. app.clearMask(PicoGL.COLOR_BUFFER_BIT).
     * @method
     * @param {GLbitfield} mask Bit mask of buffers to clear.
     * @return {App} The App object.
     */
    clearMask(mask: GLbitfield): this

    /**
     * Clear the canvas
     * @method
     * @return {App} The App object.
     */
    clear(): this

    /**
     * Bind a draw framebuffer to the WebGL context.
     * @method
     * @param {Framebuffer} framebuffer The Framebuffer object to bind.
     * @see Framebuffer
     * @return {App} The App object.
     */
    drawFramebuffer(framebuffer: Framebuffer): this

    /**
     * Bind a read framebuffer to the WebGL context.
     * @method
     * @param {Framebuffer} framebuffer The Framebuffer object to bind.
     * @see Framebuffer
     * @return {App} The App object.
     */
    readFramebuffer(framebuffer: Framebuffer): this

    /**
     * Switch back to the default framebuffer for drawing (i.e. draw to the screen).
     * Note that this method resets the viewport to match the default framebuffer.
     * @method
     * @return {App} The App object.
     */
    defaultDrawFramebuffer(): this

    /**
     * Switch back to the default framebuffer for reading (i.e. read from the screen).
     * @method
     * @return {App} The App object.
     */
    defaultReadFramebuffer(): this

    /**
     * Copy data from framebuffer attached to READ_FRAMEBUFFER to framebuffer attached to DRAW_FRAMEBUFFER.
     * @method
     * @param {GLbitfield} mask Write mask (e.g. PicoGL.COLOR_BUFFER_BIT).
     * @param {Object} [options] Blit options.
     * @return {App} The App object.
     */
    blitFramebuffer(mask: GLbitfield, options?: BlitFramebufferOptions): this

    /**
     * Set the depth range.
     * @method
     * @param {number} near Minimum depth value.
     * @param {number} far Maximum depth value.
     * @return {App} The App object.
     */
    depthRange(near: number, far: number): this

    /**
     * Enable depth testing.
     * @method
     * @return {App} The App object.
     */
    depthTest(): this

    /**
     * Disable depth testing.
     * @method
     * @return {App} The App object.
     */
    noDepthTest(): this

    /**
     * Enable or disable writing to the depth buffer.
     * @method
     * @param {boolean} mask The depth mask.
     * @return {App} The App object.
     */
    depthMask(mask: boolean): this

    /**
     * Set the depth test function. E.g. app.depthFunc(PicoGL.LEQUAL).
     * @method
     * @param {GLCompareFunc} func The depth testing function to use.
     * @return {App} The App object.
     */
    depthFunc(func: GLCompareFunc): this

    /**
     * Enable blending.
     * @method
     * @return {App} The App object.
     */
    blend(): this

    /**
     * Disable blending
     * @method
     * @return {App} The App object.
     */
    noBlend(): this

    /**
     * Set the blend function. E.g. app.blendFunc(PicoGL.ONE, PicoGL.ONE_MINUS_SRC_ALPHA).
     * @method
     * @param {GLBlend} src The source blending weight.
     * @param {GLBlend} dest The destination blending weight.
     * @return {App} The App object.
     */
    blendFunc(src: GLBlend, dest: GLBlend): this

    /**
     * Set the blend function, with separate weighting for color and alpha channels.
     * E.g. app.blendFuncSeparate(PicoGL.ONE, PicoGL.ONE_MINUS_SRC_ALPHA, PicoGL.ONE, PicoGL.ONE).
     * @method
     * @param {GLBlend} csrc The source blending weight for the RGB channels.
     * @param {GLBlend} cdest The destination blending weight for the RGB channels.
     * @param {GLBlend} asrc The source blending weight for the alpha channel.
     * @param {GLBlend} adest The destination blending weight for the alpha channel.
     * @return {App} The App object.
     */
    blendFuncSeparate(csrc: GLBlend, cdest: GLBlend, asrc: GLBlend, adest: GLBlend): this

    /**
     * Enable stencil testing.
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @return {App} The App object.
     */
    stencilTest(): this

    /**
     * Disable stencil testing.
     * @method
     * @return {App} The App object.
     */
    noStencilTest(): this

    /**
     * Enable scissor testing.
     * @method
     * @return {App} The App object.
     */
    scissorTest(): this

    /**
     * Disable scissor testing.
     * @method
     * @return {App} The App object.
     */
    noScissorTest(): this

    /**
     * Define the scissor box.
     * @method
     * @return {App} The App object.
     */
    scissor(x: number, y: number, width: number, height: number): this

    /**
     * Set the bitmask to use for tested stencil values.
     * E.g. app.stencilMask(0xFF).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLuint} mask The mask value.
     * @return {App} The App object.
     */
    stencilMask(mask: GLuint): this

    /**
     * Set the bitmask to use for tested stencil values for a particular face orientation.
     * E.g. app.stencilMaskSeparate(PicoGL.FRONT, 0xFF).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLFace} face The face orientation to apply the mask to.
     * @param {GLuint} mask The mask value.
     * @return {App} The App object.
     */
    stencilMaskSeparate(face: GLFace, mask: GLuint): this

    /**
     * Set the stencil function and reference value.
     * E.g. app.stencilFunc(PicoGL.EQUAL, 1, 0xFF).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLCompareFunc} func The testing function.
     * @param {number} ref The reference value.
     * @param {GLuint} mask The bitmask to use against tested values before applying
     *     the stencil function.
     * @return {App} The App object.
     */
    stencilFunc(func: GLCompareFunc, ref: number, mask: GLuint): this

    /**
     * Set the stencil function and reference value for a particular face orientation.
     * E.g. app.stencilFuncSeparate(PicoGL.FRONT, PicoGL.EQUAL, 1, 0xFF).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLFace} face The face orientation to apply the function to.
     * @param {GLCompareFunc} func The testing function.
     * @param {number} ref The reference value.
     * @param {GLuint} mask The bitmask to use against tested values before applying
     *     the stencil function.
     * @return {App} The App object.
     */
    stencilFuncSeparate(face: GLFace, func: GLCompareFunc, ref: number, mask: GLuint): this

    /**
     * Set the operations for updating stencil buffer values.
     * E.g. app.stencilOp(PicoGL.KEEP, PicoGL.KEEP, PicoGL.REPLACE).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLStencilOP} stencilFail Operation to apply if the stencil test fails.
     * @param {GLStencilOP} depthFail Operation to apply if the depth test fails.
     * @param {GLStencilOP} pass Operation to apply if the both the depth and stencil tests pass.
     * @return {App} The App object.
     */
    stencilOp(stencilFail: GLStencilOP, depthFail: GLStencilOP, pass: GLStencilOP): this

    /**
     * Set the operations for updating stencil buffer values for a particular face orientation.
     * E.g. app.stencilOpSeparate(PicoGL.FRONT, PicoGL.KEEP, PicoGL.KEEP, PicoGL.REPLACE).
     * NOTE: Only works if { stencil: true } passed as a context attribute when creating the App!
     * @method
     * @param {GLFace} face The face orientation to apply the operations to.
     * @param {GLStencilOP} stencilFail Operation to apply if the stencil test fails.
     * @param {GLStencilOP} depthFail Operation to apply if the depth test fails.
     * @param {GLStencilOP} pass Operation to apply if the both the depth and stencil tests pass.
     * @return {App} The App object.
     */
    stencilOpSeparate(face: GLFace, stencilFail: GLStencilOP, depthFail: GLStencilOP, pass: GLStencilOP): this

    /**
     * Enable rasterization step.
     * @method
     * @return {App} The App object.
     */
    rasterize(): this

    /**
     * Disable rasterization step.
     * @method
     * @return {App} The App object.
     */
    noRasterize(): this

    /**
     * Enable backface culling.
     * @method
     * @return {App} The App object.
     */
    cullBackfaces(): this

    /**
     * Disable backface culling.
     * @method
     * @return {App} The App object.
     */
    drawBackfaces(): this

    /**
     * Read a pixel's color value from the currently-bound framebuffer.
     * @method
     * @param {number} x The x coordinate of the pixel.
     * @param {number} y The y coordinate of the pixel.
     * @param {ArrayBufferView} outColor Typed array to store the pixel's color.
     * @param {object} [options] Options.
     * @return {App} The App object.
     */
    readPixel(x: number, y: number, outColor: ArrayBufferView, options?: ReadPixelOptions): this

    /**
     * Set the viewport.
     * @method
     * @param {number} x Left bound of the viewport rectangle.
     * @param {number} y Lower bound of the viewport rectangle.
     * @param {number} width Width of the viewport rectangle.
     * @param {number} height Height of the viewport rectangle.
     * @return {App} The App object.
     */
    viewport(x: number, y: number, width: number, height: number): this

    /**
     * Set the viewport to the full canvas.
     * @method
     * @return {App} The App object.
     */
    defaultViewport(): this

    /**
     * Resize the drawing surface.
     * @method
     * @param {number} width The new canvas width.
     * @param {number} height The new canvas height.
     * @return {App} The App object.
     */
    resize(width: number, height: number): this

    /**
     * Create a program synchronously. It is highly recommended to use <b>createPrograms</b> instead as that method will compile shaders in parallel where possible.
     * @method
     * @param {Shader|string} vertexShader Vertex shader object or source code.
     * @param {Shader|string} fragmentShader Fragment shader object or source code.
     * @param {Array} [xformFeedbackVars] Transform feedback varyings.
     * @return {Program} New Program object.
     */
    createProgram(vsSource: Shader | string, fsSource: Shader | string, xformFeedbackVars?: string[]): Program

    /**
     * Create several programs. Preferred method for program creation as it will compile shaders
     * in parallel where possible.
     * @method
     * @param {...Array} sources Variable number of 2 or 3 element arrays, each containing:
     *     <ul>
     *         <li> (Shader|string) Vertex shader object or source code.
     *         <li> (Shader|string) Fragment shader object or source code.
     *         <li> (Array - optional) Array of names of transform feedback varyings.
     *     </ul>
     * @return {Promise} Promise that will resolve to an array of Programs when compilation and
     *     linking are complete for all programs.
     */
    createPrograms(...sources: Array<[Shader | string, Shader | string] | [Shader | string, Shader | string, string[]]>): Promise<Program[]>

    /**
     * Restore several programs after a context loss. Will do so in parallel where available.
     * @method
     * @param {...Program} sources Variable number of programs to restore.
     * @return {Promise} Promise that will resolve once all programs have been restored.
     */
    restorePrograms(...programs: Program[]): Promise<void>

    /**
     * Create a shader. Creating a shader separately from a program allows for
     * shader reuse.
     * @method
     * @param {GLShaderType} type Shader type.
     * @param {string} source Shader source.
     * @return {Shader} New Shader object.
     */
    createShader(type: GLShaderType, source: string): Shader

    /**
     * Create a vertex array.
     * @method
     * @return {VertexArray} New VertexArray object.
     */
    createVertexArray(): VertexArray

    /**
     * Create a transform feedback object.
     * @method
     * @return {TransformFeedback} New TransformFeedback object.
     */
    createTransformFeedback(): TransformFeedback

    /**
     * Create a vertex buffer.
     * @method
     * @param {GLType} type The data type stored in the vertex buffer.
     * @param {number} itemSize Number of elements per vertex.
     * @param {ArrayBufferView|number} data Buffer data itself or the total number of elements to be allocated.
     * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage.
     * @return {VertexBuffer} New VertexBuffer object.
     */
    createVertexBuffer(type: GLType, itemSize: number, data: ArrayBufferView | number, usage?: GLUsage): VertexBuffer

    /**
     * Create a per-vertex matrix buffer. Matrix buffers ensure that columns
     * are correctly split across attribute locations.
     * @method
     * @param {GLMatrixType} type The data type stored in the matrix buffer. Valid types
     * are FLOAT_MAT4, FLOAT_MAT4x2, FLOAT_MAT4x3, FLOAT_MAT3, FLOAT_MAT3x2,
     * FLOAT_MAT3x4, FLOAT_MAT2, FLOAT_MAT2x3, FLOAT_MAT2x4.
     * @param {ArrayBufferView} data Matrix buffer data.
     * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage.
     * @return {VertexBuffer} New VertexBuffer object.
     */
    createMatrixBuffer(type: GLMatrixType, data: ArrayBufferView, usage?: GLUsage): VertexBuffer

    /**
     * Create an buffer without any structure information. Structure
     * must be fully specified when binding to a VertexArray.
     * @method
     * @param {number} bytesPerVertex Number of bytes per vertex.
     * @param {ArrayBufferView|number} data Buffer data itself or the total
     *     number of bytes to be allocated.
     * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage.
     * @return {VertexBuffer} New VertexBuffer object.
     */
    createInterleavedBuffer(bytesPerVertex: number, data: ArrayBufferView | number, usage?: GLUsage): VertexBuffer

    /**
     * Create an index buffer.
     * @method
     * @param {GLType} type The data type stored in the index buffer.
     * @param {number} itemSize Number of elements per primitive.
     * @param {ArrayBufferView} data Index buffer data.
     * @param {GLUsage} [usage=STATIC_DRAW] Buffer usage.
     * @return {VertexBuffer} New VertexBuffer object.
     */
    createIndexBuffer(type: GLType, itemSize: number, data: ArrayBufferView, usage?: GLUsage): VertexBuffer

    /**
     * Create a uniform buffer in std140 layout. NOTE: FLOAT_MAT2, FLOAT_MAT3x2, FLOAT_MAT4x2,
     * FLOAT_MAT3, FLOAT_MAT2x3, FLOAT_MAT4x3 are supported, but must be manually padded to
     * 4-float column alignment by the application!
     * @method
     * @param {Array} layout Array indicating the order and types of items to
     *      *       be stored in the buffer.
     * @param {GLUsage} [usage=DYNAMIC_DRAW] Buffer usage.
     * @return {UniformBuffer} New UniformBuffer object.
     */
    createUniformBuffer(layout: Array<GLType | GLMatrixType>, usage?: GLUsage): UniformBuffer

    /**
     * Create a 2D texture. Can be used in several ways depending on the type of texture data:
     * @method
     * @param {DOMElement} image Image data. An array can be passed to manually set all levels
     *     of the mipmap chain. If a single level is passed and mipmap filtering is being used,
     *     generateMipmap() will be called to produce the remaining levels.
     * @param {Texture2DOptions} [options] Texture options.
     * @return {Texture} New Texture object.
     */
    createTexture2D(image: CanvasImageSource, options?: Texture2DOptions): Texture

    /**
     * Create a 2D texture. Can be used in several ways depending on the type of texture data:
     * @method
     * @param {ArrayBufferView|Array} image Image data. An array can be passed to manually set all levels
     *     of the mipmap chain. If a single level is passed and mipmap filtering is being used,
     *     generateMipmap() will be called to produce the remaining levels.
     * @param {number} width Texture width. Required for array or empty data.
     * @param {number} height Texture height. Required for array or empty data.
     * @param {Texture2DOptions} [options] Texture options.
     * @return {Texture} New Texture object.
     */
    createTexture2D(image: ArrayBufferView | Array<number>, width: number, height: number, options?: Texture2DOptions): Texture

    /**
     * Create a 2D texture. Can be used in several ways depending on the type of texture data:
     * @method
     * @param {number} width Texture width. Required for array or empty data.
     * @param {number} height Texture height. Required for array or empty data.
     * @param {Texture2DOptions} [options] Texture options.
     * @return {Texture} New Texture object.
     */
    createTexture2D(width: number, height: number, options?: Texture2DOptions): Texture

    /**
     * Create a 3D texture.
     * @method
     * @param {ArrayBufferView|Array} image Pixel data. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels.
     * @param {number} width Texture width. Required for array or empty data.
     * @param {number} height Texture height. Required for array or empty data.
     * @param {number} depth Texture depth.
     * @param {Texture3DOptions} [options] Texture options.
     * @return {Texture} New Texture object.
     */
    createTexture3D(image: ArrayBufferView | Array<number>, width: number, height: number, options?: Texture3DOptions): Texture

    /**
     * Create a cubemap.
     * @method
     * @param {CubemapOptions} options Texture options.
     * @return {Cubemap} New Cubemap object.
     */
    createCubemap(options: CubemapOptions): Cubemap

    /**
     * Create a renderbuffer.
     * @method
     * @param {number} width Renderbuffer width.
     * @param {number} height Renderbuffer height.
     * @param {GLInternalFormat} internalFormat Internal arrangement of the renderbuffer data.
     * @param {number} [samples=0] Number of MSAA samples.
     * @return {Renderbuffer} New Renderbuffer object.
     */
    createRenderbuffer(width: number, height: number, internalFormat: GLInternalFormat, samples: number): Renderbuffer

    /**
     * Create a framebuffer.
     * @method
     * @return {Framebuffer} New Framebuffer object.
     */
    createFramebuffer(): Framebuffer

    /**
     * Create a query.
     * @method
     * @param {GLQueryType} target Information to query.
     * @return {Query} New Query object.
     */
    createQuery(target: GLQueryType): Query

    /**
     * Create a timer.
     * @method
     * @return {Timer} New Timer object.
     */
    createTimer(): Timer

    /**
     * Create a DrawCall. A DrawCall manages the state associated with
     * a WebGL draw call including a program and associated vertex data, textures,
     * uniforms and uniform blocks.
     * @method
     * @param {Program} program The program to use for this DrawCall.
     * @param {VertexArray} [vertexArray=null] Vertex data to use for drawing.
     * @return {DrawCall} New DrawCall object.
     */
    createDrawCall(program: Program, vertexArray: VertexArray): DrawCall

    // Clear the canvas
    clear(): this
  }

  /** Offscreen drawing surface. */
  export interface Framebuffer {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Handle to the framebuffer. */
    framebuffer: WebGLFramebuffer
    /** Framebuffer width. */
    width: number
    /** Framebuffer height. */
    height: number
    /** Array of color attachments. */
    colorAttachments: Array<Texture | Cubemap | Renderbuffer>
    /** Depth attachment. */
    depthAttachment: Texture | Cubemap | Renderbuffer

    appState: {
      // TODO
    }

    /**
     * Restore framebuffer after context loss.
     * @method
     * @return {Framebuffer} The Framebuffer object.
     */
    restore(): this

    /**
     * Attach a color target to this framebuffer.
     * @method
     * @param {number} index Color attachment index.
     * @param {Texture|Cubemap|Renderbuffer} attachment The texture, cubemap or renderbuffer to attach.
     * @param {GLTextTarget} [target] The texture target or layer to attach. If the texture is 3D or a texture array,
     *     defaults to 0, otherwise to TEXTURE_2D. Ignored for renderbuffers.
     * @return {Framebuffer} The Framebuffer object.
     */
    colorTarget(index: number, attachment: Texture | Cubemap | Renderbuffer, target?: GLTextTarget): this

    /**
     * Attach a depth target to this framebuffer.
     * @method
     * @param {Texture|Cubemap|Renderbuffer} texture The texture, cubemap or renderbuffer to attach.
     * @param {GLTextTarget} [target] The texture target or layer to attach. If the texture is 3D or a texture array or renderbuffer,
     *     defaults to 0, otherwise to TEXTURE_2D. Ignored for renderbuffers.
     * @return {Framebuffer} The Framebuffer object.
     */
    depthTarget(attachment: Texture | Cubemap | Renderbuffer, target?: GLTextTarget): this

    /**
     * Resize all attachments.
     * @method
     * @param {number} [width=app.width] New width of the framebuffer.
     * @param {number} [height=app.height] New height of the framebuffer.
     * @return {Framebuffer} The Framebuffer object.
     */
    resize(width: number, height: number): this

    /**
     * Delete this framebuffer.
     * @method
     * @return {Framebuffer} The Framebuffer object.
     */
    delete(): this

    /**
     * Get the current status of this framebuffer.
     * @method
     * @return {GLFrameBufferStatus} The current status of this framebuffer.
     */
    getStatus(): GLFrameBufferStatus
  }

  /** WebGL shader. */
  export interface Shader {
    gl: WebGL2RenderingContext
    shader: WebGLShader

    /**
     * Restore shader after context loss.
     * @method
     * @return {Shader} The Shader object.
     */
    restore(): this

    /**
     * Get the shader source translated for the platform's API.
     * @method
     * @return {String} The translated shader source.
     */
    translatedSource(): string

    /**
     * Delete this shader.
     * @method
     * @return {Shader} The Shader object.
     */
    delete(): this
  }

  /** WebGL program consisting of compiled and linked vertex and fragment shaders. */
  export interface Program {
    gl: WebGL2RenderingContext
    program: WebGLProgram
    transformFeedback: boolean
    uniforms: object

    /**
     * Restore program after context loss. Note that this
     * will stall for completion. <b>App.restorePrograms</b>
     * is the preferred method for program restoration as
     * it will parallelize compilation where available.
     * @method
     * @return {Program} The Program object.
     */
    restore(): this

    /**
     * Get the vertex shader source translated for the platform's API.
     * @method
     * @return {String} The translated vertex shader source.
     */
    translatedVertexSource(): string

    /**
     * Get the fragment shader source translated for the platform's API.
     * @method
     * @return {String} The translated fragment shader source.
     */
    translatedFragmentSource(): string

    /**
     * Delete this program.
     * @method
     * @return {Program} The Program object.
     */
    delete(): Program
  }

  interface VertexArrayBufferOptions {
    /** Type of data stored in the buffer. */
    type?: GLType
    /** Number of components per vertex. */
    size?: 1 | 2 | 3 | 4
    /** Number of bytes between the start of data for each vertex. */
    stride?: GLuint
    /** Number of bytes before the start of data for the first vertex. */
    offset?: GLuint
    /** Data is integer data that should be normalized to a float. */
    normalized?: boolean
    /** Pass data as integers. */
    integer?: boolean
  }

  /** Organizes vertex buffer and attribute state. */
  export interface VertexArray {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Vertex array object. */
    vertexArray: WebGLVertexArrayObject
    /** Number of elements in the vertex array. */
    numElements: number
    /** Whether this vertex array is set up for indexed drawing. */
    indexed: boolean
    /** Data type of the indices. */
    indexType: GLType
    /** Number of instances to draw with this vertex array. */
    numInstances: number

    /**
     * Restore vertex array after context loss.
     * @method
     * @return {VertexArray} The VertexArray object.
     */
    restore(): this

    /**
     * Bind an per-vertex attribute buffer to this vertex array.
     * @method
     * @param {number} attributeIndex The attribute location to bind to.
     * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind.
     * @param {VertexArrayBufferOptions} [options] Attribute pointer options. These will override those provided in the VertexBuffer.
     * @return {VertexArray} The VertexArray object.
     */
    vertexAttributeBuffer(attributeIndex: number, vertexBuffer: VertexBuffer, options?: VertexArrayBufferOptions): this

    /**
     * Bind an per-instance attribute buffer to this vertex array.
     * @method
     * @param {number} attributeIndex The attribute location to bind to.
     * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind.
     * @param {VertexArrayBufferOptions} [options] Attribute pointer options. These will override those provided in the VertexBuffer.
     * @return {VertexArray} The VertexArray object.
     */
    instanceAttributeBuffer(attributeIndex: number, vertexBuffer: VertexBuffer, options?: VertexArrayBufferOptions): this

    /**
     * Bind an index buffer to this vertex array.
     * @method
     * @param {VertexBuffer} vertexBuffer The VertexBuffer to bind.
     * @return {VertexArray} The VertexArray object.
     */
    indexBuffer(vertexBuffer: VertexBuffer): this

    /**
     * Delete this vertex array.
     * @method
     * @return {VertexArray} The VertexArray object.
     */
    delete(): this
  }

  /** Tranform feedback object. */
  export interface TransformFeedback {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Transform feedback object. */
    transformFeedback: WebGLTransformFeedback

    /**
     * Restore transform feedback after context loss.
     * @method
     * @return {TransformFeedback} The TransformFeedback object.
     */
    restore(): this

    /**
     * Bind a feedback buffer to capture transform output.
     * @method
     * @param {number} index Index of transform feedback varying to capture.
     * @param {VertexBuffer} buffer Buffer to record output into.
     * @return {TransformFeedback} The TransformFeedback object.
     */
    feedbackBuffer(index: number, buffer: VertexBuffer): this

    /**
     * Delete this transform feedback.
     * @method
     * @return {TransformFeedback} The TransformFeedback object.
     */
    delete(): this
  }

  /** Storage for vertex data. */
  export interface VertexBuffer {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Allocated buffer storage. */
    buffer: WebGLBuffer
    /** The type of data stored in the buffer. */
    type: GLType
    /** Number of array elements per vertex. */
    itemSize: number
    /** Number of vertices represented. */
    numItems: number
    /** The usage pattern of the buffer. */
    usage: GLUsage
    /** Whether this is an index array. */
    indexArray: boolean
    /** GL binding point (ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER). */
    binding: GLBinding

    /**
     * Restore vertex buffer after context loss.
     * @method
     * @param {ArrayBufferView|number} data Buffer data itself or the total number of elements to be allocated.
     * @return {VertexBuffer} The VertexBuffer object.
     */
    restore(data: ArrayBufferView | number): this

    /**
     * Update data in this buffer. NOTE: the data must fit the originally-allocated buffer!
     * @method
     * @param {ArrayBufferView} data Data to store in the buffer.
     * @return {VertexBuffer} The VertexBuffer object.
     */
    data(data: ArrayBufferView): this

    /**
     * Delete this array buffer.
     * @method
     * @return {VertexBuffer} The VertexBuffer object.
     */
    delete(): this
  }

  /** General-purpose texture. */
  export interface Texture {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Handle to the texture. */
    texture: WebGLTexture
    /** Texture width. */
    width: number
    /** Texture height. */
    height: number
    /** Texture depth. */
    depth: number
    /** Binding point for the texture. */
    binding: GLBinding
    /** Type of data stored in the texture. */
    type: GLType
    /** Layout of texture data. */
    format: GLInternalFormat
    /** Internal arrangement of the texture data. */
    internalFormat: GLInternalFormat
    /** The current texture unit this texture is bound to. */
    currentUnit: number
    /** Whether this texture contains 3D data. */
    is3D: boolean
    /** Whether the y-axis is flipped for this texture. */
    flipY: boolean
    /** Whether alpha should be pre-multiplied when loading this texture. */
    premultiplyAlpha: boolean
    /** Whether this texture is using mipmap filtering (and thus should have a complete mipmap chain). */
    mipmaps: boolean

    /**
     * Restore texture after context loss.
     * @method
     * @param {DOMElement|ArrayBufferView|Array} [image] Image data. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels.
     * @return {Texture} The Texture object.
     */
    restore(image: CanvasImageSource | ArrayBufferView): this

    /**
     * Re-allocate texture storage.
     * @method
     * @param {number} width Image width.
     * @param {number} height Image height.
     * @param {number} [depth] Image depth or number of images. Required when passing 3D or texture array data.
     * @return {Texture} The Texture object.
     */
    resize(width: number, height: number, depth?: number): this

    /**
     * Set the image data for the texture. An array can be passed to manually set all levels of the mipmap chain. If a single level is passed and mipmap filtering is being used, generateMipmap() will be called to produce the remaining levels.
     * NOTE: the data must fit the currently-allocated storage!
     * @method
     * @param {ImageElement|ArrayBufferView|Array} data Image data. If an array is passed, it will be
     *     used to set mip map levels.
     * @return {Texture} The Texture object.
     */
    data(image: CanvasImageSource | ArrayBufferView): this

    /**
     * Delete this texture.
     * @method
     * @return {Texture} The Texture object.
     */
    delete(): this
  }

  /** Cubemap for environment mapping. */
  export interface Cubemap {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Handle to the texture. */
    texture: WebGLTexture
    /** Type of data stored in the texture. */
    type: GLType
    /** Layout of texture data. */
    format: GLInternalFormat
    /** Internal arrangement of the texture data. */
    internalFormat: GLInternalFormat
    /** The current texture unit this texture is bound to. */
    currentUnit: number
    /** Whether the y-axis is flipped for this texture. */
    flipY: boolean
    /** Whether alpha should be pre-multiplied when loading this texture. */
    premultiplyAlpha: boolean

    /**
     * Restore cubemap after context loss.
     * @method
     * @param {CubemapOptions} [options] Texture options.
     * @return {Cubemap} The Cubemap object.
     */
    restore(options?: CubemapOptions): this

    /**
     * Delete this cubemap.
     * @method
     * @return {Cubemap} The Cubemap object.
     */
    delete(): this
  }

  /** Offscreen drawing attachment. */
  export interface Renderbuffer {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Handle to the renderbuffer. */
    renderbuffer: WebGLRenderbuffer
    /** Texture width. */
    width: number
    /** Texture height. */
    height: number
    /** Internal arrangement of the texture data. */
    internalFormat: GLInternalFormat
    /** Number of MSAA samples. */
    samples: number

    /**
     * Restore renderbuffer after context loss.
     * @method
     * @return {Renderbuffer} The Renderbuffer object.
     */
    restore(): this

    /**
     * Resize the renderbuffer.
     * @method
     * @param {number} width New width of the renderbuffer.
     * @param {number} height New height of the renderbuffer.
     * @return {Renderbuffer} The Renderbuffer object.
     */
    resize(width: number, height: number): this

    /**
     * Delete this renderbuffer.
     * @method
     * @return {Renderbuffer} The Renderbuffer object.
     */
    delete(): this
  }

  /** Generic query object. */
  export interface Query {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Query object. */
    query: WebGLQuery
    /** The type of information being queried. */
    target: GLQueryType
    /** Whether or not a query is currently in progress. */
    active: boolean
    /** The result of the query (only available after a call to ready() returns true). */
    result: any

    /**
     * Restore query after context loss.
     * @method
     * @return {Query} The Query object.
     */
    restore(): this

    /**
     * Begin a query.
     * @method
     * @return {Query} The Query object.
     */
    begin(): this

    /**
     * End a query.
     * @method
     * @return {Query} The Query object.
     */
    end(): this

    /**
     * Check if query result is available.
     * @method
     * @return {boolean} If results are available.
     */
    ready(): boolean

    /**
     * Delete this query.
     * @method
     * @return {Query} The Query object.
     */
    delete(): this
  }

  export interface Timer {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Timer for CPU. Will be window.performance, if available, or window.Date. */
    cpuTimer: Object
    /** Timer query object for GPU (if gpu timing is supported). */
    gpuTimerQuery: WebGLQuery
    /** Whether a gpu timer query is currently in progress. */
    gpuTimerQueryInProgress: boolean
    /** When the last CPU timing started. */
    cpuStartTime: number
    /** Time spent on CPU during last timing. Only valid if ready() returns true. */
    cpuTime: number
    /** Time spent on GPU during last timing. Only valid if ready() returns true. Will remain 0 if extension EXT_disjoint_timer_query_webgl2 is unavailable. */
    gpuTime: number

    /**
     * Restore timer after context loss.
     * @method
     * @return {Timer} The Timer object.
     */
    restore(): this

    /**
     * Start timing.
     * @method
     * @return {Timer} The Timer object.
     */
    start(): this

    /**
     * Stop timing.
     * @method
     * @return {Timer} The Timer object.
     */
    end(): this

    /**
     * Check if timing results are available. If
     * this method returns true, the cpuTime and
     * gpuTime properties will be set to valid
     * values.
     * @method
     * @return {boolean} If results are available.
     */
    ready(): boolean

    /**
     * Delete this timer.
     * @method
     * @return {Timer} The Timer object.
     */
    delete(): this
  }

  /** A DrawCall represents the program and values of associated attributes, uniforms and textures for a single draw call. */
  export interface DrawCall {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** The program to use for this draw call. */
    currentProgram: Program
    /** Vertex array to use for this draw call. */
    currentVertexArray: VertexArray
    /** Transform feedback to use for this draw call. */
    currentTransformFeedback: TransformFeedback
    /** Ordered list of active uniform buffers. */
    uniformBuffers: UniformBuffer[]
    /** Ordered list of uniform block names. */
    uniformBlockNames: string[]
    /** Number of active uniform blocks for this draw call. */
    uniformBlockCount: number
    /** Map of uniform names to indices in the uniform arrays. */
    uniformIndices: { [key: string]: number }
    /** Ordered list of uniform names. */
    uniformNames: string[]
    /** Ordered list of uniform values. */
    uniformValue: any[]
    /** The number of active uniforms for this draw call. */
    uniformCount: number
    /** Array of active textures. */
    textures: Array<Texture | Cubemap | Renderbuffer>
    /** The number of active textures for this draw call. */
    textureCount: number
    /** The number of element to draw. */
    numElements: number
    /** The number of instances to draw. */
    numInstances: number

    /**
     * Set the current draw primitive for this draw call.
     * @method
     * @param {GLPrimitive} primitive Primitive to draw.
     * @return {DrawCall} The DrawCall object.
     */
    primitive(primitive: GLPrimitive): this

    /**
     * Set the current TransformFeedback object for draw.
     * @method
     * @param {TransformFeedback} transformFeedback Transform Feedback to set.
     * @return {DrawCall} The DrawCall object.
     */
    transformFeedback(transformFeedback: TransformFeedback): this

    /**
     * Set the value for a uniform. Array uniforms are supported by
     * using appending "[0]" to the array name and passing a flat array
     * with all required values.
     * @method
     * @param {string} name Uniform name.
     * @param {any} value Uniform value.
     * @return {DrawCall} The DrawCall object.
     */
    uniform(name: string, value: any): this

    /**
     * Set texture to bind to a sampler uniform.
     * @method
     * @param {string} name Sampler uniform name.
     * @param {Texture|Cubemap|Renderbuffer} texture Texture or Cubemap to bind.
     * @return {DrawCall} The DrawCall object.
     */
    texture(name: string, texture: Texture | Cubemap | Renderbuffer): this

    /**
     * Set uniform buffer to bind to a uniform block.
     * @method
     * @param {string} name Uniform block name.
     * @param {UniformBuffer} buffer Uniform buffer to bind.
     * @return {DrawCall} The DrawCall object.
     */
    uniformBlock(name: string, buffer: UniformBuffer): this

    /**
     * Ranges in the vertex array to draw. Multiple arguments can be provided to set up
     * a multi-draw.
     * @method
     * @param {...Array} counts Variable number of 2 or 3 element arrays, each containing:
     *     <ul>
     *         <li> (Number) Number of elements to skip at the start of the array.
     *         <li> (Number) Number of elements to draw.
     *         <li> (Number - optional) Number of instances to draw of the given range.
     *     </ul>
     * @return {DrawCall} The DrawCall object.
     */
    drawRanges(...counts: Array<[number, number] | [number, number, number]>): this

    /**
     * Draw based on current state.
     * @method
     * @return {DrawCall} The DrawCall object.
     */
    draw(): this
  }

  /** Storage for uniform data. Data is stored in std140 layout. */
  export interface UniformBuffer {
    /** The WebGL context. */
    gl: WebGL2RenderingContext
    /** Allocated buffer storage. */
    buffer: WebGLBuffer
    /** Buffer data. */
    data: Float32Array
    /** Map of base data types to matching ArrayBufferViews of the buffer data. */
    dataViews: object
    /** Offsets into the array for each item in the buffer. */
    offsets: number[]
    /** Size of the item at the given offset. */
    sizes: number[]
    /** The base type of the item at the given offset (FLOAT, INT or UNSIGNED_INT). */
    types: GLType[]
    /** The size of the buffer (in 4-byte items). */
    size: number
    /** Usage pattern of the buffer. */
    usage: GLUsage

    /**
     * Restore uniform buffer after context loss.
     * @method
     * @return {UniformBuffer} The UniformBuffer object.
     */
    restore(): this

    /**
     * Update data for a given item in the buffer. NOTE: Data is not
     * sent the the GPU until the update() method is called!
     * @method
     * @param {number} index Index in the layout of item to set.
     * @param {ArrayBufferView} value Value to store at the layout location.
     * @return {UniformBuffer} The UniformBuffer object.
     */
    set(index: number, value: ArrayBufferView): this

    /**
     * Send stored buffer data to the GPU.
     * @method
     * @return {UniformBuffer} The UniformBuffer object.
     */
    update(): this

    /**
     * Delete this uniform buffer.
     * @method
     * @return {UniformBuffer} The UniformBuffer object.
     */
    delete(): this
  }
}