1#[cfg(feature = "app-hubmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 basicmenu::{BasicMenu, IBasicMenu},
11 basicmenuitem::{BasicMenuItem, IBasicMenuItem},
12 mapbasicmenuitem::{IMapBasicMenuItem, MapBasicMenuItem},
13 procinst::{IProcInst, ProcInst},
14 },
15 system::object::{IObject, Object},
16 };
17
18 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubSystemMenu_ResetItem.md"))]
19 #[::unity::class(namespace = "App", name = "HubMenu.SubSystemMenu.ResetItem")]
20 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
21 pub struct HubMenu_SubSystemMenu_ResetItem {}
22
23 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu.md"))]
24 #[::unity::class(namespace = "App", name = "HubMenu")]
25 #[parent(crate::app::basicmenu::BasicMenu)]
26 pub struct HubMenu {
27 #[static_field]
28 #[rename(name = "currentMenuSelect")]
29 pub current_menu_select: crate::app::basicmenuselect::BasicMenuSelect,
30 }
31
32 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_MaterialListItem.md"))]
33 #[::unity::class(namespace = "App", name = "HubMenu.MaterialListItem")]
34 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
35 pub struct HubMenu_MaterialListItem {}
36
37 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu.md"))]
38 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu")]
39 #[parent(crate::app::basicmenu::BasicMenu)]
40 pub struct HubMenu_SubFriendMenu {}
41
42 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SystemItem.md"))]
43 #[::unity::class(namespace = "App", name = "HubMenu.SystemItem")]
44 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
45 pub struct HubMenu_SystemItem {}
46
47 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_NextItem.md"))]
48 #[::unity::class(namespace = "App", name = "HubMenu.NextItem")]
49 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
50 pub struct HubMenu_NextItem {}
51
52 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu_RingListItem.md"))]
53 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu.RingListItem")]
54 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
55 pub struct HubMenu_SubFriendMenu_RingListItem {}
56
57 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_FriendItem.md"))]
58 #[::unity::class(namespace = "App", name = "HubMenu.FriendItem")]
59 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
60 pub struct HubMenu_FriendItem {}
61
62 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu_KizunaItem.md"))]
63 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu.KizunaItem")]
64 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
65 pub struct HubMenu_SubFriendMenu_KizunaItem {}
66
67 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_HubMenuItem.md"))]
68 #[::unity::class(namespace = "App", name = "HubMenu.HubMenuItem")]
69 #[parent(crate::app::mapbasicmenuitem::MapBasicMenuItem)]
70 pub struct HubMenu_HubMenuItem {}
71
72 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_NextChapterItem.md"))]
73 #[::unity::class(namespace = "App", name = "HubMenu.NextChapterItem")]
74 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
75 pub struct HubMenu_NextChapterItem {}
76
77 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu_NotebookItem.md"))]
78 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu.NotebookItem")]
79 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
80 pub struct HubMenu_SubFriendMenu_NotebookItem {}
81
82 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu_RelianceItem.md"))]
83 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu.RelianceItem")]
84 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
85 pub struct HubMenu_SubFriendMenu_RelianceItem {}
86
87 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SaveItem.md"))]
88 #[::unity::class(namespace = "App", name = "HubMenu.SaveItem")]
89 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
90 pub struct HubMenu_SaveItem {}
91
92 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubSystemMenu_ConfigItem.md"))]
93 #[::unity::class(namespace = "App", name = "HubMenu.SubSystemMenu.ConfigItem")]
94 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
95 pub struct HubMenu_SubSystemMenu_ConfigItem {}
96
97 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubFriendMenu_ProfileCardItem.md"))]
98 #[::unity::class(namespace = "App", name = "HubMenu.SubFriendMenu.ProfileCardItem")]
99 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
100 pub struct HubMenu_SubFriendMenu_ProfileCardItem {}
101
102 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_GmapItem.md"))]
103 #[::unity::class(namespace = "App", name = "HubMenu.GmapItem")]
104 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
105 pub struct HubMenu_GmapItem {}
106
107 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_InventoryItem.md"))]
108 #[::unity::class(namespace = "App", name = "HubMenu.InventoryItem")]
109 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
110 pub struct HubMenu_InventoryItem {}
111
112 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_MapInfoItem.md"))]
113 #[::unity::class(namespace = "App", name = "HubMenu.MapInfoItem")]
114 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
115 pub struct HubMenu_MapInfoItem {}
116
117 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_GodItem.md"))]
118 #[::unity::class(namespace = "App", name = "HubMenu.GodItem")]
119 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
120 pub struct HubMenu_GodItem {}
121
122 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubSystemMenu_TutorialItem.md"))]
123 #[::unity::class(namespace = "App", name = "HubMenu.SubSystemMenu.TutorialItem")]
124 #[parent(crate::app::hubmenu::HubMenu_HubMenuItem)]
125 pub struct HubMenu_SubSystemMenu_TutorialItem {}
126
127 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/hubmenu/HubMenu_SubSystemMenu.md"))]
128 #[::unity::class(namespace = "App", name = "HubMenu.SubSystemMenu")]
129 #[parent(crate::app::basicmenu::BasicMenu)]
130 pub struct HubMenu_SubSystemMenu {}
131}
132
133#[cfg(feature = "app-hubmenu-types")]
134pub use __types::*;
135
136#[cfg(feature = "app-hubmenu")]
137pub trait IHubMenu_SubSystemMenu_ResetItemMethods: IHubMenu_SubSystemMenu_ResetItem {
138 #[doc = "`GetName()` overload"]
139 fn get_name(self) -> ::unity::Il2CppString {
140 unsafe {
141 let __receiver =
142 <HubMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
143 {
144 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
145 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
146 panic!(
147 "unity: virtual slot {}
148 out of range (vtable len {}
149) on the runtime class behind {}
150 (method `{}
151`)",
152 4usize,
153 __vt.len(),
154 <HubMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
155 "GetName",
156 )
157 });
158 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ResetItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
159 ::core::mem::transmute(__vi.method_ptr);
160 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
161 __inner(__receiver, __mi)
162 }
163 }
164 }
165 #[doc = "`GetHelpText()` overload"]
166 fn get_help_text(self) -> ::unity::Il2CppString {
167 unsafe {
168 let __receiver =
169 <HubMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
170 {
171 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
172 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
173 panic!(
174 "unity: virtual slot {}
175 out of range (vtable len {}
176) on the runtime class behind {}
177 (method `{}
178`)",
179 28usize,
180 __vt.len(),
181 <HubMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
182 "GetHelpText",
183 )
184 });
185 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ResetItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
186 ::core::mem::transmute(__vi.method_ptr);
187 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
188 __inner(__receiver, __mi)
189 }
190 }
191 }
192 #[doc = "`BuildAttribute()` overload"]
193 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
194 unsafe {
195 let __receiver =
196 <HubMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
197 {
198 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
199 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
200 panic!(
201 "unity: virtual slot {}
202 out of range (vtable len {}
203) on the runtime class behind {}
204 (method `{}
205`)",
206 8usize,
207 __vt.len(),
208 <HubMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
209 "BuildAttribute",
210 )
211 });
212 let __inner: extern "C" fn(
213 HubMenu_SubSystemMenu_ResetItem,
214 ::unity::OptionalMethod,
215 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
216 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
217 __inner(__receiver, __mi)
218 }
219 }
220 }
221 #[doc = "`ACall()` overload"]
222 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
223 unsafe {
224 let __receiver =
225 <HubMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
226 {
227 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
228 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
229 panic!(
230 "unity: virtual slot {}
231 out of range (vtable len {}
232) on the runtime class behind {}
233 (method `{}
234`)",
235 18usize,
236 __vt.len(),
237 <HubMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
238 "ACall",
239 )
240 });
241 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ResetItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
242 ::core::mem::transmute(__vi.method_ptr);
243 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
244 __inner(__receiver, __mi)
245 }
246 }
247 }
248 #[doc = "`.ctor()` overload"]
249 fn ctor(self) -> () {
250 unsafe {
251 let __receiver =
252 <HubMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
253 ::unity::il2cpp_call!((::unity::module_base()+0x1b651d0usize)as*mut u8,();
254(HubMenu_SubSystemMenu_ResetItem)__receiver)
255 }
256 }
257}
258
259#[cfg(feature = "app-hubmenu")]
260impl<__T: IHubMenu_SubSystemMenu_ResetItem> IHubMenu_SubSystemMenu_ResetItemMethods for __T {}
261
262#[cfg(feature = "app-hubmenu")]
263impl HubMenu_SubSystemMenu_ResetItem {
264 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
265 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
266 }
267
268 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
269 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
270 }
271
272 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
273 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
274 }
275
276 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
277 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
278 }
279
280 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
281 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
282 }
283}
284
285#[cfg(feature = "app-hubmenu")]
286impl HubMenu_SubSystemMenu_ResetItem {
287 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ResetItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
288 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
289 let __mi = Self::get_name_method_info();
290 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
291 __inner(this.into(), ::core::option::Option::None)
292 }
293
294 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ResetItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
295 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
296 let __mi = Self::get_help_text_method_info();
297 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
298 __inner(this.into(), ::core::option::Option::None)
299 }
300
301 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ResetItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
302 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
303 let __mi = Self::build_attribute_method_info();
304 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
305 ::core::mem::transmute(__mi.method_ptr);
306 __inner(this.into(), ::core::option::Option::None)
307 }
308
309 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ResetItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
310 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
311 let __mi = Self::a_call_method_info();
312 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
313 ::core::mem::transmute(__mi.method_ptr);
314 __inner(this.into(), ::core::option::Option::None)
315 }
316}
317
318#[cfg(feature = "app-hubmenu")]
319impl HubMenu_SubSystemMenu_ResetItem {
320 #[doc = "`.ctor()` — no args"]
321 pub fn new() -> Self {
322 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
323 panic!(
324 "{}
325::{}
326 failed to instantiate",
327 ::core::stringify!(HubMenu_SubSystemMenu_ResetItem),
328 ::core::stringify!(new),
329 )
330 });
331 <Self as IHubMenu_SubSystemMenu_ResetItemMethods>::ctor(this);
332 this
333 }
334}
335
336#[cfg(feature = "app-hubmenu")]
337impl HubMenu {
338 #[doc = "`Init()` overload"]
339 pub fn init() -> () {
340 unsafe {
341 ::unity::il2cpp_call!((::unity::module_base()+0x28b6e30usize)as*mut u8,();
342 )
343 }
344 }
345
346 #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
347 pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
348 unsafe {
349 ::unity::il2cpp_call!((::unity::module_base()+0x28b6ef0usize)as*mut u8,();
350(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
351 }
352 }
353
354 #[doc = "`Destroy()` overload"]
355 pub fn destroy() -> () {
356 unsafe {
357 ::unity::il2cpp_call!((::unity::module_base()+0x28b7b50usize)as*mut u8,();
358 )
359 }
360 }
361
362 #[doc = "`.cctor()` overload"]
363 pub fn cctor() -> () {
364 unsafe {
365 ::unity::il2cpp_call!((::unity::module_base()+0x28b7e00usize)as*mut u8,();
366 )
367 }
368 }
369}
370
371#[cfg(feature = "app-hubmenu")]
372pub trait IHubMenuMethods: IHubMenu {
373 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` overload"]
374 fn ctor(
375 self,
376 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
377 menu_content: impl ::core::convert::Into<crate::app::basicmenucontent::BasicMenuContent>,
378 ) -> () {
379 unsafe {
380 let __receiver = <HubMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
381 ::unity::il2cpp_call!((::unity::module_base()+0x28b6d20usize)as*mut u8,();
382(HubMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::basicmenucontent::BasicMenuContent)::core::convert::Into::into(menu_content))
383 }
384 }
385 #[doc = "`GetName()` overload"]
386 fn get_name(self) -> ::unity::Il2CppString {
387 unsafe {
388 let __receiver = <HubMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
389 {
390 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
391 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
392 panic!(
393 "unity: virtual slot {}
394 out of range (vtable len {}
395) on the runtime class behind {}
396 (method `{}
397`)",
398 30usize,
399 __vt.len(),
400 <HubMenu as ::unity::ClassIdentity>::NAME,
401 "GetName",
402 )
403 });
404 let __inner: extern "C" fn(HubMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
405 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
406 __inner(__receiver, __mi)
407 }
408 }
409 }
410 #[doc = "`OnClose()` overload"]
411 fn on_close(self) -> () {
412 unsafe {
413 let __receiver = <HubMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
414 {
415 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
416 let __vi = *__vt.get(26usize).unwrap_or_else(|| {
417 panic!(
418 "unity: virtual slot {}
419 out of range (vtable len {}
420) on the runtime class behind {}
421 (method `{}
422`)",
423 26usize,
424 __vt.len(),
425 <HubMenu as ::unity::ClassIdentity>::NAME,
426 "OnClose",
427 )
428 });
429 let __inner: extern "C" fn(HubMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
430 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
431 __inner(__receiver, __mi)
432 }
433 }
434 }
435 #[doc = "`OnResume()` overload"]
436 fn on_resume(self) -> () {
437 unsafe {
438 let __receiver = <HubMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
439 {
440 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
441 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
442 panic!(
443 "unity: virtual slot {}
444 out of range (vtable len {}
445) on the runtime class behind {}
446 (method `{}
447`)",
448 28usize,
449 __vt.len(),
450 <HubMenu as ::unity::ClassIdentity>::NAME,
451 "OnResume",
452 )
453 });
454 let __inner: extern "C" fn(HubMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
455 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
456 __inner(__receiver, __mi)
457 }
458 }
459 }
460}
461
462#[cfg(feature = "app-hubmenu")]
463impl<__T: IHubMenu> IHubMenuMethods for __T {}
464
465#[cfg(feature = "app-hubmenu")]
466impl HubMenu {
467 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
468 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
469 }
470
471 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
472 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
473 }
474
475 pub fn on_close_method_info() -> &'static ::unity::il2cpp::MethodInfo {
476 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
477 }
478
479 pub fn init_method_info() -> &'static ::unity::il2cpp::MethodInfo {
480 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
481 }
482
483 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
484 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
485 }
486
487 pub fn on_resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
488 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
489 }
490
491 pub fn destroy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
492 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
493 }
494
495 pub fn cctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
496 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
497 }
498}
499
500#[cfg(feature = "app-hubmenu")]
501impl HubMenu {
502 #[doc = "Direct (non-virtual) call to `HubMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
503 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
504 let __mi = Self::get_name_method_info();
505 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
506 __inner(this.into(), ::core::option::Option::None)
507 }
508
509 #[doc = "Direct (non-virtual) call to `HubMenu`'s own `OnClose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
510 pub unsafe fn on_close(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
511 let __mi = Self::on_close_method_info();
512 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
513 __inner(this.into(), ::core::option::Option::None)
514 }
515
516 #[doc = "Direct (non-virtual) call to `HubMenu`'s own `OnResume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
517 pub unsafe fn on_resume(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
518 let __mi = Self::on_resume_method_info();
519 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
520 __inner(this.into(), ::core::option::Option::None)
521 }
522}
523
524#[cfg(feature = "app-hubmenu")]
525impl HubMenu {
526 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` — overload selector"]
527 pub fn new(
528 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
529 menu_content: crate::app::basicmenucontent::BasicMenuContent,
530 ) -> Self {
531 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
532 panic!(
533 "{}
534::{}
535 failed to instantiate",
536 ::core::stringify!(HubMenu),
537 ::core::stringify!(new),
538 )
539 });
540 <Self as IHubMenuMethods>::ctor(this, menu_item_list, menu_content);
541 this
542 }
543}
544
545#[cfg(feature = "app-hubmenu")]
546pub trait IHubMenu_MaterialListItemMethods: IHubMenu_MaterialListItem {
547 #[doc = "`GetName()` overload"]
548 fn get_name(self) -> ::unity::Il2CppString {
549 unsafe {
550 let __receiver =
551 <HubMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
552 {
553 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
554 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
555 panic!(
556 "unity: virtual slot {}
557 out of range (vtable len {}
558) on the runtime class behind {}
559 (method `{}
560`)",
561 4usize,
562 __vt.len(),
563 <HubMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
564 "GetName",
565 )
566 });
567 let __inner: extern "C" fn(HubMenu_MaterialListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
568 ::core::mem::transmute(__vi.method_ptr);
569 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
570 __inner(__receiver, __mi)
571 }
572 }
573 }
574 #[doc = "`GetHelpText()` overload"]
575 fn get_help_text(self) -> ::unity::Il2CppString {
576 unsafe {
577 let __receiver =
578 <HubMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
579 {
580 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
581 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
582 panic!(
583 "unity: virtual slot {}
584 out of range (vtable len {}
585) on the runtime class behind {}
586 (method `{}
587`)",
588 28usize,
589 __vt.len(),
590 <HubMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
591 "GetHelpText",
592 )
593 });
594 let __inner: extern "C" fn(HubMenu_MaterialListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
595 ::core::mem::transmute(__vi.method_ptr);
596 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
597 __inner(__receiver, __mi)
598 }
599 }
600 }
601 #[doc = "`BuildAttribute()` overload"]
602 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
603 unsafe {
604 let __receiver =
605 <HubMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
606 {
607 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
608 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
609 panic!(
610 "unity: virtual slot {}
611 out of range (vtable len {}
612) on the runtime class behind {}
613 (method `{}
614`)",
615 8usize,
616 __vt.len(),
617 <HubMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
618 "BuildAttribute",
619 )
620 });
621 let __inner: extern "C" fn(HubMenu_MaterialListItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
622 ::core::mem::transmute(__vi.method_ptr);
623 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
624 __inner(__receiver, __mi)
625 }
626 }
627 }
628 #[doc = "`ACall()` overload"]
629 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
630 unsafe {
631 let __receiver =
632 <HubMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
633 {
634 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
635 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
636 panic!(
637 "unity: virtual slot {}
638 out of range (vtable len {}
639) on the runtime class behind {}
640 (method `{}
641`)",
642 18usize,
643 __vt.len(),
644 <HubMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
645 "ACall",
646 )
647 });
648 let __inner: extern "C" fn(HubMenu_MaterialListItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
649 ::core::mem::transmute(__vi.method_ptr);
650 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
651 __inner(__receiver, __mi)
652 }
653 }
654 }
655 #[doc = "`.ctor()` overload"]
656 fn ctor(self) -> () {
657 unsafe {
658 let __receiver =
659 <HubMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
660 ::unity::il2cpp_call!((::unity::module_base()+0x2ae01c0usize)as*mut u8,();
661(HubMenu_MaterialListItem)__receiver)
662 }
663 }
664}
665
666#[cfg(feature = "app-hubmenu")]
667impl<__T: IHubMenu_MaterialListItem> IHubMenu_MaterialListItemMethods for __T {}
668
669#[cfg(feature = "app-hubmenu")]
670impl HubMenu_MaterialListItem {
671 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
672 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
673 }
674
675 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
676 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
677 }
678
679 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
680 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
681 }
682
683 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
684 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
685 }
686
687 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
688 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
689 }
690}
691
692#[cfg(feature = "app-hubmenu")]
693impl HubMenu_MaterialListItem {
694 #[doc = "Direct (non-virtual) call to `HubMenu_MaterialListItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
695 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
696 let __mi = Self::get_name_method_info();
697 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
698 __inner(this.into(), ::core::option::Option::None)
699 }
700
701 #[doc = "Direct (non-virtual) call to `HubMenu_MaterialListItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
702 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
703 let __mi = Self::get_help_text_method_info();
704 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
705 __inner(this.into(), ::core::option::Option::None)
706 }
707
708 #[doc = "Direct (non-virtual) call to `HubMenu_MaterialListItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
709 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
710 let __mi = Self::build_attribute_method_info();
711 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
712 ::core::mem::transmute(__mi.method_ptr);
713 __inner(this.into(), ::core::option::Option::None)
714 }
715
716 #[doc = "Direct (non-virtual) call to `HubMenu_MaterialListItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
717 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
718 let __mi = Self::a_call_method_info();
719 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
720 ::core::mem::transmute(__mi.method_ptr);
721 __inner(this.into(), ::core::option::Option::None)
722 }
723}
724
725#[cfg(feature = "app-hubmenu")]
726impl HubMenu_MaterialListItem {
727 #[doc = "`.ctor()` — no args"]
728 pub fn new() -> Self {
729 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
730 panic!(
731 "{}
732::{}
733 failed to instantiate",
734 ::core::stringify!(HubMenu_MaterialListItem),
735 ::core::stringify!(new),
736 )
737 });
738 <Self as IHubMenu_MaterialListItemMethods>::ctor(this);
739 this
740 }
741}
742
743#[cfg(feature = "app-hubmenu")]
744impl HubMenu_SubFriendMenu {
745 #[doc = "`CreateBind(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
746 pub fn create_bind(
747 super_: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
748 parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
749 ) -> () {
750 unsafe {
751 ::unity::il2cpp_call!((::unity::module_base()+0x2adea30usize)as*mut u8,();
752(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(super_),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
753 }
754 }
755}
756
757#[cfg(feature = "app-hubmenu")]
758pub trait IHubMenu_SubFriendMenuMethods: IHubMenu_SubFriendMenu {
759 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` overload"]
760 fn ctor(
761 self,
762 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
763 menu_content: impl ::core::convert::Into<crate::app::sortiesubmenucontent::SortieSubMenuContent>,
764 ) -> () {
765 unsafe {
766 let __receiver = <HubMenu_SubFriendMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
767 ::unity::il2cpp_call!((::unity::module_base()+0x2ae0b30usize)as*mut u8,();
768(HubMenu_SubFriendMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::sortiesubmenucontent::SortieSubMenuContent)::core::convert::Into::into(menu_content))
769 }
770 }
771 #[doc = "`GetName()` overload"]
772 fn get_name(self) -> ::unity::Il2CppString {
773 unsafe {
774 let __receiver = <HubMenu_SubFriendMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
775 {
776 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
777 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
778 panic!(
779 "unity: virtual slot {}
780 out of range (vtable len {}
781) on the runtime class behind {}
782 (method `{}
783`)",
784 30usize,
785 __vt.len(),
786 <HubMenu_SubFriendMenu as ::unity::ClassIdentity>::NAME,
787 "GetName",
788 )
789 });
790 let __inner: extern "C" fn(HubMenu_SubFriendMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
791 ::core::mem::transmute(__vi.method_ptr);
792 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
793 __inner(__receiver, __mi)
794 }
795 }
796 }
797}
798
799#[cfg(feature = "app-hubmenu")]
800impl<__T: IHubMenu_SubFriendMenu> IHubMenu_SubFriendMenuMethods for __T {}
801
802#[cfg(feature = "app-hubmenu")]
803impl HubMenu_SubFriendMenu {
804 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
805 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
806 }
807
808 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
809 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
810 }
811
812 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
814 }
815}
816
817#[cfg(feature = "app-hubmenu")]
818impl HubMenu_SubFriendMenu {
819 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
820 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
821 let __mi = Self::get_name_method_info();
822 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
823 __inner(this.into(), ::core::option::Option::None)
824 }
825}
826
827#[cfg(feature = "app-hubmenu")]
828impl HubMenu_SubFriendMenu {
829 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` — overload selector"]
830 pub fn new(
831 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
832 menu_content: crate::app::sortiesubmenucontent::SortieSubMenuContent,
833 ) -> Self {
834 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
835 panic!(
836 "{}
837::{}
838 failed to instantiate",
839 ::core::stringify!(HubMenu_SubFriendMenu),
840 ::core::stringify!(new),
841 )
842 });
843 <Self as IHubMenu_SubFriendMenuMethods>::ctor(this, menu_item_list, menu_content);
844 this
845 }
846}
847
848#[cfg(feature = "app-hubmenu")]
849pub trait IHubMenu_SystemItemMethods: IHubMenu_SystemItem {
850 #[doc = "`get_FlagID()` overload"]
851 fn get_flag_id(self) -> ::unity::Il2CppString {
852 unsafe {
853 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
854 {
855 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
856 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
857 panic!(
858 "unity: virtual slot {}
859 out of range (vtable len {}
860) on the runtime class behind {}
861 (method `{}
862`)",
863 27usize,
864 __vt.len(),
865 <HubMenu_SystemItem as ::unity::ClassIdentity>::NAME,
866 "get_FlagID",
867 )
868 });
869 let __inner: extern "C" fn(HubMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
870 ::core::mem::transmute(__vi.method_ptr);
871 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
872 __inner(__receiver, __mi)
873 }
874 }
875 }
876 #[doc = "`GetName()` overload"]
877 fn get_name(self) -> ::unity::Il2CppString {
878 unsafe {
879 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
880 {
881 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
882 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
883 panic!(
884 "unity: virtual slot {}
885 out of range (vtable len {}
886) on the runtime class behind {}
887 (method `{}
888`)",
889 4usize,
890 __vt.len(),
891 <HubMenu_SystemItem as ::unity::ClassIdentity>::NAME,
892 "GetName",
893 )
894 });
895 let __inner: extern "C" fn(HubMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
896 ::core::mem::transmute(__vi.method_ptr);
897 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
898 __inner(__receiver, __mi)
899 }
900 }
901 }
902 #[doc = "`GetHelpText()` overload"]
903 fn get_help_text(self) -> ::unity::Il2CppString {
904 unsafe {
905 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
906 {
907 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
908 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
909 panic!(
910 "unity: virtual slot {}
911 out of range (vtable len {}
912) on the runtime class behind {}
913 (method `{}
914`)",
915 28usize,
916 __vt.len(),
917 <HubMenu_SystemItem as ::unity::ClassIdentity>::NAME,
918 "GetHelpText",
919 )
920 });
921 let __inner: extern "C" fn(HubMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
922 ::core::mem::transmute(__vi.method_ptr);
923 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
924 __inner(__receiver, __mi)
925 }
926 }
927 }
928 #[doc = "`GetMapAttribute()` overload"]
929 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
930 unsafe {
931 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
932 {
933 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
934 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
935 panic!(
936 "unity: virtual slot {}
937 out of range (vtable len {}
938) on the runtime class behind {}
939 (method `{}
940`)",
941 29usize,
942 __vt.len(),
943 <HubMenu_SystemItem as ::unity::ClassIdentity>::NAME,
944 "GetMapAttribute",
945 )
946 });
947 let __inner: extern "C" fn(HubMenu_SystemItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
948 ::core::mem::transmute(__vi.method_ptr);
949 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
950 __inner(__receiver, __mi)
951 }
952 }
953 }
954 #[doc = "`ACall()` overload"]
955 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
956 unsafe {
957 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
958 {
959 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
960 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
961 panic!(
962 "unity: virtual slot {}
963 out of range (vtable len {}
964) on the runtime class behind {}
965 (method `{}
966`)",
967 18usize,
968 __vt.len(),
969 <HubMenu_SystemItem as ::unity::ClassIdentity>::NAME,
970 "ACall",
971 )
972 });
973 let __inner: extern "C" fn(HubMenu_SystemItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
974 ::core::mem::transmute(__vi.method_ptr);
975 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
976 __inner(__receiver, __mi)
977 }
978 }
979 }
980 #[doc = "`.ctor()` overload"]
981 fn ctor(self) -> () {
982 unsafe {
983 let __receiver = <HubMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
984 ::unity::il2cpp_call!((::unity::module_base()+0x2ae1020usize)as*mut u8,();
985(HubMenu_SystemItem)__receiver)
986 }
987 }
988}
989
990#[cfg(feature = "app-hubmenu")]
991impl<__T: IHubMenu_SystemItem> IHubMenu_SystemItemMethods for __T {}
992
993#[cfg(feature = "app-hubmenu")]
994impl HubMenu_SystemItem {
995 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
996 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
997 }
998
999 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1000 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1001 }
1002
1003 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1004 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1005 }
1006
1007 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1008 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1009 }
1010
1011 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1012 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1013 }
1014
1015 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1016 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1017 }
1018}
1019
1020#[cfg(feature = "app-hubmenu")]
1021impl HubMenu_SystemItem {
1022 #[doc = "Direct (non-virtual) call to `HubMenu_SystemItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1023 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1024 let __mi = Self::get_flag_id_method_info();
1025 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1026 __inner(this.into(), ::core::option::Option::None)
1027 }
1028
1029 #[doc = "Direct (non-virtual) call to `HubMenu_SystemItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1030 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1031 let __mi = Self::get_name_method_info();
1032 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1033 __inner(this.into(), ::core::option::Option::None)
1034 }
1035
1036 #[doc = "Direct (non-virtual) call to `HubMenu_SystemItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1037 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1038 let __mi = Self::get_help_text_method_info();
1039 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1040 __inner(this.into(), ::core::option::Option::None)
1041 }
1042
1043 #[doc = "Direct (non-virtual) call to `HubMenu_SystemItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1044 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1045 let __mi = Self::get_map_attribute_method_info();
1046 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1047 ::core::mem::transmute(__mi.method_ptr);
1048 __inner(this.into(), ::core::option::Option::None)
1049 }
1050
1051 #[doc = "Direct (non-virtual) call to `HubMenu_SystemItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1052 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1053 let __mi = Self::a_call_method_info();
1054 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1055 ::core::mem::transmute(__mi.method_ptr);
1056 __inner(this.into(), ::core::option::Option::None)
1057 }
1058}
1059
1060#[cfg(feature = "app-hubmenu")]
1061impl HubMenu_SystemItem {
1062 #[doc = "`.ctor()` — no args"]
1063 pub fn new() -> Self {
1064 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1065 panic!(
1066 "{}
1067::{}
1068 failed to instantiate",
1069 ::core::stringify!(HubMenu_SystemItem),
1070 ::core::stringify!(new),
1071 )
1072 });
1073 <Self as IHubMenu_SystemItemMethods>::ctor(this);
1074 this
1075 }
1076}
1077
1078#[cfg(feature = "app-hubmenu")]
1079pub trait IHubMenu_NextItemMethods: IHubMenu_NextItem {
1080 #[doc = "`GetName()` overload"]
1081 fn get_name(self) -> ::unity::Il2CppString {
1082 unsafe {
1083 let __receiver = <HubMenu_NextItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1084 {
1085 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1086 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1087 panic!(
1088 "unity: virtual slot {}
1089 out of range (vtable len {}
1090) on the runtime class behind {}
1091 (method `{}
1092`)",
1093 4usize,
1094 __vt.len(),
1095 <HubMenu_NextItem as ::unity::ClassIdentity>::NAME,
1096 "GetName",
1097 )
1098 });
1099 let __inner: extern "C" fn(HubMenu_NextItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1100 ::core::mem::transmute(__vi.method_ptr);
1101 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1102 __inner(__receiver, __mi)
1103 }
1104 }
1105 }
1106 #[doc = "`GetHelpText()` overload"]
1107 fn get_help_text(self) -> ::unity::Il2CppString {
1108 unsafe {
1109 let __receiver = <HubMenu_NextItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1110 {
1111 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1112 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1113 panic!(
1114 "unity: virtual slot {}
1115 out of range (vtable len {}
1116) on the runtime class behind {}
1117 (method `{}
1118`)",
1119 28usize,
1120 __vt.len(),
1121 <HubMenu_NextItem as ::unity::ClassIdentity>::NAME,
1122 "GetHelpText",
1123 )
1124 });
1125 let __inner: extern "C" fn(HubMenu_NextItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1126 ::core::mem::transmute(__vi.method_ptr);
1127 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1128 __inner(__receiver, __mi)
1129 }
1130 }
1131 }
1132 #[doc = "`BuildAttribute()` overload"]
1133 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1134 unsafe {
1135 let __receiver = <HubMenu_NextItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1136 {
1137 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1138 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1139 panic!(
1140 "unity: virtual slot {}
1141 out of range (vtable len {}
1142) on the runtime class behind {}
1143 (method `{}
1144`)",
1145 8usize,
1146 __vt.len(),
1147 <HubMenu_NextItem as ::unity::ClassIdentity>::NAME,
1148 "BuildAttribute",
1149 )
1150 });
1151 let __inner: extern "C" fn(HubMenu_NextItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1152 ::core::mem::transmute(__vi.method_ptr);
1153 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1154 __inner(__receiver, __mi)
1155 }
1156 }
1157 }
1158 #[doc = "`ACall()` overload"]
1159 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1160 unsafe {
1161 let __receiver = <HubMenu_NextItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1162 {
1163 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1164 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1165 panic!(
1166 "unity: virtual slot {}
1167 out of range (vtable len {}
1168) on the runtime class behind {}
1169 (method `{}
1170`)",
1171 18usize,
1172 __vt.len(),
1173 <HubMenu_NextItem as ::unity::ClassIdentity>::NAME,
1174 "ACall",
1175 )
1176 });
1177 let __inner: extern "C" fn(HubMenu_NextItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1178 ::core::mem::transmute(__vi.method_ptr);
1179 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1180 __inner(__receiver, __mi)
1181 }
1182 }
1183 }
1184 #[doc = "`.ctor()` overload"]
1185 fn ctor(self) -> () {
1186 unsafe {
1187 let __receiver = <HubMenu_NextItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1188 ::unity::il2cpp_call!((::unity::module_base()+0x2ae0800usize)as*mut u8,();
1189(HubMenu_NextItem)__receiver)
1190 }
1191 }
1192}
1193
1194#[cfg(feature = "app-hubmenu")]
1195impl<__T: IHubMenu_NextItem> IHubMenu_NextItemMethods for __T {}
1196
1197#[cfg(feature = "app-hubmenu")]
1198impl HubMenu_NextItem {
1199 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1200 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1201 }
1202
1203 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1204 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1205 }
1206
1207 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1208 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1209 }
1210
1211 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1212 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1213 }
1214
1215 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1216 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1217 }
1218}
1219
1220#[cfg(feature = "app-hubmenu")]
1221impl HubMenu_NextItem {
1222 #[doc = "Direct (non-virtual) call to `HubMenu_NextItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1223 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1224 let __mi = Self::get_name_method_info();
1225 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1226 __inner(this.into(), ::core::option::Option::None)
1227 }
1228
1229 #[doc = "Direct (non-virtual) call to `HubMenu_NextItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1230 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1231 let __mi = Self::get_help_text_method_info();
1232 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1233 __inner(this.into(), ::core::option::Option::None)
1234 }
1235
1236 #[doc = "Direct (non-virtual) call to `HubMenu_NextItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1237 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1238 let __mi = Self::build_attribute_method_info();
1239 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1240 ::core::mem::transmute(__mi.method_ptr);
1241 __inner(this.into(), ::core::option::Option::None)
1242 }
1243
1244 #[doc = "Direct (non-virtual) call to `HubMenu_NextItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1245 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1246 let __mi = Self::a_call_method_info();
1247 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1248 ::core::mem::transmute(__mi.method_ptr);
1249 __inner(this.into(), ::core::option::Option::None)
1250 }
1251}
1252
1253#[cfg(feature = "app-hubmenu")]
1254impl HubMenu_NextItem {
1255 #[doc = "`.ctor()` — no args"]
1256 pub fn new() -> Self {
1257 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1258 panic!(
1259 "{}
1260::{}
1261 failed to instantiate",
1262 ::core::stringify!(HubMenu_NextItem),
1263 ::core::stringify!(new),
1264 )
1265 });
1266 <Self as IHubMenu_NextItemMethods>::ctor(this);
1267 this
1268 }
1269}
1270
1271#[cfg(feature = "app-hubmenu")]
1272pub trait IHubMenu_SubFriendMenu_RingListItemMethods: IHubMenu_SubFriendMenu_RingListItem {
1273 #[doc = "`GetName()` overload"]
1274 fn get_name(self) -> ::unity::Il2CppString {
1275 unsafe {
1276 let __receiver =
1277 <HubMenu_SubFriendMenu_RingListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1278 {
1279 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1280 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1281 panic!(
1282 "unity: virtual slot {}
1283 out of range (vtable len {}
1284) on the runtime class behind {}
1285 (method `{}
1286`)",
1287 4usize,
1288 __vt.len(),
1289 <HubMenu_SubFriendMenu_RingListItem as ::unity::ClassIdentity>::NAME,
1290 "GetName",
1291 )
1292 });
1293 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RingListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1294 ::core::mem::transmute(__vi.method_ptr);
1295 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1296 __inner(__receiver, __mi)
1297 }
1298 }
1299 }
1300 #[doc = "`GetHelpText()` overload"]
1301 fn get_help_text(self) -> ::unity::Il2CppString {
1302 unsafe {
1303 let __receiver =
1304 <HubMenu_SubFriendMenu_RingListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1305 {
1306 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1307 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1308 panic!(
1309 "unity: virtual slot {}
1310 out of range (vtable len {}
1311) on the runtime class behind {}
1312 (method `{}
1313`)",
1314 28usize,
1315 __vt.len(),
1316 <HubMenu_SubFriendMenu_RingListItem as ::unity::ClassIdentity>::NAME,
1317 "GetHelpText",
1318 )
1319 });
1320 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RingListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1321 ::core::mem::transmute(__vi.method_ptr);
1322 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1323 __inner(__receiver, __mi)
1324 }
1325 }
1326 }
1327 #[doc = "`BuildAttribute()` overload"]
1328 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1329 unsafe {
1330 let __receiver =
1331 <HubMenu_SubFriendMenu_RingListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1332 {
1333 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1334 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1335 panic!(
1336 "unity: virtual slot {}
1337 out of range (vtable len {}
1338) on the runtime class behind {}
1339 (method `{}
1340`)",
1341 8usize,
1342 __vt.len(),
1343 <HubMenu_SubFriendMenu_RingListItem as ::unity::ClassIdentity>::NAME,
1344 "BuildAttribute",
1345 )
1346 });
1347 let __inner: extern "C" fn(
1348 HubMenu_SubFriendMenu_RingListItem,
1349 ::unity::OptionalMethod,
1350 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1351 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1352 __inner(__receiver, __mi)
1353 }
1354 }
1355 }
1356 #[doc = "`ACall()` overload"]
1357 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1358 unsafe {
1359 let __receiver =
1360 <HubMenu_SubFriendMenu_RingListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1361 {
1362 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1363 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1364 panic!(
1365 "unity: virtual slot {}
1366 out of range (vtable len {}
1367) on the runtime class behind {}
1368 (method `{}
1369`)",
1370 18usize,
1371 __vt.len(),
1372 <HubMenu_SubFriendMenu_RingListItem as ::unity::ClassIdentity>::NAME,
1373 "ACall",
1374 )
1375 });
1376 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RingListItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1377 ::core::mem::transmute(__vi.method_ptr);
1378 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1379 __inner(__receiver, __mi)
1380 }
1381 }
1382 }
1383 #[doc = "`.ctor()` overload"]
1384 fn ctor(self) -> () {
1385 unsafe {
1386 let __receiver =
1387 <HubMenu_SubFriendMenu_RingListItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1388 ::unity::il2cpp_call!((::unity::module_base()+0x1b64dc0usize)as*mut u8,();
1389(HubMenu_SubFriendMenu_RingListItem)__receiver)
1390 }
1391 }
1392}
1393
1394#[cfg(feature = "app-hubmenu")]
1395impl<__T: IHubMenu_SubFriendMenu_RingListItem> IHubMenu_SubFriendMenu_RingListItemMethods for __T {}
1396
1397#[cfg(feature = "app-hubmenu")]
1398impl HubMenu_SubFriendMenu_RingListItem {
1399 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1400 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1401 }
1402
1403 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1404 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1405 }
1406
1407 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1408 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1409 }
1410
1411 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1412 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1413 }
1414
1415 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1416 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1417 }
1418}
1419
1420#[cfg(feature = "app-hubmenu")]
1421impl HubMenu_SubFriendMenu_RingListItem {
1422 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RingListItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1423 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1424 let __mi = Self::get_name_method_info();
1425 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1426 __inner(this.into(), ::core::option::Option::None)
1427 }
1428
1429 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RingListItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1430 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1431 let __mi = Self::get_help_text_method_info();
1432 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1433 __inner(this.into(), ::core::option::Option::None)
1434 }
1435
1436 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RingListItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1437 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1438 let __mi = Self::build_attribute_method_info();
1439 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1440 ::core::mem::transmute(__mi.method_ptr);
1441 __inner(this.into(), ::core::option::Option::None)
1442 }
1443
1444 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RingListItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1445 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1446 let __mi = Self::a_call_method_info();
1447 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1448 ::core::mem::transmute(__mi.method_ptr);
1449 __inner(this.into(), ::core::option::Option::None)
1450 }
1451}
1452
1453#[cfg(feature = "app-hubmenu")]
1454impl HubMenu_SubFriendMenu_RingListItem {
1455 #[doc = "`.ctor()` — no args"]
1456 pub fn new() -> Self {
1457 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1458 panic!(
1459 "{}
1460::{}
1461 failed to instantiate",
1462 ::core::stringify!(HubMenu_SubFriendMenu_RingListItem),
1463 ::core::stringify!(new),
1464 )
1465 });
1466 <Self as IHubMenu_SubFriendMenu_RingListItemMethods>::ctor(this);
1467 this
1468 }
1469}
1470
1471#[cfg(feature = "app-hubmenu")]
1472pub trait IHubMenu_FriendItemMethods: IHubMenu_FriendItem {
1473 #[doc = "`get_FlagID()` overload"]
1474 fn get_flag_id(self) -> ::unity::Il2CppString {
1475 unsafe {
1476 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1477 {
1478 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1479 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1480 panic!(
1481 "unity: virtual slot {}
1482 out of range (vtable len {}
1483) on the runtime class behind {}
1484 (method `{}
1485`)",
1486 27usize,
1487 __vt.len(),
1488 <HubMenu_FriendItem as ::unity::ClassIdentity>::NAME,
1489 "get_FlagID",
1490 )
1491 });
1492 let __inner: extern "C" fn(HubMenu_FriendItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1493 ::core::mem::transmute(__vi.method_ptr);
1494 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1495 __inner(__receiver, __mi)
1496 }
1497 }
1498 }
1499 #[doc = "`GetName()` overload"]
1500 fn get_name(self) -> ::unity::Il2CppString {
1501 unsafe {
1502 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1503 {
1504 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1505 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1506 panic!(
1507 "unity: virtual slot {}
1508 out of range (vtable len {}
1509) on the runtime class behind {}
1510 (method `{}
1511`)",
1512 4usize,
1513 __vt.len(),
1514 <HubMenu_FriendItem as ::unity::ClassIdentity>::NAME,
1515 "GetName",
1516 )
1517 });
1518 let __inner: extern "C" fn(HubMenu_FriendItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1519 ::core::mem::transmute(__vi.method_ptr);
1520 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1521 __inner(__receiver, __mi)
1522 }
1523 }
1524 }
1525 #[doc = "`GetHelpText()` overload"]
1526 fn get_help_text(self) -> ::unity::Il2CppString {
1527 unsafe {
1528 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1529 {
1530 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1531 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1532 panic!(
1533 "unity: virtual slot {}
1534 out of range (vtable len {}
1535) on the runtime class behind {}
1536 (method `{}
1537`)",
1538 28usize,
1539 __vt.len(),
1540 <HubMenu_FriendItem as ::unity::ClassIdentity>::NAME,
1541 "GetHelpText",
1542 )
1543 });
1544 let __inner: extern "C" fn(HubMenu_FriendItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1545 ::core::mem::transmute(__vi.method_ptr);
1546 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1547 __inner(__receiver, __mi)
1548 }
1549 }
1550 }
1551 #[doc = "`GetMapAttribute()` overload"]
1552 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1553 unsafe {
1554 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1555 {
1556 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1557 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1558 panic!(
1559 "unity: virtual slot {}
1560 out of range (vtable len {}
1561) on the runtime class behind {}
1562 (method `{}
1563`)",
1564 29usize,
1565 __vt.len(),
1566 <HubMenu_FriendItem as ::unity::ClassIdentity>::NAME,
1567 "GetMapAttribute",
1568 )
1569 });
1570 let __inner: extern "C" fn(HubMenu_FriendItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1571 ::core::mem::transmute(__vi.method_ptr);
1572 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1573 __inner(__receiver, __mi)
1574 }
1575 }
1576 }
1577 #[doc = "`ACall()` overload"]
1578 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1579 unsafe {
1580 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1581 {
1582 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1583 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1584 panic!(
1585 "unity: virtual slot {}
1586 out of range (vtable len {}
1587) on the runtime class behind {}
1588 (method `{}
1589`)",
1590 18usize,
1591 __vt.len(),
1592 <HubMenu_FriendItem as ::unity::ClassIdentity>::NAME,
1593 "ACall",
1594 )
1595 });
1596 let __inner: extern "C" fn(HubMenu_FriendItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1597 ::core::mem::transmute(__vi.method_ptr);
1598 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1599 __inner(__receiver, __mi)
1600 }
1601 }
1602 }
1603 #[doc = "`.ctor()` overload"]
1604 fn ctor(self) -> () {
1605 unsafe {
1606 let __receiver = <HubMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1607 ::unity::il2cpp_call!((::unity::module_base()+0x2adece0usize)as*mut u8,();
1608(HubMenu_FriendItem)__receiver)
1609 }
1610 }
1611}
1612
1613#[cfg(feature = "app-hubmenu")]
1614impl<__T: IHubMenu_FriendItem> IHubMenu_FriendItemMethods for __T {}
1615
1616#[cfg(feature = "app-hubmenu")]
1617impl HubMenu_FriendItem {
1618 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1619 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1620 }
1621
1622 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1623 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1624 }
1625
1626 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1628 }
1629
1630 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1632 }
1633
1634 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1636 }
1637
1638 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1640 }
1641}
1642
1643#[cfg(feature = "app-hubmenu")]
1644impl HubMenu_FriendItem {
1645 #[doc = "Direct (non-virtual) call to `HubMenu_FriendItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1646 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1647 let __mi = Self::get_flag_id_method_info();
1648 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1649 __inner(this.into(), ::core::option::Option::None)
1650 }
1651
1652 #[doc = "Direct (non-virtual) call to `HubMenu_FriendItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1653 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1654 let __mi = Self::get_name_method_info();
1655 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1656 __inner(this.into(), ::core::option::Option::None)
1657 }
1658
1659 #[doc = "Direct (non-virtual) call to `HubMenu_FriendItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1660 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1661 let __mi = Self::get_help_text_method_info();
1662 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1663 __inner(this.into(), ::core::option::Option::None)
1664 }
1665
1666 #[doc = "Direct (non-virtual) call to `HubMenu_FriendItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1667 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1668 let __mi = Self::get_map_attribute_method_info();
1669 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1670 ::core::mem::transmute(__mi.method_ptr);
1671 __inner(this.into(), ::core::option::Option::None)
1672 }
1673
1674 #[doc = "Direct (non-virtual) call to `HubMenu_FriendItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1675 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1676 let __mi = Self::a_call_method_info();
1677 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1678 ::core::mem::transmute(__mi.method_ptr);
1679 __inner(this.into(), ::core::option::Option::None)
1680 }
1681}
1682
1683#[cfg(feature = "app-hubmenu")]
1684impl HubMenu_FriendItem {
1685 #[doc = "`.ctor()` — no args"]
1686 pub fn new() -> Self {
1687 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1688 panic!(
1689 "{}
1690::{}
1691 failed to instantiate",
1692 ::core::stringify!(HubMenu_FriendItem),
1693 ::core::stringify!(new),
1694 )
1695 });
1696 <Self as IHubMenu_FriendItemMethods>::ctor(this);
1697 this
1698 }
1699}
1700
1701#[cfg(feature = "app-hubmenu")]
1702pub trait IHubMenu_SubFriendMenu_KizunaItemMethods: IHubMenu_SubFriendMenu_KizunaItem {
1703 #[doc = "`GetName()` overload"]
1704 fn get_name(self) -> ::unity::Il2CppString {
1705 unsafe {
1706 let __receiver =
1707 <HubMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1708 {
1709 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1710 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1711 panic!(
1712 "unity: virtual slot {}
1713 out of range (vtable len {}
1714) on the runtime class behind {}
1715 (method `{}
1716`)",
1717 4usize,
1718 __vt.len(),
1719 <HubMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1720 "GetName",
1721 )
1722 });
1723 let __inner: extern "C" fn(HubMenu_SubFriendMenu_KizunaItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1724 ::core::mem::transmute(__vi.method_ptr);
1725 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1726 __inner(__receiver, __mi)
1727 }
1728 }
1729 }
1730 #[doc = "`GetHelpText()` overload"]
1731 fn get_help_text(self) -> ::unity::Il2CppString {
1732 unsafe {
1733 let __receiver =
1734 <HubMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1735 {
1736 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1737 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1738 panic!(
1739 "unity: virtual slot {}
1740 out of range (vtable len {}
1741) on the runtime class behind {}
1742 (method `{}
1743`)",
1744 28usize,
1745 __vt.len(),
1746 <HubMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1747 "GetHelpText",
1748 )
1749 });
1750 let __inner: extern "C" fn(HubMenu_SubFriendMenu_KizunaItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1751 ::core::mem::transmute(__vi.method_ptr);
1752 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1753 __inner(__receiver, __mi)
1754 }
1755 }
1756 }
1757 #[doc = "`BuildAttribute()` overload"]
1758 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1759 unsafe {
1760 let __receiver =
1761 <HubMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1762 {
1763 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1764 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1765 panic!(
1766 "unity: virtual slot {}
1767 out of range (vtable len {}
1768) on the runtime class behind {}
1769 (method `{}
1770`)",
1771 8usize,
1772 __vt.len(),
1773 <HubMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1774 "BuildAttribute",
1775 )
1776 });
1777 let __inner: extern "C" fn(
1778 HubMenu_SubFriendMenu_KizunaItem,
1779 ::unity::OptionalMethod,
1780 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1781 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1782 __inner(__receiver, __mi)
1783 }
1784 }
1785 }
1786 #[doc = "`ACall()` overload"]
1787 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1788 unsafe {
1789 let __receiver =
1790 <HubMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1791 {
1792 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1793 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1794 panic!(
1795 "unity: virtual slot {}
1796 out of range (vtable len {}
1797) on the runtime class behind {}
1798 (method `{}
1799`)",
1800 18usize,
1801 __vt.len(),
1802 <HubMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1803 "ACall",
1804 )
1805 });
1806 let __inner: extern "C" fn(HubMenu_SubFriendMenu_KizunaItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1807 ::core::mem::transmute(__vi.method_ptr);
1808 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1809 __inner(__receiver, __mi)
1810 }
1811 }
1812 }
1813 #[doc = "`.ctor()` overload"]
1814 fn ctor(self) -> () {
1815 unsafe {
1816 let __receiver =
1817 <HubMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1818 ::unity::il2cpp_call!((::unity::module_base()+0x1b64170usize)as*mut u8,();
1819(HubMenu_SubFriendMenu_KizunaItem)__receiver)
1820 }
1821 }
1822}
1823
1824#[cfg(feature = "app-hubmenu")]
1825impl<__T: IHubMenu_SubFriendMenu_KizunaItem> IHubMenu_SubFriendMenu_KizunaItemMethods for __T {}
1826
1827#[cfg(feature = "app-hubmenu")]
1828impl HubMenu_SubFriendMenu_KizunaItem {
1829 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1831 }
1832
1833 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1835 }
1836
1837 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1839 }
1840
1841 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1843 }
1844
1845 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1847 }
1848}
1849
1850#[cfg(feature = "app-hubmenu")]
1851impl HubMenu_SubFriendMenu_KizunaItem {
1852 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_KizunaItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1853 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1854 let __mi = Self::get_name_method_info();
1855 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1856 __inner(this.into(), ::core::option::Option::None)
1857 }
1858
1859 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_KizunaItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1860 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1861 let __mi = Self::get_help_text_method_info();
1862 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1863 __inner(this.into(), ::core::option::Option::None)
1864 }
1865
1866 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_KizunaItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1867 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1868 let __mi = Self::build_attribute_method_info();
1869 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1870 ::core::mem::transmute(__mi.method_ptr);
1871 __inner(this.into(), ::core::option::Option::None)
1872 }
1873
1874 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_KizunaItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1875 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1876 let __mi = Self::a_call_method_info();
1877 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1878 ::core::mem::transmute(__mi.method_ptr);
1879 __inner(this.into(), ::core::option::Option::None)
1880 }
1881}
1882
1883#[cfg(feature = "app-hubmenu")]
1884impl HubMenu_SubFriendMenu_KizunaItem {
1885 #[doc = "`.ctor()` — no args"]
1886 pub fn new() -> Self {
1887 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1888 panic!(
1889 "{}
1890::{}
1891 failed to instantiate",
1892 ::core::stringify!(HubMenu_SubFriendMenu_KizunaItem),
1893 ::core::stringify!(new),
1894 )
1895 });
1896 <Self as IHubMenu_SubFriendMenu_KizunaItemMethods>::ctor(this);
1897 this
1898 }
1899}
1900
1901#[cfg(feature = "app-hubmenu")]
1902pub trait IHubMenu_HubMenuItemMethods: IHubMenu_HubMenuItem {
1903 #[doc = "`BCall()` overload"]
1904 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1905 unsafe {
1906 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1907 {
1908 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1909 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1910 panic!(
1911 "unity: virtual slot {}
1912 out of range (vtable len {}
1913) on the runtime class behind {}
1914 (method `{}
1915`)",
1916 19usize,
1917 __vt.len(),
1918 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
1919 "BCall",
1920 )
1921 });
1922 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1923 ::core::mem::transmute(__vi.method_ptr);
1924 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1925 __inner(__receiver, __mi)
1926 }
1927 }
1928 }
1929 #[doc = "`SetHelpVisible(bool)` overload"]
1930 fn set_help_visible(self, active: impl ::core::convert::Into<bool>) -> () {
1931 unsafe {
1932 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1933 ::unity::il2cpp_call!((::unity::module_base()+0x2adf480usize)as*mut u8,();
1934(HubMenu_HubMenuItem)__receiver,(bool)::core::convert::Into::into(active))
1935 }
1936 }
1937 #[doc = "`GetMapAttribute()` overload"]
1938 fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1939 unsafe {
1940 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1941 {
1942 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1943 let __vi = *__vt.get(29usize).unwrap_or_else(|| {
1944 panic!(
1945 "unity: virtual slot {}
1946 out of range (vtable len {}
1947) on the runtime class behind {}
1948 (method `{}
1949`)",
1950 29usize,
1951 __vt.len(),
1952 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
1953 "GetMapAttribute",
1954 )
1955 });
1956 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1957 ::core::mem::transmute(__vi.method_ptr);
1958 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1959 __inner(__receiver, __mi)
1960 }
1961 }
1962 }
1963 #[doc = "`get_FlagID()` overload"]
1964 fn get_flag_id(self) -> ::unity::Il2CppString {
1965 unsafe {
1966 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1967 {
1968 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1969 let __vi = *__vt.get(27usize).unwrap_or_else(|| {
1970 panic!(
1971 "unity: virtual slot {}
1972 out of range (vtable len {}
1973) on the runtime class behind {}
1974 (method `{}
1975`)",
1976 27usize,
1977 __vt.len(),
1978 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
1979 "get_FlagID",
1980 )
1981 });
1982 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1983 ::core::mem::transmute(__vi.method_ptr);
1984 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1985 __inner(__receiver, __mi)
1986 }
1987 }
1988 }
1989 #[doc = "`GetHelpText()` overload"]
1990 fn get_help_text(self) -> ::unity::Il2CppString {
1991 unsafe {
1992 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1993 {
1994 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1995 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1996 panic!(
1997 "unity: virtual slot {}
1998 out of range (vtable len {}
1999) on the runtime class behind {}
2000 (method `{}
2001`)",
2002 28usize,
2003 __vt.len(),
2004 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
2005 "GetHelpText",
2006 )
2007 });
2008 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2009 ::core::mem::transmute(__vi.method_ptr);
2010 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2011 __inner(__receiver, __mi)
2012 }
2013 }
2014 }
2015 #[doc = "`OnSelect()` overload"]
2016 fn on_select(self) -> () {
2017 unsafe {
2018 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2019 {
2020 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2021 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2022 panic!(
2023 "unity: virtual slot {}
2024 out of range (vtable len {}
2025) on the runtime class behind {}
2026 (method `{}
2027`)",
2028 12usize,
2029 __vt.len(),
2030 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
2031 "OnSelect",
2032 )
2033 });
2034 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2035 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2036 __inner(__receiver, __mi)
2037 }
2038 }
2039 }
2040 #[doc = "`OnDeselect()` overload"]
2041 fn on_deselect(self) -> () {
2042 unsafe {
2043 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2044 {
2045 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2046 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2047 panic!(
2048 "unity: virtual slot {}
2049 out of range (vtable len {}
2050) on the runtime class behind {}
2051 (method `{}
2052`)",
2053 13usize,
2054 __vt.len(),
2055 <HubMenu_HubMenuItem as ::unity::ClassIdentity>::NAME,
2056 "OnDeselect",
2057 )
2058 });
2059 let __inner: extern "C" fn(HubMenu_HubMenuItem, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
2060 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2061 __inner(__receiver, __mi)
2062 }
2063 }
2064 }
2065 #[doc = "`.ctor()` overload"]
2066 fn ctor(self) -> () {
2067 unsafe {
2068 let __receiver = <HubMenu_HubMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2069 ::unity::il2cpp_call!((::unity::module_base()+0x2adecf0usize)as*mut u8,();
2070(HubMenu_HubMenuItem)__receiver)
2071 }
2072 }
2073}
2074
2075#[cfg(feature = "app-hubmenu")]
2076impl<__T: IHubMenu_HubMenuItem> IHubMenu_HubMenuItemMethods for __T {}
2077
2078#[cfg(feature = "app-hubmenu")]
2079impl HubMenu_HubMenuItem {
2080 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2081 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2082 }
2083
2084 pub fn set_help_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2085 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2086 }
2087
2088 pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2089 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2090 }
2091
2092 pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2093 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2094 }
2095
2096 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2097 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2098 }
2099
2100 pub fn on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2101 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2102 }
2103
2104 pub fn on_deselect_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2105 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2106 }
2107
2108 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2109 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2110 }
2111}
2112
2113#[cfg(feature = "app-hubmenu")]
2114impl HubMenu_HubMenuItem {
2115 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2116 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2117 let __mi = Self::b_call_method_info();
2118 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2119 ::core::mem::transmute(__mi.method_ptr);
2120 __inner(this.into(), ::core::option::Option::None)
2121 }
2122
2123 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2124 pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2125 let __mi = Self::get_map_attribute_method_info();
2126 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2127 ::core::mem::transmute(__mi.method_ptr);
2128 __inner(this.into(), ::core::option::Option::None)
2129 }
2130
2131 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2132 pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2133 let __mi = Self::get_flag_id_method_info();
2134 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2135 __inner(this.into(), ::core::option::Option::None)
2136 }
2137
2138 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2139 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2140 let __mi = Self::get_help_text_method_info();
2141 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2142 __inner(this.into(), ::core::option::Option::None)
2143 }
2144
2145 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `OnSelect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2146 pub unsafe fn on_select(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2147 let __mi = Self::on_select_method_info();
2148 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2149 __inner(this.into(), ::core::option::Option::None)
2150 }
2151
2152 #[doc = "Direct (non-virtual) call to `HubMenu_HubMenuItem`'s own `OnDeselect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2153 pub unsafe fn on_deselect(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2154 let __mi = Self::on_deselect_method_info();
2155 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2156 __inner(this.into(), ::core::option::Option::None)
2157 }
2158}
2159
2160#[cfg(feature = "app-hubmenu")]
2161impl HubMenu_HubMenuItem {
2162 #[doc = "`.ctor()` — no args"]
2163 pub fn new() -> Self {
2164 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2165 panic!(
2166 "{}
2167::{}
2168 failed to instantiate",
2169 ::core::stringify!(HubMenu_HubMenuItem),
2170 ::core::stringify!(new),
2171 )
2172 });
2173 <Self as IHubMenu_HubMenuItemMethods>::ctor(this);
2174 this
2175 }
2176}
2177
2178#[cfg(feature = "app-hubmenu")]
2179pub trait IHubMenu_NextChapterItemMethods: IHubMenu_NextChapterItem {
2180 #[doc = "`GetName()` overload"]
2181 fn get_name(self) -> ::unity::Il2CppString {
2182 unsafe {
2183 let __receiver =
2184 <HubMenu_NextChapterItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2185 {
2186 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2187 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2188 panic!(
2189 "unity: virtual slot {}
2190 out of range (vtable len {}
2191) on the runtime class behind {}
2192 (method `{}
2193`)",
2194 4usize,
2195 __vt.len(),
2196 <HubMenu_NextChapterItem as ::unity::ClassIdentity>::NAME,
2197 "GetName",
2198 )
2199 });
2200 let __inner: extern "C" fn(HubMenu_NextChapterItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2201 ::core::mem::transmute(__vi.method_ptr);
2202 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2203 __inner(__receiver, __mi)
2204 }
2205 }
2206 }
2207 #[doc = "`GetHelpText()` overload"]
2208 fn get_help_text(self) -> ::unity::Il2CppString {
2209 unsafe {
2210 let __receiver =
2211 <HubMenu_NextChapterItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2212 {
2213 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2214 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2215 panic!(
2216 "unity: virtual slot {}
2217 out of range (vtable len {}
2218) on the runtime class behind {}
2219 (method `{}
2220`)",
2221 28usize,
2222 __vt.len(),
2223 <HubMenu_NextChapterItem as ::unity::ClassIdentity>::NAME,
2224 "GetHelpText",
2225 )
2226 });
2227 let __inner: extern "C" fn(HubMenu_NextChapterItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2228 ::core::mem::transmute(__vi.method_ptr);
2229 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2230 __inner(__receiver, __mi)
2231 }
2232 }
2233 }
2234 #[doc = "`BuildAttribute()` overload"]
2235 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2236 unsafe {
2237 let __receiver =
2238 <HubMenu_NextChapterItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2239 {
2240 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2241 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2242 panic!(
2243 "unity: virtual slot {}
2244 out of range (vtable len {}
2245) on the runtime class behind {}
2246 (method `{}
2247`)",
2248 8usize,
2249 __vt.len(),
2250 <HubMenu_NextChapterItem as ::unity::ClassIdentity>::NAME,
2251 "BuildAttribute",
2252 )
2253 });
2254 let __inner: extern "C" fn(HubMenu_NextChapterItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2255 ::core::mem::transmute(__vi.method_ptr);
2256 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2257 __inner(__receiver, __mi)
2258 }
2259 }
2260 }
2261 #[doc = "`ACall()` overload"]
2262 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2263 unsafe {
2264 let __receiver =
2265 <HubMenu_NextChapterItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2266 {
2267 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2268 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2269 panic!(
2270 "unity: virtual slot {}
2271 out of range (vtable len {}
2272) on the runtime class behind {}
2273 (method `{}
2274`)",
2275 18usize,
2276 __vt.len(),
2277 <HubMenu_NextChapterItem as ::unity::ClassIdentity>::NAME,
2278 "ACall",
2279 )
2280 });
2281 let __inner: extern "C" fn(HubMenu_NextChapterItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2282 ::core::mem::transmute(__vi.method_ptr);
2283 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2284 __inner(__receiver, __mi)
2285 }
2286 }
2287 }
2288 #[doc = "`.ctor()` overload"]
2289 fn ctor(self) -> () {
2290 unsafe {
2291 let __receiver =
2292 <HubMenu_NextChapterItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2293 ::unity::il2cpp_call!((::unity::module_base()+0x2ae04e0usize)as*mut u8,();
2294(HubMenu_NextChapterItem)__receiver)
2295 }
2296 }
2297}
2298
2299#[cfg(feature = "app-hubmenu")]
2300impl<__T: IHubMenu_NextChapterItem> IHubMenu_NextChapterItemMethods for __T {}
2301
2302#[cfg(feature = "app-hubmenu")]
2303impl HubMenu_NextChapterItem {
2304 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2305 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2306 }
2307
2308 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2309 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2310 }
2311
2312 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2313 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2314 }
2315
2316 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2317 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2318 }
2319
2320 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2321 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2322 }
2323}
2324
2325#[cfg(feature = "app-hubmenu")]
2326impl HubMenu_NextChapterItem {
2327 #[doc = "Direct (non-virtual) call to `HubMenu_NextChapterItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2328 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2329 let __mi = Self::get_name_method_info();
2330 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2331 __inner(this.into(), ::core::option::Option::None)
2332 }
2333
2334 #[doc = "Direct (non-virtual) call to `HubMenu_NextChapterItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2335 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2336 let __mi = Self::get_help_text_method_info();
2337 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2338 __inner(this.into(), ::core::option::Option::None)
2339 }
2340
2341 #[doc = "Direct (non-virtual) call to `HubMenu_NextChapterItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2342 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2343 let __mi = Self::build_attribute_method_info();
2344 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2345 ::core::mem::transmute(__mi.method_ptr);
2346 __inner(this.into(), ::core::option::Option::None)
2347 }
2348
2349 #[doc = "Direct (non-virtual) call to `HubMenu_NextChapterItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2350 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2351 let __mi = Self::a_call_method_info();
2352 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2353 ::core::mem::transmute(__mi.method_ptr);
2354 __inner(this.into(), ::core::option::Option::None)
2355 }
2356}
2357
2358#[cfg(feature = "app-hubmenu")]
2359impl HubMenu_NextChapterItem {
2360 #[doc = "`.ctor()` — no args"]
2361 pub fn new() -> Self {
2362 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2363 panic!(
2364 "{}
2365::{}
2366 failed to instantiate",
2367 ::core::stringify!(HubMenu_NextChapterItem),
2368 ::core::stringify!(new),
2369 )
2370 });
2371 <Self as IHubMenu_NextChapterItemMethods>::ctor(this);
2372 this
2373 }
2374}
2375
2376#[cfg(feature = "app-hubmenu")]
2377pub trait IHubMenu_SubFriendMenu_NotebookItemMethods: IHubMenu_SubFriendMenu_NotebookItem {
2378 #[doc = "`GetName()` overload"]
2379 fn get_name(self) -> ::unity::Il2CppString {
2380 unsafe {
2381 let __receiver =
2382 <HubMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2383 {
2384 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2385 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2386 panic!(
2387 "unity: virtual slot {}
2388 out of range (vtable len {}
2389) on the runtime class behind {}
2390 (method `{}
2391`)",
2392 4usize,
2393 __vt.len(),
2394 <HubMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
2395 "GetName",
2396 )
2397 });
2398 let __inner: extern "C" fn(HubMenu_SubFriendMenu_NotebookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2399 ::core::mem::transmute(__vi.method_ptr);
2400 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2401 __inner(__receiver, __mi)
2402 }
2403 }
2404 }
2405 #[doc = "`GetHelpText()` overload"]
2406 fn get_help_text(self) -> ::unity::Il2CppString {
2407 unsafe {
2408 let __receiver =
2409 <HubMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2410 {
2411 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2412 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2413 panic!(
2414 "unity: virtual slot {}
2415 out of range (vtable len {}
2416) on the runtime class behind {}
2417 (method `{}
2418`)",
2419 28usize,
2420 __vt.len(),
2421 <HubMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
2422 "GetHelpText",
2423 )
2424 });
2425 let __inner: extern "C" fn(HubMenu_SubFriendMenu_NotebookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2426 ::core::mem::transmute(__vi.method_ptr);
2427 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2428 __inner(__receiver, __mi)
2429 }
2430 }
2431 }
2432 #[doc = "`BuildAttribute()` overload"]
2433 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2434 unsafe {
2435 let __receiver =
2436 <HubMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2437 {
2438 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2439 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2440 panic!(
2441 "unity: virtual slot {}
2442 out of range (vtable len {}
2443) on the runtime class behind {}
2444 (method `{}
2445`)",
2446 8usize,
2447 __vt.len(),
2448 <HubMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
2449 "BuildAttribute",
2450 )
2451 });
2452 let __inner: extern "C" fn(
2453 HubMenu_SubFriendMenu_NotebookItem,
2454 ::unity::OptionalMethod,
2455 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2456 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2457 __inner(__receiver, __mi)
2458 }
2459 }
2460 }
2461 #[doc = "`ACall()` overload"]
2462 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2463 unsafe {
2464 let __receiver =
2465 <HubMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2466 {
2467 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2468 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2469 panic!(
2470 "unity: virtual slot {}
2471 out of range (vtable len {}
2472) on the runtime class behind {}
2473 (method `{}
2474`)",
2475 18usize,
2476 __vt.len(),
2477 <HubMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
2478 "ACall",
2479 )
2480 });
2481 let __inner: extern "C" fn(HubMenu_SubFriendMenu_NotebookItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2482 ::core::mem::transmute(__vi.method_ptr);
2483 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2484 __inner(__receiver, __mi)
2485 }
2486 }
2487 }
2488 #[doc = "`.ctor()` overload"]
2489 fn ctor(self) -> () {
2490 unsafe {
2491 let __receiver =
2492 <HubMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2493 ::unity::il2cpp_call!((::unity::module_base()+0x1b64410usize)as*mut u8,();
2494(HubMenu_SubFriendMenu_NotebookItem)__receiver)
2495 }
2496 }
2497}
2498
2499#[cfg(feature = "app-hubmenu")]
2500impl<__T: IHubMenu_SubFriendMenu_NotebookItem> IHubMenu_SubFriendMenu_NotebookItemMethods for __T {}
2501
2502#[cfg(feature = "app-hubmenu")]
2503impl HubMenu_SubFriendMenu_NotebookItem {
2504 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2505 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2506 }
2507
2508 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2509 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2510 }
2511
2512 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2513 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2514 }
2515
2516 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2517 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2518 }
2519
2520 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2522 }
2523}
2524
2525#[cfg(feature = "app-hubmenu")]
2526impl HubMenu_SubFriendMenu_NotebookItem {
2527 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_NotebookItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2528 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2529 let __mi = Self::get_name_method_info();
2530 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2531 __inner(this.into(), ::core::option::Option::None)
2532 }
2533
2534 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_NotebookItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2535 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2536 let __mi = Self::get_help_text_method_info();
2537 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2538 __inner(this.into(), ::core::option::Option::None)
2539 }
2540
2541 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_NotebookItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2542 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2543 let __mi = Self::build_attribute_method_info();
2544 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2545 ::core::mem::transmute(__mi.method_ptr);
2546 __inner(this.into(), ::core::option::Option::None)
2547 }
2548
2549 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_NotebookItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2550 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2551 let __mi = Self::a_call_method_info();
2552 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2553 ::core::mem::transmute(__mi.method_ptr);
2554 __inner(this.into(), ::core::option::Option::None)
2555 }
2556}
2557
2558#[cfg(feature = "app-hubmenu")]
2559impl HubMenu_SubFriendMenu_NotebookItem {
2560 #[doc = "`.ctor()` — no args"]
2561 pub fn new() -> Self {
2562 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2563 panic!(
2564 "{}
2565::{}
2566 failed to instantiate",
2567 ::core::stringify!(HubMenu_SubFriendMenu_NotebookItem),
2568 ::core::stringify!(new),
2569 )
2570 });
2571 <Self as IHubMenu_SubFriendMenu_NotebookItemMethods>::ctor(this);
2572 this
2573 }
2574}
2575
2576#[cfg(feature = "app-hubmenu")]
2577pub trait IHubMenu_SubFriendMenu_RelianceItemMethods: IHubMenu_SubFriendMenu_RelianceItem {
2578 #[doc = "`BCall()` overload"]
2579 fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2580 unsafe {
2581 let __receiver =
2582 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2583 {
2584 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2585 let __vi = *__vt.get(19usize).unwrap_or_else(|| {
2586 panic!(
2587 "unity: virtual slot {}
2588 out of range (vtable len {}
2589) on the runtime class behind {}
2590 (method `{}
2591`)",
2592 19usize,
2593 __vt.len(),
2594 <HubMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
2595 "BCall",
2596 )
2597 });
2598 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2599 ::core::mem::transmute(__vi.method_ptr);
2600 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2601 __inner(__receiver, __mi)
2602 }
2603 }
2604 }
2605 #[doc = "`GetName()` overload"]
2606 fn get_name(self) -> ::unity::Il2CppString {
2607 unsafe {
2608 let __receiver =
2609 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2610 {
2611 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2612 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2613 panic!(
2614 "unity: virtual slot {}
2615 out of range (vtable len {}
2616) on the runtime class behind {}
2617 (method `{}
2618`)",
2619 4usize,
2620 __vt.len(),
2621 <HubMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
2622 "GetName",
2623 )
2624 });
2625 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2626 ::core::mem::transmute(__vi.method_ptr);
2627 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2628 __inner(__receiver, __mi)
2629 }
2630 }
2631 }
2632 #[doc = "`GetHelpText()` overload"]
2633 fn get_help_text(self) -> ::unity::Il2CppString {
2634 unsafe {
2635 let __receiver =
2636 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2637 {
2638 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2639 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2640 panic!(
2641 "unity: virtual slot {}
2642 out of range (vtable len {}
2643) on the runtime class behind {}
2644 (method `{}
2645`)",
2646 28usize,
2647 __vt.len(),
2648 <HubMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
2649 "GetHelpText",
2650 )
2651 });
2652 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2653 ::core::mem::transmute(__vi.method_ptr);
2654 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2655 __inner(__receiver, __mi)
2656 }
2657 }
2658 }
2659 #[doc = "`BuildAttribute()` overload"]
2660 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2661 unsafe {
2662 let __receiver =
2663 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2664 {
2665 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2666 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2667 panic!(
2668 "unity: virtual slot {}
2669 out of range (vtable len {}
2670) on the runtime class behind {}
2671 (method `{}
2672`)",
2673 8usize,
2674 __vt.len(),
2675 <HubMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
2676 "BuildAttribute",
2677 )
2678 });
2679 let __inner: extern "C" fn(
2680 HubMenu_SubFriendMenu_RelianceItem,
2681 ::unity::OptionalMethod,
2682 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2683 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2684 __inner(__receiver, __mi)
2685 }
2686 }
2687 }
2688 #[doc = "`ACall()` overload"]
2689 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2690 unsafe {
2691 let __receiver =
2692 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2693 {
2694 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2695 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2696 panic!(
2697 "unity: virtual slot {}
2698 out of range (vtable len {}
2699) on the runtime class behind {}
2700 (method `{}
2701`)",
2702 18usize,
2703 __vt.len(),
2704 <HubMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
2705 "ACall",
2706 )
2707 });
2708 let __inner: extern "C" fn(HubMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2709 ::core::mem::transmute(__vi.method_ptr);
2710 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2711 __inner(__receiver, __mi)
2712 }
2713 }
2714 }
2715 #[doc = "`.ctor()` overload"]
2716 fn ctor(self) -> () {
2717 unsafe {
2718 let __receiver =
2719 <HubMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2720 ::unity::il2cpp_call!((::unity::module_base()+0x1b64b00usize)as*mut u8,();
2721(HubMenu_SubFriendMenu_RelianceItem)__receiver)
2722 }
2723 }
2724}
2725
2726#[cfg(feature = "app-hubmenu")]
2727impl<__T: IHubMenu_SubFriendMenu_RelianceItem> IHubMenu_SubFriendMenu_RelianceItemMethods for __T {}
2728
2729#[cfg(feature = "app-hubmenu")]
2730impl HubMenu_SubFriendMenu_RelianceItem {
2731 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2732 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2733 }
2734
2735 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2736 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2737 }
2738
2739 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2740 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2741 }
2742
2743 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2745 }
2746
2747 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2748 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2749 }
2750
2751 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2752 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2753 }
2754}
2755
2756#[cfg(feature = "app-hubmenu")]
2757impl HubMenu_SubFriendMenu_RelianceItem {
2758 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RelianceItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2759 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2760 let __mi = Self::b_call_method_info();
2761 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2762 ::core::mem::transmute(__mi.method_ptr);
2763 __inner(this.into(), ::core::option::Option::None)
2764 }
2765
2766 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RelianceItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2767 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2768 let __mi = Self::get_name_method_info();
2769 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2770 __inner(this.into(), ::core::option::Option::None)
2771 }
2772
2773 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RelianceItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2774 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2775 let __mi = Self::get_help_text_method_info();
2776 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2777 __inner(this.into(), ::core::option::Option::None)
2778 }
2779
2780 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RelianceItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2781 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2782 let __mi = Self::build_attribute_method_info();
2783 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2784 ::core::mem::transmute(__mi.method_ptr);
2785 __inner(this.into(), ::core::option::Option::None)
2786 }
2787
2788 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_RelianceItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2789 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2790 let __mi = Self::a_call_method_info();
2791 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2792 ::core::mem::transmute(__mi.method_ptr);
2793 __inner(this.into(), ::core::option::Option::None)
2794 }
2795}
2796
2797#[cfg(feature = "app-hubmenu")]
2798impl HubMenu_SubFriendMenu_RelianceItem {
2799 #[doc = "`.ctor()` — no args"]
2800 pub fn new() -> Self {
2801 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2802 panic!(
2803 "{}
2804::{}
2805 failed to instantiate",
2806 ::core::stringify!(HubMenu_SubFriendMenu_RelianceItem),
2807 ::core::stringify!(new),
2808 )
2809 });
2810 <Self as IHubMenu_SubFriendMenu_RelianceItemMethods>::ctor(this);
2811 this
2812 }
2813}
2814
2815#[cfg(feature = "app-hubmenu")]
2816pub trait IHubMenu_SaveItemMethods: IHubMenu_SaveItem {
2817 #[doc = "`GetName()` overload"]
2818 fn get_name(self) -> ::unity::Il2CppString {
2819 unsafe {
2820 let __receiver = <HubMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2821 {
2822 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2823 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2824 panic!(
2825 "unity: virtual slot {}
2826 out of range (vtable len {}
2827) on the runtime class behind {}
2828 (method `{}
2829`)",
2830 4usize,
2831 __vt.len(),
2832 <HubMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2833 "GetName",
2834 )
2835 });
2836 let __inner: extern "C" fn(HubMenu_SaveItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2837 ::core::mem::transmute(__vi.method_ptr);
2838 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2839 __inner(__receiver, __mi)
2840 }
2841 }
2842 }
2843 #[doc = "`GetHelpText()` overload"]
2844 fn get_help_text(self) -> ::unity::Il2CppString {
2845 unsafe {
2846 let __receiver = <HubMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2847 {
2848 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2849 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2850 panic!(
2851 "unity: virtual slot {}
2852 out of range (vtable len {}
2853) on the runtime class behind {}
2854 (method `{}
2855`)",
2856 28usize,
2857 __vt.len(),
2858 <HubMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2859 "GetHelpText",
2860 )
2861 });
2862 let __inner: extern "C" fn(HubMenu_SaveItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2863 ::core::mem::transmute(__vi.method_ptr);
2864 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2865 __inner(__receiver, __mi)
2866 }
2867 }
2868 }
2869 #[doc = "`BuildAttribute()` overload"]
2870 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2871 unsafe {
2872 let __receiver = <HubMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2873 {
2874 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2875 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2876 panic!(
2877 "unity: virtual slot {}
2878 out of range (vtable len {}
2879) on the runtime class behind {}
2880 (method `{}
2881`)",
2882 8usize,
2883 __vt.len(),
2884 <HubMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2885 "BuildAttribute",
2886 )
2887 });
2888 let __inner: extern "C" fn(HubMenu_SaveItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2889 ::core::mem::transmute(__vi.method_ptr);
2890 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2891 __inner(__receiver, __mi)
2892 }
2893 }
2894 }
2895 #[doc = "`ACall()` overload"]
2896 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2897 unsafe {
2898 let __receiver = <HubMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2899 {
2900 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2901 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2902 panic!(
2903 "unity: virtual slot {}
2904 out of range (vtable len {}
2905) on the runtime class behind {}
2906 (method `{}
2907`)",
2908 18usize,
2909 __vt.len(),
2910 <HubMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2911 "ACall",
2912 )
2913 });
2914 let __inner: extern "C" fn(HubMenu_SaveItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2915 ::core::mem::transmute(__vi.method_ptr);
2916 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2917 __inner(__receiver, __mi)
2918 }
2919 }
2920 }
2921 #[doc = "`.ctor()` overload"]
2922 fn ctor(self) -> () {
2923 unsafe {
2924 let __receiver = <HubMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2925 ::unity::il2cpp_call!((::unity::module_base()+0x2ae0b20usize)as*mut u8,();
2926(HubMenu_SaveItem)__receiver)
2927 }
2928 }
2929}
2930
2931#[cfg(feature = "app-hubmenu")]
2932impl<__T: IHubMenu_SaveItem> IHubMenu_SaveItemMethods for __T {}
2933
2934#[cfg(feature = "app-hubmenu")]
2935impl HubMenu_SaveItem {
2936 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2937 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2938 }
2939
2940 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2942 }
2943
2944 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2945 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2946 }
2947
2948 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2949 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2950 }
2951
2952 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2953 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2954 }
2955}
2956
2957#[cfg(feature = "app-hubmenu")]
2958impl HubMenu_SaveItem {
2959 #[doc = "Direct (non-virtual) call to `HubMenu_SaveItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2960 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2961 let __mi = Self::get_name_method_info();
2962 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2963 __inner(this.into(), ::core::option::Option::None)
2964 }
2965
2966 #[doc = "Direct (non-virtual) call to `HubMenu_SaveItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2967 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2968 let __mi = Self::get_help_text_method_info();
2969 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2970 __inner(this.into(), ::core::option::Option::None)
2971 }
2972
2973 #[doc = "Direct (non-virtual) call to `HubMenu_SaveItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2974 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2975 let __mi = Self::build_attribute_method_info();
2976 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2977 ::core::mem::transmute(__mi.method_ptr);
2978 __inner(this.into(), ::core::option::Option::None)
2979 }
2980
2981 #[doc = "Direct (non-virtual) call to `HubMenu_SaveItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2982 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2983 let __mi = Self::a_call_method_info();
2984 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2985 ::core::mem::transmute(__mi.method_ptr);
2986 __inner(this.into(), ::core::option::Option::None)
2987 }
2988}
2989
2990#[cfg(feature = "app-hubmenu")]
2991impl HubMenu_SaveItem {
2992 #[doc = "`.ctor()` — no args"]
2993 pub fn new() -> Self {
2994 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2995 panic!(
2996 "{}
2997::{}
2998 failed to instantiate",
2999 ::core::stringify!(HubMenu_SaveItem),
3000 ::core::stringify!(new),
3001 )
3002 });
3003 <Self as IHubMenu_SaveItemMethods>::ctor(this);
3004 this
3005 }
3006}
3007
3008#[cfg(feature = "app-hubmenu")]
3009pub trait IHubMenu_SubSystemMenu_ConfigItemMethods: IHubMenu_SubSystemMenu_ConfigItem {
3010 #[doc = "`GetName()` overload"]
3011 fn get_name(self) -> ::unity::Il2CppString {
3012 unsafe {
3013 let __receiver =
3014 <HubMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3015 {
3016 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3017 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3018 panic!(
3019 "unity: virtual slot {}
3020 out of range (vtable len {}
3021) on the runtime class behind {}
3022 (method `{}
3023`)",
3024 4usize,
3025 __vt.len(),
3026 <HubMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
3027 "GetName",
3028 )
3029 });
3030 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ConfigItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3031 ::core::mem::transmute(__vi.method_ptr);
3032 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3033 __inner(__receiver, __mi)
3034 }
3035 }
3036 }
3037 #[doc = "`GetHelpText()` overload"]
3038 fn get_help_text(self) -> ::unity::Il2CppString {
3039 unsafe {
3040 let __receiver =
3041 <HubMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3042 {
3043 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3044 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3045 panic!(
3046 "unity: virtual slot {}
3047 out of range (vtable len {}
3048) on the runtime class behind {}
3049 (method `{}
3050`)",
3051 28usize,
3052 __vt.len(),
3053 <HubMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
3054 "GetHelpText",
3055 )
3056 });
3057 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ConfigItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3058 ::core::mem::transmute(__vi.method_ptr);
3059 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3060 __inner(__receiver, __mi)
3061 }
3062 }
3063 }
3064 #[doc = "`BuildAttribute()` overload"]
3065 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3066 unsafe {
3067 let __receiver =
3068 <HubMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3069 {
3070 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3071 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3072 panic!(
3073 "unity: virtual slot {}
3074 out of range (vtable len {}
3075) on the runtime class behind {}
3076 (method `{}
3077`)",
3078 8usize,
3079 __vt.len(),
3080 <HubMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
3081 "BuildAttribute",
3082 )
3083 });
3084 let __inner: extern "C" fn(
3085 HubMenu_SubSystemMenu_ConfigItem,
3086 ::unity::OptionalMethod,
3087 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3088 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3089 __inner(__receiver, __mi)
3090 }
3091 }
3092 }
3093 #[doc = "`ACall()` overload"]
3094 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3095 unsafe {
3096 let __receiver =
3097 <HubMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3098 {
3099 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3100 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3101 panic!(
3102 "unity: virtual slot {}
3103 out of range (vtable len {}
3104) on the runtime class behind {}
3105 (method `{}
3106`)",
3107 18usize,
3108 __vt.len(),
3109 <HubMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
3110 "ACall",
3111 )
3112 });
3113 let __inner: extern "C" fn(HubMenu_SubSystemMenu_ConfigItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3114 ::core::mem::transmute(__vi.method_ptr);
3115 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3116 __inner(__receiver, __mi)
3117 }
3118 }
3119 }
3120 #[doc = "`.ctor()` overload"]
3121 fn ctor(self) -> () {
3122 unsafe {
3123 let __receiver =
3124 <HubMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3125 ::unity::il2cpp_call!((::unity::module_base()+0x1b65060usize)as*mut u8,();
3126(HubMenu_SubSystemMenu_ConfigItem)__receiver)
3127 }
3128 }
3129}
3130
3131#[cfg(feature = "app-hubmenu")]
3132impl<__T: IHubMenu_SubSystemMenu_ConfigItem> IHubMenu_SubSystemMenu_ConfigItemMethods for __T {}
3133
3134#[cfg(feature = "app-hubmenu")]
3135impl HubMenu_SubSystemMenu_ConfigItem {
3136 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3137 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3138 }
3139
3140 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3141 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3142 }
3143
3144 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3145 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3146 }
3147
3148 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3149 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3150 }
3151
3152 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3153 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3154 }
3155}
3156
3157#[cfg(feature = "app-hubmenu")]
3158impl HubMenu_SubSystemMenu_ConfigItem {
3159 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ConfigItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3160 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3161 let __mi = Self::get_name_method_info();
3162 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3163 __inner(this.into(), ::core::option::Option::None)
3164 }
3165
3166 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ConfigItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3167 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3168 let __mi = Self::get_help_text_method_info();
3169 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3170 __inner(this.into(), ::core::option::Option::None)
3171 }
3172
3173 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ConfigItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3174 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3175 let __mi = Self::build_attribute_method_info();
3176 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3177 ::core::mem::transmute(__mi.method_ptr);
3178 __inner(this.into(), ::core::option::Option::None)
3179 }
3180
3181 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_ConfigItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3182 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3183 let __mi = Self::a_call_method_info();
3184 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3185 ::core::mem::transmute(__mi.method_ptr);
3186 __inner(this.into(), ::core::option::Option::None)
3187 }
3188}
3189
3190#[cfg(feature = "app-hubmenu")]
3191impl HubMenu_SubSystemMenu_ConfigItem {
3192 #[doc = "`.ctor()` — no args"]
3193 pub fn new() -> Self {
3194 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3195 panic!(
3196 "{}
3197::{}
3198 failed to instantiate",
3199 ::core::stringify!(HubMenu_SubSystemMenu_ConfigItem),
3200 ::core::stringify!(new),
3201 )
3202 });
3203 <Self as IHubMenu_SubSystemMenu_ConfigItemMethods>::ctor(this);
3204 this
3205 }
3206}
3207
3208#[cfg(feature = "app-hubmenu")]
3209pub trait IHubMenu_SubFriendMenu_ProfileCardItemMethods: IHubMenu_SubFriendMenu_ProfileCardItem {
3210 #[doc = "`GetName()` overload"]
3211 fn get_name(self) -> ::unity::Il2CppString {
3212 unsafe {
3213 let __receiver = <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::FromIlInstance>::from_il_instance(
3214 <Self as ::unity::SystemObject>::as_instance(self),
3215 );
3216 {
3217 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3218 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3219 panic!(
3220 "unity: virtual slot {}
3221 out of range (vtable len {}
3222) on the runtime class behind {}
3223 (method `{}
3224`)",
3225 4usize,
3226 __vt.len(),
3227 <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::ClassIdentity>::NAME,
3228 "GetName",
3229 )
3230 });
3231 let __inner: extern "C" fn(HubMenu_SubFriendMenu_ProfileCardItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3232 ::core::mem::transmute(__vi.method_ptr);
3233 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3234 __inner(__receiver, __mi)
3235 }
3236 }
3237 }
3238 #[doc = "`GetHelpText()` overload"]
3239 fn get_help_text(self) -> ::unity::Il2CppString {
3240 unsafe {
3241 let __receiver = <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::FromIlInstance>::from_il_instance(
3242 <Self as ::unity::SystemObject>::as_instance(self),
3243 );
3244 {
3245 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3246 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3247 panic!(
3248 "unity: virtual slot {}
3249 out of range (vtable len {}
3250) on the runtime class behind {}
3251 (method `{}
3252`)",
3253 28usize,
3254 __vt.len(),
3255 <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::ClassIdentity>::NAME,
3256 "GetHelpText",
3257 )
3258 });
3259 let __inner: extern "C" fn(HubMenu_SubFriendMenu_ProfileCardItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3260 ::core::mem::transmute(__vi.method_ptr);
3261 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3262 __inner(__receiver, __mi)
3263 }
3264 }
3265 }
3266 #[doc = "`BuildAttribute()` overload"]
3267 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3268 unsafe {
3269 let __receiver = <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::FromIlInstance>::from_il_instance(
3270 <Self as ::unity::SystemObject>::as_instance(self),
3271 );
3272 {
3273 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3274 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3275 panic!(
3276 "unity: virtual slot {}
3277 out of range (vtable len {}
3278) on the runtime class behind {}
3279 (method `{}
3280`)",
3281 8usize,
3282 __vt.len(),
3283 <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::ClassIdentity>::NAME,
3284 "BuildAttribute",
3285 )
3286 });
3287 let __inner: extern "C" fn(
3288 HubMenu_SubFriendMenu_ProfileCardItem,
3289 ::unity::OptionalMethod,
3290 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3291 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3292 __inner(__receiver, __mi)
3293 }
3294 }
3295 }
3296 #[doc = "`ACall()` overload"]
3297 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3298 unsafe {
3299 let __receiver = <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::FromIlInstance>::from_il_instance(
3300 <Self as ::unity::SystemObject>::as_instance(self),
3301 );
3302 {
3303 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3304 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3305 panic!(
3306 "unity: virtual slot {}
3307 out of range (vtable len {}
3308) on the runtime class behind {}
3309 (method `{}
3310`)",
3311 18usize,
3312 __vt.len(),
3313 <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::ClassIdentity>::NAME,
3314 "ACall",
3315 )
3316 });
3317 let __inner: extern "C" fn(
3318 HubMenu_SubFriendMenu_ProfileCardItem,
3319 ::unity::OptionalMethod,
3320 ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3321 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3322 __inner(__receiver, __mi)
3323 }
3324 }
3325 }
3326 #[doc = "`.ctor()` overload"]
3327 fn ctor(self) -> () {
3328 unsafe {
3329 let __receiver = <HubMenu_SubFriendMenu_ProfileCardItem as ::unity::FromIlInstance>::from_il_instance(
3330 <Self as ::unity::SystemObject>::as_instance(self),
3331 );
3332 ::unity::il2cpp_call!((::unity::module_base()+0x1b64740usize)as*mut u8,();
3333(HubMenu_SubFriendMenu_ProfileCardItem)__receiver)
3334 }
3335 }
3336}
3337
3338#[cfg(feature = "app-hubmenu")]
3339impl<__T: IHubMenu_SubFriendMenu_ProfileCardItem> IHubMenu_SubFriendMenu_ProfileCardItemMethods for __T {}
3340
3341#[cfg(feature = "app-hubmenu")]
3342impl HubMenu_SubFriendMenu_ProfileCardItem {
3343 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3344 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3345 }
3346
3347 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3348 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3349 }
3350
3351 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3352 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3353 }
3354
3355 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3356 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3357 }
3358
3359 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3360 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3361 }
3362}
3363
3364#[cfg(feature = "app-hubmenu")]
3365impl HubMenu_SubFriendMenu_ProfileCardItem {
3366 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_ProfileCardItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3367 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3368 let __mi = Self::get_name_method_info();
3369 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3370 __inner(this.into(), ::core::option::Option::None)
3371 }
3372
3373 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_ProfileCardItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3374 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3375 let __mi = Self::get_help_text_method_info();
3376 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3377 __inner(this.into(), ::core::option::Option::None)
3378 }
3379
3380 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_ProfileCardItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3381 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3382 let __mi = Self::build_attribute_method_info();
3383 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3384 ::core::mem::transmute(__mi.method_ptr);
3385 __inner(this.into(), ::core::option::Option::None)
3386 }
3387
3388 #[doc = "Direct (non-virtual) call to `HubMenu_SubFriendMenu_ProfileCardItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3389 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3390 let __mi = Self::a_call_method_info();
3391 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3392 ::core::mem::transmute(__mi.method_ptr);
3393 __inner(this.into(), ::core::option::Option::None)
3394 }
3395}
3396
3397#[cfg(feature = "app-hubmenu")]
3398impl HubMenu_SubFriendMenu_ProfileCardItem {
3399 #[doc = "`.ctor()` — no args"]
3400 pub fn new() -> Self {
3401 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3402 panic!(
3403 "{}
3404::{}
3405 failed to instantiate",
3406 ::core::stringify!(HubMenu_SubFriendMenu_ProfileCardItem),
3407 ::core::stringify!(new),
3408 )
3409 });
3410 <Self as IHubMenu_SubFriendMenu_ProfileCardItemMethods>::ctor(this);
3411 this
3412 }
3413}
3414
3415#[cfg(feature = "app-hubmenu")]
3416pub trait IHubMenu_GmapItemMethods: IHubMenu_GmapItem {
3417 #[doc = "`GetName()` overload"]
3418 fn get_name(self) -> ::unity::Il2CppString {
3419 unsafe {
3420 let __receiver = <HubMenu_GmapItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3421 {
3422 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3423 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3424 panic!(
3425 "unity: virtual slot {}
3426 out of range (vtable len {}
3427) on the runtime class behind {}
3428 (method `{}
3429`)",
3430 4usize,
3431 __vt.len(),
3432 <HubMenu_GmapItem as ::unity::ClassIdentity>::NAME,
3433 "GetName",
3434 )
3435 });
3436 let __inner: extern "C" fn(HubMenu_GmapItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3437 ::core::mem::transmute(__vi.method_ptr);
3438 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3439 __inner(__receiver, __mi)
3440 }
3441 }
3442 }
3443 #[doc = "`GetHelpText()` overload"]
3444 fn get_help_text(self) -> ::unity::Il2CppString {
3445 unsafe {
3446 let __receiver = <HubMenu_GmapItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3447 {
3448 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3449 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3450 panic!(
3451 "unity: virtual slot {}
3452 out of range (vtable len {}
3453) on the runtime class behind {}
3454 (method `{}
3455`)",
3456 28usize,
3457 __vt.len(),
3458 <HubMenu_GmapItem as ::unity::ClassIdentity>::NAME,
3459 "GetHelpText",
3460 )
3461 });
3462 let __inner: extern "C" fn(HubMenu_GmapItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3463 ::core::mem::transmute(__vi.method_ptr);
3464 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3465 __inner(__receiver, __mi)
3466 }
3467 }
3468 }
3469 #[doc = "`BuildAttribute()` overload"]
3470 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3471 unsafe {
3472 let __receiver = <HubMenu_GmapItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3473 {
3474 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3475 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3476 panic!(
3477 "unity: virtual slot {}
3478 out of range (vtable len {}
3479) on the runtime class behind {}
3480 (method `{}
3481`)",
3482 8usize,
3483 __vt.len(),
3484 <HubMenu_GmapItem as ::unity::ClassIdentity>::NAME,
3485 "BuildAttribute",
3486 )
3487 });
3488 let __inner: extern "C" fn(HubMenu_GmapItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3489 ::core::mem::transmute(__vi.method_ptr);
3490 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3491 __inner(__receiver, __mi)
3492 }
3493 }
3494 }
3495 #[doc = "`ACall()` overload"]
3496 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3497 unsafe {
3498 let __receiver = <HubMenu_GmapItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3499 {
3500 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3501 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3502 panic!(
3503 "unity: virtual slot {}
3504 out of range (vtable len {}
3505) on the runtime class behind {}
3506 (method `{}
3507`)",
3508 18usize,
3509 __vt.len(),
3510 <HubMenu_GmapItem as ::unity::ClassIdentity>::NAME,
3511 "ACall",
3512 )
3513 });
3514 let __inner: extern "C" fn(HubMenu_GmapItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3515 ::core::mem::transmute(__vi.method_ptr);
3516 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3517 __inner(__receiver, __mi)
3518 }
3519 }
3520 }
3521 #[doc = "`.ctor()` overload"]
3522 fn ctor(self) -> () {
3523 unsafe {
3524 let __receiver = <HubMenu_GmapItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3525 ::unity::il2cpp_call!((::unity::module_base()+0x2adf0d0usize)as*mut u8,();
3526(HubMenu_GmapItem)__receiver)
3527 }
3528 }
3529}
3530
3531#[cfg(feature = "app-hubmenu")]
3532impl<__T: IHubMenu_GmapItem> IHubMenu_GmapItemMethods for __T {}
3533
3534#[cfg(feature = "app-hubmenu")]
3535impl HubMenu_GmapItem {
3536 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3537 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3538 }
3539
3540 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3541 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3542 }
3543
3544 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3545 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3546 }
3547
3548 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3549 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3550 }
3551
3552 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3553 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3554 }
3555}
3556
3557#[cfg(feature = "app-hubmenu")]
3558impl HubMenu_GmapItem {
3559 #[doc = "Direct (non-virtual) call to `HubMenu_GmapItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3560 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3561 let __mi = Self::get_name_method_info();
3562 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3563 __inner(this.into(), ::core::option::Option::None)
3564 }
3565
3566 #[doc = "Direct (non-virtual) call to `HubMenu_GmapItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3567 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3568 let __mi = Self::get_help_text_method_info();
3569 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3570 __inner(this.into(), ::core::option::Option::None)
3571 }
3572
3573 #[doc = "Direct (non-virtual) call to `HubMenu_GmapItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3574 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3575 let __mi = Self::build_attribute_method_info();
3576 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3577 ::core::mem::transmute(__mi.method_ptr);
3578 __inner(this.into(), ::core::option::Option::None)
3579 }
3580
3581 #[doc = "Direct (non-virtual) call to `HubMenu_GmapItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3582 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3583 let __mi = Self::a_call_method_info();
3584 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3585 ::core::mem::transmute(__mi.method_ptr);
3586 __inner(this.into(), ::core::option::Option::None)
3587 }
3588}
3589
3590#[cfg(feature = "app-hubmenu")]
3591impl HubMenu_GmapItem {
3592 #[doc = "`.ctor()` — no args"]
3593 pub fn new() -> Self {
3594 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3595 panic!(
3596 "{}
3597::{}
3598 failed to instantiate",
3599 ::core::stringify!(HubMenu_GmapItem),
3600 ::core::stringify!(new),
3601 )
3602 });
3603 <Self as IHubMenu_GmapItemMethods>::ctor(this);
3604 this
3605 }
3606}
3607
3608#[cfg(feature = "app-hubmenu")]
3609pub trait IHubMenu_InventoryItemMethods: IHubMenu_InventoryItem {
3610 #[doc = "`GetName()` overload"]
3611 fn get_name(self) -> ::unity::Il2CppString {
3612 unsafe {
3613 let __receiver = <HubMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3614 {
3615 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3616 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3617 panic!(
3618 "unity: virtual slot {}
3619 out of range (vtable len {}
3620) on the runtime class behind {}
3621 (method `{}
3622`)",
3623 4usize,
3624 __vt.len(),
3625 <HubMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3626 "GetName",
3627 )
3628 });
3629 let __inner: extern "C" fn(HubMenu_InventoryItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3630 ::core::mem::transmute(__vi.method_ptr);
3631 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3632 __inner(__receiver, __mi)
3633 }
3634 }
3635 }
3636 #[doc = "`GetHelpText()` overload"]
3637 fn get_help_text(self) -> ::unity::Il2CppString {
3638 unsafe {
3639 let __receiver = <HubMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3640 {
3641 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3642 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3643 panic!(
3644 "unity: virtual slot {}
3645 out of range (vtable len {}
3646) on the runtime class behind {}
3647 (method `{}
3648`)",
3649 28usize,
3650 __vt.len(),
3651 <HubMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3652 "GetHelpText",
3653 )
3654 });
3655 let __inner: extern "C" fn(HubMenu_InventoryItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3656 ::core::mem::transmute(__vi.method_ptr);
3657 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3658 __inner(__receiver, __mi)
3659 }
3660 }
3661 }
3662 #[doc = "`BuildAttribute()` overload"]
3663 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3664 unsafe {
3665 let __receiver = <HubMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3666 {
3667 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3668 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3669 panic!(
3670 "unity: virtual slot {}
3671 out of range (vtable len {}
3672) on the runtime class behind {}
3673 (method `{}
3674`)",
3675 8usize,
3676 __vt.len(),
3677 <HubMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3678 "BuildAttribute",
3679 )
3680 });
3681 let __inner: extern "C" fn(HubMenu_InventoryItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3682 ::core::mem::transmute(__vi.method_ptr);
3683 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3684 __inner(__receiver, __mi)
3685 }
3686 }
3687 }
3688 #[doc = "`ACall()` overload"]
3689 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3690 unsafe {
3691 let __receiver = <HubMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3692 {
3693 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3694 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3695 panic!(
3696 "unity: virtual slot {}
3697 out of range (vtable len {}
3698) on the runtime class behind {}
3699 (method `{}
3700`)",
3701 18usize,
3702 __vt.len(),
3703 <HubMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3704 "ACall",
3705 )
3706 });
3707 let __inner: extern "C" fn(HubMenu_InventoryItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3708 ::core::mem::transmute(__vi.method_ptr);
3709 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3710 __inner(__receiver, __mi)
3711 }
3712 }
3713 }
3714 #[doc = "`.ctor()` overload"]
3715 fn ctor(self) -> () {
3716 unsafe {
3717 let __receiver = <HubMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3718 ::unity::il2cpp_call!((::unity::module_base()+0x2adfb80usize)as*mut u8,();
3719(HubMenu_InventoryItem)__receiver)
3720 }
3721 }
3722}
3723
3724#[cfg(feature = "app-hubmenu")]
3725impl<__T: IHubMenu_InventoryItem> IHubMenu_InventoryItemMethods for __T {}
3726
3727#[cfg(feature = "app-hubmenu")]
3728impl HubMenu_InventoryItem {
3729 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3730 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3731 }
3732
3733 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3735 }
3736
3737 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3739 }
3740
3741 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3743 }
3744
3745 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3747 }
3748}
3749
3750#[cfg(feature = "app-hubmenu")]
3751impl HubMenu_InventoryItem {
3752 #[doc = "Direct (non-virtual) call to `HubMenu_InventoryItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3753 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3754 let __mi = Self::get_name_method_info();
3755 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3756 __inner(this.into(), ::core::option::Option::None)
3757 }
3758
3759 #[doc = "Direct (non-virtual) call to `HubMenu_InventoryItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3760 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3761 let __mi = Self::get_help_text_method_info();
3762 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3763 __inner(this.into(), ::core::option::Option::None)
3764 }
3765
3766 #[doc = "Direct (non-virtual) call to `HubMenu_InventoryItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3767 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3768 let __mi = Self::build_attribute_method_info();
3769 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3770 ::core::mem::transmute(__mi.method_ptr);
3771 __inner(this.into(), ::core::option::Option::None)
3772 }
3773
3774 #[doc = "Direct (non-virtual) call to `HubMenu_InventoryItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3775 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3776 let __mi = Self::a_call_method_info();
3777 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3778 ::core::mem::transmute(__mi.method_ptr);
3779 __inner(this.into(), ::core::option::Option::None)
3780 }
3781}
3782
3783#[cfg(feature = "app-hubmenu")]
3784impl HubMenu_InventoryItem {
3785 #[doc = "`.ctor()` — no args"]
3786 pub fn new() -> Self {
3787 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3788 panic!(
3789 "{}
3790::{}
3791 failed to instantiate",
3792 ::core::stringify!(HubMenu_InventoryItem),
3793 ::core::stringify!(new),
3794 )
3795 });
3796 <Self as IHubMenu_InventoryItemMethods>::ctor(this);
3797 this
3798 }
3799}
3800
3801#[cfg(feature = "app-hubmenu")]
3802pub trait IHubMenu_MapInfoItemMethods: IHubMenu_MapInfoItem {
3803 #[doc = "`GetName()` overload"]
3804 fn get_name(self) -> ::unity::Il2CppString {
3805 unsafe {
3806 let __receiver = <HubMenu_MapInfoItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3807 {
3808 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3809 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3810 panic!(
3811 "unity: virtual slot {}
3812 out of range (vtable len {}
3813) on the runtime class behind {}
3814 (method `{}
3815`)",
3816 4usize,
3817 __vt.len(),
3818 <HubMenu_MapInfoItem as ::unity::ClassIdentity>::NAME,
3819 "GetName",
3820 )
3821 });
3822 let __inner: extern "C" fn(HubMenu_MapInfoItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3823 ::core::mem::transmute(__vi.method_ptr);
3824 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3825 __inner(__receiver, __mi)
3826 }
3827 }
3828 }
3829 #[doc = "`GetHelpText()` overload"]
3830 fn get_help_text(self) -> ::unity::Il2CppString {
3831 unsafe {
3832 let __receiver = <HubMenu_MapInfoItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3833 {
3834 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3835 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3836 panic!(
3837 "unity: virtual slot {}
3838 out of range (vtable len {}
3839) on the runtime class behind {}
3840 (method `{}
3841`)",
3842 28usize,
3843 __vt.len(),
3844 <HubMenu_MapInfoItem as ::unity::ClassIdentity>::NAME,
3845 "GetHelpText",
3846 )
3847 });
3848 let __inner: extern "C" fn(HubMenu_MapInfoItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3849 ::core::mem::transmute(__vi.method_ptr);
3850 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3851 __inner(__receiver, __mi)
3852 }
3853 }
3854 }
3855 #[doc = "`BuildAttribute()` overload"]
3856 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3857 unsafe {
3858 let __receiver = <HubMenu_MapInfoItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3859 {
3860 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3861 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3862 panic!(
3863 "unity: virtual slot {}
3864 out of range (vtable len {}
3865) on the runtime class behind {}
3866 (method `{}
3867`)",
3868 8usize,
3869 __vt.len(),
3870 <HubMenu_MapInfoItem as ::unity::ClassIdentity>::NAME,
3871 "BuildAttribute",
3872 )
3873 });
3874 let __inner: extern "C" fn(HubMenu_MapInfoItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3875 ::core::mem::transmute(__vi.method_ptr);
3876 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3877 __inner(__receiver, __mi)
3878 }
3879 }
3880 }
3881 #[doc = "`ACall()` overload"]
3882 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3883 unsafe {
3884 let __receiver = <HubMenu_MapInfoItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3885 {
3886 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3887 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3888 panic!(
3889 "unity: virtual slot {}
3890 out of range (vtable len {}
3891) on the runtime class behind {}
3892 (method `{}
3893`)",
3894 18usize,
3895 __vt.len(),
3896 <HubMenu_MapInfoItem as ::unity::ClassIdentity>::NAME,
3897 "ACall",
3898 )
3899 });
3900 let __inner: extern "C" fn(HubMenu_MapInfoItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3901 ::core::mem::transmute(__vi.method_ptr);
3902 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3903 __inner(__receiver, __mi)
3904 }
3905 }
3906 }
3907 #[doc = "`.ctor()` overload"]
3908 fn ctor(self) -> () {
3909 unsafe {
3910 let __receiver = <HubMenu_MapInfoItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3911 ::unity::il2cpp_call!((::unity::module_base()+0x2adfea0usize)as*mut u8,();
3912(HubMenu_MapInfoItem)__receiver)
3913 }
3914 }
3915}
3916
3917#[cfg(feature = "app-hubmenu")]
3918impl<__T: IHubMenu_MapInfoItem> IHubMenu_MapInfoItemMethods for __T {}
3919
3920#[cfg(feature = "app-hubmenu")]
3921impl HubMenu_MapInfoItem {
3922 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3923 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3924 }
3925
3926 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3927 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3928 }
3929
3930 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3931 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3932 }
3933
3934 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3935 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3936 }
3937
3938 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3939 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3940 }
3941}
3942
3943#[cfg(feature = "app-hubmenu")]
3944impl HubMenu_MapInfoItem {
3945 #[doc = "Direct (non-virtual) call to `HubMenu_MapInfoItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3946 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3947 let __mi = Self::get_name_method_info();
3948 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3949 __inner(this.into(), ::core::option::Option::None)
3950 }
3951
3952 #[doc = "Direct (non-virtual) call to `HubMenu_MapInfoItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3953 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3954 let __mi = Self::get_help_text_method_info();
3955 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3956 __inner(this.into(), ::core::option::Option::None)
3957 }
3958
3959 #[doc = "Direct (non-virtual) call to `HubMenu_MapInfoItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3960 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3961 let __mi = Self::build_attribute_method_info();
3962 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3963 ::core::mem::transmute(__mi.method_ptr);
3964 __inner(this.into(), ::core::option::Option::None)
3965 }
3966
3967 #[doc = "Direct (non-virtual) call to `HubMenu_MapInfoItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3968 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3969 let __mi = Self::a_call_method_info();
3970 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3971 ::core::mem::transmute(__mi.method_ptr);
3972 __inner(this.into(), ::core::option::Option::None)
3973 }
3974}
3975
3976#[cfg(feature = "app-hubmenu")]
3977impl HubMenu_MapInfoItem {
3978 #[doc = "`.ctor()` — no args"]
3979 pub fn new() -> Self {
3980 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3981 panic!(
3982 "{}
3983::{}
3984 failed to instantiate",
3985 ::core::stringify!(HubMenu_MapInfoItem),
3986 ::core::stringify!(new),
3987 )
3988 });
3989 <Self as IHubMenu_MapInfoItemMethods>::ctor(this);
3990 this
3991 }
3992}
3993
3994#[cfg(feature = "app-hubmenu")]
3995pub trait IHubMenu_GodItemMethods: IHubMenu_GodItem {
3996 #[doc = "`GetName()` overload"]
3997 fn get_name(self) -> ::unity::Il2CppString {
3998 unsafe {
3999 let __receiver = <HubMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4000 {
4001 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4002 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4003 panic!(
4004 "unity: virtual slot {}
4005 out of range (vtable len {}
4006) on the runtime class behind {}
4007 (method `{}
4008`)",
4009 4usize,
4010 __vt.len(),
4011 <HubMenu_GodItem as ::unity::ClassIdentity>::NAME,
4012 "GetName",
4013 )
4014 });
4015 let __inner: extern "C" fn(HubMenu_GodItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4016 ::core::mem::transmute(__vi.method_ptr);
4017 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4018 __inner(__receiver, __mi)
4019 }
4020 }
4021 }
4022 #[doc = "`GetHelpText()` overload"]
4023 fn get_help_text(self) -> ::unity::Il2CppString {
4024 unsafe {
4025 let __receiver = <HubMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4026 {
4027 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4028 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4029 panic!(
4030 "unity: virtual slot {}
4031 out of range (vtable len {}
4032) on the runtime class behind {}
4033 (method `{}
4034`)",
4035 28usize,
4036 __vt.len(),
4037 <HubMenu_GodItem as ::unity::ClassIdentity>::NAME,
4038 "GetHelpText",
4039 )
4040 });
4041 let __inner: extern "C" fn(HubMenu_GodItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4042 ::core::mem::transmute(__vi.method_ptr);
4043 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4044 __inner(__receiver, __mi)
4045 }
4046 }
4047 }
4048 #[doc = "`BuildAttribute()` overload"]
4049 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4050 unsafe {
4051 let __receiver = <HubMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4052 {
4053 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4054 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
4055 panic!(
4056 "unity: virtual slot {}
4057 out of range (vtable len {}
4058) on the runtime class behind {}
4059 (method `{}
4060`)",
4061 8usize,
4062 __vt.len(),
4063 <HubMenu_GodItem as ::unity::ClassIdentity>::NAME,
4064 "BuildAttribute",
4065 )
4066 });
4067 let __inner: extern "C" fn(HubMenu_GodItem, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4068 ::core::mem::transmute(__vi.method_ptr);
4069 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4070 __inner(__receiver, __mi)
4071 }
4072 }
4073 }
4074 #[doc = "`ACall()` overload"]
4075 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4076 unsafe {
4077 let __receiver = <HubMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4078 {
4079 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4080 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4081 panic!(
4082 "unity: virtual slot {}
4083 out of range (vtable len {}
4084) on the runtime class behind {}
4085 (method `{}
4086`)",
4087 18usize,
4088 __vt.len(),
4089 <HubMenu_GodItem as ::unity::ClassIdentity>::NAME,
4090 "ACall",
4091 )
4092 });
4093 let __inner: extern "C" fn(HubMenu_GodItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4094 ::core::mem::transmute(__vi.method_ptr);
4095 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4096 __inner(__receiver, __mi)
4097 }
4098 }
4099 }
4100 #[doc = "`.ctor()` overload"]
4101 fn ctor(self) -> () {
4102 unsafe {
4103 let __receiver = <HubMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4104 ::unity::il2cpp_call!((::unity::module_base()+0x2adf3f0usize)as*mut u8,();
4105(HubMenu_GodItem)__receiver)
4106 }
4107 }
4108}
4109
4110#[cfg(feature = "app-hubmenu")]
4111impl<__T: IHubMenu_GodItem> IHubMenu_GodItemMethods for __T {}
4112
4113#[cfg(feature = "app-hubmenu")]
4114impl HubMenu_GodItem {
4115 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4116 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4117 }
4118
4119 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4120 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4121 }
4122
4123 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4124 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4125 }
4126
4127 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4128 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4129 }
4130
4131 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4132 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4133 }
4134}
4135
4136#[cfg(feature = "app-hubmenu")]
4137impl HubMenu_GodItem {
4138 #[doc = "Direct (non-virtual) call to `HubMenu_GodItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4139 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4140 let __mi = Self::get_name_method_info();
4141 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4142 __inner(this.into(), ::core::option::Option::None)
4143 }
4144
4145 #[doc = "Direct (non-virtual) call to `HubMenu_GodItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4146 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4147 let __mi = Self::get_help_text_method_info();
4148 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4149 __inner(this.into(), ::core::option::Option::None)
4150 }
4151
4152 #[doc = "Direct (non-virtual) call to `HubMenu_GodItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4153 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4154 let __mi = Self::build_attribute_method_info();
4155 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4156 ::core::mem::transmute(__mi.method_ptr);
4157 __inner(this.into(), ::core::option::Option::None)
4158 }
4159
4160 #[doc = "Direct (non-virtual) call to `HubMenu_GodItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4161 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4162 let __mi = Self::a_call_method_info();
4163 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4164 ::core::mem::transmute(__mi.method_ptr);
4165 __inner(this.into(), ::core::option::Option::None)
4166 }
4167}
4168
4169#[cfg(feature = "app-hubmenu")]
4170impl HubMenu_GodItem {
4171 #[doc = "`.ctor()` — no args"]
4172 pub fn new() -> Self {
4173 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4174 panic!(
4175 "{}
4176::{}
4177 failed to instantiate",
4178 ::core::stringify!(HubMenu_GodItem),
4179 ::core::stringify!(new),
4180 )
4181 });
4182 <Self as IHubMenu_GodItemMethods>::ctor(this);
4183 this
4184 }
4185}
4186
4187#[cfg(feature = "app-hubmenu")]
4188pub trait IHubMenu_SubSystemMenu_TutorialItemMethods: IHubMenu_SubSystemMenu_TutorialItem {
4189 #[doc = "`GetName()` overload"]
4190 fn get_name(self) -> ::unity::Il2CppString {
4191 unsafe {
4192 let __receiver =
4193 <HubMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4194 {
4195 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4196 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4197 panic!(
4198 "unity: virtual slot {}
4199 out of range (vtable len {}
4200) on the runtime class behind {}
4201 (method `{}
4202`)",
4203 4usize,
4204 __vt.len(),
4205 <HubMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
4206 "GetName",
4207 )
4208 });
4209 let __inner: extern "C" fn(HubMenu_SubSystemMenu_TutorialItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4210 ::core::mem::transmute(__vi.method_ptr);
4211 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4212 __inner(__receiver, __mi)
4213 }
4214 }
4215 }
4216 #[doc = "`GetHelpText()` overload"]
4217 fn get_help_text(self) -> ::unity::Il2CppString {
4218 unsafe {
4219 let __receiver =
4220 <HubMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4221 {
4222 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4223 let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4224 panic!(
4225 "unity: virtual slot {}
4226 out of range (vtable len {}
4227) on the runtime class behind {}
4228 (method `{}
4229`)",
4230 28usize,
4231 __vt.len(),
4232 <HubMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
4233 "GetHelpText",
4234 )
4235 });
4236 let __inner: extern "C" fn(HubMenu_SubSystemMenu_TutorialItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4237 ::core::mem::transmute(__vi.method_ptr);
4238 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4239 __inner(__receiver, __mi)
4240 }
4241 }
4242 }
4243 #[doc = "`BuildAttribute()` overload"]
4244 fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4245 unsafe {
4246 let __receiver =
4247 <HubMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4248 {
4249 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4250 let __vi = *__vt.get(8usize).unwrap_or_else(|| {
4251 panic!(
4252 "unity: virtual slot {}
4253 out of range (vtable len {}
4254) on the runtime class behind {}
4255 (method `{}
4256`)",
4257 8usize,
4258 __vt.len(),
4259 <HubMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
4260 "BuildAttribute",
4261 )
4262 });
4263 let __inner: extern "C" fn(
4264 HubMenu_SubSystemMenu_TutorialItem,
4265 ::unity::OptionalMethod,
4266 ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4267 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4268 __inner(__receiver, __mi)
4269 }
4270 }
4271 }
4272 #[doc = "`ACall()` overload"]
4273 fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4274 unsafe {
4275 let __receiver =
4276 <HubMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4277 {
4278 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4279 let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4280 panic!(
4281 "unity: virtual slot {}
4282 out of range (vtable len {}
4283) on the runtime class behind {}
4284 (method `{}
4285`)",
4286 18usize,
4287 __vt.len(),
4288 <HubMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
4289 "ACall",
4290 )
4291 });
4292 let __inner: extern "C" fn(HubMenu_SubSystemMenu_TutorialItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4293 ::core::mem::transmute(__vi.method_ptr);
4294 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4295 __inner(__receiver, __mi)
4296 }
4297 }
4298 }
4299 #[doc = "`.ctor()` overload"]
4300 fn ctor(self) -> () {
4301 unsafe {
4302 let __receiver =
4303 <HubMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4304 ::unity::il2cpp_call!((::unity::module_base()+0x1b65470usize)as*mut u8,();
4305(HubMenu_SubSystemMenu_TutorialItem)__receiver)
4306 }
4307 }
4308}
4309
4310#[cfg(feature = "app-hubmenu")]
4311impl<__T: IHubMenu_SubSystemMenu_TutorialItem> IHubMenu_SubSystemMenu_TutorialItemMethods for __T {}
4312
4313#[cfg(feature = "app-hubmenu")]
4314impl HubMenu_SubSystemMenu_TutorialItem {
4315 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4316 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4317 }
4318
4319 pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4320 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4321 }
4322
4323 pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4324 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4325 }
4326
4327 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4328 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4329 }
4330
4331 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4332 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4333 }
4334}
4335
4336#[cfg(feature = "app-hubmenu")]
4337impl HubMenu_SubSystemMenu_TutorialItem {
4338 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_TutorialItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4339 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4340 let __mi = Self::get_name_method_info();
4341 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4342 __inner(this.into(), ::core::option::Option::None)
4343 }
4344
4345 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_TutorialItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4346 pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4347 let __mi = Self::get_help_text_method_info();
4348 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4349 __inner(this.into(), ::core::option::Option::None)
4350 }
4351
4352 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_TutorialItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4353 pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4354 let __mi = Self::build_attribute_method_info();
4355 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4356 ::core::mem::transmute(__mi.method_ptr);
4357 __inner(this.into(), ::core::option::Option::None)
4358 }
4359
4360 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu_TutorialItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4361 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4362 let __mi = Self::a_call_method_info();
4363 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4364 ::core::mem::transmute(__mi.method_ptr);
4365 __inner(this.into(), ::core::option::Option::None)
4366 }
4367}
4368
4369#[cfg(feature = "app-hubmenu")]
4370impl HubMenu_SubSystemMenu_TutorialItem {
4371 #[doc = "`.ctor()` — no args"]
4372 pub fn new() -> Self {
4373 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4374 panic!(
4375 "{}
4376::{}
4377 failed to instantiate",
4378 ::core::stringify!(HubMenu_SubSystemMenu_TutorialItem),
4379 ::core::stringify!(new),
4380 )
4381 });
4382 <Self as IHubMenu_SubSystemMenu_TutorialItemMethods>::ctor(this);
4383 this
4384 }
4385}
4386
4387#[cfg(feature = "app-hubmenu")]
4388impl HubMenu_SubSystemMenu {
4389 #[doc = "`CreateBind(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
4390 pub fn create_bind(
4391 super_: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
4392 parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
4393 ) -> () {
4394 unsafe {
4395 ::unity::il2cpp_call!((::unity::module_base()+0x2ae0bf0usize)as*mut u8,();
4396(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(super_),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
4397 }
4398 }
4399}
4400
4401#[cfg(feature = "app-hubmenu")]
4402pub trait IHubMenu_SubSystemMenuMethods: IHubMenu_SubSystemMenu {
4403 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` overload"]
4404 fn ctor(
4405 self,
4406 menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
4407 menu_content: impl ::core::convert::Into<crate::app::sortiesubmenucontent::SortieSubMenuContent>,
4408 ) -> () {
4409 unsafe {
4410 let __receiver = <HubMenu_SubSystemMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4411 ::unity::il2cpp_call!((::unity::module_base()+0x2ae0b90usize)as*mut u8,();
4412(HubMenu_SubSystemMenu)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list),(crate::app::sortiesubmenucontent::SortieSubMenuContent)::core::convert::Into::into(menu_content))
4413 }
4414 }
4415 #[doc = "`GetName()` overload"]
4416 fn get_name(self) -> ::unity::Il2CppString {
4417 unsafe {
4418 let __receiver = <HubMenu_SubSystemMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4419 {
4420 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4421 let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4422 panic!(
4423 "unity: virtual slot {}
4424 out of range (vtable len {}
4425) on the runtime class behind {}
4426 (method `{}
4427`)",
4428 30usize,
4429 __vt.len(),
4430 <HubMenu_SubSystemMenu as ::unity::ClassIdentity>::NAME,
4431 "GetName",
4432 )
4433 });
4434 let __inner: extern "C" fn(HubMenu_SubSystemMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4435 ::core::mem::transmute(__vi.method_ptr);
4436 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4437 __inner(__receiver, __mi)
4438 }
4439 }
4440 }
4441}
4442
4443#[cfg(feature = "app-hubmenu")]
4444impl<__T: IHubMenu_SubSystemMenu> IHubMenu_SubSystemMenuMethods for __T {}
4445
4446#[cfg(feature = "app-hubmenu")]
4447impl HubMenu_SubSystemMenu {
4448 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4449 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4450 }
4451
4452 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4453 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4454 }
4455
4456 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4457 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4458 }
4459}
4460
4461#[cfg(feature = "app-hubmenu")]
4462impl HubMenu_SubSystemMenu {
4463 #[doc = "Direct (non-virtual) call to `HubMenu_SubSystemMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4464 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4465 let __mi = Self::get_name_method_info();
4466 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4467 __inner(this.into(), ::core::option::Option::None)
4468 }
4469}
4470
4471#[cfg(feature = "app-hubmenu")]
4472impl HubMenu_SubSystemMenu {
4473 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` — overload selector"]
4474 pub fn new(
4475 menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
4476 menu_content: crate::app::sortiesubmenucontent::SortieSubMenuContent,
4477 ) -> Self {
4478 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4479 panic!(
4480 "{}
4481::{}
4482 failed to instantiate",
4483 ::core::stringify!(HubMenu_SubSystemMenu),
4484 ::core::stringify!(new),
4485 )
4486 });
4487 <Self as IHubMenu_SubSystemMenuMethods>::ctor(this, menu_item_list, menu_content);
4488 this
4489 }
4490}
4491
4492#[cfg(feature = "app-hubmenu")]
4493#[doc(hidden)]
4494pub mod prelude {
4495 pub use super::{
4496 HubMenu, HubMenu_FriendItem, HubMenu_GmapItem, HubMenu_GodItem, HubMenu_HubMenuItem, HubMenu_InventoryItem, HubMenu_MapInfoItem,
4497 HubMenu_MaterialListItem, HubMenu_NextChapterItem, HubMenu_NextItem, HubMenu_SaveItem, HubMenu_SubFriendMenu,
4498 HubMenu_SubFriendMenu_KizunaItem, HubMenu_SubFriendMenu_NotebookItem, HubMenu_SubFriendMenu_ProfileCardItem,
4499 HubMenu_SubFriendMenu_RelianceItem, HubMenu_SubFriendMenu_RingListItem, HubMenu_SubSystemMenu, HubMenu_SubSystemMenu_ConfigItem,
4500 HubMenu_SubSystemMenu_ResetItem, HubMenu_SubSystemMenu_TutorialItem, HubMenu_SystemItem, IHubMenu, IHubMenuMethods, IHubMenu_FriendItem,
4501 IHubMenu_FriendItemMethods, IHubMenu_GmapItem, IHubMenu_GmapItemMethods, IHubMenu_GodItem, IHubMenu_GodItemMethods, IHubMenu_HubMenuItem,
4502 IHubMenu_HubMenuItemMethods, IHubMenu_InventoryItem, IHubMenu_InventoryItemMethods, IHubMenu_MapInfoItem, IHubMenu_MapInfoItemMethods,
4503 IHubMenu_MaterialListItem, IHubMenu_MaterialListItemMethods, IHubMenu_NextChapterItem, IHubMenu_NextChapterItemMethods, IHubMenu_NextItem,
4504 IHubMenu_NextItemMethods, IHubMenu_SaveItem, IHubMenu_SaveItemMethods, IHubMenu_SubFriendMenu, IHubMenu_SubFriendMenuMethods,
4505 IHubMenu_SubFriendMenu_KizunaItem, IHubMenu_SubFriendMenu_KizunaItemMethods, IHubMenu_SubFriendMenu_NotebookItem,
4506 IHubMenu_SubFriendMenu_NotebookItemMethods, IHubMenu_SubFriendMenu_ProfileCardItem, IHubMenu_SubFriendMenu_ProfileCardItemMethods,
4507 IHubMenu_SubFriendMenu_RelianceItem, IHubMenu_SubFriendMenu_RelianceItemMethods, IHubMenu_SubFriendMenu_RingListItem,
4508 IHubMenu_SubFriendMenu_RingListItemMethods, IHubMenu_SubSystemMenu, IHubMenu_SubSystemMenuMethods, IHubMenu_SubSystemMenu_ConfigItem,
4509 IHubMenu_SubSystemMenu_ConfigItemMethods, IHubMenu_SubSystemMenu_ResetItem, IHubMenu_SubSystemMenu_ResetItemMethods,
4510 IHubMenu_SubSystemMenu_TutorialItem, IHubMenu_SubSystemMenu_TutorialItemMethods, IHubMenu_SystemItem, IHubMenu_SystemItemMethods,
4511 };
4512 #[cfg(feature = "app-basicmenu")]
4513 pub use crate::app::basicmenu::IBasicMenuMethods;
4514 #[cfg(feature = "app-basicmenuitem")]
4515 pub use crate::app::basicmenuitem::IBasicMenuItemMethods;
4516 #[cfg(feature = "app-mapbasicmenuitem")]
4517 pub use crate::app::mapbasicmenuitem::IMapBasicMenuItemMethods;
4518 #[cfg(feature = "app-procinst")]
4519 pub use crate::app::procinst::IProcInstMethods;
4520 #[cfg(feature = "system-object")]
4521 pub use crate::system::object::IObjectMethods;
4522 pub use crate::{
4523 app::{basicmenu::IBasicMenu, basicmenuitem::IBasicMenuItem, mapbasicmenuitem::IMapBasicMenuItem, procinst::IProcInst},
4524 system::object::IObject,
4525 };
4526}