SYMBOL INDEX (1478 symbols across 180 files)

FILE: crates/lune-roblox/src/datatypes/attributes.rs
  function ensure_valid_attribute_name (line 16) | pub fn ensure_valid_attribute_name(name: impl AsRef<str>) -> LuaResult<(...
  function ensure_valid_attribute_value (line 45) | pub fn ensure_valid_attribute_value(value: &DomValue) -> LuaResult<()> {

FILE: crates/lune-roblox/src/datatypes/conversion.rs
  type LuaToDomValue (line 9) | pub(crate) trait LuaToDomValue {
    method lua_to_dom_value (line 16) | fn lua_to_dom_value(
    method lua_to_dom_value (line 80) | fn lua_to_dom_value(
    method lua_to_dom_value (line 242) | fn lua_to_dom_value(&self, _: &Lua, variant_type: Option<DomType>) -> ...
  type DomValueToLua (line 23) | pub(crate) trait DomValueToLua: Sized {
    method dom_value_to_lua (line 27) | fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionRes...
    method dom_value_to_lua (line 41) | fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionRes...
    method dom_value_to_lua (line 192) | fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionRes...

FILE: crates/lune-roblox/src/datatypes/extension.rs
  type DomValueExt (line 3) | pub(crate) trait DomValueExt {
    method variant_name (line 4) | fn variant_name(&self) -> Option<&'static str>;
    method variant_name (line 8) | fn variant_name(&self) -> Option<&'static str> {
    method variant_name (line 59) | fn variant_name(&self) -> Option<&'static str> {

FILE: crates/lune-roblox/src/datatypes/result.rs
  type DomConversionError (line 11) | pub(crate) enum DomConversionError {
    method fmt (line 30) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 67) | fn from(value: LuaError) -> Self {
    method from (line 73) | fn from(value: IoError) -> Self {
  method from (line 53) | fn from(value: DomConversionError) -> Self {
  type DomConversionResult (line 80) | pub(crate) type DomConversionResult<T> = Result<T, DomConversionError>;

FILE: crates/lune-roblox/src/datatypes/types/axes.rs
  type Axes (line 18) | pub struct Axes {
    method fmt (line 98) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 108) | fn from(v: DomAxes) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "Axes";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 79) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 91) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 119) | fn from(v: Axes) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/brick_color.rs
  type BrickColor (line 19) | pub struct BrickColor {
    method fmt (line 108) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 114) | fn from(value: Color3) -> Self {
    method from (line 133) | fn from(v: DomBrickColor) -> Self {
    method from (line 155) | fn from(value: BrickColorDef) -> Self {
  constant EXPORT_NAME (line 28) | const EXPORT_NAME: &'static str = "BrickColor";
  method create_exports_table (line 30) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 83) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 95) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method default (line 102) | fn default() -> Self {
  method from (line 123) | fn from(value: BrickColor) -> Self {
  method from (line 139) | fn from(v: BrickColor) -> Self {
  type BrickColorDef (line 152) | type BrickColorDef = &'static (u16, &'static str, (u8, u8, u8));
  constant BRICK_COLOR_DEFAULT_VALUE (line 164) | const BRICK_COLOR_DEFAULT_VALUE: BrickColorDef =
  function color_from_number (line 167) | fn color_from_number(index: u16) -> BrickColor {
  function color_from_name (line 175) | fn color_from_name(name: impl AsRef<str>) -> BrickColor {
  function color_from_rgb (line 184) | fn color_from_rgb(r: u8, g: u8, b: u8) -> BrickColor {
  constant BRICK_COLOR_DEFAULT (line 209) | const BRICK_COLOR_DEFAULT: u16 = 194;
  constant BRICK_COLOR_VALUES (line 211) | const BRICK_COLOR_VALUES: &[(u16, &str, (u8, u8, u8))] = &[
  constant BRICK_COLOR_PALETTE (line 422) | const BRICK_COLOR_PALETTE: &[u16] = &[
  constant BRICK_COLOR_CONSTRUCTORS (line 432) | const BRICK_COLOR_CONSTRUCTORS: &[(&str, u16)] = &[

FILE: crates/lune-roblox/src/datatypes/types/cframe.rs
  type CFrame (line 24) | pub struct CFrame(pub Mat4);
    constant IDENTITY (line 27) | pub const IDENTITY: Self = Self(Mat4::IDENTITY);
    method position (line 29) | fn position(&self) -> Vec3 {
    method orientation (line 33) | fn orientation(&self) -> Mat3 {
    method inverse (line 41) | fn inverse(&self) -> Self {
    method fmt (line 349) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 364) | type Output = Self;
    method mul (line 365) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 371) | type Output = Vector3;
    method mul (line 372) | fn mul(self, rhs: Vector3) -> Self::Output {
    type Output (line 378) | type Output = Self;
    method add (line 379) | fn add(self, rhs: Vector3) -> Self::Output {
    type Output (line 390) | type Output = Self;
    method sub (line 391) | fn sub(self, rhs: Vector3) -> Self::Output {
    method from (line 402) | fn from(v: DomCFrame) -> Self {
  constant EXPORT_NAME (line 47) | const EXPORT_NAME: &'static str = "CFrame";
  method create_exports_table (line 50) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 178) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 204) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 414) | fn from(v: CFrame) -> Self {
  function look_at (line 433) | fn look_at(from: Vec3, to: Vec3, up: Vec3) -> Mat4 {
  function dom_cframe_from_cframe (line 454) | fn dom_cframe_from_cframe() {
  function cframe_from_dom_cframe (line 475) | fn cframe_from_dom_cframe() {

FILE: crates/lune-roblox/src/datatypes/types/color3.rs
  type Color3 (line 25) | pub struct Color3 {
    method fmt (line 204) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 210) | type Output = Self;
    method neg (line 211) | fn neg(self) -> Self::Output {
    type Output (line 221) | type Output = Self;
    method add (line 222) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 232) | type Output = Self;
    method sub (line 233) | fn sub(self, rhs: Self) -> Self::Output {
    type Output (line 243) | type Output = Color3;
    method mul (line 244) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 254) | type Output = Color3;
    method mul (line 255) | fn mul(self, rhs: f32) -> Self::Output {
    type Output (line 265) | type Output = Color3;
    method div (line 266) | fn div(self, rhs: Self) -> Self::Output {
    type Output (line 276) | type Output = Color3;
    method div (line 277) | fn div(self, rhs: f32) -> Self::Output {
    method from (line 287) | fn from(v: DomColor3) -> Self {
    method from (line 307) | fn from(v: DomColor3uint8) -> Self {
  constant EXPORT_NAME (line 32) | const EXPORT_NAME: &'static str = "Color3";
  method create_exports_table (line 34) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method from_lua (line 115) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method add_fields (line 129) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 135) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method default (line 194) | fn default() -> Self {
  method from (line 297) | fn from(v: Color3) -> Self {
  method from (line 313) | fn from(v: Color3) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/color_sequence.rs
  type ColorSequence (line 20) | pub struct ColorSequence {
    method fmt (line 89) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 102) | fn from(v: DomColorSequence) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "ColorSequence";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 78) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 82) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 115) | fn from(v: ColorSequence) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/color_sequence_keypoint.rs
  type ColorSequenceKeypoint (line 18) | pub struct ColorSequenceKeypoint {
    method fmt (line 54) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 60) | fn from(v: DomColorSequenceKeypoint) -> Self {
  constant EXPORT_NAME (line 24) | const EXPORT_NAME: &'static str = "ColorSequenceKeypoint";
  method create_exports_table (line 26) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 42) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 47) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 69) | fn from(v: ColorSequenceKeypoint) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/content.rs
  type Content (line 18) | pub struct Content(ContentType);
    method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method from (line 108) | fn from(value: DomContent) -> Self {
  constant EXPORT_NAME (line 21) | const EXPORT_NAME: &'static str = "Content";
  method create_exports_table (line 23) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 53) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 86) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 114) | fn from(value: Content) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/enum.rs
  type Enum (line 14) | pub struct Enum {
    method from_name (line 19) | pub(crate) fn from_name(name: impl AsRef<str>) -> Option<Self> {
    method fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 68) | fn from(value: &'static EnumDescriptor<'static>) -> Self {
  method add_methods (line 26) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method eq (line 62) | fn eq(&self, other: &Self) -> bool {

FILE: crates/lune-roblox/src/datatypes/types/enum_item.rs
  type EnumItem (line 14) | pub struct EnumItem {
    method from_enum_and_name (line 21) | pub(crate) fn from_enum_and_name(parent: &Enum, name: impl AsRef<str>)...
    method from_enum_and_value (line 36) | pub(crate) fn from_enum_and_value(parent: &Enum, value: u32) -> Option...
    method from_enum_name_and_name (line 50) | pub(crate) fn from_enum_name_and_name(
    method from_enum_name_and_value (line 58) | pub(crate) fn from_enum_name_and_value(enum_name: impl AsRef<str>, val...
    method fmt (line 92) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 113) | fn from(value: DomEnumItem) -> Self {
  method add_fields (line 65) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 71) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from_lua (line 78) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method eq (line 98) | fn eq(&self, other: &Self) -> bool {
  method from (line 104) | fn from(v: EnumItem) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/enums.rs
  type Enums (line 13) | pub struct Enums;
    method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method add_methods (line 16) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-roblox/src/datatypes/types/faces.rs
  type Faces (line 20) | pub struct Faces {
    method fmt (line 106) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 119) | fn from(v: DomFaces) -> Self {
  constant EXPORT_NAME (line 30) | const EXPORT_NAME: &'static str = "Faces";
  method create_exports_table (line 32) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 90) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 99) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 133) | fn from(v: Faces) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/font.rs
  type Font (line 21) | pub struct Font {
    method from_enum_item (line 29) | pub(crate) fn from_enum_item(material_enum_item: &EnumItem) -> Option<...
    method fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 142) | fn from(v: DomFont) -> Self {
  constant EXPORT_NAME (line 44) | const EXPORT_NAME: &'static str = "Font";
  method create_exports_table (line 46) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 104) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 129) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 153) | fn from(v: Font) -> Self {
  method from (line 170) | fn from(v: FontWeight) -> Self {
  method from (line 182) | fn from(v: FontStyle) -> Self {
  type FontData (line 195) | type FontData = (&'static str, FontWeight, FontStyle);
  type FontWeight (line 198) | pub(crate) enum FontWeight {
    method from (line 164) | fn from(v: DomFontWeight) -> Self {
    method as_u16 (line 211) | pub(crate) fn as_u16(self) -> u16 {
    method from_u16 (line 225) | pub(crate) fn from_u16(n: u16) -> Option<Self> {
    type Err (line 248) | type Err = &'static str;
    method from_str (line 249) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method fmt (line 266) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 242) | fn default() -> Self {
  method from_lua (line 286) | fn from_lua(lua_value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method into_lua (line 314) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  type FontStyle (line 327) | pub(crate) enum FontStyle {
    method from (line 176) | fn from(v: DomFontStyle) -> Self {
    method as_u8 (line 333) | pub(crate) fn as_u8(self) -> u8 {
    method from_u8 (line 340) | pub(crate) fn from_u8(n: u8) -> Option<Self> {
    type Err (line 356) | type Err = &'static str;
    method from_str (line 357) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method fmt (line 367) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method default (line 350) | fn default() -> Self {
  method from_lua (line 380) | fn from_lua(lua_value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method into_lua (line 408) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  constant FONT_ENUM_MAP (line 421) | const FONT_ENUM_MAP: &[(&str, Option<FontData>)] = &[

FILE: crates/lune-roblox/src/datatypes/types/number_range.rs
  type NumberRange (line 18) | pub struct NumberRange {
    method fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 62) | fn from(v: DomNumberRange) -> Self {
  constant EXPORT_NAME (line 24) | const EXPORT_NAME: &'static str = "NumberRange";
  method create_exports_table (line 26) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 44) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 49) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 71) | fn from(v: NumberRange) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/number_sequence.rs
  type NumberSequence (line 20) | pub struct NumberSequence {
    method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 106) | fn from(v: DomNumberSequence) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "NumberSequence";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 82) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 86) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 119) | fn from(v: NumberSequence) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/number_sequence_keypoint.rs
  type NumberSequenceKeypoint (line 18) | pub struct NumberSequenceKeypoint {
    method fmt (line 57) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 63) | fn from(v: DomNumberSequenceKeypoint) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "NumberSequenceKeypoint";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 44) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 50) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 73) | fn from(v: NumberSequenceKeypoint) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/physical_properties.rs
  type PhysicalProperties (line 18) | pub struct PhysicalProperties {
    method from_material (line 28) | pub(crate) fn from_material(material_enum_item: &EnumItem) -> Option<P...
    method fmt (line 114) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 128) | fn from(v: DomCustomPhysicalProperties) -> Self {
  constant EXPORT_NAME (line 44) | const EXPORT_NAME: &'static str = "PhysicalProperties";
  method create_exports_table (line 46) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 98) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 107) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 141) | fn from(v: PhysicalProperties) -> Self {
  constant MATERIAL_ENUM_MAP (line 161) | const MATERIAL_ENUM_MAP: &[(&str, f32, f32, f32, f32, f32, f32)] = &[

FILE: crates/lune-roblox/src/datatypes/types/ray.rs
  type Ray (line 20) | pub struct Ray {
    method closest_point (line 26) | fn closest_point(&self, point: Vec3) -> Vec3 {
    method fmt (line 81) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 87) | fn from(v: DomRay) -> Self {
  constant EXPORT_NAME (line 36) | const EXPORT_NAME: &'static str = "Ray";
  method create_exports_table (line 38) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 54) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 65) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 96) | fn from(v: Ray) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/rect.rs
  type Rect (line 21) | pub struct Rect {
    method new (line 27) | fn new(lhs: Vec2, rhs: Vec2) -> Self {
    method fmt (line 87) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 93) | type Output = Self;
    method neg (line 94) | fn neg(self) -> Self::Output {
    type Output (line 100) | type Output = Self;
    method add (line 101) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 107) | type Output = Self;
    method sub (line 108) | fn sub(self, rhs: Self) -> Self::Output {
    method from (line 114) | fn from(v: DomRect) -> Self {
  constant EXPORT_NAME (line 36) | const EXPORT_NAME: &'static str = "Rect";
  method create_exports_table (line 38) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 70) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 77) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 123) | fn from(v: Rect) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/region3.rs
  type Region3 (line 20) | pub struct Region3 {
    method fmt (line 66) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 72) | fn from(v: DomRegion3) -> Self {
  constant EXPORT_NAME (line 26) | const EXPORT_NAME: &'static str = "Region3";
  method create_exports_table (line 28) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 44) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 51) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 81) | fn from(v: Region3) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/region3int16.rs
  type Region3int16 (line 20) | pub struct Region3int16 {
    method fmt (line 56) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 62) | fn from(v: DomRegion3int16) -> Self {
  constant EXPORT_NAME (line 26) | const EXPORT_NAME: &'static str = "Region3int16";
  method create_exports_table (line 28) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 44) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 49) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 71) | fn from(v: Region3int16) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/udim.rs
  type UDim (line 19) | pub struct UDim {
    method new (line 25) | pub(super) fn new(scale: f32, offset: i32) -> Self {
    method fmt (line 72) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 78) | type Output = Self;
    method neg (line 79) | fn neg(self) -> Self::Output {
    type Output (line 88) | type Output = Self;
    method add (line 89) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 98) | type Output = Self;
    method sub (line 99) | fn sub(self, rhs: Self) -> Self::Output {
    method from (line 108) | fn from(v: DomUDim) -> Self {
  constant EXPORT_NAME (line 31) | const EXPORT_NAME: &'static str = "UDim";
  method create_exports_table (line 33) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 48) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 53) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method default (line 63) | fn default() -> Self {
  method from (line 117) | fn from(v: UDim) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/udim2.rs
  type UDim2 (line 22) | pub struct UDim2 {
    method fmt (line 118) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 124) | type Output = Self;
    method neg (line 125) | fn neg(self) -> Self::Output {
    type Output (line 134) | type Output = Self;
    method add (line 135) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 144) | type Output = Self;
    method sub (line 145) | fn sub(self, rhs: Self) -> Self::Output {
    method from (line 154) | fn from(v: DomUDim2) -> Self {
  constant EXPORT_NAME (line 28) | const EXPORT_NAME: &'static str = "UDim2";
  method create_exports_table (line 30) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 75) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 82) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 163) | fn from(v: UDim2) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/unique_id.rs
  type UniqueId (line 20) | pub struct UniqueId {
    method fmt (line 66) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 75) | fn from(value: DomUniqueId) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "UniqueId";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_methods (line 59) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 87) | fn from(value: UniqueId) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/vector2.rs
  type Vector2 (line 22) | pub struct Vector2(pub Vec2);
    method fmt (line 103) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 109) | type Output = Self;
    method neg (line 110) | fn neg(self) -> Self::Output {
    type Output (line 116) | type Output = Self;
    method add (line 117) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 123) | type Output = Self;
    method sub (line 124) | fn sub(self, rhs: Self) -> Self::Output {
    type Output (line 130) | type Output = Vector2;
    method mul (line 131) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 137) | type Output = Vector2;
    method mul (line 138) | fn mul(self, rhs: f32) -> Self::Output {
    type Output (line 144) | type Output = Vector2;
    method div (line 145) | fn div(self, rhs: Self) -> Self::Output {
    type Output (line 151) | type Output = Vector2;
    method div (line 152) | fn div(self, rhs: f32) -> Self::Output {
    type Output (line 165) | type Output = Vector2;
    method idiv (line 166) | fn idiv(self, rhs: f32) -> Self::Output {
    method from (line 172) | fn from(v: DomVector2) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "Vector2";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 46) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 53) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  type Output (line 158) | type Output = Vector2;
  method idiv (line 159) | fn idiv(self, rhs: Self) -> Self::Output {
  method from (line 178) | fn from(v: Vector2) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/vector2int16.rs
  type Vector2int16 (line 22) | pub struct Vector2int16(pub IVec2);
    method fmt (line 59) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 65) | type Output = Self;
    method neg (line 66) | fn neg(self) -> Self::Output {
    type Output (line 72) | type Output = Self;
    method add (line 73) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 79) | type Output = Self;
    method sub (line 80) | fn sub(self, rhs: Self) -> Self::Output {
    type Output (line 86) | type Output = Vector2int16;
    method mul (line 87) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 93) | type Output = Vector2int16;
    method mul (line 94) | fn mul(self, rhs: i32) -> Self::Output {
    type Output (line 100) | type Output = Vector2int16;
    method div (line 101) | fn div(self, rhs: Self) -> Self::Output {
    type Output (line 107) | type Output = Vector2int16;
    method div (line 108) | fn div(self, rhs: i32) -> Self::Output {
    method from (line 114) | fn from(v: DomVector2int16) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "Vector2int16";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 42) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 47) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 123) | fn from(v: Vector2int16) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/vector3.rs
  type Vector3 (line 25) | pub struct Vector3(pub Vec3);
    method fmt (line 153) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 159) | type Output = Self;
    method neg (line 160) | fn neg(self) -> Self::Output {
    type Output (line 166) | type Output = Self;
    method add (line 167) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 173) | type Output = Self;
    method sub (line 174) | fn sub(self, rhs: Self) -> Self::Output {
    type Output (line 180) | type Output = Vector3;
    method mul (line 181) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 187) | type Output = Vector3;
    method mul (line 188) | fn mul(self, rhs: f32) -> Self::Output {
    type Output (line 194) | type Output = Vector3;
    method div (line 195) | fn div(self, rhs: Self) -> Self::Output {
    type Output (line 201) | type Output = Vector3;
    method div (line 202) | fn div(self, rhs: f32) -> Self::Output {
    type Output (line 215) | type Output = Vector3;
    method idiv (line 216) | fn idiv(self, rhs: f32) -> Self::Output {
    method from (line 222) | fn from(v: DomVector3) -> Self {
  constant EXPORT_NAME (line 28) | const EXPORT_NAME: &'static str = "Vector3";
  method create_exports_table (line 30) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 96) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 104) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  type Output (line 208) | type Output = Vector3;
  method idiv (line 209) | fn idiv(self, rhs: Self) -> Self::Output {
  method from (line 232) | fn from(v: Vector3) -> Self {

FILE: crates/lune-roblox/src/datatypes/types/vector3int16.rs
  type Vector3int16 (line 22) | pub struct Vector3int16(pub IVec3);
    method fmt (line 61) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    type Output (line 67) | type Output = Self;
    method neg (line 68) | fn neg(self) -> Self::Output {
    type Output (line 74) | type Output = Self;
    method add (line 75) | fn add(self, rhs: Self) -> Self::Output {
    type Output (line 81) | type Output = Self;
    method sub (line 82) | fn sub(self, rhs: Self) -> Self::Output {
    type Output (line 88) | type Output = Vector3int16;
    method mul (line 89) | fn mul(self, rhs: Self) -> Self::Output {
    type Output (line 95) | type Output = Vector3int16;
    method mul (line 96) | fn mul(self, rhs: i32) -> Self::Output {
    type Output (line 102) | type Output = Vector3int16;
    method div (line 103) | fn div(self, rhs: Self) -> Self::Output {
    type Output (line 109) | type Output = Vector3int16;
    method div (line 110) | fn div(self, rhs: i32) -> Self::Output {
    method from (line 116) | fn from(v: DomVector3int16) -> Self {
  constant EXPORT_NAME (line 25) | const EXPORT_NAME: &'static str = "Vector3int16";
  method create_exports_table (line 27) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 43) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 49) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method from (line 126) | fn from(v: Vector3int16) -> Self {

FILE: crates/lune-roblox/src/datatypes/util.rs
  constant ROUNDING (line 4) | const ROUNDING: usize = 65_536;
  function round_float_decimal (line 6) | pub fn round_float_decimal(value: f32) -> f32 {

FILE: crates/lune-roblox/src/document/error.rs
  type DocumentError (line 7) | pub enum DocumentError {
  method from (line 28) | fn from(value: DocumentError) -> Self {

FILE: crates/lune-roblox/src/document/format.rs
  type DocumentFormat (line 17) | pub enum DocumentFormat {
    method from_extension (line 28) | pub fn from_extension(extension: impl AsRef<str>) -> Option<Self> {
    method from_path (line 42) | pub fn from_path(path: impl AsRef<Path>) -> Option<Self> {
    method from_bytes (line 60) | pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Option<Self> {
  method default (line 76) | fn default() -> Self {
  function from_extension_binary (line 88) | fn from_extension_binary() {
  function from_extension_xml (line 101) | fn from_extension_xml() {
  function from_extension_invalid (line 114) | fn from_extension_invalid() {
  function from_path_binary (line 124) | fn from_path_binary() {
  function from_path_xml (line 137) | fn from_path_xml() {
  function from_path_invalid (line 150) | fn from_path_invalid() {
  function from_bytes_binary (line 170) | fn from_bytes_binary() {
  function from_bytes_xml (line 183) | fn from_bytes_xml() {
  function from_bytes_invalid (line 196) | fn from_bytes_invalid() {

FILE: crates/lune-roblox/src/document/kind.rs
  type DocumentKind (line 18) | pub enum DocumentKind {
    method from_extension (line 29) | pub fn from_extension(extension: impl AsRef<str>) -> Option<Self> {
    method from_path (line 43) | pub fn from_path(path: impl AsRef<Path>) -> Option<Self> {
    method from_weak_dom (line 62) | pub fn from_weak_dom(dom: &WeakDom) -> Option<Self> {
  function from_extension_place (line 93) | fn from_extension_place() {
  function from_extension_model (line 106) | fn from_extension_model() {
  function from_extension_invalid (line 119) | fn from_extension_invalid() {
  function from_path_place (line 129) | fn from_path_place() {
  function from_path_model (line 142) | fn from_path_model() {
  function from_path_invalid (line 155) | fn from_path_invalid() {
  function from_weak_dom (line 175) | fn from_weak_dom() {

FILE: crates/lune-roblox/src/document/mod.rs
  type DocumentResult (line 20) | pub type DocumentResult<T> = Result<T, DocumentError>;
  type Document (line 63) | pub struct Document {
    method canonical_extension (line 83) | pub fn canonical_extension(kind: DocumentKind, format: DocumentFormat)...
    method from_bytes_inner (line 92) | fn from_bytes_inner(bytes: impl AsRef<[u8]>) -> DocumentResult<(Docume...
    method from_bytes_auto (line 122) | pub fn from_bytes_auto(bytes: impl AsRef<[u8]>) -> DocumentResult<Self> {
    method from_bytes (line 138) | pub fn from_bytes(bytes: impl AsRef<[u8]>, kind: DocumentKind) -> Docu...
    method to_bytes (line 155) | pub fn to_bytes(&self) -> DocumentResult<Vec<u8>> {
    method to_bytes_with_format (line 167) | pub fn to_bytes_with_format(&self, format: DocumentFormat) -> Document...
    method kind (line 193) | pub fn kind(&self) -> DocumentKind {
    method format (line 201) | pub fn format(&self) -> DocumentFormat {
    method extension (line 209) | pub fn extension(&self) -> &'static str {
    method into_data_model_instance (line 220) | pub fn into_data_model_instance(mut self) -> DocumentResult<Instance> {
    method into_instance_array (line 248) | pub fn into_instance_array(mut self) -> DocumentResult<Vec<Instance>> {
    method from_data_model_instance (line 270) | pub fn from_data_model_instance(i: Instance) -> DocumentResult<Self> {
    method from_instance_array (line 299) | pub fn from_instance_array(v: Vec<Instance>) -> DocumentResult<Self> {

FILE: crates/lune-roblox/src/document/postprocessing.rs
  function postprocess_dom_for_place (line 9) | pub fn postprocess_dom_for_place(_dom: &mut WeakDom) {
  function postprocess_dom_for_model (line 13) | pub fn postprocess_dom_for_model(dom: &mut WeakDom) {
  function recurse_instances (line 28) | fn recurse_instances<F>(dom: &mut WeakDom, dom_ref: DomRef, f: &F)
  function remove_matching_prop (line 44) | fn remove_matching_prop(inst: &mut DomInstance, ty: DomType, name: &'sta...

FILE: crates/lune-roblox/src/exports.rs
  type LuaExportsTable (line 40) | pub trait LuaExportsTable {
    constant EXPORT_NAME (line 41) | const EXPORT_NAME: &'static str;
    method create_exports_table (line 43) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable>;
  function export (line 60) | pub fn export<T>(lua: Lua) -> LuaResult<(&'static str, LuaValue)>

FILE: crates/lune-roblox/src/instance/base.rs
  function add_methods (line 23) | pub fn add_methods<M: LuaUserDataMethods<Instance>>(m: &mut M) {
  function ensure_not_destroyed (line 192) | fn ensure_not_destroyed(inst: &Instance) -> LuaResult<()> {
  function instance_property_get (line 214) | fn instance_property_get(lua: &Lua, this: &Instance, prop_name: String) ...
  function instance_property_set (line 294) | fn instance_property_set(

FILE: crates/lune-roblox/src/instance/data_model.rs
  constant CLASS_NAME (line 13) | pub const CLASS_NAME: &str = "DataModel";
  function add_fields (line 15) | pub fn add_fields<F: LuaUserDataFields<Instance>>(f: &mut F) {
  function add_methods (line 19) | pub fn add_methods<M: LuaUserDataMethods<Instance>>(m: &mut M) {
  function data_model_get_workspace (line 31) | fn data_model_get_workspace(_: &Lua, this: &Instance) -> LuaResult<Insta...
  function data_model_get_service (line 42) | fn data_model_get_service(_: &Lua, this: &Instance, service_name: String...
  function data_model_find_service (line 63) | fn data_model_find_service(

FILE: crates/lune-roblox/src/instance/mod.rs
  constant PROPERTY_NAME_ATTRIBUTES (line 39) | const PROPERTY_NAME_ATTRIBUTES: &str = "Attributes";
  constant PROPERTY_NAME_TAGS (line 40) | const PROPERTY_NAME_TAGS: &str = "Tags";
  type Instance (line 46) | pub struct Instance {
    method new (line 62) | pub fn new(dom_ref: DomRef) -> Self {
    method new_opt (line 75) | pub fn new_opt(dom_ref: DomRef) -> Option<Self> {
    method new_orphaned (line 102) | pub fn new_orphaned(class_name: impl AsRef<str>) -> Self {
    method from_external_dom (line 127) | pub fn from_external_dom(external_dom: &mut WeakDom, external_dom_ref:...
    method clone_into_external_dom (line 143) | pub fn clone_into_external_dom(self, external_dom: &mut WeakDom) -> Do...
    method clone_multiple_into_external_dom (line 158) | pub fn clone_multiple_into_external_dom(
    method clone_instance (line 184) | pub fn clone_instance(&self) -> Self {
    method destroy (line 207) | pub fn destroy(&mut self) -> bool {
    method is_destroyed (line 218) | fn is_destroyed(&self) -> bool {
    method clear_all_children (line 234) | pub fn clear_all_children(&mut self) {
    method is_a (line 254) | pub fn is_a(&self, class_name: impl AsRef<str>) -> bool {
    method get_class_name (line 268) | pub fn get_class_name(&self) -> &str {
    method get_name (line 279) | pub fn get_name(&self) -> String {
    method set_name (line 295) | pub fn set_name(&self, name: impl Into<String>) {
    method get_parent (line 310) | pub fn get_parent(&self) -> Option<Instance> {
    method set_parent (line 334) | pub fn set_parent(&self, parent: Option<Instance>) {
    method get_property (line 345) | pub fn get_property(&self, name: impl AsRef<str>) -> Option<DomValue> {
    method set_property (line 362) | pub fn set_property(&self, name: impl AsRef<str>, value: DomValue) {
    method get_attribute (line 379) | pub fn get_attribute(&self, name: impl AsRef<str>) -> Option<DomValue> {
    method get_attributes (line 400) | pub fn get_attributes(&self) -> BTreeMap<String, DomValue> {
    method set_attribute (line 421) | pub fn set_attribute(&self, name: impl AsRef<str>, value: DomValue) {
    method remove_attribute (line 454) | pub fn remove_attribute(&self, name: impl AsRef<str>) {
    method add_tag (line 476) | pub fn add_tag(&self, name: impl AsRef<str>) {
    method get_tags (line 498) | pub fn get_tags(&self) -> Vec<String> {
    method has_tag (line 517) | pub fn has_tag(&self, name: impl AsRef<str>) -> bool {
    method remove_tag (line 537) | pub fn remove_tag(&self, name: impl AsRef<str>) {
    method get_children (line 561) | pub fn get_children(&self) -> Vec<Instance> {
    method get_descendants (line 584) | pub fn get_descendants(&self) -> Vec<Instance> {
    method get_full_name (line 618) | pub fn get_full_name(&self) -> String {
    method find_child (line 646) | pub fn find_child<F>(&self, predicate: F) -> Option<Instance>
    method find_ancestor (line 678) | pub fn find_ancestor<F>(&self, predicate: F) -> Option<Instance>
    method find_descendant (line 707) | pub fn find_descendant<F>(&self, predicate: F) -> Option<Instance>
    method fmt (line 789) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant EXPORT_NAME (line 737) | const EXPORT_NAME: &'static str = "Instance";
  method create_exports_table (line 739) | fn create_exports_table(lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 770) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 775) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method hash (line 783) | fn hash<H: Hasher>(&self, state: &mut H) {
  method eq (line 803) | fn eq(&self, other: &Self) -> bool {
  method from (line 809) | fn from(value: Instance) -> Self {

FILE: crates/lune-roblox/src/instance/registry.rs
  type InstanceRegistryMap (line 12) | type InstanceRegistryMap = HashMap<String, HashMap<String, LuaRegistryKe...
  type InstanceRegistryError (line 15) | pub enum InstanceRegistryError {
  type InstanceRegistry (line 31) | pub struct InstanceRegistry {
    method get_or_create (line 42) | fn get_or_create(lua: &Lua) -> AppDataRef<'_, Self> {
    method insert_method (line 61) | pub fn insert_method(
    method insert_property_getter (line 97) | pub fn insert_property_getter(
    method insert_property_setter (line 133) | pub fn insert_property_setter(
    method find_method (line 168) | pub fn find_method(lua: &Lua, instance: &Instance, method_name: &str) ...
    method find_property_getter (line 191) | pub fn find_property_getter(
    method find_property_setter (line 218) | pub fn find_property_setter(
  function class_name_chain (line 250) | pub fn class_name_chain(class_name: &str) -> Vec<&str> {

FILE: crates/lune-roblox/src/instance/terrain.rs
  constant CLASS_NAME (line 11) | pub const CLASS_NAME: &str = "Terrain";
  function add_methods (line 13) | pub fn add_methods<M: LuaUserDataMethods<Instance>>(methods: &mut M) {
  function get_or_create_material_colors (line 29) | fn get_or_create_material_colors(instance: &Instance) -> MaterialColors {
  function terrain_get_material_color (line 44) | fn terrain_get_material_color(_: &Lua, this: &Instance, material: EnumIt...
  function terrain_set_material_color (line 69) | fn terrain_set_material_color(

FILE: crates/lune-roblox/src/instance/workspace.rs
  constant CLASS_NAME (line 7) | pub const CLASS_NAME: &str = "Workspace";
  function add_fields (line 9) | pub fn add_fields<F: LuaUserDataFields<Instance>>(f: &mut F) {
  function workspace_get_terrain (line 21) | fn workspace_get_terrain(_: &Lua, this: &Instance) -> LuaResult<Instance> {
  function workspace_get_camera (line 32) | fn workspace_get_camera(_: &Lua, this: &Instance) -> LuaResult<Instance> {

FILE: crates/lune-roblox/src/lib.rs
  function create_all_exports (line 22) | fn create_all_exports(lua: Lua) -> LuaResult<Vec<(&'static str, LuaValue...
  function module (line 69) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {

FILE: crates/lune-roblox/src/reflection/class.rs
  type DbClass (line 20) | type DbClass = &'static ClassDescriptor<'static>;
  type DatabaseClass (line 27) | pub struct DatabaseClass(DbClass);
    method new (line 30) | pub(crate) fn new(inner: DbClass) -> Self {
    method get_name (line 38) | pub fn get_name(&self) -> String {
    method get_superclass (line 48) | pub fn get_superclass(&self) -> Option<String> {
    method get_properties (line 57) | pub fn get_properties(&self) -> HashMap<String, DatabaseProperty> {
    method get_defaults (line 69) | pub fn get_defaults(&self) -> HashMap<String, DomVariant> {
    method get_tags_str (line 83) | pub fn get_tags_str(&self) -> Vec<&'static str> {
    method fmt (line 131) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method add_fields (line 95) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 118) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method eq (line 125) | fn eq(&self, other: &Self) -> bool {
  function find_enum_name (line 137) | fn find_enum_name(inner: DbClass, name: impl AsRef<str>) -> Option<Strin...
  function make_enum_value (line 152) | fn make_enum_value(inner: DbClass, name: impl AsRef<str>, value: u32) ->...

FILE: crates/lune-roblox/src/reflection/enums.rs
  type DbEnum (line 11) | type DbEnum = &'static EnumDescriptor<'static>;
  type DatabaseEnum (line 18) | pub struct DatabaseEnum(DbEnum);
    method new (line 21) | pub(crate) fn new(inner: DbEnum) -> Self {
    method get_name (line 29) | pub fn get_name(&self) -> String {
    method get_items (line 40) | pub fn get_items(&self) -> HashMap<String, u32> {
    method fmt (line 69) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method add_fields (line 51) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 56) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method eq (line 63) | fn eq(&self, other: &Self) -> bool {

FILE: crates/lune-roblox/src/reflection/mod.rs
  type Db (line 20) | type Db = &'static ReflectionDatabase<'static>;
  type Database (line 27) | pub struct Database(Db);
    method new (line 34) | pub fn new() -> Self {
    method get_version (line 45) | pub fn get_version(&self) -> String {
    method get_enum_names (line 54) | pub fn get_enum_names(&self) -> Vec<String> {
    method get_class_names (line 62) | pub fn get_class_names(&self) -> Vec<String> {
    method get_enum (line 69) | pub fn get_enum(&self, name: impl AsRef<str>) -> Option<DatabaseEnum> {
    method get_class (line 77) | pub fn get_class(&self, name: impl AsRef<str>) -> Option<DatabaseClass> {
    method find_enum (line 87) | pub fn find_enum(&self, name: impl AsRef<str>) -> Option<DatabaseEnum> {
    method find_class (line 102) | pub fn find_class(&self, name: impl AsRef<str>) -> Option<DatabaseClas...
    method fmt (line 149) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method add_fields (line 115) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 119) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method default (line 137) | fn default() -> Self {
  method eq (line 143) | fn eq(&self, _other: &Self) -> bool {

FILE: crates/lune-roblox/src/reflection/property.rs
  type DbClass (line 13) | type DbClass = &'static ClassDescriptor<'static>;
  type DbProp (line 14) | type DbProp = &'static PropertyDescriptor<'static>;
  type DatabaseProperty (line 21) | pub struct DatabaseProperty(DbClass, DbProp);
    method new (line 24) | pub(crate) fn new(inner: DbClass, inner_prop: DbProp) -> Self {
    method get_name (line 32) | pub fn get_name(&self) -> String {
    method get_datatype_name (line 44) | pub fn get_datatype_name(&self) -> String {
    method get_scriptability_str (line 54) | pub fn get_scriptability_str(&self) -> &'static str {
    method get_tags_str (line 64) | pub fn get_tags_str(&self) -> Vec<&'static str> {
    method fmt (line 96) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method add_fields (line 76) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 83) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method eq (line 90) | fn eq(&self, other: &Self) -> bool {

FILE: crates/lune-roblox/src/reflection/utils.rs
  function data_type_to_str (line 5) | pub fn data_type_to_str(data_type: DataType) -> String {
  function scriptability_to_str (line 20) | pub fn scriptability_to_str(scriptability: Scriptability) -> &'static str {
  function property_tag_to_str (line 31) | pub fn property_tag_to_str(tag: PropertyTag) -> &'static str {
  function class_tag_to_str (line 44) | pub fn class_tag_to_str(tag: ClassTag) -> &'static str {

FILE: crates/lune-roblox/src/shared/classes.rs
  function add_class_restricted_getter (line 9) | pub(crate) fn add_class_restricted_getter<F: LuaUserDataFields<Instance>...
  function add_class_restricted_setter (line 30) | pub(crate) fn add_class_restricted_setter<F: LuaUserDataFields<Instance>...
  function add_class_restricted_method (line 50) | pub(crate) fn add_class_restricted_method<M: LuaUserDataMethods<Instance...
  function add_class_restricted_method_mut (line 71) | pub(crate) fn add_class_restricted_method_mut<M: LuaUserDataMethods<Inst...
  function get_or_create_property_ref_instance (line 104) | pub(crate) fn get_or_create_property_ref_instance(

FILE: crates/lune-roblox/src/shared/instance.rs
  type PropertyInfo (line 9) | pub(crate) struct PropertyInfo {
  function find_property_info (line 24) | pub(crate) fn find_property_info(
  function class_exists (line 105) | pub fn class_exists(class_name: impl AsRef<str>) -> bool {
  function class_is_a (line 118) | pub fn class_is_a(instance_class: impl AsRef<str>, class_name: impl AsRe...
  function class_is_a_service (line 149) | pub fn class_is_a_service(instance_class: impl AsRef<str>) -> Option<boo...
  function is_a_class_valid (line 173) | fn is_a_class_valid() {
  function is_a_class_invalid (line 185) | fn is_a_class_invalid() {
  function is_a_service_valid (line 197) | fn is_a_service_valid() {
  function is_a_service_invalid (line 205) | fn is_a_service_invalid() {

FILE: crates/lune-roblox/src/shared/userdata.rs
  type ListWriter (line 9) | type ListWriter = dyn Fn(&mut fmt::Formatter<'_>, bool, &str) -> fmt::Re...
  function make_list_writer (line 12) | pub fn make_list_writer() -> Box<ListWriter> {
  function userdata_impl_to_string (line 34) | pub fn userdata_impl_to_string<D>(_: &Lua, datatype: &D, _: ()) -> LuaRe...
  function userdata_impl_eq (line 41) | pub fn userdata_impl_eq<D>(_: &Lua, datatype: &D, value: LuaValue) -> Lu...
  function userdata_impl_unm (line 56) | pub fn userdata_impl_unm<D>(_: &Lua, datatype: &D, _: ()) -> LuaResult<D>
  function userdata_impl_add (line 63) | pub fn userdata_impl_add<D>(_: &Lua, datatype: &D, value: LuaUserDataRef...
  function userdata_impl_sub (line 70) | pub fn userdata_impl_sub<D>(_: &Lua, datatype: &D, value: LuaUserDataRef...
  function userdata_impl_mul_f32 (line 77) | pub fn userdata_impl_mul_f32<D>(_: &Lua, datatype: &D, rhs: LuaValue) ->...
  function userdata_impl_mul_i32 (line 102) | pub fn userdata_impl_mul_i32<D>(_: &Lua, datatype: &D, rhs: LuaValue) ->...
  function userdata_impl_div_f32 (line 127) | pub fn userdata_impl_div_f32<D>(_: &Lua, datatype: &D, rhs: LuaValue) ->...
  type IDiv (line 152) | pub trait IDiv<Rhs = Self> {
    method idiv (line 155) | fn idiv(self, rhs: Rhs) -> Self::Output;
  function userdata_impl_idiv_f32 (line 158) | pub fn userdata_impl_idiv_f32<D>(_: &Lua, datatype: &D, rhs: LuaValue) -...
  function userdata_impl_div_i32 (line 183) | pub fn userdata_impl_div_i32<D>(_: &Lua, datatype: &D, rhs: LuaValue) ->...

FILE: crates/lune-std-datetime/src/date_time.rs
  constant DEFAULT_FORMAT (line 12) | const DEFAULT_FORMAT: &str = "%Y-%m-%d %H:%M:%S";
  constant DEFAULT_LOCALE (line 13) | const DEFAULT_LOCALE: &str = "en";
  type DateTime (line 16) | pub struct DateTime {
    method now (line 30) | pub fn now() -> Self {
    method from_unix_timestamp_float (line 52) | pub fn from_unix_timestamp_float(unix_timestamp: f64) -> DateTimeResul...
    method from_universal_time (line 74) | pub fn from_universal_time(values: &DateTimeValues) -> DateTimeResult<...
    method from_local_time (line 102) | pub fn from_local_time(values: &DateTimeValues) -> DateTimeResult<Self> {
    method format_string_local (line 132) | pub fn format_string_local(&self, format: Option<&str>, locale: Option...
    method format_string_universal (line 151) | pub fn format_string_universal(&self, format: Option<&str>, locale: Op...
    method from_rfc_3339 (line 171) | pub fn from_rfc_3339(date: impl AsRef<str>) -> DateTimeResult<Self> {
    method from_rfc_2822 (line 186) | pub fn from_rfc_2822(date: impl AsRef<str>) -> DateTimeResult<Self> {
    method to_local_time (line 196) | pub fn to_local_time(self) -> DateTimeValues {
    method to_universal_time (line 205) | pub fn to_universal_time(self) -> DateTimeValues {
    method to_rfc_3339 (line 215) | pub fn to_rfc_3339(self) -> String {
    method to_rfc_2822 (line 225) | pub fn to_rfc_2822(self) -> String {
  method add_fields (line 231) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 238) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-datetime/src/lib.rs
  constant TYPEDEFS (line 13) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 19) | pub fn typedefs() -> String {
  function module (line 30) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {

FILE: crates/lune-std-datetime/src/result.rs
  type DateTimeResult (line 5) | pub type DateTimeResult<T, E = DateTimeError> = Result<T, E>;
  type DateTimeError (line 8) | pub enum DateTimeError {
  method from (line 29) | fn from(value: DateTimeError) -> Self {

FILE: crates/lune-std-datetime/src/values.rs
  type DateTimeValues (line 10) | pub struct DateTimeValues {
    method verify (line 34) | pub fn verify(self) -> DateTimeResult<Self> {
    method from (line 126) | fn from(value: DateTime<T>) -> Self {
  function verify_in_range (line 46) | fn verify_in_range<T>(name: &'static str, value: T, min: T, max: T) -> D...
  method from_lua (line 72) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method into_lua (line 104) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  type Error (line 140) | type Error = DateTimeError;
  function try_from (line 141) | fn try_from(value: DateTimeValues) -> Result<Self, Self::Error> {
  type Error (line 156) | type Error = DateTimeError;
  function try_from (line 157) | fn try_from(value: DateTimeValues) -> Result<Self, Self::Error> {

FILE: crates/lune-std-fs/src/copy.rs
  type CopyContents (line 11) | pub struct CopyContents {
  function get_contents_at (line 17) | async fn get_contents_at(root: PathBuf, _: FsWriteOptions) -> LuaResult<...
  function ensure_no_dir_exists (line 73) | async fn ensure_no_dir_exists(path: impl AsRef<Path>) -> LuaResult<()> {
  function ensure_no_file_exists (line 84) | async fn ensure_no_file_exists(path: impl AsRef<Path>) -> LuaResult<()> {
  function copy (line 95) | pub async fn copy(

FILE: crates/lune-std-fs/src/lib.rs
  constant TYPEDEFS (line 21) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 27) | pub fn typedefs() -> String {
  function module (line 38) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function fs_read_file (line 54) | async fn fs_read_file(lua: Lua, path: String) -> LuaResult<LuaString> {
  function fs_read_dir (line 60) | async fn fs_read_dir(_: Lua, path: String) -> LuaResult<Vec<String>> {
  function fs_write_file (line 76) | async fn fs_write_file(_: Lua, (path, contents): (String, BString)) -> L...
  function fs_write_dir (line 80) | async fn fs_write_dir(_: Lua, path: String) -> LuaResult<()> {
  function fs_remove_file (line 84) | async fn fs_remove_file(_: Lua, path: String) -> LuaResult<()> {
  function fs_remove_dir (line 88) | async fn fs_remove_dir(_: Lua, path: String) -> LuaResult<()> {
  function fs_metadata (line 92) | async fn fs_metadata(_: Lua, path: String) -> LuaResult<FsMetadata> {
  function fs_is_file (line 100) | async fn fs_is_file(_: Lua, path: String) -> LuaResult<bool> {
  function fs_is_dir (line 108) | async fn fs_is_dir(_: Lua, path: String) -> LuaResult<bool> {
  function fs_move (line 116) | async fn fs_move(_: Lua, (from, to, options): (String, String, FsWriteOp...
  function fs_copy (line 135) | async fn fs_copy(_: Lua, (from, to, options): (String, String, FsWriteOp...

FILE: crates/lune-std-fs/src/metadata.rs
  type FsMetadataKind (line 14) | pub enum FsMetadataKind {
    method fmt (line 22) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 51) | fn from(value: StdFileType) -> Self {
  type Err (line 37) | type Err = &'static str;
  method from_str (line 39) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method into_lua (line 65) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  type FsPermissions (line 75) | pub struct FsPermissions {
    method from (line 80) | fn from(value: StdPermissions) -> Self {
  method into_lua (line 88) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  type FsMetadata (line 97) | pub struct FsMetadata {
    method not_found (line 107) | pub fn not_found() -> Self {
    method from (line 134) | fn from(value: StdMetadata) -> Self {
  method into_lua (line 120) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  function system_time_to_timestamp (line 146) | fn system_time_to_timestamp(res: IoResult<SystemTime>) -> Option<DateTim...

FILE: crates/lune-std-fs/src/options.rs
  type FsWriteOptions (line 4) | pub struct FsWriteOptions {
  method from_lua (line 9) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-luau/src/lib.rs
  constant TYPEDEFS (line 11) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 17) | pub fn typedefs() -> String {
  function module (line 28) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function compile_source (line 35) | fn compile_source(
  function load_source (line 45) | fn load_source(

FILE: crates/lune-std-luau/src/options.rs
  constant DEFAULT_DEBUG_NAME (line 6) | const DEFAULT_DEBUG_NAME: &str = "luau.load(...)";
  type LuauCompileOptions (line 12) | pub struct LuauCompileOptions {
    method into_compiler (line 19) | pub fn into_compiler(self) -> LuaCompiler {
  method default (line 28) | fn default() -> Self {
  method from_lua (line 40) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  type LuauLoadOptions (line 82) | pub struct LuauLoadOptions {
  method default (line 90) | fn default() -> Self {
  method from_lua (line 101) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-net/src/body/cursor.rs
  type ReadableBodyCursor (line 9) | pub struct ReadableBodyCursor {
    method len (line 15) | pub fn len(&self) -> usize {
    method as_slice (line 19) | pub fn as_slice(&self) -> &[u8] {
    method advance (line 23) | pub fn advance(&mut self, cnt: usize) {
    method into_bytes (line 30) | pub fn into_bytes(self) -> Bytes {
    method from (line 53) | fn from(value: T) -> Self {
  method remaining (line 36) | fn remaining(&self) -> usize {
  method chunk (line 40) | fn chunk(&self) -> &[u8] {
  method advance (line 44) | fn advance(&mut self, cnt: usize) {

FILE: crates/lune-std-net/src/body/incoming.rs
  function handle_incoming_body (line 12) | pub async fn handle_incoming_body(

FILE: crates/lune-std-net/src/body/inner.rs
  type ReadableBodyInner (line 8) | pub enum ReadableBodyInner {
    method len (line 16) | pub fn len(&self) -> usize {
    method as_slice (line 25) | pub fn as_slice(&self) -> &[u8] {
    method into_bytes (line 66) | pub fn into_bytes(self) -> Bytes {
    method from (line 77) | fn from(value: &'static str) -> Self {
    method from (line 83) | fn from(value: Vec<u8>) -> Self {
    method from (line 89) | fn from(value: Bytes) -> Self {
    method from (line 95) | fn from(value: String) -> Self {
    method from (line 101) | fn from(value: LuaString) -> Self {
    method from (line 107) | fn from(value: LuaBuffer) -> Self {

FILE: crates/lune-std-net/src/body/readable.rs
  type ReadableBody (line 20) | pub struct ReadableBody {
    method empty (line 25) | pub const fn empty() -> Self {
    method as_slice (line 29) | pub fn as_slice(&self) -> &[u8] {
    method into_bytes (line 36) | pub fn into_bytes(self) -> Bytes {
    method from (line 71) | fn from(value: T) -> Self {
    method from (line 82) | fn from(value: Option<T>) -> Self {
  type Data (line 45) | type Data = ReadableBodyCursor;
  type Error (line 46) | type Error = Infallible;
  method poll_frame (line 48) | fn poll_frame(
  method is_end_stream (line 55) | fn is_end_stream(&self) -> bool {
  method size_hint (line 59) | fn size_hint(&self) -> SizeHint {
  method from_lua (line 90) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-net/src/client/fetch.rs
  function fetch (line 33) | pub async fn fetch(
  function fetch_inner (line 83) | async fn fetch_inner(

FILE: crates/lune-std-net/src/client/mod.rs
  constant MAX_REDIRECTS (line 25) | const MAX_REDIRECTS: usize = 10;
  function connect_ws (line 30) | pub async fn connect_ws(url: Url) -> LuaResult<Websocket<WsStream>> {
  function connect_tcp (line 38) | pub async fn connect_tcp(host: String, port: u16, config: TcpConfig) -> ...
  function try_follow_redirect (line 52) | fn try_follow_redirect(
  function check_redirect (line 87) | fn check_redirect(method: Method, response: &HyperResponse<Incoming>) ->...

FILE: crates/lune-std-net/src/client/rustls.rs
  function initialize_provider (line 10) | pub fn initialize_provider() {

FILE: crates/lune-std-net/src/client/send.rs
  function send (line 27) | pub async fn send(mut request: Request, lua: Lua) -> LuaResult<Response> {

FILE: crates/lune-std-net/src/client/stream.rs
  type HttpStream (line 26) | pub type HttpStream = MaybeTlsStream;
  type MaybeTlsStream (line 36) | pub enum MaybeTlsStream {
    method connect (line 50) | pub async fn connect(host: &str, port: u16, tls: bool) -> Result<Self> {
    method connect_url (line 70) | pub async fn connect_url(url: Url) -> Result<Self> {
    method local_addr (line 91) | pub fn local_addr(&self) -> Result<SocketAddr> {
    method remote_addr (line 98) | pub fn remote_addr(&self) -> Result<SocketAddr> {
    method set_ttl (line 107) | pub fn set_ttl(&self, ttl: u32) -> Result<()> {
    method as_ref (line 113) | fn as_ref(&self) -> &TcpStream {
    method from (line 122) | fn from(stream: TcpStream) -> Self {
    method from (line 128) | fn from(stream: TlsStream<TcpStream>) -> Self {
  method poll_read (line 134) | fn poll_read(
  method poll_write (line 147) | fn poll_write(
  method poll_close (line 158) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  method poll_flush (line 165) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Re...
  type WsStream (line 179) | pub struct WsStream {
    method connect_url (line 189) | pub async fn connect_url(url: Url) -> Result<Self> {
    type Error (line 202) | type Error = TungsteniteError;
    method poll_ready (line 204) | fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method start_send (line 208) | fn start_send(mut self: Pin<&mut Self>, item: Message) -> TungsteniteR...
    method poll_flush (line 212) | fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
    method poll_close (line 216) | fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<...
  type Item (line 222) | type Item = TungsteniteResult<Message>;
  method poll_next (line 224) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: crates/lune-std-net/src/client/tcp.rs
  type TcpConfig (line 4) | pub struct TcpConfig {
  method from_lua (line 10) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-net/src/lib.rs
  constant TYPEDEFS (line 22) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 28) | pub fn typedefs() -> String {
  function module (line 39) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function net_http_request (line 67) | async fn net_http_request(lua: Lua, req: Request) -> LuaResult<Response> {
  function net_http_serve (line 71) | async fn net_http_serve(lua: Lua, (port, config): (u16, ServeConfig)) ->...
  function net_tcp_connect (line 77) | async fn net_tcp_connect(_: Lua, (host, port, config): (String, u16, Tcp...
  function net_ws_connect (line 81) | async fn net_ws_connect(_: Lua, url: String) -> LuaResult<Websocket<WsSt...
  function net_url_encode (line 86) | fn net_url_encode(
  function net_url_decode (line 95) | fn net_url_decode(

FILE: crates/lune-std-net/src/server/config.rs
  constant DEFAULT_IP_ADDRESS (line 5) | const DEFAULT_IP_ADDRESS: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
  constant WEB_SOCKET_UPDGRADE_REQUEST_HANDLER (line 7) | const WEB_SOCKET_UPDGRADE_REQUEST_HANDLER: &str = r#"
  type ServeConfig (line 18) | pub struct ServeConfig {
  method from_lua (line 25) | fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-net/src/server/handle.rs
  type ServeHandle (line 15) | pub struct ServeHandle {
    method new (line 22) | pub fn new(addr: SocketAddr) -> (Self, Receiver<()>) {
    method into_lua_table (line 34) | pub fn into_lua_table(self, lua: Lua) -> LuaResult<LuaTable> {
  method add_fields (line 55) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 60) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-net/src/server/mod.rs
  function serve (line 28) | pub async fn serve(lua: Lua, port: u16, config: ServeConfig) -> LuaResul...

FILE: crates/lune-std-net/src/server/service.rs
  type Service (line 22) | pub(super) struct Service {
    type Response (line 29) | type Response = HyperResponse<ReadableBody>;
    type Error (line 30) | type Error = LuaError;
    type Future (line 31) | type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self:...
    method call (line 33) | fn call(&self, req: HyperRequest<Incoming>) -> Self::Future {
  function handle_request (line 80) | async fn handle_request(
  function handle_websocket (line 102) | async fn handle_websocket(

FILE: crates/lune-std-net/src/server/upgrade.rs
  constant SEC_WEBSOCKET_VERSION (line 11) | const SEC_WEBSOCKET_VERSION: HeaderName = HeaderName::from_static("sec-w...
  constant SEC_WEBSOCKET_KEY (line 12) | const SEC_WEBSOCKET_KEY: HeaderName = HeaderName::from_static("sec-webso...
  constant SEC_WEBSOCKET_ACCEPT (line 13) | const SEC_WEBSOCKET_ACCEPT: HeaderName = HeaderName::from_static("sec-we...
  function is_upgrade_request (line 15) | pub fn is_upgrade_request(request: &HyperRequest<Incoming>) -> bool {
  function make_upgrade_response (line 33) | pub fn make_upgrade_response(

FILE: crates/lune-std-net/src/shared/futures.rs
  function either (line 12) | pub fn either<L: Future, R: Future>(

FILE: crates/lune-std-net/src/shared/headers.rs
  function create_user_agent_header (line 11) | pub fn create_user_agent_header(lua: &Lua) -> LuaResult<String> {
  function header_map_to_table (line 26) | pub fn header_map_to_table(
  function hash_map_to_table (line 47) | pub fn hash_map_to_table(

FILE: crates/lune-std-net/src/shared/hyper.rs
  type HyperExecutor (line 19) | pub struct HyperExecutor {
    method attach (line 25) | pub fn attach(lua: &Lua) -> mlua::AppDataRef<'_, Self> {
    method execute (line 30) | pub fn execute<Fut>(lua: Lua, fut: Fut)
    method execute (line 47) | fn execute(&self, fut: Fut) {
  type HyperTimer (line 55) | pub struct HyperTimer;
    method sleep (line 58) | fn sleep(&self, duration: Duration) -> Pin<Box<dyn rt::Sleep>> {
    method sleep_until (line 62) | fn sleep_until(&self, at: Instant) -> Pin<Box<dyn rt::Sleep>> {
    method reset (line 66) | fn reset(&self, sleep: &mut Pin<Box<dyn rt::Sleep>>, new_deadline: Ins...
  type HyperSleep (line 76) | pub struct HyperSleep {
    method from (line 81) | fn from(inner: Timer) -> Self {
  type Output (line 87) | type Output = ();
  method poll (line 89) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
  function from (line 111) | fn from(inner: T) -> Self {
  function pin_mut (line 117) | pub fn pin_mut(self: Pin<&mut Self>) -> Pin<&mut T> {
  function poll_read (line 125) | fn poll_read(
  function poll_write (line 153) | fn poll_write(
  function poll_flush (line 161) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  function poll_shutdown (line 165) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io:...
  method poll_read (line 173) | fn poll_read(
  method poll_write (line 185) | fn poll_write(
  method poll_flush (line 193) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_close (line 197) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...

FILE: crates/lune-std-net/src/shared/lua.rs
  function lua_value_to_method (line 8) | pub fn lua_value_to_method(value: &LuaValue) -> LuaResult<Method> {
  function lua_table_to_header_map (line 30) | pub fn lua_table_to_header_map(table: &LuaTable) -> LuaResult<HeaderMap> {

FILE: crates/lune-std-net/src/shared/request.rs
  type RequestOptions (line 18) | pub struct RequestOptions {
  method default (line 23) | fn default() -> Self {
  method from_lua (line 29) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  type Request (line 57) | pub struct Request {
    method from_incoming (line 68) | pub async fn from_incoming(
    method with_address (line 89) | pub fn with_address(mut self, address: SocketAddr) -> Self {
    method method (line 97) | pub fn method(&self) -> Method {
    method path (line 104) | pub fn path(&self) -> &str {
    method query (line 111) | pub fn query(&self) -> HashMap<String, Vec<String>> {
    method headers (line 131) | pub fn headers(&self) -> &HeaderMap {
    method body (line 138) | pub fn body(&self) -> &[u8] {
    method clone_inner (line 146) | pub fn clone_inner(&self) -> HyperRequest<ReadableBody> {
    method into_inner (line 154) | pub fn into_inner(self) -> HyperRequest<ReadableBody> {
    method from (line 160) | fn from(inner: HyperRequest<B>) -> Self {
  method from_lua (line 172) | fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {
  method add_fields (line 251) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {

FILE: crates/lune-std-net/src/shared/response.rs
  type Response (line 15) | pub struct Response {
    method from_incoming (line 24) | pub async fn from_incoming(
    method status_ok (line 41) | pub fn status_ok(&self) -> bool {
    method status_code (line 48) | pub fn status_code(&self) -> u16 {
    method status_message (line 55) | pub fn status_message(&self) -> &str {
    method headers (line 62) | pub fn headers(&self) -> &HeaderMap {
    method body (line 69) | pub fn body(&self) -> &[u8] {
    method clone_inner (line 77) | pub fn clone_inner(&self) -> HyperResponse<ReadableBody> {
    method into_inner (line 85) | pub fn into_inner(self) -> HyperResponse<ReadableBody> {
  method from_lua (line 91) | fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {
  method add_fields (line 142) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {

FILE: crates/lune-std-net/src/shared/tcp.rs
  constant DEFAULT_BUFFER_SIZE (line 14) | const DEFAULT_BUFFER_SIZE: usize = 1024;
  type Tcp (line 17) | pub struct Tcp {
    method read (line 25) | async fn read(&self, size: usize) -> Result<Vec<u8>, Error> {
    method write (line 36) | async fn write(&self, data: Vec<u8>) -> Result<(), Error> {
    method close (line 43) | async fn close(&self) -> Result<(), Error> {
    method from (line 56) | fn from(value: T) -> Self {
  method add_fields (line 74) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 89) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-net/src/shared/websocket.rs
  type Websocket (line 24) | pub struct Websocket<T> {
  function get_close_code (line 36) | fn get_close_code(&self) -> Option<u16> {
  function set_close_code (line 44) | fn set_close_code(&self, code: u16) {
  function send (line 49) | pub async fn send(&self, msg: TungsteniteMessage) -> LuaResult<()> {
  function next (line 54) | pub async fn next(&self) -> LuaResult<Option<TungsteniteMessage>> {
  function close (line 59) | pub async fn close(&self, code: Option<u16>) -> LuaResult<()> {
  function from (line 88) | fn from(value: T) -> Self {
  method add_fields (line 105) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 109) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-net/src/url/decode.rs
  function decode (line 3) | pub fn decode(lua_string: LuaString, as_binary: bool) -> LuaResult<Vec<u...

FILE: crates/lune-std-net/src/url/encode.rs
  function encode (line 3) | pub fn encode(lua_string: LuaString, as_binary: bool) -> LuaResult<Vec<u...

FILE: crates/lune-std-process/src/create/child.rs
  type Child (line 15) | pub struct Child {
    method new (line 24) | pub fn new(lua: &Lua, mut child: AsyncChild) -> Self {
  method add_fields (line 46) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 52) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  function handle_child (line 71) | async fn handle_child(

FILE: crates/lune-std-process/src/create/child_reader.rs
  constant DEFAULT_BUFFER_SIZE (line 9) | const DEFAULT_BUFFER_SIZE: usize = 1024;
  type ChildReaderInner (line 14) | enum ChildReaderInner {
    method read (line 21) | async fn read(&mut self, size: usize) -> Result<Vec<u8>, std::io::Erro...
    method read_to_end (line 39) | async fn read_to_end(&mut self) -> Result<Vec<u8>, std::io::Error> {
    method from (line 58) | fn from(stdout: AsyncChildStdout) -> Self {
    method from (line 64) | fn from(stderr: AsyncChildStderr) -> Self {
    method from (line 70) | fn from(stdout: Option<AsyncChildStdout>) -> Self {
    method from (line 76) | fn from(stderr: Option<AsyncChildStderr>) -> Self {
  type ChildReader (line 84) | pub struct ChildReader {
    method from (line 115) | fn from(inner: T) -> Self {
  method add_methods (line 89) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-process/src/create/child_writer.rs
  type ChildWriterInner (line 13) | enum ChildWriterInner {
    method write (line 19) | async fn write(&mut self, data: Vec<u8>) -> Result<(), std::io::Error> {
    method close (line 26) | async fn close(&mut self) -> Result<(), std::io::Error> {
    method from (line 35) | fn from(stdin: AsyncChildStdin) -> Self {
    method from (line 41) | fn from(stdin: Option<AsyncChildStdin>) -> Self {
  type ChildWriter (line 49) | pub struct ChildWriter {
    method from (line 74) | fn from(inner: T) -> Self {
  method add_methods (line 54) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-process/src/exec/mod.rs
  function exec (line 15) | pub async fn exec(

FILE: crates/lune-std-process/src/exec/tee_writer.rs
  type AsyncTeeWriter (line 11) | pub struct AsyncTeeWriter<'a, W>
  function new (line 24) | pub fn new(writer: &'a mut W) -> Self {
  function into_vec (line 31) | pub fn into_vec(self) -> Vec<u8> {
  method poll_write (line 40) | fn poll_write(
  method poll_flush (line 56) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_close (line 60) | fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...

FILE: crates/lune-std-process/src/exec/wait_for_child.rs
  type WaitForChildResult (line 14) | pub(super) struct WaitForChildResult {
  function read_with_stdio_kind (line 20) | async fn read_with_stdio_kind<R>(
  function wait_for_child (line 53) | pub(super) async fn wait_for_child(

FILE: crates/lune-std-process/src/lib.rs
  constant TYPEDEFS (line 24) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 30) | pub fn typedefs() -> String {
  function module (line 42) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function process_exec (line 91) | async fn process_exec(
  function process_create (line 115) | fn process_create(

FILE: crates/lune-std-process/src/options/kind.rs
  type ProcessSpawnOptionsStdioKind (line 6) | pub enum ProcessSpawnOptionsStdioKind {
    method all (line 17) | pub fn all() -> &'static [Self] {
    method as_stdio (line 21) | pub fn as_stdio(self) -> Stdio {
    method fmt (line 31) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 43) | type Err = LuaError;
  method from_str (line 44) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method from_lua (line 66) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-process/src/options/mod.rs
  type ProcessSpawnOptions (line 21) | pub(super) struct ProcessSpawnOptions {
    method into_command (line 134) | pub fn into_command(self, program: impl Into<OsString>, args: ProcessA...
  method from_lua (line 29) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-process/src/options/stdio.rs
  type ProcessSpawnOptionsStdio (line 7) | pub struct ProcessSpawnOptionsStdio {
    method from (line 14) | fn from(value: ProcessSpawnOptionsStdioKind) -> Self {
  method from_lua (line 24) | fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-regex/src/captures.rs
  type OptionalCaptures (line 9) | type OptionalCaptures<'a> = Option<Captures<'a>>;
  type LuaCaptures (line 22) | pub struct LuaCaptures {
    method new (line 32) | pub fn new(pattern: &Regex, text: String) -> Option<Self> {
    method captures (line 42) | fn captures(&self) -> &Captures<'_> {
    method num_captures (line 49) | fn num_captures(&self) -> usize {
    method text (line 55) | fn text(&self) -> Arc<String> {
  method add_methods (line 61) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method add_fields (line 88) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {

FILE: crates/lune-std-regex/src/lib.rs
  constant TYPEDEFS (line 13) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 19) | pub fn typedefs() -> String {
  function module (line 30) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function new_regex (line 36) | fn new_regex(_: &Lua, pattern: String) -> LuaResult<LuaRegex> {

FILE: crates/lune-std-regex/src/matches.rs
  type LuaMatch (line 9) | pub struct LuaMatch {
    method new (line 19) | pub fn new(text: Arc<String>, matched: Match) -> Self {
    method range (line 27) | fn range(&self) -> Range<usize> {
    method slice (line 31) | fn slice(&self) -> &str {
  method add_fields (line 37) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {
  method add_methods (line 47) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-std-regex/src/regex.rs
  type LuaRegex (line 12) | pub struct LuaRegex {
    method new (line 20) | pub fn new(pattern: String) -> LuaResult<Self> {
  method add_methods (line 28) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {
  method add_fields (line 73) | fn add_fields<F: LuaUserDataFields<Self>>(fields: &mut F) {

FILE: crates/lune-std-roblox/src/lib.rs
  constant TYPEDEFS (line 19) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 25) | pub fn typedefs() -> String {
  function module (line 36) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function deserialize_place (line 61) | async fn deserialize_place(lua: Lua, contents: LuaString) -> LuaResult<L...
  function deserialize_model (line 71) | async fn deserialize_model(lua: Lua, contents: LuaString) -> LuaResult<L...
  function serialize_place (line 81) | async fn serialize_place(
  function serialize_model (line 98) | async fn serialize_model(
  function get_auth_cookie (line 115) | fn get_auth_cookie(_: &Lua, raw: Option<bool>) -> LuaResult<Option<Strin...
  function get_reflection_database (line 123) | fn get_reflection_database(_: &Lua, _: ()) -> LuaResult<ReflectionDataba...
  function implement_property (line 127) | fn implement_property(
  function implement_method (line 153) | fn implement_method(
  function studio_application_path (line 161) | fn studio_application_path(_: &Lua, _: ()) -> LuaResult<String> {
  function studio_content_path (line 167) | fn studio_content_path(_: &Lua, _: ()) -> LuaResult<String> {
  function studio_plugin_path (line 173) | fn studio_plugin_path(_: &Lua, _: ()) -> LuaResult<String> {
  function studio_builtin_plugin_path (line 179) | fn studio_builtin_plugin_path(_: &Lua, _: ()) -> LuaResult<String> {

FILE: crates/lune-std-serde/src/compress_decompress.rs
  type CompressDecompressFormat (line 22) | pub enum CompressDecompressFormat {
    method detect_from_bytes (line 36) | pub fn detect_from_bytes(bytes: impl AsRef<[u8]>) -> Option<Self> {
    method detect_from_header_str (line 82) | pub fn detect_from_header_str(header: impl AsRef<str>) -> Option<Self> {
  method from_lua (line 95) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  function compress (line 128) | pub async fn compress(
  function decompress (line 175) | pub async fn decompress(
  function compress_lz4 (line 214) | fn compress_lz4(input: Vec<u8>) -> LuaResult<Vec<u8>> {
  function decompress_lz4 (line 235) | fn decompress_lz4(input: Vec<u8>) -> LuaResult<Vec<u8>> {

FILE: crates/lune-std-serde/src/encode_decode.rs
  constant LUA_SERIALIZE_OPTIONS (line 8) | const LUA_SERIALIZE_OPTIONS: LuaSerializeOptions = LuaSerializeOptions::...
  constant LUA_DESERIALIZE_OPTIONS (line 14) | const LUA_DESERIALIZE_OPTIONS: LuaDeserializeOptions = LuaDeserializeOpt...
  type EncodeDecodeFormat (line 25) | pub enum EncodeDecodeFormat {
  method from_lua (line 33) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  type EncodeDecodeConfig (line 64) | pub struct EncodeDecodeConfig {
    method from (line 70) | fn from(format: EncodeDecodeFormat) -> Self {
    method from (line 79) | fn from(value: (EncodeDecodeFormat, bool)) -> Self {
  function encode (line 94) | pub fn encode(value: LuaValue, lua: &Lua, config: EncodeDecodeConfig) ->...
  function decode (line 130) | pub fn decode(

FILE: crates/lune-std-serde/src/hash.rs
  type HashOptions (line 12) | pub struct HashOptions {
    method hash (line 76) | pub fn hash(self) -> String {
    method hmac (line 116) | pub fn hmac(self) -> LuaResult<String> {
  type HashAlgorithm (line 20) | enum HashAlgorithm {
    constant ALL (line 38) | pub const ALL: [Self; 11] = [
    method name (line 52) | pub const fn name(self) -> &'static str {
  method from_lua (line 178) | fn from_lua(value: LuaValue, _lua: &Lua) -> LuaResult<Self> {
  method from_lua_multi (line 225) | fn from_lua_multi(mut values: LuaMultiValue, lua: &Lua) -> LuaResult<Sel...

FILE: crates/lune-std-serde/src/lib.rs
  constant TYPEDEFS (line 16) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 22) | pub fn typedefs() -> String {
  function module (line 33) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function serde_encode (line 44) | fn serde_encode(
  function serde_decode (line 52) | fn serde_decode(lua: &Lua, (format, bs): (EncodeDecodeFormat, BString)) ...
  function serde_compress (line 57) | async fn serde_compress(
  function serde_decompress (line 65) | async fn serde_decompress(
  function hash_message (line 73) | fn hash_message(lua: &Lua, options: HashOptions) -> LuaResult<LuaString> {
  function hmac_message (line 77) | fn hmac_message(lua: &Lua, options: HashOptions) -> LuaResult<LuaString> {

FILE: crates/lune-std-stdio/src/lib.rs
  constant FORMAT_CONFIG (line 26) | const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
  constant TYPEDEFS (line 36) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 42) | pub fn typedefs() -> String {
  function module (line 53) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  function stdio_color (line 66) | fn stdio_color(lua: &Lua, color: ColorKind) -> LuaResult<LuaValue> {
  function stdio_style (line 70) | fn stdio_style(lua: &Lua, style: StyleKind) -> LuaResult<LuaValue> {
  function stdio_format (line 74) | fn stdio_format(_: &Lua, args: LuaMultiValue) -> LuaResult<String> {
  function stdio_write (line 78) | async fn stdio_write(_: Lua, s: LuaString) -> LuaResult<()> {
  function stdio_ewrite (line 85) | async fn stdio_ewrite(_: Lua, s: LuaString) -> LuaResult<()> {
  function stdio_read_line (line 92) | async fn stdio_read_line(lua: Lua, (): ()) -> LuaResult<LuaString> {
  function stdio_read_to_end (line 99) | async fn stdio_read_to_end(lua: Lua, (): ()) -> LuaResult<LuaString> {
  function stdio_prompt (line 106) | async fn stdio_prompt(lua: Lua, options: PromptOptions) -> LuaResult<Pro...

FILE: crates/lune-std-stdio/src/prompt.rs
  type PromptKind (line 7) | pub enum PromptKind {
    constant ALL (line 15) | const ALL: [PromptKind; 4] = [Self::Text, Self::Confirm, Self::Select,...
    method fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method default (line 19) | fn default() -> Self {
  type Err (line 25) | type Err = ();
  method from_str (line 26) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method from_lua (line 53) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  type PromptOptions (line 80) | pub struct PromptOptions {
  method from_lua_multi (line 89) | fn from_lua_multi(mut values: LuaMultiValue, lua: &Lua) -> LuaResult<Sel...
  type PromptResult (line 159) | pub enum PromptResult {
  method into_lua (line 168) | fn into_lua(self, lua: &Lua) -> LuaResult<LuaValue> {
  function prompt (line 179) | pub fn prompt(options: PromptOptions) -> LuaResult<PromptResult> {

FILE: crates/lune-std-stdio/src/style_and_color.rs
  constant ESCAPE_SEQ_RESET (line 5) | const ESCAPE_SEQ_RESET: &str = "\x1b[0m";
  type ColorKind (line 11) | pub enum ColorKind {
    constant ALL (line 24) | pub const ALL: [Self; 9] = [
    method name (line 39) | pub fn name(self) -> &'static str {
    method ansi_escape_sequence (line 56) | pub fn ansi_escape_sequence(self) -> &'static str {
  type Err (line 72) | type Err = ();
  method from_str (line 73) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method from_lua (line 92) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  type StyleKind (line 124) | pub enum StyleKind {
    constant ALL (line 131) | pub const ALL: [Self; 3] = [Self::Reset, Self::Bold, Self::Dim];
    method name (line 136) | pub fn name(self) -> &'static str {
    method ansi_escape_sequence (line 147) | pub fn ansi_escape_sequence(self) -> &'static str {
  type Err (line 157) | type Err = ();
  method from_str (line 158) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method from_lua (line 169) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {

FILE: crates/lune-std-task/src/lib.rs
  constant TYPEDEFS (line 13) | const TYPEDEFS: &str = include_str!(concat!(env!("CARGO_MANIFEST_DIR"), ...
  function typedefs (line 19) | pub fn typedefs() -> String {
  function module (line 30) | pub fn module(lua: Lua) -> LuaResult<LuaTable> {
  constant DELAY_IMPL_LUA (line 56) | const DELAY_IMPL_LUA: &str = r"
  function wait (line 63) | async fn wait(lua: Lua, secs: Option<f64>) -> LuaResult<f64> {
  function wait_inner (line 70) | async fn wait_inner(_: Lua, secs: Option<f64>) -> LuaResult<f64> {

FILE: crates/lune-std/src/global.rs
  type LuneStandardGlobal (line 9) | pub enum LuneStandardGlobal {
    constant ALL (line 21) | pub const ALL: &'static [Self] = &[
    method name (line 33) | pub fn name(&self) -> &'static str {
    method create (line 52) | pub fn create(&self, lua: Lua) -> LuaResult<LuaValue> {
  type Err (line 71) | type Err = String;
  method from_str (line 72) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: crates/lune-std/src/globals/g_table.rs
  function create (line 3) | pub fn create(lua: Lua) -> LuaResult<LuaValue> {

FILE: crates/lune-std/src/globals/print.rs
  constant FORMAT_CONFIG (line 6) | const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
  function create (line 10) | pub fn create(lua: Lua) -> LuaResult<LuaValue> {

FILE: crates/lune-std/src/globals/require.rs
  function create (line 5) | pub fn create(lua: Lua) -> LuaResult<LuaValue> {

FILE: crates/lune-std/src/globals/version.rs
  type Version (line 5) | struct Version(String);
  function create (line 9) | pub fn create(lua: Lua) -> LuaResult<LuaValue> {
  function set_global_version (line 31) | pub fn set_global_version(lua: &Lua, version: impl Into<String>) {

FILE: crates/lune-std/src/globals/warn.rs
  constant FORMAT_CONFIG (line 6) | const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new()
  function create (line 10) | pub fn create(lua: Lua) -> LuaResult<LuaValue> {

FILE: crates/lune-std/src/lib.rs
  function inject_globals (line 23) | pub fn inject_globals(lua: Lua) -> LuaResult<()> {
  function inject_std (line 38) | pub fn inject_std(lua: Lua) -> LuaResult<()> {

FILE: crates/lune-std/src/library.rs
  type LuneStandardLibrary (line 10) | pub enum LuneStandardLibrary {
    constant ALL (line 28) | pub const ALL: &'static [Self] = &[
    method name (line 47) | pub fn name(&self) -> &'static str {
    method typedefs (line 70) | pub fn typedefs(&self) -> String {
    method module (line 96) | pub fn module(&self, lua: Lua) -> LuaResult<LuaTable> {
  type Err (line 123) | type Err = String;
  method from_str (line 125) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: crates/lune-std/src/require/loader.rs
  type RequireResult (line 15) | type RequireResult = LuaResult<LuaMultiValue>;
  type RequireResultSender (line 16) | type RequireResultSender = Sender<RequireResult>;
  type RequireResultReceiver (line 17) | type RequireResultReceiver = Receiver<RequireResult>;
  type RequireLoaderState (line 23) | struct RequireLoaderState {
    method new (line 29) | fn new() -> Self {
    method get_pending_at_path (line 36) | fn get_pending_at_path(&self, path: &Path) -> Option<RequireResultRece...
    method create_pending_at_path (line 40) | fn create_pending_at_path(&self, path: &Path) -> RequireResultSender {
    method remove_pending_at_path (line 47) | fn remove_pending_at_path(&self, path: &Path) {
  type RequireLoader (line 58) | pub(crate) struct RequireLoader {
    method new (line 63) | pub(crate) fn new() -> Self {
    method load (line 69) | pub(crate) fn load(

FILE: crates/lune-std/src/require/resolver.rs
  type RequireResolver (line 17) | pub(crate) struct RequireResolver {
    method new (line 36) | pub(crate) fn new() -> Self {
    method navigate_reset (line 45) | fn navigate_reset(&mut self) {
    method navigate_to (line 51) | fn navigate_to(
  method is_require_allowed (line 75) | fn is_require_allowed(&self, chunk_name: &str) -> bool {
  method reset (line 79) | fn reset(&mut self, chunk_name: &str) -> Result<(), LuaNavigateError> {
  method jump_to_alias (line 98) | fn jump_to_alias(&mut self, path: &str) -> Result<(), LuaNavigateError> {
  method to_parent (line 105) | fn to_parent(&mut self) -> Result<(), LuaNavigateError> {
  method to_child (line 130) | fn to_child(&mut self, name: &str) -> Result<(), LuaNavigateError> {
  method has_module (line 137) | fn has_module(&self) -> bool {
  method cache_key (line 142) | fn cache_key(&self) -> String {
  method has_config (line 147) | fn has_config(&self) -> bool {
  method config (line 151) | fn config(&self) -> IoResult<Vec<u8>> {
  method loader (line 155) | fn loader(&self, lua: &Lua) -> LuaResult<LuaFunction> {

FILE: crates/lune-utils/src/fmt/error/components.rs
  constant STACK_TRACE_INDENT (line 33) | const STACK_TRACE_INDENT: &str = "    ";
  type ErrorComponents (line 51) | pub struct ErrorComponents {
    method messages (line 61) | pub fn messages(&self) -> &[String] {
    method trace (line 69) | pub fn trace(&self) -> Option<&StackTrace> {
    method has_trace (line 79) | pub fn has_trace(&self) -> bool {
    method fmt (line 87) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method from (line 104) | fn from(error: LuaError) -> Self {
    method from (line 204) | fn from(value: Box<LuaError>) -> Self {

FILE: crates/lune-utils/src/fmt/error/stack_trace.rs
  function unwrap_braced_path (line 4) | fn unwrap_braced_path(s: &str) -> &str {
  function parse_path (line 10) | fn parse_path(s: &str) -> Option<(&str, &str)> {
  function parse_function_name (line 24) | fn parse_function_name(s: &str) -> Option<&str> {
  function parse_line_number (line 29) | fn parse_line_number(s: &str) -> (Option<usize>, &str) {
  type StackTraceSource (line 40) | pub enum StackTraceSource {
    method is_c (line 53) | pub const fn is_c(self) -> bool {
    method is_lua (line 61) | pub const fn is_lua(self) -> bool {
  type StackTraceLine (line 70) | pub struct StackTraceLine {
    method source (line 82) | pub fn source(&self) -> StackTraceSource {
    method path (line 90) | pub fn path(&self) -> Option<&str> {
    method line_number (line 98) | pub fn line_number(&self) -> Option<usize> {
    method function_name (line 106) | pub fn function_name(&self) -> Option<&str> {
    method is_empty (line 120) | pub const fn is_empty(&self) -> bool {
    method fmt (line 154) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 126) | type Err = String;
  method from_str (line 127) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type StackTrace (line 174) | pub struct StackTrace {
    method lines (line 183) | pub fn lines(&self) -> &[StackTraceLine] {
    method lines_mut (line 191) | pub fn lines_mut(&mut self) -> &mut Vec<StackTraceLine> {
  type Err (line 197) | type Err = String;
  method from_str (line 198) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: crates/lune-utils/src/fmt/error/tests.rs
  function new_lua_runtime_error (line 5) | fn new_lua_runtime_error() -> LuaResult<()> {
  function new_lua_script_error (line 18) | fn new_lua_script_error() -> LuaResult<()> {
  function preserves_original (line 42) | fn preserves_original() {
  function preserves_levels (line 53) | fn preserves_levels() {
  function message (line 75) | fn message() {
  function stack_begin_end (line 83) | fn stack_begin_end() {
  function stack_lines (line 92) | fn stack_lines() {
  function message_does_not_contain_location (line 111) | fn message_does_not_contain_location() {
  function no_redundant_c_mentions (line 134) | fn no_redundant_c_mentions() {

FILE: crates/lune-utils/src/fmt/label.rs
  type Label (line 24) | pub enum Label {
    method name (line 35) | pub fn name(&self) -> &str {
    method color (line 47) | pub fn color(&self) -> Color {
    method fmt (line 57) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: crates/lune-utils/src/fmt/value/basic.rs
  constant STRING_REPLACEMENTS (line 13) | const STRING_REPLACEMENTS: &[(&str, &str)] =
  function lua_value_as_plain_string_key (line 24) | pub(crate) fn lua_value_as_plain_string_key(value: &LuaValue) -> Option<...
  function format_value_styled (line 42) | pub(crate) fn format_value_styled(value: &LuaValue, prefer_plain: bool) ...
  function format_typename_and_tostringed (line 90) | fn format_typename_and_tostringed(

FILE: crates/lune-utils/src/fmt/value/config.rs
  type ValueFormatConfig (line 5) | pub struct ValueFormatConfig {
    method new (line 15) | pub const fn new() -> Self {
    method with_max_depth (line 26) | pub const fn with_max_depth(self, max_depth: usize) -> Self {
    method with_colors_enabled (line 36) | pub const fn with_colors_enabled(self, colors_enabled: bool) -> Self {
  method default (line 45) | fn default() -> Self {

FILE: crates/lune-utils/src/fmt/value/metamethods.rs
  function get_table_type_metavalue (line 3) | pub fn get_table_type_metavalue(tab: &LuaTable) -> Option<String> {
  function get_userdata_type_metavalue (line 10) | pub fn get_userdata_type_metavalue(usr: &LuaAnyUserData) -> Option<Strin...
  function call_table_tostring_metamethod (line 17) | pub fn call_table_tostring_metamethod(tab: &LuaTable) -> Option<String> {
  function call_userdata_tostring_metamethod (line 27) | pub fn call_userdata_tostring_metamethod(usr: &LuaAnyUserData) -> Option...

FILE: crates/lune-utils/src/fmt/value/mod.rs
  function pretty_format_value (line 31) | pub fn pretty_format_value(value: &LuaValue, config: &ValueFormatConfig)...
  function pretty_format_multi_value (line 51) | pub fn pretty_format_multi_value(values: &LuaMultiValue, config: &ValueF...

FILE: crates/lune-utils/src/fmt/value/recursive.rs
  constant INDENT (line 14) | const INDENT: &str = "    ";
  type LuaValueId (line 20) | pub(crate) struct LuaValueId(usize);
    method from (line 23) | fn from(value: &LuaValue) -> Self {
    method from (line 29) | fn from(table: &LuaTable) -> Self {
  function format_value_recursive (line 41) | pub(crate) fn format_value_recursive(
  function sort_for_formatting (line 103) | fn sort_for_formatting(values: &mut [(LuaValue, LuaValue)]) {
  function format_array (line 122) | fn format_array(
  function format_table (line 141) | fn format_table(
  function format_typename_and_tostringed (line 174) | fn format_typename_and_tostringed(

FILE: crates/lune-utils/src/path/constants.rs
  constant FILE_CHUNK_PREFIX (line 5) | pub const FILE_CHUNK_PREFIX: char = '@';
  constant FILE_NAME_INIT (line 6) | pub const FILE_NAME_INIT: &str = "init";
  constant FILE_NAME_CONFIG (line 7) | pub const FILE_NAME_CONFIG: &str = ".luaurc";
  constant FILE_EXTENSIONS (line 8) | pub const FILE_EXTENSIONS: [&str; 2] = ["luau", "lua"];

FILE: crates/lune-utils/src/path/luau.rs
  type LuauFilePath (line 23) | pub enum LuauFilePath {
    method resolve (line 31) | fn resolve(module: impl AsRef<Path>) -> Result<Self, LuaNavigateError> {
    method is_file (line 75) | pub const fn is_file(&self) -> bool {
    method is_dir (line 80) | pub const fn is_dir(&self) -> bool {
    method as_file (line 85) | pub fn as_file(&self) -> Option<&Path> {
    method as_dir (line 93) | pub fn as_dir(&self) -> Option<&Path> {
    method as_ref (line 102) | fn as_ref(&self) -> &Path {
    method fmt (line 110) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type LuauModulePath (line 129) | pub struct LuauModulePath {
    method strip (line 147) | pub fn strip(path: impl Into<PathBuf>) -> PathBuf {
    method resolve (line 187) | pub fn resolve(module: impl Into<PathBuf>) -> Result<Self, LuaNavigate...
    method source (line 197) | pub fn source(&self) -> &Path {
    method target (line 205) | pub fn target(&self) -> &LuauFilePath {
    method fmt (line 211) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: crates/lune-utils/src/path/std.rs
  function create_cwd (line 17) | fn create_cwd() -> Arc<Path> {
  function create_exe (line 31) | fn create_exe() -> Arc<Path> {
  function get_current_dir (line 54) | pub fn get_current_dir() -> Arc<Path> {
  function get_current_exe (line 69) | pub fn get_current_exe() -> Arc<Path> {
  function clean_path (line 79) | pub fn clean_path(path: impl AsRef<Path>) -> PathBuf {
  function clean_path_and_make_absolute (line 91) | pub fn clean_path_and_make_absolute(path: impl AsRef<Path>) -> PathBuf {
  function append_extension (line 106) | pub fn append_extension(path: impl AsRef<Path>, ext: impl AsRef<OsStr>) ...
  function relative_path_normalize (line 126) | pub fn relative_path_normalize(path: impl AsRef<Path>) -> PathBuf {
  function relative_path_parent (line 144) | pub fn relative_path_parent(rel: &mut PathBuf) {

FILE: crates/lune-utils/src/process/args.rs
  type ProcessArgsInner (line 15) | struct ProcessArgsInner {
    method from_iter (line 20) | fn from_iter<T: IntoIterator<Item = OsString>>(iter: T) -> Self {
  type ProcessArgs (line 39) | pub struct ProcessArgs {
    method empty (line 45) | pub fn empty() -> Self {
    method current (line 52) | pub fn current() -> Self {
    method len (line 59) | pub fn len(&self) -> usize {
    method is_empty (line 65) | pub fn is_empty(&self) -> bool {
    method all (line 73) | pub fn all(&self) -> Vec<OsString> {
    method get (line 79) | pub fn get(&self, index: usize) -> Option<OsString> {
    method set (line 84) | pub fn set(&self, index: usize, val: impl Into<OsString>) {
    method push (line 91) | pub fn push(&self, val: impl Into<OsString>) {
    method pop (line 97) | pub fn pop(&self) -> Option<OsString> {
    method insert (line 102) | pub fn insert(&self, index: usize, val: impl Into<OsString>) {
    method remove (line 110) | pub fn remove(&self, index: usize) -> Option<OsString> {
    method all_bytes (line 122) | pub fn all_bytes(&self) -> Vec<Vec<u8>> {
    method get_bytes (line 130) | pub fn get_bytes(&self, index: usize) -> Option<Vec<u8>> {
    method set_bytes (line 135) | pub fn set_bytes(&self, index: usize, val: impl Into<Vec<u8>>) {
    method push_bytes (line 141) | pub fn push_bytes(&self, val: impl Into<Vec<u8>>) {
    method pop_bytes (line 148) | pub fn pop_bytes(&self) -> Option<Vec<u8>> {
    method insert_bytes (line 152) | pub fn insert_bytes(&self, index: usize, val: impl Into<Vec<u8>>) {
    method remove_bytes (line 158) | pub fn remove_bytes(&self, index: usize) -> Option<Vec<u8>> {
    method into_plain_lua_table (line 166) | pub fn into_plain_lua_table(&self, lua: Lua) -> LuaResult<LuaTable> {
    method from_iter (line 192) | fn from_iter<T: IntoIterator<Item = S>>(iter: T) -> Self {
    method extend (line 200) | fn extend<T: IntoIterator<Item = S>>(&mut self, iter: T) {
  type Item (line 182) | type Item = OsString;
  type IntoIter (line 183) | type IntoIter = std::vec::IntoIter<OsString>;
  method into_iter (line 185) | fn into_iter(self) -> Self::IntoIter {
  method from_lua (line 209) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method add_methods (line 241) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-utils/src/process/env.rs
  type ProcessEnvInner (line 16) | struct ProcessEnvInner {
    method from_iter (line 21) | fn from_iter<T: IntoIterator<Item = (OsString, OsString)>>(iter: T) ->...
  type ProcessEnv (line 40) | pub struct ProcessEnv {
    method empty (line 46) | pub fn empty() -> Self {
    method current (line 53) | pub fn current() -> Self {
    method len (line 60) | pub fn len(&self) -> usize {
    method is_empty (line 66) | pub fn is_empty(&self) -> bool {
    method get_all (line 74) | pub fn get_all(&self) -> Vec<(OsString, OsString)> {
    method get_value (line 80) | pub fn get_value(&self, key: impl AsRef<OsStr>) -> Option<OsString> {
    method set_value (line 89) | pub fn set_value(&self, key: impl Into<OsString>, val: impl Into<OsStr...
    method remove_value (line 101) | pub fn remove_value(&self, key: impl AsRef<OsStr>) {
    method get_all_bytes (line 115) | pub fn get_all_bytes(&self) -> Vec<(Vec<u8>, Vec<u8>)> {
    method get_value_bytes (line 123) | pub fn get_value_bytes(&self, key: impl AsRef<[u8]>) -> Option<Vec<u8>> {
    method set_value_bytes (line 129) | pub fn set_value_bytes(&self, key: impl AsRef<[u8]>, val: impl Into<Ve...
    method remove_value_bytes (line 137) | pub fn remove_value_bytes(&self, key: impl AsRef<[u8]>) {
    method into_plain_lua_table (line 148) | pub fn into_plain_lua_table(&self, lua: Lua) -> LuaResult<LuaTable> {
    method from_iter (line 175) | fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
    method extend (line 188) | fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
  type Item (line 165) | type Item = (OsString, OsString);
  type IntoIter (line 166) | type IntoIter = std::collections::btree_map::IntoIter<OsString, OsString>;
  method into_iter (line 168) | fn into_iter(self) -> Self::IntoIter {
  method from_lua (line 201) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {
  method add_methods (line 238) | fn add_methods<M: LuaUserDataMethods<Self>>(methods: &mut M) {

FILE: crates/lune-utils/src/process/jit.rs
  type ProcessJitEnablement (line 2) | pub struct ProcessJitEnablement {
    method new (line 8) | pub fn new(enabled: bool) -> Self {
    method set_status (line 12) | pub fn set_status(&mut self, enabled: bool) {
    method enabled (line 17) | pub fn enabled(self) -> bool {
    method from (line 29) | fn from(val: bool) -> Self {
  function from (line 23) | fn from(val: ProcessJitEnablement) -> Self {

FILE: crates/lune-utils/src/process/mod.rs
  function lua_value_to_os_string (line 14) | fn lua_value_to_os_string(res: LuaResult<LuaValue>, to: &'static str) ->...
  function validate_os_key (line 44) | fn validate_os_key(key: &OsStr) -> LuaResult<()> {
  function validate_os_value (line 61) | fn validate_os_value(val: &OsStr) -> LuaResult<()> {
  function validate_os_pair (line 74) | fn validate_os_pair((key, value): (&OsStr, &OsStr)) -> LuaResult<()> {

FILE: crates/lune-utils/src/table_builder.rs
  type TableBuilder (line 10) | pub struct TableBuilder {
    method new (line 19) | pub fn new(lua: Lua) -> LuaResult<Self> {
    method with_value (line 29) | pub fn with_value<K, V>(self, key: K, value: V) -> LuaResult<Self>
    method with_values (line 43) | pub fn with_values<K, V>(self, values: Vec<(K, V)>) -> LuaResult<Self>
    method with_sequential_value (line 60) | pub fn with_sequential_value<V>(self, value: V) -> LuaResult<Self>
    method with_sequential_values (line 74) | pub fn with_sequential_values<V>(self, values: Vec<V>) -> LuaResult<Self>
    method with_function (line 89) | pub fn with_function<K, A, R, F>(self, key: K, func: F) -> LuaResult<S...
    method with_async_function (line 105) | pub fn with_async_function<K, A, R, F, FR>(self, key: K, func: F) -> L...
    method with_metatable (line 122) | pub fn with_metatable(self, table: LuaTable) -> LuaResult<Self> {
    method build_readonly (line 132) | pub fn build_readonly(self) -> LuaResult<LuaTable> {
    method build (line 140) | pub fn build(self) -> LuaResult<LuaTable> {

FILE: crates/lune-utils/src/version_string.rs
  function get_version_string (line 19) | pub fn get_version_string(lune_version: impl AsRef<str>) -> String {
  function create_luau_version_string (line 29) | fn create_luau_version_string() -> Arc<String> {
  function is_valid_version_char (line 71) | fn is_valid_version_char(c: char) -> bool {

FILE: crates/lune/src/cli/build/base_exe.rs
  constant RELEASE_REQUEST_HEADERS (line 17) | const RELEASE_REQUEST_HEADERS: &[(&str, &str)] = &[
  function get_or_download_base_executable (line 39) | pub async fn get_or_download_base_executable(target: BuildTarget) -> Bui...

FILE: crates/lune/src/cli/build/files.rs
  function remove_source_file_ext (line 12) | pub fn remove_source_file_ext(path: &Path) -> PathBuf {
  function write_executable_file_to (line 27) | pub async fn write_executable_file_to(

FILE: crates/lune/src/cli/build/mod.rs
  type BuildCommand (line 21) | pub struct BuildCommand {
    method run (line 37) | pub async fn run(self) -> Result<ExitCode> {

FILE: crates/lune/src/cli/build/result.rs
  type BuildError (line 9) | pub enum BuildError {
  type BuildResult (line 22) | pub type BuildResult<T, E = BuildError> = std::result::Result<T, E>;

FILE: crates/lune/src/cli/build/target.rs
  type BuildTargetOS (line 18) | pub enum BuildTargetOS {
    method current_system (line 25) | fn current_system() -> Self {
    method exe_extension (line 34) | fn exe_extension(self) -> &'static str {
    method exe_suffix (line 43) | fn exe_suffix(self) -> &'static str {
    method fmt (line 52) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 62) | type Err = &'static str;
  method from_str (line 63) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type BuildTargetArch (line 77) | pub enum BuildTargetArch {
    method current_system (line 83) | fn current_system() -> Self {
    method fmt (line 93) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 102) | type Err = &'static str;
  method from_str (line 103) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type BuildTarget (line 128) | pub struct BuildTarget {
    method current_system (line 134) | pub fn current_system() -> Self {
    method is_current_system (line 141) | pub fn is_current_system(&self) -> bool {
    method exe_extension (line 145) | pub fn exe_extension(&self) -> &'static str {
    method exe_suffix (line 149) | pub fn exe_suffix(&self) -> &'static str {
    method cache_path (line 153) | pub fn cache_path(&self) -> PathBuf {
    method fmt (line 159) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 165) | type Err = &'static str;
  method from_str (line 166) | fn from_str(s: &str) -> Result<Self, Self::Err> {

FILE: crates/lune/src/cli/list.rs
  type ListCommand (line 10) | pub struct ListCommand {}
    method run (line 13) | pub async fn run(self) -> Result<ExitCode> {

FILE: crates/lune/src/cli/mod.rs
  type CliSubcommand (line 18) | pub enum CliSubcommand {
  method default (line 27) | fn default() -> Self {
  type Cli (line 35) | pub struct Cli {
    method new (line 41) | pub fn new() -> Self {
    method run (line 71) | pub async fn run(self) -> Result<ExitCode> {

FILE: crates/lune/src/cli/repl.rs
  constant MESSAGE_WELCOME (line 11) | const MESSAGE_WELCOME: &str = concat!("Lune v", env!("CARGO_PKG_VERSION"));
  constant MESSAGE_INTERRUPT (line 12) | const MESSAGE_INTERRUPT: &str = "Interrupt: ^C again to exit";
  type PromptState (line 14) | enum PromptState {
  type ReplCommand (line 21) | pub struct ReplCommand {}
    method run (line 24) | pub async fn run(self) -> Result<ExitCode> {

FILE: crates/lune/src/cli/run.rs
  type RunCommand (line 14) | pub struct RunCommand {
    method run (line 22) | pub async fn run(self) -> Result<ExitCode> {

FILE: crates/lune/src/cli/setup.rs
  constant LUAURC_PATH (line 11) | const LUAURC_PATH: &str = ".luaurc";
  type SetupCommand (line 15) | pub struct SetupCommand {}
    method run (line 18) | pub async fn run(self) -> Result<ExitCode> {
  type SetupError (line 40) | enum SetupError {
  function lune_version (line 51) | fn lune_version() -> &'static str {
  function read_or_create_luaurc (line 55) | async fn read_or_create_luaurc() -> Result<JsonValue, SetupError> {
  function write_luaurc (line 69) | async fn write_luaurc(luaurc: JsonValue) -> Result<(), SetupError> {
  function add_values_to_luaurc (line 82) | fn add_values_to_luaurc(luaurc: &mut JsonValue) {
  function generate_typedef_files_from_definitions (line 104) | async fn generate_typedef_files_from_definitions() -> Result<String> {

FILE: crates/lune/src/cli/utils/files.rs
  constant LUNE_COMMENT_PREFIX (line 9) | const LUNE_COMMENT_PREFIX: &str = "-->";
  function discover_script_path (line 17) | pub fn discover_script_path(path: impl Into<PathBuf>, in_home_dir: bool)...
  function discover_script_path_including_lune_dirs (line 64) | pub fn discover_script_path_including_lune_dirs(path: impl AsRef<Path>) ...
  function parse_lune_description_from_file (line 93) | pub fn parse_lune_description_from_file(contents: &str) -> Option<String> {

FILE: crates/lune/src/cli/utils/listing.rs
  function find_lune_scripts (line 18) | pub async fn find_lune_scripts(in_home_dir: bool) -> Result<Vec<(String,...
  function sort_lune_scripts (line 92) | pub fn sort_lune_scripts(scripts: Vec<(String, String)>) -> Vec<(String,...
  function write_lune_scripts_list (line 111) | pub fn write_lune_scripts_list(buffer: &mut String, scripts: Vec<(String...

FILE: crates/lune/src/main.rs
  function main (line 12) | fn main() -> ExitCode {

FILE: crates/lune/src/rt/result.rs
  type RuntimeResult (line 10) | pub type RuntimeResult<T, E = RuntimeError> = Result<T, E>;
  type RuntimeError (line 16) | pub struct RuntimeError {
    method enable_colors (line 29) | pub fn enable_colors(mut self) -> Self {
    method disable_colors (line 41) | pub fn disable_colors(mut self) -> Self {
    method is_incomplete_input (line 52) | pub fn is_incomplete_input(&self) -> bool {
    method from (line 64) | fn from(value: LuaError) -> Self {
    method from (line 73) | fn from(value: &LuaError) -> Self {
  method fmt (line 82) | fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
  method cause (line 88) | fn cause(&self) -> Option<&dyn Error> {

FILE: crates/lune/src/rt/runtime.rs
  type RuntimeReturnValues (line 27) | pub struct RuntimeReturnValues {
    method status (line 48) | pub fn status(&self) -> u8 {
    method success (line 58) | pub fn success(&self) -> bool {
  type Runtime (line 66) | pub struct Runtime {
    method new (line 85) | pub fn new() -> LuaResult<Self> {
    method with_args (line 156) | pub fn with_args<A, S>(mut self, args: A) -> Self
    method with_env (line 171) | pub fn with_env<E, K, V>(mut self, env: E) -> Self
    method with_jit (line 185) | pub fn with_jit<J>(mut self, jit_status: J) -> Self
    method with_lib (line 231) | pub fn with_lib<S, F>(self, name: S, make_lib: F) -> RuntimeResult<Self>
    method run_custom (line 273) | pub async fn run_custom(
    method run_file (line 292) | pub async fn run_file(
    method run_inner (line 335) | async fn run_inner(
  function strip_shebang (line 398) | fn strip_shebang(mut contents: Vec<u8>) -> Vec<u8> {

FILE: crates/lune/src/standalone/metadata.rs
  constant MAGIC (line 9) | const MAGIC: &[u8; 8] = b"cr3sc3nt";
  type Metadata (line 30) | pub struct Metadata {
    method check_env (line 39) | pub async fn check_env() -> (bool, Vec<u8>) {
    method create_env_patched_bin (line 50) | pub async fn create_env_patched_bin(
    method from_bytes (line 74) | pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Result<Self> {
    method to_bytes (line 94) | pub fn to_bytes(&self) -> Vec<u8> {

FILE: crates/lune/src/standalone/mod.rs
  function check (line 15) | pub async fn check() -> Option<Vec<u8>> {
  function run (line 27) | pub async fn run(patched_bin: impl AsRef<[u8]>) -> Result<ExitCode> {

FILE: crates/lune/src/tests.rs
  constant ARGS (line 13) | const ARGS: &[&str] = &["Foo", "Bar"];
  function run_test (line 15) | fn run_test(path: &str) -> Result<ExitCode> {

FILE: crates/mlua-luau-scheduler/examples/basic_sleep.rs
  constant MAIN_SCRIPT (line 12) | const MAIN_SCRIPT: &str = include_str!("./lua/basic_sleep.luau");
  function main (line 14) | pub fn main() -> LuaResult<()> {
  function test_basic_sleep (line 48) | fn test_basic_sleep() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/basic_spawn.rs
  constant MAIN_SCRIPT (line 12) | const MAIN_SCRIPT: &str = include_str!("./lua/basic_spawn.luau");
  function main (line 14) | pub fn main() -> LuaResult<()> {
  function test_basic_spawn (line 62) | fn test_basic_spawn() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/callbacks.rs
  constant MAIN_SCRIPT (line 10) | const MAIN_SCRIPT: &str = include_str!("./lua/callbacks.luau");
  function main (line 12) | pub fn main() -> LuaResult<()> {
  function test_callbacks (line 46) | fn test_callbacks() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/exit_code.rs
  constant MAIN_SCRIPT (line 10) | const MAIN_SCRIPT: &str = include_str!("./lua/exit_code.luau");
  function main (line 12) | pub fn main() -> LuaResult<()> {
  function test_exit_code (line 41) | fn test_exit_code() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/lots_of_threads.rs
  constant MAIN_SCRIPT (line 12) | const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
  constant ONE_NANOSECOND (line 14) | const ONE_NANOSECOND: Duration = Duration::from_nanos(1);
  function main (line 16) | pub fn main() -> LuaResult<()> {
  function test_lots_of_threads (line 53) | fn test_lots_of_threads() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/scheduler_ordering.rs
  constant MAIN_SCRIPT (line 12) | const MAIN_SCRIPT: &str = include_str!("./lua/scheduler_ordering.luau");
  function main (line 14) | pub fn main() -> LuaResult<()> {
  function test_scheduler_ordering (line 54) | fn test_scheduler_ordering() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/examples/tracy.rs
  constant MAIN_SCRIPT (line 27) | const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
  constant ONE_NANOSECOND (line 29) | const ONE_NANOSECOND: Duration = Duration::from_nanos(1);
  function main (line 31) | pub fn main() -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/src/error_callback.rs
  type ErrorCallback (line 5) | type ErrorCallback = Box<dyn Fn(LuaError) + Send + 'static>;
  type ThreadErrorCallback (line 8) | pub(crate) struct ThreadErrorCallback {
    method new (line 13) | pub fn new() -> Self {
    method replace (line 19) | pub fn replace(&self, callback: impl Fn(LuaError) + Send + 'static) {
    method clear (line 23) | pub fn clear(&self) {
    method call (line 27) | pub fn call(&self, error: &LuaError) {
  function default_error_callback (line 35) | fn default_error_callback(e: LuaError) {
  method default (line 40) | fn default() -> Self {

FILE: crates/mlua-luau-scheduler/src/events/multi.rs
  type MultiEventState (line 14) | struct MultiEventState {
  type MultiEvent (line 23) | pub(crate) struct MultiEvent {
    method new (line 31) | pub fn new() -> Self {
    method notify (line 38) | pub fn notify(&self) {
    method listen (line 54) | pub fn listen(&self) -> MultiListener {
  type MultiListener (line 66) | pub(crate) struct MultiListener {
  type Output (line 72) | type Output = ();
  method poll (line 74) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: crates/mlua-luau-scheduler/src/events/once.rs
  type OnceEventState (line 15) | struct OnceEventState {
    method new (line 20) | fn new() -> Self {
  type OnceEvent (line 33) | pub struct OnceEvent {
    method new (line 41) | pub fn new() -> Self {
    method notify (line 53) | pub fn notify(&self) {
    method listen (line 66) | pub fn listen(&self) -> OnceListener {
  type OnceListener (line 81) | pub struct OnceListener {
  type Output (line 86) | type Output = ();
  method poll (line 88) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

FILE: crates/mlua-luau-scheduler/src/exit.rs
  type Exit (line 6) | pub(crate) struct Exit {
    method new (line 12) | pub fn new() -> Self {
    method set (line 19) | pub fn set(&self, code: u8) {
    method get (line 24) | pub fn get(&self) -> Option<u8> {
    method listen (line 28) | pub async fn listen(&self) {

FILE: crates/mlua-luau-scheduler/src/functions.rs
  constant ERR_METADATA_NOT_ATTACHED (line 13) | const ERR_METADATA_NOT_ATTACHED: &str = "\
  constant EXIT_IMPL_LUA (line 19) | const EXIT_IMPL_LUA: &str = r"
  constant WRAP_IMPL_LUA (line 24) | const WRAP_IMPL_LUA: &str = r"
  type Functions (line 42) | pub struct Functions {
    method new (line 91) | pub fn new(lua: Lua) -> LuaResult<Self> {
    method inject_compat (line 268) | pub fn inject_compat(&self, lua: &Lua) -> LuaResult<()> {

FILE: crates/mlua-luau-scheduler/src/queue/deferred.rs
  type DeferredThreadQueue (line 9) | pub(crate) struct DeferredThreadQueue(ThreadQueue);
    method new (line 12) | pub fn new() -> Self {
  type Target (line 18) | type Target = ThreadQueue;
  method deref (line 19) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 25) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: crates/mlua-luau-scheduler/src/queue/futures.rs
  type LocalBoxFuture (line 7) | pub type LocalBoxFuture<'fut> = Pin<Box<dyn Future<Output = ()> + 'fut>>;
  type FuturesQueueInner (line 9) | struct FuturesQueueInner<'fut> {
  function new (line 15) | pub fn new() -> Self {
  type FuturesQueue (line 30) | pub(crate) struct FuturesQueue<'fut> {
  function new (line 35) | pub fn new() -> Self {
  function push_item (line 40) | pub fn push_item(&self, fut: impl Future<Output = ()> + 'fut) {
  function take_items (line 45) | pub fn take_items(&self) -> Vec<LocalBoxFuture<'fut>> {
  function wait_for_item (line 50) | pub async fn wait_for_item(&self) {

FILE: crates/mlua-luau-scheduler/src/queue/spawned.rs
  type SpawnedThreadQueue (line 9) | pub(crate) struct SpawnedThreadQueue(ThreadQueue);
    method new (line 12) | pub fn new() -> Self {
  type Target (line 18) | type Target = ThreadQueue;
  method deref (line 19) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 25) | fn deref_mut(&mut self) -> &mut Self::Target {

FILE: crates/mlua-luau-scheduler/src/queue/threads.rs
  type ThreadQueueInner (line 12) | struct ThreadQueueInner {
    method new (line 18) | fn new() -> Self {
  type ThreadQueue (line 33) | pub(crate) struct ThreadQueue {
    method new (line 38) | pub fn new() -> Self {
    method push_item (line 43) | pub fn push_item(
    method take_items (line 62) | pub fn take_items(&self) -> Vec<(LuaThread, LuaMultiValue)> {
    method wait_for_item (line 68) | pub async fn wait_for_item(&self) {
    method is_empty (line 75) | pub fn is_empty(&self) -> bool {

FILE: crates/mlua-luau-scheduler/src/scheduler.rs
  constant ERR_METADATA_ALREADY_ATTACHED (line 26) | const ERR_METADATA_ALREADY_ATTACHED: &str = "\
  constant ERR_METADATA_REMOVED (line 32) | const ERR_METADATA_REMOVED: &str = "\
  constant ERR_SET_CALLBACK_WHEN_RUNNING (line 37) | const ERR_SET_CALLBACK_WHEN_RUNNING: &str = "\
  type Scheduler (line 45) | pub struct Scheduler {
    method new (line 66) | pub fn new(lua: Lua) -> Scheduler {
    method set_status (line 116) | fn set_status(&self, status: Status) {
    method status (line 125) | pub fn status(&self) -> Status {
    method set_error_callback (line 140) | pub fn set_error_callback(&self, callback: impl Fn(LuaError) + Send + ...
    method remove_error_callback (line 157) | pub fn remove_error_callback(&self) {
    method get_exit_code (line 169) | pub fn get_exit_code(&self) -> Option<u8> {
    method set_exit_code (line 178) | pub fn set_exit_code(&self, code: u8) {
    method push_thread_front (line 197) | pub fn push_thread_front(
    method push_thread_back (line 224) | pub fn push_thread_back(
    method get_thread_result (line 249) | pub fn get_thread_result(&self, id: ThreadId) -> Option<LuaResult<LuaM...
    method wait_for_thread (line 258) | pub async fn wait_for_thread(&self, id: ThreadId) {
    method run (line 276) | pub async fn run(&self) {
  method drop (line 459) | fn drop(&mut self) {

FILE: crates/mlua-luau-scheduler/src/status.rs
  type Status (line 7) | pub enum Status {
    method is_not_started (line 18) | pub const fn is_not_started(self) -> bool {
    method is_running (line 23) | pub const fn is_running(self) -> bool {
    method is_completed (line 28) | pub const fn is_completed(self) -> bool {

FILE: crates/mlua-luau-scheduler/src/threads/id.rs
  type ThreadId (line 17) | pub struct ThreadId {
    method from (line 22) | fn from(thread: &LuaThread) -> Self {
  method hash (line 30) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: crates/mlua-luau-scheduler/src/threads/map.rs
  type ThreadEvent (line 12) | struct ThreadEvent {
    method new (line 18) | fn new() -> Self {
  type ThreadMap (line 27) | pub(crate) struct ThreadMap {
    method new (line 32) | pub fn new() -> Self {
    method track (line 38) | pub fn track(&self, id: ThreadId) {
    method is_tracked (line 43) | pub fn is_tracked(&self, id: ThreadId) -> bool {
    method insert (line 48) | pub fn insert(&self, id: ThreadId, result: LuaResult<LuaMultiValue>) {
    method listen (line 58) | pub fn listen(&self, id: ThreadId) -> OnceListener {
    method remove (line 67) | pub fn remove(&self, id: ThreadId) -> Option<LuaResult<LuaMultiValue>> {

FILE: crates/mlua-luau-scheduler/src/traits.rs
  type IntoLuaThread (line 27) | pub trait IntoLuaThread {
    method into_lua_thread (line 35) | fn into_lua_thread(self, lua: &Lua) -> LuaResult<LuaThread>;
    method into_lua_thread (line 39) | fn into_lua_thread(self, _: &Lua) -> LuaResult<LuaThread> {
    method into_lua_thread (line 45) | fn into_lua_thread(self, lua: &Lua) -> LuaResult<LuaThread> {
    method into_lua_thread (line 51) | fn into_lua_thread(self, lua: &Lua) -> LuaResult<LuaThread> {
    method into_lua_thread (line 60) | fn into_lua_thread(self, lua: &Lua) -> LuaResult<LuaThread> {
  type LuaSchedulerExt (line 74) | pub trait LuaSchedulerExt {
    method set_exit_code (line 84) | fn set_exit_code(&self, code: u8);
    method push_thread_front (line 95) | fn push_thread_front(
    method push_thread_back (line 110) | fn push_thread_back(
    method track_thread (line 121) | fn track_thread(&self, id: ThreadId);
    method get_thread_result (line 132) | fn get_thread_result(&self, id: ThreadId) -> Option<LuaResult<LuaMulti...
    method wait_for_thread (line 143) | fn wait_for_thread(&self, id: ThreadId) -> impl Future<Output = ()>;
    method set_exit_code (line 285) | fn set_exit_code(&self, code: u8) {
    method push_thread_front (line 292) | fn push_thread_front(
    method push_thread_back (line 303) | fn push_thread_back(
    method track_thread (line 314) | fn track_thread(&self, id: ThreadId) {
    method get_thread_result (line 321) | fn get_thread_result(&self, id: ThreadId) -> Option<LuaResult<LuaMulti...
    method wait_for_thread (line 328) | fn wait_for_thread(&self, id: ThreadId) -> impl Future<Output = ()> {
  type LuaSpawnExt (line 155) | pub trait LuaSpawnExt {
    method spawn (line 192) | fn spawn<F, T>(&self, fut: F) -> Task<T>
    method spawn_local (line 236) | fn spawn_local<F>(&self, fut: F)
    method spawn_blocking (line 278) | fn spawn_blocking<F, T>(&self, f: F) -> Task<T>
    method spawn (line 337) | fn spawn<F, T>(&self, fut: F) -> Task<T>
    method spawn_local (line 351) | fn spawn_local<F>(&self, fut: F)
    method spawn_blocking (line 362) | fn spawn_blocking<F, T>(&self, f: F) -> Task<T>

FILE: crates/mlua-luau-scheduler/src/util.rs
  function run_until_yield (line 13) | pub(crate) async fn run_until_yield(
  function is_poll_pending (line 37) | pub(crate) fn is_poll_pending(value: &LuaValue) -> bool {
  type LuaThreadOrFunction (line 49) | pub(crate) enum LuaThreadOrFunction {
    method into_thread (line 55) | pub(super) fn into_thread(self, lua: &Lua) -> LuaResult<LuaThread> {
  method from_lua (line 64) | fn from_lua(value: LuaValue, _: &Lua) -> LuaResult<Self> {