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