1#[cfg(feature = "app-publicobject-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::singletonmonobehaviour_1::{ISingletonMonoBehaviour_1, SingletonMonoBehaviour_1},
10 system::{
11 delegate::{Delegate, IDelegate},
12 multicastdelegate::{IMulticastDelegate, MulticastDelegate},
13 object::{IObject, Object},
14 },
15 unity_engine::{
16 behaviour::{Behaviour, IBehaviour},
17 component::{Component, IComponent},
18 monobehaviour::{IMonoBehaviour, MonoBehaviour},
19 object_2::{IObject_2, Object_2},
20 },
21 };
22
23 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/publicobject/PublicObject_Group.md"))]
24 #[::unity::class(namespace = "App", name = "PublicObject.Group")]
25 #[parent(crate::system::object::Object)]
26 pub struct PublicObject_Group {
27 #[offset(16)]
28 #[rename(name = "m_Name")]
29 pub m_name: ::unity::Il2CppString,
30 #[offset(24)]
31 #[rename(name = "m_Objects")]
32 pub m_objects: ::unity::Array<crate::unity_engine::object_2::Object_2>,
33 }
34
35 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/publicobject/PublicObject.md"))]
36 #[::unity::class(namespace = "App", name = "PublicObject")]
37 #[parent(crate::app::singletonmonobehaviour_1::SingletonMonoBehaviour_1<crate::app::publicobject::PublicObject>)]
38 pub struct PublicObject {
39 #[static_field]
40 #[rename(name = "AssetName")]
41 pub asset_name: ::unity::Il2CppString,
42 #[static_field]
43 #[rename(name = "AssetPath")]
44 pub asset_path: ::unity::Il2CppString,
45 #[offset(32)]
46 #[rename(name = "m_Groups")]
47 pub m_groups: ::unity::Array<crate::app::publicobject::PublicObject_Group>,
48 #[static_field]
49 #[rename(name = "s_Dictionary")]
50 pub s_dictionary:
51 crate::system::collections::generic::dictionary_2::Dictionary_2<::unity::Il2CppString, crate::unity_engine::object_2::Object_2>,
52 }
53
54 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/publicobject/PublicObject_Func_1.md"))]
55 #[::unity::class(namespace = "App", name = "PublicObject.Func`1")]
56 #[parent(crate::system::multicastdelegate::MulticastDelegate)]
57 #[parent(crate::system::delegate::Delegate)]
58 #[parent(crate::system::object::Object)]
59 pub struct PublicObject_Func_1<T0: ::unity::ClassIdentity> {}
60}
61
62#[cfg(feature = "app-publicobject-types")]
63pub use __types::*;
64
65#[cfg(feature = "app-publicobject")]
66pub trait IPublicObject_GroupMethods: IPublicObject_Group {
67 #[doc = "`.ctor()` overload"]
68 fn ctor(self) -> () {
69 unsafe {
70 let __receiver = <PublicObject_Group as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
71 ::unity::il2cpp_call!((::unity::module_base()+0x1af1100usize)as*mut u8,();
72(PublicObject_Group)__receiver)
73 }
74 }
75}
76
77#[cfg(feature = "app-publicobject")]
78impl<__T: IPublicObject_Group> IPublicObject_GroupMethods for __T {}
79
80#[cfg(feature = "app-publicobject")]
81impl PublicObject_Group {
82 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
83 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
84 }
85}
86
87#[cfg(feature = "app-publicobject")]
88impl PublicObject_Group {
89 #[doc = "`.ctor()` — no args"]
90 pub fn new() -> Self {
91 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
92 panic!(
93 "{}
94::{}
95 failed to instantiate",
96 ::core::stringify!(PublicObject_Group),
97 ::core::stringify!(new),
98 )
99 });
100 <Self as IPublicObject_GroupMethods>::ctor(this);
101 this
102 }
103}
104
105#[cfg(feature = "app-publicobject")]
106impl PublicObject {
107 #[doc = "`LoadAsync()` overload"]
108 pub fn load_async() -> () {
109 unsafe {
110 ::unity::il2cpp_call!((::unity::module_base()+0x2c09f40usize)as*mut u8,();
111 )
112 }
113 }
114
115 #[doc = "`WarmUp()` overload"]
116 pub fn warm_up() -> () {
117 unsafe {
118 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a6f0usize)as*mut u8,();
119 )
120 }
121 }
122
123 pub fn get_asset<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
124 name: impl ::core::convert::Into<::unity::Il2CppString>,
125 ) -> M0 {
126 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
127 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "GetAsset", 1));
128 #[allow(clippy::type_complexity)]
129 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
130 ::std::sync::OnceLock::new();
131 let _ = true;
132 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
133 ::core::result::Result::Ok(mi) => *mi,
134 ::core::result::Result::Err(e) => {
135 panic!(
136 "method lookup failed: {}
137::{}
138: {}
139",
140 <PublicObject as ::unity::ClassIdentity>::NAME,
141 "GetAsset",
142 e
143 )
144 },
145 };
146 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
147 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
148 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
149 let mut __guard = __cache.lock().unwrap();
150 *__guard
151 .entry(__key)
152 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
153 };
154 unsafe {
155 let __f: extern "C" fn(::unity::Il2CppString, ::unity::OptionalMethod) -> M0 = ::core::mem::transmute(__inflated.method_ptr);
156 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
157 __f(::core::convert::Into::into(name), ::core::option::Option::Some(__mi_opaque))
158 }
159 }
160
161 pub fn instantiate<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
162 name: impl ::core::convert::Into<::unity::Il2CppString>,
163 parent: impl ::core::convert::Into<crate::unity_engine::transform::Transform>,
164 ) -> M0 {
165 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
166 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "Instantiate", 2));
167 #[allow(clippy::type_complexity)]
168 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
169 ::std::sync::OnceLock::new();
170 let _ = true;
171 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
172 ::core::result::Result::Ok(mi) => *mi,
173 ::core::result::Result::Err(e) => {
174 panic!(
175 "method lookup failed: {}
176::{}
177: {}
178",
179 <PublicObject as ::unity::ClassIdentity>::NAME,
180 "Instantiate",
181 e
182 )
183 },
184 };
185 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
186 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
187 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
188 let mut __guard = __cache.lock().unwrap();
189 *__guard
190 .entry(__key)
191 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
192 };
193 unsafe {
194 let __f: extern "C" fn(::unity::Il2CppString, crate::unity_engine::transform::Transform, ::unity::OptionalMethod) -> M0 =
195 ::core::mem::transmute(__inflated.method_ptr);
196 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
197 __f(
198 ::core::convert::Into::into(name),
199 ::core::convert::Into::into(parent),
200 ::core::option::Option::Some(__mi_opaque),
201 )
202 }
203 }
204
205 pub fn instantiate_2<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
206 name: impl ::core::convert::Into<::unity::Il2CppString>,
207 parent: impl ::core::convert::Into<crate::unity_engine::gameobject::GameObject>,
208 ) -> M0 {
209 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
210 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "Instantiate", 2));
211 #[allow(clippy::type_complexity)]
212 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
213 ::std::sync::OnceLock::new();
214 let _ = true;
215 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
216 ::core::result::Result::Ok(mi) => *mi,
217 ::core::result::Result::Err(e) => {
218 panic!(
219 "method lookup failed: {}
220::{}
221: {}
222",
223 <PublicObject as ::unity::ClassIdentity>::NAME,
224 "Instantiate",
225 e
226 )
227 },
228 };
229 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
230 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
231 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
232 let mut __guard = __cache.lock().unwrap();
233 *__guard
234 .entry(__key)
235 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
236 };
237 unsafe {
238 let __f: extern "C" fn(::unity::Il2CppString, crate::unity_engine::gameobject::GameObject, ::unity::OptionalMethod) -> M0 =
239 ::core::mem::transmute(__inflated.method_ptr);
240 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
241 __f(
242 ::core::convert::Into::into(name),
243 ::core::convert::Into::into(parent),
244 ::core::option::Option::Some(__mi_opaque),
245 )
246 }
247 }
248
249 pub fn for_each<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
250 func: impl ::core::convert::Into<crate::app::publicobject::PublicObject_Func_1<M0>>,
251 ) -> () {
252 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
253 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "ForEach", 1));
254 #[allow(clippy::type_complexity)]
255 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
256 ::std::sync::OnceLock::new();
257 let _ = true;
258 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
259 ::core::result::Result::Ok(mi) => *mi,
260 ::core::result::Result::Err(e) => {
261 panic!(
262 "method lookup failed: {}
263::{}
264: {}
265",
266 <PublicObject as ::unity::ClassIdentity>::NAME,
267 "ForEach",
268 e
269 )
270 },
271 };
272 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
273 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
274 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
275 let mut __guard = __cache.lock().unwrap();
276 *__guard
277 .entry(__key)
278 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
279 };
280 unsafe {
281 let __f: extern "C" fn(crate::app::publicobject::PublicObject_Func_1<M0>, ::unity::OptionalMethod) -> () =
282 ::core::mem::transmute(__inflated.method_ptr);
283 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
284 __f(::core::convert::Into::into(func), ::core::option::Option::Some(__mi_opaque))
285 }
286 }
287
288 #[doc = "`Dump()` overload"]
289 pub fn dump() -> () {
290 unsafe {
291 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a810usize)as*mut u8,();
292 )
293 }
294 }
295
296 #[doc = "`.cctor()` overload"]
297 pub fn cctor() -> () {
298 unsafe {
299 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a8a0usize)as*mut u8,();
300 )
301 }
302 }
303}
304
305#[cfg(feature = "app-publicobject")]
306pub trait IPublicObjectMethods: IPublicObject {
307 fn for_each_impl<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
308 self,
309 func: impl ::core::convert::Into<crate::app::publicobject::PublicObject_Func_1<M0>>,
310 ) -> () {
311 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> =
312 ::std::sync::LazyLock::new(|| ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "ForEachImpl", 1));
313 #[allow(clippy::type_complexity)]
314 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
315 ::std::sync::OnceLock::new();
316 let _ = false;
317 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
318 ::core::result::Result::Ok(mi) => *mi,
319 ::core::result::Result::Err(e) => {
320 panic!(
321 "method lookup failed: {}
322::{}
323: {}
324",
325 <PublicObject as ::unity::ClassIdentity>::NAME,
326 "ForEachImpl",
327 e
328 )
329 },
330 };
331 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
332 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
333 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
334 let mut __guard = __cache.lock().unwrap();
335 *__guard
336 .entry(__key)
337 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
338 };
339 unsafe {
340 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
341 let __f: extern "C" fn(PublicObject, crate::app::publicobject::PublicObject_Func_1<M0>, ::unity::OptionalMethod) -> () =
342 ::core::mem::transmute(__inflated.method_ptr);
343 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
344 __f(__receiver, ::core::convert::Into::into(func), ::core::option::Option::Some(__mi_opaque))
345 }
346 }
347 #[doc = "`WarmUpImpl()` overload"]
348 fn warm_up_impl(self) -> () {
349 unsafe {
350 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
351 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a0b0usize)as*mut u8,();
352(PublicObject)__receiver)
353 }
354 }
355 #[doc = "`TryCreateDictionary()` overload"]
356 fn try_create_dictionary(self) -> () {
357 unsafe {
358 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
359 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a390usize)as*mut u8,();
360(PublicObject)__receiver)
361 }
362 }
363 fn get_asset_impl<M0: ::unity::IlType + ::core::marker::Copy + ::unity::ClassIdentity>(
364 self,
365 name: impl ::core::convert::Into<::unity::Il2CppString>,
366 ) -> M0 {
367 static OPEN: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
368 ::unity::lookup::method_info_on_class(<PublicObject as ::unity::ClassIdentity>::class(), "GetAssetImpl", 1)
369 });
370 #[allow(clippy::type_complexity)]
371 static CACHE: ::std::sync::OnceLock<::std::sync::Mutex<::std::collections::HashMap<usize, &'static ::unity::il2cpp::MethodInfo>>> =
372 ::std::sync::OnceLock::new();
373 let _ = false;
374 let __open: &'static ::unity::il2cpp::MethodInfo = match &*OPEN {
375 ::core::result::Result::Ok(mi) => *mi,
376 ::core::result::Result::Err(e) => {
377 panic!(
378 "method lookup failed: {}
379::{}
380: {}
381",
382 <PublicObject as ::unity::ClassIdentity>::NAME,
383 "GetAssetImpl",
384 e
385 )
386 },
387 };
388 let __cache = CACHE.get_or_init(|| ::std::sync::Mutex::new(::std::collections::HashMap::new()));
389 let __key: usize = <M0 as ::unity::IlType>::il_type() as *const _ as usize;
390 let __inflated: &'static ::unity::il2cpp::MethodInfo = {
391 let mut __guard = __cache.lock().unwrap();
392 *__guard
393 .entry(__key)
394 .or_insert_with(|| ::unity::il2cpp::generic::create_generic_method_info(__open, &[<M0 as ::unity::IlType>::il_type()]))
395 };
396 unsafe {
397 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
398 let __f: extern "C" fn(PublicObject, ::unity::Il2CppString, ::unity::OptionalMethod) -> M0 =
399 ::core::mem::transmute(__inflated.method_ptr);
400 let __mi_opaque: &'static () = &*(__inflated as *const _ as *const ());
401 __f(__receiver, ::core::convert::Into::into(name), ::core::option::Option::Some(__mi_opaque))
402 }
403 }
404 #[doc = "`DumpImpl()` overload"]
405 fn dump_impl(self) -> () {
406 unsafe {
407 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
408 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a600usize)as*mut u8,();
409(PublicObject)__receiver)
410 }
411 }
412 #[doc = "`.ctor()` overload"]
413 fn ctor(self) -> () {
414 unsafe {
415 let __receiver = <PublicObject as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
416 ::unity::il2cpp_call!((::unity::module_base()+0x2c0a820usize)as*mut u8,();
417(PublicObject)__receiver)
418 }
419 }
420}
421
422#[cfg(feature = "app-publicobject")]
423impl<__T: IPublicObject> IPublicObjectMethods for __T {}
424
425#[cfg(feature = "app-publicobject")]
426impl PublicObject {
427 pub fn load_async_method_info() -> &'static ::unity::il2cpp::MethodInfo {
428 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
429 }
430
431 pub fn warm_up_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
432 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
433 }
434
435 pub fn try_create_dictionary_method_info() -> &'static ::unity::il2cpp::MethodInfo {
436 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
437 }
438
439 pub fn dump_impl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
440 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
441 }
442
443 pub fn warm_up_method_info() -> &'static ::unity::il2cpp::MethodInfo {
444 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
445 }
446
447 pub fn dump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
448 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
449 }
450
451 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
452 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
453 }
454
455 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
456 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
457 }
458}
459
460#[cfg(feature = "app-publicobject")]
461impl PublicObject {
462 #[doc = "`.ctor()` — no args"]
463 pub fn new() -> Self {
464 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
465 panic!(
466 "{}
467::{}
468 failed to instantiate",
469 ::core::stringify!(PublicObject),
470 ::core::stringify!(new),
471 )
472 });
473 <Self as IPublicObjectMethods>::ctor(this);
474 this
475 }
476}
477
478#[cfg(feature = "app-publicobject")]
479#[::unity::methods]
480impl<T0: ::unity::ClassIdentity> PublicObject_Func_1<T0> {
481 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` overload"]
482 #[method(name = ".ctor", args = 2)]
483 pub fn ctor(self, object: crate::system::object::Object, method: ::unity::IntPtr) -> ();
484
485 #[doc = "`Invoke(::unity::Il2CppString, T0)` overload"]
486 #[method(name = "Invoke", args = 2)]
487 pub fn invoke(self, group: ::unity::Il2CppString, obj: T0) -> ();
488}
489
490#[cfg(feature = "app-publicobject")]
491impl<T0: ::unity::ClassIdentity> PublicObject_Func_1<T0> {
492 #[doc = "`.ctor(crate::system::object::Object, ::unity::IntPtr)` — overload selector"]
493 pub fn new(object: crate::system::object::Object, method: ::unity::IntPtr) -> Self {
494 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
495 panic!(
496 "{}
497::{}
498 failed to instantiate",
499 ::core::stringify!(PublicObject_Func_1),
500 ::core::stringify!(new),
501 )
502 });
503 <Self as IPublicObject_Func_1Methods<T0>>::ctor(this, object, method);
504 this
505 }
506}
507
508#[cfg(feature = "app-publicobject")]
509#[doc(hidden)]
510pub mod prelude {
511 pub use super::{
512 IPublicObject, IPublicObjectMethods, IPublicObject_Func_1, IPublicObject_Func_1Methods, IPublicObject_Group, IPublicObject_GroupMethods,
513 PublicObject, PublicObject_Func_1, PublicObject_Group,
514 };
515 #[cfg(feature = "app-singletonmonobehaviour_1")]
516 pub use crate::app::singletonmonobehaviour_1::ISingletonMonoBehaviour_1Methods;
517 #[cfg(feature = "system-delegate")]
518 pub use crate::system::delegate::IDelegateMethods;
519 #[cfg(feature = "system-multicastdelegate")]
520 pub use crate::system::multicastdelegate::IMulticastDelegateMethods;
521 #[cfg(feature = "system-object")]
522 pub use crate::system::object::IObjectMethods;
523 #[cfg(feature = "unity_engine-behaviour")]
524 pub use crate::unity_engine::behaviour::IBehaviourMethods;
525 #[cfg(feature = "unity_engine-component")]
526 pub use crate::unity_engine::component::IComponentMethods;
527 #[cfg(feature = "unity_engine-monobehaviour")]
528 pub use crate::unity_engine::monobehaviour::IMonoBehaviourMethods;
529 #[cfg(feature = "unity_engine-object_2")]
530 pub use crate::unity_engine::object_2::IObject_2Methods;
531 pub use crate::{
532 app::singletonmonobehaviour_1::ISingletonMonoBehaviour_1,
533 system::{delegate::IDelegate, multicastdelegate::IMulticastDelegate, object::IObject},
534 unity_engine::{behaviour::IBehaviour, component::IComponent, monobehaviour::IMonoBehaviour, object_2::IObject_2},
535 };
536}