1#[cfg(feature = "app-debugpathmenu-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 app::{
10 menuitem::{IMenuItem, MenuItem},
11 procinst::{IProcInst, ProcInst},
12 },
13 system::{
14 object::{IObject, Object},
15 r#enum::{Enum, IEnum},
16 valuetype::{IValueType, ValueType},
17 },
18 };
19
20 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_EntryMenuItem.md"))]
21 #[::unity::class(namespace = "App", name = "DebugPathMenu.EntryMenuItem")]
22 #[parent(crate::app::menuitem::MenuItem)]
23 pub struct DebugPathMenu_EntryMenuItem {
24 #[static_field]
25 #[rename(name = "MinWidth")]
26 pub min_width: f32,
27 #[offset(32)]
28 #[rename(name = "m_Setting")]
29 pub m_setting: crate::app::debugpathmenu::DebugPathMenu_Setting,
30 #[offset(40)]
31 #[rename(name = "m_CurrentPath")]
32 pub m_current_path: ::unity::Il2CppString,
33 #[offset(48)]
34 #[rename(name = "m_EntryData")]
35 pub m_entry_data: crate::app::debugpathmenu::DebugPathMenu_EntryData,
36 }
37
38 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Setting.md"))]
39 #[::unity::class(namespace = "App", name = "DebugPathMenu.Setting")]
40 #[parent(crate::system::object::Object)]
41 pub struct DebugPathMenu_Setting {}
42
43 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Result.md"))]
44 #[repr(C)]
45 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
46 pub struct DebugPathMenu_Result {
47 pub value: i32,
48 }
49 impl ::unity::ClassIdentity for DebugPathMenu_Result {
50 const NAME: &'static str = "DebugPathMenu.Result";
51 const NAMESPACE: &'static str = "App";
52
53 fn class() -> ::unity::Class {
54 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
55 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
56 }
57 }
58 impl ::unity::IlType for DebugPathMenu_Result {
59 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
60 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
61 }
62 }
63 impl DebugPathMenu_Result {
64 pub fn selected() -> Self {
65 Self { value: 0 }
66 }
67
68 pub fn canceled() -> Self {
69 Self { value: 1 }
70 }
71 }
72
73 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_EntryData.md"))]
74 #[::unity::class(namespace = "App", name = "DebugPathMenu.EntryData")]
75 #[parent(crate::system::object::Object)]
76 pub struct DebugPathMenu_EntryData {}
77
78 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Path.md"))]
79 #[::unity::class(namespace = "App", name = "DebugPathMenu.Path")]
80 #[parent(crate::system::object::Object)]
81 pub struct DebugPathMenu_Path {}
82
83 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_CategoriesMenu_AssetsMenuItem.md"))]
84 #[::unity::class(namespace = "App", name = "DebugPathMenu.CategoriesMenu.AssetsMenuItem")]
85 #[parent(crate::app::menuitem::MenuItem)]
86 pub struct DebugPathMenu_CategoriesMenu_AssetsMenuItem {
87 #[offset(32)]
88 #[rename(name = "m_Setting")]
89 pub m_setting: crate::app::debugpathmenu::DebugPathMenu_Setting,
90 }
91
92 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_ShowError.md"))]
93 #[::unity::class(namespace = "App", name = "DebugPathMenu.ShowError")]
94 #[parent(crate::system::object::Object)]
95 pub struct DebugPathMenu_ShowError {}
96
97 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu.md"))]
98 #[::unity::class(namespace = "App", name = "DebugPathMenu")]
99 #[parent(crate::app::procinst::ProcInst)]
100 pub struct DebugPathMenu {
101 #[offset(112)]
102 #[rename(name = "m_Setting")]
103 pub m_setting: crate::app::debugpathmenu::DebugPathMenu_Setting,
104 }
105
106 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_PCDriveMenu.md"))]
107 #[::unity::class(namespace = "App", name = "DebugPathMenu.PCDriveMenu")]
108 #[parent(crate::system::object::Object)]
109 pub struct DebugPathMenu_PCDriveMenu {}
110
111 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_CategoriesMenu_PCMenuItem.md"))]
112 #[::unity::class(namespace = "App", name = "DebugPathMenu.CategoriesMenu.PCMenuItem")]
113 #[parent(crate::app::menuitem::MenuItem)]
114 pub struct DebugPathMenu_CategoriesMenu_PCMenuItem {
115 #[offset(32)]
116 #[rename(name = "m_Setting")]
117 pub m_setting: crate::app::debugpathmenu::DebugPathMenu_Setting,
118 }
119
120 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Categories.md"))]
121 #[repr(C)]
122 #[derive(::core::clone::Clone, ::core::marker::Copy, ::core::fmt::Debug, ::core::cmp::PartialEq, ::core::cmp::Eq)]
123 pub struct DebugPathMenu_Categories {
124 pub value: i32,
125 }
126 impl ::unity::ClassIdentity for DebugPathMenu_Categories {
127 const NAME: &'static str = "DebugPathMenu.Categories";
128 const NAMESPACE: &'static str = "App";
129
130 fn class() -> ::unity::Class {
131 static CACHE: ::std::sync::OnceLock<::unity::Class> = ::std::sync::OnceLock::new();
132 *CACHE.get_or_init(|| ::unity::Class::lookup(Self::NAMESPACE, Self::NAME))
133 }
134 }
135 impl ::unity::IlType for DebugPathMenu_Categories {
136 fn il_type() -> &'static ::unity::il2cpp::Il2CppType {
137 &<Self as ::unity::ClassIdentity>::class().raw()._1.byval_arg
138 }
139 }
140 impl DebugPathMenu_Categories {
141 pub fn pc() -> Self {
142 Self { value: 1 }
143 }
144
145 pub fn assets() -> Self {
146 Self { value: 2 }
147 }
148
149 pub fn all() -> Self {
150 Self { value: 3 }
151 }
152 }
153
154 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Directory.md"))]
155 #[::unity::class(namespace = "App", name = "DebugPathMenu.Directory")]
156 #[parent(crate::system::object::Object)]
157 pub struct DebugPathMenu_Directory {}
158
159 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_ShowError_ErrorMenuItem.md"))]
160 #[::unity::class(namespace = "App", name = "DebugPathMenu.ShowError.ErrorMenuItem")]
161 #[parent(crate::app::menuitem::MenuItem)]
162 pub struct DebugPathMenu_ShowError_ErrorMenuItem {
163 #[offset(32)]
164 #[rename(name = "m_Error")]
165 pub m_error: ::unity::Il2CppString,
166 }
167
168 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_Directory_EnumResult.md"))]
169 #[::unity::class(namespace = "App", name = "DebugPathMenu.Directory.EnumResult")]
170 #[parent(crate::system::object::Object)]
171 pub struct DebugPathMenu_Directory_EnumResult {
172 #[offset(16)]
173 #[rename(name = "Entries")]
174 pub entries: crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>,
175 #[offset(24)]
176 #[rename(name = "ErrorMessage")]
177 pub error_message: ::unity::Il2CppString,
178 }
179
180 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_CategoriesMenu.md"))]
181 #[::unity::class(namespace = "App", name = "DebugPathMenu.CategoriesMenu")]
182 #[parent(crate::system::object::Object)]
183 pub struct DebugPathMenu_CategoriesMenu {}
184
185 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/app/debugpathmenu/DebugPathMenu_EntryMenu.md"))]
186 #[::unity::class(namespace = "App", name = "DebugPathMenu.EntryMenu")]
187 #[parent(crate::system::object::Object)]
188 pub struct DebugPathMenu_EntryMenu {}
189}
190
191#[cfg(feature = "app-debugpathmenu-types")]
192pub use __types::*;
193
194#[cfg(feature = "app-debugpathmenu")]
195pub trait IDebugPathMenu_EntryMenuItemMethods: IDebugPathMenu_EntryMenuItem {
196 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString, crate::app::debugpathmenu::DebugPathMenu_EntryData)` overload"]
197 fn ctor(
198 self,
199 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
200 current_path: impl ::core::convert::Into<::unity::Il2CppString>,
201 entry_data: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_EntryData>,
202 ) -> () {
203 unsafe {
204 let __receiver =
205 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
206 ::unity::il2cpp_call!((::unity::module_base()+0x19d6670usize)as*mut u8,();
207(DebugPathMenu_EntryMenuItem)__receiver,(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting),(::unity::Il2CppString)::core::convert::Into::into(current_path),(crate::app::debugpathmenu::DebugPathMenu_EntryData)::core::convert::Into::into(entry_data))
208 }
209 }
210 #[doc = "`GetName()` overload"]
211 fn get_name(self) -> ::unity::Il2CppString {
212 unsafe {
213 let __receiver =
214 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
215 {
216 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
217 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
218 panic!(
219 "unity: virtual slot {}
220 out of range (vtable len {}
221) on the runtime class behind {}
222 (method `{}
223`)",
224 5usize,
225 __vt.len(),
226 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
227 "GetName",
228 )
229 });
230 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
231 ::core::mem::transmute(__vi.method_ptr);
232 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
233 __inner(__receiver, __mi)
234 }
235 }
236 }
237 #[doc = "`GetHelp()` overload"]
238 fn get_help(self) -> ::unity::Il2CppString {
239 unsafe {
240 let __receiver =
241 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
242 {
243 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
244 let __vi = *__vt.get(7usize).unwrap_or_else(|| {
245 panic!(
246 "unity: virtual slot {}
247 out of range (vtable len {}
248) on the runtime class behind {}
249 (method `{}
250`)",
251 7usize,
252 __vt.len(),
253 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
254 "GetHelp",
255 )
256 });
257 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
258 ::core::mem::transmute(__vi.method_ptr);
259 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
260 __inner(__receiver, __mi)
261 }
262 }
263 }
264 #[doc = "`GetColumnWidth0()` overload"]
265 fn get_column_width0(self) -> f32 {
266 unsafe {
267 let __receiver =
268 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
269 {
270 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
271 let __vi = *__vt.get(31usize).unwrap_or_else(|| {
272 panic!(
273 "unity: virtual slot {}
274 out of range (vtable len {}
275) on the runtime class behind {}
276 (method `{}
277`)",
278 31usize,
279 __vt.len(),
280 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
281 "GetColumnWidth0",
282 )
283 });
284 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__vi.method_ptr);
285 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
286 __inner(__receiver, __mi)
287 }
288 }
289 }
290 #[doc = "`ACall()` overload"]
291 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
292 unsafe {
293 let __receiver =
294 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
295 {
296 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
297 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
298 panic!(
299 "unity: virtual slot {}
300 out of range (vtable len {}
301) on the runtime class behind {}
302 (method `{}
303`)",
304 12usize,
305 __vt.len(),
306 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
307 "ACall",
308 )
309 });
310 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
311 ::core::mem::transmute(__vi.method_ptr);
312 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
313 __inner(__receiver, __mi)
314 }
315 }
316 }
317 #[doc = "`XCall()` overload"]
318 fn x_call(self) -> crate::app::menuitem::MenuItem_Result {
319 unsafe {
320 let __receiver =
321 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
322 {
323 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
324 let __vi = *__vt.get(14usize).unwrap_or_else(|| {
325 panic!(
326 "unity: virtual slot {}
327 out of range (vtable len {}
328) on the runtime class behind {}
329 (method `{}
330`)",
331 14usize,
332 __vt.len(),
333 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
334 "XCall",
335 )
336 });
337 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
338 ::core::mem::transmute(__vi.method_ptr);
339 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
340 __inner(__receiver, __mi)
341 }
342 }
343 }
344 #[doc = "`BCall()` overload"]
345 fn b_call(self) -> crate::app::menuitem::MenuItem_Result {
346 unsafe {
347 let __receiver =
348 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
349 {
350 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
351 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
352 panic!(
353 "unity: virtual slot {}
354 out of range (vtable len {}
355) on the runtime class behind {}
356 (method `{}
357`)",
358 13usize,
359 __vt.len(),
360 <DebugPathMenu_EntryMenuItem as ::unity::ClassIdentity>::NAME,
361 "BCall",
362 )
363 });
364 let __inner: extern "C" fn(DebugPathMenu_EntryMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
365 ::core::mem::transmute(__vi.method_ptr);
366 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
367 __inner(__receiver, __mi)
368 }
369 }
370 }
371 #[doc = "`Decide()` overload"]
372 fn decide(self) -> crate::app::menuitem::MenuItem_Result {
373 unsafe {
374 let __receiver =
375 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
376 ::unity::il2cpp_call!((::unity::module_base()+0x19d6a20usize)as*mut u8,crate::app::menuitem::MenuItem_Result;
377(DebugPathMenu_EntryMenuItem)__receiver)
378 }
379 }
380 #[doc = "`MoveToParent()` overload"]
381 fn move_to_parent(self) -> crate::app::menuitem::MenuItem_Result {
382 unsafe {
383 let __receiver =
384 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
385 ::unity::il2cpp_call!((::unity::module_base()+0x19d68c0usize)as*mut u8,crate::app::menuitem::MenuItem_Result;
386(DebugPathMenu_EntryMenuItem)__receiver)
387 }
388 }
389 #[doc = "`MoveToSub()` overload"]
390 fn move_to_sub(self) -> crate::app::menuitem::MenuItem_Result {
391 unsafe {
392 let __receiver =
393 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
394 ::unity::il2cpp_call!((::unity::module_base()+0x19d69d0usize)as*mut u8,crate::app::menuitem::MenuItem_Result;
395(DebugPathMenu_EntryMenuItem)__receiver)
396 }
397 }
398 #[doc = "`Cancel()` overload"]
399 fn cancel(self) -> crate::app::menuitem::MenuItem_Result {
400 unsafe {
401 let __receiver =
402 <DebugPathMenu_EntryMenuItem as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
403 ::unity::il2cpp_call!((::unity::module_base()+0x19d6e80usize)as*mut u8,crate::app::menuitem::MenuItem_Result;
404(DebugPathMenu_EntryMenuItem)__receiver)
405 }
406 }
407}
408
409#[cfg(feature = "app-debugpathmenu")]
410impl<__T: IDebugPathMenu_EntryMenuItem> IDebugPathMenu_EntryMenuItemMethods for __T {}
411
412#[cfg(feature = "app-debugpathmenu")]
413impl DebugPathMenu_EntryMenuItem {
414 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
416 }
417
418 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
420 }
421
422 pub fn get_help_method_info() -> &'static ::unity::il2cpp::MethodInfo {
423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
424 }
425
426 pub fn get_column_width0_method_info() -> &'static ::unity::il2cpp::MethodInfo {
427 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
428 }
429
430 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
431 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
432 }
433
434 pub fn x_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
435 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
436 }
437
438 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
439 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
440 }
441
442 pub fn decide_method_info() -> &'static ::unity::il2cpp::MethodInfo {
443 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
444 }
445
446 pub fn move_to_parent_method_info() -> &'static ::unity::il2cpp::MethodInfo {
447 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
448 }
449
450 pub fn move_to_sub_method_info() -> &'static ::unity::il2cpp::MethodInfo {
451 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
452 }
453
454 pub fn cancel_method_info() -> &'static ::unity::il2cpp::MethodInfo {
455 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
456 }
457}
458
459#[cfg(feature = "app-debugpathmenu")]
460impl DebugPathMenu_EntryMenuItem {
461 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
462 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
463 let __mi = Self::get_name_method_info();
464 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
465 __inner(this.into(), ::core::option::Option::None)
466 }
467
468 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `GetHelp`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
469 pub unsafe fn get_help(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
470 let __mi = Self::get_help_method_info();
471 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
472 __inner(this.into(), ::core::option::Option::None)
473 }
474
475 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `GetColumnWidth0`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
476 pub unsafe fn get_column_width0(this: impl ::core::convert::Into<::unity::IlInstance>) -> f32 {
477 let __mi = Self::get_column_width0_method_info();
478 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> f32 = ::core::mem::transmute(__mi.method_ptr);
479 __inner(this.into(), ::core::option::Option::None)
480 }
481
482 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
483 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
484 let __mi = Self::a_call_method_info();
485 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
486 ::core::mem::transmute(__mi.method_ptr);
487 __inner(this.into(), ::core::option::Option::None)
488 }
489
490 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `XCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
491 pub unsafe fn x_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
492 let __mi = Self::x_call_method_info();
493 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
494 ::core::mem::transmute(__mi.method_ptr);
495 __inner(this.into(), ::core::option::Option::None)
496 }
497
498 #[doc = "Direct (non-virtual) call to `DebugPathMenu_EntryMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
499 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
500 let __mi = Self::b_call_method_info();
501 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
502 ::core::mem::transmute(__mi.method_ptr);
503 __inner(this.into(), ::core::option::Option::None)
504 }
505}
506
507#[cfg(feature = "app-debugpathmenu")]
508impl DebugPathMenu_EntryMenuItem {
509 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString, crate::app::debugpathmenu::DebugPathMenu_EntryData)` — overload selector"]
510 pub fn new(
511 setting: crate::app::debugpathmenu::DebugPathMenu_Setting,
512 current_path: ::unity::Il2CppString,
513 entry_data: crate::app::debugpathmenu::DebugPathMenu_EntryData,
514 ) -> Self {
515 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
516 panic!(
517 "{}
518::{}
519 failed to instantiate",
520 ::core::stringify!(DebugPathMenu_EntryMenuItem),
521 ::core::stringify!(new),
522 )
523 });
524 <Self as IDebugPathMenu_EntryMenuItemMethods>::ctor(this, setting, current_path, entry_data);
525 this
526 }
527}
528
529#[cfg(feature = "app-debugpathmenu")]
530pub trait IDebugPathMenu_SettingMethods: IDebugPathMenu_Setting {
531 #[doc = "`.ctor()` overload"]
532 fn ctor(self) -> () {
533 unsafe {
534 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
535 ::unity::il2cpp_call!((::unity::module_base()+0x19d6f20usize)as*mut u8,();
536(DebugPathMenu_Setting)__receiver)
537 }
538 }
539 #[doc = "`get_Categories()` overload"]
540 fn get_categories(self) -> crate::app::debugpathmenu::DebugPathMenu_Categories {
541 unsafe {
542 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
543 ::unity::il2cpp_call!((::unity::module_base()+0x19d6f80usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_Categories;
544(DebugPathMenu_Setting)__receiver)
545 }
546 }
547 #[doc = "`set_Categories(crate::app::debugpathmenu::DebugPathMenu_Categories)` overload"]
548 fn set_categories(self, value: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Categories>) -> () {
549 unsafe {
550 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
551 ::unity::il2cpp_call!((::unity::module_base()+0x19d6f90usize)as*mut u8,();
552(DebugPathMenu_Setting)__receiver,(crate::app::debugpathmenu::DebugPathMenu_Categories)::core::convert::Into::into(value))
553 }
554 }
555 #[doc = "`get_IsDirectoryOnly()` overload"]
556 fn get_is_directory_only(self) -> bool {
557 unsafe {
558 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
559 ::unity::il2cpp_call!((::unity::module_base()+0x19d6fa0usize)as*mut u8,bool;
560(DebugPathMenu_Setting)__receiver)
561 }
562 }
563 #[doc = "`set_IsDirectoryOnly(bool)` overload"]
564 fn set_is_directory_only(self, value: impl ::core::convert::Into<bool>) -> () {
565 unsafe {
566 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
567 ::unity::il2cpp_call!((::unity::module_base()+0x19d6fb0usize)as*mut u8,();
568(DebugPathMenu_Setting)__receiver,(bool)::core::convert::Into::into(value))
569 }
570 }
571 #[doc = "`get_InitialDirectoryPath()` overload"]
572 fn get_initial_directory_path(self) -> ::unity::Il2CppString {
573 unsafe {
574 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
575 ::unity::il2cpp_call!((::unity::module_base()+0x19d6fc0usize)as*mut u8, ::unity::Il2CppString;
576(DebugPathMenu_Setting)__receiver)
577 }
578 }
579 #[doc = "`set_InitialDirectoryPath(::unity::Il2CppString)` overload"]
580 fn set_initial_directory_path(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
581 unsafe {
582 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
583 ::unity::il2cpp_call!((::unity::module_base()+0x19d6fd0usize)as*mut u8,();
584(DebugPathMenu_Setting)__receiver,(::unity::Il2CppString)::core::convert::Into::into(value))
585 }
586 }
587 #[doc = "`get_OnSelect()` overload"]
588 fn get_on_select(self) -> crate::system::action_1::Action_1<::unity::Il2CppString> {
589 unsafe {
590 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
591 ::unity::il2cpp_call!((::unity::module_base()+0x19d6fe0usize)as*mut u8,crate::system::action_1::Action_1< ::unity::Il2CppString> ;
592(DebugPathMenu_Setting)__receiver)
593 }
594 }
595 #[doc = "`set_OnSelect(crate::system::action_1::Action_1<::unity::Il2CppString>)` overload"]
596 fn set_on_select(self, value: impl ::core::convert::Into<crate::system::action_1::Action_1<::unity::Il2CppString>>) -> () {
597 unsafe {
598 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
599 ::unity::il2cpp_call!((::unity::module_base()+0x19d6ff0usize)as*mut u8,();
600(DebugPathMenu_Setting)__receiver,(crate::system::action_1::Action_1< ::unity::Il2CppString>)::core::convert::Into::into(value))
601 }
602 }
603 #[doc = "`get_OnCancel()` overload"]
604 fn get_on_cancel(self) -> crate::system::action::Action {
605 unsafe {
606 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
607 ::unity::il2cpp_call!((::unity::module_base()+0x19d7000usize)as*mut u8,crate::system::action::Action;
608(DebugPathMenu_Setting)__receiver)
609 }
610 }
611 #[doc = "`set_OnCancel(crate::system::action::Action)` overload"]
612 fn set_on_cancel(self, value: impl ::core::convert::Into<crate::system::action::Action>) -> () {
613 unsafe {
614 let __receiver = <DebugPathMenu_Setting as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
615 ::unity::il2cpp_call!((::unity::module_base()+0x19d7010usize)as*mut u8,();
616(DebugPathMenu_Setting)__receiver,(crate::system::action::Action)::core::convert::Into::into(value))
617 }
618 }
619}
620
621#[cfg(feature = "app-debugpathmenu")]
622impl<__T: IDebugPathMenu_Setting> IDebugPathMenu_SettingMethods for __T {}
623
624#[cfg(feature = "app-debugpathmenu")]
625impl DebugPathMenu_Setting {
626 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
627 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
628 }
629
630 pub fn get_categories_method_info() -> &'static ::unity::il2cpp::MethodInfo {
631 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
632 }
633
634 pub fn set_categories_method_info() -> &'static ::unity::il2cpp::MethodInfo {
635 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
636 }
637
638 pub fn get_is_directory_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
639 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
640 }
641
642 pub fn set_is_directory_only_method_info() -> &'static ::unity::il2cpp::MethodInfo {
643 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
644 }
645
646 pub fn get_initial_directory_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
647 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
648 }
649
650 pub fn set_initial_directory_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
651 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
652 }
653
654 pub fn get_on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
655 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
656 }
657
658 pub fn set_on_select_method_info() -> &'static ::unity::il2cpp::MethodInfo {
659 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
660 }
661
662 pub fn get_on_cancel_method_info() -> &'static ::unity::il2cpp::MethodInfo {
663 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
664 }
665
666 pub fn set_on_cancel_method_info() -> &'static ::unity::il2cpp::MethodInfo {
667 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
668 }
669}
670
671#[cfg(feature = "app-debugpathmenu")]
672impl DebugPathMenu_Setting {
673 #[doc = "`.ctor()` — no args"]
674 pub fn new() -> Self {
675 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
676 panic!(
677 "{}
678::{}
679 failed to instantiate",
680 ::core::stringify!(DebugPathMenu_Setting),
681 ::core::stringify!(new),
682 )
683 });
684 <Self as IDebugPathMenu_SettingMethods>::ctor(this);
685 this
686 }
687}
688
689#[cfg(feature = "app-debugpathmenu")]
690pub trait IDebugPathMenu_EntryDataMethods: IDebugPathMenu_EntryData {
691 #[doc = "`.ctor(bool, ::unity::Il2CppString)` overload"]
692 fn ctor(self, is_directory: impl ::core::convert::Into<bool>, name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
693 unsafe {
694 let __receiver =
695 <DebugPathMenu_EntryData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
696 ::unity::il2cpp_call!((::unity::module_base()+0x19d5c20usize)as*mut u8,();
697(DebugPathMenu_EntryData)__receiver,(bool)::core::convert::Into::into(is_directory),(::unity::Il2CppString)::core::convert::Into::into(name))
698 }
699 }
700 #[doc = "`get_IsDirectory()` overload"]
701 fn get_is_directory(self) -> bool {
702 unsafe {
703 let __receiver =
704 <DebugPathMenu_EntryData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
705 ::unity::il2cpp_call!((::unity::module_base()+0x19d62d0usize)as*mut u8,bool;
706(DebugPathMenu_EntryData)__receiver)
707 }
708 }
709 #[doc = "`set_IsDirectory(bool)` overload"]
710 fn set_is_directory(self, value: impl ::core::convert::Into<bool>) -> () {
711 unsafe {
712 let __receiver =
713 <DebugPathMenu_EntryData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
714 ::unity::il2cpp_call!((::unity::module_base()+0x19d62e0usize)as*mut u8,();
715(DebugPathMenu_EntryData)__receiver,(bool)::core::convert::Into::into(value))
716 }
717 }
718 #[doc = "`get_Name()` overload"]
719 fn get_name(self) -> ::unity::Il2CppString {
720 unsafe {
721 let __receiver =
722 <DebugPathMenu_EntryData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
723 ::unity::il2cpp_call!((::unity::module_base()+0x19d62f0usize)as*mut u8, ::unity::Il2CppString;
724(DebugPathMenu_EntryData)__receiver)
725 }
726 }
727 #[doc = "`set_Name(::unity::Il2CppString)` overload"]
728 fn set_name(self, value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
729 unsafe {
730 let __receiver =
731 <DebugPathMenu_EntryData as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
732 ::unity::il2cpp_call!((::unity::module_base()+0x19d6300usize)as*mut u8,();
733(DebugPathMenu_EntryData)__receiver,(::unity::Il2CppString)::core::convert::Into::into(value))
734 }
735 }
736}
737
738#[cfg(feature = "app-debugpathmenu")]
739impl<__T: IDebugPathMenu_EntryData> IDebugPathMenu_EntryDataMethods for __T {}
740
741#[cfg(feature = "app-debugpathmenu")]
742impl DebugPathMenu_EntryData {
743 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
745 }
746
747 pub fn get_is_directory_method_info() -> &'static ::unity::il2cpp::MethodInfo {
748 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
749 }
750
751 pub fn set_is_directory_method_info() -> &'static ::unity::il2cpp::MethodInfo {
752 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
753 }
754
755 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
756 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
757 }
758
759 pub fn set_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
760 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
761 }
762}
763
764#[cfg(feature = "app-debugpathmenu")]
765impl DebugPathMenu_EntryData {
766 #[doc = "`.ctor(bool, ::unity::Il2CppString)` — overload selector"]
767 pub fn new(is_directory: bool, name: ::unity::Il2CppString) -> Self {
768 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
769 panic!(
770 "{}
771::{}
772 failed to instantiate",
773 ::core::stringify!(DebugPathMenu_EntryData),
774 ::core::stringify!(new),
775 )
776 });
777 <Self as IDebugPathMenu_EntryDataMethods>::ctor(this, is_directory, name);
778 this
779 }
780}
781
782#[cfg(feature = "app-debugpathmenu")]
783impl DebugPathMenu_Path {
784 #[doc = "`NormalizeForDirectory(::unity::Il2CppString)` overload"]
785 pub fn normalize_for_directory(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
786 unsafe {
787 ::unity::il2cpp_call!((::unity::module_base()+0x19d5b70usize)as*mut u8, ::unity::Il2CppString;
788(::unity::Il2CppString)::core::convert::Into::into(original_path))
789 }
790 }
791
792 #[doc = "`NormalizeForFile(::unity::Il2CppString)` overload"]
793 pub fn normalize_for_file(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
794 unsafe {
795 ::unity::il2cpp_call!((::unity::module_base()+0x19d5c10usize)as*mut u8, ::unity::Il2CppString;
796(::unity::Il2CppString)::core::convert::Into::into(original_path))
797 }
798 }
799
800 #[doc = "`NormalizePathSeparator(::unity::Il2CppString)` overload"]
801 pub fn normalize_path_separator(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
802 unsafe {
803 ::unity::il2cpp_call!((::unity::module_base()+0x19d6f00usize)as*mut u8, ::unity::Il2CppString;
804(::unity::Il2CppString)::core::convert::Into::into(original_path))
805 }
806 }
807
808 #[doc = "`GetParentDirectory(::unity::Il2CppString)` overload"]
809 pub fn get_parent_directory(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
810 unsafe {
811 ::unity::il2cpp_call!((::unity::module_base()+0x19d6be0usize)as*mut u8, ::unity::Il2CppString;
812(::unity::Il2CppString)::core::convert::Into::into(original_path))
813 }
814 }
815
816 #[doc = "`GetDirectoryName(::unity::Il2CppString)` overload"]
817 pub fn get_directory_name(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
818 unsafe {
819 ::unity::il2cpp_call!((::unity::module_base()+0x19d6130usize)as*mut u8, ::unity::Il2CppString;
820(::unity::Il2CppString)::core::convert::Into::into(original_path))
821 }
822 }
823
824 #[doc = "`GetFileName(::unity::Il2CppString)` overload"]
825 pub fn get_file_name(original_path: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
826 unsafe {
827 ::unity::il2cpp_call!((::unity::module_base()+0x19d6240usize)as*mut u8, ::unity::Il2CppString;
828(::unity::Il2CppString)::core::convert::Into::into(original_path))
829 }
830 }
831}
832
833#[cfg(feature = "app-debugpathmenu")]
834pub trait IDebugPathMenu_PathMethods: IDebugPathMenu_Path {
835 #[doc = "`.ctor()` overload"]
836 fn ctor(self) -> () {
837 unsafe {
838 let __receiver = <DebugPathMenu_Path as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
839 ::unity::il2cpp_call!((::unity::module_base()+0x19d6f10usize)as*mut u8,();
840(DebugPathMenu_Path)__receiver)
841 }
842 }
843}
844
845#[cfg(feature = "app-debugpathmenu")]
846impl<__T: IDebugPathMenu_Path> IDebugPathMenu_PathMethods for __T {}
847
848#[cfg(feature = "app-debugpathmenu")]
849impl DebugPathMenu_Path {
850 pub fn normalize_for_directory_method_info() -> &'static ::unity::il2cpp::MethodInfo {
851 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
852 }
853
854 pub fn normalize_for_file_method_info() -> &'static ::unity::il2cpp::MethodInfo {
855 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
856 }
857
858 pub fn normalize_path_separator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
859 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
860 }
861
862 pub fn get_parent_directory_method_info() -> &'static ::unity::il2cpp::MethodInfo {
863 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
864 }
865
866 pub fn get_directory_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
867 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
868 }
869
870 pub fn get_file_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
871 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
872 }
873
874 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
875 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
876 }
877}
878
879#[cfg(feature = "app-debugpathmenu")]
880impl DebugPathMenu_Path {
881 #[doc = "`.ctor()` — no args"]
882 pub fn new() -> Self {
883 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
884 panic!(
885 "{}
886::{}
887 failed to instantiate",
888 ::core::stringify!(DebugPathMenu_Path),
889 ::core::stringify!(new),
890 )
891 });
892 <Self as IDebugPathMenu_PathMethods>::ctor(this);
893 this
894 }
895}
896
897#[cfg(feature = "app-debugpathmenu")]
898pub trait IDebugPathMenu_CategoriesMenu_AssetsMenuItemMethods: IDebugPathMenu_CategoriesMenu_AssetsMenuItem {
899 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
900 fn ctor(self, setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>) -> () {
901 unsafe {
902 let __receiver = <DebugPathMenu_CategoriesMenu_AssetsMenuItem as ::unity::FromIlInstance>::from_il_instance(
903 <Self as ::unity::SystemObject>::as_instance(self),
904 );
905 ::unity::il2cpp_call!((::unity::module_base()+0x1b32e20usize)as*mut u8,();
906(DebugPathMenu_CategoriesMenu_AssetsMenuItem)__receiver,(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
907 }
908 }
909 #[doc = "`GetName()` overload"]
910 fn get_name(self) -> ::unity::Il2CppString {
911 unsafe {
912 let __receiver = <DebugPathMenu_CategoriesMenu_AssetsMenuItem as ::unity::FromIlInstance>::from_il_instance(
913 <Self as ::unity::SystemObject>::as_instance(self),
914 );
915 {
916 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
917 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
918 panic!(
919 "unity: virtual slot {}
920 out of range (vtable len {}
921) on the runtime class behind {}
922 (method `{}
923`)",
924 5usize,
925 __vt.len(),
926 <DebugPathMenu_CategoriesMenu_AssetsMenuItem as ::unity::ClassIdentity>::NAME,
927 "GetName",
928 )
929 });
930 let __inner: extern "C" fn(DebugPathMenu_CategoriesMenu_AssetsMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
931 ::core::mem::transmute(__vi.method_ptr);
932 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
933 __inner(__receiver, __mi)
934 }
935 }
936 }
937 #[doc = "`ACall()` overload"]
938 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
939 unsafe {
940 let __receiver = <DebugPathMenu_CategoriesMenu_AssetsMenuItem as ::unity::FromIlInstance>::from_il_instance(
941 <Self as ::unity::SystemObject>::as_instance(self),
942 );
943 {
944 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
945 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
946 panic!(
947 "unity: virtual slot {}
948 out of range (vtable len {}
949) on the runtime class behind {}
950 (method `{}
951`)",
952 12usize,
953 __vt.len(),
954 <DebugPathMenu_CategoriesMenu_AssetsMenuItem as ::unity::ClassIdentity>::NAME,
955 "ACall",
956 )
957 });
958 let __inner: extern "C" fn(
959 DebugPathMenu_CategoriesMenu_AssetsMenuItem,
960 ::unity::OptionalMethod,
961 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
962 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
963 __inner(__receiver, __mi)
964 }
965 }
966 }
967}
968
969#[cfg(feature = "app-debugpathmenu")]
970impl<__T: IDebugPathMenu_CategoriesMenu_AssetsMenuItem> IDebugPathMenu_CategoriesMenu_AssetsMenuItemMethods for __T {}
971
972#[cfg(feature = "app-debugpathmenu")]
973impl DebugPathMenu_CategoriesMenu_AssetsMenuItem {
974 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
975 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
976 }
977
978 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
979 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
980 }
981
982 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
983 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
984 }
985}
986
987#[cfg(feature = "app-debugpathmenu")]
988impl DebugPathMenu_CategoriesMenu_AssetsMenuItem {
989 #[doc = "Direct (non-virtual) call to `DebugPathMenu_CategoriesMenu_AssetsMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
990 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
991 let __mi = Self::get_name_method_info();
992 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
993 __inner(this.into(), ::core::option::Option::None)
994 }
995
996 #[doc = "Direct (non-virtual) call to `DebugPathMenu_CategoriesMenu_AssetsMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
997 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
998 let __mi = Self::a_call_method_info();
999 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1000 ::core::mem::transmute(__mi.method_ptr);
1001 __inner(this.into(), ::core::option::Option::None)
1002 }
1003}
1004
1005#[cfg(feature = "app-debugpathmenu")]
1006impl DebugPathMenu_CategoriesMenu_AssetsMenuItem {
1007 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` — overload selector"]
1008 pub fn new(setting: crate::app::debugpathmenu::DebugPathMenu_Setting) -> Self {
1009 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1010 panic!(
1011 "{}
1012::{}
1013 failed to instantiate",
1014 ::core::stringify!(DebugPathMenu_CategoriesMenu_AssetsMenuItem),
1015 ::core::stringify!(new),
1016 )
1017 });
1018 <Self as IDebugPathMenu_CategoriesMenu_AssetsMenuItemMethods>::ctor(this, setting);
1019 this
1020 }
1021}
1022
1023#[cfg(feature = "app-debugpathmenu")]
1024impl DebugPathMenu_ShowError {
1025 #[doc = "`CreateBind(crate::app::procinst::ProcInst, ::unity::Il2CppString)` overload"]
1026 pub fn create_bind(
1027 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1028 message: impl ::core::convert::Into<::unity::Il2CppString>,
1029 ) -> () {
1030 unsafe {
1031 ::unity::il2cpp_call!((::unity::module_base()+0x19d6580usize)as*mut u8,();
1032(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(::unity::Il2CppString)::core::convert::Into::into(message))
1033 }
1034 }
1035}
1036
1037#[cfg(feature = "app-debugpathmenu")]
1038pub trait IDebugPathMenu_ShowErrorMethods: IDebugPathMenu_ShowError {
1039 #[doc = "`.ctor()` overload"]
1040 fn ctor(self) -> () {
1041 unsafe {
1042 let __receiver =
1043 <DebugPathMenu_ShowError as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1044 ::unity::il2cpp_call!((::unity::module_base()+0x19d7020usize)as*mut u8,();
1045(DebugPathMenu_ShowError)__receiver)
1046 }
1047 }
1048}
1049
1050#[cfg(feature = "app-debugpathmenu")]
1051impl<__T: IDebugPathMenu_ShowError> IDebugPathMenu_ShowErrorMethods for __T {}
1052
1053#[cfg(feature = "app-debugpathmenu")]
1054impl DebugPathMenu_ShowError {
1055 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1056 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1057 }
1058
1059 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1060 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1061 }
1062}
1063
1064#[cfg(feature = "app-debugpathmenu")]
1065impl DebugPathMenu_ShowError {
1066 #[doc = "`.ctor()` — no args"]
1067 pub fn new() -> Self {
1068 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1069 panic!(
1070 "{}
1071::{}
1072 failed to instantiate",
1073 ::core::stringify!(DebugPathMenu_ShowError),
1074 ::core::stringify!(new),
1075 )
1076 });
1077 <Self as IDebugPathMenu_ShowErrorMethods>::ctor(this);
1078 this
1079 }
1080}
1081
1082#[cfg(feature = "app-debugpathmenu")]
1083impl DebugPathMenu {
1084 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
1085 pub fn create_bind(
1086 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1087 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1088 ) -> () {
1089 unsafe {
1090 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fa60usize)as*mut u8,();
1091(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
1092 }
1093 }
1094
1095 #[doc = "`get_LastResult()` overload"]
1096 pub fn get_last_result() -> crate::app::debugpathmenu::DebugPathMenu_Result {
1097 unsafe {
1098 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fd60usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_Result;
1099 )
1100 }
1101 }
1102
1103 #[doc = "`set_LastResult(crate::app::debugpathmenu::DebugPathMenu_Result)` overload"]
1104 pub fn set_last_result(value: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Result>) -> () {
1105 unsafe {
1106 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fdb0usize)as*mut u8,();
1107(crate::app::debugpathmenu::DebugPathMenu_Result)::core::convert::Into::into(value))
1108 }
1109 }
1110
1111 #[doc = "`get_LastPath()` overload"]
1112 pub fn get_last_path() -> ::unity::Il2CppString {
1113 unsafe {
1114 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fe10usize)as*mut u8, ::unity::Il2CppString;
1115 )
1116 }
1117 }
1118
1119 #[doc = "`set_LastPath(::unity::Il2CppString)` overload"]
1120 pub fn set_last_path(value: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1121 unsafe {
1122 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fe60usize)as*mut u8,();
1123(::unity::Il2CppString)::core::convert::Into::into(value))
1124 }
1125 }
1126}
1127
1128#[cfg(feature = "app-debugpathmenu")]
1129pub trait IDebugPathMenuMethods: IDebugPathMenu {
1130 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
1131 fn ctor(self, setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>) -> () {
1132 unsafe {
1133 let __receiver = <DebugPathMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1134 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fc20usize)as*mut u8,();
1135(DebugPathMenu)__receiver,(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
1136 }
1137 }
1138 #[doc = "`CreateMenu()` overload"]
1139 fn create_menu(self) -> () {
1140 unsafe {
1141 let __receiver = <DebugPathMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1142 ::unity::il2cpp_call!((::unity::module_base()+0x2a0fec0usize)as*mut u8,();
1143(DebugPathMenu)__receiver)
1144 }
1145 }
1146}
1147
1148#[cfg(feature = "app-debugpathmenu")]
1149impl<__T: IDebugPathMenu> IDebugPathMenuMethods for __T {}
1150
1151#[cfg(feature = "app-debugpathmenu")]
1152impl DebugPathMenu {
1153 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1154 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1155 }
1156
1157 pub fn get_last_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1158 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1159 }
1160
1161 pub fn set_last_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1162 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1163 }
1164
1165 pub fn get_last_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1166 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1167 }
1168
1169 pub fn set_last_path_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1170 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1171 }
1172
1173 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1174 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1175 }
1176
1177 pub fn create_menu_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1178 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1179 }
1180}
1181
1182#[cfg(feature = "app-debugpathmenu")]
1183impl DebugPathMenu {
1184 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` — overload selector"]
1185 pub fn new(setting: crate::app::debugpathmenu::DebugPathMenu_Setting) -> Self {
1186 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1187 panic!(
1188 "{}
1189::{}
1190 failed to instantiate",
1191 ::core::stringify!(DebugPathMenu),
1192 ::core::stringify!(new),
1193 )
1194 });
1195 <Self as IDebugPathMenuMethods>::ctor(this, setting);
1196 this
1197 }
1198}
1199
1200#[cfg(feature = "app-debugpathmenu")]
1201impl DebugPathMenu_PCDriveMenu {
1202 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
1203 pub fn create_bind(
1204 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1205 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1206 ) -> () {
1207 unsafe {
1208 ::unity::il2cpp_call!((::unity::module_base()+0x19d6c80usize)as*mut u8,();
1209(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
1210 }
1211 }
1212}
1213
1214#[cfg(feature = "app-debugpathmenu")]
1215pub trait IDebugPathMenu_PCDriveMenuMethods: IDebugPathMenu_PCDriveMenu {
1216 #[doc = "`.ctor()` overload"]
1217 fn ctor(self) -> () {
1218 unsafe {
1219 let __receiver =
1220 <DebugPathMenu_PCDriveMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1221 ::unity::il2cpp_call!((::unity::module_base()+0x19d6ef0usize)as*mut u8,();
1222(DebugPathMenu_PCDriveMenu)__receiver)
1223 }
1224 }
1225}
1226
1227#[cfg(feature = "app-debugpathmenu")]
1228impl<__T: IDebugPathMenu_PCDriveMenu> IDebugPathMenu_PCDriveMenuMethods for __T {}
1229
1230#[cfg(feature = "app-debugpathmenu")]
1231impl DebugPathMenu_PCDriveMenu {
1232 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1233 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1234 }
1235
1236 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1237 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1238 }
1239}
1240
1241#[cfg(feature = "app-debugpathmenu")]
1242impl DebugPathMenu_PCDriveMenu {
1243 #[doc = "`.ctor()` — no args"]
1244 pub fn new() -> Self {
1245 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1246 panic!(
1247 "{}
1248::{}
1249 failed to instantiate",
1250 ::core::stringify!(DebugPathMenu_PCDriveMenu),
1251 ::core::stringify!(new),
1252 )
1253 });
1254 <Self as IDebugPathMenu_PCDriveMenuMethods>::ctor(this);
1255 this
1256 }
1257}
1258
1259#[cfg(feature = "app-debugpathmenu")]
1260pub trait IDebugPathMenu_CategoriesMenu_PCMenuItemMethods: IDebugPathMenu_CategoriesMenu_PCMenuItem {
1261 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
1262 fn ctor(self, setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>) -> () {
1263 unsafe {
1264 let __receiver = <DebugPathMenu_CategoriesMenu_PCMenuItem as ::unity::FromIlInstance>::from_il_instance(
1265 <Self as ::unity::SystemObject>::as_instance(self),
1266 );
1267 ::unity::il2cpp_call!((::unity::module_base()+0x1b32f00usize)as*mut u8,();
1268(DebugPathMenu_CategoriesMenu_PCMenuItem)__receiver,(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
1269 }
1270 }
1271 #[doc = "`GetName()` overload"]
1272 fn get_name(self) -> ::unity::Il2CppString {
1273 unsafe {
1274 let __receiver = <DebugPathMenu_CategoriesMenu_PCMenuItem as ::unity::FromIlInstance>::from_il_instance(
1275 <Self as ::unity::SystemObject>::as_instance(self),
1276 );
1277 {
1278 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1279 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1280 panic!(
1281 "unity: virtual slot {}
1282 out of range (vtable len {}
1283) on the runtime class behind {}
1284 (method `{}
1285`)",
1286 5usize,
1287 __vt.len(),
1288 <DebugPathMenu_CategoriesMenu_PCMenuItem as ::unity::ClassIdentity>::NAME,
1289 "GetName",
1290 )
1291 });
1292 let __inner: extern "C" fn(DebugPathMenu_CategoriesMenu_PCMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1293 ::core::mem::transmute(__vi.method_ptr);
1294 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1295 __inner(__receiver, __mi)
1296 }
1297 }
1298 }
1299 #[doc = "`ACall()` overload"]
1300 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
1301 unsafe {
1302 let __receiver = <DebugPathMenu_CategoriesMenu_PCMenuItem as ::unity::FromIlInstance>::from_il_instance(
1303 <Self as ::unity::SystemObject>::as_instance(self),
1304 );
1305 {
1306 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1307 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1308 panic!(
1309 "unity: virtual slot {}
1310 out of range (vtable len {}
1311) on the runtime class behind {}
1312 (method `{}
1313`)",
1314 12usize,
1315 __vt.len(),
1316 <DebugPathMenu_CategoriesMenu_PCMenuItem as ::unity::ClassIdentity>::NAME,
1317 "ACall",
1318 )
1319 });
1320 let __inner: extern "C" fn(
1321 DebugPathMenu_CategoriesMenu_PCMenuItem,
1322 ::unity::OptionalMethod,
1323 ) -> crate::app::menuitem::MenuItem_Result = ::core::mem::transmute(__vi.method_ptr);
1324 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1325 __inner(__receiver, __mi)
1326 }
1327 }
1328 }
1329}
1330
1331#[cfg(feature = "app-debugpathmenu")]
1332impl<__T: IDebugPathMenu_CategoriesMenu_PCMenuItem> IDebugPathMenu_CategoriesMenu_PCMenuItemMethods for __T {}
1333
1334#[cfg(feature = "app-debugpathmenu")]
1335impl DebugPathMenu_CategoriesMenu_PCMenuItem {
1336 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1337 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1338 }
1339
1340 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1341 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1342 }
1343
1344 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1345 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1346 }
1347}
1348
1349#[cfg(feature = "app-debugpathmenu")]
1350impl DebugPathMenu_CategoriesMenu_PCMenuItem {
1351 #[doc = "Direct (non-virtual) call to `DebugPathMenu_CategoriesMenu_PCMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1352 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1353 let __mi = Self::get_name_method_info();
1354 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1355 __inner(this.into(), ::core::option::Option::None)
1356 }
1357
1358 #[doc = "Direct (non-virtual) call to `DebugPathMenu_CategoriesMenu_PCMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1359 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
1360 let __mi = Self::a_call_method_info();
1361 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1362 ::core::mem::transmute(__mi.method_ptr);
1363 __inner(this.into(), ::core::option::Option::None)
1364 }
1365}
1366
1367#[cfg(feature = "app-debugpathmenu")]
1368impl DebugPathMenu_CategoriesMenu_PCMenuItem {
1369 #[doc = "`.ctor(crate::app::debugpathmenu::DebugPathMenu_Setting)` — overload selector"]
1370 pub fn new(setting: crate::app::debugpathmenu::DebugPathMenu_Setting) -> Self {
1371 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1372 panic!(
1373 "{}
1374::{}
1375 failed to instantiate",
1376 ::core::stringify!(DebugPathMenu_CategoriesMenu_PCMenuItem),
1377 ::core::stringify!(new),
1378 )
1379 });
1380 <Self as IDebugPathMenu_CategoriesMenu_PCMenuItemMethods>::ctor(this, setting);
1381 this
1382 }
1383}
1384
1385#[cfg(feature = "app-debugpathmenu")]
1386impl DebugPathMenu_Directory {
1387 #[doc = "`EnumEntries(crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString)` overload"]
1388 pub fn enum_entries(
1389 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1390 path: impl ::core::convert::Into<::unity::Il2CppString>,
1391 ) -> crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult {
1392 unsafe {
1393 ::unity::il2cpp_call!((::unity::module_base()+0x19d5670usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult;
1394(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting),(::unity::Il2CppString)::core::convert::Into::into(path))
1395 }
1396 }
1397
1398 #[doc = "`IsExists(::unity::Il2CppString)` overload"]
1399 pub fn is_exists(path: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
1400 unsafe {
1401 ::unity::il2cpp_call!((::unity::module_base()+0x19d59a0usize)as*mut u8,bool;
1402(::unity::Il2CppString)::core::convert::Into::into(path))
1403 }
1404 }
1405
1406 #[doc = "`EnumEntriesNX(crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString)` overload"]
1407 pub fn enum_entries_nx(
1408 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1409 path: impl ::core::convert::Into<::unity::Il2CppString>,
1410 ) -> crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult {
1411 unsafe {
1412 ::unity::il2cpp_call!((::unity::module_base()+0x19d5680usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult;
1413(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting),(::unity::Il2CppString)::core::convert::Into::into(path))
1414 }
1415 }
1416
1417 #[doc = "`MakeEntryDataNX(bool, ::unity::Il2CppString)` overload"]
1418 pub fn make_entry_data_nx(
1419 is_directory: impl ::core::convert::Into<bool>,
1420 entry_name: impl ::core::convert::Into<::unity::Il2CppString>,
1421 ) -> crate::app::debugpathmenu::DebugPathMenu_EntryData {
1422 unsafe {
1423 ::unity::il2cpp_call!((::unity::module_base()+0x19d5a60usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_EntryData;
1424(bool)::core::convert::Into::into(is_directory),(::unity::Il2CppString)::core::convert::Into::into(entry_name))
1425 }
1426 }
1427
1428 #[doc = "`IsExistsNX(::unity::Il2CppString)` overload"]
1429 pub fn is_exists_nx(path: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
1430 unsafe {
1431 ::unity::il2cpp_call!((::unity::module_base()+0x19d5a00usize)as*mut u8,bool;
1432(::unity::Il2CppString)::core::convert::Into::into(path))
1433 }
1434 }
1435
1436 #[doc = "`EnumEntriesWin(crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString)` overload"]
1437 pub fn enum_entries_win(
1438 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1439 path: impl ::core::convert::Into<::unity::Il2CppString>,
1440 ) -> crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult {
1441 unsafe {
1442 ::unity::il2cpp_call!((::unity::module_base()+0x19d5c70usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_Directory_EnumResult;
1443(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting),(::unity::Il2CppString)::core::convert::Into::into(path))
1444 }
1445 }
1446
1447 #[doc = "`MakeEntryDataWin(bool, ::unity::Il2CppString)` overload"]
1448 pub fn make_entry_data_win(
1449 is_directory: impl ::core::convert::Into<bool>,
1450 full_path: impl ::core::convert::Into<::unity::Il2CppString>,
1451 ) -> crate::app::debugpathmenu::DebugPathMenu_EntryData {
1452 unsafe {
1453 ::unity::il2cpp_call!((::unity::module_base()+0x19d6040usize)as*mut u8,crate::app::debugpathmenu::DebugPathMenu_EntryData;
1454(bool)::core::convert::Into::into(is_directory),(::unity::Il2CppString)::core::convert::Into::into(full_path))
1455 }
1456 }
1457
1458 #[doc = "`IsExistsWin(::unity::Il2CppString)` overload"]
1459 pub fn is_exists_win(path: impl ::core::convert::Into<::unity::Il2CppString>) -> bool {
1460 unsafe {
1461 ::unity::il2cpp_call!((::unity::module_base()+0x19d62b0usize)as*mut u8,bool;
1462(::unity::Il2CppString)::core::convert::Into::into(path))
1463 }
1464 }
1465}
1466
1467#[cfg(feature = "app-debugpathmenu")]
1468pub trait IDebugPathMenu_DirectoryMethods: IDebugPathMenu_Directory {
1469 #[doc = "`.ctor()` overload"]
1470 fn ctor(self) -> () {
1471 unsafe {
1472 let __receiver =
1473 <DebugPathMenu_Directory as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1474 ::unity::il2cpp_call!((::unity::module_base()+0x19d62c0usize)as*mut u8,();
1475(DebugPathMenu_Directory)__receiver)
1476 }
1477 }
1478}
1479
1480#[cfg(feature = "app-debugpathmenu")]
1481impl<__T: IDebugPathMenu_Directory> IDebugPathMenu_DirectoryMethods for __T {}
1482
1483#[cfg(feature = "app-debugpathmenu")]
1484impl DebugPathMenu_Directory {
1485 pub fn enum_entries_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1486 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1487 }
1488
1489 pub fn is_exists_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1490 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1491 }
1492
1493 pub fn enum_entries_nx_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1494 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1495 }
1496
1497 pub fn make_entry_data_nx_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1498 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1499 }
1500
1501 pub fn is_exists_nx_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1502 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1503 }
1504
1505 pub fn enum_entries_win_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1506 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1507 }
1508
1509 pub fn make_entry_data_win_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1510 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1511 }
1512
1513 pub fn is_exists_win_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1514 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1515 }
1516
1517 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1518 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1519 }
1520}
1521
1522#[cfg(feature = "app-debugpathmenu")]
1523impl DebugPathMenu_Directory {
1524 #[doc = "`.ctor()` — no args"]
1525 pub fn new() -> Self {
1526 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1527 panic!(
1528 "{}
1529::{}
1530 failed to instantiate",
1531 ::core::stringify!(DebugPathMenu_Directory),
1532 ::core::stringify!(new),
1533 )
1534 });
1535 <Self as IDebugPathMenu_DirectoryMethods>::ctor(this);
1536 this
1537 }
1538}
1539
1540#[cfg(feature = "app-debugpathmenu")]
1541pub trait IDebugPathMenu_ShowError_ErrorMenuItemMethods: IDebugPathMenu_ShowError_ErrorMenuItem {
1542 #[doc = "`.ctor(::unity::Il2CppString)` overload"]
1543 fn ctor(self, error: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1544 unsafe {
1545 let __receiver = <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::FromIlInstance>::from_il_instance(
1546 <Self as ::unity::SystemObject>::as_instance(self),
1547 );
1548 ::unity::il2cpp_call!((::unity::module_base()+0x1b33050usize)as*mut u8,();
1549(DebugPathMenu_ShowError_ErrorMenuItem)__receiver,(::unity::Il2CppString)::core::convert::Into::into(error))
1550 }
1551 }
1552 #[doc = "`GetName()` overload"]
1553 fn get_name(self) -> ::unity::Il2CppString {
1554 unsafe {
1555 let __receiver = <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::FromIlInstance>::from_il_instance(
1556 <Self as ::unity::SystemObject>::as_instance(self),
1557 );
1558 {
1559 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1560 let __vi = *__vt.get(5usize).unwrap_or_else(|| {
1561 panic!(
1562 "unity: virtual slot {}
1563 out of range (vtable len {}
1564) on the runtime class behind {}
1565 (method `{}
1566`)",
1567 5usize,
1568 __vt.len(),
1569 <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::ClassIdentity>::NAME,
1570 "GetName",
1571 )
1572 });
1573 let __inner: extern "C" fn(DebugPathMenu_ShowError_ErrorMenuItem, ::unity::OptionalMethod) -> ::unity::Il2CppString =
1574 ::core::mem::transmute(__vi.method_ptr);
1575 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1576 __inner(__receiver, __mi)
1577 }
1578 }
1579 }
1580 #[doc = "`ACall()` overload"]
1581 fn a_call(self) -> crate::app::menuitem::MenuItem_Result {
1582 unsafe {
1583 let __receiver = <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::FromIlInstance>::from_il_instance(
1584 <Self as ::unity::SystemObject>::as_instance(self),
1585 );
1586 {
1587 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1588 let __vi = *__vt.get(12usize).unwrap_or_else(|| {
1589 panic!(
1590 "unity: virtual slot {}
1591 out of range (vtable len {}
1592) on the runtime class behind {}
1593 (method `{}
1594`)",
1595 12usize,
1596 __vt.len(),
1597 <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::ClassIdentity>::NAME,
1598 "ACall",
1599 )
1600 });
1601 let __inner: extern "C" fn(DebugPathMenu_ShowError_ErrorMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1602 ::core::mem::transmute(__vi.method_ptr);
1603 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1604 __inner(__receiver, __mi)
1605 }
1606 }
1607 }
1608 #[doc = "`BCall()` overload"]
1609 fn b_call(self) -> crate::app::menuitem::MenuItem_Result {
1610 unsafe {
1611 let __receiver = <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::FromIlInstance>::from_il_instance(
1612 <Self as ::unity::SystemObject>::as_instance(self),
1613 );
1614 {
1615 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1616 let __vi = *__vt.get(13usize).unwrap_or_else(|| {
1617 panic!(
1618 "unity: virtual slot {}
1619 out of range (vtable len {}
1620) on the runtime class behind {}
1621 (method `{}
1622`)",
1623 13usize,
1624 __vt.len(),
1625 <DebugPathMenu_ShowError_ErrorMenuItem as ::unity::ClassIdentity>::NAME,
1626 "BCall",
1627 )
1628 });
1629 let __inner: extern "C" fn(DebugPathMenu_ShowError_ErrorMenuItem, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1630 ::core::mem::transmute(__vi.method_ptr);
1631 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1632 __inner(__receiver, __mi)
1633 }
1634 }
1635 }
1636}
1637
1638#[cfg(feature = "app-debugpathmenu")]
1639impl<__T: IDebugPathMenu_ShowError_ErrorMenuItem> IDebugPathMenu_ShowError_ErrorMenuItemMethods for __T {}
1640
1641#[cfg(feature = "app-debugpathmenu")]
1642impl DebugPathMenu_ShowError_ErrorMenuItem {
1643 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1644 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1645 }
1646
1647 pub fn get_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1648 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1649 }
1650
1651 pub fn a_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1652 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1653 }
1654
1655 pub fn b_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1656 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
1657 }
1658}
1659
1660#[cfg(feature = "app-debugpathmenu")]
1661impl DebugPathMenu_ShowError_ErrorMenuItem {
1662 #[doc = "Direct (non-virtual) call to `DebugPathMenu_ShowError_ErrorMenuItem`'s own `GetName`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1663 pub unsafe fn get_name(this: impl ::core::convert::Into<::unity::IlInstance>) -> ::unity::Il2CppString {
1664 let __mi = Self::get_name_method_info();
1665 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> ::unity::Il2CppString = ::core::mem::transmute(__mi.method_ptr);
1666 __inner(this.into(), ::core::option::Option::None)
1667 }
1668
1669 #[doc = "Direct (non-virtual) call to `DebugPathMenu_ShowError_ErrorMenuItem`'s own `ACall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1670 pub unsafe fn a_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
1671 let __mi = Self::a_call_method_info();
1672 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1673 ::core::mem::transmute(__mi.method_ptr);
1674 __inner(this.into(), ::core::option::Option::None)
1675 }
1676
1677 #[doc = "Direct (non-virtual) call to `DebugPathMenu_ShowError_ErrorMenuItem`'s own `BCall`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1678 pub unsafe fn b_call(this: impl ::core::convert::Into<::unity::IlInstance>) -> crate::app::menuitem::MenuItem_Result {
1679 let __mi = Self::b_call_method_info();
1680 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> crate::app::menuitem::MenuItem_Result =
1681 ::core::mem::transmute(__mi.method_ptr);
1682 __inner(this.into(), ::core::option::Option::None)
1683 }
1684}
1685
1686#[cfg(feature = "app-debugpathmenu")]
1687impl DebugPathMenu_ShowError_ErrorMenuItem {
1688 #[doc = "`.ctor(::unity::Il2CppString)` — overload selector"]
1689 pub fn new(error: ::unity::Il2CppString) -> Self {
1690 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1691 panic!(
1692 "{}
1693::{}
1694 failed to instantiate",
1695 ::core::stringify!(DebugPathMenu_ShowError_ErrorMenuItem),
1696 ::core::stringify!(new),
1697 )
1698 });
1699 <Self as IDebugPathMenu_ShowError_ErrorMenuItemMethods>::ctor(this, error);
1700 this
1701 }
1702}
1703
1704#[cfg(feature = "app-debugpathmenu")]
1705pub trait IDebugPathMenu_Directory_EnumResultMethods: IDebugPathMenu_Directory_EnumResult {
1706 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>)` overload"]
1707 fn ctor(
1708 self,
1709 entries: impl ::core::convert::Into<crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>>,
1710 ) -> () {
1711 unsafe {
1712 let __receiver =
1713 <DebugPathMenu_Directory_EnumResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1714 ::unity::il2cpp_call!((::unity::module_base()+0x1b32fc0usize)as*mut u8,();
1715(DebugPathMenu_Directory_EnumResult)__receiver,(crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>)::core::convert::Into::into(entries))
1716 }
1717 }
1718 #[doc = "`.ctor(::unity::Il2CppString)` overload"]
1719 fn ctor_2(self, error_message: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1720 unsafe {
1721 let __receiver =
1722 <DebugPathMenu_Directory_EnumResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1723 ::unity::il2cpp_call!((::unity::module_base()+0x1b33000usize)as*mut u8,();
1724(DebugPathMenu_Directory_EnumResult)__receiver,(::unity::Il2CppString)::core::convert::Into::into(error_message))
1725 }
1726 }
1727 #[doc = "`IsFailure()` overload"]
1728 fn is_failure(self) -> bool {
1729 unsafe {
1730 let __receiver =
1731 <DebugPathMenu_Directory_EnumResult as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1732 ::unity::il2cpp_call!((::unity::module_base()+0x1b33040usize)as*mut u8,bool;
1733(DebugPathMenu_Directory_EnumResult)__receiver)
1734 }
1735 }
1736}
1737
1738#[cfg(feature = "app-debugpathmenu")]
1739impl<__T: IDebugPathMenu_Directory_EnumResult> IDebugPathMenu_Directory_EnumResultMethods for __T {}
1740
1741#[cfg(feature = "app-debugpathmenu")]
1742impl DebugPathMenu_Directory_EnumResult {
1743 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1744 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1745 }
1746
1747 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1748 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1749 }
1750
1751 pub fn is_failure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1752 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1753 }
1754}
1755
1756#[cfg(feature = "app-debugpathmenu")]
1757impl DebugPathMenu_Directory_EnumResult {
1758 #[doc = "`.ctor(crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>)` — overload selector"]
1759 pub fn new(entries: crate::system::collections::generic::list_1::List_1<crate::app::debugpathmenu::DebugPathMenu_EntryData>) -> Self {
1760 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1761 panic!(
1762 "{}
1763::{}
1764 failed to instantiate",
1765 ::core::stringify!(DebugPathMenu_Directory_EnumResult),
1766 ::core::stringify!(new),
1767 )
1768 });
1769 <Self as IDebugPathMenu_Directory_EnumResultMethods>::ctor(this, entries);
1770 this
1771 }
1772
1773 #[doc = "`.ctor(::unity::Il2CppString)` — overload selector"]
1774 pub fn new_2(error_message: ::unity::Il2CppString) -> Self {
1775 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1776 panic!(
1777 "{}
1778::{}
1779 failed to instantiate",
1780 ::core::stringify!(DebugPathMenu_Directory_EnumResult),
1781 ::core::stringify!(new_2),
1782 )
1783 });
1784 <Self as IDebugPathMenu_Directory_EnumResultMethods>::ctor_2(this, error_message);
1785 this
1786 }
1787}
1788
1789#[cfg(feature = "app-debugpathmenu")]
1790impl DebugPathMenu_CategoriesMenu {
1791 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::debugpathmenu::DebugPathMenu_Setting)` overload"]
1792 pub fn create_bind(
1793 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1794 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1795 ) -> () {
1796 unsafe {
1797 ::unity::il2cpp_call!((::unity::module_base()+0x19d5550usize)as*mut u8,();
1798(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting))
1799 }
1800 }
1801}
1802
1803#[cfg(feature = "app-debugpathmenu")]
1804pub trait IDebugPathMenu_CategoriesMenuMethods: IDebugPathMenu_CategoriesMenu {
1805 #[doc = "`.ctor()` overload"]
1806 fn ctor(self) -> () {
1807 unsafe {
1808 let __receiver =
1809 <DebugPathMenu_CategoriesMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1810 ::unity::il2cpp_call!((::unity::module_base()+0x19d5660usize)as*mut u8,();
1811(DebugPathMenu_CategoriesMenu)__receiver)
1812 }
1813 }
1814}
1815
1816#[cfg(feature = "app-debugpathmenu")]
1817impl<__T: IDebugPathMenu_CategoriesMenu> IDebugPathMenu_CategoriesMenuMethods for __T {}
1818
1819#[cfg(feature = "app-debugpathmenu")]
1820impl DebugPathMenu_CategoriesMenu {
1821 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1823 }
1824
1825 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1827 }
1828}
1829
1830#[cfg(feature = "app-debugpathmenu")]
1831impl DebugPathMenu_CategoriesMenu {
1832 #[doc = "`.ctor()` — no args"]
1833 pub fn new() -> Self {
1834 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1835 panic!(
1836 "{}
1837::{}
1838 failed to instantiate",
1839 ::core::stringify!(DebugPathMenu_CategoriesMenu),
1840 ::core::stringify!(new),
1841 )
1842 });
1843 <Self as IDebugPathMenu_CategoriesMenuMethods>::ctor(this);
1844 this
1845 }
1846}
1847
1848#[cfg(feature = "app-debugpathmenu")]
1849impl DebugPathMenu_EntryMenu {
1850 #[doc = "`CreateBind(crate::app::procinst::ProcInst, crate::app::debugpathmenu::DebugPathMenu_Setting, ::unity::Il2CppString, bool)` overload"]
1851 pub fn create_bind(
1852 super_: impl ::core::convert::Into<crate::app::procinst::ProcInst>,
1853 setting: impl ::core::convert::Into<crate::app::debugpathmenu::DebugPathMenu_Setting>,
1854 parent_path: impl ::core::convert::Into<::unity::Il2CppString>,
1855 is_root: impl ::core::convert::Into<bool>,
1856 ) -> () {
1857 unsafe {
1858 ::unity::il2cpp_call!((::unity::module_base()+0x19d6310usize)as*mut u8,();
1859(crate::app::procinst::ProcInst)::core::convert::Into::into(super_),(crate::app::debugpathmenu::DebugPathMenu_Setting)::core::convert::Into::into(setting),(::unity::Il2CppString)::core::convert::Into::into(parent_path),(bool)::core::convert::Into::into(is_root))
1860 }
1861 }
1862}
1863
1864#[cfg(feature = "app-debugpathmenu")]
1865pub trait IDebugPathMenu_EntryMenuMethods: IDebugPathMenu_EntryMenu {
1866 #[doc = "`.ctor()` overload"]
1867 fn ctor(self) -> () {
1868 unsafe {
1869 let __receiver =
1870 <DebugPathMenu_EntryMenu as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1871 ::unity::il2cpp_call!((::unity::module_base()+0x19d66e0usize)as*mut u8,();
1872(DebugPathMenu_EntryMenu)__receiver)
1873 }
1874 }
1875}
1876
1877#[cfg(feature = "app-debugpathmenu")]
1878impl<__T: IDebugPathMenu_EntryMenu> IDebugPathMenu_EntryMenuMethods for __T {}
1879
1880#[cfg(feature = "app-debugpathmenu")]
1881impl DebugPathMenu_EntryMenu {
1882 pub fn create_bind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1883 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1884 }
1885
1886 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1887 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1888 }
1889}
1890
1891#[cfg(feature = "app-debugpathmenu")]
1892impl DebugPathMenu_EntryMenu {
1893 #[doc = "`.ctor()` — no args"]
1894 pub fn new() -> Self {
1895 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1896 panic!(
1897 "{}
1898::{}
1899 failed to instantiate",
1900 ::core::stringify!(DebugPathMenu_EntryMenu),
1901 ::core::stringify!(new),
1902 )
1903 });
1904 <Self as IDebugPathMenu_EntryMenuMethods>::ctor(this);
1905 this
1906 }
1907}
1908
1909#[cfg(feature = "app-debugpathmenu")]
1910#[doc(hidden)]
1911pub mod prelude {
1912 pub use super::{
1913 DebugPathMenu, DebugPathMenu_Categories, DebugPathMenu_CategoriesMenu, DebugPathMenu_CategoriesMenu_AssetsMenuItem,
1914 DebugPathMenu_CategoriesMenu_PCMenuItem, DebugPathMenu_Directory, DebugPathMenu_Directory_EnumResult, DebugPathMenu_EntryData,
1915 DebugPathMenu_EntryMenu, DebugPathMenu_EntryMenuItem, DebugPathMenu_PCDriveMenu, DebugPathMenu_Path, DebugPathMenu_Result,
1916 DebugPathMenu_Setting, DebugPathMenu_ShowError, DebugPathMenu_ShowError_ErrorMenuItem, IDebugPathMenu, IDebugPathMenuMethods,
1917 IDebugPathMenu_CategoriesMenu, IDebugPathMenu_CategoriesMenuMethods, IDebugPathMenu_CategoriesMenu_AssetsMenuItem,
1918 IDebugPathMenu_CategoriesMenu_AssetsMenuItemMethods, IDebugPathMenu_CategoriesMenu_PCMenuItem,
1919 IDebugPathMenu_CategoriesMenu_PCMenuItemMethods, IDebugPathMenu_Directory, IDebugPathMenu_DirectoryMethods,
1920 IDebugPathMenu_Directory_EnumResult, IDebugPathMenu_Directory_EnumResultMethods, IDebugPathMenu_EntryData, IDebugPathMenu_EntryDataMethods,
1921 IDebugPathMenu_EntryMenu, IDebugPathMenu_EntryMenuItem, IDebugPathMenu_EntryMenuItemMethods, IDebugPathMenu_EntryMenuMethods,
1922 IDebugPathMenu_PCDriveMenu, IDebugPathMenu_PCDriveMenuMethods, IDebugPathMenu_Path, IDebugPathMenu_PathMethods, IDebugPathMenu_Setting,
1923 IDebugPathMenu_SettingMethods, IDebugPathMenu_ShowError, IDebugPathMenu_ShowErrorMethods, IDebugPathMenu_ShowError_ErrorMenuItem,
1924 IDebugPathMenu_ShowError_ErrorMenuItemMethods,
1925 };
1926 #[cfg(feature = "app-menuitem")]
1927 pub use crate::app::menuitem::IMenuItemMethods;
1928 #[cfg(feature = "app-procinst")]
1929 pub use crate::app::procinst::IProcInstMethods;
1930 #[cfg(feature = "system-object")]
1931 pub use crate::system::object::IObjectMethods;
1932 #[cfg(feature = "system-enum")]
1933 pub use crate::system::r#enum::IEnumMethods;
1934 #[cfg(feature = "system-valuetype")]
1935 pub use crate::system::valuetype::IValueTypeMethods;
1936 pub use crate::{
1937 app::{menuitem::IMenuItem, procinst::IProcInst},
1938 system::{object::IObject, r#enum::IEnum, valuetype::IValueType},
1939 };
1940}