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