Skip to main content

engage/generated/moon_sharp/interpreter/
script.rs

1// @generated by il2cpp-bindgen — do not edit by hand.
2
3#[cfg(feature = "moon_sharp-interpreter-script-types")]
4mod __types {
5    #[allow(unused_imports)] use ::unity::prelude::*;
6
7    use super::*;
8    use crate::system::object::{IObject, Object};
9
10    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/script/Script.md"))]
11    #[::unity::class(namespace = "MoonSharp.Interpreter", name = "Script")]
12    #[parent(crate::system::object::Object)]
13    pub struct Script {
14        #[static_field]
15        #[rename(name = "VERSION")]
16        pub version: ::unity::Il2CppString,
17        #[static_field]
18        #[rename(name = "LUA_VERSION")]
19        pub lua_version: ::unity::Il2CppString,
20        #[offset(16)]
21        #[rename(name = "m_MainProcessor")]
22        pub m_main_processor: crate::moon_sharp::interpreter::execution::vm::processor::Processor,
23        #[offset(24)]
24        #[rename(name = "m_ByteCode")]
25        pub m_byte_code: crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode,
26        #[offset(32)]
27        #[rename(name = "m_Sources")]
28        pub m_sources: crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode>,
29        #[offset(40)]
30        #[rename(name = "m_GlobalTable")]
31        pub m_global_table: crate::moon_sharp::interpreter::table::Table,
32        #[offset(48)]
33        #[rename(name = "m_Debugger")]
34        pub m_debugger: crate::moon_sharp::interpreter::debugging::idebugger::IDebugger,
35        #[offset(56)]
36        #[rename(name = "m_TypeMetatables")]
37        pub m_type_metatables: ::unity::Array<crate::moon_sharp::interpreter::table::Table>,
38    }
39}
40
41#[cfg(feature = "moon_sharp-interpreter-script-types")]
42pub use __types::*;
43
44#[cfg(feature = "moon_sharp-interpreter-script")]
45#[doc(hidden)]
46#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
47mod __Script_unity_raw {
48    use super::*;
49    #[doc(hidden)]
50    #[allow(non_snake_case)]
51    pub mod __lookup_cctor {
52        use super::*;
53        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
54            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
55            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), ".cctor", 0, param_types, true)
56        });
57        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
58            match &*METHOD {
59                ::core::result::Result::Ok(mi) => *mi,
60                ::core::result::Result::Err(e) => {
61                    panic!(
62                        "method lookup failed: {}
63::{}
64: {}
65",
66                        <Script as ::unity::ClassIdentity>::NAME,
67                        ".cctor",
68                        e
69                    )
70                },
71            }
72        }
73    }
74    #[doc(hidden)]
75    #[allow(non_snake_case)]
76    pub mod __lookup_ctor {
77        use super::*;
78        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
79            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
80            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), ".ctor", 0, param_types, false)
81        });
82        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
83            match &*METHOD {
84                ::core::result::Result::Ok(mi) => *mi,
85                ::core::result::Result::Err(e) => {
86                    panic!(
87                        "method lookup failed: {}
88::{}
89: {}
90",
91                        <Script as ::unity::ClassIdentity>::NAME,
92                        ".ctor",
93                        e
94                    )
95                },
96            }
97        }
98    }
99    #[doc(hidden)]
100    #[allow(non_snake_case)]
101    pub mod __lookup_ctor_2 {
102        use super::*;
103        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
104            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
105                &[<crate::moon_sharp::interpreter::coremodules::CoreModules as ::unity::IlType>::il_type()];
106            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), ".ctor", 1, param_types, false)
107        });
108        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
109            match &*METHOD {
110                ::core::result::Result::Ok(mi) => *mi,
111                ::core::result::Result::Err(e) => {
112                    panic!(
113                        "method lookup failed: {}
114::{}
115: {}
116",
117                        <Script as ::unity::ClassIdentity>::NAME,
118                        ".ctor",
119                        e
120                    )
121                },
122            }
123        }
124    }
125    #[doc(hidden)]
126    #[allow(non_snake_case)]
127    pub mod __lookup_get_default_options {
128        use super::*;
129        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
130            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
131            ::unity::lookup::method_info_on_class_with_signature(
132                <Script as ::unity::ClassIdentity>::class(),
133                "get_DefaultOptions",
134                0,
135                param_types,
136                true,
137            )
138        });
139        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
140            match &*METHOD {
141                ::core::result::Result::Ok(mi) => *mi,
142                ::core::result::Result::Err(e) => {
143                    panic!(
144                        "method lookup failed: {}
145::{}
146: {}
147",
148                        <Script as ::unity::ClassIdentity>::NAME,
149                        "get_DefaultOptions",
150                        e
151                    )
152                },
153            }
154        }
155    }
156    #[doc(hidden)]
157    #[allow(non_snake_case)]
158    pub mod __lookup_set_default_options {
159        use super::*;
160        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
161            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
162                &[<crate::moon_sharp::interpreter::scriptoptions::ScriptOptions as ::unity::IlType>::il_type()];
163            ::unity::lookup::method_info_on_class_with_signature(
164                <Script as ::unity::ClassIdentity>::class(),
165                "set_DefaultOptions",
166                1,
167                param_types,
168                true,
169            )
170        });
171        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
172            match &*METHOD {
173                ::core::result::Result::Ok(mi) => *mi,
174                ::core::result::Result::Err(e) => {
175                    panic!(
176                        "method lookup failed: {}
177::{}
178: {}
179",
180                        <Script as ::unity::ClassIdentity>::NAME,
181                        "set_DefaultOptions",
182                        e
183                    )
184                },
185            }
186        }
187    }
188    #[doc(hidden)]
189    #[allow(non_snake_case)]
190    pub mod __lookup_get_options {
191        use super::*;
192        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
193            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
194            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "get_Options", 0, param_types, false)
195        });
196        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
197            match &*METHOD {
198                ::core::result::Result::Ok(mi) => *mi,
199                ::core::result::Result::Err(e) => {
200                    panic!(
201                        "method lookup failed: {}
202::{}
203: {}
204",
205                        <Script as ::unity::ClassIdentity>::NAME,
206                        "get_Options",
207                        e
208                    )
209                },
210            }
211        }
212    }
213    #[doc(hidden)]
214    #[allow(non_snake_case)]
215    pub mod __lookup_set_options {
216        use super::*;
217        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
218            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
219                &[<crate::moon_sharp::interpreter::scriptoptions::ScriptOptions as ::unity::IlType>::il_type()];
220            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "set_Options", 1, param_types, false)
221        });
222        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
223            match &*METHOD {
224                ::core::result::Result::Ok(mi) => *mi,
225                ::core::result::Result::Err(e) => {
226                    panic!(
227                        "method lookup failed: {}
228::{}
229: {}
230",
231                        <Script as ::unity::ClassIdentity>::NAME,
232                        "set_Options",
233                        e
234                    )
235                },
236            }
237        }
238    }
239    #[doc(hidden)]
240    #[allow(non_snake_case)]
241    pub mod __lookup_get_global_options {
242        use super::*;
243        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
244            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
245            ::unity::lookup::method_info_on_class_with_signature(
246                <Script as ::unity::ClassIdentity>::class(),
247                "get_GlobalOptions",
248                0,
249                param_types,
250                true,
251            )
252        });
253        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
254            match &*METHOD {
255                ::core::result::Result::Ok(mi) => *mi,
256                ::core::result::Result::Err(e) => {
257                    panic!(
258                        "method lookup failed: {}
259::{}
260: {}
261",
262                        <Script as ::unity::ClassIdentity>::NAME,
263                        "get_GlobalOptions",
264                        e
265                    )
266                },
267            }
268        }
269    }
270    #[doc(hidden)]
271    #[allow(non_snake_case)]
272    pub mod __lookup_set_global_options {
273        use super::*;
274        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
275            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
276                &[<crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions as ::unity::IlType>::il_type()];
277            ::unity::lookup::method_info_on_class_with_signature(
278                <Script as ::unity::ClassIdentity>::class(),
279                "set_GlobalOptions",
280                1,
281                param_types,
282                true,
283            )
284        });
285        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
286            match &*METHOD {
287                ::core::result::Result::Ok(mi) => *mi,
288                ::core::result::Result::Err(e) => {
289                    panic!(
290                        "method lookup failed: {}
291::{}
292: {}
293",
294                        <Script as ::unity::ClassIdentity>::NAME,
295                        "set_GlobalOptions",
296                        e
297                    )
298                },
299            }
300        }
301    }
302    #[doc(hidden)]
303    #[allow(non_snake_case)]
304    pub mod __lookup_get_performance_stats {
305        use super::*;
306        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
307            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
308            ::unity::lookup::method_info_on_class_with_signature(
309                <Script as ::unity::ClassIdentity>::class(),
310                "get_PerformanceStats",
311                0,
312                param_types,
313                false,
314            )
315        });
316        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
317            match &*METHOD {
318                ::core::result::Result::Ok(mi) => *mi,
319                ::core::result::Result::Err(e) => {
320                    panic!(
321                        "method lookup failed: {}
322::{}
323: {}
324",
325                        <Script as ::unity::ClassIdentity>::NAME,
326                        "get_PerformanceStats",
327                        e
328                    )
329                },
330            }
331        }
332    }
333    #[doc(hidden)]
334    #[allow(non_snake_case)]
335    pub mod __lookup_set_performance_stats {
336        use super::*;
337        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
338            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
339                &[<crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics as ::unity::IlType>::il_type()];
340            ::unity::lookup::method_info_on_class_with_signature(
341                <Script as ::unity::ClassIdentity>::class(),
342                "set_PerformanceStats",
343                1,
344                param_types,
345                false,
346            )
347        });
348        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
349            match &*METHOD {
350                ::core::result::Result::Ok(mi) => *mi,
351                ::core::result::Result::Err(e) => {
352                    panic!(
353                        "method lookup failed: {}
354::{}
355: {}
356",
357                        <Script as ::unity::ClassIdentity>::NAME,
358                        "set_PerformanceStats",
359                        e
360                    )
361                },
362            }
363        }
364    }
365    #[doc(hidden)]
366    #[allow(non_snake_case)]
367    pub mod __lookup_get_globals {
368        use super::*;
369        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
370            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
371            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "get_Globals", 0, param_types, false)
372        });
373        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
374            match &*METHOD {
375                ::core::result::Result::Ok(mi) => *mi,
376                ::core::result::Result::Err(e) => {
377                    panic!(
378                        "method lookup failed: {}
379::{}
380: {}
381",
382                        <Script as ::unity::ClassIdentity>::NAME,
383                        "get_Globals",
384                        e
385                    )
386                },
387            }
388        }
389    }
390    #[doc(hidden)]
391    #[allow(non_snake_case)]
392    pub mod __lookup_load_function {
393        use super::*;
394        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
395            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
396                <::unity::Il2CppString as ::unity::IlType>::il_type(),
397                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
398                <::unity::Il2CppString as ::unity::IlType>::il_type(),
399            ];
400            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "LoadFunction", 3, param_types, false)
401        });
402        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
403            match &*METHOD {
404                ::core::result::Result::Ok(mi) => *mi,
405                ::core::result::Result::Err(e) => {
406                    panic!(
407                        "method lookup failed: {}
408::{}
409: {}
410",
411                        <Script as ::unity::ClassIdentity>::NAME,
412                        "LoadFunction",
413                        e
414                    )
415                },
416            }
417        }
418    }
419    #[doc(hidden)]
420    #[allow(non_snake_case)]
421    pub mod __lookup_signal_byte_code_change {
422        use super::*;
423        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
424            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
425            ::unity::lookup::method_info_on_class_with_signature(
426                <Script as ::unity::ClassIdentity>::class(),
427                "SignalByteCodeChange",
428                0,
429                param_types,
430                false,
431            )
432        });
433        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
434            match &*METHOD {
435                ::core::result::Result::Ok(mi) => *mi,
436                ::core::result::Result::Err(e) => {
437                    panic!(
438                        "method lookup failed: {}
439::{}
440: {}
441",
442                        <Script as ::unity::ClassIdentity>::NAME,
443                        "SignalByteCodeChange",
444                        e
445                    )
446                },
447            }
448        }
449    }
450    #[doc(hidden)]
451    #[allow(non_snake_case)]
452    pub mod __lookup_signal_source_code_change {
453        use super::*;
454        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
455            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
456                &[<crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode as ::unity::IlType>::il_type()];
457            ::unity::lookup::method_info_on_class_with_signature(
458                <Script as ::unity::ClassIdentity>::class(),
459                "SignalSourceCodeChange",
460                1,
461                param_types,
462                false,
463            )
464        });
465        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
466            match &*METHOD {
467                ::core::result::Result::Ok(mi) => *mi,
468                ::core::result::Result::Err(e) => {
469                    panic!(
470                        "method lookup failed: {}
471::{}
472: {}
473",
474                        <Script as ::unity::ClassIdentity>::NAME,
475                        "SignalSourceCodeChange",
476                        e
477                    )
478                },
479            }
480        }
481    }
482    #[doc(hidden)]
483    #[allow(non_snake_case)]
484    pub mod __lookup_load_string {
485        use super::*;
486        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
487            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
488                <::unity::Il2CppString as ::unity::IlType>::il_type(),
489                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
490                <::unity::Il2CppString as ::unity::IlType>::il_type(),
491            ];
492            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "LoadString", 3, param_types, false)
493        });
494        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
495            match &*METHOD {
496                ::core::result::Result::Ok(mi) => *mi,
497                ::core::result::Result::Err(e) => {
498                    panic!(
499                        "method lookup failed: {}
500::{}
501: {}
502",
503                        <Script as ::unity::ClassIdentity>::NAME,
504                        "LoadString",
505                        e
506                    )
507                },
508            }
509        }
510    }
511    #[doc(hidden)]
512    #[allow(non_snake_case)]
513    pub mod __lookup_load_stream {
514        use super::*;
515        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
516            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
517                <crate::system::io::stream::Stream as ::unity::IlType>::il_type(),
518                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
519                <::unity::Il2CppString as ::unity::IlType>::il_type(),
520            ];
521            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "LoadStream", 3, param_types, false)
522        });
523        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
524            match &*METHOD {
525                ::core::result::Result::Ok(mi) => *mi,
526                ::core::result::Result::Err(e) => {
527                    panic!(
528                        "method lookup failed: {}
529::{}
530: {}
531",
532                        <Script as ::unity::ClassIdentity>::NAME,
533                        "LoadStream",
534                        e
535                    )
536                },
537            }
538        }
539    }
540    #[doc(hidden)]
541    #[allow(non_snake_case)]
542    pub mod __lookup_dump {
543        use super::*;
544        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
545            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
546                <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
547                <crate::system::io::stream::Stream as ::unity::IlType>::il_type(),
548            ];
549            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Dump", 2, param_types, false)
550        });
551        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
552            match &*METHOD {
553                ::core::result::Result::Ok(mi) => *mi,
554                ::core::result::Result::Err(e) => {
555                    panic!(
556                        "method lookup failed: {}
557::{}
558: {}
559",
560                        <Script as ::unity::ClassIdentity>::NAME,
561                        "Dump",
562                        e
563                    )
564                },
565            }
566        }
567    }
568    #[doc(hidden)]
569    #[allow(non_snake_case)]
570    pub mod __lookup_load_file {
571        use super::*;
572        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
573            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
574                <::unity::Il2CppString as ::unity::IlType>::il_type(),
575                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
576                <::unity::Il2CppString as ::unity::IlType>::il_type(),
577            ];
578            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "LoadFile", 3, param_types, false)
579        });
580        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
581            match &*METHOD {
582                ::core::result::Result::Ok(mi) => *mi,
583                ::core::result::Result::Err(e) => {
584                    panic!(
585                        "method lookup failed: {}
586::{}
587: {}
588",
589                        <Script as ::unity::ClassIdentity>::NAME,
590                        "LoadFile",
591                        e
592                    )
593                },
594            }
595        }
596    }
597    #[doc(hidden)]
598    #[allow(non_snake_case)]
599    pub mod __lookup_do_string {
600        use super::*;
601        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
602            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
603                <::unity::Il2CppString as ::unity::IlType>::il_type(),
604                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
605                <::unity::Il2CppString as ::unity::IlType>::il_type(),
606            ];
607            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "DoString", 3, param_types, false)
608        });
609        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
610            match &*METHOD {
611                ::core::result::Result::Ok(mi) => *mi,
612                ::core::result::Result::Err(e) => {
613                    panic!(
614                        "method lookup failed: {}
615::{}
616: {}
617",
618                        <Script as ::unity::ClassIdentity>::NAME,
619                        "DoString",
620                        e
621                    )
622                },
623            }
624        }
625    }
626    #[doc(hidden)]
627    #[allow(non_snake_case)]
628    pub mod __lookup_do_stream {
629        use super::*;
630        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
631            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
632                <crate::system::io::stream::Stream as ::unity::IlType>::il_type(),
633                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
634                <::unity::Il2CppString as ::unity::IlType>::il_type(),
635            ];
636            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "DoStream", 3, param_types, false)
637        });
638        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
639            match &*METHOD {
640                ::core::result::Result::Ok(mi) => *mi,
641                ::core::result::Result::Err(e) => {
642                    panic!(
643                        "method lookup failed: {}
644::{}
645: {}
646",
647                        <Script as ::unity::ClassIdentity>::NAME,
648                        "DoStream",
649                        e
650                    )
651                },
652            }
653        }
654    }
655    #[doc(hidden)]
656    #[allow(non_snake_case)]
657    pub mod __lookup_do_file {
658        use super::*;
659        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
660            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
661                <::unity::Il2CppString as ::unity::IlType>::il_type(),
662                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
663                <::unity::Il2CppString as ::unity::IlType>::il_type(),
664            ];
665            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "DoFile", 3, param_types, false)
666        });
667        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
668            match &*METHOD {
669                ::core::result::Result::Ok(mi) => *mi,
670                ::core::result::Result::Err(e) => {
671                    panic!(
672                        "method lookup failed: {}
673::{}
674: {}
675",
676                        <Script as ::unity::ClassIdentity>::NAME,
677                        "DoFile",
678                        e
679                    )
680                },
681            }
682        }
683    }
684    #[doc(hidden)]
685    #[allow(non_snake_case)]
686    pub mod __lookup_run_file {
687        use super::*;
688        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
689            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
690            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "RunFile", 1, param_types, true)
691        });
692        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
693            match &*METHOD {
694                ::core::result::Result::Ok(mi) => *mi,
695                ::core::result::Result::Err(e) => {
696                    panic!(
697                        "method lookup failed: {}
698::{}
699: {}
700",
701                        <Script as ::unity::ClassIdentity>::NAME,
702                        "RunFile",
703                        e
704                    )
705                },
706            }
707        }
708    }
709    #[doc(hidden)]
710    #[allow(non_snake_case)]
711    pub mod __lookup_run_string {
712        use super::*;
713        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
714            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
715            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "RunString", 1, param_types, true)
716        });
717        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
718            match &*METHOD {
719                ::core::result::Result::Ok(mi) => *mi,
720                ::core::result::Result::Err(e) => {
721                    panic!(
722                        "method lookup failed: {}
723::{}
724: {}
725",
726                        <Script as ::unity::ClassIdentity>::NAME,
727                        "RunString",
728                        e
729                    )
730                },
731            }
732        }
733    }
734    #[doc(hidden)]
735    #[allow(non_snake_case)]
736    pub mod __lookup_make_closure {
737        use super::*;
738        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
739            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
740                <i32 as ::unity::IlType>::il_type(),
741                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
742            ];
743            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "MakeClosure", 2, param_types, false)
744        });
745        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
746            match &*METHOD {
747                ::core::result::Result::Ok(mi) => *mi,
748                ::core::result::Result::Err(e) => {
749                    panic!(
750                        "method lookup failed: {}
751::{}
752: {}
753",
754                        <Script as ::unity::ClassIdentity>::NAME,
755                        "MakeClosure",
756                        e
757                    )
758                },
759            }
760        }
761    }
762    #[doc(hidden)]
763    #[allow(non_snake_case)]
764    pub mod __lookup_call {
765        use super::*;
766        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
767            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
768                &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
769            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Call", 1, param_types, false)
770        });
771        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
772            match &*METHOD {
773                ::core::result::Result::Ok(mi) => *mi,
774                ::core::result::Result::Err(e) => {
775                    panic!(
776                        "method lookup failed: {}
777::{}
778: {}
779",
780                        <Script as ::unity::ClassIdentity>::NAME,
781                        "Call",
782                        e
783                    )
784                },
785            }
786        }
787    }
788    #[doc(hidden)]
789    #[allow(non_snake_case)]
790    pub mod __lookup_call_2 {
791        use super::*;
792        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
793            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
794                <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
795                <::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type(),
796            ];
797            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Call", 2, param_types, false)
798        });
799        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
800            match &*METHOD {
801                ::core::result::Result::Ok(mi) => *mi,
802                ::core::result::Result::Err(e) => {
803                    panic!(
804                        "method lookup failed: {}
805::{}
806: {}
807",
808                        <Script as ::unity::ClassIdentity>::NAME,
809                        "Call",
810                        e
811                    )
812                },
813            }
814        }
815    }
816    #[doc(hidden)]
817    #[allow(non_snake_case)]
818    pub mod __lookup_call_3 {
819        use super::*;
820        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
821            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
822                <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
823                <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
824            ];
825            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Call", 2, param_types, false)
826        });
827        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
828            match &*METHOD {
829                ::core::result::Result::Ok(mi) => *mi,
830                ::core::result::Result::Err(e) => {
831                    panic!(
832                        "method lookup failed: {}
833::{}
834: {}
835",
836                        <Script as ::unity::ClassIdentity>::NAME,
837                        "Call",
838                        e
839                    )
840                },
841            }
842        }
843    }
844    #[doc(hidden)]
845    #[allow(non_snake_case)]
846    pub mod __lookup_call_4 {
847        use super::*;
848        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
849            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
850            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Call", 1, param_types, false)
851        });
852        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
853            match &*METHOD {
854                ::core::result::Result::Ok(mi) => *mi,
855                ::core::result::Result::Err(e) => {
856                    panic!(
857                        "method lookup failed: {}
858::{}
859: {}
860",
861                        <Script as ::unity::ClassIdentity>::NAME,
862                        "Call",
863                        e
864                    )
865                },
866            }
867        }
868    }
869    #[doc(hidden)]
870    #[allow(non_snake_case)]
871    pub mod __lookup_call_5 {
872        use super::*;
873        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
874            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
875                <crate::system::object::Object as ::unity::IlType>::il_type(),
876                <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
877            ];
878            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "Call", 2, param_types, false)
879        });
880        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
881            match &*METHOD {
882                ::core::result::Result::Ok(mi) => *mi,
883                ::core::result::Result::Err(e) => {
884                    panic!(
885                        "method lookup failed: {}
886::{}
887: {}
888",
889                        <Script as ::unity::ClassIdentity>::NAME,
890                        "Call",
891                        e
892                    )
893                },
894            }
895        }
896    }
897    #[doc(hidden)]
898    #[allow(non_snake_case)]
899    pub mod __lookup_create_coroutine {
900        use super::*;
901        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
902            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
903                &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
904            ::unity::lookup::method_info_on_class_with_signature(
905                <Script as ::unity::ClassIdentity>::class(),
906                "CreateCoroutine",
907                1,
908                param_types,
909                false,
910            )
911        });
912        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
913            match &*METHOD {
914                ::core::result::Result::Ok(mi) => *mi,
915                ::core::result::Result::Err(e) => {
916                    panic!(
917                        "method lookup failed: {}
918::{}
919: {}
920",
921                        <Script as ::unity::ClassIdentity>::NAME,
922                        "CreateCoroutine",
923                        e
924                    )
925                },
926            }
927        }
928    }
929    #[doc(hidden)]
930    #[allow(non_snake_case)]
931    pub mod __lookup_create_coroutine_2 {
932        use super::*;
933        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
934            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::object::Object as ::unity::IlType>::il_type()];
935            ::unity::lookup::method_info_on_class_with_signature(
936                <Script as ::unity::ClassIdentity>::class(),
937                "CreateCoroutine",
938                1,
939                param_types,
940                false,
941            )
942        });
943        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
944            match &*METHOD {
945                ::core::result::Result::Ok(mi) => *mi,
946                ::core::result::Result::Err(e) => {
947                    panic!(
948                        "method lookup failed: {}
949::{}
950: {}
951",
952                        <Script as ::unity::ClassIdentity>::NAME,
953                        "CreateCoroutine",
954                        e
955                    )
956                },
957            }
958        }
959    }
960    #[doc(hidden)]
961    #[allow(non_snake_case)]
962    pub mod __lookup_get_debugger_enabled {
963        use super::*;
964        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
965            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
966            ::unity::lookup::method_info_on_class_with_signature(
967                <Script as ::unity::ClassIdentity>::class(),
968                "get_DebuggerEnabled",
969                0,
970                param_types,
971                false,
972            )
973        });
974        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975            match &*METHOD {
976                ::core::result::Result::Ok(mi) => *mi,
977                ::core::result::Result::Err(e) => {
978                    panic!(
979                        "method lookup failed: {}
980::{}
981: {}
982",
983                        <Script as ::unity::ClassIdentity>::NAME,
984                        "get_DebuggerEnabled",
985                        e
986                    )
987                },
988            }
989        }
990    }
991    #[doc(hidden)]
992    #[allow(non_snake_case)]
993    pub mod __lookup_set_debugger_enabled {
994        use super::*;
995        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
996            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
997            ::unity::lookup::method_info_on_class_with_signature(
998                <Script as ::unity::ClassIdentity>::class(),
999                "set_DebuggerEnabled",
1000                1,
1001                param_types,
1002                false,
1003            )
1004        });
1005        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1006            match &*METHOD {
1007                ::core::result::Result::Ok(mi) => *mi,
1008                ::core::result::Result::Err(e) => {
1009                    panic!(
1010                        "method lookup failed: {}
1011::{}
1012: {}
1013",
1014                        <Script as ::unity::ClassIdentity>::NAME,
1015                        "set_DebuggerEnabled",
1016                        e
1017                    )
1018                },
1019            }
1020        }
1021    }
1022    #[doc(hidden)]
1023    #[allow(non_snake_case)]
1024    pub mod __lookup_attach_debugger {
1025        use super::*;
1026        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1027            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1028                &[<crate::moon_sharp::interpreter::debugging::idebugger::IDebugger as ::unity::IlType>::il_type()];
1029            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "AttachDebugger", 1, param_types, false)
1030        });
1031        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1032            match &*METHOD {
1033                ::core::result::Result::Ok(mi) => *mi,
1034                ::core::result::Result::Err(e) => {
1035                    panic!(
1036                        "method lookup failed: {}
1037::{}
1038: {}
1039",
1040                        <Script as ::unity::ClassIdentity>::NAME,
1041                        "AttachDebugger",
1042                        e
1043                    )
1044                },
1045            }
1046        }
1047    }
1048    #[doc(hidden)]
1049    #[allow(non_snake_case)]
1050    pub mod __lookup_get_source_code {
1051        use super::*;
1052        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1053            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1054            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "GetSourceCode", 1, param_types, false)
1055        });
1056        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1057            match &*METHOD {
1058                ::core::result::Result::Ok(mi) => *mi,
1059                ::core::result::Result::Err(e) => {
1060                    panic!(
1061                        "method lookup failed: {}
1062::{}
1063: {}
1064",
1065                        <Script as ::unity::ClassIdentity>::NAME,
1066                        "GetSourceCode",
1067                        e
1068                    )
1069                },
1070            }
1071        }
1072    }
1073    #[doc(hidden)]
1074    #[allow(non_snake_case)]
1075    pub mod __lookup_get_source_code_count {
1076        use super::*;
1077        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1078            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1079            ::unity::lookup::method_info_on_class_with_signature(
1080                <Script as ::unity::ClassIdentity>::class(),
1081                "get_SourceCodeCount",
1082                0,
1083                param_types,
1084                false,
1085            )
1086        });
1087        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1088            match &*METHOD {
1089                ::core::result::Result::Ok(mi) => *mi,
1090                ::core::result::Result::Err(e) => {
1091                    panic!(
1092                        "method lookup failed: {}
1093::{}
1094: {}
1095",
1096                        <Script as ::unity::ClassIdentity>::NAME,
1097                        "get_SourceCodeCount",
1098                        e
1099                    )
1100                },
1101            }
1102        }
1103    }
1104    #[doc(hidden)]
1105    #[allow(non_snake_case)]
1106    pub mod __lookup_require_module {
1107        use super::*;
1108        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1109            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1110                <::unity::Il2CppString as ::unity::IlType>::il_type(),
1111                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
1112            ];
1113            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "RequireModule", 2, param_types, false)
1114        });
1115        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1116            match &*METHOD {
1117                ::core::result::Result::Ok(mi) => *mi,
1118                ::core::result::Result::Err(e) => {
1119                    panic!(
1120                        "method lookup failed: {}
1121::{}
1122: {}
1123",
1124                        <Script as ::unity::ClassIdentity>::NAME,
1125                        "RequireModule",
1126                        e
1127                    )
1128                },
1129            }
1130        }
1131    }
1132    #[doc(hidden)]
1133    #[allow(non_snake_case)]
1134    pub mod __lookup_get_type_metatable {
1135        use super::*;
1136        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1137            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1138                &[<crate::moon_sharp::interpreter::datatype::DataType as ::unity::IlType>::il_type()];
1139            ::unity::lookup::method_info_on_class_with_signature(
1140                <Script as ::unity::ClassIdentity>::class(),
1141                "GetTypeMetatable",
1142                1,
1143                param_types,
1144                false,
1145            )
1146        });
1147        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1148            match &*METHOD {
1149                ::core::result::Result::Ok(mi) => *mi,
1150                ::core::result::Result::Err(e) => {
1151                    panic!(
1152                        "method lookup failed: {}
1153::{}
1154: {}
1155",
1156                        <Script as ::unity::ClassIdentity>::NAME,
1157                        "GetTypeMetatable",
1158                        e
1159                    )
1160                },
1161            }
1162        }
1163    }
1164    #[doc(hidden)]
1165    #[allow(non_snake_case)]
1166    pub mod __lookup_set_type_metatable {
1167        use super::*;
1168        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1169            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1170                <crate::moon_sharp::interpreter::datatype::DataType as ::unity::IlType>::il_type(),
1171                <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
1172            ];
1173            ::unity::lookup::method_info_on_class_with_signature(
1174                <Script as ::unity::ClassIdentity>::class(),
1175                "SetTypeMetatable",
1176                2,
1177                param_types,
1178                false,
1179            )
1180        });
1181        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1182            match &*METHOD {
1183                ::core::result::Result::Ok(mi) => *mi,
1184                ::core::result::Result::Err(e) => {
1185                    panic!(
1186                        "method lookup failed: {}
1187::{}
1188: {}
1189",
1190                        <Script as ::unity::ClassIdentity>::NAME,
1191                        "SetTypeMetatable",
1192                        e
1193                    )
1194                },
1195            }
1196        }
1197    }
1198    #[doc(hidden)]
1199    #[allow(non_snake_case)]
1200    pub mod __lookup_warm_up {
1201        use super::*;
1202        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1203            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1204            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "WarmUp", 0, param_types, true)
1205        });
1206        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1207            match &*METHOD {
1208                ::core::result::Result::Ok(mi) => *mi,
1209                ::core::result::Result::Err(e) => {
1210                    panic!(
1211                        "method lookup failed: {}
1212::{}
1213: {}
1214",
1215                        <Script as ::unity::ClassIdentity>::NAME,
1216                        "WarmUp",
1217                        e
1218                    )
1219                },
1220            }
1221        }
1222    }
1223    #[doc(hidden)]
1224    #[allow(non_snake_case)]
1225    pub mod __lookup_create_dynamic_expression {
1226        use super::*;
1227        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1228            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
1229            ::unity::lookup::method_info_on_class_with_signature(
1230                <Script as ::unity::ClassIdentity>::class(),
1231                "CreateDynamicExpression",
1232                1,
1233                param_types,
1234                false,
1235            )
1236        });
1237        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1238            match &*METHOD {
1239                ::core::result::Result::Ok(mi) => *mi,
1240                ::core::result::Result::Err(e) => {
1241                    panic!(
1242                        "method lookup failed: {}
1243::{}
1244: {}
1245",
1246                        <Script as ::unity::ClassIdentity>::NAME,
1247                        "CreateDynamicExpression",
1248                        e
1249                    )
1250                },
1251            }
1252        }
1253    }
1254    #[doc(hidden)]
1255    #[allow(non_snake_case)]
1256    pub mod __lookup_create_constant_dynamic_expression {
1257        use super::*;
1258        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1259            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1260                <::unity::Il2CppString as ::unity::IlType>::il_type(),
1261                <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1262            ];
1263            ::unity::lookup::method_info_on_class_with_signature(
1264                <Script as ::unity::ClassIdentity>::class(),
1265                "CreateConstantDynamicExpression",
1266                2,
1267                param_types,
1268                false,
1269            )
1270        });
1271        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1272            match &*METHOD {
1273                ::core::result::Result::Ok(mi) => *mi,
1274                ::core::result::Result::Err(e) => {
1275                    panic!(
1276                        "method lookup failed: {}
1277::{}
1278: {}
1279",
1280                        <Script as ::unity::ClassIdentity>::NAME,
1281                        "CreateConstantDynamicExpression",
1282                        e
1283                    )
1284                },
1285            }
1286        }
1287    }
1288    #[doc(hidden)]
1289    #[allow(non_snake_case)]
1290    pub mod __lookup_create_dynamic_execution_context {
1291        use super::*;
1292        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1293            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1294                &[<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction as ::unity::IlType>::il_type()];
1295            ::unity::lookup::method_info_on_class_with_signature(
1296                <Script as ::unity::ClassIdentity>::class(),
1297                "CreateDynamicExecutionContext",
1298                1,
1299                param_types,
1300                false,
1301            )
1302        });
1303        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1304            match &*METHOD {
1305                ::core::result::Result::Ok(mi) => *mi,
1306                ::core::result::Result::Err(e) => {
1307                    panic!(
1308                        "method lookup failed: {}
1309::{}
1310: {}
1311",
1312                        <Script as ::unity::ClassIdentity>::NAME,
1313                        "CreateDynamicExecutionContext",
1314                        e
1315                    )
1316                },
1317            }
1318        }
1319    }
1320    #[doc(hidden)]
1321    #[allow(non_snake_case)]
1322    pub mod __lookup_get_registry {
1323        use super::*;
1324        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1325            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1326            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "get_Registry", 0, param_types, false)
1327        });
1328        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1329            match &*METHOD {
1330                ::core::result::Result::Ok(mi) => *mi,
1331                ::core::result::Result::Err(e) => {
1332                    panic!(
1333                        "method lookup failed: {}
1334::{}
1335: {}
1336",
1337                        <Script as ::unity::ClassIdentity>::NAME,
1338                        "get_Registry",
1339                        e
1340                    )
1341                },
1342            }
1343        }
1344    }
1345    #[doc(hidden)]
1346    #[allow(non_snake_case)]
1347    pub mod __lookup_set_registry {
1348        use super::*;
1349        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1350            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1351                &[<crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type()];
1352            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "set_Registry", 1, param_types, false)
1353        });
1354        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1355            match &*METHOD {
1356                ::core::result::Result::Ok(mi) => *mi,
1357                ::core::result::Result::Err(e) => {
1358                    panic!(
1359                        "method lookup failed: {}
1360::{}
1361: {}
1362",
1363                        <Script as ::unity::ClassIdentity>::NAME,
1364                        "set_Registry",
1365                        e
1366                    )
1367                },
1368            }
1369        }
1370    }
1371    #[doc(hidden)]
1372    #[allow(non_snake_case)]
1373    pub mod __lookup_get_banner {
1374        use super::*;
1375        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1376            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
1377            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "GetBanner", 1, param_types, true)
1378        });
1379        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1380            match &*METHOD {
1381                ::core::result::Result::Ok(mi) => *mi,
1382                ::core::result::Result::Err(e) => {
1383                    panic!(
1384                        "method lookup failed: {}
1385::{}
1386: {}
1387",
1388                        <Script as ::unity::ClassIdentity>::NAME,
1389                        "GetBanner",
1390                        e
1391                    )
1392                },
1393            }
1394        }
1395    }
1396    #[doc(hidden)]
1397    #[allow(non_snake_case)]
1398    pub mod __lookup_get_line {
1399        use super::*;
1400        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1401            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1402            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "GetLine", 1, param_types, false)
1403        });
1404        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1405            match &*METHOD {
1406                ::core::result::Result::Ok(mi) => *mi,
1407                ::core::result::Result::Err(e) => {
1408                    panic!(
1409                        "method lookup failed: {}
1410::{}
1411: {}
1412",
1413                        <Script as ::unity::ClassIdentity>::NAME,
1414                        "GetLine",
1415                        e
1416                    )
1417                },
1418            }
1419        }
1420    }
1421    #[doc(hidden)]
1422    #[allow(non_snake_case)]
1423    pub mod __lookup_get_line_2 {
1424        use super::*;
1425        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1426            let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1427                &[<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem as ::unity::IlType>::il_type()];
1428            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "GetLine", 1, param_types, false)
1429        });
1430        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1431            match &*METHOD {
1432                ::core::result::Result::Ok(mi) => *mi,
1433                ::core::result::Result::Err(e) => {
1434                    panic!(
1435                        "method lookup failed: {}
1436::{}
1437: {}
1438",
1439                        <Script as ::unity::ClassIdentity>::NAME,
1440                        "GetLine",
1441                        e
1442                    )
1443                },
1444            }
1445        }
1446    }
1447    #[doc(hidden)]
1448    #[allow(non_snake_case)]
1449    pub mod __lookup_get_source_ref {
1450        use super::*;
1451        static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1452            let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1453            ::unity::lookup::method_info_on_class_with_signature(<Script as ::unity::ClassIdentity>::class(), "GetSourceRef", 1, param_types, false)
1454        });
1455        pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1456            match &*METHOD {
1457                ::core::result::Result::Ok(mi) => *mi,
1458                ::core::result::Result::Err(e) => {
1459                    panic!(
1460                        "method lookup failed: {}
1461::{}
1462: {}
1463",
1464                        <Script as ::unity::ClassIdentity>::NAME,
1465                        "GetSourceRef",
1466                        e
1467                    )
1468                },
1469            }
1470        }
1471    }
1472}
1473
1474#[cfg(feature = "moon_sharp-interpreter-script")]
1475impl Script {
1476    #[doc = "`.cctor()` overload"]
1477    pub fn cctor() -> () {
1478        unsafe {
1479            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_cctor::get_method_info().method_ptr,();
1480            )
1481        }
1482    }
1483
1484    #[doc = "`get_DefaultOptions()` overload"]
1485    pub fn get_default_options() -> crate::moon_sharp::interpreter::scriptoptions::ScriptOptions {
1486        unsafe {
1487            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_default_options::get_method_info().method_ptr,crate::moon_sharp::interpreter::scriptoptions::ScriptOptions;
1488            )
1489        }
1490    }
1491
1492    #[doc = "`set_DefaultOptions(crate::moon_sharp::interpreter::scriptoptions::ScriptOptions)` overload"]
1493    pub fn set_default_options(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptoptions::ScriptOptions>) -> () {
1494        unsafe {
1495            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_default_options::get_method_info().method_ptr,();
1496(crate::moon_sharp::interpreter::scriptoptions::ScriptOptions)::core::convert::Into::into(value))
1497        }
1498    }
1499
1500    #[doc = "`get_GlobalOptions()` overload"]
1501    pub fn get_global_options() -> crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions {
1502        unsafe {
1503            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_global_options::get_method_info().method_ptr,crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions;
1504            )
1505        }
1506    }
1507
1508    #[doc = "`set_GlobalOptions(crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions)` overload"]
1509    pub fn set_global_options(value: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions>) -> () {
1510        unsafe {
1511            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_global_options::get_method_info().method_ptr,();
1512(crate::moon_sharp::interpreter::scriptglobaloptions::ScriptGlobalOptions)::core::convert::Into::into(value))
1513        }
1514    }
1515
1516    #[doc = "`RunFile(::unity::Il2CppString)` overload"]
1517    pub fn run_file(filename: impl ::core::convert::Into<::unity::Il2CppString>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1518        unsafe {
1519            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_run_file::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1520(::unity::Il2CppString)::core::convert::Into::into(filename))
1521        }
1522    }
1523
1524    #[doc = "`RunString(::unity::Il2CppString)` overload"]
1525    pub fn run_string(code: impl ::core::convert::Into<::unity::Il2CppString>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1526        unsafe {
1527            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_run_string::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1528(::unity::Il2CppString)::core::convert::Into::into(code))
1529        }
1530    }
1531
1532    #[doc = "`WarmUp()` overload"]
1533    pub fn warm_up() -> () {
1534        unsafe {
1535            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_warm_up::get_method_info().method_ptr,();
1536            )
1537        }
1538    }
1539
1540    #[doc = "`GetBanner(::unity::Il2CppString)` overload"]
1541    pub fn get_banner(subproduct: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
1542        unsafe {
1543            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_banner::get_method_info().method_ptr, ::unity::Il2CppString;
1544(::unity::Il2CppString)::core::convert::Into::into(subproduct))
1545        }
1546    }
1547}
1548
1549#[cfg(feature = "moon_sharp-interpreter-script")]
1550pub trait IScriptMethods: IScript {
1551    #[doc = "`.ctor()` overload"]
1552    fn ctor(self) -> () {
1553        unsafe {
1554            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1555            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
1556(Script)__receiver)
1557        }
1558    }
1559    #[doc = "`.ctor(crate::moon_sharp::interpreter::coremodules::CoreModules)` overload"]
1560    fn ctor_2(self, core_modules: impl ::core::convert::Into<crate::moon_sharp::interpreter::coremodules::CoreModules>) -> () {
1561        unsafe {
1562            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1563            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_ctor_2::get_method_info().method_ptr,();
1564(Script)__receiver,(crate::moon_sharp::interpreter::coremodules::CoreModules)::core::convert::Into::into(core_modules))
1565        }
1566    }
1567    #[doc = "`get_Options()` overload"]
1568    fn get_options(self) -> crate::moon_sharp::interpreter::scriptoptions::ScriptOptions {
1569        unsafe {
1570            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1571            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_options::get_method_info().method_ptr,crate::moon_sharp::interpreter::scriptoptions::ScriptOptions;
1572(Script)__receiver)
1573        }
1574    }
1575    #[doc = "`set_Options(crate::moon_sharp::interpreter::scriptoptions::ScriptOptions)` overload"]
1576    fn set_options(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptoptions::ScriptOptions>) -> () {
1577        unsafe {
1578            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1579            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_options::get_method_info().method_ptr,();
1580(Script)__receiver,(crate::moon_sharp::interpreter::scriptoptions::ScriptOptions)::core::convert::Into::into(value))
1581        }
1582    }
1583    #[doc = "`get_PerformanceStats()` overload"]
1584    fn get_performance_stats(self) -> crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics {
1585        unsafe {
1586            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1587            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_performance_stats::get_method_info().method_ptr,crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics;
1588(Script)__receiver)
1589        }
1590    }
1591    #[doc = "`set_PerformanceStats(crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics)` overload"]
1592    fn set_performance_stats(
1593        self,
1594        value: impl ::core::convert::Into<crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics>,
1595    ) -> () {
1596        unsafe {
1597            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1598            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_performance_stats::get_method_info().method_ptr,();
1599(Script)__receiver,(crate::moon_sharp::interpreter::diagnostics::performancestatistics::PerformanceStatistics)::core::convert::Into::into(value))
1600        }
1601    }
1602    #[doc = "`get_Globals()` overload"]
1603    fn get_globals(self) -> crate::moon_sharp::interpreter::table::Table {
1604        unsafe {
1605            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1606            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_globals::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
1607(Script)__receiver)
1608        }
1609    }
1610    #[doc = "`LoadFunction(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1611    fn load_function(
1612        self,
1613        code: impl ::core::convert::Into<::unity::Il2CppString>,
1614        global_table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1615        func_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1616    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1617        unsafe {
1618            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1619            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_load_function::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1620(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(code),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_table),(::unity::Il2CppString)::core::convert::Into::into(func_friendly_name))
1621        }
1622    }
1623    #[doc = "`SignalByteCodeChange()` overload"]
1624    fn signal_byte_code_change(self) -> () {
1625        unsafe {
1626            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1627            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_signal_byte_code_change::get_method_info().method_ptr,();
1628(Script)__receiver)
1629        }
1630    }
1631    #[doc = "`SignalSourceCodeChange(crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode)` overload"]
1632    fn signal_source_code_change(self, source: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode>) -> () {
1633        unsafe {
1634            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1635            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_signal_source_code_change::get_method_info().method_ptr,();
1636(Script)__receiver,(crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode)::core::convert::Into::into(source))
1637        }
1638    }
1639    #[doc = "`LoadString(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1640    fn load_string(
1641        self,
1642        code: impl ::core::convert::Into<::unity::Il2CppString>,
1643        global_table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1644        code_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1645    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1646        unsafe {
1647            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1648            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_load_string::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1649(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(code),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_table),(::unity::Il2CppString)::core::convert::Into::into(code_friendly_name))
1650        }
1651    }
1652    #[doc = "`LoadStream(crate::system::io::stream::Stream, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1653    fn load_stream(
1654        self,
1655        stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
1656        global_table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1657        code_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1658    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1659        unsafe {
1660            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1661            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_load_stream::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1662(Script)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_table),(::unity::Il2CppString)::core::convert::Into::into(code_friendly_name))
1663        }
1664    }
1665    #[doc = "`Dump(crate::moon_sharp::interpreter::dynvalue::DynValue, crate::system::io::stream::Stream)` overload"]
1666    fn dump(
1667        self,
1668        function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1669        stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
1670    ) -> () {
1671        unsafe {
1672            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1673            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_dump::get_method_info().method_ptr,();
1674(Script)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function),(crate::system::io::stream::Stream)::core::convert::Into::into(stream))
1675        }
1676    }
1677    #[doc = "`LoadFile(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1678    fn load_file(
1679        self,
1680        filename: impl ::core::convert::Into<::unity::Il2CppString>,
1681        global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1682        friendly_filename: impl ::core::convert::Into<::unity::Il2CppString>,
1683    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1684        unsafe {
1685            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1686            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_load_file::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1687(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(filename),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context),(::unity::Il2CppString)::core::convert::Into::into(friendly_filename))
1688        }
1689    }
1690    #[doc = "`DoString(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1691    fn do_string(
1692        self,
1693        code: impl ::core::convert::Into<::unity::Il2CppString>,
1694        global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1695        code_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1696    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1697        unsafe {
1698            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1699            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_do_string::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1700(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(code),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context),(::unity::Il2CppString)::core::convert::Into::into(code_friendly_name))
1701        }
1702    }
1703    #[doc = "`DoStream(crate::system::io::stream::Stream, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1704    fn do_stream(
1705        self,
1706        stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
1707        global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1708        code_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1709    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1710        unsafe {
1711            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1712            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_do_stream::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1713(Script)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context),(::unity::Il2CppString)::core::convert::Into::into(code_friendly_name))
1714        }
1715    }
1716    #[doc = "`DoFile(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table, ::unity::Il2CppString)` overload"]
1717    fn do_file(
1718        self,
1719        filename: impl ::core::convert::Into<::unity::Il2CppString>,
1720        global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1721        code_friendly_name: impl ::core::convert::Into<::unity::Il2CppString>,
1722    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1723        unsafe {
1724            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1725            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_do_file::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1726(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(filename),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context),(::unity::Il2CppString)::core::convert::Into::into(code_friendly_name))
1727        }
1728    }
1729    #[doc = "`MakeClosure(i32, crate::moon_sharp::interpreter::table::Table)` overload"]
1730    fn make_closure(
1731        self,
1732        address: impl ::core::convert::Into<i32>,
1733        env_table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1734    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1735        unsafe {
1736            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1737            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_make_closure::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1738(Script)__receiver,(i32)::core::convert::Into::into(address),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(env_table))
1739        }
1740    }
1741    #[doc = "`Call(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1742    fn call(
1743        self,
1744        function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1745    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1746        unsafe {
1747            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1748            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_call::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1749(Script)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function))
1750        }
1751    }
1752    #[doc = "`Call(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
1753    fn call_2(
1754        self,
1755        function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1756        args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
1757    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1758        unsafe {
1759            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1760            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_call_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1761(Script)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function),(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
1762        }
1763    }
1764    #[doc = "`Call(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Array<crate::system::object::Object>)` overload"]
1765    fn call_3(
1766        self,
1767        function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1768        args: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
1769    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1770        unsafe {
1771            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1772            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_call_3::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1773(Script)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(args))
1774        }
1775    }
1776    #[doc = "`Call(crate::system::object::Object)` overload"]
1777    fn call_4(self, function: impl ::core::convert::Into<crate::system::object::Object>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1778        unsafe {
1779            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1780            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_call_4::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1781(Script)__receiver,(crate::system::object::Object)::core::convert::Into::into(function))
1782        }
1783    }
1784    #[doc = "`Call(crate::system::object::Object, ::unity::Array<crate::system::object::Object>)` overload"]
1785    fn call_5(
1786        self,
1787        function: impl ::core::convert::Into<crate::system::object::Object>,
1788        args: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
1789    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1790        unsafe {
1791            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1792            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_call_5::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1793(Script)__receiver,(crate::system::object::Object)::core::convert::Into::into(function),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(args))
1794        }
1795    }
1796    #[doc = "`CreateCoroutine(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1797    fn create_coroutine(
1798        self,
1799        function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1800    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1801        unsafe {
1802            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1803            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_create_coroutine::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1804(Script)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function))
1805        }
1806    }
1807    #[doc = "`CreateCoroutine(crate::system::object::Object)` overload"]
1808    fn create_coroutine_2(
1809        self,
1810        function: impl ::core::convert::Into<crate::system::object::Object>,
1811    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1812        unsafe {
1813            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1814            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_create_coroutine_2::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1815(Script)__receiver,(crate::system::object::Object)::core::convert::Into::into(function))
1816        }
1817    }
1818    #[doc = "`get_DebuggerEnabled()` overload"]
1819    fn get_debugger_enabled(self) -> bool {
1820        unsafe {
1821            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1822            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_debugger_enabled::get_method_info().method_ptr,bool;
1823(Script)__receiver)
1824        }
1825    }
1826    #[doc = "`set_DebuggerEnabled(bool)` overload"]
1827    fn set_debugger_enabled(self, value: impl ::core::convert::Into<bool>) -> () {
1828        unsafe {
1829            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1830            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_debugger_enabled::get_method_info().method_ptr,();
1831(Script)__receiver,(bool)::core::convert::Into::into(value))
1832        }
1833    }
1834    #[doc = "`AttachDebugger(crate::moon_sharp::interpreter::debugging::idebugger::IDebugger)` overload"]
1835    fn attach_debugger(self, debugger: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::idebugger::IDebugger>) -> () {
1836        unsafe {
1837            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1838            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_attach_debugger::get_method_info().method_ptr,();
1839(Script)__receiver,(crate::moon_sharp::interpreter::debugging::idebugger::IDebugger)::core::convert::Into::into(debugger))
1840        }
1841    }
1842    #[doc = "`GetSourceCode(i32)` overload"]
1843    fn get_source_code(self, source_code_id: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode {
1844        unsafe {
1845            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1846            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_source_code::get_method_info().method_ptr,crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode;
1847(Script)__receiver,(i32)::core::convert::Into::into(source_code_id))
1848        }
1849    }
1850    #[doc = "`get_SourceCodeCount()` overload"]
1851    fn get_source_code_count(self) -> i32 {
1852        unsafe {
1853            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1854            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_source_code_count::get_method_info().method_ptr,i32;
1855(Script)__receiver)
1856        }
1857    }
1858    #[doc = "`RequireModule(::unity::Il2CppString, crate::moon_sharp::interpreter::table::Table)` overload"]
1859    fn require_module(
1860        self,
1861        modname: impl ::core::convert::Into<::unity::Il2CppString>,
1862        global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1863    ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1864        unsafe {
1865            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1866            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_require_module::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1867(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(modname),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context))
1868        }
1869    }
1870    #[doc = "`GetTypeMetatable(crate::moon_sharp::interpreter::datatype::DataType)` overload"]
1871    fn get_type_metatable(
1872        self,
1873        r#type: impl ::core::convert::Into<crate::moon_sharp::interpreter::datatype::DataType>,
1874    ) -> crate::moon_sharp::interpreter::table::Table {
1875        unsafe {
1876            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1877            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_type_metatable::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
1878(Script)__receiver,(crate::moon_sharp::interpreter::datatype::DataType)::core::convert::Into::into(r#type))
1879        }
1880    }
1881    #[doc = "`SetTypeMetatable(crate::moon_sharp::interpreter::datatype::DataType, crate::moon_sharp::interpreter::table::Table)` overload"]
1882    fn set_type_metatable(
1883        self,
1884        r#type: impl ::core::convert::Into<crate::moon_sharp::interpreter::datatype::DataType>,
1885        metatable: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
1886    ) -> () {
1887        unsafe {
1888            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1889            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_type_metatable::get_method_info().method_ptr,();
1890(Script)__receiver,(crate::moon_sharp::interpreter::datatype::DataType)::core::convert::Into::into(r#type),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(metatable))
1891        }
1892    }
1893    #[doc = "`CreateDynamicExpression(::unity::Il2CppString)` overload"]
1894    fn create_dynamic_expression(
1895        self,
1896        code: impl ::core::convert::Into<::unity::Il2CppString>,
1897    ) -> crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression {
1898        unsafe {
1899            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1900            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_create_dynamic_expression::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression;
1901(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(code))
1902        }
1903    }
1904    #[doc = "`CreateConstantDynamicExpression(::unity::Il2CppString, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1905    fn create_constant_dynamic_expression(
1906        self,
1907        code: impl ::core::convert::Into<::unity::Il2CppString>,
1908        constant: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1909    ) -> crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression {
1910        unsafe {
1911            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1912            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_create_constant_dynamic_expression::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression;
1913(Script)__receiver,(::unity::Il2CppString)::core::convert::Into::into(code),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(constant))
1914        }
1915    }
1916    #[doc = "`CreateDynamicExecutionContext(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)` overload"]
1917    fn create_dynamic_execution_context(
1918        self,
1919        func: impl ::core::convert::Into<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction>,
1920    ) -> crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext {
1921        unsafe {
1922            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1923            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_create_dynamic_execution_context::get_method_info().method_ptr,crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext;
1924(Script)__receiver,(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)::core::convert::Into::into(func))
1925        }
1926    }
1927    #[doc = "`get_Registry()` overload"]
1928    fn get_registry(self) -> crate::moon_sharp::interpreter::table::Table {
1929        unsafe {
1930            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1931            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_registry::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
1932(Script)__receiver)
1933        }
1934    }
1935    #[doc = "`set_Registry(crate::moon_sharp::interpreter::table::Table)` overload"]
1936    fn set_registry(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>) -> () {
1937        unsafe {
1938            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1939            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_set_registry::get_method_info().method_ptr,();
1940(Script)__receiver,(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(value))
1941        }
1942    }
1943    #[doc = "`MoonSharp.Interpreter.IScriptPrivateResource.get_OwnerScript()` overload"]
1944    fn moon_sharp_interpreter_i_script_private_resource_get_owner_script(self) -> crate::moon_sharp::interpreter::script::Script {
1945        unsafe {
1946            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1947            {
1948                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1949                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1950                    panic!(
1951                        "unity: virtual slot {}
1952 out of range (vtable len {}
1953) on the runtime class behind {}
1954 (method `{}
1955`)",
1956                        4usize,
1957                        __vt.len(),
1958                        <Script as ::unity::ClassIdentity>::NAME,
1959                        "MoonSharp.Interpreter.IScriptPrivateResource.get_OwnerScript",
1960                    )
1961                });
1962                let __inner: extern "C" fn(Script, ::unity::OptionalMethod) -> crate::moon_sharp::interpreter::script::Script =
1963                    ::core::mem::transmute(__vi.method_ptr);
1964                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1965                __inner(__receiver, __mi)
1966            }
1967        }
1968    }
1969    #[doc = "`GetLine(i32)` overload"]
1970    fn get_line(self, i_address: impl ::core::convert::Into<i32>) -> i32 {
1971        unsafe {
1972            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1973            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_line::get_method_info().method_ptr,i32;
1974(Script)__receiver,(i32)::core::convert::Into::into(i_address))
1975        }
1976    }
1977    #[doc = "`GetLine(crate::moon_sharp::interpreter::debugging::watchitem::WatchItem)` overload"]
1978    fn get_line_2(self, item: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem>) -> i32 {
1979        unsafe {
1980            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1981            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_line_2::get_method_info().method_ptr,i32;
1982(Script)__receiver,(crate::moon_sharp::interpreter::debugging::watchitem::WatchItem)::core::convert::Into::into(item))
1983        }
1984    }
1985    #[doc = "`GetSourceRef(i32)` overload"]
1986    fn get_source_ref(self, i_address: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::debugging::sourceref::SourceRef {
1987        unsafe {
1988            let __receiver = <Script as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1989            ::unity::il2cpp_call!(__Script_unity_raw::__lookup_get_source_ref::get_method_info().method_ptr,crate::moon_sharp::interpreter::debugging::sourceref::SourceRef;
1990(Script)__receiver,(i32)::core::convert::Into::into(i_address))
1991        }
1992    }
1993}
1994
1995#[cfg(feature = "moon_sharp-interpreter-script")]
1996impl<__T: IScript> IScriptMethods for __T {}
1997
1998#[cfg(feature = "moon_sharp-interpreter-script")]
1999impl Script {
2000    pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2001        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2002    }
2003
2004    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2005        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2006    }
2007
2008    pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2009        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2010    }
2011
2012    pub fn get_default_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2013        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2014    }
2015
2016    pub fn set_default_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2017        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2018    }
2019
2020    pub fn get_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2021        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2022    }
2023
2024    pub fn set_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2025        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2026    }
2027
2028    pub fn get_global_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2029        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2030    }
2031
2032    pub fn set_global_options_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2033        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2034    }
2035
2036    pub fn get_performance_stats_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2037        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2038    }
2039
2040    pub fn set_performance_stats_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2041        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2042    }
2043
2044    pub fn get_globals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2045        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2046    }
2047
2048    pub fn load_function_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2049        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2050    }
2051
2052    pub fn signal_byte_code_change_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2053        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2054    }
2055
2056    pub fn signal_source_code_change_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2057        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2058    }
2059
2060    pub fn load_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2061        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2062    }
2063
2064    pub fn load_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2065        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2066    }
2067
2068    pub fn dump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2069        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2070    }
2071
2072    pub fn load_file_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2073        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2074    }
2075
2076    pub fn do_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2077        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2078    }
2079
2080    pub fn do_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2081        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2082    }
2083
2084    pub fn do_file_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2085        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2086    }
2087
2088    pub fn run_file_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2089        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2090    }
2091
2092    pub fn run_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2093        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2094    }
2095
2096    pub fn make_closure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2097        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2098    }
2099
2100    pub fn call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2101        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2102    }
2103
2104    pub fn call_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2105        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2106    }
2107
2108    pub fn call_3_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2109        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2110    }
2111
2112    pub fn call_4_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2113        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2114    }
2115
2116    pub fn call_5_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2117        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2118    }
2119
2120    pub fn create_coroutine_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2121        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2122    }
2123
2124    pub fn create_coroutine_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2125        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2126    }
2127
2128    pub fn get_debugger_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2129        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2130    }
2131
2132    pub fn set_debugger_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2133        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2134    }
2135
2136    pub fn attach_debugger_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2137        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2138    }
2139
2140    pub fn get_source_code_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2141        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2142    }
2143
2144    pub fn get_source_code_count_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2145        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2146    }
2147
2148    pub fn require_module_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2149        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2150    }
2151
2152    pub fn get_type_metatable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2153        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2154    }
2155
2156    pub fn set_type_metatable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2157        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2158    }
2159
2160    pub fn warm_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2161        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2162    }
2163
2164    pub fn create_dynamic_expression_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2165        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2166    }
2167
2168    pub fn create_constant_dynamic_expression_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2169        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2170    }
2171
2172    pub fn create_dynamic_execution_context_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2173        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2174    }
2175
2176    pub fn get_registry_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2177        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2178    }
2179
2180    pub fn set_registry_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2181        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2182    }
2183
2184    pub fn get_banner_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2185        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2186    }
2187
2188    pub fn moon_sharp_interpreter_i_script_private_resource_get_owner_script_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2189        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2190    }
2191
2192    pub fn get_line_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2193        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2194    }
2195
2196    pub fn get_line_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2197        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2198    }
2199
2200    pub fn get_source_ref_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2201        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2202    }
2203}
2204
2205#[cfg(feature = "moon_sharp-interpreter-script")]
2206impl Script {
2207    #[doc = "Direct (non-virtual) call to `Script`'s own `MoonSharp.Interpreter.IScriptPrivateResource.get_OwnerScript`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2208    pub unsafe fn moon_sharp_interpreter_i_script_private_resource_get_owner_script(
2209        this: impl ::core::convert::Into<::unity::IlInstance>,
2210    ) -> crate::moon_sharp::interpreter::script::Script {
2211        let __mi = Self::moon_sharp_interpreter_i_script_private_resource_get_owner_script_method_info();
2212        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::moon_sharp::interpreter::script::Script =
2213            ::core::mem::transmute(__mi.method_ptr);
2214        __inner(this.into(), ::core::option::Option::None)
2215    }
2216}
2217
2218#[cfg(feature = "moon_sharp-interpreter-script")]
2219impl Script {
2220    #[doc = "`.ctor()` — no args"]
2221    pub fn new() -> Self {
2222        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2223            panic!(
2224                "{}
2225::{}
2226 failed to instantiate",
2227                ::core::stringify!(Script),
2228                ::core::stringify!(new),
2229            )
2230        });
2231        <Self as IScriptMethods>::ctor(this);
2232        this
2233    }
2234
2235    #[doc = "`.ctor(crate::moon_sharp::interpreter::coremodules::CoreModules)` — overload selector"]
2236    pub fn new_2(core_modules: crate::moon_sharp::interpreter::coremodules::CoreModules) -> Self {
2237        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2238            panic!(
2239                "{}
2240::{}
2241 failed to instantiate",
2242                ::core::stringify!(Script),
2243                ::core::stringify!(new_2),
2244            )
2245        });
2246        <Self as IScriptMethods>::ctor_2(this, core_modules);
2247        this
2248    }
2249}
2250
2251#[cfg(feature = "moon_sharp-interpreter-script")]
2252#[doc(hidden)]
2253pub mod prelude {
2254    pub use super::{IScript, IScriptMethods, Script};
2255    pub use crate::system::object::IObject;
2256    #[cfg(feature = "system-object")]
2257    pub use crate::system::object::IObjectMethods;
2258}