engage/generated/app/
gmapmenusequence.rs

1// @generated by il2cpp-bindgen — do not edit by hand.
2
3#[cfg(feature = "app-gmapmenusequence-types")]
4mod __types {
5    #[allow(unused_imports)] use ::unity::prelude::*;
6
7    use super::*;
8    use crate::{
9        app::{
10            basicdialogitem::{BasicDialogItem, IBasicDialogItem},
11            basicdialogitemno::{BasicDialogItemNo, IBasicDialogItemNo},
12            basicdialogitemyes::{BasicDialogItemYes, IBasicDialogItemYes},
13            basicmenu::{BasicMenu, IBasicMenu},
14            basicmenuitem::{BasicMenuItem, IBasicMenuItem},
15            mapbasicmenuitem::{IMapBasicMenuItem, MapBasicMenuItem},
16            procinst::{IProcInst, ProcInst},
17            singletonprocinst_1::{ISingletonProcInst_1, SingletonProcInst_1},
18        },
19        system::{
20            object::{IObject, Object},
21            r#enum::{Enum, IEnum},
22            valuetype::{IValueType, ValueType},
23        },
24    };
25
26    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem.md"))]
27    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubFriendMenu.RelianceItem")]
28    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
29    pub struct GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem {}
30
31    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_GodItem.md"))]
32    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.GodItem")]
33    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
34    pub struct GmapMenuSequence_GmapMenu_GodItem {}
35
36    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem.md"))]
37    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubSystemMenu.TutorialItem")]
38    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
39    pub struct GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem {}
40
41    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem.md"))]
42    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubFriendMenu.KizunaItem")]
43    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
44    pub struct GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem {}
45
46    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubFriendMenu.md"))]
47    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubFriendMenu")]
48    #[parent(crate::app::basicmenu::BasicMenu)]
49    pub struct GmapMenuSequence_GmapMenu_SubFriendMenu {}
50
51    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem.md"))]
52    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubFriendMenu.RingbookItem")]
53    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
54    pub struct GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem {}
55
56    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_MaterialListItem.md"))]
57    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.MaterialListItem")]
58    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
59    pub struct GmapMenuSequence_GmapMenu_MaterialListItem {}
60
61    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_EnterChapterItem.md"))]
62    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.EnterChapterItem")]
63    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
64    pub struct GmapMenuSequence_GmapMenu_EnterChapterItem {}
65
66    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubSystemMenu.md"))]
67    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubSystemMenu")]
68    #[parent(crate::app::basicmenu::BasicMenu)]
69    pub struct GmapMenuSequence_GmapMenu_SubSystemMenu {}
70
71    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SaveItem.md"))]
72    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SaveItem")]
73    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
74    pub struct GmapMenuSequence_GmapMenu_SaveItem {}
75
76    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_ShopItem.md"))]
77    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.ShopItem")]
78    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
79    pub struct GmapMenuSequence_GmapMenu_ShopItem {}
80
81    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_GmapMenuMenuItem.md"))]
82    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.GmapMenuMenuItem")]
83    #[parent(crate::app::mapbasicmenuitem::MapBasicMenuItem)]
84    pub struct GmapMenuSequence_GmapMenu_GmapMenuMenuItem {}
85
86    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem.md"))]
87    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.RankingItem.ConfirmSequence.YesMenuItem")]
88    #[parent(crate::app::basicdialogitemyes::BasicDialogItemYes)]
89    pub struct GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem {
90        #[offset(112)]
91        #[rename(name = "m_ResultFunc")]
92        pub m_result_func: crate::app::netenablesequence::NetEnableSequence_ResultFunction,
93    }
94
95    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem.md"))]
96    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubSystemMenu.ResetItem")]
97    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
98    pub struct GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem {}
99
100    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_RankingItem.md"))]
101    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.RankingItem")]
102    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
103    pub struct GmapMenuSequence_GmapMenu_RankingItem {}
104
105    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence.md"))]
106    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.RankingItem.ConfirmSequence")]
107    #[parent(crate::app::procinst::ProcInst)]
108    pub struct GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence {
109        #[offset(112)]
110        #[rename(name = "m_ResultFunc")]
111        pub m_result_func: crate::app::netenablesequence::NetEnableSequence_ResultFunction,
112    }
113
114    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_InventoryItem.md"))]
115    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.InventoryItem")]
116    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
117    pub struct GmapMenuSequence_GmapMenu_InventoryItem {}
118
119    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_FriendItem.md"))]
120    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.FriendItem")]
121    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
122    pub struct GmapMenuSequence_GmapMenu_FriendItem {}
123
124    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem.md"))]
125    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubShopMenu.ItemShopMenuItem")]
126    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
127    pub struct GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem {}
128
129    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem.md"))]
130    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubFriendMenu.NotebookItem")]
131    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
132    pub struct GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem {}
133
134    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence.md"))]
135    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.RankingItem.JumpToRankingSequence")]
136    #[parent(crate::app::procinst::ProcInst)]
137    pub struct GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence {
138        #[offset(112)]
139        #[rename(name = "m_JumpFunc")]
140        pub m_jump_func: crate::system::action::Action,
141    }
142
143    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem.md"))]
144    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubShopMenu.WeaponShopMenuItem")]
145    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
146    pub struct GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem {}
147
148    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_Label.md"))]
149    #[repr(C)]
150    #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
151    pub struct GmapMenuSequence_Label {
152        pub value: i32,
153    }
154    impl ::unity::ClassIdentity for GmapMenuSequence_Label {
155        const NAME: &'static str = "GmapMenuSequence.Label";
156        const NAMESPACE: &'static str = "App";
157
158        fn class() -> ::unity::Class {
159            static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
160            *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
161        }
162    }
163    impl ::unity::IlType for GmapMenuSequence_Label {
164        fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
165            &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
166        }
167    }
168    impl GmapMenuSequence_Label {
169        pub fn top_menu() -> Self {
170            Self { value: 0 }
171        }
172
173        pub fn enter_chapter() -> Self {
174            Self { value: 1 }
175        }
176
177        pub fn inventory() -> Self {
178            Self { value: 2 }
179        }
180
181        pub fn ring_select() -> Self {
182            Self { value: 3 }
183        }
184
185        pub fn ranking() -> Self {
186            Self { value: 4 }
187        }
188
189        pub fn material_list() -> Self {
190            Self { value: 5 }
191        }
192
193        pub fn save_data() -> Self {
194            Self { value: 6 }
195        }
196
197        pub fn go_to_solanel() -> Self {
198            Self { value: 7 }
199        }
200
201        pub fn end() -> Self {
202            Self { value: 8 }
203        }
204    }
205
206    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu.md"))]
207    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu")]
208    #[parent(crate::app::basicmenu::BasicMenu)]
209    pub struct GmapMenuSequence_GmapMenu {}
210
211    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GoToMapSequence.md"))]
212    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GoToMapSequence")]
213    #[parent(crate::app::procinst::ProcInst)]
214    pub struct GmapMenuSequence_GoToMapSequence {}
215
216    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_GoToSolanelItem.md"))]
217    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.GoToSolanelItem")]
218    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
219    pub struct GmapMenuSequence_GmapMenu_GoToSolanelItem {}
220
221    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem.md"))]
222    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.RankingItem.ConfirmSequence.NoMenuItem")]
223    #[parent(crate::app::basicdialogitemno::BasicDialogItemNo)]
224    pub struct GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem {}
225
226    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SystemItem.md"))]
227    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SystemItem")]
228    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
229    pub struct GmapMenuSequence_GmapMenu_SystemItem {}
230
231    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GoToMapSequence_Label.md"))]
232    #[repr(C)]
233    #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
234    pub struct GmapMenuSequence_GoToMapSequence_Label {
235        pub value: i32,
236    }
237    impl ::unity::ClassIdentity for GmapMenuSequence_GoToMapSequence_Label {
238        const NAME: &'static str = "GmapMenuSequence.GoToMapSequence.Label";
239        const NAMESPACE: &'static str = "App";
240
241        fn class() -> ::unity::Class {
242            static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
243            *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
244        }
245    }
246    impl ::unity::IlType for GmapMenuSequence_GoToMapSequence_Label {
247        fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
248            &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
249        }
250    }
251    impl GmapMenuSequence_GoToMapSequence_Label {
252        pub fn move_to_solanel() -> Self {
253            Self { value: 0 }
254        }
255
256        pub fn move_to_gmap() -> Self {
257            Self { value: 1 }
258        }
259
260        pub fn end() -> Self {
261            Self { value: 2 }
262        }
263    }
264
265    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem.md"))]
266    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubSystemMenu.ConfigItem")]
267    #[parent(crate::app::gmapmenusequence::GmapMenuSequence_GmapMenu_GmapMenuMenuItem)]
268    pub struct GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem {}
269
270    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence.md"))]
271    #[::unity::class(namespace = "App", name = "GmapMenuSequence")]
272    #[parent(crate::app::singletonprocinst_1::SingletonProcInst_1<crate::app::gmapmenusequence::GmapMenuSequence>)]
273    pub struct GmapMenuSequence {
274        #[offset(120)]
275        #[rename(name = "m_OpenTopCallback")]
276        pub m_open_top_callback: crate::system::action::Action,
277        #[offset(128)]
278        #[rename(name = "m_DecideCallback")]
279        pub m_decide_callback: crate::system::action::Action,
280        #[offset(136)]
281        #[rename(name = "m_CloseCallback")]
282        pub m_close_callback: crate::system::action::Action,
283    }
284
285    #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/gmapmenusequence/GmapMenuSequence_GmapMenu_SubShopMenu.md"))]
286    #[::unity::class(namespace = "App", name = "GmapMenuSequence.GmapMenu.SubShopMenu")]
287    #[parent(crate::app::basicmenu::BasicMenu)]
288    pub struct GmapMenuSequence_GmapMenu_SubShopMenu {}
289}
290
291#[cfg(feature = "app-gmapmenusequence-types")]
292pub use __types::*;
293
294#[cfg(feature = "app-gmapmenusequence")]
295pub trait IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItemMethods: IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem {
296    #[doc = "`GetName()` overload"]
297    fn get_name(self) -> ::unity::Il2CppString {
298        unsafe {
299            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
300                <Self as ::unity::SystemObject>::as_instance(self),
301            );
302            {
303                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
304                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
305                    panic!(
306                        "unity: virtual slot {}
307 out of range (vtable len {}
308) on the runtime class behind {}
309 (method `{}
310`)",
311                        4usize,
312                        __vt.len(),
313                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
314                        "GetName",
315                    )
316                });
317                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
318                    ::core::mem::transmute(__vi.method_ptr);
319                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
320                __inner(__receiver, __mi)
321            }
322        }
323    }
324    #[doc = "`GetHelpText()` overload"]
325    fn get_help_text(self) -> ::unity::Il2CppString {
326        unsafe {
327            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
328                <Self as ::unity::SystemObject>::as_instance(self),
329            );
330            {
331                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
332                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
333                    panic!(
334                        "unity: virtual slot {}
335 out of range (vtable len {}
336) on the runtime class behind {}
337 (method `{}
338`)",
339                        28usize,
340                        __vt.len(),
341                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
342                        "GetHelpText",
343                    )
344                });
345                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
346                    ::core::mem::transmute(__vi.method_ptr);
347                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
348                __inner(__receiver, __mi)
349            }
350        }
351    }
352    #[doc = "`BuildAttribute()` overload"]
353    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
354        unsafe {
355            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
356                <Self as ::unity::SystemObject>::as_instance(self),
357            );
358            {
359                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
360                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
361                    panic!(
362                        "unity: virtual slot {}
363 out of range (vtable len {}
364) on the runtime class behind {}
365 (method `{}
366`)",
367                        8usize,
368                        __vt.len(),
369                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
370                        "BuildAttribute",
371                    )
372                });
373                let __inner: extern "C" fn(
374                    GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem,
375                    ::unity::OptionalMethod,
376                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
377                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
378                __inner(__receiver, __mi)
379            }
380        }
381    }
382    #[doc = "`ACall()` overload"]
383    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
384        unsafe {
385            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
386                <Self as ::unity::SystemObject>::as_instance(self),
387            );
388            {
389                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
390                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
391                    panic!(
392                        "unity: virtual slot {}
393 out of range (vtable len {}
394) on the runtime class behind {}
395 (method `{}
396`)",
397                        18usize,
398                        __vt.len(),
399                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
400                        "ACall",
401                    )
402                });
403                let __inner: extern "C" fn(
404                    GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem,
405                    ::unity::OptionalMethod,
406                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
407                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
408                __inner(__receiver, __mi)
409            }
410        }
411    }
412    #[doc = "`BCall()` overload"]
413    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
414        unsafe {
415            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
416                <Self as ::unity::SystemObject>::as_instance(self),
417            );
418            {
419                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
420                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
421                    panic!(
422                        "unity: virtual slot {}
423 out of range (vtable len {}
424) on the runtime class behind {}
425 (method `{}
426`)",
427                        19usize,
428                        __vt.len(),
429                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::ClassIdentity>::NAME,
430                        "BCall",
431                    )
432                });
433                let __inner: extern "C" fn(
434                    GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem,
435                    ::unity::OptionalMethod,
436                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
437                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
438                __inner(__receiver, __mi)
439            }
440        }
441    }
442    #[doc = "`.ctor()` overload"]
443    fn ctor(self) -> () {
444        unsafe {
445            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem as ::unity::FromIlInstance>::from_il_instance(
446                <Self as ::unity::SystemObject>::as_instance(self),
447            );
448            ::unity::il2cpp_call!((::unity::module_base()+0x22fe600usize)as*mut u8,();
449(GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem)__receiver)
450        }
451    }
452}
453
454#[cfg(feature = "app-gmapmenusequence")]
455impl<__T: IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem> IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItemMethods for __T {}
456
457#[cfg(feature = "app-gmapmenusequence")]
458impl GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem {
459    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
460        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
461    }
462
463    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
464        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
465    }
466
467    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
468        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
469    }
470
471    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
472        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
473    }
474
475    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
476        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
477    }
478
479    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
480        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
481    }
482}
483
484#[cfg(feature = "app-gmapmenusequence")]
485impl GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem {
486    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
487    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
488        let __mi = Self::get_name_method_info();
489        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
490        __inner(this.into(), ::core::option::Option::None)
491    }
492
493    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
494    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
495        let __mi = Self::get_help_text_method_info();
496        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
497        __inner(this.into(), ::core::option::Option::None)
498    }
499
500    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
501    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
502        let __mi = Self::build_attribute_method_info();
503        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
504            ::core::mem::transmute(__mi.method_ptr);
505        __inner(this.into(), ::core::option::Option::None)
506    }
507
508    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
509    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
510        let __mi = Self::a_call_method_info();
511        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
512            ::core::mem::transmute(__mi.method_ptr);
513        __inner(this.into(), ::core::option::Option::None)
514    }
515
516    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
517    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
518        let __mi = Self::b_call_method_info();
519        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
520            ::core::mem::transmute(__mi.method_ptr);
521        __inner(this.into(), ::core::option::Option::None)
522    }
523}
524
525#[cfg(feature = "app-gmapmenusequence")]
526impl GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem {
527    #[doc = "`.ctor()` — no args"]
528    pub fn new() -> Self {
529        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
530            panic!(
531                "{}
532::{}
533 failed to instantiate",
534                ::core::stringify!(GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem),
535                ::core::stringify!(new),
536            )
537        });
538        <Self as IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItemMethods>::ctor(this);
539        this
540    }
541}
542
543#[cfg(feature = "app-gmapmenusequence")]
544pub trait IGmapMenuSequence_GmapMenu_GodItemMethods: IGmapMenuSequence_GmapMenu_GodItem {
545    #[doc = "`GetName()` overload"]
546    fn get_name(self) -> ::unity::Il2CppString {
547        unsafe {
548            let __receiver =
549                <GmapMenuSequence_GmapMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
550            {
551                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
552                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
553                    panic!(
554                        "unity: virtual slot {}
555 out of range (vtable len {}
556) on the runtime class behind {}
557 (method `{}
558`)",
559                        4usize,
560                        __vt.len(),
561                        <GmapMenuSequence_GmapMenu_GodItem as ::unity::ClassIdentity>::NAME,
562                        "GetName",
563                    )
564                });
565                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GodItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
566                    ::core::mem::transmute(__vi.method_ptr);
567                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
568                __inner(__receiver, __mi)
569            }
570        }
571    }
572    #[doc = "`GetHelpText()` overload"]
573    fn get_help_text(self) -> ::unity::Il2CppString {
574        unsafe {
575            let __receiver =
576                <GmapMenuSequence_GmapMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
577            {
578                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
579                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
580                    panic!(
581                        "unity: virtual slot {}
582 out of range (vtable len {}
583) on the runtime class behind {}
584 (method `{}
585`)",
586                        28usize,
587                        __vt.len(),
588                        <GmapMenuSequence_GmapMenu_GodItem as ::unity::ClassIdentity>::NAME,
589                        "GetHelpText",
590                    )
591                });
592                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GodItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
593                    ::core::mem::transmute(__vi.method_ptr);
594                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
595                __inner(__receiver, __mi)
596            }
597        }
598    }
599    #[doc = "`BuildAttribute()` overload"]
600    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
601        unsafe {
602            let __receiver =
603                <GmapMenuSequence_GmapMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
604            {
605                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
606                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
607                    panic!(
608                        "unity: virtual slot {}
609 out of range (vtable len {}
610) on the runtime class behind {}
611 (method `{}
612`)",
613                        8usize,
614                        __vt.len(),
615                        <GmapMenuSequence_GmapMenu_GodItem as ::unity::ClassIdentity>::NAME,
616                        "BuildAttribute",
617                    )
618                });
619                let __inner: extern "C" fn(
620                    GmapMenuSequence_GmapMenu_GodItem,
621                    ::unity::OptionalMethod,
622                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::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                <GmapMenuSequence_GmapMenu_GodItem 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                        <GmapMenuSequence_GmapMenu_GodItem as ::unity::ClassIdentity>::NAME,
645                        "ACall",
646                    )
647                });
648                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GodItem, ::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                <GmapMenuSequence_GmapMenu_GodItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
660            ::unity::il2cpp_call!((::unity::module_base()+0x1b3c200usize)as*mut u8,();
661(GmapMenuSequence_GmapMenu_GodItem)__receiver)
662        }
663    }
664}
665
666#[cfg(feature = "app-gmapmenusequence")]
667impl<__T: IGmapMenuSequence_GmapMenu_GodItem> IGmapMenuSequence_GmapMenu_GodItemMethods for __T {}
668
669#[cfg(feature = "app-gmapmenusequence")]
670impl GmapMenuSequence_GmapMenu_GodItem {
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-gmapmenusequence")]
693impl GmapMenuSequence_GmapMenu_GodItem {
694    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GodItem`'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 `GmapMenuSequence_GmapMenu_GodItem`'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 `GmapMenuSequence_GmapMenu_GodItem`'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 `GmapMenuSequence_GmapMenu_GodItem`'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-gmapmenusequence")]
726impl GmapMenuSequence_GmapMenu_GodItem {
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!(GmapMenuSequence_GmapMenu_GodItem),
735                ::core::stringify!(new),
736            )
737        });
738        <Self as IGmapMenuSequence_GmapMenu_GodItemMethods>::ctor(this);
739        this
740    }
741}
742
743#[cfg(feature = "app-gmapmenusequence")]
744pub trait IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItemMethods: IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem {
745    #[doc = "`GetName()` overload"]
746    fn get_name(self) -> ::unity::Il2CppString {
747        unsafe {
748            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
749                <Self as ::unity::SystemObject>::as_instance(self),
750            );
751            {
752                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
753                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
754                    panic!(
755                        "unity: virtual slot {}
756 out of range (vtable len {}
757) on the runtime class behind {}
758 (method `{}
759`)",
760                        4usize,
761                        __vt.len(),
762                        <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
763                        "GetName",
764                    )
765                });
766                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
767                    ::core::mem::transmute(__vi.method_ptr);
768                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
769                __inner(__receiver, __mi)
770            }
771        }
772    }
773    #[doc = "`GetHelpText()` overload"]
774    fn get_help_text(self) -> ::unity::Il2CppString {
775        unsafe {
776            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
777                <Self as ::unity::SystemObject>::as_instance(self),
778            );
779            {
780                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
781                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
782                    panic!(
783                        "unity: virtual slot {}
784 out of range (vtable len {}
785) on the runtime class behind {}
786 (method `{}
787`)",
788                        28usize,
789                        __vt.len(),
790                        <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
791                        "GetHelpText",
792                    )
793                });
794                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
795                    ::core::mem::transmute(__vi.method_ptr);
796                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
797                __inner(__receiver, __mi)
798            }
799        }
800    }
801    #[doc = "`BuildAttribute()` overload"]
802    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
803        unsafe {
804            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
805                <Self as ::unity::SystemObject>::as_instance(self),
806            );
807            {
808                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
809                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
810                    panic!(
811                        "unity: virtual slot {}
812 out of range (vtable len {}
813) on the runtime class behind {}
814 (method `{}
815`)",
816                        8usize,
817                        __vt.len(),
818                        <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
819                        "BuildAttribute",
820                    )
821                });
822                let __inner: extern "C" fn(
823                    GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem,
824                    ::unity::OptionalMethod,
825                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
826                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
827                __inner(__receiver, __mi)
828            }
829        }
830    }
831    #[doc = "`ACall()` overload"]
832    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
833        unsafe {
834            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
835                <Self as ::unity::SystemObject>::as_instance(self),
836            );
837            {
838                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
839                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
840                    panic!(
841                        "unity: virtual slot {}
842 out of range (vtable len {}
843) on the runtime class behind {}
844 (method `{}
845`)",
846                        18usize,
847                        __vt.len(),
848                        <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
849                        "ACall",
850                    )
851                });
852                let __inner: extern "C" fn(
853                    GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem,
854                    ::unity::OptionalMethod,
855                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
856                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
857                __inner(__receiver, __mi)
858            }
859        }
860    }
861    #[doc = "`BCall()` overload"]
862    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
863        unsafe {
864            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
865                <Self as ::unity::SystemObject>::as_instance(self),
866            );
867            {
868                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
869                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
870                    panic!(
871                        "unity: virtual slot {}
872 out of range (vtable len {}
873) on the runtime class behind {}
874 (method `{}
875`)",
876                        19usize,
877                        __vt.len(),
878                        <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::ClassIdentity>::NAME,
879                        "BCall",
880                    )
881                });
882                let __inner: extern "C" fn(
883                    GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem,
884                    ::unity::OptionalMethod,
885                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
886                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
887                __inner(__receiver, __mi)
888            }
889        }
890    }
891    #[doc = "`.ctor()` overload"]
892    fn ctor(self) -> () {
893        unsafe {
894            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem as ::unity::FromIlInstance>::from_il_instance(
895                <Self as ::unity::SystemObject>::as_instance(self),
896            );
897            ::unity::il2cpp_call!((::unity::module_base()+0x22ff340usize)as*mut u8,();
898(GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem)__receiver)
899        }
900    }
901}
902
903#[cfg(feature = "app-gmapmenusequence")]
904impl<__T: IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem> IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItemMethods for __T {}
905
906#[cfg(feature = "app-gmapmenusequence")]
907impl GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem {
908    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
909        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
910    }
911
912    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
913        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
914    }
915
916    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
917        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
918    }
919
920    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
921        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
922    }
923
924    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
925        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
926    }
927
928    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
929        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
930    }
931}
932
933#[cfg(feature = "app-gmapmenusequence")]
934impl GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem {
935    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
936    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
937        let __mi = Self::get_name_method_info();
938        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
939        __inner(this.into(), ::core::option::Option::None)
940    }
941
942    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
943    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
944        let __mi = Self::get_help_text_method_info();
945        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
946        __inner(this.into(), ::core::option::Option::None)
947    }
948
949    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
950    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
951        let __mi = Self::build_attribute_method_info();
952        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
953            ::core::mem::transmute(__mi.method_ptr);
954        __inner(this.into(), ::core::option::Option::None)
955    }
956
957    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
958    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
959        let __mi = Self::a_call_method_info();
960        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
961            ::core::mem::transmute(__mi.method_ptr);
962        __inner(this.into(), ::core::option::Option::None)
963    }
964
965    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
966    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
967        let __mi = Self::b_call_method_info();
968        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
969            ::core::mem::transmute(__mi.method_ptr);
970        __inner(this.into(), ::core::option::Option::None)
971    }
972}
973
974#[cfg(feature = "app-gmapmenusequence")]
975impl GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem {
976    #[doc = "`.ctor()` — no args"]
977    pub fn new() -> Self {
978        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
979            panic!(
980                "{}
981::{}
982 failed to instantiate",
983                ::core::stringify!(GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem),
984                ::core::stringify!(new),
985            )
986        });
987        <Self as IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItemMethods>::ctor(this);
988        this
989    }
990}
991
992#[cfg(feature = "app-gmapmenusequence")]
993pub trait IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItemMethods: IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem {
994    #[doc = "`GetName()` overload"]
995    fn get_name(self) -> ::unity::Il2CppString {
996        unsafe {
997            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
998                <Self as ::unity::SystemObject>::as_instance(self),
999            );
1000            {
1001                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1002                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1003                    panic!(
1004                        "unity: virtual slot {}
1005 out of range (vtable len {}
1006) on the runtime class behind {}
1007 (method `{}
1008`)",
1009                        4usize,
1010                        __vt.len(),
1011                        <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1012                        "GetName",
1013                    )
1014                });
1015                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1016                    ::core::mem::transmute(__vi.method_ptr);
1017                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1018                __inner(__receiver, __mi)
1019            }
1020        }
1021    }
1022    #[doc = "`GetHelpText()` overload"]
1023    fn get_help_text(self) -> ::unity::Il2CppString {
1024        unsafe {
1025            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
1026                <Self as ::unity::SystemObject>::as_instance(self),
1027            );
1028            {
1029                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1030                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1031                    panic!(
1032                        "unity: virtual slot {}
1033 out of range (vtable len {}
1034) on the runtime class behind {}
1035 (method `{}
1036`)",
1037                        28usize,
1038                        __vt.len(),
1039                        <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1040                        "GetHelpText",
1041                    )
1042                });
1043                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1044                    ::core::mem::transmute(__vi.method_ptr);
1045                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1046                __inner(__receiver, __mi)
1047            }
1048        }
1049    }
1050    #[doc = "`BuildAttribute()` overload"]
1051    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1052        unsafe {
1053            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
1054                <Self as ::unity::SystemObject>::as_instance(self),
1055            );
1056            {
1057                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1058                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1059                    panic!(
1060                        "unity: virtual slot {}
1061 out of range (vtable len {}
1062) on the runtime class behind {}
1063 (method `{}
1064`)",
1065                        8usize,
1066                        __vt.len(),
1067                        <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1068                        "BuildAttribute",
1069                    )
1070                });
1071                let __inner: extern "C" fn(
1072                    GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem,
1073                    ::unity::OptionalMethod,
1074                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1075                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1076                __inner(__receiver, __mi)
1077            }
1078        }
1079    }
1080    #[doc = "`ACall()` overload"]
1081    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1082        unsafe {
1083            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
1084                <Self as ::unity::SystemObject>::as_instance(self),
1085            );
1086            {
1087                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1088                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1089                    panic!(
1090                        "unity: virtual slot {}
1091 out of range (vtable len {}
1092) on the runtime class behind {}
1093 (method `{}
1094`)",
1095                        18usize,
1096                        __vt.len(),
1097                        <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1098                        "ACall",
1099                    )
1100                });
1101                let __inner: extern "C" fn(
1102                    GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem,
1103                    ::unity::OptionalMethod,
1104                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1105                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1106                __inner(__receiver, __mi)
1107            }
1108        }
1109    }
1110    #[doc = "`BCall()` overload"]
1111    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1112        unsafe {
1113            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
1114                <Self as ::unity::SystemObject>::as_instance(self),
1115            );
1116            {
1117                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1118                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1119                    panic!(
1120                        "unity: virtual slot {}
1121 out of range (vtable len {}
1122) on the runtime class behind {}
1123 (method `{}
1124`)",
1125                        19usize,
1126                        __vt.len(),
1127                        <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::ClassIdentity>::NAME,
1128                        "BCall",
1129                    )
1130                });
1131                let __inner: extern "C" fn(
1132                    GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem,
1133                    ::unity::OptionalMethod,
1134                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1135                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1136                __inner(__receiver, __mi)
1137            }
1138        }
1139    }
1140    #[doc = "`.ctor()` overload"]
1141    fn ctor(self) -> () {
1142        unsafe {
1143            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem as ::unity::FromIlInstance>::from_il_instance(
1144                <Self as ::unity::SystemObject>::as_instance(self),
1145            );
1146            ::unity::il2cpp_call!((::unity::module_base()+0x22fe050usize)as*mut u8,();
1147(GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem)__receiver)
1148        }
1149    }
1150}
1151
1152#[cfg(feature = "app-gmapmenusequence")]
1153impl<__T: IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem> IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItemMethods for __T {}
1154
1155#[cfg(feature = "app-gmapmenusequence")]
1156impl GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem {
1157    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1158        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1159    }
1160
1161    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1162        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1163    }
1164
1165    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1166        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1167    }
1168
1169    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1170        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1171    }
1172
1173    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1174        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1175    }
1176
1177    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1178        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1179    }
1180}
1181
1182#[cfg(feature = "app-gmapmenusequence")]
1183impl GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem {
1184    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1185    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1186        let __mi = Self::get_name_method_info();
1187        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1188        __inner(this.into(), ::core::option::Option::None)
1189    }
1190
1191    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1192    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1193        let __mi = Self::get_help_text_method_info();
1194        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1195        __inner(this.into(), ::core::option::Option::None)
1196    }
1197
1198    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1199    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1200        let __mi = Self::build_attribute_method_info();
1201        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1202            ::core::mem::transmute(__mi.method_ptr);
1203        __inner(this.into(), ::core::option::Option::None)
1204    }
1205
1206    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1207    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1208        let __mi = Self::a_call_method_info();
1209        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1210            ::core::mem::transmute(__mi.method_ptr);
1211        __inner(this.into(), ::core::option::Option::None)
1212    }
1213
1214    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1215    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1216        let __mi = Self::b_call_method_info();
1217        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1218            ::core::mem::transmute(__mi.method_ptr);
1219        __inner(this.into(), ::core::option::Option::None)
1220    }
1221}
1222
1223#[cfg(feature = "app-gmapmenusequence")]
1224impl GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem {
1225    #[doc = "`.ctor()` — no args"]
1226    pub fn new() -> Self {
1227        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1228            panic!(
1229                "{}
1230::{}
1231 failed to instantiate",
1232                ::core::stringify!(GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem),
1233                ::core::stringify!(new),
1234            )
1235        });
1236        <Self as IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItemMethods>::ctor(this);
1237        this
1238    }
1239}
1240
1241#[cfg(feature = "app-gmapmenusequence")]
1242impl GmapMenuSequence_GmapMenu_SubFriendMenu {
1243    #[doc = "`CreateBind(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
1244    pub fn create_bind(
1245        super_: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
1246        parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
1247    ) -> () {
1248        unsafe {
1249            ::unity::il2cpp_call!((::unity::module_base()+0x1b3b5e0usize)as*mut u8,();
1250(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(super_),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
1251        }
1252    }
1253}
1254
1255#[cfg(feature = "app-gmapmenusequence")]
1256pub trait IGmapMenuSequence_GmapMenu_SubFriendMenuMethods: IGmapMenuSequence_GmapMenu_SubFriendMenu {
1257    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` overload"]
1258    fn ctor(
1259        self,
1260        menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
1261        menu_content: impl ::core::convert::Into<crate::app::sortiesubmenucontent::SortieSubMenuContent>,
1262    ) -> () {
1263        unsafe {
1264            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu as ::unity::FromIlInstance>::from_il_instance(
1265                <Self as ::unity::SystemObject>::as_instance(self),
1266            );
1267            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d460usize)as*mut u8,();
1268(GmapMenuSequence_GmapMenu_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))
1269        }
1270    }
1271    #[doc = "`GetName()` overload"]
1272    fn get_name(self) -> ::unity::Il2CppString {
1273        unsafe {
1274            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu as ::unity::FromIlInstance>::from_il_instance(
1275                <Self as ::unity::SystemObject>::as_instance(self),
1276            );
1277            {
1278                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1279                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
1280                    panic!(
1281                        "unity: virtual slot {}
1282 out of range (vtable len {}
1283) on the runtime class behind {}
1284 (method `{}
1285`)",
1286                        30usize,
1287                        __vt.len(),
1288                        <GmapMenuSequence_GmapMenu_SubFriendMenu as ::unity::ClassIdentity>::NAME,
1289                        "GetName",
1290                    )
1291                });
1292                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1293                    ::core::mem::transmute(__vi.method_ptr);
1294                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1295                __inner(__receiver, __mi)
1296            }
1297        }
1298    }
1299}
1300
1301#[cfg(feature = "app-gmapmenusequence")]
1302impl<__T: IGmapMenuSequence_GmapMenu_SubFriendMenu> IGmapMenuSequence_GmapMenu_SubFriendMenuMethods for __T {}
1303
1304#[cfg(feature = "app-gmapmenusequence")]
1305impl GmapMenuSequence_GmapMenu_SubFriendMenu {
1306    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1307        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1308    }
1309
1310    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1311        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1312    }
1313
1314    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1315        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1316    }
1317}
1318
1319#[cfg(feature = "app-gmapmenusequence")]
1320impl GmapMenuSequence_GmapMenu_SubFriendMenu {
1321    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1322    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1323        let __mi = Self::get_name_method_info();
1324        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1325        __inner(this.into(), ::core::option::Option::None)
1326    }
1327}
1328
1329#[cfg(feature = "app-gmapmenusequence")]
1330impl GmapMenuSequence_GmapMenu_SubFriendMenu {
1331    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` — overload selector"]
1332    pub fn new(
1333        menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
1334        menu_content: crate::app::sortiesubmenucontent::SortieSubMenuContent,
1335    ) -> Self {
1336        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1337            panic!(
1338                "{}
1339::{}
1340 failed to instantiate",
1341                ::core::stringify!(GmapMenuSequence_GmapMenu_SubFriendMenu),
1342                ::core::stringify!(new),
1343            )
1344        });
1345        <Self as IGmapMenuSequence_GmapMenu_SubFriendMenuMethods>::ctor(this, menu_item_list, menu_content);
1346        this
1347    }
1348}
1349
1350#[cfg(feature = "app-gmapmenusequence")]
1351pub trait IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItemMethods: IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem {
1352    #[doc = "`GetName()` overload"]
1353    fn get_name(self) -> ::unity::Il2CppString {
1354        unsafe {
1355            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1356                <Self as ::unity::SystemObject>::as_instance(self),
1357            );
1358            {
1359                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1360                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1361                    panic!(
1362                        "unity: virtual slot {}
1363 out of range (vtable len {}
1364) on the runtime class behind {}
1365 (method `{}
1366`)",
1367                        4usize,
1368                        __vt.len(),
1369                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::ClassIdentity>::NAME,
1370                        "GetName",
1371                    )
1372                });
1373                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1374                    ::core::mem::transmute(__vi.method_ptr);
1375                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1376                __inner(__receiver, __mi)
1377            }
1378        }
1379    }
1380    #[doc = "`GetHelpText()` overload"]
1381    fn get_help_text(self) -> ::unity::Il2CppString {
1382        unsafe {
1383            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1384                <Self as ::unity::SystemObject>::as_instance(self),
1385            );
1386            {
1387                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1388                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1389                    panic!(
1390                        "unity: virtual slot {}
1391 out of range (vtable len {}
1392) on the runtime class behind {}
1393 (method `{}
1394`)",
1395                        28usize,
1396                        __vt.len(),
1397                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::ClassIdentity>::NAME,
1398                        "GetHelpText",
1399                    )
1400                });
1401                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1402                    ::core::mem::transmute(__vi.method_ptr);
1403                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1404                __inner(__receiver, __mi)
1405            }
1406        }
1407    }
1408    #[doc = "`BuildAttribute()` overload"]
1409    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1410        unsafe {
1411            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1412                <Self as ::unity::SystemObject>::as_instance(self),
1413            );
1414            {
1415                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1416                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1417                    panic!(
1418                        "unity: virtual slot {}
1419 out of range (vtable len {}
1420) on the runtime class behind {}
1421 (method `{}
1422`)",
1423                        8usize,
1424                        __vt.len(),
1425                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::ClassIdentity>::NAME,
1426                        "BuildAttribute",
1427                    )
1428                });
1429                let __inner: extern "C" fn(
1430                    GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem,
1431                    ::unity::OptionalMethod,
1432                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1433                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1434                __inner(__receiver, __mi)
1435            }
1436        }
1437    }
1438    #[doc = "`ACall()` overload"]
1439    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1440        unsafe {
1441            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1442                <Self as ::unity::SystemObject>::as_instance(self),
1443            );
1444            {
1445                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1446                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1447                    panic!(
1448                        "unity: virtual slot {}
1449 out of range (vtable len {}
1450) on the runtime class behind {}
1451 (method `{}
1452`)",
1453                        18usize,
1454                        __vt.len(),
1455                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::ClassIdentity>::NAME,
1456                        "ACall",
1457                    )
1458                });
1459                let __inner: extern "C" fn(
1460                    GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem,
1461                    ::unity::OptionalMethod,
1462                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1463                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1464                __inner(__receiver, __mi)
1465            }
1466        }
1467    }
1468    #[doc = "`BCall()` overload"]
1469    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1470        unsafe {
1471            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1472                <Self as ::unity::SystemObject>::as_instance(self),
1473            );
1474            {
1475                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1476                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
1477                    panic!(
1478                        "unity: virtual slot {}
1479 out of range (vtable len {}
1480) on the runtime class behind {}
1481 (method `{}
1482`)",
1483                        19usize,
1484                        __vt.len(),
1485                        <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::ClassIdentity>::NAME,
1486                        "BCall",
1487                    )
1488                });
1489                let __inner: extern "C" fn(
1490                    GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem,
1491                    ::unity::OptionalMethod,
1492                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1493                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1494                __inner(__receiver, __mi)
1495            }
1496        }
1497    }
1498    #[doc = "`.ctor()` overload"]
1499    fn ctor(self) -> () {
1500        unsafe {
1501            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem as ::unity::FromIlInstance>::from_il_instance(
1502                <Self as ::unity::SystemObject>::as_instance(self),
1503            );
1504            ::unity::il2cpp_call!((::unity::module_base()+0x22fe880usize)as*mut u8,();
1505(GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem)__receiver)
1506        }
1507    }
1508}
1509
1510#[cfg(feature = "app-gmapmenusequence")]
1511impl<__T: IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem> IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItemMethods for __T {}
1512
1513#[cfg(feature = "app-gmapmenusequence")]
1514impl GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem {
1515    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1516        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1517    }
1518
1519    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1520        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1521    }
1522
1523    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1524        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1525    }
1526
1527    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1528        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1529    }
1530
1531    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1532        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1533    }
1534
1535    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1537    }
1538}
1539
1540#[cfg(feature = "app-gmapmenusequence")]
1541impl GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem {
1542    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1543    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1544        let __mi = Self::get_name_method_info();
1545        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1546        __inner(this.into(), ::core::option::Option::None)
1547    }
1548
1549    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1550    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1551        let __mi = Self::get_help_text_method_info();
1552        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1553        __inner(this.into(), ::core::option::Option::None)
1554    }
1555
1556    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1557    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1558        let __mi = Self::build_attribute_method_info();
1559        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1560            ::core::mem::transmute(__mi.method_ptr);
1561        __inner(this.into(), ::core::option::Option::None)
1562    }
1563
1564    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1565    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1566        let __mi = Self::a_call_method_info();
1567        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1568            ::core::mem::transmute(__mi.method_ptr);
1569        __inner(this.into(), ::core::option::Option::None)
1570    }
1571
1572    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1573    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1574        let __mi = Self::b_call_method_info();
1575        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1576            ::core::mem::transmute(__mi.method_ptr);
1577        __inner(this.into(), ::core::option::Option::None)
1578    }
1579}
1580
1581#[cfg(feature = "app-gmapmenusequence")]
1582impl GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem {
1583    #[doc = "`.ctor()` — no args"]
1584    pub fn new() -> Self {
1585        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1586            panic!(
1587                "{}
1588::{}
1589 failed to instantiate",
1590                ::core::stringify!(GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem),
1591                ::core::stringify!(new),
1592            )
1593        });
1594        <Self as IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItemMethods>::ctor(this);
1595        this
1596    }
1597}
1598
1599#[cfg(feature = "app-gmapmenusequence")]
1600pub trait IGmapMenuSequence_GmapMenu_MaterialListItemMethods: IGmapMenuSequence_GmapMenu_MaterialListItem {
1601    #[doc = "`GetName()` overload"]
1602    fn get_name(self) -> ::unity::Il2CppString {
1603        unsafe {
1604            let __receiver = <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(
1605                <Self as ::unity::SystemObject>::as_instance(self),
1606            );
1607            {
1608                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1609                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1610                    panic!(
1611                        "unity: virtual slot {}
1612 out of range (vtable len {}
1613) on the runtime class behind {}
1614 (method `{}
1615`)",
1616                        4usize,
1617                        __vt.len(),
1618                        <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
1619                        "GetName",
1620                    )
1621                });
1622                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_MaterialListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1623                    ::core::mem::transmute(__vi.method_ptr);
1624                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1625                __inner(__receiver, __mi)
1626            }
1627        }
1628    }
1629    #[doc = "`GetHelpText()` overload"]
1630    fn get_help_text(self) -> ::unity::Il2CppString {
1631        unsafe {
1632            let __receiver = <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(
1633                <Self as ::unity::SystemObject>::as_instance(self),
1634            );
1635            {
1636                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1637                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1638                    panic!(
1639                        "unity: virtual slot {}
1640 out of range (vtable len {}
1641) on the runtime class behind {}
1642 (method `{}
1643`)",
1644                        28usize,
1645                        __vt.len(),
1646                        <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
1647                        "GetHelpText",
1648                    )
1649                });
1650                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_MaterialListItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1651                    ::core::mem::transmute(__vi.method_ptr);
1652                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1653                __inner(__receiver, __mi)
1654            }
1655        }
1656    }
1657    #[doc = "`BuildAttribute()` overload"]
1658    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1659        unsafe {
1660            let __receiver = <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(
1661                <Self as ::unity::SystemObject>::as_instance(self),
1662            );
1663            {
1664                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1665                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1666                    panic!(
1667                        "unity: virtual slot {}
1668 out of range (vtable len {}
1669) on the runtime class behind {}
1670 (method `{}
1671`)",
1672                        8usize,
1673                        __vt.len(),
1674                        <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
1675                        "BuildAttribute",
1676                    )
1677                });
1678                let __inner: extern "C" fn(
1679                    GmapMenuSequence_GmapMenu_MaterialListItem,
1680                    ::unity::OptionalMethod,
1681                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1682                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1683                __inner(__receiver, __mi)
1684            }
1685        }
1686    }
1687    #[doc = "`ACall()` overload"]
1688    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1689        unsafe {
1690            let __receiver = <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(
1691                <Self as ::unity::SystemObject>::as_instance(self),
1692            );
1693            {
1694                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1695                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1696                    panic!(
1697                        "unity: virtual slot {}
1698 out of range (vtable len {}
1699) on the runtime class behind {}
1700 (method `{}
1701`)",
1702                        18usize,
1703                        __vt.len(),
1704                        <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::ClassIdentity>::NAME,
1705                        "ACall",
1706                    )
1707                });
1708                let __inner: extern "C" fn(
1709                    GmapMenuSequence_GmapMenu_MaterialListItem,
1710                    ::unity::OptionalMethod,
1711                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1712                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1713                __inner(__receiver, __mi)
1714            }
1715        }
1716    }
1717    #[doc = "`.ctor()` overload"]
1718    fn ctor(self) -> () {
1719        unsafe {
1720            let __receiver = <GmapMenuSequence_GmapMenu_MaterialListItem as ::unity::FromIlInstance>::from_il_instance(
1721                <Self as ::unity::SystemObject>::as_instance(self),
1722            );
1723            ::unity::il2cpp_call!((::unity::module_base()+0x1b3c840usize)as*mut u8,();
1724(GmapMenuSequence_GmapMenu_MaterialListItem)__receiver)
1725        }
1726    }
1727}
1728
1729#[cfg(feature = "app-gmapmenusequence")]
1730impl<__T: IGmapMenuSequence_GmapMenu_MaterialListItem> IGmapMenuSequence_GmapMenu_MaterialListItemMethods for __T {}
1731
1732#[cfg(feature = "app-gmapmenusequence")]
1733impl GmapMenuSequence_GmapMenu_MaterialListItem {
1734    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1735        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1736    }
1737
1738    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1739        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1740    }
1741
1742    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1743        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1744    }
1745
1746    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1747        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1748    }
1749
1750    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1751        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1752    }
1753}
1754
1755#[cfg(feature = "app-gmapmenusequence")]
1756impl GmapMenuSequence_GmapMenu_MaterialListItem {
1757    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_MaterialListItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1758    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1759        let __mi = Self::get_name_method_info();
1760        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1761        __inner(this.into(), ::core::option::Option::None)
1762    }
1763
1764    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_MaterialListItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1765    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1766        let __mi = Self::get_help_text_method_info();
1767        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1768        __inner(this.into(), ::core::option::Option::None)
1769    }
1770
1771    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_MaterialListItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1772    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1773        let __mi = Self::build_attribute_method_info();
1774        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
1775            ::core::mem::transmute(__mi.method_ptr);
1776        __inner(this.into(), ::core::option::Option::None)
1777    }
1778
1779    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_MaterialListItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1780    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
1781        let __mi = Self::a_call_method_info();
1782        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
1783            ::core::mem::transmute(__mi.method_ptr);
1784        __inner(this.into(), ::core::option::Option::None)
1785    }
1786}
1787
1788#[cfg(feature = "app-gmapmenusequence")]
1789impl GmapMenuSequence_GmapMenu_MaterialListItem {
1790    #[doc = "`.ctor()` — no args"]
1791    pub fn new() -> Self {
1792        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1793            panic!(
1794                "{}
1795::{}
1796 failed to instantiate",
1797                ::core::stringify!(GmapMenuSequence_GmapMenu_MaterialListItem),
1798                ::core::stringify!(new),
1799            )
1800        });
1801        <Self as IGmapMenuSequence_GmapMenu_MaterialListItemMethods>::ctor(this);
1802        this
1803    }
1804}
1805
1806#[cfg(feature = "app-gmapmenusequence")]
1807impl GmapMenuSequence_GmapMenu_EnterChapterItem {
1808    #[doc = "`get_Type()` overload"]
1809    pub fn get_type() -> crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type {
1810        unsafe {
1811            ::unity::il2cpp_call!((::unity::module_base()+0x1b3aab0usize)as*mut u8,crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type;
1812            )
1813        }
1814    }
1815
1816    #[doc = "`set_Type(crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type)` overload"]
1817    pub fn set_type(value: impl ::core::convert::Into<crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type>) -> () {
1818        unsafe {
1819            ::unity::il2cpp_call!((::unity::module_base()+0x1b3ab00usize)as*mut u8,();
1820(crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type)::core::convert::Into::into(value))
1821        }
1822    }
1823}
1824
1825#[cfg(feature = "app-gmapmenusequence")]
1826pub trait IGmapMenuSequence_GmapMenu_EnterChapterItemMethods: IGmapMenuSequence_GmapMenu_EnterChapterItem {
1827    #[doc = "`.ctor(crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type)` overload"]
1828    fn ctor(self, r#type: impl ::core::convert::Into<crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type>) -> () {
1829        unsafe {
1830            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1831                <Self as ::unity::SystemObject>::as_instance(self),
1832            );
1833            ::unity::il2cpp_call!((::unity::module_base()+0x1b3ab60usize)as*mut u8,();
1834(GmapMenuSequence_GmapMenu_EnterChapterItem)__receiver,(crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type)::core::convert::Into::into(r#type))
1835        }
1836    }
1837    #[doc = "`GetName()` overload"]
1838    fn get_name(self) -> ::unity::Il2CppString {
1839        unsafe {
1840            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1841                <Self as ::unity::SystemObject>::as_instance(self),
1842            );
1843            {
1844                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1845                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1846                    panic!(
1847                        "unity: virtual slot {}
1848 out of range (vtable len {}
1849) on the runtime class behind {}
1850 (method `{}
1851`)",
1852                        4usize,
1853                        __vt.len(),
1854                        <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::ClassIdentity>::NAME,
1855                        "GetName",
1856                    )
1857                });
1858                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_EnterChapterItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1859                    ::core::mem::transmute(__vi.method_ptr);
1860                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1861                __inner(__receiver, __mi)
1862            }
1863        }
1864    }
1865    #[doc = "`GetHelpText()` overload"]
1866    fn get_help_text(self) -> ::unity::Il2CppString {
1867        unsafe {
1868            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1869                <Self as ::unity::SystemObject>::as_instance(self),
1870            );
1871            {
1872                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1873                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
1874                    panic!(
1875                        "unity: virtual slot {}
1876 out of range (vtable len {}
1877) on the runtime class behind {}
1878 (method `{}
1879`)",
1880                        28usize,
1881                        __vt.len(),
1882                        <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::ClassIdentity>::NAME,
1883                        "GetHelpText",
1884                    )
1885                });
1886                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_EnterChapterItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1887                    ::core::mem::transmute(__vi.method_ptr);
1888                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1889                __inner(__receiver, __mi)
1890            }
1891        }
1892    }
1893    #[doc = "`OnBuild()` overload"]
1894    fn on_build(self) -> () {
1895        unsafe {
1896            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1897                <Self as ::unity::SystemObject>::as_instance(self),
1898            );
1899            {
1900                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1901                let __vi = *__vt.get(10usize).unwrap_or_else(|| {
1902                    panic!(
1903                        "unity: virtual slot {}
1904 out of range (vtable len {}
1905) on the runtime class behind {}
1906 (method `{}
1907`)",
1908                        10usize,
1909                        __vt.len(),
1910                        <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::ClassIdentity>::NAME,
1911                        "OnBuild",
1912                    )
1913                });
1914                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_EnterChapterItem, ::unity::OptionalMethod) -> () =
1915                    ::core::mem::transmute(__vi.method_ptr);
1916                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1917                __inner(__receiver, __mi)
1918            }
1919        }
1920    }
1921    #[doc = "`BuildAttribute()` overload"]
1922    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
1923        unsafe {
1924            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1925                <Self as ::unity::SystemObject>::as_instance(self),
1926            );
1927            {
1928                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1929                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
1930                    panic!(
1931                        "unity: virtual slot {}
1932 out of range (vtable len {}
1933) on the runtime class behind {}
1934 (method `{}
1935`)",
1936                        8usize,
1937                        __vt.len(),
1938                        <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::ClassIdentity>::NAME,
1939                        "BuildAttribute",
1940                    )
1941                });
1942                let __inner: extern "C" fn(
1943                    GmapMenuSequence_GmapMenu_EnterChapterItem,
1944                    ::unity::OptionalMethod,
1945                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
1946                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1947                __inner(__receiver, __mi)
1948            }
1949        }
1950    }
1951    #[doc = "`ACall()` overload"]
1952    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
1953        unsafe {
1954            let __receiver = <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::FromIlInstance>::from_il_instance(
1955                <Self as ::unity::SystemObject>::as_instance(self),
1956            );
1957            {
1958                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1959                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
1960                    panic!(
1961                        "unity: virtual slot {}
1962 out of range (vtable len {}
1963) on the runtime class behind {}
1964 (method `{}
1965`)",
1966                        18usize,
1967                        __vt.len(),
1968                        <GmapMenuSequence_GmapMenu_EnterChapterItem as ::unity::ClassIdentity>::NAME,
1969                        "ACall",
1970                    )
1971                });
1972                let __inner: extern "C" fn(
1973                    GmapMenuSequence_GmapMenu_EnterChapterItem,
1974                    ::unity::OptionalMethod,
1975                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
1976                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1977                __inner(__receiver, __mi)
1978            }
1979        }
1980    }
1981}
1982
1983#[cfg(feature = "app-gmapmenusequence")]
1984impl<__T: IGmapMenuSequence_GmapMenu_EnterChapterItem> IGmapMenuSequence_GmapMenu_EnterChapterItemMethods for __T {}
1985
1986#[cfg(feature = "app-gmapmenusequence")]
1987impl GmapMenuSequence_GmapMenu_EnterChapterItem {
1988    pub fn get_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1989        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1990    }
1991
1992    pub fn set_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1993        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1994    }
1995
1996    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1997        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1998    }
1999
2000    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2001        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2002    }
2003
2004    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2005        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2006    }
2007
2008    pub fn on_build_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2009        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2010    }
2011
2012    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2013        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2014    }
2015
2016    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2017        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2018    }
2019}
2020
2021#[cfg(feature = "app-gmapmenusequence")]
2022impl GmapMenuSequence_GmapMenu_EnterChapterItem {
2023    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_EnterChapterItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2024    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2025        let __mi = Self::get_name_method_info();
2026        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2027        __inner(this.into(), ::core::option::Option::None)
2028    }
2029
2030    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_EnterChapterItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2031    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2032        let __mi = Self::get_help_text_method_info();
2033        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2034        __inner(this.into(), ::core::option::Option::None)
2035    }
2036
2037    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_EnterChapterItem`'s own `OnBuild`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2038    pub unsafe fn on_build(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2039        let __mi = Self::on_build_method_info();
2040        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2041        __inner(this.into(), ::core::option::Option::None)
2042    }
2043
2044    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_EnterChapterItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2045    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2046        let __mi = Self::build_attribute_method_info();
2047        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2048            ::core::mem::transmute(__mi.method_ptr);
2049        __inner(this.into(), ::core::option::Option::None)
2050    }
2051
2052    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_EnterChapterItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2053    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2054        let __mi = Self::a_call_method_info();
2055        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2056            ::core::mem::transmute(__mi.method_ptr);
2057        __inner(this.into(), ::core::option::Option::None)
2058    }
2059}
2060
2061#[cfg(feature = "app-gmapmenusequence")]
2062impl GmapMenuSequence_GmapMenu_EnterChapterItem {
2063    #[doc = "`.ctor(crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type)` — overload selector"]
2064    pub fn new(r#type: crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type) -> Self {
2065        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2066            panic!(
2067                "{}
2068::{}
2069 failed to instantiate",
2070                ::core::stringify!(GmapMenuSequence_GmapMenu_EnterChapterItem),
2071                ::core::stringify!(new),
2072            )
2073        });
2074        <Self as IGmapMenuSequence_GmapMenu_EnterChapterItemMethods>::ctor(this, r#type);
2075        this
2076    }
2077}
2078
2079#[cfg(feature = "app-gmapmenusequence")]
2080impl GmapMenuSequence_GmapMenu_SubSystemMenu {
2081    #[doc = "`CreateBind(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
2082    pub fn create_bind(
2083        super_: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
2084        parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
2085    ) -> () {
2086        unsafe {
2087            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d580usize)as*mut u8,();
2088(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(super_),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
2089        }
2090    }
2091}
2092
2093#[cfg(feature = "app-gmapmenusequence")]
2094pub trait IGmapMenuSequence_GmapMenu_SubSystemMenuMethods: IGmapMenuSequence_GmapMenu_SubSystemMenu {
2095    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` overload"]
2096    fn ctor(
2097        self,
2098        menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
2099        menu_content: impl ::core::convert::Into<crate::app::sortiesubmenucontent::SortieSubMenuContent>,
2100    ) -> () {
2101        unsafe {
2102            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu as ::unity::FromIlInstance>::from_il_instance(
2103                <Self as ::unity::SystemObject>::as_instance(self),
2104            );
2105            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d520usize)as*mut u8,();
2106(GmapMenuSequence_GmapMenu_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))
2107        }
2108    }
2109    #[doc = "`GetName()` overload"]
2110    fn get_name(self) -> ::unity::Il2CppString {
2111        unsafe {
2112            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu as ::unity::FromIlInstance>::from_il_instance(
2113                <Self as ::unity::SystemObject>::as_instance(self),
2114            );
2115            {
2116                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2117                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
2118                    panic!(
2119                        "unity: virtual slot {}
2120 out of range (vtable len {}
2121) on the runtime class behind {}
2122 (method `{}
2123`)",
2124                        30usize,
2125                        __vt.len(),
2126                        <GmapMenuSequence_GmapMenu_SubSystemMenu as ::unity::ClassIdentity>::NAME,
2127                        "GetName",
2128                    )
2129                });
2130                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2131                    ::core::mem::transmute(__vi.method_ptr);
2132                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2133                __inner(__receiver, __mi)
2134            }
2135        }
2136    }
2137}
2138
2139#[cfg(feature = "app-gmapmenusequence")]
2140impl<__T: IGmapMenuSequence_GmapMenu_SubSystemMenu> IGmapMenuSequence_GmapMenu_SubSystemMenuMethods for __T {}
2141
2142#[cfg(feature = "app-gmapmenusequence")]
2143impl GmapMenuSequence_GmapMenu_SubSystemMenu {
2144    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2145        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2146    }
2147
2148    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2149        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2150    }
2151
2152    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2153        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2154    }
2155}
2156
2157#[cfg(feature = "app-gmapmenusequence")]
2158impl GmapMenuSequence_GmapMenu_SubSystemMenu {
2159    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2160    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2161        let __mi = Self::get_name_method_info();
2162        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2163        __inner(this.into(), ::core::option::Option::None)
2164    }
2165}
2166
2167#[cfg(feature = "app-gmapmenusequence")]
2168impl GmapMenuSequence_GmapMenu_SubSystemMenu {
2169    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` — overload selector"]
2170    pub fn new(
2171        menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
2172        menu_content: crate::app::sortiesubmenucontent::SortieSubMenuContent,
2173    ) -> Self {
2174        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2175            panic!(
2176                "{}
2177::{}
2178 failed to instantiate",
2179                ::core::stringify!(GmapMenuSequence_GmapMenu_SubSystemMenu),
2180                ::core::stringify!(new),
2181            )
2182        });
2183        <Self as IGmapMenuSequence_GmapMenu_SubSystemMenuMethods>::ctor(this, menu_item_list, menu_content);
2184        this
2185    }
2186}
2187
2188#[cfg(feature = "app-gmapmenusequence")]
2189pub trait IGmapMenuSequence_GmapMenu_SaveItemMethods: IGmapMenuSequence_GmapMenu_SaveItem {
2190    #[doc = "`GetName()` overload"]
2191    fn get_name(self) -> ::unity::Il2CppString {
2192        unsafe {
2193            let __receiver =
2194                <GmapMenuSequence_GmapMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2195            {
2196                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2197                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2198                    panic!(
2199                        "unity: virtual slot {}
2200 out of range (vtable len {}
2201) on the runtime class behind {}
2202 (method `{}
2203`)",
2204                        4usize,
2205                        __vt.len(),
2206                        <GmapMenuSequence_GmapMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2207                        "GetName",
2208                    )
2209                });
2210                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SaveItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2211                    ::core::mem::transmute(__vi.method_ptr);
2212                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2213                __inner(__receiver, __mi)
2214            }
2215        }
2216    }
2217    #[doc = "`GetHelpText()` overload"]
2218    fn get_help_text(self) -> ::unity::Il2CppString {
2219        unsafe {
2220            let __receiver =
2221                <GmapMenuSequence_GmapMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2222            {
2223                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2224                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2225                    panic!(
2226                        "unity: virtual slot {}
2227 out of range (vtable len {}
2228) on the runtime class behind {}
2229 (method `{}
2230`)",
2231                        28usize,
2232                        __vt.len(),
2233                        <GmapMenuSequence_GmapMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2234                        "GetHelpText",
2235                    )
2236                });
2237                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SaveItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2238                    ::core::mem::transmute(__vi.method_ptr);
2239                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2240                __inner(__receiver, __mi)
2241            }
2242        }
2243    }
2244    #[doc = "`BuildAttribute()` overload"]
2245    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2246        unsafe {
2247            let __receiver =
2248                <GmapMenuSequence_GmapMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2249            {
2250                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2251                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2252                    panic!(
2253                        "unity: virtual slot {}
2254 out of range (vtable len {}
2255) on the runtime class behind {}
2256 (method `{}
2257`)",
2258                        8usize,
2259                        __vt.len(),
2260                        <GmapMenuSequence_GmapMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2261                        "BuildAttribute",
2262                    )
2263                });
2264                let __inner: extern "C" fn(
2265                    GmapMenuSequence_GmapMenu_SaveItem,
2266                    ::unity::OptionalMethod,
2267                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2268                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2269                __inner(__receiver, __mi)
2270            }
2271        }
2272    }
2273    #[doc = "`ACall()` overload"]
2274    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2275        unsafe {
2276            let __receiver =
2277                <GmapMenuSequence_GmapMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2278            {
2279                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2280                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2281                    panic!(
2282                        "unity: virtual slot {}
2283 out of range (vtable len {}
2284) on the runtime class behind {}
2285 (method `{}
2286`)",
2287                        18usize,
2288                        __vt.len(),
2289                        <GmapMenuSequence_GmapMenu_SaveItem as ::unity::ClassIdentity>::NAME,
2290                        "ACall",
2291                    )
2292                });
2293                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SaveItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2294                    ::core::mem::transmute(__vi.method_ptr);
2295                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2296                __inner(__receiver, __mi)
2297            }
2298        }
2299    }
2300    #[doc = "`.ctor()` overload"]
2301    fn ctor(self) -> () {
2302        unsafe {
2303            let __receiver =
2304                <GmapMenuSequence_GmapMenu_SaveItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2305            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d090usize)as*mut u8,();
2306(GmapMenuSequence_GmapMenu_SaveItem)__receiver)
2307        }
2308    }
2309}
2310
2311#[cfg(feature = "app-gmapmenusequence")]
2312impl<__T: IGmapMenuSequence_GmapMenu_SaveItem> IGmapMenuSequence_GmapMenu_SaveItemMethods for __T {}
2313
2314#[cfg(feature = "app-gmapmenusequence")]
2315impl GmapMenuSequence_GmapMenu_SaveItem {
2316    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2317        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2318    }
2319
2320    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2321        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2322    }
2323
2324    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2325        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2326    }
2327
2328    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2329        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2330    }
2331
2332    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2333        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2334    }
2335}
2336
2337#[cfg(feature = "app-gmapmenusequence")]
2338impl GmapMenuSequence_GmapMenu_SaveItem {
2339    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SaveItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2340    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2341        let __mi = Self::get_name_method_info();
2342        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2343        __inner(this.into(), ::core::option::Option::None)
2344    }
2345
2346    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SaveItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2347    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2348        let __mi = Self::get_help_text_method_info();
2349        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2350        __inner(this.into(), ::core::option::Option::None)
2351    }
2352
2353    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SaveItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2354    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2355        let __mi = Self::build_attribute_method_info();
2356        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2357            ::core::mem::transmute(__mi.method_ptr);
2358        __inner(this.into(), ::core::option::Option::None)
2359    }
2360
2361    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SaveItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2362    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2363        let __mi = Self::a_call_method_info();
2364        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2365            ::core::mem::transmute(__mi.method_ptr);
2366        __inner(this.into(), ::core::option::Option::None)
2367    }
2368}
2369
2370#[cfg(feature = "app-gmapmenusequence")]
2371impl GmapMenuSequence_GmapMenu_SaveItem {
2372    #[doc = "`.ctor()` — no args"]
2373    pub fn new() -> Self {
2374        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2375            panic!(
2376                "{}
2377::{}
2378 failed to instantiate",
2379                ::core::stringify!(GmapMenuSequence_GmapMenu_SaveItem),
2380                ::core::stringify!(new),
2381            )
2382        });
2383        <Self as IGmapMenuSequence_GmapMenu_SaveItemMethods>::ctor(this);
2384        this
2385    }
2386}
2387
2388#[cfg(feature = "app-gmapmenusequence")]
2389pub trait IGmapMenuSequence_GmapMenu_ShopItemMethods: IGmapMenuSequence_GmapMenu_ShopItem {
2390    #[doc = "`GetName()` overload"]
2391    fn get_name(self) -> ::unity::Il2CppString {
2392        unsafe {
2393            let __receiver =
2394                <GmapMenuSequence_GmapMenu_ShopItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2395            {
2396                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2397                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2398                    panic!(
2399                        "unity: virtual slot {}
2400 out of range (vtable len {}
2401) on the runtime class behind {}
2402 (method `{}
2403`)",
2404                        4usize,
2405                        __vt.len(),
2406                        <GmapMenuSequence_GmapMenu_ShopItem as ::unity::ClassIdentity>::NAME,
2407                        "GetName",
2408                    )
2409                });
2410                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_ShopItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2411                    ::core::mem::transmute(__vi.method_ptr);
2412                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2413                __inner(__receiver, __mi)
2414            }
2415        }
2416    }
2417    #[doc = "`GetHelpText()` overload"]
2418    fn get_help_text(self) -> ::unity::Il2CppString {
2419        unsafe {
2420            let __receiver =
2421                <GmapMenuSequence_GmapMenu_ShopItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2422            {
2423                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2424                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2425                    panic!(
2426                        "unity: virtual slot {}
2427 out of range (vtable len {}
2428) on the runtime class behind {}
2429 (method `{}
2430`)",
2431                        28usize,
2432                        __vt.len(),
2433                        <GmapMenuSequence_GmapMenu_ShopItem as ::unity::ClassIdentity>::NAME,
2434                        "GetHelpText",
2435                    )
2436                });
2437                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_ShopItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2438                    ::core::mem::transmute(__vi.method_ptr);
2439                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2440                __inner(__receiver, __mi)
2441            }
2442        }
2443    }
2444    #[doc = "`BuildAttribute()` overload"]
2445    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2446        unsafe {
2447            let __receiver =
2448                <GmapMenuSequence_GmapMenu_ShopItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2449            {
2450                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2451                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
2452                    panic!(
2453                        "unity: virtual slot {}
2454 out of range (vtable len {}
2455) on the runtime class behind {}
2456 (method `{}
2457`)",
2458                        8usize,
2459                        __vt.len(),
2460                        <GmapMenuSequence_GmapMenu_ShopItem as ::unity::ClassIdentity>::NAME,
2461                        "BuildAttribute",
2462                    )
2463                });
2464                let __inner: extern "C" fn(
2465                    GmapMenuSequence_GmapMenu_ShopItem,
2466                    ::unity::OptionalMethod,
2467                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2468                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2469                __inner(__receiver, __mi)
2470            }
2471        }
2472    }
2473    #[doc = "`ACall()` overload"]
2474    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2475        unsafe {
2476            let __receiver =
2477                <GmapMenuSequence_GmapMenu_ShopItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2478            {
2479                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2480                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2481                    panic!(
2482                        "unity: virtual slot {}
2483 out of range (vtable len {}
2484) on the runtime class behind {}
2485 (method `{}
2486`)",
2487                        18usize,
2488                        __vt.len(),
2489                        <GmapMenuSequence_GmapMenu_ShopItem as ::unity::ClassIdentity>::NAME,
2490                        "ACall",
2491                    )
2492                });
2493                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_ShopItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2494                    ::core::mem::transmute(__vi.method_ptr);
2495                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2496                __inner(__receiver, __mi)
2497            }
2498        }
2499    }
2500    #[doc = "`.ctor()` overload"]
2501    fn ctor(self) -> () {
2502        unsafe {
2503            let __receiver =
2504                <GmapMenuSequence_GmapMenu_ShopItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2505            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d450usize)as*mut u8,();
2506(GmapMenuSequence_GmapMenu_ShopItem)__receiver)
2507        }
2508    }
2509}
2510
2511#[cfg(feature = "app-gmapmenusequence")]
2512impl<__T: IGmapMenuSequence_GmapMenu_ShopItem> IGmapMenuSequence_GmapMenu_ShopItemMethods for __T {}
2513
2514#[cfg(feature = "app-gmapmenusequence")]
2515impl GmapMenuSequence_GmapMenu_ShopItem {
2516    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2517        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2518    }
2519
2520    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2521        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2522    }
2523
2524    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2525        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2526    }
2527
2528    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2529        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2530    }
2531
2532    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2533        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2534    }
2535}
2536
2537#[cfg(feature = "app-gmapmenusequence")]
2538impl GmapMenuSequence_GmapMenu_ShopItem {
2539    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_ShopItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2540    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2541        let __mi = Self::get_name_method_info();
2542        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2543        __inner(this.into(), ::core::option::Option::None)
2544    }
2545
2546    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_ShopItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2547    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2548        let __mi = Self::get_help_text_method_info();
2549        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2550        __inner(this.into(), ::core::option::Option::None)
2551    }
2552
2553    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_ShopItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2554    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2555        let __mi = Self::build_attribute_method_info();
2556        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2557            ::core::mem::transmute(__mi.method_ptr);
2558        __inner(this.into(), ::core::option::Option::None)
2559    }
2560
2561    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_ShopItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2562    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2563        let __mi = Self::a_call_method_info();
2564        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2565            ::core::mem::transmute(__mi.method_ptr);
2566        __inner(this.into(), ::core::option::Option::None)
2567    }
2568}
2569
2570#[cfg(feature = "app-gmapmenusequence")]
2571impl GmapMenuSequence_GmapMenu_ShopItem {
2572    #[doc = "`.ctor()` — no args"]
2573    pub fn new() -> Self {
2574        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2575            panic!(
2576                "{}
2577::{}
2578 failed to instantiate",
2579                ::core::stringify!(GmapMenuSequence_GmapMenu_ShopItem),
2580                ::core::stringify!(new),
2581            )
2582        });
2583        <Self as IGmapMenuSequence_GmapMenu_ShopItemMethods>::ctor(this);
2584        this
2585    }
2586}
2587
2588#[cfg(feature = "app-gmapmenusequence")]
2589pub trait IGmapMenuSequence_GmapMenu_GmapMenuMenuItemMethods: IGmapMenuSequence_GmapMenu_GmapMenuMenuItem {
2590    #[doc = "`GetMapAttribute()` overload"]
2591    fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2592        unsafe {
2593            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2594                <Self as ::unity::SystemObject>::as_instance(self),
2595            );
2596            {
2597                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2598                let __vi = *__vt.get(29usize).unwrap_or_else(|| {
2599                    panic!(
2600                        "unity: virtual slot {}
2601 out of range (vtable len {}
2602) on the runtime class behind {}
2603 (method `{}
2604`)",
2605                        29usize,
2606                        __vt.len(),
2607                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2608                        "GetMapAttribute",
2609                    )
2610                });
2611                let __inner: extern "C" fn(
2612                    GmapMenuSequence_GmapMenu_GmapMenuMenuItem,
2613                    ::unity::OptionalMethod,
2614                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
2615                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2616                __inner(__receiver, __mi)
2617            }
2618        }
2619    }
2620    #[doc = "`get_FlagID()` overload"]
2621    fn get_flag_id(self) -> ::unity::Il2CppString {
2622        unsafe {
2623            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2624                <Self as ::unity::SystemObject>::as_instance(self),
2625            );
2626            {
2627                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2628                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
2629                    panic!(
2630                        "unity: virtual slot {}
2631 out of range (vtable len {}
2632) on the runtime class behind {}
2633 (method `{}
2634`)",
2635                        27usize,
2636                        __vt.len(),
2637                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2638                        "get_FlagID",
2639                    )
2640                });
2641                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GmapMenuMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2642                    ::core::mem::transmute(__vi.method_ptr);
2643                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2644                __inner(__receiver, __mi)
2645            }
2646        }
2647    }
2648    #[doc = "`ACall()` overload"]
2649    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2650        unsafe {
2651            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2652                <Self as ::unity::SystemObject>::as_instance(self),
2653            );
2654            {
2655                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2656                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2657                    panic!(
2658                        "unity: virtual slot {}
2659 out of range (vtable len {}
2660) on the runtime class behind {}
2661 (method `{}
2662`)",
2663                        18usize,
2664                        __vt.len(),
2665                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2666                        "ACall",
2667                    )
2668                });
2669                let __inner: extern "C" fn(
2670                    GmapMenuSequence_GmapMenu_GmapMenuMenuItem,
2671                    ::unity::OptionalMethod,
2672                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
2673                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2674                __inner(__receiver, __mi)
2675            }
2676        }
2677    }
2678    #[doc = "`SetHelpVisible(bool)` overload"]
2679    fn set_help_visible(self, active: impl ::core::convert::Into<bool>) -> () {
2680        unsafe {
2681            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2682                <Self as ::unity::SystemObject>::as_instance(self),
2683            );
2684            ::unity::il2cpp_call!((::unity::module_base()+0x1b3b4e0usize)as*mut u8,();
2685(GmapMenuSequence_GmapMenu_GmapMenuMenuItem)__receiver,(bool)::core::convert::Into::into(active))
2686        }
2687    }
2688    #[doc = "`SaveMenuSelect()` overload"]
2689    fn save_menu_select(self) -> () {
2690        unsafe {
2691            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2692                <Self as ::unity::SystemObject>::as_instance(self),
2693            );
2694            ::unity::il2cpp_call!((::unity::module_base()+0x1b3b230usize)as*mut u8,();
2695(GmapMenuSequence_GmapMenu_GmapMenuMenuItem)__receiver)
2696        }
2697    }
2698    #[doc = "`GetHelpText()` overload"]
2699    fn get_help_text(self) -> ::unity::Il2CppString {
2700        unsafe {
2701            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2702                <Self as ::unity::SystemObject>::as_instance(self),
2703            );
2704            {
2705                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2706                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
2707                    panic!(
2708                        "unity: virtual slot {}
2709 out of range (vtable len {}
2710) on the runtime class behind {}
2711 (method `{}
2712`)",
2713                        28usize,
2714                        __vt.len(),
2715                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2716                        "GetHelpText",
2717                    )
2718                });
2719                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GmapMenuMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
2720                    ::core::mem::transmute(__vi.method_ptr);
2721                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2722                __inner(__receiver, __mi)
2723            }
2724        }
2725    }
2726    #[doc = "`OnSelect()` overload"]
2727    fn on_select(self) -> () {
2728        unsafe {
2729            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2730                <Self as ::unity::SystemObject>::as_instance(self),
2731            );
2732            {
2733                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2734                let __vi = *__vt.get(12usize).unwrap_or_else(|| {
2735                    panic!(
2736                        "unity: virtual slot {}
2737 out of range (vtable len {}
2738) on the runtime class behind {}
2739 (method `{}
2740`)",
2741                        12usize,
2742                        __vt.len(),
2743                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2744                        "OnSelect",
2745                    )
2746                });
2747                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GmapMenuMenuItem, ::unity::OptionalMethod) -> () =
2748                    ::core::mem::transmute(__vi.method_ptr);
2749                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2750                __inner(__receiver, __mi)
2751            }
2752        }
2753    }
2754    #[doc = "`OnDeselect()` overload"]
2755    fn on_deselect(self) -> () {
2756        unsafe {
2757            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2758                <Self as ::unity::SystemObject>::as_instance(self),
2759            );
2760            {
2761                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2762                let __vi = *__vt.get(13usize).unwrap_or_else(|| {
2763                    panic!(
2764                        "unity: virtual slot {}
2765 out of range (vtable len {}
2766) on the runtime class behind {}
2767 (method `{}
2768`)",
2769                        13usize,
2770                        __vt.len(),
2771                        <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::ClassIdentity>::NAME,
2772                        "OnDeselect",
2773                    )
2774                });
2775                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GmapMenuMenuItem, ::unity::OptionalMethod) -> () =
2776                    ::core::mem::transmute(__vi.method_ptr);
2777                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2778                __inner(__receiver, __mi)
2779            }
2780        }
2781    }
2782    #[doc = "`.ctor()` overload"]
2783    fn ctor(self) -> () {
2784        unsafe {
2785            let __receiver = <GmapMenuSequence_GmapMenu_GmapMenuMenuItem as ::unity::FromIlInstance>::from_il_instance(
2786                <Self as ::unity::SystemObject>::as_instance(self),
2787            );
2788            ::unity::il2cpp_call!((::unity::module_base()+0x1b3abc0usize)as*mut u8,();
2789(GmapMenuSequence_GmapMenu_GmapMenuMenuItem)__receiver)
2790        }
2791    }
2792}
2793
2794#[cfg(feature = "app-gmapmenusequence")]
2795impl<__T: IGmapMenuSequence_GmapMenu_GmapMenuMenuItem> IGmapMenuSequence_GmapMenu_GmapMenuMenuItemMethods for __T {}
2796
2797#[cfg(feature = "app-gmapmenusequence")]
2798impl GmapMenuSequence_GmapMenu_GmapMenuMenuItem {
2799    pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2800        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2801    }
2802
2803    pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2804        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2805    }
2806
2807    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2808        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2809    }
2810
2811    pub fn set_help_visible_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2812        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2813    }
2814
2815    pub fn save_menu_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2816        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2817    }
2818
2819    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2820        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2821    }
2822
2823    pub fn on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2824        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2825    }
2826
2827    pub fn on_deselect_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2828        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2829    }
2830
2831    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2832        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2833    }
2834}
2835
2836#[cfg(feature = "app-gmapmenusequence")]
2837impl GmapMenuSequence_GmapMenu_GmapMenuMenuItem {
2838    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2839    pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
2840        let __mi = Self::get_map_attribute_method_info();
2841        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
2842            ::core::mem::transmute(__mi.method_ptr);
2843        __inner(this.into(), ::core::option::Option::None)
2844    }
2845
2846    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2847    pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2848        let __mi = Self::get_flag_id_method_info();
2849        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2850        __inner(this.into(), ::core::option::Option::None)
2851    }
2852
2853    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2854    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
2855        let __mi = Self::a_call_method_info();
2856        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
2857            ::core::mem::transmute(__mi.method_ptr);
2858        __inner(this.into(), ::core::option::Option::None)
2859    }
2860
2861    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2862    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
2863        let __mi = Self::get_help_text_method_info();
2864        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
2865        __inner(this.into(), ::core::option::Option::None)
2866    }
2867
2868    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `OnSelect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2869    pub unsafe fn on_select(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2870        let __mi = Self::on_select_method_info();
2871        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2872        __inner(this.into(), ::core::option::Option::None)
2873    }
2874
2875    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GmapMenuMenuItem`'s own `OnDeselect`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
2876    pub unsafe fn on_deselect(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
2877        let __mi = Self::on_deselect_method_info();
2878        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2879        __inner(this.into(), ::core::option::Option::None)
2880    }
2881}
2882
2883#[cfg(feature = "app-gmapmenusequence")]
2884impl GmapMenuSequence_GmapMenu_GmapMenuMenuItem {
2885    #[doc = "`.ctor()` — no args"]
2886    pub fn new() -> Self {
2887        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2888            panic!(
2889                "{}
2890::{}
2891 failed to instantiate",
2892                ::core::stringify!(GmapMenuSequence_GmapMenu_GmapMenuMenuItem),
2893                ::core::stringify!(new),
2894            )
2895        });
2896        <Self as IGmapMenuSequence_GmapMenu_GmapMenuMenuItemMethods>::ctor(this);
2897        this
2898    }
2899}
2900
2901#[cfg(feature = "app-gmapmenusequence")]
2902pub trait IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItemMethods:
2903    IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem
2904{
2905    #[doc = "`.ctor(crate::app::netenablesequence::NetEnableSequence_ResultFunction)` overload"]
2906    fn ctor(self, result_func: impl ::core::convert::Into<crate::app::netenablesequence::NetEnableSequence_ResultFunction>) -> () {
2907        unsafe {
2908            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem as ::unity::FromIlInstance>::from_il_instance(
2909                <Self as ::unity::SystemObject>::as_instance(self),
2910            );
2911            ::unity::il2cpp_call!((::unity::module_base()+0x3edb0e0usize)as*mut u8,();
2912(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem)__receiver,(crate::app::netenablesequence::NetEnableSequence_ResultFunction)::core::convert::Into::into(result_func))
2913        }
2914    }
2915    #[doc = "`GetName()` overload"]
2916    fn get_name(self) -> ::unity::Il2CppString {
2917        unsafe {
2918            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem as ::unity::FromIlInstance>::from_il_instance(
2919                <Self as ::unity::SystemObject>::as_instance(self),
2920            );
2921            {
2922                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2923                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
2924                    panic!(
2925                        "unity: virtual slot {}
2926 out of range (vtable len {}
2927) on the runtime class behind {}
2928 (method `{}
2929`)",
2930                        4usize,
2931                        __vt.len(),
2932                        <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem as ::unity::ClassIdentity>::NAME,
2933                        "GetName",
2934                    )
2935                });
2936                let __inner: extern "C" fn(
2937                    GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem,
2938                    ::unity::OptionalMethod,
2939                ) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
2940                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2941                __inner(__receiver, __mi)
2942            }
2943        }
2944    }
2945    #[doc = "`ACall()` overload"]
2946    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
2947        unsafe {
2948            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem as ::unity::FromIlInstance>::from_il_instance(
2949                <Self as ::unity::SystemObject>::as_instance(self),
2950            );
2951            {
2952                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
2953                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
2954                    panic!(
2955                        "unity: virtual slot {}
2956 out of range (vtable len {}
2957) on the runtime class behind {}
2958 (method `{}
2959`)",
2960                        18usize,
2961                        __vt.len(),
2962                        <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem as ::unity::ClassIdentity>::NAME,
2963                        "ACall",
2964                    )
2965                });
2966                let __inner: extern "C" fn(
2967                    GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem,
2968                    ::unity::OptionalMethod,
2969                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
2970                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
2971                __inner(__receiver, __mi)
2972            }
2973        }
2974    }
2975}
2976
2977#[cfg(feature = "app-gmapmenusequence")]
2978impl<__T: IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem>
2979    IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItemMethods for __T
2980{
2981}
2982
2983#[cfg(feature = "app-gmapmenusequence")]
2984impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem {
2985    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2986        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2987    }
2988
2989    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2990        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2991    }
2992
2993    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2994        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2995    }
2996}
2997
2998#[cfg(feature = "app-gmapmenusequence")]
2999impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem {
3000    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3001    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3002        let __mi = Self::get_name_method_info();
3003        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3004        __inner(this.into(), ::core::option::Option::None)
3005    }
3006
3007    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3008    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3009        let __mi = Self::a_call_method_info();
3010        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3011            ::core::mem::transmute(__mi.method_ptr);
3012        __inner(this.into(), ::core::option::Option::None)
3013    }
3014}
3015
3016#[cfg(feature = "app-gmapmenusequence")]
3017impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem {
3018    #[doc = "`.ctor(crate::app::netenablesequence::NetEnableSequence_ResultFunction)` — overload selector"]
3019    pub fn new(result_func: crate::app::netenablesequence::NetEnableSequence_ResultFunction) -> Self {
3020        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3021            panic!(
3022                "{}
3023::{}
3024 failed to instantiate",
3025                ::core::stringify!(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem),
3026                ::core::stringify!(new),
3027            )
3028        });
3029        <Self as IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItemMethods>::ctor(this, result_func);
3030        this
3031    }
3032}
3033
3034#[cfg(feature = "app-gmapmenusequence")]
3035pub trait IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItemMethods: IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem {
3036    #[doc = "`GetName()` overload"]
3037    fn get_name(self) -> ::unity::Il2CppString {
3038        unsafe {
3039            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3040                <Self as ::unity::SystemObject>::as_instance(self),
3041            );
3042            {
3043                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3044                let __vi = *__vt.get(4usize).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                        4usize,
3052                        __vt.len(),
3053                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
3054                        "GetName",
3055                    )
3056                });
3057                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem, ::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 = "`GetHelpText()` overload"]
3065    fn get_help_text(self) -> ::unity::Il2CppString {
3066        unsafe {
3067            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3068                <Self as ::unity::SystemObject>::as_instance(self),
3069            );
3070            {
3071                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3072                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3073                    panic!(
3074                        "unity: virtual slot {}
3075 out of range (vtable len {}
3076) on the runtime class behind {}
3077 (method `{}
3078`)",
3079                        28usize,
3080                        __vt.len(),
3081                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
3082                        "GetHelpText",
3083                    )
3084                });
3085                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3086                    ::core::mem::transmute(__vi.method_ptr);
3087                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3088                __inner(__receiver, __mi)
3089            }
3090        }
3091    }
3092    #[doc = "`BuildAttribute()` overload"]
3093    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3094        unsafe {
3095            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3096                <Self as ::unity::SystemObject>::as_instance(self),
3097            );
3098            {
3099                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3100                let __vi = *__vt.get(8usize).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                        8usize,
3108                        __vt.len(),
3109                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
3110                        "BuildAttribute",
3111                    )
3112                });
3113                let __inner: extern "C" fn(
3114                    GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem,
3115                    ::unity::OptionalMethod,
3116                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3117                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3118                __inner(__receiver, __mi)
3119            }
3120        }
3121    }
3122    #[doc = "`ACall()` overload"]
3123    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3124        unsafe {
3125            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3126                <Self as ::unity::SystemObject>::as_instance(self),
3127            );
3128            {
3129                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3130                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3131                    panic!(
3132                        "unity: virtual slot {}
3133 out of range (vtable len {}
3134) on the runtime class behind {}
3135 (method `{}
3136`)",
3137                        18usize,
3138                        __vt.len(),
3139                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
3140                        "ACall",
3141                    )
3142                });
3143                let __inner: extern "C" fn(
3144                    GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem,
3145                    ::unity::OptionalMethod,
3146                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3147                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3148                __inner(__receiver, __mi)
3149            }
3150        }
3151    }
3152    #[doc = "`BCall()` overload"]
3153    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3154        unsafe {
3155            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3156                <Self as ::unity::SystemObject>::as_instance(self),
3157            );
3158            {
3159                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3160                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
3161                    panic!(
3162                        "unity: virtual slot {}
3163 out of range (vtable len {}
3164) on the runtime class behind {}
3165 (method `{}
3166`)",
3167                        19usize,
3168                        __vt.len(),
3169                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::ClassIdentity>::NAME,
3170                        "BCall",
3171                    )
3172                });
3173                let __inner: extern "C" fn(
3174                    GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem,
3175                    ::unity::OptionalMethod,
3176                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3177                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3178                __inner(__receiver, __mi)
3179            }
3180        }
3181    }
3182    #[doc = "`.ctor()` overload"]
3183    fn ctor(self) -> () {
3184        unsafe {
3185            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem as ::unity::FromIlInstance>::from_il_instance(
3186                <Self as ::unity::SystemObject>::as_instance(self),
3187            );
3188            ::unity::il2cpp_call!((::unity::module_base()+0x22ff0e0usize)as*mut u8,();
3189(GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem)__receiver)
3190        }
3191    }
3192}
3193
3194#[cfg(feature = "app-gmapmenusequence")]
3195impl<__T: IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem> IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItemMethods for __T {}
3196
3197#[cfg(feature = "app-gmapmenusequence")]
3198impl GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem {
3199    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3200        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3201    }
3202
3203    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3204        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3205    }
3206
3207    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3208        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3209    }
3210
3211    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3212        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3213    }
3214
3215    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3216        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3217    }
3218
3219    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3220        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3221    }
3222}
3223
3224#[cfg(feature = "app-gmapmenusequence")]
3225impl GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem {
3226    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3227    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3228        let __mi = Self::get_name_method_info();
3229        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3230        __inner(this.into(), ::core::option::Option::None)
3231    }
3232
3233    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3234    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3235        let __mi = Self::get_help_text_method_info();
3236        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3237        __inner(this.into(), ::core::option::Option::None)
3238    }
3239
3240    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3241    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3242        let __mi = Self::build_attribute_method_info();
3243        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3244            ::core::mem::transmute(__mi.method_ptr);
3245        __inner(this.into(), ::core::option::Option::None)
3246    }
3247
3248    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3249    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3250        let __mi = Self::a_call_method_info();
3251        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3252            ::core::mem::transmute(__mi.method_ptr);
3253        __inner(this.into(), ::core::option::Option::None)
3254    }
3255
3256    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3257    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3258        let __mi = Self::b_call_method_info();
3259        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3260            ::core::mem::transmute(__mi.method_ptr);
3261        __inner(this.into(), ::core::option::Option::None)
3262    }
3263}
3264
3265#[cfg(feature = "app-gmapmenusequence")]
3266impl GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem {
3267    #[doc = "`.ctor()` — no args"]
3268    pub fn new() -> Self {
3269        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3270            panic!(
3271                "{}
3272::{}
3273 failed to instantiate",
3274                ::core::stringify!(GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem),
3275                ::core::stringify!(new),
3276            )
3277        });
3278        <Self as IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItemMethods>::ctor(this);
3279        this
3280    }
3281}
3282
3283#[cfg(feature = "app-gmapmenusequence")]
3284pub trait IGmapMenuSequence_GmapMenu_RankingItemMethods: IGmapMenuSequence_GmapMenu_RankingItem {
3285    #[doc = "`GetName()` overload"]
3286    fn get_name(self) -> ::unity::Il2CppString {
3287        unsafe {
3288            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem as ::unity::FromIlInstance>::from_il_instance(
3289                <Self as ::unity::SystemObject>::as_instance(self),
3290            );
3291            {
3292                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3293                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3294                    panic!(
3295                        "unity: virtual slot {}
3296 out of range (vtable len {}
3297) on the runtime class behind {}
3298 (method `{}
3299`)",
3300                        4usize,
3301                        __vt.len(),
3302                        <GmapMenuSequence_GmapMenu_RankingItem as ::unity::ClassIdentity>::NAME,
3303                        "GetName",
3304                    )
3305                });
3306                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_RankingItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3307                    ::core::mem::transmute(__vi.method_ptr);
3308                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3309                __inner(__receiver, __mi)
3310            }
3311        }
3312    }
3313    #[doc = "`GetHelpText()` overload"]
3314    fn get_help_text(self) -> ::unity::Il2CppString {
3315        unsafe {
3316            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem as ::unity::FromIlInstance>::from_il_instance(
3317                <Self as ::unity::SystemObject>::as_instance(self),
3318            );
3319            {
3320                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3321                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3322                    panic!(
3323                        "unity: virtual slot {}
3324 out of range (vtable len {}
3325) on the runtime class behind {}
3326 (method `{}
3327`)",
3328                        28usize,
3329                        __vt.len(),
3330                        <GmapMenuSequence_GmapMenu_RankingItem as ::unity::ClassIdentity>::NAME,
3331                        "GetHelpText",
3332                    )
3333                });
3334                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_RankingItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3335                    ::core::mem::transmute(__vi.method_ptr);
3336                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3337                __inner(__receiver, __mi)
3338            }
3339        }
3340    }
3341    #[doc = "`BuildAttribute()` overload"]
3342    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3343        unsafe {
3344            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem as ::unity::FromIlInstance>::from_il_instance(
3345                <Self as ::unity::SystemObject>::as_instance(self),
3346            );
3347            {
3348                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3349                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3350                    panic!(
3351                        "unity: virtual slot {}
3352 out of range (vtable len {}
3353) on the runtime class behind {}
3354 (method `{}
3355`)",
3356                        8usize,
3357                        __vt.len(),
3358                        <GmapMenuSequence_GmapMenu_RankingItem as ::unity::ClassIdentity>::NAME,
3359                        "BuildAttribute",
3360                    )
3361                });
3362                let __inner: extern "C" fn(
3363                    GmapMenuSequence_GmapMenu_RankingItem,
3364                    ::unity::OptionalMethod,
3365                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3366                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3367                __inner(__receiver, __mi)
3368            }
3369        }
3370    }
3371    #[doc = "`ACall()` overload"]
3372    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3373        unsafe {
3374            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem as ::unity::FromIlInstance>::from_il_instance(
3375                <Self as ::unity::SystemObject>::as_instance(self),
3376            );
3377            {
3378                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3379                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3380                    panic!(
3381                        "unity: virtual slot {}
3382 out of range (vtable len {}
3383) on the runtime class behind {}
3384 (method `{}
3385`)",
3386                        18usize,
3387                        __vt.len(),
3388                        <GmapMenuSequence_GmapMenu_RankingItem as ::unity::ClassIdentity>::NAME,
3389                        "ACall",
3390                    )
3391                });
3392                let __inner: extern "C" fn(
3393                    GmapMenuSequence_GmapMenu_RankingItem,
3394                    ::unity::OptionalMethod,
3395                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3396                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3397                __inner(__receiver, __mi)
3398            }
3399        }
3400    }
3401    #[doc = "`.ctor()` overload"]
3402    fn ctor(self) -> () {
3403        unsafe {
3404            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem as ::unity::FromIlInstance>::from_il_instance(
3405                <Self as ::unity::SystemObject>::as_instance(self),
3406            );
3407            ::unity::il2cpp_call!((::unity::module_base()+0x1b3cb60usize)as*mut u8,();
3408(GmapMenuSequence_GmapMenu_RankingItem)__receiver)
3409        }
3410    }
3411}
3412
3413#[cfg(feature = "app-gmapmenusequence")]
3414impl<__T: IGmapMenuSequence_GmapMenu_RankingItem> IGmapMenuSequence_GmapMenu_RankingItemMethods for __T {}
3415
3416#[cfg(feature = "app-gmapmenusequence")]
3417impl GmapMenuSequence_GmapMenu_RankingItem {
3418    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3419        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3420    }
3421
3422    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3423        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3424    }
3425
3426    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3427        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3428    }
3429
3430    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3431        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3432    }
3433
3434    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3435        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3436    }
3437}
3438
3439#[cfg(feature = "app-gmapmenusequence")]
3440impl GmapMenuSequence_GmapMenu_RankingItem {
3441    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3442    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3443        let __mi = Self::get_name_method_info();
3444        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3445        __inner(this.into(), ::core::option::Option::None)
3446    }
3447
3448    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3449    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3450        let __mi = Self::get_help_text_method_info();
3451        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3452        __inner(this.into(), ::core::option::Option::None)
3453    }
3454
3455    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3456    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3457        let __mi = Self::build_attribute_method_info();
3458        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3459            ::core::mem::transmute(__mi.method_ptr);
3460        __inner(this.into(), ::core::option::Option::None)
3461    }
3462
3463    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3464    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3465        let __mi = Self::a_call_method_info();
3466        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3467            ::core::mem::transmute(__mi.method_ptr);
3468        __inner(this.into(), ::core::option::Option::None)
3469    }
3470}
3471
3472#[cfg(feature = "app-gmapmenusequence")]
3473impl GmapMenuSequence_GmapMenu_RankingItem {
3474    #[doc = "`.ctor()` — no args"]
3475    pub fn new() -> Self {
3476        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3477            panic!(
3478                "{}
3479::{}
3480 failed to instantiate",
3481                ::core::stringify!(GmapMenuSequence_GmapMenu_RankingItem),
3482                ::core::stringify!(new),
3483            )
3484        });
3485        <Self as IGmapMenuSequence_GmapMenu_RankingItemMethods>::ctor(this);
3486        this
3487    }
3488}
3489
3490#[cfg(feature = "app-gmapmenusequence")]
3491impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence {
3492    #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::netenablesequence::NetEnableSequence_ResultFunction)` overload"]
3493    pub fn create_bind(
3494        super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
3495        result_func: impl ::core::convert::Into<crate::app::netenablesequence::NetEnableSequence_ResultFunction>,
3496    ) -> () {
3497        unsafe {
3498            ::unity::il2cpp_call!((::unity::module_base()+0x22fd870usize)as*mut u8,();
3499(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::netenablesequence::NetEnableSequence_ResultFunction)::core::convert::Into::into(result_func))
3500        }
3501    }
3502}
3503
3504#[cfg(feature = "app-gmapmenusequence")]
3505pub trait IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequenceMethods: IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence {
3506    #[doc = "`.ctor(crate::app::netenablesequence::NetEnableSequence_ResultFunction)` overload"]
3507    fn ctor(self, result_func: impl ::core::convert::Into<crate::app::netenablesequence::NetEnableSequence_ResultFunction>) -> () {
3508        unsafe {
3509            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence as ::unity::FromIlInstance>::from_il_instance(
3510                <Self as ::unity::SystemObject>::as_instance(self),
3511            );
3512            ::unity::il2cpp_call!((::unity::module_base()+0x22fd730usize)as*mut u8,();
3513(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence)__receiver,(crate::app::netenablesequence::NetEnableSequence_ResultFunction)::core::convert::Into::into(result_func))
3514        }
3515    }
3516    #[doc = "`Confirm()` overload"]
3517    fn confirm(self) -> () {
3518        unsafe {
3519            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence as ::unity::FromIlInstance>::from_il_instance(
3520                <Self as ::unity::SystemObject>::as_instance(self),
3521            );
3522            ::unity::il2cpp_call!((::unity::module_base()+0x22fd770usize)as*mut u8,();
3523(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence)__receiver)
3524        }
3525    }
3526}
3527
3528#[cfg(feature = "app-gmapmenusequence")]
3529impl<__T: IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence> IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequenceMethods for __T {}
3530
3531#[cfg(feature = "app-gmapmenusequence")]
3532impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence {
3533    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3534        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3535    }
3536
3537    pub fn confirm_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3538        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3539    }
3540
3541    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3542        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3543    }
3544}
3545
3546#[cfg(feature = "app-gmapmenusequence")]
3547impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence {
3548    #[doc = "`.ctor(crate::app::netenablesequence::NetEnableSequence_ResultFunction)` — overload selector"]
3549    pub fn new(result_func: crate::app::netenablesequence::NetEnableSequence_ResultFunction) -> Self {
3550        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3551            panic!(
3552                "{}
3553::{}
3554 failed to instantiate",
3555                ::core::stringify!(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence),
3556                ::core::stringify!(new),
3557            )
3558        });
3559        <Self as IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequenceMethods>::ctor(this, result_func);
3560        this
3561    }
3562}
3563
3564#[cfg(feature = "app-gmapmenusequence")]
3565pub trait IGmapMenuSequence_GmapMenu_InventoryItemMethods: IGmapMenuSequence_GmapMenu_InventoryItem {
3566    #[doc = "`GetName()` overload"]
3567    fn get_name(self) -> ::unity::Il2CppString {
3568        unsafe {
3569            let __receiver = <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(
3570                <Self as ::unity::SystemObject>::as_instance(self),
3571            );
3572            {
3573                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3574                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
3575                    panic!(
3576                        "unity: virtual slot {}
3577 out of range (vtable len {}
3578) on the runtime class behind {}
3579 (method `{}
3580`)",
3581                        4usize,
3582                        __vt.len(),
3583                        <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3584                        "GetName",
3585                    )
3586                });
3587                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_InventoryItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3588                    ::core::mem::transmute(__vi.method_ptr);
3589                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3590                __inner(__receiver, __mi)
3591            }
3592        }
3593    }
3594    #[doc = "`GetHelpText()` overload"]
3595    fn get_help_text(self) -> ::unity::Il2CppString {
3596        unsafe {
3597            let __receiver = <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(
3598                <Self as ::unity::SystemObject>::as_instance(self),
3599            );
3600            {
3601                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3602                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3603                    panic!(
3604                        "unity: virtual slot {}
3605 out of range (vtable len {}
3606) on the runtime class behind {}
3607 (method `{}
3608`)",
3609                        28usize,
3610                        __vt.len(),
3611                        <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3612                        "GetHelpText",
3613                    )
3614                });
3615                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_InventoryItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3616                    ::core::mem::transmute(__vi.method_ptr);
3617                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3618                __inner(__receiver, __mi)
3619            }
3620        }
3621    }
3622    #[doc = "`BuildAttribute()` overload"]
3623    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3624        unsafe {
3625            let __receiver = <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(
3626                <Self as ::unity::SystemObject>::as_instance(self),
3627            );
3628            {
3629                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3630                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
3631                    panic!(
3632                        "unity: virtual slot {}
3633 out of range (vtable len {}
3634) on the runtime class behind {}
3635 (method `{}
3636`)",
3637                        8usize,
3638                        __vt.len(),
3639                        <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3640                        "BuildAttribute",
3641                    )
3642                });
3643                let __inner: extern "C" fn(
3644                    GmapMenuSequence_GmapMenu_InventoryItem,
3645                    ::unity::OptionalMethod,
3646                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3647                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3648                __inner(__receiver, __mi)
3649            }
3650        }
3651    }
3652    #[doc = "`ACall()` overload"]
3653    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3654        unsafe {
3655            let __receiver = <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(
3656                <Self as ::unity::SystemObject>::as_instance(self),
3657            );
3658            {
3659                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3660                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3661                    panic!(
3662                        "unity: virtual slot {}
3663 out of range (vtable len {}
3664) on the runtime class behind {}
3665 (method `{}
3666`)",
3667                        18usize,
3668                        __vt.len(),
3669                        <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::ClassIdentity>::NAME,
3670                        "ACall",
3671                    )
3672                });
3673                let __inner: extern "C" fn(
3674                    GmapMenuSequence_GmapMenu_InventoryItem,
3675                    ::unity::OptionalMethod,
3676                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
3677                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3678                __inner(__receiver, __mi)
3679            }
3680        }
3681    }
3682    #[doc = "`.ctor()` overload"]
3683    fn ctor(self) -> () {
3684        unsafe {
3685            let __receiver = <GmapMenuSequence_GmapMenu_InventoryItem as ::unity::FromIlInstance>::from_il_instance(
3686                <Self as ::unity::SystemObject>::as_instance(self),
3687            );
3688            ::unity::il2cpp_call!((::unity::module_base()+0x1b3c520usize)as*mut u8,();
3689(GmapMenuSequence_GmapMenu_InventoryItem)__receiver)
3690        }
3691    }
3692}
3693
3694#[cfg(feature = "app-gmapmenusequence")]
3695impl<__T: IGmapMenuSequence_GmapMenu_InventoryItem> IGmapMenuSequence_GmapMenu_InventoryItemMethods for __T {}
3696
3697#[cfg(feature = "app-gmapmenusequence")]
3698impl GmapMenuSequence_GmapMenu_InventoryItem {
3699    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3700        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3701    }
3702
3703    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3704        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3705    }
3706
3707    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3708        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3709    }
3710
3711    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3712        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3713    }
3714
3715    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3716        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3717    }
3718}
3719
3720#[cfg(feature = "app-gmapmenusequence")]
3721impl GmapMenuSequence_GmapMenu_InventoryItem {
3722    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_InventoryItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3723    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3724        let __mi = Self::get_name_method_info();
3725        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3726        __inner(this.into(), ::core::option::Option::None)
3727    }
3728
3729    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_InventoryItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3730    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3731        let __mi = Self::get_help_text_method_info();
3732        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3733        __inner(this.into(), ::core::option::Option::None)
3734    }
3735
3736    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_InventoryItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3737    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3738        let __mi = Self::build_attribute_method_info();
3739        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3740            ::core::mem::transmute(__mi.method_ptr);
3741        __inner(this.into(), ::core::option::Option::None)
3742    }
3743
3744    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_InventoryItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3745    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3746        let __mi = Self::a_call_method_info();
3747        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3748            ::core::mem::transmute(__mi.method_ptr);
3749        __inner(this.into(), ::core::option::Option::None)
3750    }
3751}
3752
3753#[cfg(feature = "app-gmapmenusequence")]
3754impl GmapMenuSequence_GmapMenu_InventoryItem {
3755    #[doc = "`.ctor()` — no args"]
3756    pub fn new() -> Self {
3757        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
3758            panic!(
3759                "{}
3760::{}
3761 failed to instantiate",
3762                ::core::stringify!(GmapMenuSequence_GmapMenu_InventoryItem),
3763                ::core::stringify!(new),
3764            )
3765        });
3766        <Self as IGmapMenuSequence_GmapMenu_InventoryItemMethods>::ctor(this);
3767        this
3768    }
3769}
3770
3771#[cfg(feature = "app-gmapmenusequence")]
3772pub trait IGmapMenuSequence_GmapMenu_FriendItemMethods: IGmapMenuSequence_GmapMenu_FriendItem {
3773    #[doc = "`get_FlagID()` overload"]
3774    fn get_flag_id(self) -> ::unity::Il2CppString {
3775        unsafe {
3776            let __receiver = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3777                <Self as ::unity::SystemObject>::as_instance(self),
3778            );
3779            {
3780                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3781                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
3782                    panic!(
3783                        "unity: virtual slot {}
3784 out of range (vtable len {}
3785) on the runtime class behind {}
3786 (method `{}
3787`)",
3788                        27usize,
3789                        __vt.len(),
3790                        <GmapMenuSequence_GmapMenu_FriendItem as ::unity::ClassIdentity>::NAME,
3791                        "get_FlagID",
3792                    )
3793                });
3794                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_FriendItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3795                    ::core::mem::transmute(__vi.method_ptr);
3796                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3797                __inner(__receiver, __mi)
3798            }
3799        }
3800    }
3801    #[doc = "`GetName()` overload"]
3802    fn get_name(self) -> ::unity::Il2CppString {
3803        unsafe {
3804            let __receiver = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3805                <Self as ::unity::SystemObject>::as_instance(self),
3806            );
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                        <GmapMenuSequence_GmapMenu_FriendItem as ::unity::ClassIdentity>::NAME,
3819                        "GetName",
3820                    )
3821                });
3822                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_FriendItem, ::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 = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3833                <Self as ::unity::SystemObject>::as_instance(self),
3834            );
3835            {
3836                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3837                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
3838                    panic!(
3839                        "unity: virtual slot {}
3840 out of range (vtable len {}
3841) on the runtime class behind {}
3842 (method `{}
3843`)",
3844                        28usize,
3845                        __vt.len(),
3846                        <GmapMenuSequence_GmapMenu_FriendItem as ::unity::ClassIdentity>::NAME,
3847                        "GetHelpText",
3848                    )
3849                });
3850                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_FriendItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
3851                    ::core::mem::transmute(__vi.method_ptr);
3852                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3853                __inner(__receiver, __mi)
3854            }
3855        }
3856    }
3857    #[doc = "`GetMapAttribute()` overload"]
3858    fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3859        unsafe {
3860            let __receiver = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3861                <Self as ::unity::SystemObject>::as_instance(self),
3862            );
3863            {
3864                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3865                let __vi = *__vt.get(29usize).unwrap_or_else(|| {
3866                    panic!(
3867                        "unity: virtual slot {}
3868 out of range (vtable len {}
3869) on the runtime class behind {}
3870 (method `{}
3871`)",
3872                        29usize,
3873                        __vt.len(),
3874                        <GmapMenuSequence_GmapMenu_FriendItem as ::unity::ClassIdentity>::NAME,
3875                        "GetMapAttribute",
3876                    )
3877                });
3878                let __inner: extern "C" fn(
3879                    GmapMenuSequence_GmapMenu_FriendItem,
3880                    ::unity::OptionalMethod,
3881                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
3882                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3883                __inner(__receiver, __mi)
3884            }
3885        }
3886    }
3887    #[doc = "`ACall()` overload"]
3888    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
3889        unsafe {
3890            let __receiver = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3891                <Self as ::unity::SystemObject>::as_instance(self),
3892            );
3893            {
3894                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
3895                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
3896                    panic!(
3897                        "unity: virtual slot {}
3898 out of range (vtable len {}
3899) on the runtime class behind {}
3900 (method `{}
3901`)",
3902                        18usize,
3903                        __vt.len(),
3904                        <GmapMenuSequence_GmapMenu_FriendItem as ::unity::ClassIdentity>::NAME,
3905                        "ACall",
3906                    )
3907                });
3908                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_FriendItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3909                    ::core::mem::transmute(__vi.method_ptr);
3910                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
3911                __inner(__receiver, __mi)
3912            }
3913        }
3914    }
3915    #[doc = "`.ctor()` overload"]
3916    fn ctor(self) -> () {
3917        unsafe {
3918            let __receiver = <GmapMenuSequence_GmapMenu_FriendItem as ::unity::FromIlInstance>::from_il_instance(
3919                <Self as ::unity::SystemObject>::as_instance(self),
3920            );
3921            ::unity::il2cpp_call!((::unity::module_base()+0x1b3b830usize)as*mut u8,();
3922(GmapMenuSequence_GmapMenu_FriendItem)__receiver)
3923        }
3924    }
3925}
3926
3927#[cfg(feature = "app-gmapmenusequence")]
3928impl<__T: IGmapMenuSequence_GmapMenu_FriendItem> IGmapMenuSequence_GmapMenu_FriendItemMethods for __T {}
3929
3930#[cfg(feature = "app-gmapmenusequence")]
3931impl GmapMenuSequence_GmapMenu_FriendItem {
3932    pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3933        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
3934    }
3935
3936    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3937        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
3938    }
3939
3940    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3941        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
3942    }
3943
3944    pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3945        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
3946    }
3947
3948    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3949        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
3950    }
3951
3952    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3953        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
3954    }
3955}
3956
3957#[cfg(feature = "app-gmapmenusequence")]
3958impl GmapMenuSequence_GmapMenu_FriendItem {
3959    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_FriendItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3960    pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3961        let __mi = Self::get_flag_id_method_info();
3962        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3963        __inner(this.into(), ::core::option::Option::None)
3964    }
3965
3966    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_FriendItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3967    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3968        let __mi = Self::get_name_method_info();
3969        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3970        __inner(this.into(), ::core::option::Option::None)
3971    }
3972
3973    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_FriendItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3974    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
3975        let __mi = Self::get_help_text_method_info();
3976        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
3977        __inner(this.into(), ::core::option::Option::None)
3978    }
3979
3980    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_FriendItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3981    pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
3982        let __mi = Self::get_map_attribute_method_info();
3983        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
3984            ::core::mem::transmute(__mi.method_ptr);
3985        __inner(this.into(), ::core::option::Option::None)
3986    }
3987
3988    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_FriendItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
3989    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
3990        let __mi = Self::a_call_method_info();
3991        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
3992            ::core::mem::transmute(__mi.method_ptr);
3993        __inner(this.into(), ::core::option::Option::None)
3994    }
3995}
3996
3997#[cfg(feature = "app-gmapmenusequence")]
3998impl GmapMenuSequence_GmapMenu_FriendItem {
3999    #[doc = "`.ctor()` — no args"]
4000    pub fn new() -> Self {
4001        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4002            panic!(
4003                "{}
4004::{}
4005 failed to instantiate",
4006                ::core::stringify!(GmapMenuSequence_GmapMenu_FriendItem),
4007                ::core::stringify!(new),
4008            )
4009        });
4010        <Self as IGmapMenuSequence_GmapMenu_FriendItemMethods>::ctor(this);
4011        this
4012    }
4013}
4014
4015#[cfg(feature = "app-gmapmenusequence")]
4016pub trait IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItemMethods: IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem {
4017    #[doc = "`GetName()` overload"]
4018    fn get_name(self) -> ::unity::Il2CppString {
4019        unsafe {
4020            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4021                <Self as ::unity::SystemObject>::as_instance(self),
4022            );
4023            {
4024                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4025                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4026                    panic!(
4027                        "unity: virtual slot {}
4028 out of range (vtable len {}
4029) on the runtime class behind {}
4030 (method `{}
4031`)",
4032                        4usize,
4033                        __vt.len(),
4034                        <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::ClassIdentity>::NAME,
4035                        "GetName",
4036                    )
4037                });
4038                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4039                    ::core::mem::transmute(__vi.method_ptr);
4040                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4041                __inner(__receiver, __mi)
4042            }
4043        }
4044    }
4045    #[doc = "`GetHelpText()` overload"]
4046    fn get_help_text(self) -> ::unity::Il2CppString {
4047        unsafe {
4048            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4049                <Self as ::unity::SystemObject>::as_instance(self),
4050            );
4051            {
4052                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4053                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4054                    panic!(
4055                        "unity: virtual slot {}
4056 out of range (vtable len {}
4057) on the runtime class behind {}
4058 (method `{}
4059`)",
4060                        28usize,
4061                        __vt.len(),
4062                        <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::ClassIdentity>::NAME,
4063                        "GetHelpText",
4064                    )
4065                });
4066                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4067                    ::core::mem::transmute(__vi.method_ptr);
4068                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4069                __inner(__receiver, __mi)
4070            }
4071        }
4072    }
4073    #[doc = "`BuildAttribute()` overload"]
4074    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4075        unsafe {
4076            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4077                <Self as ::unity::SystemObject>::as_instance(self),
4078            );
4079            {
4080                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4081                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
4082                    panic!(
4083                        "unity: virtual slot {}
4084 out of range (vtable len {}
4085) on the runtime class behind {}
4086 (method `{}
4087`)",
4088                        8usize,
4089                        __vt.len(),
4090                        <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::ClassIdentity>::NAME,
4091                        "BuildAttribute",
4092                    )
4093                });
4094                let __inner: extern "C" fn(
4095                    GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem,
4096                    ::unity::OptionalMethod,
4097                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4098                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4099                __inner(__receiver, __mi)
4100            }
4101        }
4102    }
4103    #[doc = "`ACall()` overload"]
4104    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4105        unsafe {
4106            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4107                <Self as ::unity::SystemObject>::as_instance(self),
4108            );
4109            {
4110                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4111                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4112                    panic!(
4113                        "unity: virtual slot {}
4114 out of range (vtable len {}
4115) on the runtime class behind {}
4116 (method `{}
4117`)",
4118                        18usize,
4119                        __vt.len(),
4120                        <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::ClassIdentity>::NAME,
4121                        "ACall",
4122                    )
4123                });
4124                let __inner: extern "C" fn(
4125                    GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem,
4126                    ::unity::OptionalMethod,
4127                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4128                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4129                __inner(__receiver, __mi)
4130            }
4131        }
4132    }
4133    #[doc = "`BCall()` overload"]
4134    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4135        unsafe {
4136            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4137                <Self as ::unity::SystemObject>::as_instance(self),
4138            );
4139            {
4140                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4141                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
4142                    panic!(
4143                        "unity: virtual slot {}
4144 out of range (vtable len {}
4145) on the runtime class behind {}
4146 (method `{}
4147`)",
4148                        19usize,
4149                        __vt.len(),
4150                        <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::ClassIdentity>::NAME,
4151                        "BCall",
4152                    )
4153                });
4154                let __inner: extern "C" fn(
4155                    GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem,
4156                    ::unity::OptionalMethod,
4157                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4158                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4159                __inner(__receiver, __mi)
4160            }
4161        }
4162    }
4163    #[doc = "`.ctor()` overload"]
4164    fn ctor(self) -> () {
4165        unsafe {
4166            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4167                <Self as ::unity::SystemObject>::as_instance(self),
4168            );
4169            ::unity::il2cpp_call!((::unity::module_base()+0x22feac0usize)as*mut u8,();
4170(GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem)__receiver)
4171        }
4172    }
4173}
4174
4175#[cfg(feature = "app-gmapmenusequence")]
4176impl<__T: IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem> IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItemMethods for __T {}
4177
4178#[cfg(feature = "app-gmapmenusequence")]
4179impl GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem {
4180    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4181        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4182    }
4183
4184    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4185        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4186    }
4187
4188    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4189        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4190    }
4191
4192    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4193        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4194    }
4195
4196    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4197        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4198    }
4199
4200    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4201        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4202    }
4203}
4204
4205#[cfg(feature = "app-gmapmenusequence")]
4206impl GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem {
4207    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4208    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4209        let __mi = Self::get_name_method_info();
4210        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4211        __inner(this.into(), ::core::option::Option::None)
4212    }
4213
4214    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4215    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4216        let __mi = Self::get_help_text_method_info();
4217        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4218        __inner(this.into(), ::core::option::Option::None)
4219    }
4220
4221    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4222    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4223        let __mi = Self::build_attribute_method_info();
4224        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4225            ::core::mem::transmute(__mi.method_ptr);
4226        __inner(this.into(), ::core::option::Option::None)
4227    }
4228
4229    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4230    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4231        let __mi = Self::a_call_method_info();
4232        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4233            ::core::mem::transmute(__mi.method_ptr);
4234        __inner(this.into(), ::core::option::Option::None)
4235    }
4236
4237    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4238    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4239        let __mi = Self::b_call_method_info();
4240        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4241            ::core::mem::transmute(__mi.method_ptr);
4242        __inner(this.into(), ::core::option::Option::None)
4243    }
4244}
4245
4246#[cfg(feature = "app-gmapmenusequence")]
4247impl GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem {
4248    #[doc = "`.ctor()` — no args"]
4249    pub fn new() -> Self {
4250        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4251            panic!(
4252                "{}
4253::{}
4254 failed to instantiate",
4255                ::core::stringify!(GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem),
4256                ::core::stringify!(new),
4257            )
4258        });
4259        <Self as IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItemMethods>::ctor(this);
4260        this
4261    }
4262}
4263
4264#[cfg(feature = "app-gmapmenusequence")]
4265pub trait IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItemMethods: IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem {
4266    #[doc = "`GetName()` overload"]
4267    fn get_name(self) -> ::unity::Il2CppString {
4268        unsafe {
4269            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4270                <Self as ::unity::SystemObject>::as_instance(self),
4271            );
4272            {
4273                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4274                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4275                    panic!(
4276                        "unity: virtual slot {}
4277 out of range (vtable len {}
4278) on the runtime class behind {}
4279 (method `{}
4280`)",
4281                        4usize,
4282                        __vt.len(),
4283                        <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
4284                        "GetName",
4285                    )
4286                });
4287                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4288                    ::core::mem::transmute(__vi.method_ptr);
4289                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4290                __inner(__receiver, __mi)
4291            }
4292        }
4293    }
4294    #[doc = "`GetHelpText()` overload"]
4295    fn get_help_text(self) -> ::unity::Il2CppString {
4296        unsafe {
4297            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4298                <Self as ::unity::SystemObject>::as_instance(self),
4299            );
4300            {
4301                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4302                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4303                    panic!(
4304                        "unity: virtual slot {}
4305 out of range (vtable len {}
4306) on the runtime class behind {}
4307 (method `{}
4308`)",
4309                        28usize,
4310                        __vt.len(),
4311                        <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
4312                        "GetHelpText",
4313                    )
4314                });
4315                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4316                    ::core::mem::transmute(__vi.method_ptr);
4317                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4318                __inner(__receiver, __mi)
4319            }
4320        }
4321    }
4322    #[doc = "`BuildAttribute()` overload"]
4323    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4324        unsafe {
4325            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4326                <Self as ::unity::SystemObject>::as_instance(self),
4327            );
4328            {
4329                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4330                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
4331                    panic!(
4332                        "unity: virtual slot {}
4333 out of range (vtable len {}
4334) on the runtime class behind {}
4335 (method `{}
4336`)",
4337                        8usize,
4338                        __vt.len(),
4339                        <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
4340                        "BuildAttribute",
4341                    )
4342                });
4343                let __inner: extern "C" fn(
4344                    GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem,
4345                    ::unity::OptionalMethod,
4346                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4347                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4348                __inner(__receiver, __mi)
4349            }
4350        }
4351    }
4352    #[doc = "`ACall()` overload"]
4353    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4354        unsafe {
4355            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4356                <Self as ::unity::SystemObject>::as_instance(self),
4357            );
4358            {
4359                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4360                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4361                    panic!(
4362                        "unity: virtual slot {}
4363 out of range (vtable len {}
4364) on the runtime class behind {}
4365 (method `{}
4366`)",
4367                        18usize,
4368                        __vt.len(),
4369                        <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
4370                        "ACall",
4371                    )
4372                });
4373                let __inner: extern "C" fn(
4374                    GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem,
4375                    ::unity::OptionalMethod,
4376                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4377                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4378                __inner(__receiver, __mi)
4379            }
4380        }
4381    }
4382    #[doc = "`BCall()` overload"]
4383    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4384        unsafe {
4385            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4386                <Self as ::unity::SystemObject>::as_instance(self),
4387            );
4388            {
4389                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4390                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
4391                    panic!(
4392                        "unity: virtual slot {}
4393 out of range (vtable len {}
4394) on the runtime class behind {}
4395 (method `{}
4396`)",
4397                        19usize,
4398                        __vt.len(),
4399                        <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::ClassIdentity>::NAME,
4400                        "BCall",
4401                    )
4402                });
4403                let __inner: extern "C" fn(
4404                    GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem,
4405                    ::unity::OptionalMethod,
4406                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4407                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4408                __inner(__receiver, __mi)
4409            }
4410        }
4411    }
4412    #[doc = "`.ctor()` overload"]
4413    fn ctor(self) -> () {
4414        unsafe {
4415            let __receiver = <GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem as ::unity::FromIlInstance>::from_il_instance(
4416                <Self as ::unity::SystemObject>::as_instance(self),
4417            );
4418            ::unity::il2cpp_call!((::unity::module_base()+0x22fe2b0usize)as*mut u8,();
4419(GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem)__receiver)
4420        }
4421    }
4422}
4423
4424#[cfg(feature = "app-gmapmenusequence")]
4425impl<__T: IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem> IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItemMethods for __T {}
4426
4427#[cfg(feature = "app-gmapmenusequence")]
4428impl GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem {
4429    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4430        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4431    }
4432
4433    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4434        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4435    }
4436
4437    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4438        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4439    }
4440
4441    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4442        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4443    }
4444
4445    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4446        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4447    }
4448
4449    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4450        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4451    }
4452}
4453
4454#[cfg(feature = "app-gmapmenusequence")]
4455impl GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem {
4456    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4457    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4458        let __mi = Self::get_name_method_info();
4459        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4460        __inner(this.into(), ::core::option::Option::None)
4461    }
4462
4463    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4464    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4465        let __mi = Self::get_help_text_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    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4471    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4472        let __mi = Self::build_attribute_method_info();
4473        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4474            ::core::mem::transmute(__mi.method_ptr);
4475        __inner(this.into(), ::core::option::Option::None)
4476    }
4477
4478    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4479    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4480        let __mi = Self::a_call_method_info();
4481        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4482            ::core::mem::transmute(__mi.method_ptr);
4483        __inner(this.into(), ::core::option::Option::None)
4484    }
4485
4486    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4487    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4488        let __mi = Self::b_call_method_info();
4489        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4490            ::core::mem::transmute(__mi.method_ptr);
4491        __inner(this.into(), ::core::option::Option::None)
4492    }
4493}
4494
4495#[cfg(feature = "app-gmapmenusequence")]
4496impl GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem {
4497    #[doc = "`.ctor()` — no args"]
4498    pub fn new() -> Self {
4499        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4500            panic!(
4501                "{}
4502::{}
4503 failed to instantiate",
4504                ::core::stringify!(GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem),
4505                ::core::stringify!(new),
4506            )
4507        });
4508        <Self as IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItemMethods>::ctor(this);
4509        this
4510    }
4511}
4512
4513#[cfg(feature = "app-gmapmenusequence")]
4514impl GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence {
4515    #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::system::action::Action)` overload"]
4516    pub fn create_bind(
4517        super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
4518        jump_func: impl ::core::convert::Into<crate::system::action::Action>,
4519    ) -> () {
4520        unsafe {
4521            ::unity::il2cpp_call!((::unity::module_base()+0x22fdaf0usize)as*mut u8,();
4522(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::system::action::Action)::core::convert::Into::into(jump_func))
4523        }
4524    }
4525}
4526
4527#[cfg(feature = "app-gmapmenusequence")]
4528pub trait IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequenceMethods: IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence {
4529    #[doc = "`.ctor(crate::system::action::Action)` overload"]
4530    fn ctor(self, jump_func: impl ::core::convert::Into<crate::system::action::Action>) -> () {
4531        unsafe {
4532            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence as ::unity::FromIlInstance>::from_il_instance(
4533                <Self as ::unity::SystemObject>::as_instance(self),
4534            );
4535            ::unity::il2cpp_call!((::unity::module_base()+0x22fda90usize)as*mut u8,();
4536(GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence)__receiver,(crate::system::action::Action)::core::convert::Into::into(jump_func))
4537        }
4538    }
4539    #[doc = "`JumpToRanking()` overload"]
4540    fn jump_to_ranking(self) -> () {
4541        unsafe {
4542            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence as ::unity::FromIlInstance>::from_il_instance(
4543                <Self as ::unity::SystemObject>::as_instance(self),
4544            );
4545            ::unity::il2cpp_call!((::unity::module_base()+0x22fdad0usize)as*mut u8,();
4546(GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence)__receiver)
4547        }
4548    }
4549}
4550
4551#[cfg(feature = "app-gmapmenusequence")]
4552impl<__T: IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence> IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequenceMethods for __T {}
4553
4554#[cfg(feature = "app-gmapmenusequence")]
4555impl GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence {
4556    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4557        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4558    }
4559
4560    pub fn jump_to_ranking_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4561        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4562    }
4563
4564    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4565        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4566    }
4567}
4568
4569#[cfg(feature = "app-gmapmenusequence")]
4570impl GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence {
4571    #[doc = "`.ctor(crate::system::action::Action)` — overload selector"]
4572    pub fn new(jump_func: crate::system::action::Action) -> Self {
4573        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4574            panic!(
4575                "{}
4576::{}
4577 failed to instantiate",
4578                ::core::stringify!(GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence),
4579                ::core::stringify!(new),
4580            )
4581        });
4582        <Self as IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequenceMethods>::ctor(this, jump_func);
4583        this
4584    }
4585}
4586
4587#[cfg(feature = "app-gmapmenusequence")]
4588pub trait IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItemMethods: IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem {
4589    #[doc = "`GetName()` overload"]
4590    fn get_name(self) -> ::unity::Il2CppString {
4591        unsafe {
4592            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4593                <Self as ::unity::SystemObject>::as_instance(self),
4594            );
4595            {
4596                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4597                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
4598                    panic!(
4599                        "unity: virtual slot {}
4600 out of range (vtable len {}
4601) on the runtime class behind {}
4602 (method `{}
4603`)",
4604                        4usize,
4605                        __vt.len(),
4606                        <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::ClassIdentity>::NAME,
4607                        "GetName",
4608                    )
4609                });
4610                let __inner: extern "C" fn(
4611                    GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem,
4612                    ::unity::OptionalMethod,
4613                ) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
4614                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4615                __inner(__receiver, __mi)
4616            }
4617        }
4618    }
4619    #[doc = "`GetHelpText()` overload"]
4620    fn get_help_text(self) -> ::unity::Il2CppString {
4621        unsafe {
4622            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4623                <Self as ::unity::SystemObject>::as_instance(self),
4624            );
4625            {
4626                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4627                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4628                    panic!(
4629                        "unity: virtual slot {}
4630 out of range (vtable len {}
4631) on the runtime class behind {}
4632 (method `{}
4633`)",
4634                        28usize,
4635                        __vt.len(),
4636                        <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::ClassIdentity>::NAME,
4637                        "GetHelpText",
4638                    )
4639                });
4640                let __inner: extern "C" fn(
4641                    GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem,
4642                    ::unity::OptionalMethod,
4643                ) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
4644                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4645                __inner(__receiver, __mi)
4646            }
4647        }
4648    }
4649    #[doc = "`BuildAttribute()` overload"]
4650    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4651        unsafe {
4652            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4653                <Self as ::unity::SystemObject>::as_instance(self),
4654            );
4655            {
4656                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4657                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
4658                    panic!(
4659                        "unity: virtual slot {}
4660 out of range (vtable len {}
4661) on the runtime class behind {}
4662 (method `{}
4663`)",
4664                        8usize,
4665                        __vt.len(),
4666                        <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::ClassIdentity>::NAME,
4667                        "BuildAttribute",
4668                    )
4669                });
4670                let __inner: extern "C" fn(
4671                    GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem,
4672                    ::unity::OptionalMethod,
4673                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
4674                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4675                __inner(__receiver, __mi)
4676            }
4677        }
4678    }
4679    #[doc = "`ACall()` overload"]
4680    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4681        unsafe {
4682            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4683                <Self as ::unity::SystemObject>::as_instance(self),
4684            );
4685            {
4686                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4687                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
4688                    panic!(
4689                        "unity: virtual slot {}
4690 out of range (vtable len {}
4691) on the runtime class behind {}
4692 (method `{}
4693`)",
4694                        18usize,
4695                        __vt.len(),
4696                        <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::ClassIdentity>::NAME,
4697                        "ACall",
4698                    )
4699                });
4700                let __inner: extern "C" fn(
4701                    GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem,
4702                    ::unity::OptionalMethod,
4703                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4704                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4705                __inner(__receiver, __mi)
4706            }
4707        }
4708    }
4709    #[doc = "`BCall()` overload"]
4710    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4711        unsafe {
4712            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4713                <Self as ::unity::SystemObject>::as_instance(self),
4714            );
4715            {
4716                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4717                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
4718                    panic!(
4719                        "unity: virtual slot {}
4720 out of range (vtable len {}
4721) on the runtime class behind {}
4722 (method `{}
4723`)",
4724                        19usize,
4725                        __vt.len(),
4726                        <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::ClassIdentity>::NAME,
4727                        "BCall",
4728                    )
4729                });
4730                let __inner: extern "C" fn(
4731                    GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem,
4732                    ::unity::OptionalMethod,
4733                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
4734                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4735                __inner(__receiver, __mi)
4736            }
4737        }
4738    }
4739    #[doc = "`.ctor()` overload"]
4740    fn ctor(self) -> () {
4741        unsafe {
4742            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem as ::unity::FromIlInstance>::from_il_instance(
4743                <Self as ::unity::SystemObject>::as_instance(self),
4744            );
4745            ::unity::il2cpp_call!((::unity::module_base()+0x22fed00usize)as*mut u8,();
4746(GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem)__receiver)
4747        }
4748    }
4749}
4750
4751#[cfg(feature = "app-gmapmenusequence")]
4752impl<__T: IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem> IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItemMethods for __T {}
4753
4754#[cfg(feature = "app-gmapmenusequence")]
4755impl GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem {
4756    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4757        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4758    }
4759
4760    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4761        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4762    }
4763
4764    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4765        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4766    }
4767
4768    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4769        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4770    }
4771
4772    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4773        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4774    }
4775
4776    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4777        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4778    }
4779}
4780
4781#[cfg(feature = "app-gmapmenusequence")]
4782impl GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem {
4783    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4784    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4785        let __mi = Self::get_name_method_info();
4786        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4787        __inner(this.into(), ::core::option::Option::None)
4788    }
4789
4790    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4791    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
4792        let __mi = Self::get_help_text_method_info();
4793        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
4794        __inner(this.into(), ::core::option::Option::None)
4795    }
4796
4797    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4798    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
4799        let __mi = Self::build_attribute_method_info();
4800        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
4801            ::core::mem::transmute(__mi.method_ptr);
4802        __inner(this.into(), ::core::option::Option::None)
4803    }
4804
4805    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4806    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4807        let __mi = Self::a_call_method_info();
4808        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4809            ::core::mem::transmute(__mi.method_ptr);
4810        __inner(this.into(), ::core::option::Option::None)
4811    }
4812
4813    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
4814    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
4815        let __mi = Self::b_call_method_info();
4816        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4817            ::core::mem::transmute(__mi.method_ptr);
4818        __inner(this.into(), ::core::option::Option::None)
4819    }
4820}
4821
4822#[cfg(feature = "app-gmapmenusequence")]
4823impl GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem {
4824    #[doc = "`.ctor()` — no args"]
4825    pub fn new() -> Self {
4826        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4827            panic!(
4828                "{}
4829::{}
4830 failed to instantiate",
4831                ::core::stringify!(GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem),
4832                ::core::stringify!(new),
4833            )
4834        });
4835        <Self as IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItemMethods>::ctor(this);
4836        this
4837    }
4838}
4839
4840#[cfg(feature = "app-gmapmenusequence")]
4841impl GmapMenuSequence_GmapMenu {
4842    #[doc = "`get_EnterChapterType()` overload"]
4843    pub fn get_enter_chapter_type() -> crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type {
4844        unsafe {
4845            ::unity::il2cpp_call!((::unity::module_base()+0x1cccd10usize)as*mut u8,crate::app::gmap::enterchapteryesnodialog::EnterChapterYesNoDialog_Type;
4846            )
4847        }
4848    }
4849
4850    #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
4851    pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
4852        unsafe {
4853            ::unity::il2cpp_call!((::unity::module_base()+0x1cccdc0usize)as*mut u8,();
4854(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
4855        }
4856    }
4857
4858    #[doc = "`AddStartChapterItem(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)` overload"]
4859    pub fn add_start_chapter_item(
4860        menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
4861    ) -> () {
4862        unsafe {
4863            ::unity::il2cpp_call!((::unity::module_base()+0x1ccd190usize)as*mut u8,();
4864(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>)::core::convert::Into::into(menu_item_list))
4865        }
4866    }
4867}
4868
4869#[cfg(feature = "app-gmapmenusequence")]
4870pub trait IGmapMenuSequence_GmapMenuMethods: IGmapMenuSequence_GmapMenu {
4871    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` overload"]
4872    fn ctor(
4873        self,
4874        menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
4875        menu_content: impl ::core::convert::Into<crate::app::basicmenucontent::BasicMenuContent>,
4876    ) -> () {
4877        unsafe {
4878            let __receiver =
4879                <GmapMenuSequence_GmapMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4880            ::unity::il2cpp_call!((::unity::module_base()+0x1cccd60usize)as*mut u8,();
4881(GmapMenuSequence_GmapMenu)__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))
4882        }
4883    }
4884    #[doc = "`GetName()` overload"]
4885    fn get_name(self) -> ::unity::Il2CppString {
4886        unsafe {
4887            let __receiver =
4888                <GmapMenuSequence_GmapMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4889            {
4890                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4891                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
4892                    panic!(
4893                        "unity: virtual slot {}
4894 out of range (vtable len {}
4895) on the runtime class behind {}
4896 (method `{}
4897`)",
4898                        30usize,
4899                        __vt.len(),
4900                        <GmapMenuSequence_GmapMenu as ::unity::ClassIdentity>::NAME,
4901                        "GetName",
4902                    )
4903                });
4904                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
4905                    ::core::mem::transmute(__vi.method_ptr);
4906                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4907                __inner(__receiver, __mi)
4908            }
4909        }
4910    }
4911    #[doc = "`OnResume()` overload"]
4912    fn on_resume(self) -> () {
4913        unsafe {
4914            let __receiver =
4915                <GmapMenuSequence_GmapMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4916            {
4917                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4918                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
4919                    panic!(
4920                        "unity: virtual slot {}
4921 out of range (vtable len {}
4922) on the runtime class behind {}
4923 (method `{}
4924`)",
4925                        28usize,
4926                        __vt.len(),
4927                        <GmapMenuSequence_GmapMenu as ::unity::ClassIdentity>::NAME,
4928                        "OnResume",
4929                    )
4930                });
4931                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
4932                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4933                __inner(__receiver, __mi)
4934            }
4935        }
4936    }
4937    #[doc = "`BCall()` overload"]
4938    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
4939        unsafe {
4940            let __receiver =
4941                <GmapMenuSequence_GmapMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4942            {
4943                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
4944                let __vi = *__vt.get(51usize).unwrap_or_else(|| {
4945                    panic!(
4946                        "unity: virtual slot {}
4947 out of range (vtable len {}
4948) on the runtime class behind {}
4949 (method `{}
4950`)",
4951                        51usize,
4952                        __vt.len(),
4953                        <GmapMenuSequence_GmapMenu as ::unity::ClassIdentity>::NAME,
4954                        "BCall",
4955                    )
4956                });
4957                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
4958                    ::core::mem::transmute(__vi.method_ptr);
4959                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
4960                __inner(__receiver, __mi)
4961            }
4962        }
4963    }
4964}
4965
4966#[cfg(feature = "app-gmapmenusequence")]
4967impl<__T: IGmapMenuSequence_GmapMenu> IGmapMenuSequence_GmapMenuMethods for __T {}
4968
4969#[cfg(feature = "app-gmapmenusequence")]
4970impl GmapMenuSequence_GmapMenu {
4971    pub fn get_enter_chapter_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4972        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4973    }
4974
4975    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4976        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4977    }
4978
4979    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4980        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4981    }
4982
4983    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4984        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4985    }
4986
4987    pub fn add_start_chapter_item_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4988        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4989    }
4990
4991    pub fn on_resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4992        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4993    }
4994
4995    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4996        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4997    }
4998}
4999
5000#[cfg(feature = "app-gmapmenusequence")]
5001impl GmapMenuSequence_GmapMenu {
5002    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5003    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5004        let __mi = Self::get_name_method_info();
5005        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5006        __inner(this.into(), ::core::option::Option::None)
5007    }
5008
5009    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu`'s own `OnResume`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5010    pub unsafe fn on_resume(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
5011        let __mi = Self::on_resume_method_info();
5012        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
5013        __inner(this.into(), ::core::option::Option::None)
5014    }
5015
5016    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5017    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5018        let __mi = Self::b_call_method_info();
5019        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5020            ::core::mem::transmute(__mi.method_ptr);
5021        __inner(this.into(), ::core::option::Option::None)
5022    }
5023}
5024
5025#[cfg(feature = "app-gmapmenusequence")]
5026impl GmapMenuSequence_GmapMenu {
5027    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::basicmenucontent::BasicMenuContent)` — overload selector"]
5028    pub fn new(
5029        menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
5030        menu_content: crate::app::basicmenucontent::BasicMenuContent,
5031    ) -> Self {
5032        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5033            panic!(
5034                "{}
5035::{}
5036 failed to instantiate",
5037                ::core::stringify!(GmapMenuSequence_GmapMenu),
5038                ::core::stringify!(new),
5039            )
5040        });
5041        <Self as IGmapMenuSequence_GmapMenuMethods>::ctor(this, menu_item_list, menu_content);
5042        this
5043    }
5044}
5045
5046#[cfg(feature = "app-gmapmenusequence")]
5047impl GmapMenuSequence_GoToMapSequence {
5048    #[doc = "`CreateBind(crate::app::procinst::ProcInst)` overload"]
5049    pub fn create_bind(super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>) -> () {
5050        unsafe {
5051            ::unity::il2cpp_call!((::unity::module_base()+0x1ccdaf0usize)as*mut u8,();
5052(crate::app::procinst::ProcInst)::core::convert::Into::into(super_))
5053        }
5054    }
5055}
5056
5057#[cfg(feature = "app-gmapmenusequence")]
5058pub trait IGmapMenuSequence_GoToMapSequenceMethods: IGmapMenuSequence_GoToMapSequence {
5059    #[doc = "`OpenDialog()` overload"]
5060    fn open_dialog(self) -> () {
5061        unsafe {
5062            let __receiver =
5063                <GmapMenuSequence_GoToMapSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5064            ::unity::il2cpp_call!((::unity::module_base()+0x1ccd5c0usize)as*mut u8,();
5065(GmapMenuSequence_GoToMapSequence)__receiver)
5066        }
5067    }
5068    #[doc = "`MoveSolanel()` overload"]
5069    fn move_solanel(self) -> () {
5070        unsafe {
5071            let __receiver =
5072                <GmapMenuSequence_GoToMapSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5073            ::unity::il2cpp_call!((::unity::module_base()+0x1ccd760usize)as*mut u8,();
5074(GmapMenuSequence_GoToMapSequence)__receiver)
5075        }
5076    }
5077    #[doc = "`MoveGmap()` overload"]
5078    fn move_gmap(self) -> () {
5079        unsafe {
5080            let __receiver =
5081                <GmapMenuSequence_GoToMapSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5082            ::unity::il2cpp_call!((::unity::module_base()+0x1ccd940usize)as*mut u8,();
5083(GmapMenuSequence_GoToMapSequence)__receiver)
5084        }
5085    }
5086    #[doc = "`.ctor()` overload"]
5087    fn ctor(self) -> () {
5088        unsafe {
5089            let __receiver =
5090                <GmapMenuSequence_GoToMapSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5091            ::unity::il2cpp_call!((::unity::module_base()+0x1ccdfa0usize)as*mut u8,();
5092(GmapMenuSequence_GoToMapSequence)__receiver)
5093        }
5094    }
5095}
5096
5097#[cfg(feature = "app-gmapmenusequence")]
5098impl<__T: IGmapMenuSequence_GoToMapSequence> IGmapMenuSequence_GoToMapSequenceMethods for __T {}
5099
5100#[cfg(feature = "app-gmapmenusequence")]
5101impl GmapMenuSequence_GoToMapSequence {
5102    pub fn open_dialog_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5103        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5104    }
5105
5106    pub fn move_solanel_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5107        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5108    }
5109
5110    pub fn move_gmap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5111        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5112    }
5113
5114    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5115        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5116    }
5117
5118    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5119        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5120    }
5121}
5122
5123#[cfg(feature = "app-gmapmenusequence")]
5124impl GmapMenuSequence_GoToMapSequence {
5125    #[doc = "`.ctor()` — no args"]
5126    pub fn new() -> Self {
5127        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5128            panic!(
5129                "{}
5130::{}
5131 failed to instantiate",
5132                ::core::stringify!(GmapMenuSequence_GoToMapSequence),
5133                ::core::stringify!(new),
5134            )
5135        });
5136        <Self as IGmapMenuSequence_GoToMapSequenceMethods>::ctor(this);
5137        this
5138    }
5139}
5140
5141#[cfg(feature = "app-gmapmenusequence")]
5142pub trait IGmapMenuSequence_GmapMenu_GoToSolanelItemMethods: IGmapMenuSequence_GmapMenu_GoToSolanelItem {
5143    #[doc = "`GetName()` overload"]
5144    fn get_name(self) -> ::unity::Il2CppString {
5145        unsafe {
5146            let __receiver = <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::FromIlInstance>::from_il_instance(
5147                <Self as ::unity::SystemObject>::as_instance(self),
5148            );
5149            {
5150                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5151                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5152                    panic!(
5153                        "unity: virtual slot {}
5154 out of range (vtable len {}
5155) on the runtime class behind {}
5156 (method `{}
5157`)",
5158                        4usize,
5159                        __vt.len(),
5160                        <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::ClassIdentity>::NAME,
5161                        "GetName",
5162                    )
5163                });
5164                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GoToSolanelItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5165                    ::core::mem::transmute(__vi.method_ptr);
5166                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5167                __inner(__receiver, __mi)
5168            }
5169        }
5170    }
5171    #[doc = "`GetHelpText()` overload"]
5172    fn get_help_text(self) -> ::unity::Il2CppString {
5173        unsafe {
5174            let __receiver = <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::FromIlInstance>::from_il_instance(
5175                <Self as ::unity::SystemObject>::as_instance(self),
5176            );
5177            {
5178                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5179                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
5180                    panic!(
5181                        "unity: virtual slot {}
5182 out of range (vtable len {}
5183) on the runtime class behind {}
5184 (method `{}
5185`)",
5186                        28usize,
5187                        __vt.len(),
5188                        <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::ClassIdentity>::NAME,
5189                        "GetHelpText",
5190                    )
5191                });
5192                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_GoToSolanelItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5193                    ::core::mem::transmute(__vi.method_ptr);
5194                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5195                __inner(__receiver, __mi)
5196            }
5197        }
5198    }
5199    #[doc = "`BuildAttribute()` overload"]
5200    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5201        unsafe {
5202            let __receiver = <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::FromIlInstance>::from_il_instance(
5203                <Self as ::unity::SystemObject>::as_instance(self),
5204            );
5205            {
5206                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5207                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
5208                    panic!(
5209                        "unity: virtual slot {}
5210 out of range (vtable len {}
5211) on the runtime class behind {}
5212 (method `{}
5213`)",
5214                        8usize,
5215                        __vt.len(),
5216                        <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::ClassIdentity>::NAME,
5217                        "BuildAttribute",
5218                    )
5219                });
5220                let __inner: extern "C" fn(
5221                    GmapMenuSequence_GmapMenu_GoToSolanelItem,
5222                    ::unity::OptionalMethod,
5223                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
5224                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5225                __inner(__receiver, __mi)
5226            }
5227        }
5228    }
5229    #[doc = "`ACall()` overload"]
5230    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
5231        unsafe {
5232            let __receiver = <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::FromIlInstance>::from_il_instance(
5233                <Self as ::unity::SystemObject>::as_instance(self),
5234            );
5235            {
5236                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5237                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
5238                    panic!(
5239                        "unity: virtual slot {}
5240 out of range (vtable len {}
5241) on the runtime class behind {}
5242 (method `{}
5243`)",
5244                        18usize,
5245                        __vt.len(),
5246                        <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::ClassIdentity>::NAME,
5247                        "ACall",
5248                    )
5249                });
5250                let __inner: extern "C" fn(
5251                    GmapMenuSequence_GmapMenu_GoToSolanelItem,
5252                    ::unity::OptionalMethod,
5253                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
5254                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5255                __inner(__receiver, __mi)
5256            }
5257        }
5258    }
5259    #[doc = "`.ctor()` overload"]
5260    fn ctor(self) -> () {
5261        unsafe {
5262            let __receiver = <GmapMenuSequence_GmapMenu_GoToSolanelItem as ::unity::FromIlInstance>::from_il_instance(
5263                <Self as ::unity::SystemObject>::as_instance(self),
5264            );
5265            ::unity::il2cpp_call!((::unity::module_base()+0x1b3bee0usize)as*mut u8,();
5266(GmapMenuSequence_GmapMenu_GoToSolanelItem)__receiver)
5267        }
5268    }
5269}
5270
5271#[cfg(feature = "app-gmapmenusequence")]
5272impl<__T: IGmapMenuSequence_GmapMenu_GoToSolanelItem> IGmapMenuSequence_GmapMenu_GoToSolanelItemMethods for __T {}
5273
5274#[cfg(feature = "app-gmapmenusequence")]
5275impl GmapMenuSequence_GmapMenu_GoToSolanelItem {
5276    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5277        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5278    }
5279
5280    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5281        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5282    }
5283
5284    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5285        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5286    }
5287
5288    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5289        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5290    }
5291
5292    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5293        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5294    }
5295}
5296
5297#[cfg(feature = "app-gmapmenusequence")]
5298impl GmapMenuSequence_GmapMenu_GoToSolanelItem {
5299    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GoToSolanelItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5300    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5301        let __mi = Self::get_name_method_info();
5302        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5303        __inner(this.into(), ::core::option::Option::None)
5304    }
5305
5306    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GoToSolanelItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5307    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5308        let __mi = Self::get_help_text_method_info();
5309        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5310        __inner(this.into(), ::core::option::Option::None)
5311    }
5312
5313    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GoToSolanelItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5314    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5315        let __mi = Self::build_attribute_method_info();
5316        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
5317            ::core::mem::transmute(__mi.method_ptr);
5318        __inner(this.into(), ::core::option::Option::None)
5319    }
5320
5321    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_GoToSolanelItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5322    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5323        let __mi = Self::a_call_method_info();
5324        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5325            ::core::mem::transmute(__mi.method_ptr);
5326        __inner(this.into(), ::core::option::Option::None)
5327    }
5328}
5329
5330#[cfg(feature = "app-gmapmenusequence")]
5331impl GmapMenuSequence_GmapMenu_GoToSolanelItem {
5332    #[doc = "`.ctor()` — no args"]
5333    pub fn new() -> Self {
5334        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5335            panic!(
5336                "{}
5337::{}
5338 failed to instantiate",
5339                ::core::stringify!(GmapMenuSequence_GmapMenu_GoToSolanelItem),
5340                ::core::stringify!(new),
5341            )
5342        });
5343        <Self as IGmapMenuSequence_GmapMenu_GoToSolanelItemMethods>::ctor(this);
5344        this
5345    }
5346}
5347
5348#[cfg(feature = "app-gmapmenusequence")]
5349pub trait IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItemMethods:
5350    IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem
5351{
5352    #[doc = "`GetName()` overload"]
5353    fn get_name(self) -> ::unity::Il2CppString {
5354        unsafe {
5355            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem as ::unity::FromIlInstance>::from_il_instance(
5356                <Self as ::unity::SystemObject>::as_instance(self),
5357            );
5358            {
5359                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5360                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5361                    panic!(
5362                        "unity: virtual slot {}
5363 out of range (vtable len {}
5364) on the runtime class behind {}
5365 (method `{}
5366`)",
5367                        4usize,
5368                        __vt.len(),
5369                        <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem as ::unity::ClassIdentity>::NAME,
5370                        "GetName",
5371                    )
5372                });
5373                let __inner: extern "C" fn(
5374                    GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem,
5375                    ::unity::OptionalMethod,
5376                ) -> ::unity::Il2CppString = ::core::mem::transmute(__vi.method_ptr);
5377                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5378                __inner(__receiver, __mi)
5379            }
5380        }
5381    }
5382    #[doc = "`.ctor()` overload"]
5383    fn ctor(self) -> () {
5384        unsafe {
5385            let __receiver = <GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem as ::unity::FromIlInstance>::from_il_instance(
5386                <Self as ::unity::SystemObject>::as_instance(self),
5387            );
5388            ::unity::il2cpp_call!((::unity::module_base()+0x3edb0d0usize)as*mut u8,();
5389(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem)__receiver)
5390        }
5391    }
5392}
5393
5394#[cfg(feature = "app-gmapmenusequence")]
5395impl<__T: IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem> IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItemMethods
5396    for __T
5397{
5398}
5399
5400#[cfg(feature = "app-gmapmenusequence")]
5401impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem {
5402    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5403        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5404    }
5405
5406    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5407        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5408    }
5409}
5410
5411#[cfg(feature = "app-gmapmenusequence")]
5412impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem {
5413    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5414    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5415        let __mi = Self::get_name_method_info();
5416        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5417        __inner(this.into(), ::core::option::Option::None)
5418    }
5419}
5420
5421#[cfg(feature = "app-gmapmenusequence")]
5422impl GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem {
5423    #[doc = "`.ctor()` — no args"]
5424    pub fn new() -> Self {
5425        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5426            panic!(
5427                "{}
5428::{}
5429 failed to instantiate",
5430                ::core::stringify!(GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem),
5431                ::core::stringify!(new),
5432            )
5433        });
5434        <Self as IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItemMethods>::ctor(this);
5435        this
5436    }
5437}
5438
5439#[cfg(feature = "app-gmapmenusequence")]
5440pub trait IGmapMenuSequence_GmapMenu_SystemItemMethods: IGmapMenuSequence_GmapMenu_SystemItem {
5441    #[doc = "`get_FlagID()` overload"]
5442    fn get_flag_id(self) -> ::unity::Il2CppString {
5443        unsafe {
5444            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5445                <Self as ::unity::SystemObject>::as_instance(self),
5446            );
5447            {
5448                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5449                let __vi = *__vt.get(27usize).unwrap_or_else(|| {
5450                    panic!(
5451                        "unity: virtual slot {}
5452 out of range (vtable len {}
5453) on the runtime class behind {}
5454 (method `{}
5455`)",
5456                        27usize,
5457                        __vt.len(),
5458                        <GmapMenuSequence_GmapMenu_SystemItem as ::unity::ClassIdentity>::NAME,
5459                        "get_FlagID",
5460                    )
5461                });
5462                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5463                    ::core::mem::transmute(__vi.method_ptr);
5464                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5465                __inner(__receiver, __mi)
5466            }
5467        }
5468    }
5469    #[doc = "`GetName()` overload"]
5470    fn get_name(self) -> ::unity::Il2CppString {
5471        unsafe {
5472            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5473                <Self as ::unity::SystemObject>::as_instance(self),
5474            );
5475            {
5476                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5477                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5478                    panic!(
5479                        "unity: virtual slot {}
5480 out of range (vtable len {}
5481) on the runtime class behind {}
5482 (method `{}
5483`)",
5484                        4usize,
5485                        __vt.len(),
5486                        <GmapMenuSequence_GmapMenu_SystemItem as ::unity::ClassIdentity>::NAME,
5487                        "GetName",
5488                    )
5489                });
5490                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5491                    ::core::mem::transmute(__vi.method_ptr);
5492                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5493                __inner(__receiver, __mi)
5494            }
5495        }
5496    }
5497    #[doc = "`GetHelpText()` overload"]
5498    fn get_help_text(self) -> ::unity::Il2CppString {
5499        unsafe {
5500            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5501                <Self as ::unity::SystemObject>::as_instance(self),
5502            );
5503            {
5504                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5505                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
5506                    panic!(
5507                        "unity: virtual slot {}
5508 out of range (vtable len {}
5509) on the runtime class behind {}
5510 (method `{}
5511`)",
5512                        28usize,
5513                        __vt.len(),
5514                        <GmapMenuSequence_GmapMenu_SystemItem as ::unity::ClassIdentity>::NAME,
5515                        "GetHelpText",
5516                    )
5517                });
5518                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SystemItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5519                    ::core::mem::transmute(__vi.method_ptr);
5520                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5521                __inner(__receiver, __mi)
5522            }
5523        }
5524    }
5525    #[doc = "`GetMapAttribute()` overload"]
5526    fn get_map_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5527        unsafe {
5528            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5529                <Self as ::unity::SystemObject>::as_instance(self),
5530            );
5531            {
5532                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5533                let __vi = *__vt.get(29usize).unwrap_or_else(|| {
5534                    panic!(
5535                        "unity: virtual slot {}
5536 out of range (vtable len {}
5537) on the runtime class behind {}
5538 (method `{}
5539`)",
5540                        29usize,
5541                        __vt.len(),
5542                        <GmapMenuSequence_GmapMenu_SystemItem as ::unity::ClassIdentity>::NAME,
5543                        "GetMapAttribute",
5544                    )
5545                });
5546                let __inner: extern "C" fn(
5547                    GmapMenuSequence_GmapMenu_SystemItem,
5548                    ::unity::OptionalMethod,
5549                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
5550                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5551                __inner(__receiver, __mi)
5552            }
5553        }
5554    }
5555    #[doc = "`ACall()` overload"]
5556    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
5557        unsafe {
5558            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5559                <Self as ::unity::SystemObject>::as_instance(self),
5560            );
5561            {
5562                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5563                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
5564                    panic!(
5565                        "unity: virtual slot {}
5566 out of range (vtable len {}
5567) on the runtime class behind {}
5568 (method `{}
5569`)",
5570                        18usize,
5571                        __vt.len(),
5572                        <GmapMenuSequence_GmapMenu_SystemItem as ::unity::ClassIdentity>::NAME,
5573                        "ACall",
5574                    )
5575                });
5576                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SystemItem, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5577                    ::core::mem::transmute(__vi.method_ptr);
5578                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5579                __inner(__receiver, __mi)
5580            }
5581        }
5582    }
5583    #[doc = "`.ctor()` overload"]
5584    fn ctor(self) -> () {
5585        unsafe {
5586            let __receiver = <GmapMenuSequence_GmapMenu_SystemItem as ::unity::FromIlInstance>::from_il_instance(
5587                <Self as ::unity::SystemObject>::as_instance(self),
5588            );
5589            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d9c0usize)as*mut u8,();
5590(GmapMenuSequence_GmapMenu_SystemItem)__receiver)
5591        }
5592    }
5593}
5594
5595#[cfg(feature = "app-gmapmenusequence")]
5596impl<__T: IGmapMenuSequence_GmapMenu_SystemItem> IGmapMenuSequence_GmapMenu_SystemItemMethods for __T {}
5597
5598#[cfg(feature = "app-gmapmenusequence")]
5599impl GmapMenuSequence_GmapMenu_SystemItem {
5600    pub fn get_flag_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5601        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5602    }
5603
5604    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5605        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5606    }
5607
5608    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5609        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5610    }
5611
5612    pub fn get_map_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5613        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5614    }
5615
5616    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5617        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5618    }
5619
5620    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5621        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5622    }
5623}
5624
5625#[cfg(feature = "app-gmapmenusequence")]
5626impl GmapMenuSequence_GmapMenu_SystemItem {
5627    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SystemItem`'s own `get_FlagID`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5628    pub unsafe fn get_flag_id(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5629        let __mi = Self::get_flag_id_method_info();
5630        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5631        __inner(this.into(), ::core::option::Option::None)
5632    }
5633
5634    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SystemItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5635    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5636        let __mi = Self::get_name_method_info();
5637        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5638        __inner(this.into(), ::core::option::Option::None)
5639    }
5640
5641    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SystemItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5642    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5643        let __mi = Self::get_help_text_method_info();
5644        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5645        __inner(this.into(), ::core::option::Option::None)
5646    }
5647
5648    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SystemItem`'s own `GetMapAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5649    pub unsafe fn get_map_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5650        let __mi = Self::get_map_attribute_method_info();
5651        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
5652            ::core::mem::transmute(__mi.method_ptr);
5653        __inner(this.into(), ::core::option::Option::None)
5654    }
5655
5656    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SystemItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5657    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5658        let __mi = Self::a_call_method_info();
5659        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5660            ::core::mem::transmute(__mi.method_ptr);
5661        __inner(this.into(), ::core::option::Option::None)
5662    }
5663}
5664
5665#[cfg(feature = "app-gmapmenusequence")]
5666impl GmapMenuSequence_GmapMenu_SystemItem {
5667    #[doc = "`.ctor()` — no args"]
5668    pub fn new() -> Self {
5669        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5670            panic!(
5671                "{}
5672::{}
5673 failed to instantiate",
5674                ::core::stringify!(GmapMenuSequence_GmapMenu_SystemItem),
5675                ::core::stringify!(new),
5676            )
5677        });
5678        <Self as IGmapMenuSequence_GmapMenu_SystemItemMethods>::ctor(this);
5679        this
5680    }
5681}
5682
5683#[cfg(feature = "app-gmapmenusequence")]
5684pub trait IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItemMethods: IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem {
5685    #[doc = "`GetName()` overload"]
5686    fn get_name(self) -> ::unity::Il2CppString {
5687        unsafe {
5688            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5689                <Self as ::unity::SystemObject>::as_instance(self),
5690            );
5691            {
5692                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5693                let __vi = *__vt.get(4usize).unwrap_or_else(|| {
5694                    panic!(
5695                        "unity: virtual slot {}
5696 out of range (vtable len {}
5697) on the runtime class behind {}
5698 (method `{}
5699`)",
5700                        4usize,
5701                        __vt.len(),
5702                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
5703                        "GetName",
5704                    )
5705                });
5706                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5707                    ::core::mem::transmute(__vi.method_ptr);
5708                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5709                __inner(__receiver, __mi)
5710            }
5711        }
5712    }
5713    #[doc = "`GetHelpText()` overload"]
5714    fn get_help_text(self) -> ::unity::Il2CppString {
5715        unsafe {
5716            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5717                <Self as ::unity::SystemObject>::as_instance(self),
5718            );
5719            {
5720                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5721                let __vi = *__vt.get(28usize).unwrap_or_else(|| {
5722                    panic!(
5723                        "unity: virtual slot {}
5724 out of range (vtable len {}
5725) on the runtime class behind {}
5726 (method `{}
5727`)",
5728                        28usize,
5729                        __vt.len(),
5730                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
5731                        "GetHelpText",
5732                    )
5733                });
5734                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
5735                    ::core::mem::transmute(__vi.method_ptr);
5736                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5737                __inner(__receiver, __mi)
5738            }
5739        }
5740    }
5741    #[doc = "`BuildAttribute()` overload"]
5742    fn build_attribute(self) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5743        unsafe {
5744            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5745                <Self as ::unity::SystemObject>::as_instance(self),
5746            );
5747            {
5748                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5749                let __vi = *__vt.get(8usize).unwrap_or_else(|| {
5750                    panic!(
5751                        "unity: virtual slot {}
5752 out of range (vtable len {}
5753) on the runtime class behind {}
5754 (method `{}
5755`)",
5756                        8usize,
5757                        __vt.len(),
5758                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
5759                        "BuildAttribute",
5760                    )
5761                });
5762                let __inner: extern "C" fn(
5763                    GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem,
5764                    ::unity::OptionalMethod,
5765                ) -> crate::app::basicmenuitem::BasicMenuItem_Attribute = ::core::mem::transmute(__vi.method_ptr);
5766                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5767                __inner(__receiver, __mi)
5768            }
5769        }
5770    }
5771    #[doc = "`ACall()` overload"]
5772    fn a_call(self) -> crate::app::basicmenu::BasicMenu_Result {
5773        unsafe {
5774            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5775                <Self as ::unity::SystemObject>::as_instance(self),
5776            );
5777            {
5778                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5779                let __vi = *__vt.get(18usize).unwrap_or_else(|| {
5780                    panic!(
5781                        "unity: virtual slot {}
5782 out of range (vtable len {}
5783) on the runtime class behind {}
5784 (method `{}
5785`)",
5786                        18usize,
5787                        __vt.len(),
5788                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
5789                        "ACall",
5790                    )
5791                });
5792                let __inner: extern "C" fn(
5793                    GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem,
5794                    ::unity::OptionalMethod,
5795                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
5796                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5797                __inner(__receiver, __mi)
5798            }
5799        }
5800    }
5801    #[doc = "`BCall()` overload"]
5802    fn b_call(self) -> crate::app::basicmenu::BasicMenu_Result {
5803        unsafe {
5804            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5805                <Self as ::unity::SystemObject>::as_instance(self),
5806            );
5807            {
5808                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5809                let __vi = *__vt.get(19usize).unwrap_or_else(|| {
5810                    panic!(
5811                        "unity: virtual slot {}
5812 out of range (vtable len {}
5813) on the runtime class behind {}
5814 (method `{}
5815`)",
5816                        19usize,
5817                        __vt.len(),
5818                        <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::ClassIdentity>::NAME,
5819                        "BCall",
5820                    )
5821                });
5822                let __inner: extern "C" fn(
5823                    GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem,
5824                    ::unity::OptionalMethod,
5825                ) -> crate::app::basicmenu::BasicMenu_Result = ::core::mem::transmute(__vi.method_ptr);
5826                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5827                __inner(__receiver, __mi)
5828            }
5829        }
5830    }
5831    #[doc = "`.ctor()` overload"]
5832    fn ctor(self) -> () {
5833        unsafe {
5834            let __receiver = <GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem as ::unity::FromIlInstance>::from_il_instance(
5835                <Self as ::unity::SystemObject>::as_instance(self),
5836            );
5837            ::unity::il2cpp_call!((::unity::module_base()+0x22fef60usize)as*mut u8,();
5838(GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem)__receiver)
5839        }
5840    }
5841}
5842
5843#[cfg(feature = "app-gmapmenusequence")]
5844impl<__T: IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem> IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItemMethods for __T {}
5845
5846#[cfg(feature = "app-gmapmenusequence")]
5847impl GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem {
5848    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5849        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
5850    }
5851
5852    pub fn get_help_text_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5853        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
5854    }
5855
5856    pub fn build_attribute_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5857        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
5858    }
5859
5860    pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5861        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
5862    }
5863
5864    pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5865        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
5866    }
5867
5868    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
5869        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
5870    }
5871}
5872
5873#[cfg(feature = "app-gmapmenusequence")]
5874impl GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem {
5875    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5876    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5877        let __mi = Self::get_name_method_info();
5878        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5879        __inner(this.into(), ::core::option::Option::None)
5880    }
5881
5882    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem`'s own `GetHelpText`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5883    pub unsafe fn get_help_text(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
5884        let __mi = Self::get_help_text_method_info();
5885        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
5886        __inner(this.into(), ::core::option::Option::None)
5887    }
5888
5889    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem`'s own `BuildAttribute`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5890    pub unsafe fn build_attribute(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenuitem::BasicMenuItem_Attribute {
5891        let __mi = Self::build_attribute_method_info();
5892        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenuitem::BasicMenuItem_Attribute =
5893            ::core::mem::transmute(__mi.method_ptr);
5894        __inner(this.into(), ::core::option::Option::None)
5895    }
5896
5897    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5898    pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5899        let __mi = Self::a_call_method_info();
5900        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5901            ::core::mem::transmute(__mi.method_ptr);
5902        __inner(this.into(), ::core::option::Option::None)
5903    }
5904
5905    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
5906    pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::basicmenu::BasicMenu_Result {
5907        let __mi = Self::b_call_method_info();
5908        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::basicmenu::BasicMenu_Result =
5909            ::core::mem::transmute(__mi.method_ptr);
5910        __inner(this.into(), ::core::option::Option::None)
5911    }
5912}
5913
5914#[cfg(feature = "app-gmapmenusequence")]
5915impl GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem {
5916    #[doc = "`.ctor()` — no args"]
5917    pub fn new() -> Self {
5918        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
5919            panic!(
5920                "{}
5921::{}
5922 failed to instantiate",
5923                ::core::stringify!(GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem),
5924                ::core::stringify!(new),
5925            )
5926        });
5927        <Self as IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItemMethods>::ctor(this);
5928        this
5929    }
5930}
5931
5932#[cfg(feature = "app-gmapmenusequence")]
5933impl GmapMenuSequence {
5934    #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::system::action::Action, crate::system::action::Action, crate::system::action::Action)` overload"]
5935    pub fn create_bind(
5936        super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
5937        open_top_callback: impl ::core::convert::Into<crate::system::action::Action>,
5938        decide_callback: impl ::core::convert::Into<crate::system::action::Action>,
5939        close_callback: impl ::core::convert::Into<crate::system::action::Action>,
5940    ) -> crate::app::procinst::ProcInst {
5941        unsafe {
5942            ::unity::il2cpp_call!((::unity::module_base()+0x252e3a0usize)as*mut u8,crate::app::procinst::ProcInst;
5943(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::system::action::Action)::core::convert::Into::into(open_top_callback),(crate::system::action::Action)::core::convert::Into::into(decide_callback),(crate::system::action::Action)::core::convert::Into::into(close_callback))
5944        }
5945    }
5946}
5947
5948#[cfg(feature = "app-gmapmenusequence")]
5949pub trait IGmapMenuSequenceMethods: IGmapMenuSequence {
5950    #[doc = "`.ctor(crate::system::action::Action, crate::system::action::Action, crate::system::action::Action)` overload"]
5951    fn ctor(
5952        self,
5953        open_top_callback: impl ::core::convert::Into<crate::system::action::Action>,
5954        decide_callback: impl ::core::convert::Into<crate::system::action::Action>,
5955        close_callback: impl ::core::convert::Into<crate::system::action::Action>,
5956    ) -> () {
5957        unsafe {
5958            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5959            ::unity::il2cpp_call!((::unity::module_base()+0x252e2d0usize)as*mut u8,();
5960(GmapMenuSequence)__receiver,(crate::system::action::Action)::core::convert::Into::into(open_top_callback),(crate::system::action::Action)::core::convert::Into::into(decide_callback),(crate::system::action::Action)::core::convert::Into::into(close_callback))
5961        }
5962    }
5963    #[doc = "`OpenTopCallback()` overload"]
5964    fn open_top_callback(self) -> () {
5965        unsafe {
5966            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5967            ::unity::il2cpp_call!((::unity::module_base()+0x252e100usize)as*mut u8,();
5968(GmapMenuSequence)__receiver)
5969        }
5970    }
5971    #[doc = "`OnShutdown()` overload"]
5972    fn on_shutdown(self) -> () {
5973        unsafe {
5974            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
5975            {
5976                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
5977                let __vi = *__vt.get(15usize).unwrap_or_else(|| {
5978                    panic!(
5979                        "unity: virtual slot {}
5980 out of range (vtable len {}
5981) on the runtime class behind {}
5982 (method `{}
5983`)",
5984                        15usize,
5985                        __vt.len(),
5986                        <GmapMenuSequence as ::unity::ClassIdentity>::NAME,
5987                        "OnShutdown",
5988                    )
5989                });
5990                let __inner: extern "C" fn(GmapMenuSequence, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
5991                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
5992                __inner(__receiver, __mi)
5993            }
5994        }
5995    }
5996    #[doc = "`Init()` overload"]
5997    fn init(self) -> () {
5998        unsafe {
5999            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6000            ::unity::il2cpp_call!((::unity::module_base()+0x252f040usize)as*mut u8,();
6001(GmapMenuSequence)__receiver)
6002        }
6003    }
6004    #[doc = "`OpenTopMenu()` overload"]
6005    fn open_top_menu(self) -> () {
6006        unsafe {
6007            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6008            ::unity::il2cpp_call!((::unity::module_base()+0x252f0c0usize)as*mut u8,();
6009(GmapMenuSequence)__receiver)
6010        }
6011    }
6012    #[doc = "`EnterChapterDialog()` overload"]
6013    fn enter_chapter_dialog(self) -> () {
6014        unsafe {
6015            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6016            ::unity::il2cpp_call!((::unity::module_base()+0x252f100usize)as*mut u8,();
6017(GmapMenuSequence)__receiver)
6018        }
6019    }
6020    #[doc = "`Final()` overload"]
6021    fn r#final(self) -> () {
6022        unsafe {
6023            let __receiver = <GmapMenuSequence as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
6024            ::unity::il2cpp_call!((::unity::module_base()+0x252f1f0usize)as*mut u8,();
6025(GmapMenuSequence)__receiver)
6026        }
6027    }
6028}
6029
6030#[cfg(feature = "app-gmapmenusequence")]
6031impl<__T: IGmapMenuSequence> IGmapMenuSequenceMethods for __T {}
6032
6033#[cfg(feature = "app-gmapmenusequence")]
6034impl GmapMenuSequence {
6035    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6036        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6037    }
6038
6039    pub fn open_top_callback_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6040        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6041    }
6042
6043    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6044        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6045    }
6046
6047    pub fn on_shutdown_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6048        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
6049    }
6050
6051    pub fn init_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6052        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
6053    }
6054
6055    pub fn open_top_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6056        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
6057    }
6058
6059    pub fn enter_chapter_dialog_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6060        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
6061    }
6062
6063    pub fn final_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6064        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
6065    }
6066}
6067
6068#[cfg(feature = "app-gmapmenusequence")]
6069impl GmapMenuSequence {
6070    #[doc = "Direct (non-virtual) call to `GmapMenuSequence`'s own `OnShutdown`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6071    pub unsafe fn on_shutdown(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
6072        let __mi = Self::on_shutdown_method_info();
6073        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
6074        __inner(this.into(), ::core::option::Option::None)
6075    }
6076}
6077
6078#[cfg(feature = "app-gmapmenusequence")]
6079impl GmapMenuSequence {
6080    #[doc = "`.ctor(crate::system::action::Action, crate::system::action::Action, crate::system::action::Action)` — overload selector"]
6081    pub fn new(
6082        open_top_callback: crate::system::action::Action,
6083        decide_callback: crate::system::action::Action,
6084        close_callback: crate::system::action::Action,
6085    ) -> Self {
6086        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6087            panic!(
6088                "{}
6089::{}
6090 failed to instantiate",
6091                ::core::stringify!(GmapMenuSequence),
6092                ::core::stringify!(new),
6093            )
6094        });
6095        <Self as IGmapMenuSequenceMethods>::ctor(this, open_top_callback, decide_callback, close_callback);
6096        this
6097    }
6098}
6099
6100#[cfg(feature = "app-gmapmenusequence")]
6101impl GmapMenuSequence_GmapMenu_SubShopMenu {
6102    #[doc = "`CreateBind(crate::app::basicmenu::BasicMenu, crate::app::basicmenuitem::BasicMenuItem)` overload"]
6103    pub fn create_bind(
6104        super_: impl ::core::convert::Into<crate::app::basicmenu::BasicMenu>,
6105        parent_menu_item: impl ::core::convert::Into<crate::app::basicmenuitem::BasicMenuItem>,
6106    ) -> () {
6107        unsafe {
6108            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d270usize)as*mut u8,();
6109(crate::app::basicmenu::BasicMenu)::core::convert::Into::into(super_),(crate::app::basicmenuitem::BasicMenuItem)::core::convert::Into::into(parent_menu_item))
6110        }
6111    }
6112}
6113
6114#[cfg(feature = "app-gmapmenusequence")]
6115pub trait IGmapMenuSequence_GmapMenu_SubShopMenuMethods: IGmapMenuSequence_GmapMenu_SubShopMenu {
6116    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` overload"]
6117    fn ctor(
6118        self,
6119        menu_item_list: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>>,
6120        menu_content: impl ::core::convert::Into<crate::app::sortiesubmenucontent::SortieSubMenuContent>,
6121    ) -> () {
6122        unsafe {
6123            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu as ::unity::FromIlInstance>::from_il_instance(
6124                <Self as ::unity::SystemObject>::as_instance(self),
6125            );
6126            ::unity::il2cpp_call!((::unity::module_base()+0x1b3d4c0usize)as*mut u8,();
6127(GmapMenuSequence_GmapMenu_SubShopMenu)__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))
6128        }
6129    }
6130    #[doc = "`GetName()` overload"]
6131    fn get_name(self) -> ::unity::Il2CppString {
6132        unsafe {
6133            let __receiver = <GmapMenuSequence_GmapMenu_SubShopMenu as ::unity::FromIlInstance>::from_il_instance(
6134                <Self as ::unity::SystemObject>::as_instance(self),
6135            );
6136            {
6137                let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
6138                let __vi = *__vt.get(30usize).unwrap_or_else(|| {
6139                    panic!(
6140                        "unity: virtual slot {}
6141 out of range (vtable len {}
6142) on the runtime class behind {}
6143 (method `{}
6144`)",
6145                        30usize,
6146                        __vt.len(),
6147                        <GmapMenuSequence_GmapMenu_SubShopMenu as ::unity::ClassIdentity>::NAME,
6148                        "GetName",
6149                    )
6150                });
6151                let __inner: extern "C" fn(GmapMenuSequence_GmapMenu_SubShopMenu, ::unity::OptionalMethod) -> ::unity::Il2CppString =
6152                    ::core::mem::transmute(__vi.method_ptr);
6153                let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
6154                __inner(__receiver, __mi)
6155            }
6156        }
6157    }
6158}
6159
6160#[cfg(feature = "app-gmapmenusequence")]
6161impl<__T: IGmapMenuSequence_GmapMenu_SubShopMenu> IGmapMenuSequence_GmapMenu_SubShopMenuMethods for __T {}
6162
6163#[cfg(feature = "app-gmapmenusequence")]
6164impl GmapMenuSequence_GmapMenu_SubShopMenu {
6165    pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6166        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
6167    }
6168
6169    pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6170        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
6171    }
6172
6173    pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
6174        <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
6175    }
6176}
6177
6178#[cfg(feature = "app-gmapmenusequence")]
6179impl GmapMenuSequence_GmapMenu_SubShopMenu {
6180    #[doc = "Direct (non-virtual) call to `GmapMenuSequence_GmapMenu_SubShopMenu`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
6181    pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
6182        let __mi = Self::get_name_method_info();
6183        let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
6184        __inner(this.into(), ::core::option::Option::None)
6185    }
6186}
6187
6188#[cfg(feature = "app-gmapmenusequence")]
6189impl GmapMenuSequence_GmapMenu_SubShopMenu {
6190    #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>, crate::app::sortiesubmenucontent::SortieSubMenuContent)` — overload selector"]
6191    pub fn new(
6192        menu_item_list: crate::system::collections::generic::list_1::List_1<crate::app::basicmenuitem::BasicMenuItem>,
6193        menu_content: crate::app::sortiesubmenucontent::SortieSubMenuContent,
6194    ) -> Self {
6195        let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
6196            panic!(
6197                "{}
6198::{}
6199 failed to instantiate",
6200                ::core::stringify!(GmapMenuSequence_GmapMenu_SubShopMenu),
6201                ::core::stringify!(new),
6202            )
6203        });
6204        <Self as IGmapMenuSequence_GmapMenu_SubShopMenuMethods>::ctor(this, menu_item_list, menu_content);
6205        this
6206    }
6207}
6208
6209#[cfg(feature = "app-gmapmenusequence")]
6210#[doc(hidden)]
6211pub mod prelude {
6212    pub use super::{
6213        GmapMenuSequence, GmapMenuSequence_GmapMenu, GmapMenuSequence_GmapMenu_EnterChapterItem, GmapMenuSequence_GmapMenu_FriendItem,
6214        GmapMenuSequence_GmapMenu_GmapMenuMenuItem, GmapMenuSequence_GmapMenu_GoToSolanelItem, GmapMenuSequence_GmapMenu_GodItem,
6215        GmapMenuSequence_GmapMenu_InventoryItem, GmapMenuSequence_GmapMenu_MaterialListItem, GmapMenuSequence_GmapMenu_RankingItem,
6216        GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence, GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem,
6217        GmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem, GmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence,
6218        GmapMenuSequence_GmapMenu_SaveItem, GmapMenuSequence_GmapMenu_ShopItem, GmapMenuSequence_GmapMenu_SubFriendMenu,
6219        GmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem, GmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem,
6220        GmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem, GmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem,
6221        GmapMenuSequence_GmapMenu_SubShopMenu, GmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem,
6222        GmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem, GmapMenuSequence_GmapMenu_SubSystemMenu,
6223        GmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem, GmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem,
6224        GmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem, GmapMenuSequence_GmapMenu_SystemItem, GmapMenuSequence_GoToMapSequence,
6225        GmapMenuSequence_GoToMapSequence_Label, GmapMenuSequence_Label, IGmapMenuSequence, IGmapMenuSequenceMethods, IGmapMenuSequence_GmapMenu,
6226        IGmapMenuSequence_GmapMenuMethods, IGmapMenuSequence_GmapMenu_EnterChapterItem, IGmapMenuSequence_GmapMenu_EnterChapterItemMethods,
6227        IGmapMenuSequence_GmapMenu_FriendItem, IGmapMenuSequence_GmapMenu_FriendItemMethods, IGmapMenuSequence_GmapMenu_GmapMenuMenuItem,
6228        IGmapMenuSequence_GmapMenu_GmapMenuMenuItemMethods, IGmapMenuSequence_GmapMenu_GoToSolanelItem,
6229        IGmapMenuSequence_GmapMenu_GoToSolanelItemMethods, IGmapMenuSequence_GmapMenu_GodItem, IGmapMenuSequence_GmapMenu_GodItemMethods,
6230        IGmapMenuSequence_GmapMenu_InventoryItem, IGmapMenuSequence_GmapMenu_InventoryItemMethods, IGmapMenuSequence_GmapMenu_MaterialListItem,
6231        IGmapMenuSequence_GmapMenu_MaterialListItemMethods, IGmapMenuSequence_GmapMenu_RankingItem, IGmapMenuSequence_GmapMenu_RankingItemMethods,
6232        IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence, IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequenceMethods,
6233        IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItem, IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_NoMenuItemMethods,
6234        IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItem,
6235        IGmapMenuSequence_GmapMenu_RankingItem_ConfirmSequence_YesMenuItemMethods, IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequence,
6236        IGmapMenuSequence_GmapMenu_RankingItem_JumpToRankingSequenceMethods, IGmapMenuSequence_GmapMenu_SaveItem,
6237        IGmapMenuSequence_GmapMenu_SaveItemMethods, IGmapMenuSequence_GmapMenu_ShopItem, IGmapMenuSequence_GmapMenu_ShopItemMethods,
6238        IGmapMenuSequence_GmapMenu_SubFriendMenu, IGmapMenuSequence_GmapMenu_SubFriendMenuMethods,
6239        IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItem, IGmapMenuSequence_GmapMenu_SubFriendMenu_KizunaItemMethods,
6240        IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItem, IGmapMenuSequence_GmapMenu_SubFriendMenu_NotebookItemMethods,
6241        IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItem, IGmapMenuSequence_GmapMenu_SubFriendMenu_RelianceItemMethods,
6242        IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItem, IGmapMenuSequence_GmapMenu_SubFriendMenu_RingbookItemMethods,
6243        IGmapMenuSequence_GmapMenu_SubShopMenu, IGmapMenuSequence_GmapMenu_SubShopMenuMethods,
6244        IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItem, IGmapMenuSequence_GmapMenu_SubShopMenu_ItemShopMenuItemMethods,
6245        IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItem, IGmapMenuSequence_GmapMenu_SubShopMenu_WeaponShopMenuItemMethods,
6246        IGmapMenuSequence_GmapMenu_SubSystemMenu, IGmapMenuSequence_GmapMenu_SubSystemMenuMethods,
6247        IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItem, IGmapMenuSequence_GmapMenu_SubSystemMenu_ConfigItemMethods,
6248        IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItem, IGmapMenuSequence_GmapMenu_SubSystemMenu_ResetItemMethods,
6249        IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItem, IGmapMenuSequence_GmapMenu_SubSystemMenu_TutorialItemMethods,
6250        IGmapMenuSequence_GmapMenu_SystemItem, IGmapMenuSequence_GmapMenu_SystemItemMethods, IGmapMenuSequence_GoToMapSequence,
6251        IGmapMenuSequence_GoToMapSequenceMethods,
6252    };
6253    #[cfg(feature = "app-basicdialogitem")]
6254    pub use crate::app::basicdialogitem::IBasicDialogItemMethods;
6255    #[cfg(feature = "app-basicdialogitemno")]
6256    pub use crate::app::basicdialogitemno::IBasicDialogItemNoMethods;
6257    #[cfg(feature = "app-basicdialogitemyes")]
6258    pub use crate::app::basicdialogitemyes::IBasicDialogItemYesMethods;
6259    #[cfg(feature = "app-basicmenu")]
6260    pub use crate::app::basicmenu::IBasicMenuMethods;
6261    #[cfg(feature = "app-basicmenuitem")]
6262    pub use crate::app::basicmenuitem::IBasicMenuItemMethods;
6263    #[cfg(feature = "app-mapbasicmenuitem")]
6264    pub use crate::app::mapbasicmenuitem::IMapBasicMenuItemMethods;
6265    #[cfg(feature = "app-procinst")]
6266    pub use crate::app::procinst::IProcInstMethods;
6267    #[cfg(feature = "app-singletonprocinst_1")]
6268    pub use crate::app::singletonprocinst_1::ISingletonProcInst_1Methods;
6269    #[cfg(feature = "system-object")]
6270    pub use crate::system::object::IObjectMethods;
6271    #[cfg(feature = "system-enum")]
6272    pub use crate::system::r#enum::IEnumMethods;
6273    #[cfg(feature = "system-valuetype")]
6274    pub use crate::system::valuetype::IValueTypeMethods;
6275    pub use crate::{
6276        app::{
6277            basicdialogitem::IBasicDialogItem, basicdialogitemno::IBasicDialogItemNo, basicdialogitemyes::IBasicDialogItemYes, basicmenu::IBasicMenu,
6278            basicmenuitem::IBasicMenuItem, mapbasicmenuitem::IMapBasicMenuItem, procinst::IProcInst, singletonprocinst_1::ISingletonProcInst_1,
6279        },
6280        system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
6281    };
6282}
engage/generated/app/gmapmenusequence.rs

engage/generated/app/
gmapmenusequence.rs
