Add vector.normalize; rm luau generated bindings;

didn't mean to commit those!

api/init.lua

@@ -42957,6 +42957,32 @@ return {
       enums = {},
       external = true,
       functions = {
+        {
+          name = "normalize",
+          summary = "Get a normalized vector.",
+          description = "Returns the normalized version of the input vector (a vector that points in the same direction, but has a length of 1).",
+          key = "vector.normalize",
+          module = "vector",
+          notes = "This can be called as a method, e.g. `v:normalize()`.",
+          variants = {
+            {
+              arguments = {
+                {
+                  name = "v",
+                  type = "vector",
+                  description = "The vector to normalize."
+                }
+              },
+              returns = {
+                {
+                  name = "normalized",
+                  type = "vector",
+                  description = "The normalized vector."
+                }
+              }
+            }
+          }
+        },
         {
           name = "pack",
           summary = "Pack numbers into a vector.",

api/lovr/vector/normalize.lua

@@ -0,0 +1,26 @@
+return {
+  summary = 'Get a normalized vector.',
+  description = [[
+    Returns the normalized version of the input vector (a vector that points in the same direction,
+    but has a length of 1).
+  ]],
+  arguments = {
+    v = {
+      type = 'vector',
+      description = 'The vector to normalize.'
+    }
+  },
+  returns = {
+    normalized = {
+      type = 'vector',
+      description = 'The normalized vector.'
+    }
+  },
+  variants = {
+    {
+      arguments = { 'v' },
+      returns = { 'normalized' }
+    }
+  },
+  notes = 'This can be called as a method, e.g. `v:normalize()`.'
+}

api/luau/lovr.d.luau

@@ -1,1885 +0,0 @@
-declare extern type userdata with end
-declare extern type lightuserdata with end
-
-declare extern type quaternion with
-  x: number
-  y: number
-  z: number
-  w: number
-end
-
-type Vec2 = {number}
-type Vec3 = {number} | vector
-type Vec4 = {number}
-type Quat = {number} | quaternion
-type Mat4 = {number}
-
-declare class Joint end
-declare class Shape end
-
-declare class Object
-  function release(self)
-  function type(self): string
-end
-
-type AudioMaterial =
-  | "generic"
-  | "brick"
-  | "carpet"
-  | "ceramic"
-  | "concrete"
-  | "glass"
-  | "gravel"
-  | "metal"
-  | "plaster"
-  | "rock"
-  | "wood"
-
-type AudioShareMode =
-  | "shared"
-  | "exclusive"
-
-type AudioType =
-  | "playback"
-  | "capture"
-
-type Effect =
-  | "absorption"
-  | "attenuation"
-  | "occlusion"
-  | "reverb"
-  | "spatialization"
-  | "transmission"
-
-type TimeUnit =
-  | "seconds"
-  | "frames"
-
-type VolumeUnit =
-  | "linear"
-  | "db"
-
-declare class Source extends Object
-  function clone(self): Source
-  function getDirectivity(self): (number, number)
-  function getDuration(self, unit: TimeUnit?): number
-  function getOrientation(self): (number, number, number, number)
-  function getPitch(self): number
-  function getPose(self): (number, number, number, number, number, number, number)
-  function getPosition(self): (number, number, number)
-  function getRadius(self): number
-  function getSound(self): Sound
-  function getVolume(self, units: VolumeUnit?): number
-  function isEffectEnabled(self, effect: Effect): boolean
-  function isLooping(self): boolean
-  function isPlaying(self): boolean
-  function isSpatial(self): boolean
-  function pause(self)
-  function play(self): boolean
-  function seek(self, position: number, unit: TimeUnit?)
-  function setDirectivity(self, weight: number, power: number)
-  function setEffectEnabled(self, effect: Effect, enable: boolean)
-  function setLooping(self, loop: boolean)
-  function setOrientation(self, angle: number, ax: number, ay: number, az: number)
-  function setOrientation(self, orientation: Quat)
-  function setPitch(self, pitch: number)
-  function setPose(self, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number)
-  function setPose(self, position: Vec3, orientation: Quat)
-  function setPosition(self, x: number, y: number, z: number)
-  function setPosition(self, position: Vec3)
-  function setRadius(self, radius: number)
-  function setVolume(self, volume: number, units: VolumeUnit?)
-  function stop(self)
-  function tell(self, unit: TimeUnit?): number
-end
-
-type AudioModule = {
-  getAbsorption: () -> (number, number, number),
-  getDevice: (type: AudioType?) -> (string | nil, userdata | nil),
-  getDevices: (type: AudioType?) -> {},
-  getOrientation: () -> (number, number, number, number),
-  getPose: () -> (number, number, number, number, number, number, number),
-  getPosition: () -> (number, number, number),
-  getSampleRate: () -> number,
-  getSpatializer: () -> string,
-  getVolume: (units: VolumeUnit?) -> number,
-  isStarted: (type: AudioType?) -> boolean,
-  newSource:
-    & ((file: string | Blob, options: {}?) -> Source)
-    & ((sound: Sound, options: {}?) -> Source),
-  setAbsorption: (low: number, mid: number, high: number) -> (),
-  setDevice: (type: AudioType?, id: userdata?, sink: Sound?, mode: AudioShareMode?) -> boolean,
-  setGeometry:
-    & ((vertices: {}, indices: {}, material: AudioMaterial?) -> boolean)
-    & ((model: Model, material: AudioMaterial?) -> boolean),
-  setOrientation:
-    & ((angle: number, ax: number, ay: number, az: number) -> ())
-    & ((orientation: Quat) -> ()),
-  setPose:
-    & ((x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number) -> ())
-    & ((position: Vec3, orientation: Quat) -> ()),
-  setPosition:
-    & ((x: number, y: number, z: number) -> ())
-    & ((position: Vec3) -> ()),
-  setVolume: (volume: number, units: VolumeUnit?) -> (),
-  start: (type: AudioType?) -> boolean,
-  stop: (type: AudioType?) -> boolean,
-}
-
-type AnimationProperty =
-  | "translation"
-  | "rotation"
-  | "scale"
-  | "weights"
-
-type AttributeType =
-  | "i8"
-  | "u8"
-  | "i16"
-  | "u16"
-  | "i32"
-  | "u32"
-  | "f32"
-
-type ChannelLayout =
-  | "mono"
-  | "stereo"
-  | "ambisonic"
-
-type DefaultAttribute =
-  | "position"
-  | "normal"
-  | "uv"
-  | "color"
-  | "tangent"
-  | "joints"
-  | "weights"
-
-type ModelDrawMode =
-  | "points"
-  | "lines"
-  | "linestrip"
-  | "lineloop"
-  | "strip"
-  | "triangles"
-  | "fan"
-
-type SampleFormat =
-  | "f32"
-  | "i16"
-
-type SmoothMode =
-  | "step"
-  | "linear"
-  | "cubic"
-
-type TextureFormat =
-  | "r8"
-  | "rg8"
-  | "rgba8"
-  | "bgra8"
-  | "r16"
-  | "rg16"
-  | "rgba16"
-  | "r16f"
-  | "rg16f"
-  | "rgba16f"
-  | "r32f"
-  | "rg32f"
-  | "rgba32f"
-  | "rgb565"
-  | "rgb5a1"
-  | "rgb10a2"
-  | "rg11b10f"
-  | "d16"
-  | "d24"
-  | "d24s8"
-  | "d32f"
-  | "d32fs8"
-  | "bc1"
-  | "bc2"
-  | "bc3"
-  | "bc4u"
-  | "bc4s"
-  | "bc5u"
-  | "bc5s"
-  | "bc6uf"
-  | "bc6sf"
-  | "bc7"
-  | "astc4x4"
-  | "astc5x4"
-  | "astc5x5"
-  | "astc6x5"
-  | "astc6x6"
-  | "astc8x5"
-  | "astc8x6"
-  | "astc8x8"
-  | "astc10x5"
-  | "astc10x6"
-  | "astc10x8"
-  | "astc10x10"
-  | "astc12x10"
-  | "astc12x12"
-
-declare class Blob extends Object
-  function getSize(self): number
-  function getName(self): string
-  function getPointer(self): userdata
-  function getString(self, offset: number?, size: number?): string
-  function getI8(self, offset: number?, count: number?): number
-  function getU8(self, offset: number?, count: number?): number
-  function getI16(self, offset: number?, count: number?): number
-  function getU16(self, offset: number?, count: number?): number
-  function getI32(self, offset: number?, count: number?): number
-  function getU32(self, offset: number?, count: number?): number
-  function getF32(self, offset: number?, count: number?): number
-  function getF64(self, offset: number?, count: number?): number
-  function setI8(self, offset: number, ...: number)
-  function setI8(self, offset: number, table: {number})
-  function setU8(self, offset: number, ...: number)
-  function setU8(self, offset: number, table: {number})
-  function setI16(self, offset: number, ...: number)
-  function setI16(self, offset: number, table: {number})
-  function setU16(self, offset: number, ...: number)
-  function setU16(self, offset: number, table: {number})
-  function setI32(self, offset: number, ...: number)
-  function setI32(self, offset: number, table: {number})
-  function setU32(self, offset: number, ...: number)
-  function setU32(self, offset: number, table: {number})
-  function setF32(self, offset: number, ...: number)
-  function setF32(self, offset: number, table: {number})
-  function setF64(self, offset: number, ...: number)
-  function setF64(self, offset: number, table: {number})
-end
-
-declare class Image extends Object
-  function encode(self): Blob
-  function getBlob(self): Blob
-  function getDimensions(self): (number, number)
-  function getFormat(self): TextureFormat
-  function getHeight(self): number
-  function getPixel(self, x: number, y: number): (number, number, number, number)
-  function getPointer(self, level: number?, layer: number?): userdata
-  function getWidth(self): number
-  function mapPixel(self, callback: () -> (), x: number?, y: number?, w: number?, h: number?)
-  function paste(self, source: Image, x: number?, y: number?, fromX: number?, fromY: number?, width: number?, height: number?)
-  function setPixel(self, x: number, y: number, r: number, g: number, b: number, a: number?)
-end
-
-declare class ModelData extends Object
-  function getAnimationChannelCount(self, animation: number | string): number
-  function getAnimationCount(self): number
-  function getAnimationDuration(self, animation: string | number): number
-  function getAnimationKeyframe(self, animation: number, channel: number, keyframe: number): (number, number)
-  function getAnimationKeyframeCount(self, animation: string | number, channel: number): number
-  function getAnimationName(self, index: number): string | nil
-  function getAnimationNode(self, animation: number, channel: number): number
-  function getAnimationProperty(self, animation: string | number, channel: number): AnimationProperty
-  function getAnimationSmoothMode(self, animation: string | number, channel: number): SmoothMode
-  function getBlendShapeCount(self): number
-  function getBlendShapeName(self, index: number): string
-  function getBlob(self, index: number): Blob
-  function getBlobCount(self): number
-  function getBoundingBox(self): (number, number, number, number, number, number)
-  function getBoundingSphere(self): (number, number, number, number)
-  function getCenter(self): (number, number, number)
-  function getDepth(self): number
-  function getDimensions(self): (number, number, number)
-  function getHeight(self): number
-  function getImage(self, index: number): Image
-  function getImageCount(self): number
-  function getMaterial(self, material: number): {}
-  function getMaterialCount(self): number
-  function getMaterialName(self, index: number): string
-  function getMeshCount(self): number
-  function getMeshDrawMode(self, mesh: number): ModelDrawMode
-  function getMeshIndex(self, mesh: number, index: number): number
-  function getMeshIndexCount(self, mesh: number): number
-  function getMeshIndexFormat(self, mesh: number): (AttributeType, number, number, number)
-  function getMeshMaterial(self, mesh: number): number
-  function getMeshVertex(self, mesh: number, vertex: number): number
-  function getMeshVertexCount(self, mesh: number): number
-  function getMeshVertexFormat(self, mesh: number): {}
-  function getMetadata(self): string
-  function getNodeChildren(self, node: string | number): {number}
-  function getNodeCount(self): number
-  function getNodeMeshes(self, node: string | number): {}
-  function getNodeName(self, index: number): string
-  function getNodeOrientation(self, node: string | number): (number, number, number, number)
-  function getNodeParent(self, node: string | number): number
-  function getNodePose(self, node: string | number): (number, number, number, number, number, number, number)
-  function getNodePosition(self, node: string | number): (number, number, number)
-  function getNodeScale(self, node: string | number): (number, number, number)
-  function getNodeSkin(self, node: string | number): number
-  function getNodeTransform(self, node: string | number): (number, number, number, number, number, number, number, number, number, number)
-  function getRootNode(self): number
-  function getSkinCount(self): number
-  function getSkinInverseBindMatrix(self, skin: number, joint: number): number
-  function getSkinJoints(self, skin: number): {}
-  function getTriangleCount(self): number
-  function getTriangles(self): ({}, {})
-  function getVertexCount(self): number
-  function getWidth(self): number
-end
-
-declare class Rasterizer extends Object
-  function getAdvance(self, glyph: string | number): number
-  function getAscent(self): number
-  function getBearing(self, glyph: string | number): number
-  function getBoundingBox(self, glyph: string | number): (number, number, number, number)
-  function getBoundingBox(self): (number, number, number, number)
-  function getCurves(self, glyph: string | number, three: boolean): {}
-  function getDescent(self): number
-  function getDimensions(self, glyph: string): (number, number)
-  function getDimensions(self): (number, number)
-  function getFontSize(self): number
-  function getGlyphCount(self): number
-  function getHeight(self, glyph: string | number): number
-  function getHeight(self): number
-  function getKerning(self, first: string | number, second: string | number): number
-  function getLeading(self): number
-  function getWidth(self, glyph: string | number): number
-  function getWidth(self): number
-  function hasGlyphs(self, ...: string | number): boolean
-  function newImage(self, glyph: string | number, spread: number?, padding: number?): Image
-end
-
-declare class Sound extends Object
-  function getBlob(self): Blob
-  function getByteStride(self): number
-  function getCapacity(self): number
-  function getChannelCount(self): number
-  function getChannelLayout(self): ChannelLayout
-  function getDuration(self): number
-  function getFormat(self): SampleFormat
-  function getFrameCount(self): number
-  function getFrames(self, count: number?, srcOffset: number?): ({number}, number)
-  function getFrames(self, t: {}, count: number?, srcOffset: number?, dstOffset: number?): ({number}, number)
-  function getFrames(self, blob: Blob, count: number?, srcOffset: number?, dstOffset: number?): number
-  function getFrames(self, sound: Sound, count: number?, srcOffset: number?, dstOffset: number?): number
-  function getSampleCount(self): number
-  function getSampleRate(self): number
-  function isCompressed(self): boolean
-  function isStream(self): boolean
-  function setFrames(self, source: {} | Blob | Sound, count: number?, dstOffset: number?, srcOffset: number?): number
-end
-
-type DataModule = {
-  newBlob:
-    & ((size: number, name: string?) -> Blob)
-    & ((contents: string, name: string?) -> Blob)
-    & ((source: Blob, name: string?) -> Blob),
-  newImage:
-    & ((file: string | Blob) -> Image)
-    & ((width: number, height: number, format: TextureFormat?, data: Blob?) -> Image)
-    & ((source: Image) -> Image),
-  newModelData: (file: string | Blob) -> ModelData,
-  newRasterizer:
-    & ((file: string | Blob, size: number?) -> Rasterizer)
-    & ((size: number?) -> Rasterizer),
-  newSound:
-    & ((frames: number, format: SampleFormat?, channels: ChannelLayout?, sampleRate: number?, contents: Blob | string | nil | nil) -> Sound)
-    & ((file: string | Blob, decode: boolean?) -> Sound),
-}
-
-type DisplayType =
-  | "headset"
-  | "window"
-
-type KeyCode =
-  | "a"
-  | "b"
-  | "c"
-  | "d"
-  | "e"
-  | "f"
-  | "g"
-  | "h"
-  | "i"
-  | "j"
-  | "k"
-  | "l"
-  | "m"
-  | "n"
-  | "o"
-  | "p"
-  | "q"
-  | "r"
-  | "s"
-  | "t"
-  | "u"
-  | "v"
-  | "w"
-  | "x"
-  | "y"
-  | "z"
-  | "0"
-  | "1"
-  | "2"
-  | "3"
-  | "4"
-  | "5"
-  | "6"
-  | "7"
-  | "8"
-  | "9"
-  | "space"
-  | "return"
-  | "tab"
-  | "escape"
-  | "backspace"
-  | "up"
-  | "down"
-  | "left"
-  | "right"
-  | "home"
-  | "end"
-  | "pageup"
-  | "pagedown"
-  | "insert"
-  | "delete"
-  | "f1"
-  | "f2"
-  | "f3"
-  | "f4"
-  | "f5"
-  | "f6"
-  | "f7"
-  | "f8"
-  | "f9"
-  | "f10"
-  | "f11"
-  | "f12"
-  | "`"
-  | "-"
-  | "="
-  | "["
-  | "]"
-  | "\\"
-  | ";"
-  | "'"
-  | ","
-  | "."
-  | "/"
-  | "kp0"
-  | "kp1"
-  | "kp2"
-  | "kp3"
-  | "kp4"
-  | "kp5"
-  | "kp6"
-  | "kp7"
-  | "kp8"
-  | "kp9"
-  | "kp."
-  | "kp/"
-  | "kp*"
-  | "kp-"
-  | "kp+"
-  | "kpenter"
-  | "kp="
-  | "lctrl"
-  | "lshift"
-  | "lalt"
-  | "lgui"
-  | "rctrl"
-  | "rshift"
-  | "ralt"
-  | "rgui"
-  | "capslock"
-  | "scrolllock"
-  | "numlock"
-
-type EventModule = {
-  clear: () -> (),
-  poll: () -> (() -> ()),
-  push: (name: string, ...any) -> (),
-  quit: (code: number?) -> (),
-  restart: () -> (),
-}
-
-type FileAction =
-  | "create"
-  | "delete"
-  | "modify"
-  | "rename"
-
-type OpenMode =
-  | "r"
-  | "w"
-  | "a"
-
-declare class File extends Object
-  function getMode(self): OpenMode
-  function getPath(self): string
-  function getSize(self): (number, string)
-  function isEOF(self): boolean
-  function read(self, bytes: number): (string, number)
-  function seek(self, offset: number)
-  function tell(self): number
-  function write(self, string: string, size: number?): (boolean, string)
-  function write(self, blob: Blob, size: number?): (boolean, string)
-end
-
-type FilesystemModule = {
-  append: (filename: string, content: string | Blob) -> (boolean, string | nil),
-  createDirectory: (path: string) -> (boolean, string | nil),
-  getAppdataDirectory: () -> string | nil,
-  getDirectoryItems: (path: string) -> {string},
-  getExecutablePath: () -> string | nil,
-  getIdentity: () -> string | nil,
-  getLastModified: (path: string) -> (number | nil, string | nil),
-  getRealDirectory: (path: string) -> string | nil,
-  getRequirePath: () -> string,
-  getSaveDirectory: () -> string,
-  getSize: (file: string) -> (number | nil, string | nil),
-  getSource: () -> string | nil,
-  getUserDirectory: () -> string | nil,
-  getWorkingDirectory: () -> string | nil,
-  isDirectory: (path: string) -> boolean,
-  isFile: (path: string) -> boolean,
-  isFused: () -> boolean,
-  load: (filename: string, mode: string?) -> (() -> ()),
-  mount: (path: string, mountpoint: string?, append: boolean?, root: string?) -> (boolean, string | nil),
-  newBlob: (filename: string) -> Blob,
-  newFile: (path: string, mode: OpenMode) -> (File, string),
-  read: (filename: string) -> (string | nil, string | nil),
-  remove: (path: string) -> (boolean, string | nil),
-  setIdentity: (identity: string) -> (),
-  setRequirePath: (path: string?) -> (),
-  unmount: (path: string) -> boolean,
-  unwatch: () -> (),
-  watch: () -> (),
-  write: (filename: string, content: string | Blob) -> (boolean, string),
-}
-
-type BlendAlphaMode =
-  | "alphamultiply"
-  | "premultiplied"
-
-type BlendMode =
-  | "alpha"
-  | "add"
-  | "subtract"
-  | "multiply"
-  | "lighten"
-  | "darken"
-  | "screen"
-  | "none"
-
-type CompareMode =
-  | "none"
-  | "equal"
-  | "notequal"
-  | "less"
-  | "lequal"
-  | "greater"
-  | "gequal"
-
-type CullMode =
-  | "none"
-  | "back"
-  | "front"
-
-type DataLayout =
-  | "packed"
-  | "std140"
-  | "std430"
-
-type DataType =
-  | "i8x4"
-  | "u8x4"
-  | "sn8x4"
-  | "un8x4"
-  | "sn10x3"
-  | "un10x3"
-  | "i16"
-  | "i16x2"
-  | "i16x4"
-  | "u16"
-  | "u16x2"
-  | "u16x4"
-  | "sn16x2"
-  | "sn16x4"
-  | "un16x2"
-  | "un16x4"
-  | "i32"
-  | "i32x2"
-  | "i32x3"
-  | "i32x4"
-  | "u32"
-  | "u32x2"
-  | "u32x3"
-  | "u32x4"
-  | "f16x2"
-  | "f16x4"
-  | "f32"
-  | "f32x2"
-  | "f32x3"
-  | "f32x4"
-  | "mat2"
-  | "mat3"
-  | "mat4"
-  | "index16"
-  | "index32"
-
-type DefaultShader =
-  | "unlit"
-  | "normal"
-  | "font"
-  | "cubemap"
-  | "equirect"
-  | "fill"
-
-type DrawMode =
-  | "points"
-  | "lines"
-  | "triangles"
-
-type DrawStyle =
-  | "fill"
-  | "line"
-
-type FilterMode =
-  | "nearest"
-  | "linear"
-  | "cubic"
-
-type HorizontalAlign =
-  | "left"
-  | "center"
-  | "right"
-
-type MeshStorage =
-  | "cpu"
-  | "gpu"
-
-type OriginType =
-  | "root"
-  | "parent"
-
-type ShaderStage =
-  | "vertex"
-  | "fragment"
-  | "compute"
-
-type ShaderType =
-  | "graphics"
-  | "compute"
-
-type StackType =
-  | "transform"
-  | "state"
-
-type StencilAction =
-  | "keep"
-  | "zero"
-  | "replace"
-  | "increment"
-  | "decrement"
-  | "incrementwrap"
-  | "decrementwrap"
-  | "invert"
-
-type TextureFeature =
-  | "sample"
-  | "render"
-  | "storage"
-  | "blit"
-  | "cubic"
-
-type TextureType =
-  | "2d"
-  | "3d"
-  | "cube"
-  | "array"
-
-type TextureUsage =
-  | "sample"
-  | "render"
-  | "storage"
-  | "transfer"
-
-type VerticalAlign =
-  | "top"
-  | "middle"
-  | "bottom"
-
-type Winding =
-  | "clockwise"
-  | "counterclockwise"
-
-type WrapMode =
-  | "clamp"
-  | "repeat"
-  | "mirror"
-  | "border"
-
-declare class Buffer extends Object
-  function clear(self, offset: number?, extent: number?, value: number?)
-  function getData(self, index: number?, count: number?): {}
-  function getFormat(self): {}
-  function getLength(self): number
-  function getSize(self): number
-  function getStride(self): number
-  function mapData(self, offset: number?, extent: number?): lightuserdata
-  function newReadback(self, offset: number?, extent: number?): Readback
-  function setData(self, table: {}, destinationIndex: number?, sourceIndex: number?, count: number?)
-  function setData(self, ...: number)
-  function setData(self, vector: any)
-  function setData(self, blob: Blob, destinationOffset: number?, sourceOffset: number?, size: number?)
-  function setData(self, buffer: Buffer, destinationOffset: number?, sourceOffset: number?, size: number?)
-end
-
-declare class Font extends Object
-  function getAscent(self): number
-  function getDescent(self): number
-  function getHeight(self): number
-  function getKerning(self, first: string | number, second: string | number): number
-  function getLineSpacing(self): number
-  function getLines(self, string: string, wrap: number): {string}
-  function getLines(self, strings: {}, wrap: number): {string}
-  function getPixelDensity(self): number
-  function getRasterizer(self): Rasterizer
-  function getVertices(self, string: string, wrap: number?, halign: HorizontalAlign, valign: VerticalAlign): ({number}, Material)
-  function getVertices(self, strings: {}, wrap: number?, halign: HorizontalAlign, valign: VerticalAlign): ({number}, Material)
-  function getWidth(self, string: string): number
-  function getWidth(self, strings: {}): number
-  function setLineSpacing(self, spacing: number)
-  function setPixelDensity(self, density: number)
-  function setPixelDensity(self)
-end
-
-declare class Material extends Object
-  function getProperties(self): {}
-end
-
-declare class Mesh extends Object
-  function computeBoundingBox(self): boolean
-  function getBoundingBox(self): (number, number, number, number, number, number)
-  function getDrawMode(self): DrawMode
-  function getDrawRange(self): (number, number, number)
-  function getDrawRange(self)
-  function getIndexBuffer(self): Buffer
-  function getIndices(self): {number}
-  function getMaterial(self): Material
-  function getVertexBuffer(self): Buffer
-  function getVertexCount(self): number
-  function getVertexFormat(self): {}
-  function getVertexStride(self): number
-  function getVertices(self, index: number?, count: number?): {{number}}
-  function setBoundingBox(self, minx: number, maxx: number, miny: number, maxy: number, minz: number, maxz: number)
-  function setBoundingBox(self)
-  function setDrawMode(self, mode: DrawMode)
-  function setDrawRange(self, start: number, count: number, offset: number)
-  function setDrawRange(self)
-  function setIndexBuffer(self, buffer: Buffer)
-  function setIndices(self, t: {number})
-  function setIndices(self, blob: Blob, type: DataType)
-  function setIndices(self)
-  function setMaterial(self, material: Material)
-  function setMaterial(self, texture: Texture)
-  function setVertices(self, vertices: {{number}}, index: number?, count: number?)
-  function setVertices(self, blob: Blob, index: number?, count: number?)
-end
-
-declare class Model extends Object
-  function animate(self, animation: string, time: number, blend: number?)
-  function clone(self): Model
-  function getAnimationCount(self): number
-  function getAnimationDuration(self, animation: string | number): number
-  function getAnimationName(self, index: number): string | nil
-  function getBlendShapeCount(self): number
-  function getBlendShapeName(self, index: number): string
-  function getBlendShapeWeight(self, blendshape: string | number): number
-  function getBoundingBox(self): (number, number, number, number, number, number)
-  function getBoundingSphere(self): (number, number, number, number)
-  function getCenter(self): (number, number, number)
-  function getData(self): ModelData
-  function getDepth(self): number
-  function getDimensions(self): (number, number, number)
-  function getHeight(self): number
-  function getIndexBuffer(self): Buffer
-  function getMaterial(self, which: string | number): Material
-  function getMaterialCount(self): number
-  function getMaterialName(self, index: number): string
-  function getMesh(self, index: number): Mesh
-  function getMeshCount(self): number
-  function getMetadata(self): string
-  function getNodeChildren(self, node: string | number): {number}
-  function getNodeCount(self): number
-  function getNodeName(self, index: number): string
-  function getNodeOrientation(self, node: string | number, origin: OriginType?): (number, number, number, number)
-  function getNodeParent(self, node: number): number
-  function getNodePose(self, node: string | number, origin: OriginType?): (number, number, number, number, number, number, number)
-  function getNodePosition(self, node: string | number, space: OriginType?): (number, number, number)
-  function getNodeScale(self, node: string | number, origin: OriginType?): (number, number, number)
-  function getNodeTransform(self, node: string | number, origin: OriginType?): (number, number, number, number, number, number, number, number, number, number)
-  function getRootNode(self): number
-  function getTexture(self, index: number): Texture
-  function getTextureCount(self): number
-  function getTriangleCount(self): number
-  function getTriangles(self): ({number}, {number})
-  function getVertexBuffer(self): Buffer
-  function getVertexCount(self): number
-  function getWidth(self): number
-  function hasJoints(self): boolean
-  function resetBlendShapes(self)
-  function resetNodeTransforms(self)
-  function setBlendShapeWeight(self, blendshape: string | number, weight: number)
-  function setNodeOrientation(self, node: string | number, angle: number, ax: number, ay: number, az: number, blend: number?)
-  function setNodeOrientation(self, node: string | number, orientation: Quat, blend: number?)
-  function setNodePose(self, node: string | number, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number, blend: number?)
-  function setNodePose(self, node: string | number, position: Vec3, orientation: Quat, blend: number?)
-  function setNodePosition(self, node: string | number, x: number, y: number, z: number, blend: number?)
-  function setNodePosition(self, node: string | number, position: Vec3, blend: number?)
-  function setNodeScale(self, node: string | number, sx: number, sy: number, sz: number, blend: number?)
-  function setNodeScale(self, node: string | number, scale: Vec3, blend: number?)
-  function setNodeTransform(self, node: string | number, x: number, y: number, z: number, sx: number, sy: number, sz: number, angle: number, ax: number, ay: number, az: number, blend: number?)
-  function setNodeTransform(self, node: string | number, position: Vec3, scale: Vec3, orientation: Quat, blend: number?)
-  function setNodeTransform(self, node: string | number, transform: Mat4, blend: number?)
-end
-
-declare class Pass extends Object
-  function barrier(self)
-  function beginTally(self): number
-  function box(self, x: number?, y: number?, z: number?, width: number?, height: number?, depth: number?, angle: number?, ax: number?, ay: number?, az: number?, style: DrawStyle?)
-  function box(self, position: Vec3, size: Vec3, orientation: Quat, style: DrawStyle?)
-  function box(self, transform: Mat4, style: DrawStyle?)
-  function capsule(self, x: number?, y: number?, z: number?, radius: number?, length: number?, angle: number?, ax: number?, ay: number?, az: number?, segments: number?)
-  function capsule(self, position: Vec3, radius: number?, length: number?, orientation: Quat, segments: number?)
-  function capsule(self, transform: Mat4, segments: number?)
-  function capsule(self, p1: Vec3, p2: Vec3, radius: number?, segments: number?)
-  function circle(self, x: number?, y: number?, z: number?, radius: number?, angle: number?, ax: number?, ay: number?, az: number?, style: DrawStyle?, angle1: number?, angle2: number?, segments: number?)
-  function circle(self, position: Vec3, radius: number?, orientation: Quat, style: DrawStyle?, angle1: number?, angle2: number?, segments: number?)
-  function circle(self, transform: Mat4, style: DrawStyle?, angle1: number?, angle2: number?, segments: number?)
-  function compute(self, x: number?, y: number?, z: number?)
-  function compute(self, buffer: Buffer, offset: number?)
-  function cone(self, x: number?, y: number?, z: number?, radius: number?, length: number?, angle: number?, ax: number?, ay: number?, az: number?, segments: number?)
-  function cone(self, position: Vec3, radius: number?, length: number?, orientation: Quat, segments: number?)
-  function cone(self, transform: Mat4, segments: number?)
-  function cone(self, p1: Vec3, p2: Vec3, radius: number?, segments: number?)
-  function cube(self, x: number?, y: number?, z: number?, size: number?, angle: number?, ax: number?, ay: number?, az: number?, style: DrawStyle?)
-  function cube(self, position: Vec3, size: number?, orientation: Quat, style: DrawStyle?)
-  function cube(self, transform: Mat4, style: DrawStyle?)
-  function cylinder(self, x: number?, y: number?, z: number?, radius: number?, length: number?, angle: number?, ax: number?, ay: number?, az: number?, capped: boolean?, angle1: number?, angle2: number?, segments: number?)
-  function cylinder(self, position: Vec3, radius: number?, length: number?, orientation: Quat, capped: boolean?, angle1: number?, angle2: number?, segments: number?)
-  function cylinder(self, transform: Mat4, capped: boolean?, angle1: number?, angle2: number?, segments: number?)
-  function cylinder(self, p1: Vec3, p2: Vec3, radius: number?, capped: boolean?, angle1: number?, angle2: number?, segments: number?)
-  function draw(self, object: Model | Mesh | Texture, x: number?, y: number?, z: number?, scale: number?, angle: number?, ax: number?, ay: number?, az: number?, instances: number?)
-  function draw(self, object: Model | Mesh | Texture, position: Vec3, scale3: Vec3, orientation: Quat, instances: number?)
-  function draw(self, object: Model | Mesh | Texture, transform: Mat4, instances: number?)
-  function fill(self, texture: Texture)
-  function fill(self)
-  function finishTally(self): number
-  function getCanvas(self): {}
-  function getCanvas(self)
-  function getClear(self): {}
-  function getDimensions(self): (number, number)
-  function getHeight(self): number
-  function getLabel(self): string
-  function getProjection(self, view: number): (number, number, number, number)
-  function getProjection(self, view: number, matrix: Mat4): Mat4
-  function getStats(self): {}
-  function getTallyBuffer(self): (Buffer, number)
-  function getViewCount(self): number
-  function getViewPose(self, view: number): (number, number, number, number, number, number, number)
-  function getViewPose(self, view: number, matrix: Mat4, invert: boolean): Mat4
-  function getWidth(self): number
-  function line(self, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, ...: number)
-  function line(self, t: {number | Vec3})
-  function line(self, v1: Vec3, v2: Vec3, ...: Vec3)
-  function mesh(self, vertices: Buffer?, x: number?, y: number?, z: number?, scale: number?, angle: number?, ax: number?, ay: number?, az: number?, start: number?, count: number?, instances: number?)
-  function mesh(self, vertices: Buffer?, position: Vec3, scales: Vec3, orientation: Quat, start: number?, count: number?, instances: number?)
-  function mesh(self, vertices: Buffer?, transform: Mat4, start: number?, count: number?, instances: number?)
-  function mesh(self, vertices: Buffer?, indices: Buffer, x: number?, y: number?, z: number?, scale: number?, angle: number?, ax: number?, ay: number?, az: number?, start: number?, count: number?, instances: number?, base: number?)
-  function mesh(self, vertices: Buffer?, indices: Buffer, position: Vec3, scales: Vec3, orientation: Quat, start: number?, count: number?, instances: number?, base: number?)
-  function mesh(self, vertices: Buffer?, indices: Buffer, transform: Mat4, start: number?, count: number?, instances: number?, base: number?)
-  function mesh(self, vertices: Buffer?, indices: Buffer, draws: Buffer, drawcount: number?, offset: number?, stride: number?)
-  function origin(self)
-  function plane(self, x: number?, y: number?, z: number?, width: number?, height: number?, angle: number?, ax: number?, ay: number?, az: number?, style: DrawStyle?, columns: number?, rows: number?)
-  function plane(self, position: Vec3, size: Vec2, orientation: Quat, style: DrawStyle?, columns: number?, rows: number?)
-  function plane(self, transform: Mat4, style: DrawStyle?, columns: number?, rows: number?)
-  function points(self, x: number, y: number, z: number, ...: any)
-  function points(self, t: {number | Vec3})
-  function points(self, v: Vec3, ...: any)
-  function polygon(self, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, ...: any)
-  function polygon(self, t: {number | Vec3})
-  function polygon(self, v1: Vec3, v2: Vec3, ...: any)
-  function pop(self, stack: StackType?)
-  function push(self, stack: StackType?)
-  function reset(self)
-  function rotate(self, angle: number, ax: number, ay: number, az: number)
-  function rotate(self, rotation: Quat)
-  function roundrect(self, x: number?, y: number?, z: number?, width: number?, height: number?, thickness: number?, angle: number?, ax: number?, ay: number?, az: number?, radius: number?, segments: number?)
-  function roundrect(self, position: Vec3, size: Vec3, orientation: Quat, radius: number?, segments: number?)
-  function roundrect(self, transform: Mat4, radius: number?, segments: number?)
-  function scale(self, sx: number, sy: number?, sz: number?)
-  function scale(self, scale: Vec3)
-  function send(self, name: string, buffer: Buffer, offset: number?, extent: number?)
-  function send(self, name: string, texture: Texture)
-  function send(self, name: string, sampler: Sampler)
-  function send(self, name: string, data: any)
-  function setAlphaToCoverage(self, enable: boolean)
-  function setBlendMode(self, blend: BlendMode, alphaBlend: BlendAlphaMode)
-  function setBlendMode(self)
-  function setBlendMode(self, index: number, blend: BlendMode, alphaBlend: BlendAlphaMode)
-  function setBlendMode(self, index: number)
-  function setCanvas(self, ...: Texture)
-  function setCanvas(self, canvas: {})
-  function setCanvas(self)
-  function setClear(self, hex: number)
-  function setClear(self, r: number, g: number, b: number, a: number?)
-  function setClear(self, clear: boolean)
-  function setClear(self, t: {})
-  function setColor(self, r: number, g: number, b: number, a: number?)
-  function setColor(self, t: {number})
-  function setColor(self, hex: number, a: number?)
-  function setColorWrite(self, enable: boolean)
-  function setColorWrite(self, r: boolean, g: boolean, b: boolean, a: boolean)
-  function setColorWrite(self, index: number, enable: boolean)
-  function setColorWrite(self, index: number, r: boolean, g: boolean, b: boolean, a: boolean)
-  function setCullMode(self, mode: CullMode)
-  function setCullMode(self)
-  function setDepthClamp(self, enable: boolean)
-  function setDepthOffset(self, offset: number?, sloped: number?)
-  function setDepthTest(self, test: CompareMode)
-  function setDepthTest(self)
-  function setDepthWrite(self, write: boolean)
-  function setFaceCull(self, mode: CullMode)
-  function setFaceCull(self)
-  function setFont(self, font: Font)
-  function setMaterial(self, material: Texture | Material)
-  function setMaterial(self)
-  function setMeshMode(self, mode: DrawMode)
-  function setProjection(self, view: number, left: number, right: number, up: number, down: number, near: number?, far: number?)
-  function setProjection(self, view: number, matrix: Mat4)
-  function setSampler(self, sampler: Sampler | FilterMode | nil)
-  function setScissor(self, x: number, y: number, w: number, h: number)
-  function setScissor(self)
-  function setShader(self, shader: Shader | DefaultShader)
-  function setShader(self)
-  function setStencilTest(self, test: CompareMode, value: number, mask: number?)
-  function setStencilTest(self)
-  function setStencilWrite(self, action: StencilAction | {StencilAction}, value: number?, mask: number?)
-  function setStencilWrite(self)
-  function setTallyBuffer(self, buffer: Buffer, offset: number)
-  function setTallyBuffer(self)
-  function setViewCull(self, enable: boolean)
-  function setViewPose(self, view: number, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number)
-  function setViewPose(self, view: number, position: Vec3, orientation: Quat)
-  function setViewPose(self, view: number, matrix: Mat4, inverted: boolean)
-  function setViewport(self, x: number, y: number, w: number, h: number, dmin: number?, dmax: number?)
-  function setViewport(self)
-  function setWinding(self, winding: Winding)
-  function setWireframe(self, enable: boolean)
-  function skybox(self, skybox: Texture)
-  function skybox(self)
-  function sphere(self, x: number?, y: number?, z: number?, radius: number?, angle: number?, ax: number?, ay: number?, az: number?, longitudes: number?, latitudes: number?)
-  function sphere(self, position: Vec3, radius: number?, orientation: Quat, longitudes: number?, latitudes: number?)
-  function sphere(self, transform: Mat4, longitudes: number?, latitudes: number?)
-  function text(self, text: string, x: number?, y: number?, z: number?, scale: number?, angle: number?, ax: number?, ay: number?, az: number?, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function text(self, text: string, position: Vec3, scale: number?, orientation: Quat, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function text(self, text: string, transform: Mat4, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function text(self, colortext: {}, x: number?, y: number?, z: number?, scale: number?, angle: number?, ax: number?, ay: number?, az: number?, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function text(self, colortext: {}, position: Vec3, scale: number?, orientation: Quat, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function text(self, colortext: {}, transform: Mat4, wrap: number?, halign: HorizontalAlign?, valign: VerticalAlign?)
-  function torus(self, x: number?, y: number?, z: number?, radius: number?, thickness: number?, angle: number?, ax: number?, ay: number?, az: number?, tsegments: number?, psegments: number?)
-  function torus(self, position: Vec3, scale: Vec3, orientation: Quat, tsegments: number?, psegments: number?)
-  function torus(self, transform: Mat4, tsegments: number?, psegments: number?)
-  function transform(self, x: number, y: number, z: number, sx: number, sy: number, sz: number, angle: number, ax: number, ay: number, az: number)
-  function transform(self, translation: Vec3, scale: Vec3, rotation: Quat)
-  function transform(self, transform: Mat4)
-  function translate(self, x: number, y: number, z: number)
-  function translate(self, translation: Vec3)
-end
-
-declare class Readback extends Object
-  function getBlob(self): Blob
-  function getData(self): {}
-  function getImage(self): Image
-  function isComplete(self): boolean
-  function wait(self): boolean
-end
-
-declare class Sampler extends Object
-  function getAnisotropy(self): number
-  function getCompareMode(self): CompareMode
-  function getFilter(self): (FilterMode, FilterMode, FilterMode)
-  function getMipmapRange(self): (number, number)
-  function getWrap(self): (WrapMode, WrapMode, WrapMode)
-end
-
-declare class Shader extends Object
-  function clone(self, source: Shader, flags: {}): Shader
-  function getBufferFormat(self, name: string): ({}, number)
-  function getLabel(self): string
-  function getType(self): ShaderType
-  function getWorkgroupSize(self): (number, number, number)
-  function hasAttribute(self, name: string): boolean
-  function hasAttribute(self, location: number): boolean
-  function hasStage(self, stage: ShaderStage): boolean
-  function hasVariable(self, name: string): boolean
-end
-
-declare class Texture extends Object
-  function clear(self)
-  function clear(self, hex: number, layer: number?, layerCount: number?, mipmap: number?, mipmapCount: number?)
-  function clear(self, r: number, g: number, b: number, a: number, layer: number?, layerCount: number?, mipmap: number?, mipmapCount: number?)
-  function clear(self, t: {number}, layer: number?, layerCount: number?, mipmap: number?, mipmapCount: number?)
-  function clear(self, v3: Vec3, layer: number?, layerCount: number?, mipmap: number?, mipmapCount: number?)
-  function clear(self, v4: Vec4, layer: number?, layerCount: number?, mipmap: number?, mipmapCount: number?)
-  function generateMipmaps(self, base: number?, count: number?)
-  function getDimensions(self): (number, number, number)
-  function getFormat(self): (TextureFormat, boolean)
-  function getHeight(self): number
-  function getLabel(self): string
-  function getLayerCount(self): number
-  function getMipmapCount(self): number
-  function getPixels(self, x: number?, y: number?, layer: number?, mipmap: number?, width: number?, height: number?): Image
-  function getSampleCount(self): number
-  function getSampler(self): Sampler
-  function getType(self): TextureType
-  function getWidth(self): number
-  function hasUsage(self, ...: TextureUsage): boolean
-  function newReadback(self, x: number?, y: number?, layer: number?, mipmap: number?, width: number?, height: number?): Readback
-  function setPixels(self, source: Texture | Image, dstx: number?, dsty: number?, dstlayer: number?, dstmipmap: number?, srcx: number?, srcy: number?, srclayer: number?, srcmipmap: number?, width: number?, height: number?, layers: number?)
-  function setSampler(self, mode: FilterMode)
-  function setSampler(self, sampler: Sampler)
-  function setSampler(self)
-end
-
-type GraphicsModule = {
-  compileShader: (stage: ShaderStage, source: string | Blob) -> Blob,
-  getBackgroundColor: () -> (number, number, number, number),
-  getDefaultFont: () -> Font,
-  getDevice: () -> {},
-  getFeatures: () -> {},
-  getLimits: () -> {},
-  getWindowPass: () -> Pass | nil,
-  isFormatSupported: (format: TextureFormat, ...TextureFeature) -> (boolean, boolean),
-  isHDR: () -> boolean,
-  isTimingEnabled: () -> boolean,
-  newBuffer:
-    & ((size: number) -> Buffer)
-    & ((blob: Blob) -> Buffer)
-    & ((format: {} | DataType, length: number?) -> Buffer)
-    & ((format: {} | DataType, data: {} | Blob) -> Buffer),
-  newFont:
-    & ((file: string | Blob, size: number?, spread: number?) -> Font)
-    & ((size: number?, spread: number?) -> Font)
-    & ((rasterizer: Rasterizer, spread: number?) -> Font),
-  newMaterial: (properties: {}) -> Material,
-  newMesh:
-    & ((count: number, storage: MeshStorage?) -> Mesh)
-    & ((vertices: {}, storage: MeshStorage?) -> Mesh)
-    & ((blob: Blob, storage: MeshStorage?) -> Mesh)
-    & ((format: {}, count: number, storage: MeshStorage?) -> Mesh)
-    & ((format: {}, vertices: {}, storage: MeshStorage?) -> Mesh)
-    & ((format: {}, blob: Blob, storage: MeshStorage?) -> Mesh)
-    & ((buffer: Buffer) -> Mesh),
-  newModel:
-    & ((file: string | Blob, options: {}?) -> Model)
-    & ((modelData: ModelData, options: {}?) -> Model),
-  newPass:
-    & ((...Texture) -> Pass)
-    & ((canvas: {}) -> Pass)
-    & (() -> Pass),
-  newSampler: (parameters: {}) -> Sampler,
-  newShader:
-    & ((vertex: string | DefaultShader | Blob, fragment: string | DefaultShader | Blob, options: {}?) -> Shader)
-    & ((compute: string | Blob, options: {}?) -> Shader)
-    & ((defaultshader: DefaultShader, options: {}?) -> Shader),
-  newTexture:
-    & ((file: string | Blob, options: {}?) -> Texture)
-    & ((width: number, height: number, options: {}?) -> Texture)
-    & ((width: number, height: number, layers: number, options: {}?) -> Texture)
-    & ((image: string, options: {}?) -> Texture)
-    & ((images: {string | Blob | Image}, options: {}?) -> Texture),
-  newTextureView: (parent: Texture, options: {}?) -> Texture,
-  present: () -> (),
-  setBackgroundColor:
-    & ((r: number, g: number, b: number, a: number?) -> ())
-    & ((hex: number, a: number?) -> ())
-    & ((table: {number}) -> ()),
-  setTimingEnabled: (enable: boolean) -> (),
-  submit:
-    & ((...Pass | boolean | nil) -> boolean)
-    & ((t: {Pass | boolean}) -> boolean),
-  wait: () -> (),
-}
-
-type Device =
-  | "head"
-  | "floor"
-  | "left"
-  | "right"
-  | "hand/left"
-  | "hand/right"
-  | "hand/left/grip"
-  | "hand/right/grip"
-  | "hand/left/point"
-  | "hand/right/point"
-  | "hand/left/pinch"
-  | "hand/right/pinch"
-  | "hand/left/poke"
-  | "hand/right/poke"
-  | "elbow/left"
-  | "elbow/right"
-  | "shoulder/left"
-  | "shoulder/right"
-  | "chest"
-  | "waist"
-  | "knee/left"
-  | "knee/right"
-  | "foot/left"
-  | "foot/right"
-  | "camera"
-  | "keyboard"
-  | "stylus"
-  | "eye/left"
-  | "eye/right"
-  | "eye/gaze"
-
-type DeviceAxis =
-  | "trigger"
-  | "thumbstick"
-  | "thumbrest"
-  | "touchpad"
-  | "grip"
-  | "nib"
-
-type DeviceButton =
-  | "trigger"
-  | "thumbstick"
-  | "thumbrest"
-  | "touchpad"
-  | "grip"
-  | "menu"
-  | "a"
-  | "b"
-  | "x"
-  | "y"
-  | "nib"
-
-type FoveationLevel =
-  | "low"
-  | "medium"
-  | "high"
-
-type HeadsetDriver =
-  | "simulator"
-  | "openxr"
-
-type HeadsetOrigin =
-  | "head"
-  | "floor"
-
-type PassthroughMode =
-  | "opaque"
-  | "blend"
-  | "add"
-
-declare class Layer extends Object
-  function getColor(self): (number, number, number, number)
-  function getCurve(self): number
-  function getDimensions(self): (number, number)
-  function getOrientation(self): (number, number, number, number)
-  function getPass(self): Pass
-  function getPose(self): (number, number, number, number, number, number, number)
-  function getPosition(self): (number, number, number)
-  function getTexture(self): Texture
-  function getViewport(self): (number, number, number, number)
-  function setColor(self, r: number, g: number, b: number, a: number?)
-  function setColor(self, t: {number})
-  function setColor(self, hex: number, a: number?)
-  function setCurve(self, curve: number?)
-  function setDimensions(self, width: number, height: number)
-  function setOrientation(self, angle: number, ax: number, ay: number, az: number)
-  function setOrientation(self, orientation: Quat)
-  function setPose(self, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number)
-  function setPose(self, position: Vec3, orientation: Quat)
-  function setPosition(self, x: number, y: number, z: number)
-  function setViewport(self, x: number, y: number, w: number, h: number)
-end
-
-type HeadsetModule = {
-  animate:
-    & ((model: Model) -> boolean)
-    & ((device: Device?, model: Model) -> boolean),
-  getAngularVelocity: (device: Device?) -> (number, number, number),
-  getAxis: (device: Device, axis: DeviceAxis) -> number | nil,
-  getBoundsDepth: () -> number,
-  getBoundsDimensions: () -> (number, number),
-  getBoundsGeometry: (t: {}?) -> {},
-  getBoundsWidth: () -> number,
-  getClipDistance: () -> (number, number),
-  getDeltaTime: () -> number,
-  getDirection: (device: Device?) -> (number, number, number),
-  getDisplayDimensions: () -> (number, number),
-  getDisplayHeight: () -> number,
-  getDisplayWidth: () -> number,
-  getDriver: () -> (HeadsetDriver, string),
-  getFeatures: () -> {},
-  getFoveation: () -> (FoveationLevel, boolean),
-  getHandles: () -> (lightuserdata, lightuserdata),
-  getHands: () -> {Device},
-  getLayers: () -> {Layer},
-  getName: () -> string,
-  getOrientation: (device: Device?) -> (number, number, number, number),
-  getPass: () -> Pass | nil,
-  getPassthrough: () -> PassthroughMode,
-  getPassthroughModes: () -> {},
-  getPose: (device: Device?) -> (number, number, number, number, number, number, number),
-  getPosition: (device: Device?) -> (number, number, number),
-  getRefreshRate: () -> number | nil,
-  getRefreshRates: () -> {} | nil,
-  getSkeleton:
-    & ((device: Device) -> {{number}} | nil)
-    & ((device: Device, t: {}) -> {{number}} | nil),
-  getTexture: () -> Texture | nil,
-  getTime: () -> number,
-  getVelocity: (device: Device?) -> (number, number, number),
-  getViewAngles: (view: number) -> (number | nil, number | nil, number | nil, number | nil),
-  getViewCount: () -> number,
-  getViewPose: (view: number) -> (number | nil, number | nil, number | nil, number | nil, number | nil, number | nil, number | nil),
-  isActive: () -> boolean,
-  isDown: (device: Device, button: DeviceButton) -> boolean | nil,
-  isFocused: () -> boolean,
-  isMounted: () -> boolean,
-  isSeated: () -> boolean,
-  isTouched: (device: Device, button: DeviceButton) -> boolean | nil,
-  isTracked: (device: Device?) -> boolean,
-  isVisible: () -> boolean,
-  newLayer: (width: number, height: number) -> Layer,
-  newModel:
-    & ((key: lightuserdata) -> Model)
-    & ((device: Device?) -> Model),
-  setBackground:
-    & ((background: Image | {Image} | Texture) -> ())
-    & (() -> ()),
-  setClipDistance: (near: number, far: number) -> (),
-  setFoveation:
-    & ((level: FoveationLevel, dynamic: boolean?) -> boolean)
-    & (() -> boolean),
-  setLayers:
-    & ((...Layer) -> ())
-    & ((t: {}) -> ()),
-  setPassthrough:
-    & ((mode: PassthroughMode) -> boolean)
-    & ((transparent: boolean) -> boolean)
-    & (() -> boolean),
-  setRefreshRate: (rate: number) -> boolean,
-  start: () -> (),
-  stop: () -> (),
-  stopVibration: (device: Device?) -> (),
-  submit: () -> (),
-  update: () -> (),
-  vibrate: (device: Device?, strength: number?, duration: number?, frequency: number?) -> boolean,
-  wasPressed: (device: Device, button: DeviceButton) -> boolean,
-  wasReleased: (device: Device, button: DeviceButton) -> boolean,
-}
-
-declare class Curve extends Object
-  function addPoint(self, x: number, y: number, z: number, index: number?)
-  function evaluate(self, t: number): (number, number, number)
-  function getPoint(self, index: number): (number, number, number)
-  function getPointCount(self): number
-  function getTangent(self, t: number): (number, number, number)
-  function removePoint(self, index: number)
-  function render(self, n: number?, t1: number?, t2: number?): {number}
-  function setPoint(self, index: number, x: number, y: number, z: number)
-  function slice(self, t1: number, t2: number): Curve
-end
-
-declare class RandomGenerator extends Object
-  function getSeed(self): (number, number)
-  function getState(self): string
-  function random(self): number
-  function random(self, high: number): number
-  function random(self, low: number, high: number): number
-  function randomNormal(self, sigma: number?, mu: number?): number
-  function setSeed(self, seed: number)
-  function setSeed(self, low: number, high: number)
-  function setState(self, state: string)
-end
-
-type MathModule = {
-  drain: () -> (),
-  gammaToLinear:
-    & ((gr: number, gg: number, gb: number) -> (number, number, number))
-    & ((color: {number}) -> (number, number, number))
-    & ((x: number) -> number),
-  getRandomSeed: () -> number,
-  linearToGamma:
-    & ((lr: number, lg: number, lb: number) -> (number, number, number))
-    & ((color: {number}) -> (number, number, number))
-    & ((x: number) -> number),
-  mat4:
-    & (() -> Mat4)
-    & ((n: Mat4) -> Mat4)
-    & ((position: Vec3?, scale: Vec3?, rotation: Quat?) -> Mat4)
-    & ((position: Vec3?, rotation: Quat?) -> Mat4)
-    & ((...number) -> Mat4)
-    & ((d: number) -> Mat4),
-  newCurve:
-    & ((x: number, y: number, z: number, ...any) -> Curve)
-    & ((v: Vec3, ...any) -> Curve)
-    & ((points: {}) -> Curve)
-    & ((n: number) -> Curve),
-  newMat4:
-    & (() -> Mat4)
-    & ((n: Mat4) -> Mat4)
-    & ((position: Vec3?, scale: Vec3?, rotation: Quat?) -> Mat4)
-    & ((position: Vec3?, rotation: Quat?) -> Mat4)
-    & ((...number) -> Mat4)
-    & ((d: number) -> Mat4),
-  newQuat:
-    & ((angle: number?, ax: number?, ay: number?, az: number?, raw: boolean?) -> Quat)
-    & ((r: Quat) -> Quat)
-    & ((v: Vec3) -> Quat)
-    & ((v: Vec3, u: Vec3) -> Quat)
-    & ((m: Mat4) -> Quat)
-    & (() -> Quat),
-  newRandomGenerator:
-    & (() -> RandomGenerator)
-    & ((seed: number) -> RandomGenerator)
-    & ((low: number, high: number) -> RandomGenerator),
-  newVec2:
-    & ((x: number?, y: number?) -> Vec2)
-    & ((u: Vec2) -> Vec2),
-  newVec3:
-    & ((x: number?, y: number?, z: number?) -> Vec3)
-    & ((u: Vec3) -> Vec3)
-    & ((m: Mat4) -> Vec3)
-    & ((q: Quat) -> Vec3),
-  newVec4:
-    & ((x: number?, y: number?, z: number?, w: number?) -> Vec4)
-    & ((u: Vec4) -> Vec4),
-  noise:
-    & ((x: number) -> number)
-    & ((x: number, y: number) -> number)
-    & ((x: number, y: number, z: number) -> number)
-    & ((x: number, y: number, z: number, w: number) -> number),
-  quat:
-    & ((angle: number?, ax: number?, ay: number?, az: number?, raw: boolean?) -> Quat)
-    & ((r: Quat) -> Quat)
-    & ((v: Vec3) -> Quat)
-    & ((v: Vec3, u: Vec3) -> Quat)
-    & ((m: Mat4) -> Quat)
-    & (() -> Quat),
-  random:
-    & (() -> number)
-    & ((high: number) -> number)
-    & ((low: number, high: number) -> number),
-  randomNormal: (sigma: number?, mu: number?) -> number,
-  setRandomSeed: (seed: number) -> (),
-  vec2:
-    & ((x: number?, y: number?) -> Vec2)
-    & ((u: Vec2) -> Vec2),
-  vec3:
-    & ((x: number?, y: number?, z: number?) -> Vec3)
-    & ((u: Vec3) -> Vec3)
-    & ((m: Mat4) -> Vec3)
-    & ((q: Quat) -> Vec3),
-  vec4:
-    & ((x: number?, y: number?, z: number?, w: number?) -> Vec4)
-    & ((u: Vec4) -> Vec4),
-}
-
-type JointType =
-  | "ball"
-  | "distance"
-  | "hinge"
-  | "slider"
-
-type MotorMode =
-  | "position"
-  | "velocity"
-
-type ShapeType =
-  | "box"
-  | "sphere"
-  | "capsule"
-  | "cylinder"
-  | "convex"
-  | "mesh"
-  | "terrain"
-
-declare class BallJoint extends Joint
-end
-
-declare class BoxShape extends Shape
-  function getDimensions(self): (number, number, number)
-  function setDimensions(self, width: number, height: number, depth: number)
-end
-
-declare class CapsuleShape extends Shape
-  function getLength(self): number
-  function getRadius(self): number
-  function setLength(self, length: number)
-  function setRadius(self, radius: number)
-end
-
-declare class Collider extends Object
-  function addShape(self, shape: Shape)
-  function applyAngularImpulse(self, x: number, y: number, z: number)
-  function applyAngularImpulse(self, impulse: Vec3)
-  function applyForce(self, x: number, y: number, z: number)
-  function applyForce(self, x: number, y: number, z: number, px: number, py: number, pz: number)
-  function applyForce(self, force: Vec3)
-  function applyForce(self, force: Vec3, position: Vec3)
-  function applyLinearImpulse(self, x: number, y: number, z: number)
-  function applyLinearImpulse(self, x: number, y: number, z: number, px: number, py: number, pz: number)
-  function applyLinearImpulse(self, impulse: Vec3)
-  function applyLinearImpulse(self, impulse: Vec3, position: Vec3)
-  function applyTorque(self, x: number, y: number, z: number)
-  function applyTorque(self, torque: Vec3)
-  function destroy(self)
-  function getAABB(self): (number, number, number, number, number, number)
-  function getAngularDamping(self): number
-  function getAngularVelocity(self): (number, number, number)
-  function getAutomaticMass(self): boolean
-  function getCenterOfMass(self): (number, number, number)
-  function getDegreesOfFreedom(self): (string, string)
-  function getFriction(self): number
-  function getGravityScale(self): number
-  function getInertia(self): (number, number, number, number, number, number, number)
-  function getJoints(self): {}
-  function getLinearDamping(self): number
-  function getLinearVelocity(self): (number, number, number)
-  function getLinearVelocityFromLocalPoint(self, x: number, y: number, z: number): (number, number, number)
-  function getLinearVelocityFromLocalPoint(self, point: Vec3): (number, number, number)
-  function getLinearVelocityFromWorldPoint(self, x: number, y: number, z: number): (number, number, number)
-  function getLinearVelocityFromWorldPoint(self, point: Vec3): (number, number, number)
-  function getLocalPoint(self, wx: number, wy: number, wz: number): (number, number, number)
-  function getLocalPoint(self, point: Vec3): (number, number, number)
-  function getLocalVector(self, wx: number, wy: number, wz: number): (number, number, number)
-  function getLocalVector(self, vector: Vec3): (number, number, number)
-  function getMass(self): number
-  function getOrientation(self): (number, number, number, number)
-  function getPose(self): (number, number, number, number, number, number, number)
-  function getPosition(self): (number, number, number)
-  function getRestitution(self): number
-  function getShape(self): Shape | nil
-  function getShapes(self): {}
-  function getTag(self): string | nil
-  function getUserData(self): any
-  function getWorld(self): World
-  function getWorldPoint(self, x: number, y: number, z: number): (number, number, number)
-  function getWorldPoint(self, point: Vec3): (number, number, number)
-  function getWorldVector(self, x: number, y: number, z: number): (number, number, number)
-  function getWorldVector(self, vector: Vec3): (number, number, number)
-  function isAwake(self): boolean
-  function isContinuous(self): boolean
-  function isDestroyed(self): boolean
-  function isEnabled(self): boolean
-  function isGravityIgnored(self): boolean
-  function isKinematic(self): boolean
-  function isSensor(self): boolean
-  function isSleepingAllowed(self): boolean
-  function moveKinematic(self)
-  function removeShape(self, shape: Shape)
-  function resetMassData(self)
-  function setAngularDamping(self, damping: number)
-  function setAngularVelocity(self, vx: number, vy: number, vz: number)
-  function setAngularVelocity(self, velocity: Vec3)
-  function setAutomaticMass(self, enable: boolean)
-  function setAwake(self, awake: boolean)
-  function setCenterOfMass(self, x: number, y: number, z: number)
-  function setCenterOfMass(self, center: Vec3)
-  function setContinuous(self, continuous: boolean)
-  function setDegreesOfFreedom(self, translation: string?, rotation: string?)
-  function setEnabled(self, enable: boolean)
-  function setFriction(self, friction: number)
-  function setGravityIgnored(self, ignored: boolean)
-  function setGravityScale(self, scale: number)
-  function setInertia(self, dx: number, dy: number, dz: number, angle: number, ax: number, ay: number, az: number)
-  function setInertia(self, diagonal: Vec3, rotation: Quat)
-  function setKinematic(self, kinematic: boolean)
-  function setLinearDamping(self, damping: number)
-  function setLinearVelocity(self, vx: number, vy: number, vz: number)
-  function setLinearVelocity(self, velocity: Vec3)
-  function setMass(self, mass: number)
-  function setOrientation(self, angle: number, ax: number, ay: number, az: number)
-  function setOrientation(self, orientation: Quat)
-  function setPose(self, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number)
-  function setPose(self, position: Vec3, orientation: Quat)
-  function setPosition(self, x: number, y: number, z: number)
-  function setPosition(self, position: Vec3)
-  function setRestitution(self, restitution: number)
-  function setSensor(self, sensor: boolean)
-  function setSleepingAllowed(self, sleepy: boolean)
-  function setTag(self, tag: string)
-  function setTag(self)
-  function setUserData(self, data: any)
-end
-
-declare class ConeJoint extends Joint
-  function getAxis(self): (number, number, number)
-  function getLimit(self): number
-  function setLimit(self, limit: number)
-end
-
-declare class Contact
-  function getColliders(self): (Collider, Collider)
-  function getFriction(self): number
-  function getNormal(self): (number, number, number)
-  function getOverlap(self): number
-  function getPoints(self): number
-  function getRestitution(self): number
-  function getShapes(self): (Shape, Shape)
-  function getSurfaceVelocity(self): (number, number, number)
-  function isEnabled(self): boolean
-  function setEnabled(self, enable: boolean)
-  function setFriction(self, friction: number)
-  function setRestitution(self, restitution: number)
-  function setSurfaceVelocity(self, x: number, y: number, z: number)
-  function setSurfaceVelocity(self, velocity: Vec3)
-end
-
-declare class ConvexShape extends Shape
-  function getFace(self, index: number): {}
-  function getFaceCount(self): number
-  function getPoint(self, index: number): (number, number, number)
-  function getPointCount(self): number
-  function getScale(self): number
-end
-
-declare class CylinderShape extends Shape
-  function getLength(self): number
-  function getRadius(self): number
-  function setLength(self, length: number)
-  function setRadius(self, radius: number)
-end
-
-declare class DistanceJoint extends Joint
-  function getLimits(self): (number, number)
-  function getSpring(self): (number, number)
-  function setLimits(self, min: number?, max: number?)
-  function setLimits(self)
-  function setSpring(self, frequency: number?, damping: number?)
-end
-
-declare class HingeJoint extends Joint
-  function getAngle(self): number
-  function getAxis(self): (number, number, number)
-  function getFriction(self): number
-  function getLimits(self): (number, number)
-  function getMaxMotorTorque(self): (number, number)
-  function getMotorMode(self): MotorMode
-  function getMotorSpring(self): (number, number)
-  function getMotorTarget(self): number
-  function getMotorTorque(self): number
-  function getSpring(self): (number, number)
-  function setFriction(self, friction: number)
-  function setLimits(self, min: number, max: number)
-  function setLimits(self)
-  function setMaxMotorTorque(self, positive: number?, negative: number?)
-  function setMotorMode(self, mode: MotorMode)
-  function setMotorMode(self)
-  function setMotorSpring(self, frequency: number?, damping: number?)
-  function setMotorTarget(self, target: number)
-  function setSpring(self, frequency: number?, damping: number?)
-end
-
-declare class Joint extends Object
-  function destroy(self)
-  function getAnchors(self): (number, number, number, number, number, number)
-  function getColliders(self): (Collider, Collider)
-  function getForce(self): number
-  function getPriority(self): number
-  function getTorque(self): number
-  function getType(self): JointType
-  function getUserData(self): any
-  function isDestroyed(self): boolean
-  function isEnabled(self): boolean
-  function setEnabled(self, enabled: boolean)
-  function setPriority(self, priority: number)
-  function setUserData(self, data: any)
-end
-
-declare class MeshShape extends Shape
-  function getScale(self): number
-end
-
-declare class Shape extends Object
-  function containsPoint(self, x: number, y: number, z: number): boolean
-  function containsPoint(self, point: Vec3): boolean
-  function destroy(self)
-  function getAABB(self): (number, number, number, number, number, number)
-  function getCenterOfMass(self): (number, number, number)
-  function getCollider(self): Collider
-  function getDensity(self): number
-  function getInertia(self): (number, number, number, number, number, number, number)
-  function getMass(self): number
-  function getOffset(self): (number, number, number, number, number, number, number)
-  function getOrientation(self): (number, number, number, number)
-  function getPose(self): (number, number, number, number, number, number, number)
-  function getPosition(self): (number, number, number)
-  function getType(self): ShapeType
-  function getUserData(self): any
-  function getVolume(self): number
-  function isDestroyed(self): boolean
-  function raycast(self, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): (number, number, number, number, number, number, number | nil)
-  function raycast(self, origin: Vec3, endpoint: Vec3): (number, number, number, number, number, number, number | nil)
-  function setDensity(self, density: number)
-  function setOffset(self, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number)
-  function setOffset(self, position: Vec3, rotation: Quat)
-  function setUserData(self, data: any)
-end
-
-declare class SliderJoint extends Joint
-  function getAxis(self): (number, number, number)
-  function getFriction(self): number
-  function getLimits(self): (number, number)
-  function getMaxMotorForce(self): (number, number)
-  function getMotorForce(self): number
-  function getMotorMode(self): MotorMode
-  function getMotorSpring(self): (number, number)
-  function getMotorTarget(self): number
-  function getPosition(self): number
-  function getSpring(self): (number, number)
-  function setFriction(self, friction: number)
-  function setLimits(self, min: number, max: number)
-  function setLimits(self)
-  function setMaxMotorForce(self, positive: number?, negative: number?)
-  function setMotorMode(self, mode: MotorMode)
-  function setMotorMode(self)
-  function setMotorSpring(self, frequency: number?, damping: number?)
-  function setMotorTarget(self, target: number)
-  function setSpring(self, frequency: number?, damping: number?)
-end
-
-declare class SphereShape extends Shape
-  function getRadius(self): number
-  function setRadius(self, radius: number)
-end
-
-declare class TerrainShape extends Shape
-end
-
-declare class WeldJoint extends Joint
-end
-
-declare class World extends Object
-  function destroy(self)
-  function disableCollisionBetween(self, tag1: string, tag2: string)
-  function enableCollisionBetween(self, tag1: string, tag2: string)
-  function getAngularDamping(self): (number, number)
-  function getCallbacks(self): {}
-  function getColliderCount(self): number
-  function getColliders(self): {Collider}
-  function getGravity(self): (number, number, number)
-  function getJointCount(self): number
-  function getJoints(self): {Joint}
-  function getLinearDamping(self): (number, number)
-  function getResponseTime(self): number
-  function getStepCount(self): number
-  function getTags(self): {string}
-  function getTightness(self): number
-  function interpolate(self, alpha: number)
-  function isCollisionEnabledBetween(self, tag1: string, tag2: string): boolean
-  function isDestroyed(self): boolean
-  function isSleepingAllowed(self): boolean
-  function newBoxCollider(self, x: number?, y: number?, z: number?, width: number?, height: number?, depth: number?): Collider
-  function newBoxCollider(self, position: Vec3, size: Vec3): Collider
-  function newCapsuleCollider(self, x: number?, y: number?, z: number?, radius: number?, length: number?): Collider
-  function newCapsuleCollider(self, position: Vec3, radius: number?, length: number?): Collider
-  function newCollider(self, x: number, y: number, z: number): Collider
-  function newCollider(self, position: Vec3): Collider
-  function newConvexCollider(self, x: number?, y: number?, z: number?, points: {}, scale: number?): Collider
-  function newConvexCollider(self, position: Vec3, points: {}, scale: number?): Collider
-  function newConvexCollider(self, x: number?, y: number?, z: number?, modelData: ModelData, scale: number?): Collider
-  function newConvexCollider(self, position: Vec3, modelData: ModelData, scale: number?): Collider
-  function newConvexCollider(self, x: number?, y: number?, z: number?, model: Model, scale: number?): Collider
-  function newConvexCollider(self, position: Vec3, model: Model, scale: number?): Collider
-  function newConvexCollider(self, x: number?, y: number?, z: number?, mesh: Mesh, scale: number?): Collider
-  function newConvexCollider(self, position: Vec3, mesh: Mesh, scale: number?): Collider
-  function newConvexCollider(self, x: number?, y: number?, z: number?, template: ConvexShape, scale: number?): Collider
-  function newConvexCollider(self, position: Vec3, template: ConvexShape, scale: number?): Collider
-  function newCylinderCollider(self, x: number?, y: number?, z: number?, radius: number?, length: number?): Collider
-  function newCylinderCollider(self, position: Vec3, radius: number?, length: number?): Collider
-  function newMeshCollider(self, vertices: {}, indices: {}): Collider
-  function newMeshCollider(self, modelData: ModelData): Collider
-  function newMeshCollider(self, model: Model): Collider
-  function newMeshCollider(self, mesh: Mesh): Collider
-  function newMeshCollider(self, template: MeshShape): Collider
-  function newSphereCollider(self, x: number?, y: number?, z: number?, radius: number?): Collider
-  function newSphereCollider(self, position: Vec3, radius: number?): Collider
-  function newTerrainCollider(self, scale: number): Collider
-  function newTerrainCollider(self, scale: number, heightmap: Image, stretch: number?): Collider
-  function newTerrainCollider(self, scale: number, callback: (x: number, z: number) -> number, samples: number?): Collider
-  function overlapShape(self, shape: Shape, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number, maxDistance: number?, filter: string?, callback: () -> ()?)
-  function overlapShape(self, shape: Shape, position: Vec3, orientation: Quat, maxDistance: number?, filter: string?, callback: () -> ()?)
-  function overlapShape(self, shape: Shape, x: number, y: number, z: number, angle: number, ax: number, ay: number, az: number, maxDistance: number?, filter: string?): (Collider, Shape, number, number, number, number, number, number)
-  function overlapShape(self, shape: Shape, position: Vec3, orientation: Quat, maxDistance: number?, filter: string?): (Collider, Shape, number, number, number, number, number, number)
-  function queryBox(self, x: number, y: number, z: number, width: number, height: number, depth: number, filter: string?, callback: () -> ()?)
-  function queryBox(self, position: Vec3, size: Vec3, filter: string?, callback: () -> ()?)
-  function queryBox(self, x: number, y: number, z: number, width: number, height: number, depth: number, filter: string?): Collider
-  function queryBox(self, position: Vec3, size: Vec3, filter: string?): Collider
-  function querySphere(self, x: number, y: number, z: number, radius: number, filter: string?, callback: () -> ()?)
-  function querySphere(self, position: Vec3, radius: number, filter: string?, callback: () -> ()?)
-  function querySphere(self, x: number, y: number, z: number, radius: number, filter: string?): Collider
-  function querySphere(self, position: Vec3, radius: number, filter: string?): Collider
-  function raycast(self, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, filter: string?, callback: (collider: Collider, shape: Shape, x: number, y: number, z: number, nx: number, ny: number, nz: number, triangle: number, fraction: number) -> number??)
-  function raycast(self, origin: Vec3, endpoint: Vec3, filter: string?, callback: (collider: Collider, shape: Shape, x: number, y: number, z: number, nx: number, ny: number, nz: number, triangle: number, fraction: number) -> number??)
-  function raycast(self, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, filter: string?): (Collider, Shape, number, number, number, number, number, number, number | nil)
-  function raycast(self, origin: Vec3, endpoint: Vec3, filter: string?): (Collider, Shape, number, number, number, number, number, number, number | nil)
-  function setAngularDamping(self, damping: number, threshold: number?)
-  function setCallbacks(self, callbacks: {})
-  function setGravity(self, xg: number, yg: number, zg: number)
-  function setGravity(self, gravity: Vec3)
-  function setLinearDamping(self, damping: number, threshold: number?)
-  function setResponseTime(self, responseTime: number)
-  function setSleepingAllowed(self, allowed: boolean)
-  function setStepCount(self, steps: number)
-  function setTightness(self, tightness: number)
-  function shapecast(self, shape: Shape, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, angle: number, ax: number, ay: number, az: number, filter: string?, callback: (collider: Collider, shape: Shape, x: number, y: number, z: number, nx: number, ny: number, nz: number, triangle: number, fraction: number) -> number?)
-  function shapecast(self, shape: Shape, position: Vec3, destination: Vec3, orientation: Quat, filter: string?, callback: (collider: Collider, shape: Shape, x: number, y: number, z: number, nx: number, ny: number, nz: number, triangle: number, fraction: number) -> number?)
-  function shapecast(self, shape: Shape, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number, angle: number, ax: number, ay: number, az: number, filter: string?): (Collider, Shape, number, number, number, number, number, number, number, number)
-  function shapecast(self, shape: Shape, position: Vec3, destination: Vec3, orientation: Quat, filter: string?): (Collider, Shape, number, number, number, number, number, number, number, number)
-  function update(self, dt: number)
-end
-
-type PhysicsModule = {
-  newBallJoint:
-    & ((colliderA: Collider, colliderB: Collider, x: number, y: number, z: number) -> BallJoint)
-    & ((colliderA: Collider, colliderB: Collider, anchor: Vec3) -> BallJoint),
-  newBoxShape: (width: number?, height: number?, depth: number?) -> BoxShape,
-  newCapsuleShape: (radius: number?, length: number?) -> CapsuleShape,
-  newConeJoint:
-    & ((colliderA: Collider, colliderB: Collider, x: number, y: number, z: number, ax: number, ay: number, az: number) -> ConeJoint)
-    & ((colliderA: Collider, colliderB: Collider, anchor: Vec3, axis: Vec3) -> ConeJoint),
-  newConvexShape:
-    & ((points: {}, scale: number?) -> ConvexShape)
-    & ((object: ModelData | Model | Mesh, scale: number?) -> ConvexShape)
-    & ((template: ConvexShape, scale: number?) -> ConvexShape),
-  newCylinderShape: (radius: number?, length: number?) -> CylinderShape,
-  newDistanceJoint:
-    & ((colliderA: Collider, colliderB: Collider, x1: number, y1: number, z1: number, x2: number, y2: number, z2: number) -> DistanceJoint)
-    & ((colliderA: Collider, colliderB: Collider, first: Vec3, second: Vec3) -> DistanceJoint),
-  newHingeJoint:
-    & ((colliderA: Collider, colliderB: Collider, x: number, y: number, z: number, ax: number, ay: number, az: number) -> HingeJoint)
-    & ((colliderA: Collider, colliderB: Collider, anchor: Vec3, axis: Vec3) -> HingeJoint),
-  newMeshShape:
-    & ((vertices: {}, indices: {}, scale: number?) -> MeshShape)
-    & ((object: ModelData | Model | Mesh, scale: number?) -> MeshShape)
-    & ((template: MeshShape, scale: number?) -> MeshShape),
-  newSliderJoint:
-    & ((colliderA: Collider, colliderB: Collider, ax: number, ay: number, az: number) -> SliderJoint)
-    & ((colliderA: Collider, colliderB: Collider, axis: Vec3) -> SliderJoint),
-  newSphereShape: (radius: number?) -> SphereShape,
-  newTerrainShape:
-    & ((scale: number) -> TerrainShape)
-    & ((scale: number, heightmap: Image, stretch: number?) -> TerrainShape)
-    & ((scale: number, callback: (x: number, z: number) -> (), samples: number?) -> TerrainShape),
-  newWeldJoint: (colliderA: Collider, colliderB: Collider) -> WeldJoint,
-  newWorld: (settings: {}?) -> World,
-}
-
-type Permission =
-  | "audiocapture"
-
-type SystemModule = {
-  getClipboardText: () -> string | nil,
-  getCoreCount: () -> number,
-  getMousePosition: () -> (number, number),
-  getMouseX: () -> number,
-  getMouseY: () -> number,
-  getOS: () -> string,
-  getWindowDensity: () -> number,
-  getWindowDimensions: () -> (number, number),
-  getWindowHeight: () -> number,
-  getWindowWidth: () -> number,
-  hasKeyRepeat: () -> boolean,
-  isKeyDown: (...KeyCode) -> boolean,
-  isMouseDown: (button: number) -> boolean,
-  isWindowFocused: () -> boolean,
-  isWindowOpen: () -> boolean,
-  isWindowVisible: () -> boolean,
-  openWindow: (options: {}) -> (),
-  pollEvents: () -> (),
-  requestPermission: (permission: Permission) -> (),
-  setClipboardText: (text: string) -> (),
-  setKeyRepeat: (enable: boolean) -> (),
-  wasKeyPressed: (...KeyCode) -> boolean,
-  wasKeyReleased: (...KeyCode) -> boolean,
-  wasMousePressed: (button: number) -> boolean,
-  wasMouseReleased: (button: number) -> boolean,
-}
-
-declare class Channel extends Object
-  function clear(self)
-  function getCount(self): number
-  function hasRead(self, id: number): boolean
-  function peek(self): (any, boolean)
-  function pop(self, wait: number | boolean | nil): any
-  function push(self, message: any, wait: number | boolean | nil): (number, boolean)
-end
-
-declare class Thread extends Object
-  function getError(self): string | nil
-  function isRunning(self): boolean
-  function start(self, ...: any)
-  function wait(self)
-end
-
-type ThreadModule = {
-  getChannel: (name: string) -> Channel,
-  newChannel: () -> Channel,
-  newThread:
-    & ((code: string) -> Thread)
-    & ((file: string | Blob) -> Thread),
-}
-
-type TimerModule = {
-  getAverageDelta: () -> number,
-  getDelta: () -> number,
-  getFPS: () -> number,
-  getTime: () -> number,
-  sleep: (duration: number) -> (),
-  step: () -> number,
-}
-
-declare lovr: {
-  getVersion: () -> (number, number, number, string, string),
-
-  conf: (t: {}) -> (),
-  draw: (pass: Pass) -> boolean | nil,
-  errhand: (message: string) -> (() -> any),
-  filechanged: (path: string, action: FileAction, oldpath: string) -> (),
-  focus: (focused: boolean, display: DisplayType) -> (),
-  keypressed: (key: KeyCode, scancode: number, isrepeat: boolean) -> (),
-  keyreleased: (key: KeyCode, scancode: number) -> (),
-  load: (arg: {}) -> (),
-  log: (message: string, level: string, tag: string) -> (),
-  mirror: (pass: Pass) -> boolean,
-  mount: (mounted: boolean) -> (),
-  mousemoved: (x: number, y: number, dx: number, dy: number) -> (),
-  mousepressed: (x: number, y: number, button: number) -> (),
-  mousereleased: (x: number, y: number, button: number) -> (),
-  permission: (permission: Permission, granted: boolean) -> (),
-  quit: () -> boolean,
-  recenter: () -> (),
-  resize: (width: number, height: number) -> (),
-  restart: () -> any,
-  run: () -> (() -> any),
-  textinput: (text: string, code: number) -> (),
-  threaderror: (thread: Thread, message: string) -> (),
-  update: (dt: number) -> (),
-  visible: (visible: boolean, display: DisplayType) -> (),
-  wheelmoved: (dx: number, dy: number) -> (),
-
-  audio: AudioModule,
-  data: DataModule,
-  event: EventModule,
-  filesystem: FilesystemModule,
-  graphics: GraphicsModule,
-  headset: HeadsetModule,
-  math: MathModule,
-  physics: PhysicsModule,
-  system: SystemModule,
-  thread: ThreadModule,
-  timer: TimerModule,
-}