1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const _STRING_H: u32 = 1;
84pub const _FEATURES_H: u32 = 1;
85pub const _ISOC95_SOURCE: u32 = 1;
86pub const _ISOC99_SOURCE: u32 = 1;
87pub const _ISOC11_SOURCE: u32 = 1;
88pub const _ISOC2X_SOURCE: u32 = 1;
89pub const _POSIX_SOURCE: u32 = 1;
90pub const _POSIX_C_SOURCE: u32 = 200809;
91pub const _XOPEN_SOURCE: u32 = 700;
92pub const _XOPEN_SOURCE_EXTENDED: u32 = 1;
93pub const _LARGEFILE64_SOURCE: u32 = 1;
94pub const _DEFAULT_SOURCE: u32 = 1;
95pub const _ATFILE_SOURCE: u32 = 1;
96pub const _DYNAMIC_STACK_SIZE_SOURCE: u32 = 1;
97pub const __GLIBC_USE_ISOC2X: u32 = 1;
98pub const __USE_ISOC11: u32 = 1;
99pub const __USE_ISOC99: u32 = 1;
100pub const __USE_ISOC95: u32 = 1;
101pub const __USE_ISOCXX11: u32 = 1;
102pub const __USE_POSIX: u32 = 1;
103pub const __USE_POSIX2: u32 = 1;
104pub const __USE_POSIX199309: u32 = 1;
105pub const __USE_POSIX199506: u32 = 1;
106pub const __USE_XOPEN2K: u32 = 1;
107pub const __USE_XOPEN2K8: u32 = 1;
108pub const __USE_XOPEN: u32 = 1;
109pub const __USE_XOPEN_EXTENDED: u32 = 1;
110pub const __USE_UNIX98: u32 = 1;
111pub const _LARGEFILE_SOURCE: u32 = 1;
112pub const __USE_XOPEN2K8XSI: u32 = 1;
113pub const __USE_XOPEN2KXSI: u32 = 1;
114pub const __USE_LARGEFILE: u32 = 1;
115pub const __USE_LARGEFILE64: u32 = 1;
116pub const __WORDSIZE: u32 = 64;
117pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
118pub const __SYSCALL_WORDSIZE: u32 = 64;
119pub const __TIMESIZE: u32 = 64;
120pub const __USE_MISC: u32 = 1;
121pub const __USE_ATFILE: u32 = 1;
122pub const __USE_DYNAMIC_STACK_SIZE: u32 = 1;
123pub const __USE_GNU: u32 = 1;
124pub const __USE_FORTIFY_LEVEL: u32 = 0;
125pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 1;
126pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
127pub const __GLIBC_USE_C2X_STRTOL: u32 = 1;
128pub const _STDC_PREDEF_H: u32 = 1;
129pub const __STDC_IEC_559__: u32 = 1;
130pub const __STDC_IEC_60559_BFP__: u32 = 201404;
131pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
132pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
133pub const __STDC_ISO_10646__: u32 = 201706;
134pub const __GNU_LIBRARY__: u32 = 6;
135pub const __GLIBC__: u32 = 2;
136pub const __GLIBC_MINOR__: u32 = 39;
137pub const _SYS_CDEFS_H: u32 = 1;
138pub const __glibc_c99_flexarr_available: u32 = 1;
139pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
140pub const __HAVE_GENERIC_SELECTION: u32 = 0;
141pub const __GLIBC_USE_LIB_EXT2: u32 = 1;
142pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 1;
143pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 1;
144pub const __GLIBC_USE_IEC_60559_EXT: u32 = 1;
145pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 1;
146pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 1;
147pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 1;
148pub const _BITS_TYPES_LOCALE_T_H: u32 = 1;
149pub const _BITS_TYPES___LOCALE_T_H: u32 = 1;
150pub const _STRINGS_H: u32 = 1;
151pub const STEAMCLIENT_INTERFACE_VERSION: &[u8; 15] = b"SteamClient023\0";
152pub const STEAMUSER_INTERFACE_VERSION: &[u8; 13] = b"SteamUser023\0";
153pub const STEAMFRIENDS_INTERFACE_VERSION: &[u8; 16] = b"SteamFriends018\0";
154pub const STEAMUTILS_INTERFACE_VERSION: &[u8; 14] = b"SteamUtils010\0";
155pub const _STDIO_H: u32 = 1;
156pub const _BITS_TYPES_H: u32 = 1;
157pub const _BITS_TYPESIZES_H: u32 = 1;
158pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
159pub const __INO_T_MATCHES_INO64_T: u32 = 1;
160pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
161pub const __STATFS_MATCHES_STATFS64: u32 = 1;
162pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64: u32 = 1;
163pub const __FD_SETSIZE: u32 = 1024;
164pub const _BITS_TIME64_H: u32 = 1;
165pub const _____fpos_t_defined: u32 = 1;
166pub const ____mbstate_t_defined: u32 = 1;
167pub const _____fpos64_t_defined: u32 = 1;
168pub const ____FILE_defined: u32 = 1;
169pub const __FILE_defined: u32 = 1;
170pub const __struct_FILE_defined: u32 = 1;
171pub const _IO_EOF_SEEN: u32 = 16;
172pub const _IO_ERR_SEEN: u32 = 32;
173pub const _IO_USER_LOCK: u32 = 32768;
174pub const __cookie_io_functions_t_defined: u32 = 1;
175pub const _IOFBF: u32 = 0;
176pub const _IOLBF: u32 = 1;
177pub const _IONBF: u32 = 2;
178pub const BUFSIZ: u32 = 8192;
179pub const EOF: i32 = -1;
180pub const SEEK_SET: u32 = 0;
181pub const SEEK_CUR: u32 = 1;
182pub const SEEK_END: u32 = 2;
183pub const SEEK_DATA: u32 = 3;
184pub const SEEK_HOLE: u32 = 4;
185pub const P_tmpdir: &[u8; 5] = b"/tmp\0";
186pub const L_tmpnam: u32 = 20;
187pub const TMP_MAX: u32 = 238328;
188pub const _BITS_STDIO_LIM_H: u32 = 1;
189pub const FILENAME_MAX: u32 = 4096;
190pub const L_ctermid: u32 = 9;
191pub const L_cuserid: u32 = 9;
192pub const FOPEN_MAX: u32 = 16;
193pub const _PRINTF_NAN_LEN_MAX: u32 = 4;
194pub const RENAME_NOREPLACE: u32 = 1;
195pub const RENAME_EXCHANGE: u32 = 2;
196pub const RENAME_WHITEOUT: u32 = 4;
197pub const __HAVE_FLOAT128: u32 = 0;
198pub const __HAVE_DISTINCT_FLOAT128: u32 = 0;
199pub const __HAVE_FLOAT64X: u32 = 1;
200pub const __HAVE_FLOAT64X_LONG_DOUBLE: u32 = 1;
201pub const __HAVE_FLOAT16: u32 = 0;
202pub const __HAVE_FLOAT32: u32 = 1;
203pub const __HAVE_FLOAT64: u32 = 1;
204pub const __HAVE_FLOAT32X: u32 = 1;
205pub const __HAVE_FLOAT128X: u32 = 0;
206pub const __HAVE_DISTINCT_FLOAT16: u32 = 0;
207pub const __HAVE_DISTINCT_FLOAT32: u32 = 0;
208pub const __HAVE_DISTINCT_FLOAT64: u32 = 0;
209pub const __HAVE_DISTINCT_FLOAT32X: u32 = 0;
210pub const __HAVE_DISTINCT_FLOAT64X: u32 = 0;
211pub const __HAVE_DISTINCT_FLOAT128X: u32 = 0;
212pub const __HAVE_FLOATN_NOT_TYPEDEF: u32 = 0;
213pub const k_nMaxLobbyKeyLength: u32 = 255;
214pub const STEAMMATCHMAKING_INTERFACE_VERSION: &[u8; 20] = b"SteamMatchMaking009\0";
215pub const STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION: &[u8; 27] = b"SteamMatchMakingServers002\0";
216pub const STEAMPARTIES_INTERFACE_VERSION: &[u8; 16] = b"SteamParties002\0";
217pub const STEAMREMOTESTORAGE_INTERFACE_VERSION: &[u8; 40] =
218 b"STEAMREMOTESTORAGE_INTERFACE_VERSION016\0";
219pub const STEAMUSERSTATS_INTERFACE_VERSION: &[u8; 36] = b"STEAMUSERSTATS_INTERFACE_VERSION013\0";
220pub const STEAMAPPS_INTERFACE_VERSION: &[u8; 31] = b"STEAMAPPS_INTERFACE_VERSION009\0";
221pub const STEAMNETWORKING_INTERFACE_VERSION: &[u8; 19] = b"SteamNetworking006\0";
222pub const INVALID_SCREENSHOT_HANDLE: u32 = 0;
223pub const STEAMSCREENSHOTS_INTERFACE_VERSION: &[u8; 38] =
224 b"STEAMSCREENSHOTS_INTERFACE_VERSION003\0";
225pub const STEAMMUSIC_INTERFACE_VERSION: &[u8; 32] = b"STEAMMUSIC_INTERFACE_VERSION001\0";
226pub const INVALID_HTTPREQUEST_HANDLE: u32 = 0;
227pub const INVALID_HTTPCOOKIE_HANDLE: u32 = 0;
228pub const STEAMHTTP_INTERFACE_VERSION: &[u8; 31] = b"STEAMHTTP_INTERFACE_VERSION003\0";
229pub const STEAM_INPUT_MAX_COUNT: u32 = 16;
230pub const STEAM_INPUT_MAX_ANALOG_ACTIONS: u32 = 24;
231pub const STEAM_INPUT_MAX_DIGITAL_ACTIONS: u32 = 256;
232pub const STEAM_INPUT_MAX_ORIGINS: u32 = 8;
233pub const STEAM_INPUT_MAX_ACTIVE_LAYERS: u32 = 16;
234pub const STEAM_INPUT_MIN_ANALOG_ACTION_DATA: f64 = -1.0;
235pub const STEAM_INPUT_MAX_ANALOG_ACTION_DATA: f64 = 1.0;
236pub const STEAMINPUT_INTERFACE_VERSION: &[u8; 14] = b"SteamInput006\0";
237pub const STEAM_CONTROLLER_MAX_COUNT: u32 = 16;
238pub const STEAM_CONTROLLER_MAX_ANALOG_ACTIONS: u32 = 24;
239pub const STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS: u32 = 256;
240pub const STEAM_CONTROLLER_MAX_ORIGINS: u32 = 8;
241pub const STEAM_CONTROLLER_MAX_ACTIVE_LAYERS: u32 = 16;
242pub const STEAM_CONTROLLER_MIN_ANALOG_ACTION_DATA: f64 = -1.0;
243pub const STEAM_CONTROLLER_MAX_ANALOG_ACTION_DATA: f64 = 1.0;
244pub const STEAMCONTROLLER_INTERFACE_VERSION: &[u8; 19] = b"SteamController008\0";
245pub const STEAMUGC_INTERFACE_VERSION: &[u8; 30] = b"STEAMUGC_INTERFACE_VERSION021\0";
246pub const STEAMHTMLSURFACE_INTERFACE_VERSION: &[u8; 39] =
247 b"STEAMHTMLSURFACE_INTERFACE_VERSION_005\0";
248pub const STEAMINVENTORY_INTERFACE_VERSION: &[u8; 30] = b"STEAMINVENTORY_INTERFACE_V003\0";
249pub const STEAMTIMELINE_INTERFACE_VERSION: &[u8; 29] = b"STEAMTIMELINE_INTERFACE_V004\0";
250pub const STEAMVIDEO_INTERFACE_VERSION: &[u8; 26] = b"STEAMVIDEO_INTERFACE_V007\0";
251pub const STEAMPARENTALSETTINGS_INTERFACE_VERSION: &[u8; 43] =
252 b"STEAMPARENTALSETTINGS_INTERFACE_VERSION001\0";
253pub const STEAMREMOTEPLAY_INTERFACE_VERSION: &[u8; 37] = b"STEAMREMOTEPLAY_INTERFACE_VERSION004\0";
254pub const _STDINT_H: u32 = 1;
255pub const _BITS_WCHAR_H: u32 = 1;
256pub const _BITS_STDINT_INTN_H: u32 = 1;
257pub const _BITS_STDINT_UINTN_H: u32 = 1;
258pub const _BITS_STDINT_LEAST_H: u32 = 1;
259pub const INT8_MIN: i32 = -128;
260pub const INT16_MIN: i32 = -32768;
261pub const INT32_MIN: i32 = -2147483648;
262pub const INT8_MAX: u32 = 127;
263pub const INT16_MAX: u32 = 32767;
264pub const INT32_MAX: u32 = 2147483647;
265pub const UINT8_MAX: u32 = 255;
266pub const UINT16_MAX: u32 = 65535;
267pub const UINT32_MAX: u32 = 4294967295;
268pub const INT_LEAST8_MIN: i32 = -128;
269pub const INT_LEAST16_MIN: i32 = -32768;
270pub const INT_LEAST32_MIN: i32 = -2147483648;
271pub const INT_LEAST8_MAX: u32 = 127;
272pub const INT_LEAST16_MAX: u32 = 32767;
273pub const INT_LEAST32_MAX: u32 = 2147483647;
274pub const UINT_LEAST8_MAX: u32 = 255;
275pub const UINT_LEAST16_MAX: u32 = 65535;
276pub const UINT_LEAST32_MAX: u32 = 4294967295;
277pub const INT_FAST8_MIN: i32 = -128;
278pub const INT_FAST16_MIN: i64 = -9223372036854775808;
279pub const INT_FAST32_MIN: i64 = -9223372036854775808;
280pub const INT_FAST8_MAX: u32 = 127;
281pub const INT_FAST16_MAX: u64 = 9223372036854775807;
282pub const INT_FAST32_MAX: u64 = 9223372036854775807;
283pub const UINT_FAST8_MAX: u32 = 255;
284pub const UINT_FAST16_MAX: i32 = -1;
285pub const UINT_FAST32_MAX: i32 = -1;
286pub const INTPTR_MIN: i64 = -9223372036854775808;
287pub const INTPTR_MAX: u64 = 9223372036854775807;
288pub const UINTPTR_MAX: i32 = -1;
289pub const PTRDIFF_MIN: i64 = -9223372036854775808;
290pub const PTRDIFF_MAX: u64 = 9223372036854775807;
291pub const SIG_ATOMIC_MIN: i32 = -2147483648;
292pub const SIG_ATOMIC_MAX: u32 = 2147483647;
293pub const SIZE_MAX: i32 = -1;
294pub const WINT_MIN: u32 = 0;
295pub const WINT_MAX: u32 = 4294967295;
296pub const INT8_WIDTH: u32 = 8;
297pub const UINT8_WIDTH: u32 = 8;
298pub const INT16_WIDTH: u32 = 16;
299pub const UINT16_WIDTH: u32 = 16;
300pub const INT32_WIDTH: u32 = 32;
301pub const UINT32_WIDTH: u32 = 32;
302pub const INT64_WIDTH: u32 = 64;
303pub const UINT64_WIDTH: u32 = 64;
304pub const INT_LEAST8_WIDTH: u32 = 8;
305pub const UINT_LEAST8_WIDTH: u32 = 8;
306pub const INT_LEAST16_WIDTH: u32 = 16;
307pub const UINT_LEAST16_WIDTH: u32 = 16;
308pub const INT_LEAST32_WIDTH: u32 = 32;
309pub const UINT_LEAST32_WIDTH: u32 = 32;
310pub const INT_LEAST64_WIDTH: u32 = 64;
311pub const UINT_LEAST64_WIDTH: u32 = 64;
312pub const INT_FAST8_WIDTH: u32 = 8;
313pub const UINT_FAST8_WIDTH: u32 = 8;
314pub const INT_FAST16_WIDTH: u32 = 64;
315pub const UINT_FAST16_WIDTH: u32 = 64;
316pub const INT_FAST32_WIDTH: u32 = 64;
317pub const UINT_FAST32_WIDTH: u32 = 64;
318pub const INT_FAST64_WIDTH: u32 = 64;
319pub const UINT_FAST64_WIDTH: u32 = 64;
320pub const INTPTR_WIDTH: u32 = 64;
321pub const UINTPTR_WIDTH: u32 = 64;
322pub const INTMAX_WIDTH: u32 = 64;
323pub const UINTMAX_WIDTH: u32 = 64;
324pub const PTRDIFF_WIDTH: u32 = 64;
325pub const SIG_ATOMIC_WIDTH: u32 = 32;
326pub const SIZE_WIDTH: u32 = 64;
327pub const WCHAR_WIDTH: u32 = 32;
328pub const WINT_WIDTH: u32 = 32;
329pub const STEAMNETWORKINGMESSAGES_INTERFACE_VERSION: &[u8; 27] = b"SteamNetworkingMessages002\0";
330pub const STEAMNETWORKINGSOCKETS_INTERFACE_VERSION: &[u8; 26] = b"SteamNetworkingSockets012\0";
331pub const STEAMNETWORKINGUTILS_INTERFACE_VERSION: &[u8; 24] = b"SteamNetworkingUtils004\0";
332pub const STEAMGAMESERVER_INTERFACE_VERSION: &[u8; 19] = b"SteamGameServer015\0";
333pub const STEAMGAMESERVERSTATS_INTERFACE_VERSION: &[u8; 24] = b"SteamGameServerStats001\0";
334pub type uint8 = ::std::os::raw::c_uchar;
335pub type int8 = ::std::os::raw::c_schar;
336pub type int16 = ::std::os::raw::c_short;
337pub type uint16 = ::std::os::raw::c_ushort;
338pub type int32 = ::std::os::raw::c_int;
339pub type uint32 = ::std::os::raw::c_uint;
340pub type int64 = ::std::os::raw::c_longlong;
341pub type uint64 = ::std::os::raw::c_ulonglong;
342pub type lint64 = ::std::os::raw::c_long;
343pub type ulint64 = ::std::os::raw::c_ulong;
344pub type intp = ::std::os::raw::c_longlong;
345pub type uintp = ::std::os::raw::c_ulonglong;
346pub type AppId_t = uint32;
347pub const k_uAppIdInvalid: AppId_t = 0;
348pub type DepotId_t = uint32;
349pub const k_uDepotIdInvalid: DepotId_t = 0;
350pub type RTime32 = uint32;
351pub type SteamAPICall_t = uint64;
352pub const k_uAPICallInvalid: SteamAPICall_t = 0;
353pub type AccountID_t = uint32;
354pub const k_uAccountIdInvalid: AccountID_t = 0;
355pub type PartyBeaconID_t = uint64;
356pub const k_ulPartyBeaconIdInvalid: PartyBeaconID_t = 0;
357#[repr(u32)]
358#[non_exhaustive]
359#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
360pub enum ESteamIPType {
361 k_ESteamIPTypeIPv4 = 0,
362 k_ESteamIPTypeIPv6 = 1,
363}
364#[repr(C, packed)]
365#[derive(Copy, Clone)]
366pub struct SteamIPAddress_t {
367 pub __bindgen_anon_1: SteamIPAddress_t__bindgen_ty_1,
368 pub m_eType: ESteamIPType,
369}
370#[repr(C, packed)]
371#[derive(Copy, Clone)]
372pub union SteamIPAddress_t__bindgen_ty_1 {
373 pub m_unIPv4: uint32,
374 pub m_rgubIPv6: [uint8; 16usize],
375 pub m_ipv6Qword: [uint64; 2usize],
376}
377#[test]
378fn bindgen_test_layout_SteamIPAddress_t__bindgen_ty_1() {
379 const UNINIT: ::std::mem::MaybeUninit<SteamIPAddress_t__bindgen_ty_1> =
380 ::std::mem::MaybeUninit::uninit();
381 let ptr = UNINIT.as_ptr();
382 assert_eq!(
383 ::std::mem::size_of::<SteamIPAddress_t__bindgen_ty_1>(),
384 16usize,
385 concat!("Size of: ", stringify!(SteamIPAddress_t__bindgen_ty_1))
386 );
387 assert_eq!(
388 ::std::mem::align_of::<SteamIPAddress_t__bindgen_ty_1>(),
389 1usize,
390 concat!("Alignment of ", stringify!(SteamIPAddress_t__bindgen_ty_1))
391 );
392 assert_eq!(
393 unsafe { ::std::ptr::addr_of!((*ptr).m_unIPv4) as usize - ptr as usize },
394 0usize,
395 concat!(
396 "Offset of field: ",
397 stringify!(SteamIPAddress_t__bindgen_ty_1),
398 "::",
399 stringify!(m_unIPv4)
400 )
401 );
402 assert_eq!(
403 unsafe { ::std::ptr::addr_of!((*ptr).m_rgubIPv6) as usize - ptr as usize },
404 0usize,
405 concat!(
406 "Offset of field: ",
407 stringify!(SteamIPAddress_t__bindgen_ty_1),
408 "::",
409 stringify!(m_rgubIPv6)
410 )
411 );
412 assert_eq!(
413 unsafe { ::std::ptr::addr_of!((*ptr).m_ipv6Qword) as usize - ptr as usize },
414 0usize,
415 concat!(
416 "Offset of field: ",
417 stringify!(SteamIPAddress_t__bindgen_ty_1),
418 "::",
419 stringify!(m_ipv6Qword)
420 )
421 );
422}
423#[test]
424fn bindgen_test_layout_SteamIPAddress_t() {
425 const UNINIT: ::std::mem::MaybeUninit<SteamIPAddress_t> = ::std::mem::MaybeUninit::uninit();
426 let ptr = UNINIT.as_ptr();
427 assert_eq!(
428 ::std::mem::size_of::<SteamIPAddress_t>(),
429 20usize,
430 concat!("Size of: ", stringify!(SteamIPAddress_t))
431 );
432 assert_eq!(
433 ::std::mem::align_of::<SteamIPAddress_t>(),
434 1usize,
435 concat!("Alignment of ", stringify!(SteamIPAddress_t))
436 );
437 assert_eq!(
438 unsafe { ::std::ptr::addr_of!((*ptr).m_eType) as usize - ptr as usize },
439 16usize,
440 concat!(
441 "Offset of field: ",
442 stringify!(SteamIPAddress_t),
443 "::",
444 stringify!(m_eType)
445 )
446 );
447}
448#[repr(u32)]
449#[non_exhaustive]
450#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
451pub enum EUniverse {
452 k_EUniverseInvalid = 0,
453 k_EUniversePublic = 1,
454 k_EUniverseBeta = 2,
455 k_EUniverseInternal = 3,
456 k_EUniverseDev = 4,
457 k_EUniverseMax = 5,
458}
459#[repr(u32)]
460#[non_exhaustive]
461#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
462pub enum EResult {
463 k_EResultNone = 0,
464 k_EResultOK = 1,
465 k_EResultFail = 2,
466 k_EResultNoConnection = 3,
467 k_EResultInvalidPassword = 5,
468 k_EResultLoggedInElsewhere = 6,
469 k_EResultInvalidProtocolVer = 7,
470 k_EResultInvalidParam = 8,
471 k_EResultFileNotFound = 9,
472 k_EResultBusy = 10,
473 k_EResultInvalidState = 11,
474 k_EResultInvalidName = 12,
475 k_EResultInvalidEmail = 13,
476 k_EResultDuplicateName = 14,
477 k_EResultAccessDenied = 15,
478 k_EResultTimeout = 16,
479 k_EResultBanned = 17,
480 k_EResultAccountNotFound = 18,
481 k_EResultInvalidSteamID = 19,
482 k_EResultServiceUnavailable = 20,
483 k_EResultNotLoggedOn = 21,
484 k_EResultPending = 22,
485 k_EResultEncryptionFailure = 23,
486 k_EResultInsufficientPrivilege = 24,
487 k_EResultLimitExceeded = 25,
488 k_EResultRevoked = 26,
489 k_EResultExpired = 27,
490 k_EResultAlreadyRedeemed = 28,
491 k_EResultDuplicateRequest = 29,
492 k_EResultAlreadyOwned = 30,
493 k_EResultIPNotFound = 31,
494 k_EResultPersistFailed = 32,
495 k_EResultLockingFailed = 33,
496 k_EResultLogonSessionReplaced = 34,
497 k_EResultConnectFailed = 35,
498 k_EResultHandshakeFailed = 36,
499 k_EResultIOFailure = 37,
500 k_EResultRemoteDisconnect = 38,
501 k_EResultShoppingCartNotFound = 39,
502 k_EResultBlocked = 40,
503 k_EResultIgnored = 41,
504 k_EResultNoMatch = 42,
505 k_EResultAccountDisabled = 43,
506 k_EResultServiceReadOnly = 44,
507 k_EResultAccountNotFeatured = 45,
508 k_EResultAdministratorOK = 46,
509 k_EResultContentVersion = 47,
510 k_EResultTryAnotherCM = 48,
511 k_EResultPasswordRequiredToKickSession = 49,
512 k_EResultAlreadyLoggedInElsewhere = 50,
513 k_EResultSuspended = 51,
514 k_EResultCancelled = 52,
515 k_EResultDataCorruption = 53,
516 k_EResultDiskFull = 54,
517 k_EResultRemoteCallFailed = 55,
518 k_EResultPasswordUnset = 56,
519 k_EResultExternalAccountUnlinked = 57,
520 k_EResultPSNTicketInvalid = 58,
521 k_EResultExternalAccountAlreadyLinked = 59,
522 k_EResultRemoteFileConflict = 60,
523 k_EResultIllegalPassword = 61,
524 k_EResultSameAsPreviousValue = 62,
525 k_EResultAccountLogonDenied = 63,
526 k_EResultCannotUseOldPassword = 64,
527 k_EResultInvalidLoginAuthCode = 65,
528 k_EResultAccountLogonDeniedNoMail = 66,
529 k_EResultHardwareNotCapableOfIPT = 67,
530 k_EResultIPTInitError = 68,
531 k_EResultParentalControlRestricted = 69,
532 k_EResultFacebookQueryError = 70,
533 k_EResultExpiredLoginAuthCode = 71,
534 k_EResultIPLoginRestrictionFailed = 72,
535 k_EResultAccountLockedDown = 73,
536 k_EResultAccountLogonDeniedVerifiedEmailRequired = 74,
537 k_EResultNoMatchingURL = 75,
538 k_EResultBadResponse = 76,
539 k_EResultRequirePasswordReEntry = 77,
540 k_EResultValueOutOfRange = 78,
541 k_EResultUnexpectedError = 79,
542 k_EResultDisabled = 80,
543 k_EResultInvalidCEGSubmission = 81,
544 k_EResultRestrictedDevice = 82,
545 k_EResultRegionLocked = 83,
546 k_EResultRateLimitExceeded = 84,
547 k_EResultAccountLoginDeniedNeedTwoFactor = 85,
548 k_EResultItemDeleted = 86,
549 k_EResultAccountLoginDeniedThrottle = 87,
550 k_EResultTwoFactorCodeMismatch = 88,
551 k_EResultTwoFactorActivationCodeMismatch = 89,
552 k_EResultAccountAssociatedToMultiplePartners = 90,
553 k_EResultNotModified = 91,
554 k_EResultNoMobileDevice = 92,
555 k_EResultTimeNotSynced = 93,
556 k_EResultSmsCodeFailed = 94,
557 k_EResultAccountLimitExceeded = 95,
558 k_EResultAccountActivityLimitExceeded = 96,
559 k_EResultPhoneActivityLimitExceeded = 97,
560 k_EResultRefundToWallet = 98,
561 k_EResultEmailSendFailure = 99,
562 k_EResultNotSettled = 100,
563 k_EResultNeedCaptcha = 101,
564 k_EResultGSLTDenied = 102,
565 k_EResultGSOwnerDenied = 103,
566 k_EResultInvalidItemType = 104,
567 k_EResultIPBanned = 105,
568 k_EResultGSLTExpired = 106,
569 k_EResultInsufficientFunds = 107,
570 k_EResultTooManyPending = 108,
571 k_EResultNoSiteLicensesFound = 109,
572 k_EResultWGNetworkSendExceeded = 110,
573 k_EResultAccountNotFriends = 111,
574 k_EResultLimitedUserAccount = 112,
575 k_EResultCantRemoveItem = 113,
576 k_EResultAccountDeleted = 114,
577 k_EResultExistingUserCancelledLicense = 115,
578 k_EResultCommunityCooldown = 116,
579 k_EResultNoLauncherSpecified = 117,
580 k_EResultMustAgreeToSSA = 118,
581 k_EResultLauncherMigrated = 119,
582 k_EResultSteamRealmMismatch = 120,
583 k_EResultInvalidSignature = 121,
584 k_EResultParseFailure = 122,
585 k_EResultNoVerifiedPhone = 123,
586 k_EResultInsufficientBattery = 124,
587 k_EResultChargerRequired = 125,
588 k_EResultCachedCredentialInvalid = 126,
589 K_EResultPhoneNumberIsVOIP = 127,
590 k_EResultNotSupported = 128,
591 k_EResultFamilySizeLimitExceeded = 129,
592 k_EResultOfflineAppCacheInvalid = 130,
593 k_EResultTryLater = 131,
594}
595#[repr(u32)]
596#[non_exhaustive]
597#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
598pub enum EVoiceResult {
599 k_EVoiceResultOK = 0,
600 k_EVoiceResultNotInitialized = 1,
601 k_EVoiceResultNotRecording = 2,
602 k_EVoiceResultNoData = 3,
603 k_EVoiceResultBufferTooSmall = 4,
604 k_EVoiceResultDataCorrupted = 5,
605 k_EVoiceResultRestricted = 6,
606 k_EVoiceResultUnsupportedCodec = 7,
607 k_EVoiceResultReceiverOutOfDate = 8,
608 k_EVoiceResultReceiverDidNotAnswer = 9,
609}
610#[repr(u32)]
611#[non_exhaustive]
612#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
613pub enum EDenyReason {
614 k_EDenyInvalid = 0,
615 k_EDenyInvalidVersion = 1,
616 k_EDenyGeneric = 2,
617 k_EDenyNotLoggedOn = 3,
618 k_EDenyNoLicense = 4,
619 k_EDenyCheater = 5,
620 k_EDenyLoggedInElseWhere = 6,
621 k_EDenyUnknownText = 7,
622 k_EDenyIncompatibleAnticheat = 8,
623 k_EDenyMemoryCorruption = 9,
624 k_EDenyIncompatibleSoftware = 10,
625 k_EDenySteamConnectionLost = 11,
626 k_EDenySteamConnectionError = 12,
627 k_EDenySteamResponseTimedOut = 13,
628 k_EDenySteamValidationStalled = 14,
629 k_EDenySteamOwnerLeftGuestUser = 15,
630}
631pub type HAuthTicket = uint32;
632pub const k_HAuthTicketInvalid: HAuthTicket = 0;
633#[repr(u32)]
634#[non_exhaustive]
635#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
636pub enum EBeginAuthSessionResult {
637 k_EBeginAuthSessionResultOK = 0,
638 k_EBeginAuthSessionResultInvalidTicket = 1,
639 k_EBeginAuthSessionResultDuplicateRequest = 2,
640 k_EBeginAuthSessionResultInvalidVersion = 3,
641 k_EBeginAuthSessionResultGameMismatch = 4,
642 k_EBeginAuthSessionResultExpiredTicket = 5,
643}
644#[repr(u32)]
645#[non_exhaustive]
646#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
647pub enum EAuthSessionResponse {
648 k_EAuthSessionResponseOK = 0,
649 k_EAuthSessionResponseUserNotConnectedToSteam = 1,
650 k_EAuthSessionResponseNoLicenseOrExpired = 2,
651 k_EAuthSessionResponseVACBanned = 3,
652 k_EAuthSessionResponseLoggedInElseWhere = 4,
653 k_EAuthSessionResponseVACCheckTimedOut = 5,
654 k_EAuthSessionResponseAuthTicketCanceled = 6,
655 k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7,
656 k_EAuthSessionResponseAuthTicketInvalid = 8,
657 k_EAuthSessionResponsePublisherIssuedBan = 9,
658 k_EAuthSessionResponseAuthTicketNetworkIdentityFailure = 10,
659}
660#[repr(u32)]
661#[non_exhaustive]
662#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
663pub enum EUserHasLicenseForAppResult {
664 k_EUserHasLicenseResultHasLicense = 0,
665 k_EUserHasLicenseResultDoesNotHaveLicense = 1,
666 k_EUserHasLicenseResultNoAuth = 2,
667}
668#[repr(u32)]
669#[non_exhaustive]
670#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
671pub enum EAccountType {
672 k_EAccountTypeInvalid = 0,
673 k_EAccountTypeIndividual = 1,
674 k_EAccountTypeMultiseat = 2,
675 k_EAccountTypeGameServer = 3,
676 k_EAccountTypeAnonGameServer = 4,
677 k_EAccountTypePending = 5,
678 k_EAccountTypeContentServer = 6,
679 k_EAccountTypeClan = 7,
680 k_EAccountTypeChat = 8,
681 k_EAccountTypeConsoleUser = 9,
682 k_EAccountTypeAnonUser = 10,
683 k_EAccountTypeMax = 11,
684}
685#[repr(u32)]
686#[non_exhaustive]
687#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
688pub enum EChatEntryType {
689 k_EChatEntryTypeInvalid = 0,
690 k_EChatEntryTypeChatMsg = 1,
691 k_EChatEntryTypeTyping = 2,
692 k_EChatEntryTypeInviteGame = 3,
693 k_EChatEntryTypeEmote = 4,
694 k_EChatEntryTypeLeftConversation = 6,
695 k_EChatEntryTypeEntered = 7,
696 k_EChatEntryTypeWasKicked = 8,
697 k_EChatEntryTypeWasBanned = 9,
698 k_EChatEntryTypeDisconnected = 10,
699 k_EChatEntryTypeHistoricalChat = 11,
700 k_EChatEntryTypeLinkBlocked = 14,
701}
702#[repr(u32)]
703#[non_exhaustive]
704#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
705pub enum EChatRoomEnterResponse {
706 k_EChatRoomEnterResponseSuccess = 1,
707 k_EChatRoomEnterResponseDoesntExist = 2,
708 k_EChatRoomEnterResponseNotAllowed = 3,
709 k_EChatRoomEnterResponseFull = 4,
710 k_EChatRoomEnterResponseError = 5,
711 k_EChatRoomEnterResponseBanned = 6,
712 k_EChatRoomEnterResponseLimited = 7,
713 k_EChatRoomEnterResponseClanDisabled = 8,
714 k_EChatRoomEnterResponseCommunityBan = 9,
715 k_EChatRoomEnterResponseMemberBlockedYou = 10,
716 k_EChatRoomEnterResponseYouBlockedMember = 11,
717 k_EChatRoomEnterResponseRatelimitExceeded = 15,
718}
719pub const k_unSteamAccountIDMask: ::std::os::raw::c_uint = 4294967295;
720pub const k_unSteamAccountInstanceMask: ::std::os::raw::c_uint = 1048575;
721pub const k_unSteamUserDefaultInstance: ::std::os::raw::c_uint = 1;
722impl EChatSteamIDInstanceFlags {
723 pub const k_EChatAccountInstanceMask: EChatSteamIDInstanceFlags =
724 EChatSteamIDInstanceFlags(4095);
725}
726impl EChatSteamIDInstanceFlags {
727 pub const k_EChatInstanceFlagClan: EChatSteamIDInstanceFlags =
728 EChatSteamIDInstanceFlags(524288);
729}
730impl EChatSteamIDInstanceFlags {
731 pub const k_EChatInstanceFlagLobby: EChatSteamIDInstanceFlags =
732 EChatSteamIDInstanceFlags(262144);
733}
734impl EChatSteamIDInstanceFlags {
735 pub const k_EChatInstanceFlagMMSLobby: EChatSteamIDInstanceFlags =
736 EChatSteamIDInstanceFlags(131072);
737}
738impl ::std::ops::BitOr<EChatSteamIDInstanceFlags> for EChatSteamIDInstanceFlags {
739 type Output = Self;
740 #[inline]
741 fn bitor(self, other: Self) -> Self {
742 EChatSteamIDInstanceFlags(self.0 | other.0)
743 }
744}
745impl ::std::ops::BitOrAssign for EChatSteamIDInstanceFlags {
746 #[inline]
747 fn bitor_assign(&mut self, rhs: EChatSteamIDInstanceFlags) {
748 self.0 |= rhs.0;
749 }
750}
751impl ::std::ops::BitAnd<EChatSteamIDInstanceFlags> for EChatSteamIDInstanceFlags {
752 type Output = Self;
753 #[inline]
754 fn bitand(self, other: Self) -> Self {
755 EChatSteamIDInstanceFlags(self.0 & other.0)
756 }
757}
758impl ::std::ops::BitAndAssign for EChatSteamIDInstanceFlags {
759 #[inline]
760 fn bitand_assign(&mut self, rhs: EChatSteamIDInstanceFlags) {
761 self.0 &= rhs.0;
762 }
763}
764#[repr(transparent)]
765#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
766pub struct EChatSteamIDInstanceFlags(pub ::std::os::raw::c_uint);
767#[repr(i32)]
768#[non_exhaustive]
769#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
770pub enum ENotificationPosition {
771 k_EPositionInvalid = -1,
772 k_EPositionTopLeft = 0,
773 k_EPositionTopRight = 1,
774 k_EPositionBottomLeft = 2,
775 k_EPositionBottomRight = 3,
776}
777#[repr(u32)]
778#[non_exhaustive]
779#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
780pub enum EBroadcastUploadResult {
781 k_EBroadcastUploadResultNone = 0,
782 k_EBroadcastUploadResultOK = 1,
783 k_EBroadcastUploadResultInitFailed = 2,
784 k_EBroadcastUploadResultFrameFailed = 3,
785 k_EBroadcastUploadResultTimeout = 4,
786 k_EBroadcastUploadResultBandwidthExceeded = 5,
787 k_EBroadcastUploadResultLowFPS = 6,
788 k_EBroadcastUploadResultMissingKeyFrames = 7,
789 k_EBroadcastUploadResultNoConnection = 8,
790 k_EBroadcastUploadResultRelayFailed = 9,
791 k_EBroadcastUploadResultSettingsChanged = 10,
792 k_EBroadcastUploadResultMissingAudio = 11,
793 k_EBroadcastUploadResultTooFarBehind = 12,
794 k_EBroadcastUploadResultTranscodeBehind = 13,
795 k_EBroadcastUploadResultNotAllowedToPlay = 14,
796 k_EBroadcastUploadResultBusy = 15,
797 k_EBroadcastUploadResultBanned = 16,
798 k_EBroadcastUploadResultAlreadyActive = 17,
799 k_EBroadcastUploadResultForcedOff = 18,
800 k_EBroadcastUploadResultAudioBehind = 19,
801 k_EBroadcastUploadResultShutdown = 20,
802 k_EBroadcastUploadResultDisconnect = 21,
803 k_EBroadcastUploadResultVideoInitFailed = 22,
804 k_EBroadcastUploadResultAudioInitFailed = 23,
805}
806impl EMarketNotAllowedReasonFlags {
807 pub const k_EMarketNotAllowedReason_None: EMarketNotAllowedReasonFlags =
808 EMarketNotAllowedReasonFlags(0);
809}
810impl EMarketNotAllowedReasonFlags {
811 pub const k_EMarketNotAllowedReason_TemporaryFailure: EMarketNotAllowedReasonFlags =
812 EMarketNotAllowedReasonFlags(1);
813}
814impl EMarketNotAllowedReasonFlags {
815 pub const k_EMarketNotAllowedReason_AccountDisabled: EMarketNotAllowedReasonFlags =
816 EMarketNotAllowedReasonFlags(2);
817}
818impl EMarketNotAllowedReasonFlags {
819 pub const k_EMarketNotAllowedReason_AccountLockedDown: EMarketNotAllowedReasonFlags =
820 EMarketNotAllowedReasonFlags(4);
821}
822impl EMarketNotAllowedReasonFlags {
823 pub const k_EMarketNotAllowedReason_AccountLimited: EMarketNotAllowedReasonFlags =
824 EMarketNotAllowedReasonFlags(8);
825}
826impl EMarketNotAllowedReasonFlags {
827 pub const k_EMarketNotAllowedReason_TradeBanned: EMarketNotAllowedReasonFlags =
828 EMarketNotAllowedReasonFlags(16);
829}
830impl EMarketNotAllowedReasonFlags {
831 pub const k_EMarketNotAllowedReason_AccountNotTrusted: EMarketNotAllowedReasonFlags =
832 EMarketNotAllowedReasonFlags(32);
833}
834impl EMarketNotAllowedReasonFlags {
835 pub const k_EMarketNotAllowedReason_SteamGuardNotEnabled: EMarketNotAllowedReasonFlags =
836 EMarketNotAllowedReasonFlags(64);
837}
838impl EMarketNotAllowedReasonFlags {
839 pub const k_EMarketNotAllowedReason_SteamGuardOnlyRecentlyEnabled:
840 EMarketNotAllowedReasonFlags = EMarketNotAllowedReasonFlags(128);
841}
842impl EMarketNotAllowedReasonFlags {
843 pub const k_EMarketNotAllowedReason_RecentPasswordReset: EMarketNotAllowedReasonFlags =
844 EMarketNotAllowedReasonFlags(256);
845}
846impl EMarketNotAllowedReasonFlags {
847 pub const k_EMarketNotAllowedReason_NewPaymentMethod: EMarketNotAllowedReasonFlags =
848 EMarketNotAllowedReasonFlags(512);
849}
850impl EMarketNotAllowedReasonFlags {
851 pub const k_EMarketNotAllowedReason_InvalidCookie: EMarketNotAllowedReasonFlags =
852 EMarketNotAllowedReasonFlags(1024);
853}
854impl EMarketNotAllowedReasonFlags {
855 pub const k_EMarketNotAllowedReason_UsingNewDevice: EMarketNotAllowedReasonFlags =
856 EMarketNotAllowedReasonFlags(2048);
857}
858impl EMarketNotAllowedReasonFlags {
859 pub const k_EMarketNotAllowedReason_RecentSelfRefund: EMarketNotAllowedReasonFlags =
860 EMarketNotAllowedReasonFlags(4096);
861}
862impl EMarketNotAllowedReasonFlags {
863 pub const k_EMarketNotAllowedReason_NewPaymentMethodCannotBeVerified:
864 EMarketNotAllowedReasonFlags = EMarketNotAllowedReasonFlags(8192);
865}
866impl EMarketNotAllowedReasonFlags {
867 pub const k_EMarketNotAllowedReason_NoRecentPurchases: EMarketNotAllowedReasonFlags =
868 EMarketNotAllowedReasonFlags(16384);
869}
870impl EMarketNotAllowedReasonFlags {
871 pub const k_EMarketNotAllowedReason_AcceptedWalletGift: EMarketNotAllowedReasonFlags =
872 EMarketNotAllowedReasonFlags(32768);
873}
874impl EMarketNotAllowedReasonFlags {
875 pub const k_EMarketNotAllowedReason_TradeCooldown: EMarketNotAllowedReasonFlags =
876 EMarketNotAllowedReasonFlags(65536);
877}
878impl ::std::ops::BitOr<EMarketNotAllowedReasonFlags> for EMarketNotAllowedReasonFlags {
879 type Output = Self;
880 #[inline]
881 fn bitor(self, other: Self) -> Self {
882 EMarketNotAllowedReasonFlags(self.0 | other.0)
883 }
884}
885impl ::std::ops::BitOrAssign for EMarketNotAllowedReasonFlags {
886 #[inline]
887 fn bitor_assign(&mut self, rhs: EMarketNotAllowedReasonFlags) {
888 self.0 |= rhs.0;
889 }
890}
891impl ::std::ops::BitAnd<EMarketNotAllowedReasonFlags> for EMarketNotAllowedReasonFlags {
892 type Output = Self;
893 #[inline]
894 fn bitand(self, other: Self) -> Self {
895 EMarketNotAllowedReasonFlags(self.0 & other.0)
896 }
897}
898impl ::std::ops::BitAndAssign for EMarketNotAllowedReasonFlags {
899 #[inline]
900 fn bitand_assign(&mut self, rhs: EMarketNotAllowedReasonFlags) {
901 self.0 &= rhs.0;
902 }
903}
904#[repr(transparent)]
905#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
906pub struct EMarketNotAllowedReasonFlags(pub ::std::os::raw::c_uint);
907#[repr(u32)]
908#[non_exhaustive]
909#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
910pub enum EDurationControlProgress {
911 k_EDurationControlProgress_Full = 0,
912 k_EDurationControlProgress_Half = 1,
913 k_EDurationControlProgress_None = 2,
914 k_EDurationControl_ExitSoon_3h = 3,
915 k_EDurationControl_ExitSoon_5h = 4,
916 k_EDurationControl_ExitSoon_Night = 5,
917}
918#[repr(u32)]
919#[non_exhaustive]
920#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
921pub enum EDurationControlNotification {
922 k_EDurationControlNotification_None = 0,
923 k_EDurationControlNotification_1Hour = 1,
924 k_EDurationControlNotification_3Hours = 2,
925 k_EDurationControlNotification_HalfProgress = 3,
926 k_EDurationControlNotification_NoProgress = 4,
927 k_EDurationControlNotification_ExitSoon_3h = 5,
928 k_EDurationControlNotification_ExitSoon_5h = 6,
929 k_EDurationControlNotification_ExitSoon_Night = 7,
930}
931#[repr(u32)]
932#[non_exhaustive]
933#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
934pub enum EDurationControlOnlineState {
935 k_EDurationControlOnlineState_Invalid = 0,
936 k_EDurationControlOnlineState_Offline = 1,
937 k_EDurationControlOnlineState_Online = 2,
938 k_EDurationControlOnlineState_OnlineHighPri = 3,
939}
940impl EBetaBranchFlags {
941 pub const k_EBetaBranch_None: EBetaBranchFlags = EBetaBranchFlags(0);
942}
943impl EBetaBranchFlags {
944 pub const k_EBetaBranch_Default: EBetaBranchFlags = EBetaBranchFlags(1);
945}
946impl EBetaBranchFlags {
947 pub const k_EBetaBranch_Available: EBetaBranchFlags = EBetaBranchFlags(2);
948}
949impl EBetaBranchFlags {
950 pub const k_EBetaBranch_Private: EBetaBranchFlags = EBetaBranchFlags(4);
951}
952impl EBetaBranchFlags {
953 pub const k_EBetaBranch_Selected: EBetaBranchFlags = EBetaBranchFlags(8);
954}
955impl EBetaBranchFlags {
956 pub const k_EBetaBranch_Installed: EBetaBranchFlags = EBetaBranchFlags(16);
957}
958impl ::std::ops::BitOr<EBetaBranchFlags> for EBetaBranchFlags {
959 type Output = Self;
960 #[inline]
961 fn bitor(self, other: Self) -> Self {
962 EBetaBranchFlags(self.0 | other.0)
963 }
964}
965impl ::std::ops::BitOrAssign for EBetaBranchFlags {
966 #[inline]
967 fn bitor_assign(&mut self, rhs: EBetaBranchFlags) {
968 self.0 |= rhs.0;
969 }
970}
971impl ::std::ops::BitAnd<EBetaBranchFlags> for EBetaBranchFlags {
972 type Output = Self;
973 #[inline]
974 fn bitand(self, other: Self) -> Self {
975 EBetaBranchFlags(self.0 & other.0)
976 }
977}
978impl ::std::ops::BitAndAssign for EBetaBranchFlags {
979 #[inline]
980 fn bitand_assign(&mut self, rhs: EBetaBranchFlags) {
981 self.0 &= rhs.0;
982 }
983}
984#[repr(transparent)]
985#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
986pub struct EBetaBranchFlags(pub ::std::os::raw::c_uint);
987#[repr(C)]
988#[derive(Copy, Clone)]
989pub struct CSteamID {
990 pub m_steamid: CSteamID_SteamID_t,
991}
992#[repr(C, packed)]
993#[derive(Copy, Clone)]
994pub union CSteamID_SteamID_t {
995 pub m_comp: CSteamID_SteamID_t_SteamIDComponent_t,
996 pub m_unAll64Bits: uint64,
997}
998#[repr(C)]
999#[derive(Debug, Copy, Clone)]
1000pub struct CSteamID_SteamID_t_SteamIDComponent_t {
1001 pub _bitfield_align_1: [u8; 0],
1002 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1003}
1004#[test]
1005fn bindgen_test_layout_CSteamID_SteamID_t_SteamIDComponent_t() {
1006 assert_eq!(
1007 ::std::mem::size_of::<CSteamID_SteamID_t_SteamIDComponent_t>(),
1008 8usize,
1009 concat!(
1010 "Size of: ",
1011 stringify!(CSteamID_SteamID_t_SteamIDComponent_t)
1012 )
1013 );
1014 assert_eq!(
1015 ::std::mem::align_of::<CSteamID_SteamID_t_SteamIDComponent_t>(),
1016 1usize,
1017 concat!(
1018 "Alignment of ",
1019 stringify!(CSteamID_SteamID_t_SteamIDComponent_t)
1020 )
1021 );
1022}
1023impl CSteamID_SteamID_t_SteamIDComponent_t {
1024 #[inline]
1025 pub fn m_unAccountID(&self) -> uint32 {
1026 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 32u8) as u32) }
1027 }
1028 #[inline]
1029 pub fn set_m_unAccountID(&mut self, val: uint32) {
1030 unsafe {
1031 let val: u32 = ::std::mem::transmute(val);
1032 self._bitfield_1.set(0usize, 32u8, val as u64)
1033 }
1034 }
1035 #[inline]
1036 pub fn m_unAccountInstance(&self) -> ::std::os::raw::c_uint {
1037 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 20u8) as u32) }
1038 }
1039 #[inline]
1040 pub fn set_m_unAccountInstance(&mut self, val: ::std::os::raw::c_uint) {
1041 unsafe {
1042 let val: u32 = ::std::mem::transmute(val);
1043 self._bitfield_1.set(32usize, 20u8, val as u64)
1044 }
1045 }
1046 #[inline]
1047 pub fn m_EAccountType(&self) -> ::std::os::raw::c_uint {
1048 unsafe { ::std::mem::transmute(self._bitfield_1.get(52usize, 4u8) as u32) }
1049 }
1050 #[inline]
1051 pub fn set_m_EAccountType(&mut self, val: ::std::os::raw::c_uint) {
1052 unsafe {
1053 let val: u32 = ::std::mem::transmute(val);
1054 self._bitfield_1.set(52usize, 4u8, val as u64)
1055 }
1056 }
1057 #[inline]
1058 pub fn m_EUniverse(&self) -> EUniverse {
1059 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
1060 }
1061 #[inline]
1062 pub fn set_m_EUniverse(&mut self, val: EUniverse) {
1063 unsafe {
1064 let val: u32 = ::std::mem::transmute(val);
1065 self._bitfield_1.set(56usize, 8u8, val as u64)
1066 }
1067 }
1068 #[inline]
1069 pub fn new_bitfield_1(
1070 m_unAccountID: uint32,
1071 m_unAccountInstance: ::std::os::raw::c_uint,
1072 m_EAccountType: ::std::os::raw::c_uint,
1073 m_EUniverse: EUniverse,
1074 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1075 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1076 __bindgen_bitfield_unit.set(0usize, 32u8, {
1077 let m_unAccountID: u32 = unsafe { ::std::mem::transmute(m_unAccountID) };
1078 m_unAccountID as u64
1079 });
1080 __bindgen_bitfield_unit.set(32usize, 20u8, {
1081 let m_unAccountInstance: u32 = unsafe { ::std::mem::transmute(m_unAccountInstance) };
1082 m_unAccountInstance as u64
1083 });
1084 __bindgen_bitfield_unit.set(52usize, 4u8, {
1085 let m_EAccountType: u32 = unsafe { ::std::mem::transmute(m_EAccountType) };
1086 m_EAccountType as u64
1087 });
1088 __bindgen_bitfield_unit.set(56usize, 8u8, {
1089 let m_EUniverse: u32 = unsafe { ::std::mem::transmute(m_EUniverse) };
1090 m_EUniverse as u64
1091 });
1092 __bindgen_bitfield_unit
1093 }
1094}
1095#[test]
1096fn bindgen_test_layout_CSteamID_SteamID_t() {
1097 const UNINIT: ::std::mem::MaybeUninit<CSteamID_SteamID_t> = ::std::mem::MaybeUninit::uninit();
1098 let ptr = UNINIT.as_ptr();
1099 assert_eq!(
1100 ::std::mem::size_of::<CSteamID_SteamID_t>(),
1101 8usize,
1102 concat!("Size of: ", stringify!(CSteamID_SteamID_t))
1103 );
1104 assert_eq!(
1105 ::std::mem::align_of::<CSteamID_SteamID_t>(),
1106 1usize,
1107 concat!("Alignment of ", stringify!(CSteamID_SteamID_t))
1108 );
1109 assert_eq!(
1110 unsafe { ::std::ptr::addr_of!((*ptr).m_comp) as usize - ptr as usize },
1111 0usize,
1112 concat!(
1113 "Offset of field: ",
1114 stringify!(CSteamID_SteamID_t),
1115 "::",
1116 stringify!(m_comp)
1117 )
1118 );
1119 assert_eq!(
1120 unsafe { ::std::ptr::addr_of!((*ptr).m_unAll64Bits) as usize - ptr as usize },
1121 0usize,
1122 concat!(
1123 "Offset of field: ",
1124 stringify!(CSteamID_SteamID_t),
1125 "::",
1126 stringify!(m_unAll64Bits)
1127 )
1128 );
1129}
1130#[test]
1131fn bindgen_test_layout_CSteamID() {
1132 const UNINIT: ::std::mem::MaybeUninit<CSteamID> = ::std::mem::MaybeUninit::uninit();
1133 let ptr = UNINIT.as_ptr();
1134 assert_eq!(
1135 ::std::mem::size_of::<CSteamID>(),
1136 8usize,
1137 concat!("Size of: ", stringify!(CSteamID))
1138 );
1139 assert_eq!(
1140 ::std::mem::align_of::<CSteamID>(),
1141 1usize,
1142 concat!("Alignment of ", stringify!(CSteamID))
1143 );
1144 assert_eq!(
1145 unsafe { ::std::ptr::addr_of!((*ptr).m_steamid) as usize - ptr as usize },
1146 0usize,
1147 concat!(
1148 "Offset of field: ",
1149 stringify!(CSteamID),
1150 "::",
1151 stringify!(m_steamid)
1152 )
1153 );
1154}
1155extern "C" {
1156 #[link_name = "\u{1}_ZNK8CSteamID6RenderEv"]
1157 pub fn CSteamID_Render(this: *const CSteamID) -> *const ::std::os::raw::c_char;
1158}
1159extern "C" {
1160 #[link_name = "\u{1}_ZN8CSteamID6RenderEy"]
1161 pub fn CSteamID_Render1(ulSteamID: uint64) -> *const ::std::os::raw::c_char;
1162}
1163extern "C" {
1164 #[link_name = "\u{1}_ZN8CSteamID13SetFromStringEPKc9EUniverse"]
1165 pub fn CSteamID_SetFromString(
1166 this: *mut CSteamID,
1167 pchSteamID: *const ::std::os::raw::c_char,
1168 eDefaultUniverse: EUniverse,
1169 );
1170}
1171extern "C" {
1172 #[link_name = "\u{1}_ZN8CSteamID19SetFromStringStrictEPKc9EUniverse"]
1173 pub fn CSteamID_SetFromStringStrict(
1174 this: *mut CSteamID,
1175 pchSteamID: *const ::std::os::raw::c_char,
1176 eDefaultUniverse: EUniverse,
1177 ) -> bool;
1178}
1179extern "C" {
1180 #[link_name = "\u{1}_ZNK8CSteamID21BValidExternalSteamIDEv"]
1181 pub fn CSteamID_BValidExternalSteamID(this: *const CSteamID) -> bool;
1182}
1183extern "C" {
1184 #[link_name = "\u{1}_ZN8CSteamIDC1EPKc9EUniverse"]
1185 pub fn CSteamID_CSteamID(
1186 this: *mut CSteamID,
1187 pchSteamID: *const ::std::os::raw::c_char,
1188 eDefaultUniverse: EUniverse,
1189 );
1190}
1191impl CSteamID {
1192 #[inline]
1193 pub unsafe fn Render(&self) -> *const ::std::os::raw::c_char {
1194 CSteamID_Render(self)
1195 }
1196 #[inline]
1197 pub unsafe fn Render1(ulSteamID: uint64) -> *const ::std::os::raw::c_char {
1198 CSteamID_Render1(ulSteamID)
1199 }
1200 #[inline]
1201 pub unsafe fn SetFromString(
1202 &mut self,
1203 pchSteamID: *const ::std::os::raw::c_char,
1204 eDefaultUniverse: EUniverse,
1205 ) {
1206 CSteamID_SetFromString(self, pchSteamID, eDefaultUniverse)
1207 }
1208 #[inline]
1209 pub unsafe fn SetFromStringStrict(
1210 &mut self,
1211 pchSteamID: *const ::std::os::raw::c_char,
1212 eDefaultUniverse: EUniverse,
1213 ) -> bool {
1214 CSteamID_SetFromStringStrict(self, pchSteamID, eDefaultUniverse)
1215 }
1216 #[inline]
1217 pub unsafe fn BValidExternalSteamID(&self) -> bool {
1218 CSteamID_BValidExternalSteamID(self)
1219 }
1220 #[inline]
1221 pub unsafe fn new(
1222 pchSteamID: *const ::std::os::raw::c_char,
1223 eDefaultUniverse: EUniverse,
1224 ) -> Self {
1225 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
1226 CSteamID_CSteamID(__bindgen_tmp.as_mut_ptr(), pchSteamID, eDefaultUniverse);
1227 __bindgen_tmp.assume_init()
1228 }
1229}
1230#[repr(C)]
1231#[derive(Copy, Clone)]
1232pub struct CGameID {
1233 pub __bindgen_anon_1: CGameID__bindgen_ty_1,
1234}
1235#[repr(u32)]
1236#[non_exhaustive]
1237#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1238pub enum CGameID_EGameIDType {
1239 k_EGameIDTypeApp = 0,
1240 k_EGameIDTypeGameMod = 1,
1241 k_EGameIDTypeShortcut = 2,
1242 k_EGameIDTypeP2P = 3,
1243}
1244#[repr(C)]
1245#[derive(Debug, Copy, Clone)]
1246pub struct CGameID_GameID_t {
1247 pub _bitfield_align_1: [u8; 0],
1248 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
1249}
1250#[test]
1251fn bindgen_test_layout_CGameID_GameID_t() {
1252 assert_eq!(
1253 ::std::mem::size_of::<CGameID_GameID_t>(),
1254 8usize,
1255 concat!("Size of: ", stringify!(CGameID_GameID_t))
1256 );
1257 assert_eq!(
1258 ::std::mem::align_of::<CGameID_GameID_t>(),
1259 1usize,
1260 concat!("Alignment of ", stringify!(CGameID_GameID_t))
1261 );
1262}
1263impl CGameID_GameID_t {
1264 #[inline]
1265 pub fn m_nAppID(&self) -> ::std::os::raw::c_uint {
1266 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
1267 }
1268 #[inline]
1269 pub fn set_m_nAppID(&mut self, val: ::std::os::raw::c_uint) {
1270 unsafe {
1271 let val: u32 = ::std::mem::transmute(val);
1272 self._bitfield_1.set(0usize, 24u8, val as u64)
1273 }
1274 }
1275 #[inline]
1276 pub fn m_nType(&self) -> ::std::os::raw::c_uint {
1277 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
1278 }
1279 #[inline]
1280 pub fn set_m_nType(&mut self, val: ::std::os::raw::c_uint) {
1281 unsafe {
1282 let val: u32 = ::std::mem::transmute(val);
1283 self._bitfield_1.set(24usize, 8u8, val as u64)
1284 }
1285 }
1286 #[inline]
1287 pub fn m_nModID(&self) -> ::std::os::raw::c_uint {
1288 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 32u8) as u32) }
1289 }
1290 #[inline]
1291 pub fn set_m_nModID(&mut self, val: ::std::os::raw::c_uint) {
1292 unsafe {
1293 let val: u32 = ::std::mem::transmute(val);
1294 self._bitfield_1.set(32usize, 32u8, val as u64)
1295 }
1296 }
1297 #[inline]
1298 pub fn new_bitfield_1(
1299 m_nAppID: ::std::os::raw::c_uint,
1300 m_nType: ::std::os::raw::c_uint,
1301 m_nModID: ::std::os::raw::c_uint,
1302 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
1303 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
1304 __bindgen_bitfield_unit.set(0usize, 24u8, {
1305 let m_nAppID: u32 = unsafe { ::std::mem::transmute(m_nAppID) };
1306 m_nAppID as u64
1307 });
1308 __bindgen_bitfield_unit.set(24usize, 8u8, {
1309 let m_nType: u32 = unsafe { ::std::mem::transmute(m_nType) };
1310 m_nType as u64
1311 });
1312 __bindgen_bitfield_unit.set(32usize, 32u8, {
1313 let m_nModID: u32 = unsafe { ::std::mem::transmute(m_nModID) };
1314 m_nModID as u64
1315 });
1316 __bindgen_bitfield_unit
1317 }
1318}
1319#[repr(C, packed)]
1320#[derive(Copy, Clone)]
1321pub union CGameID__bindgen_ty_1 {
1322 pub m_ulGameID: uint64,
1323 pub m_gameID: CGameID_GameID_t,
1324}
1325#[test]
1326fn bindgen_test_layout_CGameID__bindgen_ty_1() {
1327 const UNINIT: ::std::mem::MaybeUninit<CGameID__bindgen_ty_1> =
1328 ::std::mem::MaybeUninit::uninit();
1329 let ptr = UNINIT.as_ptr();
1330 assert_eq!(
1331 ::std::mem::size_of::<CGameID__bindgen_ty_1>(),
1332 8usize,
1333 concat!("Size of: ", stringify!(CGameID__bindgen_ty_1))
1334 );
1335 assert_eq!(
1336 ::std::mem::align_of::<CGameID__bindgen_ty_1>(),
1337 1usize,
1338 concat!("Alignment of ", stringify!(CGameID__bindgen_ty_1))
1339 );
1340 assert_eq!(
1341 unsafe { ::std::ptr::addr_of!((*ptr).m_ulGameID) as usize - ptr as usize },
1342 0usize,
1343 concat!(
1344 "Offset of field: ",
1345 stringify!(CGameID__bindgen_ty_1),
1346 "::",
1347 stringify!(m_ulGameID)
1348 )
1349 );
1350 assert_eq!(
1351 unsafe { ::std::ptr::addr_of!((*ptr).m_gameID) as usize - ptr as usize },
1352 0usize,
1353 concat!(
1354 "Offset of field: ",
1355 stringify!(CGameID__bindgen_ty_1),
1356 "::",
1357 stringify!(m_gameID)
1358 )
1359 );
1360}
1361#[test]
1362fn bindgen_test_layout_CGameID() {
1363 assert_eq!(
1364 ::std::mem::size_of::<CGameID>(),
1365 8usize,
1366 concat!("Size of: ", stringify!(CGameID))
1367 );
1368 assert_eq!(
1369 ::std::mem::align_of::<CGameID>(),
1370 1usize,
1371 concat!("Alignment of ", stringify!(CGameID))
1372 );
1373}
1374extern "C" {
1375 #[link_name = "\u{1}_ZNK7CGameID6RenderEv"]
1376 pub fn CGameID_Render(this: *const CGameID) -> *const ::std::os::raw::c_char;
1377}
1378extern "C" {
1379 #[link_name = "\u{1}_ZN7CGameID6RenderEy"]
1380 pub fn CGameID_Render1(ulGameID: uint64) -> *const ::std::os::raw::c_char;
1381}
1382extern "C" {
1383 #[link_name = "\u{1}_ZN7CGameIDC1EPKc"]
1384 pub fn CGameID_CGameID(this: *mut CGameID, pchGameID: *const ::std::os::raw::c_char);
1385}
1386impl CGameID {
1387 #[inline]
1388 pub unsafe fn Render(&self) -> *const ::std::os::raw::c_char {
1389 CGameID_Render(self)
1390 }
1391 #[inline]
1392 pub unsafe fn Render1(ulGameID: uint64) -> *const ::std::os::raw::c_char {
1393 CGameID_Render1(ulGameID)
1394 }
1395 #[inline]
1396 pub unsafe fn new(pchGameID: *const ::std::os::raw::c_char) -> Self {
1397 let mut __bindgen_tmp = ::std::mem::MaybeUninit::uninit();
1398 CGameID_CGameID(__bindgen_tmp.as_mut_ptr(), pchGameID);
1399 __bindgen_tmp.assume_init()
1400 }
1401}
1402pub const k_cchGameExtraInfoMax: ::std::os::raw::c_int = 64;
1403pub type PFNPreMinidumpCallback =
1404 ::std::option::Option<unsafe extern "C" fn(context: *mut ::std::os::raw::c_void)>;
1405#[repr(u32)]
1406#[non_exhaustive]
1407#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1408pub enum ESteamIPv6ConnectivityProtocol {
1409 k_ESteamIPv6ConnectivityProtocol_Invalid = 0,
1410 k_ESteamIPv6ConnectivityProtocol_HTTP = 1,
1411 k_ESteamIPv6ConnectivityProtocol_UDP = 2,
1412}
1413#[repr(u32)]
1414#[non_exhaustive]
1415#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1416pub enum ESteamIPv6ConnectivityState {
1417 k_ESteamIPv6ConnectivityState_Unknown = 0,
1418 k_ESteamIPv6ConnectivityState_Good = 1,
1419 k_ESteamIPv6ConnectivityState_Bad = 2,
1420}
1421#[repr(C, packed(4))]
1422#[derive(Debug, Copy, Clone)]
1423pub struct ValvePackingSentinel_t {
1424 pub m_u32: uint32,
1425 pub m_u64: uint64,
1426 pub m_u16: uint16,
1427 pub m_d: f64,
1428}
1429#[test]
1430fn bindgen_test_layout_ValvePackingSentinel_t() {
1431 const UNINIT: ::std::mem::MaybeUninit<ValvePackingSentinel_t> =
1432 ::std::mem::MaybeUninit::uninit();
1433 let ptr = UNINIT.as_ptr();
1434 assert_eq!(
1435 ::std::mem::size_of::<ValvePackingSentinel_t>(),
1436 24usize,
1437 concat!("Size of: ", stringify!(ValvePackingSentinel_t))
1438 );
1439 assert_eq!(
1440 ::std::mem::align_of::<ValvePackingSentinel_t>(),
1441 4usize,
1442 concat!("Alignment of ", stringify!(ValvePackingSentinel_t))
1443 );
1444 assert_eq!(
1445 unsafe { ::std::ptr::addr_of!((*ptr).m_u32) as usize - ptr as usize },
1446 0usize,
1447 concat!(
1448 "Offset of field: ",
1449 stringify!(ValvePackingSentinel_t),
1450 "::",
1451 stringify!(m_u32)
1452 )
1453 );
1454 assert_eq!(
1455 unsafe { ::std::ptr::addr_of!((*ptr).m_u64) as usize - ptr as usize },
1456 4usize,
1457 concat!(
1458 "Offset of field: ",
1459 stringify!(ValvePackingSentinel_t),
1460 "::",
1461 stringify!(m_u64)
1462 )
1463 );
1464 assert_eq!(
1465 unsafe { ::std::ptr::addr_of!((*ptr).m_u16) as usize - ptr as usize },
1466 12usize,
1467 concat!(
1468 "Offset of field: ",
1469 stringify!(ValvePackingSentinel_t),
1470 "::",
1471 stringify!(m_u16)
1472 )
1473 );
1474 assert_eq!(
1475 unsafe { ::std::ptr::addr_of!((*ptr).m_d) as usize - ptr as usize },
1476 16usize,
1477 concat!(
1478 "Offset of field: ",
1479 stringify!(ValvePackingSentinel_t),
1480 "::",
1481 stringify!(m_d)
1482 )
1483 );
1484}
1485pub type compile_time_assert_type = [::std::os::raw::c_char; 1usize];
1486pub type HSteamPipe = int32;
1487pub type HSteamUser = int32;
1488pub const k_cchMaxSteamErrMsg: ::std::os::raw::c_int = 1024;
1489pub type SteamErrMsg = [::std::os::raw::c_char; 1024usize];
1490pub type SteamAPIWarningMessageHook_t = ::std::option::Option<
1491 unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char),
1492>;
1493pub type SteamAPI_CheckCallbackRegistered_t =
1494 ::std::option::Option<unsafe extern "C" fn(iCallbackNum: ::std::os::raw::c_int) -> uint32>;
1495extern "C" {
1496 pub fn SteamAPI_RunCallbacks();
1497}
1498extern "C" {
1499 pub fn SteamGameServer_RunCallbacks();
1500}
1501#[repr(C)]
1502pub struct CCallbackBase__bindgen_vtable(::std::os::raw::c_void);
1503#[repr(C)]
1504#[derive(Debug, Copy, Clone)]
1505pub struct CCallbackBase {
1506 pub vtable_: *const CCallbackBase__bindgen_vtable,
1507 pub m_nCallbackFlags: uint8,
1508 pub m_iCallback: ::std::os::raw::c_int,
1509}
1510pub const CCallbackBase_k_ECallbackFlagsRegistered: CCallbackBase__bindgen_ty_1 =
1511 CCallbackBase__bindgen_ty_1::k_ECallbackFlagsRegistered;
1512pub const CCallbackBase_k_ECallbackFlagsGameServer: CCallbackBase__bindgen_ty_1 =
1513 CCallbackBase__bindgen_ty_1::k_ECallbackFlagsGameServer;
1514#[repr(u32)]
1515#[non_exhaustive]
1516#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1517pub enum CCallbackBase__bindgen_ty_1 {
1518 k_ECallbackFlagsRegistered = 1,
1519 k_ECallbackFlagsGameServer = 2,
1520}
1521#[test]
1522fn bindgen_test_layout_CCallbackBase() {
1523 const UNINIT: ::std::mem::MaybeUninit<CCallbackBase> = ::std::mem::MaybeUninit::uninit();
1524 let ptr = UNINIT.as_ptr();
1525 assert_eq!(
1526 ::std::mem::size_of::<CCallbackBase>(),
1527 16usize,
1528 concat!("Size of: ", stringify!(CCallbackBase))
1529 );
1530 assert_eq!(
1531 ::std::mem::align_of::<CCallbackBase>(),
1532 8usize,
1533 concat!("Alignment of ", stringify!(CCallbackBase))
1534 );
1535 assert_eq!(
1536 unsafe { ::std::ptr::addr_of!((*ptr).m_nCallbackFlags) as usize - ptr as usize },
1537 8usize,
1538 concat!(
1539 "Offset of field: ",
1540 stringify!(CCallbackBase),
1541 "::",
1542 stringify!(m_nCallbackFlags)
1543 )
1544 );
1545 assert_eq!(
1546 unsafe { ::std::ptr::addr_of!((*ptr).m_iCallback) as usize - ptr as usize },
1547 12usize,
1548 concat!(
1549 "Offset of field: ",
1550 stringify!(CCallbackBase),
1551 "::",
1552 stringify!(m_iCallback)
1553 )
1554 );
1555}
1556#[repr(C)]
1557#[derive(Debug)]
1558pub struct CCallResult<T, P> {
1559 pub _base: CCallbackBase,
1560 pub m_hAPICall: SteamAPICall_t,
1561 pub m_pObj: *mut T,
1562 pub m_Func: CCallResult_func_t<P>,
1563 pub _phantom_0: ::std::marker::PhantomData<::std::cell::UnsafeCell<T>>,
1564 pub _phantom_1: ::std::marker::PhantomData<::std::cell::UnsafeCell<P>>,
1565}
1566pub type CCallResult_func_t<P> =
1567 ::std::option::Option<unsafe extern "C" fn(arg1: *mut P, arg2: bool)>;
1568pub type CCallback_func_t<P> = ::std::option::Option<unsafe extern "C" fn(arg1: *mut P)>;
1569#[repr(C)]
1570#[derive(Debug, Copy, Clone)]
1571pub struct __locale_struct {
1572 pub __locales: [*mut __locale_data; 13usize],
1573 pub __ctype_b: *const ::std::os::raw::c_ushort,
1574 pub __ctype_tolower: *const ::std::os::raw::c_int,
1575 pub __ctype_toupper: *const ::std::os::raw::c_int,
1576 pub __names: [*const ::std::os::raw::c_char; 13usize],
1577}
1578#[test]
1579fn bindgen_test_layout___locale_struct() {
1580 const UNINIT: ::std::mem::MaybeUninit<__locale_struct> = ::std::mem::MaybeUninit::uninit();
1581 let ptr = UNINIT.as_ptr();
1582 assert_eq!(
1583 ::std::mem::size_of::<__locale_struct>(),
1584 232usize,
1585 concat!("Size of: ", stringify!(__locale_struct))
1586 );
1587 assert_eq!(
1588 ::std::mem::align_of::<__locale_struct>(),
1589 8usize,
1590 concat!("Alignment of ", stringify!(__locale_struct))
1591 );
1592 assert_eq!(
1593 unsafe { ::std::ptr::addr_of!((*ptr).__locales) as usize - ptr as usize },
1594 0usize,
1595 concat!(
1596 "Offset of field: ",
1597 stringify!(__locale_struct),
1598 "::",
1599 stringify!(__locales)
1600 )
1601 );
1602 assert_eq!(
1603 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_b) as usize - ptr as usize },
1604 104usize,
1605 concat!(
1606 "Offset of field: ",
1607 stringify!(__locale_struct),
1608 "::",
1609 stringify!(__ctype_b)
1610 )
1611 );
1612 assert_eq!(
1613 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_tolower) as usize - ptr as usize },
1614 112usize,
1615 concat!(
1616 "Offset of field: ",
1617 stringify!(__locale_struct),
1618 "::",
1619 stringify!(__ctype_tolower)
1620 )
1621 );
1622 assert_eq!(
1623 unsafe { ::std::ptr::addr_of!((*ptr).__ctype_toupper) as usize - ptr as usize },
1624 120usize,
1625 concat!(
1626 "Offset of field: ",
1627 stringify!(__locale_struct),
1628 "::",
1629 stringify!(__ctype_toupper)
1630 )
1631 );
1632 assert_eq!(
1633 unsafe { ::std::ptr::addr_of!((*ptr).__names) as usize - ptr as usize },
1634 128usize,
1635 concat!(
1636 "Offset of field: ",
1637 stringify!(__locale_struct),
1638 "::",
1639 stringify!(__names)
1640 )
1641 );
1642}
1643pub type __locale_t = *mut __locale_struct;
1644pub type locale_t = __locale_t;
1645extern "C" {
1646 pub fn SteamAPI_GetHSteamPipe() -> HSteamPipe;
1647}
1648extern "C" {
1649 pub fn SteamAPI_GetHSteamUser() -> HSteamUser;
1650}
1651extern "C" {
1652 pub fn SteamGameServer_GetHSteamPipe() -> HSteamPipe;
1653}
1654extern "C" {
1655 pub fn SteamGameServer_GetHSteamUser() -> HSteamUser;
1656}
1657extern "C" {
1658 pub fn SteamInternal_ContextInit(
1659 pContextInitData: *mut ::std::os::raw::c_void,
1660 ) -> *mut ::std::os::raw::c_void;
1661}
1662extern "C" {
1663 pub fn SteamInternal_CreateInterface(
1664 ver: *const ::std::os::raw::c_char,
1665 ) -> *mut ::std::os::raw::c_void;
1666}
1667extern "C" {
1668 pub fn SteamInternal_FindOrCreateUserInterface(
1669 hSteamUser: HSteamUser,
1670 pszVersion: *const ::std::os::raw::c_char,
1671 ) -> *mut ::std::os::raw::c_void;
1672}
1673extern "C" {
1674 pub fn SteamInternal_FindOrCreateGameServerInterface(
1675 hSteamUser: HSteamUser,
1676 pszVersion: *const ::std::os::raw::c_char,
1677 ) -> *mut ::std::os::raw::c_void;
1678}
1679extern "C" {
1680 pub fn SteamAPI_RegisterCallback(
1681 pCallback: *mut CCallbackBase,
1682 iCallback: ::std::os::raw::c_int,
1683 );
1684}
1685extern "C" {
1686 pub fn SteamAPI_UnregisterCallback(pCallback: *mut CCallbackBase);
1687}
1688extern "C" {
1689 pub fn SteamAPI_RegisterCallResult(pCallback: *mut CCallbackBase, hAPICall: SteamAPICall_t);
1690}
1691extern "C" {
1692 pub fn SteamAPI_UnregisterCallResult(pCallback: *mut CCallbackBase, hAPICall: SteamAPICall_t);
1693}
1694#[doc = " Internal structure used in manual callback dispatch"]
1695#[repr(C, packed(4))]
1696#[derive(Debug, Copy, Clone)]
1697pub struct CallbackMsg_t {
1698 pub m_hSteamUser: HSteamUser,
1699 pub m_iCallback: ::std::os::raw::c_int,
1700 pub m_pubParam: *mut uint8,
1701 pub m_cubParam: ::std::os::raw::c_int,
1702}
1703#[test]
1704fn bindgen_test_layout_CallbackMsg_t() {
1705 const UNINIT: ::std::mem::MaybeUninit<CallbackMsg_t> = ::std::mem::MaybeUninit::uninit();
1706 let ptr = UNINIT.as_ptr();
1707 assert_eq!(
1708 ::std::mem::size_of::<CallbackMsg_t>(),
1709 20usize,
1710 concat!("Size of: ", stringify!(CallbackMsg_t))
1711 );
1712 assert_eq!(
1713 ::std::mem::align_of::<CallbackMsg_t>(),
1714 4usize,
1715 concat!("Alignment of ", stringify!(CallbackMsg_t))
1716 );
1717 assert_eq!(
1718 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamUser) as usize - ptr as usize },
1719 0usize,
1720 concat!(
1721 "Offset of field: ",
1722 stringify!(CallbackMsg_t),
1723 "::",
1724 stringify!(m_hSteamUser)
1725 )
1726 );
1727 assert_eq!(
1728 unsafe { ::std::ptr::addr_of!((*ptr).m_iCallback) as usize - ptr as usize },
1729 4usize,
1730 concat!(
1731 "Offset of field: ",
1732 stringify!(CallbackMsg_t),
1733 "::",
1734 stringify!(m_iCallback)
1735 )
1736 );
1737 assert_eq!(
1738 unsafe { ::std::ptr::addr_of!((*ptr).m_pubParam) as usize - ptr as usize },
1739 8usize,
1740 concat!(
1741 "Offset of field: ",
1742 stringify!(CallbackMsg_t),
1743 "::",
1744 stringify!(m_pubParam)
1745 )
1746 );
1747 assert_eq!(
1748 unsafe { ::std::ptr::addr_of!((*ptr).m_cubParam) as usize - ptr as usize },
1749 16usize,
1750 concat!(
1751 "Offset of field: ",
1752 stringify!(CallbackMsg_t),
1753 "::",
1754 stringify!(m_cubParam)
1755 )
1756 );
1757}
1758#[repr(C)]
1759#[derive(Debug, Copy, Clone)]
1760pub struct ISteamContentServer {
1761 _unused: [u8; 0],
1762}
1763pub const k_iSteamUserCallbacks: _bindgen_ty_1 = _bindgen_ty_1::k_iSteamUserCallbacks;
1764#[repr(u32)]
1765#[non_exhaustive]
1766#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1767pub enum _bindgen_ty_1 {
1768 k_iSteamUserCallbacks = 100,
1769}
1770pub const k_iSteamGameServerCallbacks: _bindgen_ty_2 = _bindgen_ty_2::k_iSteamGameServerCallbacks;
1771#[repr(u32)]
1772#[non_exhaustive]
1773#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1774pub enum _bindgen_ty_2 {
1775 k_iSteamGameServerCallbacks = 200,
1776}
1777pub const k_iSteamFriendsCallbacks: _bindgen_ty_3 = _bindgen_ty_3::k_iSteamFriendsCallbacks;
1778#[repr(u32)]
1779#[non_exhaustive]
1780#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1781pub enum _bindgen_ty_3 {
1782 k_iSteamFriendsCallbacks = 300,
1783}
1784pub const k_iSteamBillingCallbacks: _bindgen_ty_4 = _bindgen_ty_4::k_iSteamBillingCallbacks;
1785#[repr(u32)]
1786#[non_exhaustive]
1787#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1788pub enum _bindgen_ty_4 {
1789 k_iSteamBillingCallbacks = 400,
1790}
1791pub const k_iSteamMatchmakingCallbacks: _bindgen_ty_5 = _bindgen_ty_5::k_iSteamMatchmakingCallbacks;
1792#[repr(u32)]
1793#[non_exhaustive]
1794#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1795pub enum _bindgen_ty_5 {
1796 k_iSteamMatchmakingCallbacks = 500,
1797}
1798pub const k_iSteamContentServerCallbacks: _bindgen_ty_6 =
1799 _bindgen_ty_6::k_iSteamContentServerCallbacks;
1800#[repr(u32)]
1801#[non_exhaustive]
1802#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1803pub enum _bindgen_ty_6 {
1804 k_iSteamContentServerCallbacks = 600,
1805}
1806pub const k_iSteamUtilsCallbacks: _bindgen_ty_7 = _bindgen_ty_7::k_iSteamUtilsCallbacks;
1807#[repr(u32)]
1808#[non_exhaustive]
1809#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1810pub enum _bindgen_ty_7 {
1811 k_iSteamUtilsCallbacks = 700,
1812}
1813pub const k_iSteamAppsCallbacks: _bindgen_ty_8 = _bindgen_ty_8::k_iSteamAppsCallbacks;
1814#[repr(u32)]
1815#[non_exhaustive]
1816#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1817pub enum _bindgen_ty_8 {
1818 k_iSteamAppsCallbacks = 1000,
1819}
1820pub const k_iSteamUserStatsCallbacks: _bindgen_ty_9 = _bindgen_ty_9::k_iSteamUserStatsCallbacks;
1821#[repr(u32)]
1822#[non_exhaustive]
1823#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1824pub enum _bindgen_ty_9 {
1825 k_iSteamUserStatsCallbacks = 1100,
1826}
1827pub const k_iSteamNetworkingCallbacks: _bindgen_ty_10 = _bindgen_ty_10::k_iSteamNetworkingCallbacks;
1828#[repr(u32)]
1829#[non_exhaustive]
1830#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1831pub enum _bindgen_ty_10 {
1832 k_iSteamNetworkingCallbacks = 1200,
1833}
1834pub const k_iSteamNetworkingSocketsCallbacks: _bindgen_ty_11 =
1835 _bindgen_ty_11::k_iSteamNetworkingSocketsCallbacks;
1836#[repr(u32)]
1837#[non_exhaustive]
1838#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1839pub enum _bindgen_ty_11 {
1840 k_iSteamNetworkingSocketsCallbacks = 1220,
1841}
1842pub const k_iSteamNetworkingMessagesCallbacks: _bindgen_ty_12 =
1843 _bindgen_ty_12::k_iSteamNetworkingMessagesCallbacks;
1844#[repr(u32)]
1845#[non_exhaustive]
1846#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1847pub enum _bindgen_ty_12 {
1848 k_iSteamNetworkingMessagesCallbacks = 1250,
1849}
1850pub const k_iSteamNetworkingUtilsCallbacks: _bindgen_ty_13 =
1851 _bindgen_ty_13::k_iSteamNetworkingUtilsCallbacks;
1852#[repr(u32)]
1853#[non_exhaustive]
1854#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1855pub enum _bindgen_ty_13 {
1856 k_iSteamNetworkingUtilsCallbacks = 1280,
1857}
1858pub const k_iSteamRemoteStorageCallbacks: _bindgen_ty_14 =
1859 _bindgen_ty_14::k_iSteamRemoteStorageCallbacks;
1860#[repr(u32)]
1861#[non_exhaustive]
1862#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1863pub enum _bindgen_ty_14 {
1864 k_iSteamRemoteStorageCallbacks = 1300,
1865}
1866pub const k_iSteamGameServerItemsCallbacks: _bindgen_ty_15 =
1867 _bindgen_ty_15::k_iSteamGameServerItemsCallbacks;
1868#[repr(u32)]
1869#[non_exhaustive]
1870#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1871pub enum _bindgen_ty_15 {
1872 k_iSteamGameServerItemsCallbacks = 1500,
1873}
1874pub const k_iSteamGameCoordinatorCallbacks: _bindgen_ty_16 =
1875 _bindgen_ty_16::k_iSteamGameCoordinatorCallbacks;
1876#[repr(u32)]
1877#[non_exhaustive]
1878#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1879pub enum _bindgen_ty_16 {
1880 k_iSteamGameCoordinatorCallbacks = 1700,
1881}
1882pub const k_iSteamGameServerStatsCallbacks: _bindgen_ty_17 =
1883 _bindgen_ty_17::k_iSteamGameServerStatsCallbacks;
1884#[repr(u32)]
1885#[non_exhaustive]
1886#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1887pub enum _bindgen_ty_17 {
1888 k_iSteamGameServerStatsCallbacks = 1800,
1889}
1890pub const k_iSteam2AsyncCallbacks: _bindgen_ty_18 = _bindgen_ty_18::k_iSteam2AsyncCallbacks;
1891#[repr(u32)]
1892#[non_exhaustive]
1893#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1894pub enum _bindgen_ty_18 {
1895 k_iSteam2AsyncCallbacks = 1900,
1896}
1897pub const k_iSteamGameStatsCallbacks: _bindgen_ty_19 = _bindgen_ty_19::k_iSteamGameStatsCallbacks;
1898#[repr(u32)]
1899#[non_exhaustive]
1900#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1901pub enum _bindgen_ty_19 {
1902 k_iSteamGameStatsCallbacks = 2000,
1903}
1904pub const k_iSteamHTTPCallbacks: _bindgen_ty_20 = _bindgen_ty_20::k_iSteamHTTPCallbacks;
1905#[repr(u32)]
1906#[non_exhaustive]
1907#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1908pub enum _bindgen_ty_20 {
1909 k_iSteamHTTPCallbacks = 2100,
1910}
1911pub const k_iSteamScreenshotsCallbacks: _bindgen_ty_21 =
1912 _bindgen_ty_21::k_iSteamScreenshotsCallbacks;
1913#[repr(u32)]
1914#[non_exhaustive]
1915#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1916pub enum _bindgen_ty_21 {
1917 k_iSteamScreenshotsCallbacks = 2300,
1918}
1919pub const k_iSteamStreamLauncherCallbacks: _bindgen_ty_22 =
1920 _bindgen_ty_22::k_iSteamStreamLauncherCallbacks;
1921#[repr(u32)]
1922#[non_exhaustive]
1923#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1924pub enum _bindgen_ty_22 {
1925 k_iSteamStreamLauncherCallbacks = 2600,
1926}
1927pub const k_iSteamControllerCallbacks: _bindgen_ty_23 = _bindgen_ty_23::k_iSteamControllerCallbacks;
1928#[repr(u32)]
1929#[non_exhaustive]
1930#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1931pub enum _bindgen_ty_23 {
1932 k_iSteamControllerCallbacks = 2800,
1933}
1934pub const k_iSteamUGCCallbacks: _bindgen_ty_24 = _bindgen_ty_24::k_iSteamUGCCallbacks;
1935#[repr(u32)]
1936#[non_exhaustive]
1937#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1938pub enum _bindgen_ty_24 {
1939 k_iSteamUGCCallbacks = 3400,
1940}
1941pub const k_iSteamStreamClientCallbacks: _bindgen_ty_25 =
1942 _bindgen_ty_25::k_iSteamStreamClientCallbacks;
1943#[repr(u32)]
1944#[non_exhaustive]
1945#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1946pub enum _bindgen_ty_25 {
1947 k_iSteamStreamClientCallbacks = 3500,
1948}
1949pub const k_iSteamMusicCallbacks: _bindgen_ty_26 = _bindgen_ty_26::k_iSteamMusicCallbacks;
1950#[repr(u32)]
1951#[non_exhaustive]
1952#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1953pub enum _bindgen_ty_26 {
1954 k_iSteamMusicCallbacks = 4000,
1955}
1956pub const k_iSteamGameNotificationCallbacks: _bindgen_ty_27 =
1957 _bindgen_ty_27::k_iSteamGameNotificationCallbacks;
1958#[repr(u32)]
1959#[non_exhaustive]
1960#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1961pub enum _bindgen_ty_27 {
1962 k_iSteamGameNotificationCallbacks = 4400,
1963}
1964pub const k_iSteamHTMLSurfaceCallbacks: _bindgen_ty_28 =
1965 _bindgen_ty_28::k_iSteamHTMLSurfaceCallbacks;
1966#[repr(u32)]
1967#[non_exhaustive]
1968#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1969pub enum _bindgen_ty_28 {
1970 k_iSteamHTMLSurfaceCallbacks = 4500,
1971}
1972pub const k_iSteamVideoCallbacks: _bindgen_ty_29 = _bindgen_ty_29::k_iSteamVideoCallbacks;
1973#[repr(u32)]
1974#[non_exhaustive]
1975#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1976pub enum _bindgen_ty_29 {
1977 k_iSteamVideoCallbacks = 4600,
1978}
1979pub const k_iSteamInventoryCallbacks: _bindgen_ty_30 = _bindgen_ty_30::k_iSteamInventoryCallbacks;
1980#[repr(u32)]
1981#[non_exhaustive]
1982#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1983pub enum _bindgen_ty_30 {
1984 k_iSteamInventoryCallbacks = 4700,
1985}
1986pub const k_ISteamParentalSettingsCallbacks: _bindgen_ty_31 =
1987 _bindgen_ty_31::k_ISteamParentalSettingsCallbacks;
1988#[repr(u32)]
1989#[non_exhaustive]
1990#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1991pub enum _bindgen_ty_31 {
1992 k_ISteamParentalSettingsCallbacks = 5000,
1993}
1994pub const k_iSteamGameSearchCallbacks: _bindgen_ty_32 = _bindgen_ty_32::k_iSteamGameSearchCallbacks;
1995#[repr(u32)]
1996#[non_exhaustive]
1997#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1998pub enum _bindgen_ty_32 {
1999 k_iSteamGameSearchCallbacks = 5200,
2000}
2001pub const k_iSteamPartiesCallbacks: _bindgen_ty_33 = _bindgen_ty_33::k_iSteamPartiesCallbacks;
2002#[repr(u32)]
2003#[non_exhaustive]
2004#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2005pub enum _bindgen_ty_33 {
2006 k_iSteamPartiesCallbacks = 5300,
2007}
2008pub const k_iSteamSTARCallbacks: _bindgen_ty_34 = _bindgen_ty_34::k_iSteamSTARCallbacks;
2009#[repr(u32)]
2010#[non_exhaustive]
2011#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2012pub enum _bindgen_ty_34 {
2013 k_iSteamSTARCallbacks = 5500,
2014}
2015pub const k_iSteamRemotePlayCallbacks: _bindgen_ty_35 = _bindgen_ty_35::k_iSteamRemotePlayCallbacks;
2016#[repr(u32)]
2017#[non_exhaustive]
2018#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2019pub enum _bindgen_ty_35 {
2020 k_iSteamRemotePlayCallbacks = 5700,
2021}
2022pub const k_iSteamChatCallbacks: _bindgen_ty_36 = _bindgen_ty_36::k_iSteamChatCallbacks;
2023#[repr(u32)]
2024#[non_exhaustive]
2025#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2026pub enum _bindgen_ty_36 {
2027 k_iSteamChatCallbacks = 5900,
2028}
2029pub const k_iSteamTimelineCallbacks: _bindgen_ty_37 = _bindgen_ty_37::k_iSteamTimelineCallbacks;
2030#[repr(u32)]
2031#[non_exhaustive]
2032#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2033pub enum _bindgen_ty_37 {
2034 k_iSteamTimelineCallbacks = 6000,
2035}
2036#[repr(C)]
2037pub struct ISteamClient__bindgen_vtable(::std::os::raw::c_void);
2038#[repr(C)]
2039#[derive(Debug, Copy, Clone)]
2040pub struct ISteamClient {
2041 pub vtable_: *const ISteamClient__bindgen_vtable,
2042}
2043#[test]
2044fn bindgen_test_layout_ISteamClient() {
2045 assert_eq!(
2046 ::std::mem::size_of::<ISteamClient>(),
2047 8usize,
2048 concat!("Size of: ", stringify!(ISteamClient))
2049 );
2050 assert_eq!(
2051 ::std::mem::align_of::<ISteamClient>(),
2052 8usize,
2053 concat!("Alignment of ", stringify!(ISteamClient))
2054 );
2055}
2056#[repr(C)]
2057pub struct ISteamUser__bindgen_vtable(::std::os::raw::c_void);
2058#[repr(C)]
2059#[derive(Debug, Copy, Clone)]
2060pub struct ISteamUser {
2061 pub vtable_: *const ISteamUser__bindgen_vtable,
2062}
2063#[test]
2064fn bindgen_test_layout_ISteamUser() {
2065 assert_eq!(
2066 ::std::mem::size_of::<ISteamUser>(),
2067 8usize,
2068 concat!("Size of: ", stringify!(ISteamUser))
2069 );
2070 assert_eq!(
2071 ::std::mem::align_of::<ISteamUser>(),
2072 8usize,
2073 concat!("Alignment of ", stringify!(ISteamUser))
2074 );
2075}
2076#[repr(C)]
2077#[derive(Debug, Copy, Clone)]
2078pub struct SteamServersConnected_t {
2079 pub _address: u8,
2080}
2081pub const SteamServersConnected_t_k_iCallback: SteamServersConnected_t__bindgen_ty_1 =
2082 SteamServersConnected_t__bindgen_ty_1::k_iCallback;
2083#[repr(u32)]
2084#[non_exhaustive]
2085#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2086pub enum SteamServersConnected_t__bindgen_ty_1 {
2087 k_iCallback = 101,
2088}
2089#[test]
2090fn bindgen_test_layout_SteamServersConnected_t() {
2091 assert_eq!(
2092 ::std::mem::size_of::<SteamServersConnected_t>(),
2093 1usize,
2094 concat!("Size of: ", stringify!(SteamServersConnected_t))
2095 );
2096 assert_eq!(
2097 ::std::mem::align_of::<SteamServersConnected_t>(),
2098 1usize,
2099 concat!("Alignment of ", stringify!(SteamServersConnected_t))
2100 );
2101}
2102#[repr(C)]
2103#[derive(Debug, Copy, Clone)]
2104pub struct SteamServerConnectFailure_t {
2105 pub m_eResult: EResult,
2106 pub m_bStillRetrying: bool,
2107}
2108pub const SteamServerConnectFailure_t_k_iCallback: SteamServerConnectFailure_t__bindgen_ty_1 =
2109 SteamServerConnectFailure_t__bindgen_ty_1::k_iCallback;
2110#[repr(u32)]
2111#[non_exhaustive]
2112#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2113pub enum SteamServerConnectFailure_t__bindgen_ty_1 {
2114 k_iCallback = 102,
2115}
2116#[test]
2117fn bindgen_test_layout_SteamServerConnectFailure_t() {
2118 const UNINIT: ::std::mem::MaybeUninit<SteamServerConnectFailure_t> =
2119 ::std::mem::MaybeUninit::uninit();
2120 let ptr = UNINIT.as_ptr();
2121 assert_eq!(
2122 ::std::mem::size_of::<SteamServerConnectFailure_t>(),
2123 8usize,
2124 concat!("Size of: ", stringify!(SteamServerConnectFailure_t))
2125 );
2126 assert_eq!(
2127 ::std::mem::align_of::<SteamServerConnectFailure_t>(),
2128 4usize,
2129 concat!("Alignment of ", stringify!(SteamServerConnectFailure_t))
2130 );
2131 assert_eq!(
2132 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2133 0usize,
2134 concat!(
2135 "Offset of field: ",
2136 stringify!(SteamServerConnectFailure_t),
2137 "::",
2138 stringify!(m_eResult)
2139 )
2140 );
2141 assert_eq!(
2142 unsafe { ::std::ptr::addr_of!((*ptr).m_bStillRetrying) as usize - ptr as usize },
2143 4usize,
2144 concat!(
2145 "Offset of field: ",
2146 stringify!(SteamServerConnectFailure_t),
2147 "::",
2148 stringify!(m_bStillRetrying)
2149 )
2150 );
2151}
2152#[repr(C)]
2153#[derive(Debug, Copy, Clone)]
2154pub struct SteamServersDisconnected_t {
2155 pub m_eResult: EResult,
2156}
2157pub const SteamServersDisconnected_t_k_iCallback: SteamServersDisconnected_t__bindgen_ty_1 =
2158 SteamServersDisconnected_t__bindgen_ty_1::k_iCallback;
2159#[repr(u32)]
2160#[non_exhaustive]
2161#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2162pub enum SteamServersDisconnected_t__bindgen_ty_1 {
2163 k_iCallback = 103,
2164}
2165#[test]
2166fn bindgen_test_layout_SteamServersDisconnected_t() {
2167 const UNINIT: ::std::mem::MaybeUninit<SteamServersDisconnected_t> =
2168 ::std::mem::MaybeUninit::uninit();
2169 let ptr = UNINIT.as_ptr();
2170 assert_eq!(
2171 ::std::mem::size_of::<SteamServersDisconnected_t>(),
2172 4usize,
2173 concat!("Size of: ", stringify!(SteamServersDisconnected_t))
2174 );
2175 assert_eq!(
2176 ::std::mem::align_of::<SteamServersDisconnected_t>(),
2177 4usize,
2178 concat!("Alignment of ", stringify!(SteamServersDisconnected_t))
2179 );
2180 assert_eq!(
2181 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2182 0usize,
2183 concat!(
2184 "Offset of field: ",
2185 stringify!(SteamServersDisconnected_t),
2186 "::",
2187 stringify!(m_eResult)
2188 )
2189 );
2190}
2191#[repr(C)]
2192#[derive(Debug, Copy, Clone)]
2193pub struct ClientGameServerDeny_t {
2194 pub m_uAppID: uint32,
2195 pub m_unGameServerIP: uint32,
2196 pub m_usGameServerPort: uint16,
2197 pub m_bSecure: uint16,
2198 pub m_uReason: uint32,
2199}
2200pub const ClientGameServerDeny_t_k_iCallback: ClientGameServerDeny_t__bindgen_ty_1 =
2201 ClientGameServerDeny_t__bindgen_ty_1::k_iCallback;
2202#[repr(u32)]
2203#[non_exhaustive]
2204#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2205pub enum ClientGameServerDeny_t__bindgen_ty_1 {
2206 k_iCallback = 113,
2207}
2208#[test]
2209fn bindgen_test_layout_ClientGameServerDeny_t() {
2210 const UNINIT: ::std::mem::MaybeUninit<ClientGameServerDeny_t> =
2211 ::std::mem::MaybeUninit::uninit();
2212 let ptr = UNINIT.as_ptr();
2213 assert_eq!(
2214 ::std::mem::size_of::<ClientGameServerDeny_t>(),
2215 16usize,
2216 concat!("Size of: ", stringify!(ClientGameServerDeny_t))
2217 );
2218 assert_eq!(
2219 ::std::mem::align_of::<ClientGameServerDeny_t>(),
2220 4usize,
2221 concat!("Alignment of ", stringify!(ClientGameServerDeny_t))
2222 );
2223 assert_eq!(
2224 unsafe { ::std::ptr::addr_of!((*ptr).m_uAppID) as usize - ptr as usize },
2225 0usize,
2226 concat!(
2227 "Offset of field: ",
2228 stringify!(ClientGameServerDeny_t),
2229 "::",
2230 stringify!(m_uAppID)
2231 )
2232 );
2233 assert_eq!(
2234 unsafe { ::std::ptr::addr_of!((*ptr).m_unGameServerIP) as usize - ptr as usize },
2235 4usize,
2236 concat!(
2237 "Offset of field: ",
2238 stringify!(ClientGameServerDeny_t),
2239 "::",
2240 stringify!(m_unGameServerIP)
2241 )
2242 );
2243 assert_eq!(
2244 unsafe { ::std::ptr::addr_of!((*ptr).m_usGameServerPort) as usize - ptr as usize },
2245 8usize,
2246 concat!(
2247 "Offset of field: ",
2248 stringify!(ClientGameServerDeny_t),
2249 "::",
2250 stringify!(m_usGameServerPort)
2251 )
2252 );
2253 assert_eq!(
2254 unsafe { ::std::ptr::addr_of!((*ptr).m_bSecure) as usize - ptr as usize },
2255 10usize,
2256 concat!(
2257 "Offset of field: ",
2258 stringify!(ClientGameServerDeny_t),
2259 "::",
2260 stringify!(m_bSecure)
2261 )
2262 );
2263 assert_eq!(
2264 unsafe { ::std::ptr::addr_of!((*ptr).m_uReason) as usize - ptr as usize },
2265 12usize,
2266 concat!(
2267 "Offset of field: ",
2268 stringify!(ClientGameServerDeny_t),
2269 "::",
2270 stringify!(m_uReason)
2271 )
2272 );
2273}
2274#[repr(C)]
2275#[derive(Debug, Copy, Clone)]
2276pub struct IPCFailure_t {
2277 pub m_eFailureType: uint8,
2278}
2279pub const IPCFailure_t_k_iCallback: IPCFailure_t__bindgen_ty_1 =
2280 IPCFailure_t__bindgen_ty_1::k_iCallback;
2281#[repr(u32)]
2282#[non_exhaustive]
2283#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2284pub enum IPCFailure_t__bindgen_ty_1 {
2285 k_iCallback = 117,
2286}
2287#[repr(u32)]
2288#[non_exhaustive]
2289#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2290pub enum IPCFailure_t_EFailureType {
2291 k_EFailureFlushedCallbackQueue = 0,
2292 k_EFailurePipeFail = 1,
2293}
2294#[test]
2295fn bindgen_test_layout_IPCFailure_t() {
2296 const UNINIT: ::std::mem::MaybeUninit<IPCFailure_t> = ::std::mem::MaybeUninit::uninit();
2297 let ptr = UNINIT.as_ptr();
2298 assert_eq!(
2299 ::std::mem::size_of::<IPCFailure_t>(),
2300 1usize,
2301 concat!("Size of: ", stringify!(IPCFailure_t))
2302 );
2303 assert_eq!(
2304 ::std::mem::align_of::<IPCFailure_t>(),
2305 1usize,
2306 concat!("Alignment of ", stringify!(IPCFailure_t))
2307 );
2308 assert_eq!(
2309 unsafe { ::std::ptr::addr_of!((*ptr).m_eFailureType) as usize - ptr as usize },
2310 0usize,
2311 concat!(
2312 "Offset of field: ",
2313 stringify!(IPCFailure_t),
2314 "::",
2315 stringify!(m_eFailureType)
2316 )
2317 );
2318}
2319#[repr(C)]
2320#[derive(Debug, Copy, Clone)]
2321pub struct LicensesUpdated_t {
2322 pub _address: u8,
2323}
2324pub const LicensesUpdated_t_k_iCallback: LicensesUpdated_t__bindgen_ty_1 =
2325 LicensesUpdated_t__bindgen_ty_1::k_iCallback;
2326#[repr(u32)]
2327#[non_exhaustive]
2328#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2329pub enum LicensesUpdated_t__bindgen_ty_1 {
2330 k_iCallback = 125,
2331}
2332#[test]
2333fn bindgen_test_layout_LicensesUpdated_t() {
2334 assert_eq!(
2335 ::std::mem::size_of::<LicensesUpdated_t>(),
2336 1usize,
2337 concat!("Size of: ", stringify!(LicensesUpdated_t))
2338 );
2339 assert_eq!(
2340 ::std::mem::align_of::<LicensesUpdated_t>(),
2341 1usize,
2342 concat!("Alignment of ", stringify!(LicensesUpdated_t))
2343 );
2344}
2345#[repr(C)]
2346#[derive(Copy, Clone)]
2347pub struct ValidateAuthTicketResponse_t {
2348 pub m_SteamID: CSteamID,
2349 pub m_eAuthSessionResponse: EAuthSessionResponse,
2350 pub m_OwnerSteamID: CSteamID,
2351}
2352pub const ValidateAuthTicketResponse_t_k_iCallback: ValidateAuthTicketResponse_t__bindgen_ty_1 =
2353 ValidateAuthTicketResponse_t__bindgen_ty_1::k_iCallback;
2354#[repr(u32)]
2355#[non_exhaustive]
2356#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2357pub enum ValidateAuthTicketResponse_t__bindgen_ty_1 {
2358 k_iCallback = 143,
2359}
2360#[test]
2361fn bindgen_test_layout_ValidateAuthTicketResponse_t() {
2362 const UNINIT: ::std::mem::MaybeUninit<ValidateAuthTicketResponse_t> =
2363 ::std::mem::MaybeUninit::uninit();
2364 let ptr = UNINIT.as_ptr();
2365 assert_eq!(
2366 ::std::mem::size_of::<ValidateAuthTicketResponse_t>(),
2367 20usize,
2368 concat!("Size of: ", stringify!(ValidateAuthTicketResponse_t))
2369 );
2370 assert_eq!(
2371 ::std::mem::align_of::<ValidateAuthTicketResponse_t>(),
2372 4usize,
2373 concat!("Alignment of ", stringify!(ValidateAuthTicketResponse_t))
2374 );
2375 assert_eq!(
2376 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamID) as usize - ptr as usize },
2377 0usize,
2378 concat!(
2379 "Offset of field: ",
2380 stringify!(ValidateAuthTicketResponse_t),
2381 "::",
2382 stringify!(m_SteamID)
2383 )
2384 );
2385 assert_eq!(
2386 unsafe { ::std::ptr::addr_of!((*ptr).m_eAuthSessionResponse) as usize - ptr as usize },
2387 8usize,
2388 concat!(
2389 "Offset of field: ",
2390 stringify!(ValidateAuthTicketResponse_t),
2391 "::",
2392 stringify!(m_eAuthSessionResponse)
2393 )
2394 );
2395 assert_eq!(
2396 unsafe { ::std::ptr::addr_of!((*ptr).m_OwnerSteamID) as usize - ptr as usize },
2397 12usize,
2398 concat!(
2399 "Offset of field: ",
2400 stringify!(ValidateAuthTicketResponse_t),
2401 "::",
2402 stringify!(m_OwnerSteamID)
2403 )
2404 );
2405}
2406#[repr(C, packed(4))]
2407#[derive(Debug, Copy, Clone)]
2408pub struct MicroTxnAuthorizationResponse_t {
2409 pub m_unAppID: uint32,
2410 pub m_ulOrderID: uint64,
2411 pub m_bAuthorized: uint8,
2412}
2413pub const MicroTxnAuthorizationResponse_t_k_iCallback:
2414 MicroTxnAuthorizationResponse_t__bindgen_ty_1 =
2415 MicroTxnAuthorizationResponse_t__bindgen_ty_1::k_iCallback;
2416#[repr(u32)]
2417#[non_exhaustive]
2418#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2419pub enum MicroTxnAuthorizationResponse_t__bindgen_ty_1 {
2420 k_iCallback = 152,
2421}
2422#[test]
2423fn bindgen_test_layout_MicroTxnAuthorizationResponse_t() {
2424 const UNINIT: ::std::mem::MaybeUninit<MicroTxnAuthorizationResponse_t> =
2425 ::std::mem::MaybeUninit::uninit();
2426 let ptr = UNINIT.as_ptr();
2427 assert_eq!(
2428 ::std::mem::size_of::<MicroTxnAuthorizationResponse_t>(),
2429 16usize,
2430 concat!("Size of: ", stringify!(MicroTxnAuthorizationResponse_t))
2431 );
2432 assert_eq!(
2433 ::std::mem::align_of::<MicroTxnAuthorizationResponse_t>(),
2434 4usize,
2435 concat!("Alignment of ", stringify!(MicroTxnAuthorizationResponse_t))
2436 );
2437 assert_eq!(
2438 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
2439 0usize,
2440 concat!(
2441 "Offset of field: ",
2442 stringify!(MicroTxnAuthorizationResponse_t),
2443 "::",
2444 stringify!(m_unAppID)
2445 )
2446 );
2447 assert_eq!(
2448 unsafe { ::std::ptr::addr_of!((*ptr).m_ulOrderID) as usize - ptr as usize },
2449 4usize,
2450 concat!(
2451 "Offset of field: ",
2452 stringify!(MicroTxnAuthorizationResponse_t),
2453 "::",
2454 stringify!(m_ulOrderID)
2455 )
2456 );
2457 assert_eq!(
2458 unsafe { ::std::ptr::addr_of!((*ptr).m_bAuthorized) as usize - ptr as usize },
2459 12usize,
2460 concat!(
2461 "Offset of field: ",
2462 stringify!(MicroTxnAuthorizationResponse_t),
2463 "::",
2464 stringify!(m_bAuthorized)
2465 )
2466 );
2467}
2468#[repr(C)]
2469#[derive(Debug, Copy, Clone)]
2470pub struct EncryptedAppTicketResponse_t {
2471 pub m_eResult: EResult,
2472}
2473pub const EncryptedAppTicketResponse_t_k_iCallback: EncryptedAppTicketResponse_t__bindgen_ty_1 =
2474 EncryptedAppTicketResponse_t__bindgen_ty_1::k_iCallback;
2475#[repr(u32)]
2476#[non_exhaustive]
2477#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2478pub enum EncryptedAppTicketResponse_t__bindgen_ty_1 {
2479 k_iCallback = 154,
2480}
2481#[test]
2482fn bindgen_test_layout_EncryptedAppTicketResponse_t() {
2483 const UNINIT: ::std::mem::MaybeUninit<EncryptedAppTicketResponse_t> =
2484 ::std::mem::MaybeUninit::uninit();
2485 let ptr = UNINIT.as_ptr();
2486 assert_eq!(
2487 ::std::mem::size_of::<EncryptedAppTicketResponse_t>(),
2488 4usize,
2489 concat!("Size of: ", stringify!(EncryptedAppTicketResponse_t))
2490 );
2491 assert_eq!(
2492 ::std::mem::align_of::<EncryptedAppTicketResponse_t>(),
2493 4usize,
2494 concat!("Alignment of ", stringify!(EncryptedAppTicketResponse_t))
2495 );
2496 assert_eq!(
2497 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2498 0usize,
2499 concat!(
2500 "Offset of field: ",
2501 stringify!(EncryptedAppTicketResponse_t),
2502 "::",
2503 stringify!(m_eResult)
2504 )
2505 );
2506}
2507#[repr(C)]
2508#[derive(Debug, Copy, Clone)]
2509pub struct GetAuthSessionTicketResponse_t {
2510 pub m_hAuthTicket: HAuthTicket,
2511 pub m_eResult: EResult,
2512}
2513pub const GetAuthSessionTicketResponse_t_k_iCallback: GetAuthSessionTicketResponse_t__bindgen_ty_1 =
2514 GetAuthSessionTicketResponse_t__bindgen_ty_1::k_iCallback;
2515#[repr(u32)]
2516#[non_exhaustive]
2517#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2518pub enum GetAuthSessionTicketResponse_t__bindgen_ty_1 {
2519 k_iCallback = 163,
2520}
2521#[test]
2522fn bindgen_test_layout_GetAuthSessionTicketResponse_t() {
2523 const UNINIT: ::std::mem::MaybeUninit<GetAuthSessionTicketResponse_t> =
2524 ::std::mem::MaybeUninit::uninit();
2525 let ptr = UNINIT.as_ptr();
2526 assert_eq!(
2527 ::std::mem::size_of::<GetAuthSessionTicketResponse_t>(),
2528 8usize,
2529 concat!("Size of: ", stringify!(GetAuthSessionTicketResponse_t))
2530 );
2531 assert_eq!(
2532 ::std::mem::align_of::<GetAuthSessionTicketResponse_t>(),
2533 4usize,
2534 concat!("Alignment of ", stringify!(GetAuthSessionTicketResponse_t))
2535 );
2536 assert_eq!(
2537 unsafe { ::std::ptr::addr_of!((*ptr).m_hAuthTicket) as usize - ptr as usize },
2538 0usize,
2539 concat!(
2540 "Offset of field: ",
2541 stringify!(GetAuthSessionTicketResponse_t),
2542 "::",
2543 stringify!(m_hAuthTicket)
2544 )
2545 );
2546 assert_eq!(
2547 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2548 4usize,
2549 concat!(
2550 "Offset of field: ",
2551 stringify!(GetAuthSessionTicketResponse_t),
2552 "::",
2553 stringify!(m_eResult)
2554 )
2555 );
2556}
2557#[repr(C)]
2558#[derive(Debug, Copy, Clone)]
2559pub struct GameWebCallback_t {
2560 pub m_szURL: [::std::os::raw::c_char; 256usize],
2561}
2562pub const GameWebCallback_t_k_iCallback: GameWebCallback_t__bindgen_ty_1 =
2563 GameWebCallback_t__bindgen_ty_1::k_iCallback;
2564#[repr(u32)]
2565#[non_exhaustive]
2566#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2567pub enum GameWebCallback_t__bindgen_ty_1 {
2568 k_iCallback = 164,
2569}
2570#[test]
2571fn bindgen_test_layout_GameWebCallback_t() {
2572 const UNINIT: ::std::mem::MaybeUninit<GameWebCallback_t> = ::std::mem::MaybeUninit::uninit();
2573 let ptr = UNINIT.as_ptr();
2574 assert_eq!(
2575 ::std::mem::size_of::<GameWebCallback_t>(),
2576 256usize,
2577 concat!("Size of: ", stringify!(GameWebCallback_t))
2578 );
2579 assert_eq!(
2580 ::std::mem::align_of::<GameWebCallback_t>(),
2581 1usize,
2582 concat!("Alignment of ", stringify!(GameWebCallback_t))
2583 );
2584 assert_eq!(
2585 unsafe { ::std::ptr::addr_of!((*ptr).m_szURL) as usize - ptr as usize },
2586 0usize,
2587 concat!(
2588 "Offset of field: ",
2589 stringify!(GameWebCallback_t),
2590 "::",
2591 stringify!(m_szURL)
2592 )
2593 );
2594}
2595#[repr(C)]
2596#[derive(Debug, Copy, Clone)]
2597pub struct StoreAuthURLResponse_t {
2598 pub m_szURL: [::std::os::raw::c_char; 512usize],
2599}
2600pub const StoreAuthURLResponse_t_k_iCallback: StoreAuthURLResponse_t__bindgen_ty_1 =
2601 StoreAuthURLResponse_t__bindgen_ty_1::k_iCallback;
2602#[repr(u32)]
2603#[non_exhaustive]
2604#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2605pub enum StoreAuthURLResponse_t__bindgen_ty_1 {
2606 k_iCallback = 165,
2607}
2608#[test]
2609fn bindgen_test_layout_StoreAuthURLResponse_t() {
2610 const UNINIT: ::std::mem::MaybeUninit<StoreAuthURLResponse_t> =
2611 ::std::mem::MaybeUninit::uninit();
2612 let ptr = UNINIT.as_ptr();
2613 assert_eq!(
2614 ::std::mem::size_of::<StoreAuthURLResponse_t>(),
2615 512usize,
2616 concat!("Size of: ", stringify!(StoreAuthURLResponse_t))
2617 );
2618 assert_eq!(
2619 ::std::mem::align_of::<StoreAuthURLResponse_t>(),
2620 1usize,
2621 concat!("Alignment of ", stringify!(StoreAuthURLResponse_t))
2622 );
2623 assert_eq!(
2624 unsafe { ::std::ptr::addr_of!((*ptr).m_szURL) as usize - ptr as usize },
2625 0usize,
2626 concat!(
2627 "Offset of field: ",
2628 stringify!(StoreAuthURLResponse_t),
2629 "::",
2630 stringify!(m_szURL)
2631 )
2632 );
2633}
2634#[repr(C)]
2635#[derive(Debug, Copy, Clone)]
2636pub struct MarketEligibilityResponse_t {
2637 pub m_bAllowed: bool,
2638 pub m_eNotAllowedReason: EMarketNotAllowedReasonFlags,
2639 pub m_rtAllowedAtTime: RTime32,
2640 pub m_cdaySteamGuardRequiredDays: ::std::os::raw::c_int,
2641 pub m_cdayNewDeviceCooldown: ::std::os::raw::c_int,
2642}
2643pub const MarketEligibilityResponse_t_k_iCallback: MarketEligibilityResponse_t__bindgen_ty_1 =
2644 MarketEligibilityResponse_t__bindgen_ty_1::k_iCallback;
2645#[repr(u32)]
2646#[non_exhaustive]
2647#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2648pub enum MarketEligibilityResponse_t__bindgen_ty_1 {
2649 k_iCallback = 166,
2650}
2651#[test]
2652fn bindgen_test_layout_MarketEligibilityResponse_t() {
2653 const UNINIT: ::std::mem::MaybeUninit<MarketEligibilityResponse_t> =
2654 ::std::mem::MaybeUninit::uninit();
2655 let ptr = UNINIT.as_ptr();
2656 assert_eq!(
2657 ::std::mem::size_of::<MarketEligibilityResponse_t>(),
2658 20usize,
2659 concat!("Size of: ", stringify!(MarketEligibilityResponse_t))
2660 );
2661 assert_eq!(
2662 ::std::mem::align_of::<MarketEligibilityResponse_t>(),
2663 4usize,
2664 concat!("Alignment of ", stringify!(MarketEligibilityResponse_t))
2665 );
2666 assert_eq!(
2667 unsafe { ::std::ptr::addr_of!((*ptr).m_bAllowed) as usize - ptr as usize },
2668 0usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(MarketEligibilityResponse_t),
2672 "::",
2673 stringify!(m_bAllowed)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { ::std::ptr::addr_of!((*ptr).m_eNotAllowedReason) as usize - ptr as usize },
2678 4usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(MarketEligibilityResponse_t),
2682 "::",
2683 stringify!(m_eNotAllowedReason)
2684 )
2685 );
2686 assert_eq!(
2687 unsafe { ::std::ptr::addr_of!((*ptr).m_rtAllowedAtTime) as usize - ptr as usize },
2688 8usize,
2689 concat!(
2690 "Offset of field: ",
2691 stringify!(MarketEligibilityResponse_t),
2692 "::",
2693 stringify!(m_rtAllowedAtTime)
2694 )
2695 );
2696 assert_eq!(
2697 unsafe {
2698 ::std::ptr::addr_of!((*ptr).m_cdaySteamGuardRequiredDays) as usize - ptr as usize
2699 },
2700 12usize,
2701 concat!(
2702 "Offset of field: ",
2703 stringify!(MarketEligibilityResponse_t),
2704 "::",
2705 stringify!(m_cdaySteamGuardRequiredDays)
2706 )
2707 );
2708 assert_eq!(
2709 unsafe { ::std::ptr::addr_of!((*ptr).m_cdayNewDeviceCooldown) as usize - ptr as usize },
2710 16usize,
2711 concat!(
2712 "Offset of field: ",
2713 stringify!(MarketEligibilityResponse_t),
2714 "::",
2715 stringify!(m_cdayNewDeviceCooldown)
2716 )
2717 );
2718}
2719#[repr(C)]
2720#[derive(Debug, Copy, Clone)]
2721pub struct DurationControl_t {
2722 pub m_eResult: EResult,
2723 pub m_appid: AppId_t,
2724 pub m_bApplicable: bool,
2725 pub m_csecsLast5h: int32,
2726 pub m_progress: EDurationControlProgress,
2727 pub m_notification: EDurationControlNotification,
2728 pub m_csecsToday: int32,
2729 pub m_csecsRemaining: int32,
2730}
2731pub const DurationControl_t_k_iCallback: DurationControl_t__bindgen_ty_1 =
2732 DurationControl_t__bindgen_ty_1::k_iCallback;
2733#[repr(u32)]
2734#[non_exhaustive]
2735#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2736pub enum DurationControl_t__bindgen_ty_1 {
2737 k_iCallback = 167,
2738}
2739#[test]
2740fn bindgen_test_layout_DurationControl_t() {
2741 const UNINIT: ::std::mem::MaybeUninit<DurationControl_t> = ::std::mem::MaybeUninit::uninit();
2742 let ptr = UNINIT.as_ptr();
2743 assert_eq!(
2744 ::std::mem::size_of::<DurationControl_t>(),
2745 32usize,
2746 concat!("Size of: ", stringify!(DurationControl_t))
2747 );
2748 assert_eq!(
2749 ::std::mem::align_of::<DurationControl_t>(),
2750 4usize,
2751 concat!("Alignment of ", stringify!(DurationControl_t))
2752 );
2753 assert_eq!(
2754 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2755 0usize,
2756 concat!(
2757 "Offset of field: ",
2758 stringify!(DurationControl_t),
2759 "::",
2760 stringify!(m_eResult)
2761 )
2762 );
2763 assert_eq!(
2764 unsafe { ::std::ptr::addr_of!((*ptr).m_appid) as usize - ptr as usize },
2765 4usize,
2766 concat!(
2767 "Offset of field: ",
2768 stringify!(DurationControl_t),
2769 "::",
2770 stringify!(m_appid)
2771 )
2772 );
2773 assert_eq!(
2774 unsafe { ::std::ptr::addr_of!((*ptr).m_bApplicable) as usize - ptr as usize },
2775 8usize,
2776 concat!(
2777 "Offset of field: ",
2778 stringify!(DurationControl_t),
2779 "::",
2780 stringify!(m_bApplicable)
2781 )
2782 );
2783 assert_eq!(
2784 unsafe { ::std::ptr::addr_of!((*ptr).m_csecsLast5h) as usize - ptr as usize },
2785 12usize,
2786 concat!(
2787 "Offset of field: ",
2788 stringify!(DurationControl_t),
2789 "::",
2790 stringify!(m_csecsLast5h)
2791 )
2792 );
2793 assert_eq!(
2794 unsafe { ::std::ptr::addr_of!((*ptr).m_progress) as usize - ptr as usize },
2795 16usize,
2796 concat!(
2797 "Offset of field: ",
2798 stringify!(DurationControl_t),
2799 "::",
2800 stringify!(m_progress)
2801 )
2802 );
2803 assert_eq!(
2804 unsafe { ::std::ptr::addr_of!((*ptr).m_notification) as usize - ptr as usize },
2805 20usize,
2806 concat!(
2807 "Offset of field: ",
2808 stringify!(DurationControl_t),
2809 "::",
2810 stringify!(m_notification)
2811 )
2812 );
2813 assert_eq!(
2814 unsafe { ::std::ptr::addr_of!((*ptr).m_csecsToday) as usize - ptr as usize },
2815 24usize,
2816 concat!(
2817 "Offset of field: ",
2818 stringify!(DurationControl_t),
2819 "::",
2820 stringify!(m_csecsToday)
2821 )
2822 );
2823 assert_eq!(
2824 unsafe { ::std::ptr::addr_of!((*ptr).m_csecsRemaining) as usize - ptr as usize },
2825 28usize,
2826 concat!(
2827 "Offset of field: ",
2828 stringify!(DurationControl_t),
2829 "::",
2830 stringify!(m_csecsRemaining)
2831 )
2832 );
2833}
2834#[repr(C)]
2835#[derive(Debug, Copy, Clone)]
2836pub struct GetTicketForWebApiResponse_t {
2837 pub m_hAuthTicket: HAuthTicket,
2838 pub m_eResult: EResult,
2839 pub m_cubTicket: ::std::os::raw::c_int,
2840 pub m_rgubTicket: [uint8; 2560usize],
2841}
2842pub const GetTicketForWebApiResponse_t_k_iCallback: GetTicketForWebApiResponse_t__bindgen_ty_1 =
2843 GetTicketForWebApiResponse_t__bindgen_ty_1::k_iCallback;
2844#[repr(u32)]
2845#[non_exhaustive]
2846#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2847pub enum GetTicketForWebApiResponse_t__bindgen_ty_1 {
2848 k_iCallback = 168,
2849}
2850pub const GetTicketForWebApiResponse_t_k_nCubTicketMaxLength: ::std::os::raw::c_int = 2560;
2851#[test]
2852fn bindgen_test_layout_GetTicketForWebApiResponse_t() {
2853 const UNINIT: ::std::mem::MaybeUninit<GetTicketForWebApiResponse_t> =
2854 ::std::mem::MaybeUninit::uninit();
2855 let ptr = UNINIT.as_ptr();
2856 assert_eq!(
2857 ::std::mem::size_of::<GetTicketForWebApiResponse_t>(),
2858 2572usize,
2859 concat!("Size of: ", stringify!(GetTicketForWebApiResponse_t))
2860 );
2861 assert_eq!(
2862 ::std::mem::align_of::<GetTicketForWebApiResponse_t>(),
2863 4usize,
2864 concat!("Alignment of ", stringify!(GetTicketForWebApiResponse_t))
2865 );
2866 assert_eq!(
2867 unsafe { ::std::ptr::addr_of!((*ptr).m_hAuthTicket) as usize - ptr as usize },
2868 0usize,
2869 concat!(
2870 "Offset of field: ",
2871 stringify!(GetTicketForWebApiResponse_t),
2872 "::",
2873 stringify!(m_hAuthTicket)
2874 )
2875 );
2876 assert_eq!(
2877 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
2878 4usize,
2879 concat!(
2880 "Offset of field: ",
2881 stringify!(GetTicketForWebApiResponse_t),
2882 "::",
2883 stringify!(m_eResult)
2884 )
2885 );
2886 assert_eq!(
2887 unsafe { ::std::ptr::addr_of!((*ptr).m_cubTicket) as usize - ptr as usize },
2888 8usize,
2889 concat!(
2890 "Offset of field: ",
2891 stringify!(GetTicketForWebApiResponse_t),
2892 "::",
2893 stringify!(m_cubTicket)
2894 )
2895 );
2896 assert_eq!(
2897 unsafe { ::std::ptr::addr_of!((*ptr).m_rgubTicket) as usize - ptr as usize },
2898 12usize,
2899 concat!(
2900 "Offset of field: ",
2901 stringify!(GetTicketForWebApiResponse_t),
2902 "::",
2903 stringify!(m_rgubTicket)
2904 )
2905 );
2906}
2907#[repr(u32)]
2908#[non_exhaustive]
2909#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2910pub enum EFriendRelationship {
2911 k_EFriendRelationshipNone = 0,
2912 k_EFriendRelationshipBlocked = 1,
2913 k_EFriendRelationshipRequestRecipient = 2,
2914 k_EFriendRelationshipFriend = 3,
2915 k_EFriendRelationshipRequestInitiator = 4,
2916 k_EFriendRelationshipIgnored = 5,
2917 k_EFriendRelationshipIgnoredFriend = 6,
2918 k_EFriendRelationshipSuggested_DEPRECATED = 7,
2919 k_EFriendRelationshipMax = 8,
2920}
2921pub const k_cchMaxFriendsGroupName: ::std::os::raw::c_int = 64;
2922pub const k_cFriendsGroupLimit: ::std::os::raw::c_int = 100;
2923pub type FriendsGroupID_t = int16;
2924pub const k_FriendsGroupID_Invalid: FriendsGroupID_t = -1;
2925pub const k_cEnumerateFollowersMax: ::std::os::raw::c_int = 50;
2926#[repr(u32)]
2927#[non_exhaustive]
2928#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2929pub enum EPersonaState {
2930 k_EPersonaStateOffline = 0,
2931 k_EPersonaStateOnline = 1,
2932 k_EPersonaStateBusy = 2,
2933 k_EPersonaStateAway = 3,
2934 k_EPersonaStateSnooze = 4,
2935 k_EPersonaStateLookingToTrade = 5,
2936 k_EPersonaStateLookingToPlay = 6,
2937 k_EPersonaStateInvisible = 7,
2938 k_EPersonaStateMax = 8,
2939}
2940impl EFriendFlags {
2941 pub const k_EFriendFlagNone: EFriendFlags = EFriendFlags(0);
2942}
2943impl EFriendFlags {
2944 pub const k_EFriendFlagBlocked: EFriendFlags = EFriendFlags(1);
2945}
2946impl EFriendFlags {
2947 pub const k_EFriendFlagFriendshipRequested: EFriendFlags = EFriendFlags(2);
2948}
2949impl EFriendFlags {
2950 pub const k_EFriendFlagImmediate: EFriendFlags = EFriendFlags(4);
2951}
2952impl EFriendFlags {
2953 pub const k_EFriendFlagClanMember: EFriendFlags = EFriendFlags(8);
2954}
2955impl EFriendFlags {
2956 pub const k_EFriendFlagOnGameServer: EFriendFlags = EFriendFlags(16);
2957}
2958impl EFriendFlags {
2959 pub const k_EFriendFlagRequestingFriendship: EFriendFlags = EFriendFlags(128);
2960}
2961impl EFriendFlags {
2962 pub const k_EFriendFlagRequestingInfo: EFriendFlags = EFriendFlags(256);
2963}
2964impl EFriendFlags {
2965 pub const k_EFriendFlagIgnored: EFriendFlags = EFriendFlags(512);
2966}
2967impl EFriendFlags {
2968 pub const k_EFriendFlagIgnoredFriend: EFriendFlags = EFriendFlags(1024);
2969}
2970impl EFriendFlags {
2971 pub const k_EFriendFlagChatMember: EFriendFlags = EFriendFlags(4096);
2972}
2973impl EFriendFlags {
2974 pub const k_EFriendFlagAll: EFriendFlags = EFriendFlags(65535);
2975}
2976impl ::std::ops::BitOr<EFriendFlags> for EFriendFlags {
2977 type Output = Self;
2978 #[inline]
2979 fn bitor(self, other: Self) -> Self {
2980 EFriendFlags(self.0 | other.0)
2981 }
2982}
2983impl ::std::ops::BitOrAssign for EFriendFlags {
2984 #[inline]
2985 fn bitor_assign(&mut self, rhs: EFriendFlags) {
2986 self.0 |= rhs.0;
2987 }
2988}
2989impl ::std::ops::BitAnd<EFriendFlags> for EFriendFlags {
2990 type Output = Self;
2991 #[inline]
2992 fn bitand(self, other: Self) -> Self {
2993 EFriendFlags(self.0 & other.0)
2994 }
2995}
2996impl ::std::ops::BitAndAssign for EFriendFlags {
2997 #[inline]
2998 fn bitand_assign(&mut self, rhs: EFriendFlags) {
2999 self.0 &= rhs.0;
3000 }
3001}
3002#[repr(transparent)]
3003#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3004pub struct EFriendFlags(pub ::std::os::raw::c_uint);
3005#[repr(C)]
3006#[derive(Copy, Clone)]
3007pub struct FriendGameInfo_t {
3008 pub m_gameID: CGameID,
3009 pub m_unGameIP: uint32,
3010 pub m_usGamePort: uint16,
3011 pub m_usQueryPort: uint16,
3012 pub m_steamIDLobby: CSteamID,
3013}
3014#[test]
3015fn bindgen_test_layout_FriendGameInfo_t() {
3016 const UNINIT: ::std::mem::MaybeUninit<FriendGameInfo_t> = ::std::mem::MaybeUninit::uninit();
3017 let ptr = UNINIT.as_ptr();
3018 assert_eq!(
3019 ::std::mem::size_of::<FriendGameInfo_t>(),
3020 24usize,
3021 concat!("Size of: ", stringify!(FriendGameInfo_t))
3022 );
3023 assert_eq!(
3024 ::std::mem::align_of::<FriendGameInfo_t>(),
3025 4usize,
3026 concat!("Alignment of ", stringify!(FriendGameInfo_t))
3027 );
3028 assert_eq!(
3029 unsafe { ::std::ptr::addr_of!((*ptr).m_gameID) as usize - ptr as usize },
3030 0usize,
3031 concat!(
3032 "Offset of field: ",
3033 stringify!(FriendGameInfo_t),
3034 "::",
3035 stringify!(m_gameID)
3036 )
3037 );
3038 assert_eq!(
3039 unsafe { ::std::ptr::addr_of!((*ptr).m_unGameIP) as usize - ptr as usize },
3040 8usize,
3041 concat!(
3042 "Offset of field: ",
3043 stringify!(FriendGameInfo_t),
3044 "::",
3045 stringify!(m_unGameIP)
3046 )
3047 );
3048 assert_eq!(
3049 unsafe { ::std::ptr::addr_of!((*ptr).m_usGamePort) as usize - ptr as usize },
3050 12usize,
3051 concat!(
3052 "Offset of field: ",
3053 stringify!(FriendGameInfo_t),
3054 "::",
3055 stringify!(m_usGamePort)
3056 )
3057 );
3058 assert_eq!(
3059 unsafe { ::std::ptr::addr_of!((*ptr).m_usQueryPort) as usize - ptr as usize },
3060 14usize,
3061 concat!(
3062 "Offset of field: ",
3063 stringify!(FriendGameInfo_t),
3064 "::",
3065 stringify!(m_usQueryPort)
3066 )
3067 );
3068 assert_eq!(
3069 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDLobby) as usize - ptr as usize },
3070 16usize,
3071 concat!(
3072 "Offset of field: ",
3073 stringify!(FriendGameInfo_t),
3074 "::",
3075 stringify!(m_steamIDLobby)
3076 )
3077 );
3078}
3079pub const k_usFriendGameInfoQueryPort_NotInitialized: uint16 = 65535;
3080pub const k_usFriendGameInfoQueryPort_Error: uint16 = 65534;
3081pub const k_cchPersonaNameMax: _bindgen_ty_38 = _bindgen_ty_38::k_cchPersonaNameMax;
3082pub const k_cwchPersonaNameMax: _bindgen_ty_38 = _bindgen_ty_38::k_cwchPersonaNameMax;
3083#[repr(u32)]
3084#[non_exhaustive]
3085#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3086pub enum _bindgen_ty_38 {
3087 k_cchPersonaNameMax = 128,
3088 k_cwchPersonaNameMax = 32,
3089}
3090pub const k_cubChatMetadataMax: uint32 = 8192;
3091pub const k_cchMaxRichPresenceKeys: _bindgen_ty_39 = _bindgen_ty_39::k_cchMaxRichPresenceKeys;
3092#[repr(u32)]
3093#[non_exhaustive]
3094#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3095pub enum _bindgen_ty_39 {
3096 k_cchMaxRichPresenceKeys = 30,
3097}
3098pub const k_cchMaxRichPresenceKeyLength: _bindgen_ty_40 =
3099 _bindgen_ty_40::k_cchMaxRichPresenceKeyLength;
3100#[repr(u32)]
3101#[non_exhaustive]
3102#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3103pub enum _bindgen_ty_40 {
3104 k_cchMaxRichPresenceKeyLength = 64,
3105}
3106pub const k_cchMaxRichPresenceValueLength: _bindgen_ty_41 =
3107 _bindgen_ty_41::k_cchMaxRichPresenceValueLength;
3108#[repr(u32)]
3109#[non_exhaustive]
3110#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3111pub enum _bindgen_ty_41 {
3112 k_cchMaxRichPresenceValueLength = 256,
3113}
3114impl EOverlayToStoreFlag {
3115 pub const k_EOverlayToStoreFlag_None: EOverlayToStoreFlag = EOverlayToStoreFlag(0);
3116}
3117impl EOverlayToStoreFlag {
3118 pub const k_EOverlayToStoreFlag_AddToCart: EOverlayToStoreFlag = EOverlayToStoreFlag(1);
3119}
3120impl EOverlayToStoreFlag {
3121 pub const k_EOverlayToStoreFlag_AddToCartAndShow: EOverlayToStoreFlag = EOverlayToStoreFlag(2);
3122}
3123impl ::std::ops::BitOr<EOverlayToStoreFlag> for EOverlayToStoreFlag {
3124 type Output = Self;
3125 #[inline]
3126 fn bitor(self, other: Self) -> Self {
3127 EOverlayToStoreFlag(self.0 | other.0)
3128 }
3129}
3130impl ::std::ops::BitOrAssign for EOverlayToStoreFlag {
3131 #[inline]
3132 fn bitor_assign(&mut self, rhs: EOverlayToStoreFlag) {
3133 self.0 |= rhs.0;
3134 }
3135}
3136impl ::std::ops::BitAnd<EOverlayToStoreFlag> for EOverlayToStoreFlag {
3137 type Output = Self;
3138 #[inline]
3139 fn bitand(self, other: Self) -> Self {
3140 EOverlayToStoreFlag(self.0 & other.0)
3141 }
3142}
3143impl ::std::ops::BitAndAssign for EOverlayToStoreFlag {
3144 #[inline]
3145 fn bitand_assign(&mut self, rhs: EOverlayToStoreFlag) {
3146 self.0 &= rhs.0;
3147 }
3148}
3149#[repr(transparent)]
3150#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3151pub struct EOverlayToStoreFlag(pub ::std::os::raw::c_uint);
3152#[repr(u32)]
3153#[non_exhaustive]
3154#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3155pub enum EActivateGameOverlayToWebPageMode {
3156 k_EActivateGameOverlayToWebPageMode_Default = 0,
3157 k_EActivateGameOverlayToWebPageMode_Modal = 1,
3158}
3159#[repr(u32)]
3160#[non_exhaustive]
3161#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3162pub enum ECommunityProfileItemType {
3163 k_ECommunityProfileItemType_AnimatedAvatar = 0,
3164 k_ECommunityProfileItemType_AvatarFrame = 1,
3165 k_ECommunityProfileItemType_ProfileModifier = 2,
3166 k_ECommunityProfileItemType_ProfileBackground = 3,
3167 k_ECommunityProfileItemType_MiniProfileBackground = 4,
3168}
3169#[repr(u32)]
3170#[non_exhaustive]
3171#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3172pub enum ECommunityProfileItemProperty {
3173 k_ECommunityProfileItemProperty_ImageSmall = 0,
3174 k_ECommunityProfileItemProperty_ImageLarge = 1,
3175 k_ECommunityProfileItemProperty_InternalName = 2,
3176 k_ECommunityProfileItemProperty_Title = 3,
3177 k_ECommunityProfileItemProperty_Description = 4,
3178 k_ECommunityProfileItemProperty_AppID = 5,
3179 k_ECommunityProfileItemProperty_TypeID = 6,
3180 k_ECommunityProfileItemProperty_Class = 7,
3181 k_ECommunityProfileItemProperty_MovieWebM = 8,
3182 k_ECommunityProfileItemProperty_MovieMP4 = 9,
3183 k_ECommunityProfileItemProperty_MovieWebMSmall = 10,
3184 k_ECommunityProfileItemProperty_MovieMP4Small = 11,
3185}
3186#[repr(C)]
3187pub struct ISteamFriends__bindgen_vtable(::std::os::raw::c_void);
3188#[repr(C)]
3189#[derive(Debug, Copy, Clone)]
3190pub struct ISteamFriends {
3191 pub vtable_: *const ISteamFriends__bindgen_vtable,
3192}
3193#[test]
3194fn bindgen_test_layout_ISteamFriends() {
3195 assert_eq!(
3196 ::std::mem::size_of::<ISteamFriends>(),
3197 8usize,
3198 concat!("Size of: ", stringify!(ISteamFriends))
3199 );
3200 assert_eq!(
3201 ::std::mem::align_of::<ISteamFriends>(),
3202 8usize,
3203 concat!("Alignment of ", stringify!(ISteamFriends))
3204 );
3205}
3206#[repr(C, packed(4))]
3207#[derive(Debug, Copy, Clone)]
3208pub struct PersonaStateChange_t {
3209 pub m_ulSteamID: uint64,
3210 pub m_nChangeFlags: ::std::os::raw::c_int,
3211}
3212pub const PersonaStateChange_t_k_iCallback: PersonaStateChange_t__bindgen_ty_1 =
3213 PersonaStateChange_t__bindgen_ty_1::k_iCallback;
3214#[repr(u32)]
3215#[non_exhaustive]
3216#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3217pub enum PersonaStateChange_t__bindgen_ty_1 {
3218 k_iCallback = 304,
3219}
3220#[test]
3221fn bindgen_test_layout_PersonaStateChange_t() {
3222 const UNINIT: ::std::mem::MaybeUninit<PersonaStateChange_t> = ::std::mem::MaybeUninit::uninit();
3223 let ptr = UNINIT.as_ptr();
3224 assert_eq!(
3225 ::std::mem::size_of::<PersonaStateChange_t>(),
3226 12usize,
3227 concat!("Size of: ", stringify!(PersonaStateChange_t))
3228 );
3229 assert_eq!(
3230 ::std::mem::align_of::<PersonaStateChange_t>(),
3231 4usize,
3232 concat!("Alignment of ", stringify!(PersonaStateChange_t))
3233 );
3234 assert_eq!(
3235 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamID) as usize - ptr as usize },
3236 0usize,
3237 concat!(
3238 "Offset of field: ",
3239 stringify!(PersonaStateChange_t),
3240 "::",
3241 stringify!(m_ulSteamID)
3242 )
3243 );
3244 assert_eq!(
3245 unsafe { ::std::ptr::addr_of!((*ptr).m_nChangeFlags) as usize - ptr as usize },
3246 8usize,
3247 concat!(
3248 "Offset of field: ",
3249 stringify!(PersonaStateChange_t),
3250 "::",
3251 stringify!(m_nChangeFlags)
3252 )
3253 );
3254}
3255impl EPersonaChange {
3256 pub const k_EPersonaChangeName: EPersonaChange = EPersonaChange(1);
3257}
3258impl EPersonaChange {
3259 pub const k_EPersonaChangeStatus: EPersonaChange = EPersonaChange(2);
3260}
3261impl EPersonaChange {
3262 pub const k_EPersonaChangeComeOnline: EPersonaChange = EPersonaChange(4);
3263}
3264impl EPersonaChange {
3265 pub const k_EPersonaChangeGoneOffline: EPersonaChange = EPersonaChange(8);
3266}
3267impl EPersonaChange {
3268 pub const k_EPersonaChangeGamePlayed: EPersonaChange = EPersonaChange(16);
3269}
3270impl EPersonaChange {
3271 pub const k_EPersonaChangeGameServer: EPersonaChange = EPersonaChange(32);
3272}
3273impl EPersonaChange {
3274 pub const k_EPersonaChangeAvatar: EPersonaChange = EPersonaChange(64);
3275}
3276impl EPersonaChange {
3277 pub const k_EPersonaChangeJoinedSource: EPersonaChange = EPersonaChange(128);
3278}
3279impl EPersonaChange {
3280 pub const k_EPersonaChangeLeftSource: EPersonaChange = EPersonaChange(256);
3281}
3282impl EPersonaChange {
3283 pub const k_EPersonaChangeRelationshipChanged: EPersonaChange = EPersonaChange(512);
3284}
3285impl EPersonaChange {
3286 pub const k_EPersonaChangeNameFirstSet: EPersonaChange = EPersonaChange(1024);
3287}
3288impl EPersonaChange {
3289 pub const k_EPersonaChangeBroadcast: EPersonaChange = EPersonaChange(2048);
3290}
3291impl EPersonaChange {
3292 pub const k_EPersonaChangeNickname: EPersonaChange = EPersonaChange(4096);
3293}
3294impl EPersonaChange {
3295 pub const k_EPersonaChangeSteamLevel: EPersonaChange = EPersonaChange(8192);
3296}
3297impl EPersonaChange {
3298 pub const k_EPersonaChangeRichPresence: EPersonaChange = EPersonaChange(16384);
3299}
3300impl ::std::ops::BitOr<EPersonaChange> for EPersonaChange {
3301 type Output = Self;
3302 #[inline]
3303 fn bitor(self, other: Self) -> Self {
3304 EPersonaChange(self.0 | other.0)
3305 }
3306}
3307impl ::std::ops::BitOrAssign for EPersonaChange {
3308 #[inline]
3309 fn bitor_assign(&mut self, rhs: EPersonaChange) {
3310 self.0 |= rhs.0;
3311 }
3312}
3313impl ::std::ops::BitAnd<EPersonaChange> for EPersonaChange {
3314 type Output = Self;
3315 #[inline]
3316 fn bitand(self, other: Self) -> Self {
3317 EPersonaChange(self.0 & other.0)
3318 }
3319}
3320impl ::std::ops::BitAndAssign for EPersonaChange {
3321 #[inline]
3322 fn bitand_assign(&mut self, rhs: EPersonaChange) {
3323 self.0 &= rhs.0;
3324 }
3325}
3326#[repr(transparent)]
3327#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3328pub struct EPersonaChange(pub ::std::os::raw::c_uint);
3329#[repr(C)]
3330#[derive(Debug, Copy, Clone)]
3331pub struct GameOverlayActivated_t {
3332 pub m_bActive: uint8,
3333 pub m_bUserInitiated: bool,
3334 pub m_nAppID: AppId_t,
3335 pub m_dwOverlayPID: uint32,
3336}
3337pub const GameOverlayActivated_t_k_iCallback: GameOverlayActivated_t__bindgen_ty_1 =
3338 GameOverlayActivated_t__bindgen_ty_1::k_iCallback;
3339#[repr(u32)]
3340#[non_exhaustive]
3341#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3342pub enum GameOverlayActivated_t__bindgen_ty_1 {
3343 k_iCallback = 331,
3344}
3345#[test]
3346fn bindgen_test_layout_GameOverlayActivated_t() {
3347 const UNINIT: ::std::mem::MaybeUninit<GameOverlayActivated_t> =
3348 ::std::mem::MaybeUninit::uninit();
3349 let ptr = UNINIT.as_ptr();
3350 assert_eq!(
3351 ::std::mem::size_of::<GameOverlayActivated_t>(),
3352 12usize,
3353 concat!("Size of: ", stringify!(GameOverlayActivated_t))
3354 );
3355 assert_eq!(
3356 ::std::mem::align_of::<GameOverlayActivated_t>(),
3357 4usize,
3358 concat!("Alignment of ", stringify!(GameOverlayActivated_t))
3359 );
3360 assert_eq!(
3361 unsafe { ::std::ptr::addr_of!((*ptr).m_bActive) as usize - ptr as usize },
3362 0usize,
3363 concat!(
3364 "Offset of field: ",
3365 stringify!(GameOverlayActivated_t),
3366 "::",
3367 stringify!(m_bActive)
3368 )
3369 );
3370 assert_eq!(
3371 unsafe { ::std::ptr::addr_of!((*ptr).m_bUserInitiated) as usize - ptr as usize },
3372 1usize,
3373 concat!(
3374 "Offset of field: ",
3375 stringify!(GameOverlayActivated_t),
3376 "::",
3377 stringify!(m_bUserInitiated)
3378 )
3379 );
3380 assert_eq!(
3381 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
3382 4usize,
3383 concat!(
3384 "Offset of field: ",
3385 stringify!(GameOverlayActivated_t),
3386 "::",
3387 stringify!(m_nAppID)
3388 )
3389 );
3390 assert_eq!(
3391 unsafe { ::std::ptr::addr_of!((*ptr).m_dwOverlayPID) as usize - ptr as usize },
3392 8usize,
3393 concat!(
3394 "Offset of field: ",
3395 stringify!(GameOverlayActivated_t),
3396 "::",
3397 stringify!(m_dwOverlayPID)
3398 )
3399 );
3400}
3401#[repr(C)]
3402#[derive(Debug, Copy, Clone)]
3403pub struct GameServerChangeRequested_t {
3404 pub m_rgchServer: [::std::os::raw::c_char; 64usize],
3405 pub m_rgchPassword: [::std::os::raw::c_char; 64usize],
3406}
3407pub const GameServerChangeRequested_t_k_iCallback: GameServerChangeRequested_t__bindgen_ty_1 =
3408 GameServerChangeRequested_t__bindgen_ty_1::k_iCallback;
3409#[repr(u32)]
3410#[non_exhaustive]
3411#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3412pub enum GameServerChangeRequested_t__bindgen_ty_1 {
3413 k_iCallback = 332,
3414}
3415#[test]
3416fn bindgen_test_layout_GameServerChangeRequested_t() {
3417 const UNINIT: ::std::mem::MaybeUninit<GameServerChangeRequested_t> =
3418 ::std::mem::MaybeUninit::uninit();
3419 let ptr = UNINIT.as_ptr();
3420 assert_eq!(
3421 ::std::mem::size_of::<GameServerChangeRequested_t>(),
3422 128usize,
3423 concat!("Size of: ", stringify!(GameServerChangeRequested_t))
3424 );
3425 assert_eq!(
3426 ::std::mem::align_of::<GameServerChangeRequested_t>(),
3427 1usize,
3428 concat!("Alignment of ", stringify!(GameServerChangeRequested_t))
3429 );
3430 assert_eq!(
3431 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchServer) as usize - ptr as usize },
3432 0usize,
3433 concat!(
3434 "Offset of field: ",
3435 stringify!(GameServerChangeRequested_t),
3436 "::",
3437 stringify!(m_rgchServer)
3438 )
3439 );
3440 assert_eq!(
3441 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchPassword) as usize - ptr as usize },
3442 64usize,
3443 concat!(
3444 "Offset of field: ",
3445 stringify!(GameServerChangeRequested_t),
3446 "::",
3447 stringify!(m_rgchPassword)
3448 )
3449 );
3450}
3451#[repr(C)]
3452#[derive(Copy, Clone)]
3453pub struct GameLobbyJoinRequested_t {
3454 pub m_steamIDLobby: CSteamID,
3455 pub m_steamIDFriend: CSteamID,
3456}
3457pub const GameLobbyJoinRequested_t_k_iCallback: GameLobbyJoinRequested_t__bindgen_ty_1 =
3458 GameLobbyJoinRequested_t__bindgen_ty_1::k_iCallback;
3459#[repr(u32)]
3460#[non_exhaustive]
3461#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3462pub enum GameLobbyJoinRequested_t__bindgen_ty_1 {
3463 k_iCallback = 333,
3464}
3465#[test]
3466fn bindgen_test_layout_GameLobbyJoinRequested_t() {
3467 const UNINIT: ::std::mem::MaybeUninit<GameLobbyJoinRequested_t> =
3468 ::std::mem::MaybeUninit::uninit();
3469 let ptr = UNINIT.as_ptr();
3470 assert_eq!(
3471 ::std::mem::size_of::<GameLobbyJoinRequested_t>(),
3472 16usize,
3473 concat!("Size of: ", stringify!(GameLobbyJoinRequested_t))
3474 );
3475 assert_eq!(
3476 ::std::mem::align_of::<GameLobbyJoinRequested_t>(),
3477 1usize,
3478 concat!("Alignment of ", stringify!(GameLobbyJoinRequested_t))
3479 );
3480 assert_eq!(
3481 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDLobby) as usize - ptr as usize },
3482 0usize,
3483 concat!(
3484 "Offset of field: ",
3485 stringify!(GameLobbyJoinRequested_t),
3486 "::",
3487 stringify!(m_steamIDLobby)
3488 )
3489 );
3490 assert_eq!(
3491 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDFriend) as usize - ptr as usize },
3492 8usize,
3493 concat!(
3494 "Offset of field: ",
3495 stringify!(GameLobbyJoinRequested_t),
3496 "::",
3497 stringify!(m_steamIDFriend)
3498 )
3499 );
3500}
3501#[repr(C)]
3502#[derive(Copy, Clone)]
3503pub struct AvatarImageLoaded_t {
3504 pub m_steamID: CSteamID,
3505 pub m_iImage: ::std::os::raw::c_int,
3506 pub m_iWide: ::std::os::raw::c_int,
3507 pub m_iTall: ::std::os::raw::c_int,
3508}
3509pub const AvatarImageLoaded_t_k_iCallback: AvatarImageLoaded_t__bindgen_ty_1 =
3510 AvatarImageLoaded_t__bindgen_ty_1::k_iCallback;
3511#[repr(u32)]
3512#[non_exhaustive]
3513#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3514pub enum AvatarImageLoaded_t__bindgen_ty_1 {
3515 k_iCallback = 334,
3516}
3517#[test]
3518fn bindgen_test_layout_AvatarImageLoaded_t() {
3519 const UNINIT: ::std::mem::MaybeUninit<AvatarImageLoaded_t> = ::std::mem::MaybeUninit::uninit();
3520 let ptr = UNINIT.as_ptr();
3521 assert_eq!(
3522 ::std::mem::size_of::<AvatarImageLoaded_t>(),
3523 20usize,
3524 concat!("Size of: ", stringify!(AvatarImageLoaded_t))
3525 );
3526 assert_eq!(
3527 ::std::mem::align_of::<AvatarImageLoaded_t>(),
3528 4usize,
3529 concat!("Alignment of ", stringify!(AvatarImageLoaded_t))
3530 );
3531 assert_eq!(
3532 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
3533 0usize,
3534 concat!(
3535 "Offset of field: ",
3536 stringify!(AvatarImageLoaded_t),
3537 "::",
3538 stringify!(m_steamID)
3539 )
3540 );
3541 assert_eq!(
3542 unsafe { ::std::ptr::addr_of!((*ptr).m_iImage) as usize - ptr as usize },
3543 8usize,
3544 concat!(
3545 "Offset of field: ",
3546 stringify!(AvatarImageLoaded_t),
3547 "::",
3548 stringify!(m_iImage)
3549 )
3550 );
3551 assert_eq!(
3552 unsafe { ::std::ptr::addr_of!((*ptr).m_iWide) as usize - ptr as usize },
3553 12usize,
3554 concat!(
3555 "Offset of field: ",
3556 stringify!(AvatarImageLoaded_t),
3557 "::",
3558 stringify!(m_iWide)
3559 )
3560 );
3561 assert_eq!(
3562 unsafe { ::std::ptr::addr_of!((*ptr).m_iTall) as usize - ptr as usize },
3563 16usize,
3564 concat!(
3565 "Offset of field: ",
3566 stringify!(AvatarImageLoaded_t),
3567 "::",
3568 stringify!(m_iTall)
3569 )
3570 );
3571}
3572#[repr(C)]
3573#[derive(Copy, Clone)]
3574pub struct ClanOfficerListResponse_t {
3575 pub m_steamIDClan: CSteamID,
3576 pub m_cOfficers: ::std::os::raw::c_int,
3577 pub m_bSuccess: uint8,
3578}
3579pub const ClanOfficerListResponse_t_k_iCallback: ClanOfficerListResponse_t__bindgen_ty_1 =
3580 ClanOfficerListResponse_t__bindgen_ty_1::k_iCallback;
3581#[repr(u32)]
3582#[non_exhaustive]
3583#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3584pub enum ClanOfficerListResponse_t__bindgen_ty_1 {
3585 k_iCallback = 335,
3586}
3587#[test]
3588fn bindgen_test_layout_ClanOfficerListResponse_t() {
3589 const UNINIT: ::std::mem::MaybeUninit<ClanOfficerListResponse_t> =
3590 ::std::mem::MaybeUninit::uninit();
3591 let ptr = UNINIT.as_ptr();
3592 assert_eq!(
3593 ::std::mem::size_of::<ClanOfficerListResponse_t>(),
3594 16usize,
3595 concat!("Size of: ", stringify!(ClanOfficerListResponse_t))
3596 );
3597 assert_eq!(
3598 ::std::mem::align_of::<ClanOfficerListResponse_t>(),
3599 4usize,
3600 concat!("Alignment of ", stringify!(ClanOfficerListResponse_t))
3601 );
3602 assert_eq!(
3603 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDClan) as usize - ptr as usize },
3604 0usize,
3605 concat!(
3606 "Offset of field: ",
3607 stringify!(ClanOfficerListResponse_t),
3608 "::",
3609 stringify!(m_steamIDClan)
3610 )
3611 );
3612 assert_eq!(
3613 unsafe { ::std::ptr::addr_of!((*ptr).m_cOfficers) as usize - ptr as usize },
3614 8usize,
3615 concat!(
3616 "Offset of field: ",
3617 stringify!(ClanOfficerListResponse_t),
3618 "::",
3619 stringify!(m_cOfficers)
3620 )
3621 );
3622 assert_eq!(
3623 unsafe { ::std::ptr::addr_of!((*ptr).m_bSuccess) as usize - ptr as usize },
3624 12usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(ClanOfficerListResponse_t),
3628 "::",
3629 stringify!(m_bSuccess)
3630 )
3631 );
3632}
3633#[repr(C)]
3634#[derive(Copy, Clone)]
3635pub struct FriendRichPresenceUpdate_t {
3636 pub m_steamIDFriend: CSteamID,
3637 pub m_nAppID: AppId_t,
3638}
3639pub const FriendRichPresenceUpdate_t_k_iCallback: FriendRichPresenceUpdate_t__bindgen_ty_1 =
3640 FriendRichPresenceUpdate_t__bindgen_ty_1::k_iCallback;
3641#[repr(u32)]
3642#[non_exhaustive]
3643#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3644pub enum FriendRichPresenceUpdate_t__bindgen_ty_1 {
3645 k_iCallback = 336,
3646}
3647#[test]
3648fn bindgen_test_layout_FriendRichPresenceUpdate_t() {
3649 const UNINIT: ::std::mem::MaybeUninit<FriendRichPresenceUpdate_t> =
3650 ::std::mem::MaybeUninit::uninit();
3651 let ptr = UNINIT.as_ptr();
3652 assert_eq!(
3653 ::std::mem::size_of::<FriendRichPresenceUpdate_t>(),
3654 12usize,
3655 concat!("Size of: ", stringify!(FriendRichPresenceUpdate_t))
3656 );
3657 assert_eq!(
3658 ::std::mem::align_of::<FriendRichPresenceUpdate_t>(),
3659 4usize,
3660 concat!("Alignment of ", stringify!(FriendRichPresenceUpdate_t))
3661 );
3662 assert_eq!(
3663 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDFriend) as usize - ptr as usize },
3664 0usize,
3665 concat!(
3666 "Offset of field: ",
3667 stringify!(FriendRichPresenceUpdate_t),
3668 "::",
3669 stringify!(m_steamIDFriend)
3670 )
3671 );
3672 assert_eq!(
3673 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
3674 8usize,
3675 concat!(
3676 "Offset of field: ",
3677 stringify!(FriendRichPresenceUpdate_t),
3678 "::",
3679 stringify!(m_nAppID)
3680 )
3681 );
3682}
3683#[repr(C)]
3684#[derive(Copy, Clone)]
3685pub struct GameRichPresenceJoinRequested_t {
3686 pub m_steamIDFriend: CSteamID,
3687 pub m_rgchConnect: [::std::os::raw::c_char; 256usize],
3688}
3689pub const GameRichPresenceJoinRequested_t_k_iCallback:
3690 GameRichPresenceJoinRequested_t__bindgen_ty_1 =
3691 GameRichPresenceJoinRequested_t__bindgen_ty_1::k_iCallback;
3692#[repr(u32)]
3693#[non_exhaustive]
3694#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3695pub enum GameRichPresenceJoinRequested_t__bindgen_ty_1 {
3696 k_iCallback = 337,
3697}
3698#[test]
3699fn bindgen_test_layout_GameRichPresenceJoinRequested_t() {
3700 const UNINIT: ::std::mem::MaybeUninit<GameRichPresenceJoinRequested_t> =
3701 ::std::mem::MaybeUninit::uninit();
3702 let ptr = UNINIT.as_ptr();
3703 assert_eq!(
3704 ::std::mem::size_of::<GameRichPresenceJoinRequested_t>(),
3705 264usize,
3706 concat!("Size of: ", stringify!(GameRichPresenceJoinRequested_t))
3707 );
3708 assert_eq!(
3709 ::std::mem::align_of::<GameRichPresenceJoinRequested_t>(),
3710 1usize,
3711 concat!("Alignment of ", stringify!(GameRichPresenceJoinRequested_t))
3712 );
3713 assert_eq!(
3714 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDFriend) as usize - ptr as usize },
3715 0usize,
3716 concat!(
3717 "Offset of field: ",
3718 stringify!(GameRichPresenceJoinRequested_t),
3719 "::",
3720 stringify!(m_steamIDFriend)
3721 )
3722 );
3723 assert_eq!(
3724 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchConnect) as usize - ptr as usize },
3725 8usize,
3726 concat!(
3727 "Offset of field: ",
3728 stringify!(GameRichPresenceJoinRequested_t),
3729 "::",
3730 stringify!(m_rgchConnect)
3731 )
3732 );
3733}
3734#[repr(C)]
3735#[derive(Copy, Clone)]
3736pub struct GameConnectedClanChatMsg_t {
3737 pub m_steamIDClanChat: CSteamID,
3738 pub m_steamIDUser: CSteamID,
3739 pub m_iMessageID: ::std::os::raw::c_int,
3740}
3741pub const GameConnectedClanChatMsg_t_k_iCallback: GameConnectedClanChatMsg_t__bindgen_ty_1 =
3742 GameConnectedClanChatMsg_t__bindgen_ty_1::k_iCallback;
3743#[repr(u32)]
3744#[non_exhaustive]
3745#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3746pub enum GameConnectedClanChatMsg_t__bindgen_ty_1 {
3747 k_iCallback = 338,
3748}
3749#[test]
3750fn bindgen_test_layout_GameConnectedClanChatMsg_t() {
3751 const UNINIT: ::std::mem::MaybeUninit<GameConnectedClanChatMsg_t> =
3752 ::std::mem::MaybeUninit::uninit();
3753 let ptr = UNINIT.as_ptr();
3754 assert_eq!(
3755 ::std::mem::size_of::<GameConnectedClanChatMsg_t>(),
3756 20usize,
3757 concat!("Size of: ", stringify!(GameConnectedClanChatMsg_t))
3758 );
3759 assert_eq!(
3760 ::std::mem::align_of::<GameConnectedClanChatMsg_t>(),
3761 4usize,
3762 concat!("Alignment of ", stringify!(GameConnectedClanChatMsg_t))
3763 );
3764 assert_eq!(
3765 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDClanChat) as usize - ptr as usize },
3766 0usize,
3767 concat!(
3768 "Offset of field: ",
3769 stringify!(GameConnectedClanChatMsg_t),
3770 "::",
3771 stringify!(m_steamIDClanChat)
3772 )
3773 );
3774 assert_eq!(
3775 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
3776 8usize,
3777 concat!(
3778 "Offset of field: ",
3779 stringify!(GameConnectedClanChatMsg_t),
3780 "::",
3781 stringify!(m_steamIDUser)
3782 )
3783 );
3784 assert_eq!(
3785 unsafe { ::std::ptr::addr_of!((*ptr).m_iMessageID) as usize - ptr as usize },
3786 16usize,
3787 concat!(
3788 "Offset of field: ",
3789 stringify!(GameConnectedClanChatMsg_t),
3790 "::",
3791 stringify!(m_iMessageID)
3792 )
3793 );
3794}
3795#[repr(C)]
3796#[derive(Copy, Clone)]
3797pub struct GameConnectedChatJoin_t {
3798 pub m_steamIDClanChat: CSteamID,
3799 pub m_steamIDUser: CSteamID,
3800}
3801pub const GameConnectedChatJoin_t_k_iCallback: GameConnectedChatJoin_t__bindgen_ty_1 =
3802 GameConnectedChatJoin_t__bindgen_ty_1::k_iCallback;
3803#[repr(u32)]
3804#[non_exhaustive]
3805#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3806pub enum GameConnectedChatJoin_t__bindgen_ty_1 {
3807 k_iCallback = 339,
3808}
3809#[test]
3810fn bindgen_test_layout_GameConnectedChatJoin_t() {
3811 const UNINIT: ::std::mem::MaybeUninit<GameConnectedChatJoin_t> =
3812 ::std::mem::MaybeUninit::uninit();
3813 let ptr = UNINIT.as_ptr();
3814 assert_eq!(
3815 ::std::mem::size_of::<GameConnectedChatJoin_t>(),
3816 16usize,
3817 concat!("Size of: ", stringify!(GameConnectedChatJoin_t))
3818 );
3819 assert_eq!(
3820 ::std::mem::align_of::<GameConnectedChatJoin_t>(),
3821 1usize,
3822 concat!("Alignment of ", stringify!(GameConnectedChatJoin_t))
3823 );
3824 assert_eq!(
3825 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDClanChat) as usize - ptr as usize },
3826 0usize,
3827 concat!(
3828 "Offset of field: ",
3829 stringify!(GameConnectedChatJoin_t),
3830 "::",
3831 stringify!(m_steamIDClanChat)
3832 )
3833 );
3834 assert_eq!(
3835 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
3836 8usize,
3837 concat!(
3838 "Offset of field: ",
3839 stringify!(GameConnectedChatJoin_t),
3840 "::",
3841 stringify!(m_steamIDUser)
3842 )
3843 );
3844}
3845#[repr(C)]
3846#[derive(Copy, Clone)]
3847pub struct GameConnectedChatLeave_t {
3848 pub m_steamIDClanChat: CSteamID,
3849 pub m_steamIDUser: CSteamID,
3850 pub m_bKicked: bool,
3851 pub m_bDropped: bool,
3852}
3853pub const GameConnectedChatLeave_t_k_iCallback: GameConnectedChatLeave_t__bindgen_ty_1 =
3854 GameConnectedChatLeave_t__bindgen_ty_1::k_iCallback;
3855#[repr(u32)]
3856#[non_exhaustive]
3857#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3858pub enum GameConnectedChatLeave_t__bindgen_ty_1 {
3859 k_iCallback = 340,
3860}
3861#[test]
3862fn bindgen_test_layout_GameConnectedChatLeave_t() {
3863 const UNINIT: ::std::mem::MaybeUninit<GameConnectedChatLeave_t> =
3864 ::std::mem::MaybeUninit::uninit();
3865 let ptr = UNINIT.as_ptr();
3866 assert_eq!(
3867 ::std::mem::size_of::<GameConnectedChatLeave_t>(),
3868 18usize,
3869 concat!("Size of: ", stringify!(GameConnectedChatLeave_t))
3870 );
3871 assert_eq!(
3872 ::std::mem::align_of::<GameConnectedChatLeave_t>(),
3873 1usize,
3874 concat!("Alignment of ", stringify!(GameConnectedChatLeave_t))
3875 );
3876 assert_eq!(
3877 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDClanChat) as usize - ptr as usize },
3878 0usize,
3879 concat!(
3880 "Offset of field: ",
3881 stringify!(GameConnectedChatLeave_t),
3882 "::",
3883 stringify!(m_steamIDClanChat)
3884 )
3885 );
3886 assert_eq!(
3887 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
3888 8usize,
3889 concat!(
3890 "Offset of field: ",
3891 stringify!(GameConnectedChatLeave_t),
3892 "::",
3893 stringify!(m_steamIDUser)
3894 )
3895 );
3896 assert_eq!(
3897 unsafe { ::std::ptr::addr_of!((*ptr).m_bKicked) as usize - ptr as usize },
3898 16usize,
3899 concat!(
3900 "Offset of field: ",
3901 stringify!(GameConnectedChatLeave_t),
3902 "::",
3903 stringify!(m_bKicked)
3904 )
3905 );
3906 assert_eq!(
3907 unsafe { ::std::ptr::addr_of!((*ptr).m_bDropped) as usize - ptr as usize },
3908 17usize,
3909 concat!(
3910 "Offset of field: ",
3911 stringify!(GameConnectedChatLeave_t),
3912 "::",
3913 stringify!(m_bDropped)
3914 )
3915 );
3916}
3917#[repr(C)]
3918#[derive(Debug, Copy, Clone)]
3919pub struct DownloadClanActivityCountsResult_t {
3920 pub m_bSuccess: bool,
3921}
3922pub const DownloadClanActivityCountsResult_t_k_iCallback:
3923 DownloadClanActivityCountsResult_t__bindgen_ty_1 =
3924 DownloadClanActivityCountsResult_t__bindgen_ty_1::k_iCallback;
3925#[repr(u32)]
3926#[non_exhaustive]
3927#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3928pub enum DownloadClanActivityCountsResult_t__bindgen_ty_1 {
3929 k_iCallback = 341,
3930}
3931#[test]
3932fn bindgen_test_layout_DownloadClanActivityCountsResult_t() {
3933 const UNINIT: ::std::mem::MaybeUninit<DownloadClanActivityCountsResult_t> =
3934 ::std::mem::MaybeUninit::uninit();
3935 let ptr = UNINIT.as_ptr();
3936 assert_eq!(
3937 ::std::mem::size_of::<DownloadClanActivityCountsResult_t>(),
3938 1usize,
3939 concat!("Size of: ", stringify!(DownloadClanActivityCountsResult_t))
3940 );
3941 assert_eq!(
3942 ::std::mem::align_of::<DownloadClanActivityCountsResult_t>(),
3943 1usize,
3944 concat!(
3945 "Alignment of ",
3946 stringify!(DownloadClanActivityCountsResult_t)
3947 )
3948 );
3949 assert_eq!(
3950 unsafe { ::std::ptr::addr_of!((*ptr).m_bSuccess) as usize - ptr as usize },
3951 0usize,
3952 concat!(
3953 "Offset of field: ",
3954 stringify!(DownloadClanActivityCountsResult_t),
3955 "::",
3956 stringify!(m_bSuccess)
3957 )
3958 );
3959}
3960#[repr(C)]
3961#[derive(Copy, Clone)]
3962pub struct JoinClanChatRoomCompletionResult_t {
3963 pub m_steamIDClanChat: CSteamID,
3964 pub m_eChatRoomEnterResponse: EChatRoomEnterResponse,
3965}
3966pub const JoinClanChatRoomCompletionResult_t_k_iCallback:
3967 JoinClanChatRoomCompletionResult_t__bindgen_ty_1 =
3968 JoinClanChatRoomCompletionResult_t__bindgen_ty_1::k_iCallback;
3969#[repr(u32)]
3970#[non_exhaustive]
3971#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3972pub enum JoinClanChatRoomCompletionResult_t__bindgen_ty_1 {
3973 k_iCallback = 342,
3974}
3975#[test]
3976fn bindgen_test_layout_JoinClanChatRoomCompletionResult_t() {
3977 const UNINIT: ::std::mem::MaybeUninit<JoinClanChatRoomCompletionResult_t> =
3978 ::std::mem::MaybeUninit::uninit();
3979 let ptr = UNINIT.as_ptr();
3980 assert_eq!(
3981 ::std::mem::size_of::<JoinClanChatRoomCompletionResult_t>(),
3982 12usize,
3983 concat!("Size of: ", stringify!(JoinClanChatRoomCompletionResult_t))
3984 );
3985 assert_eq!(
3986 ::std::mem::align_of::<JoinClanChatRoomCompletionResult_t>(),
3987 4usize,
3988 concat!(
3989 "Alignment of ",
3990 stringify!(JoinClanChatRoomCompletionResult_t)
3991 )
3992 );
3993 assert_eq!(
3994 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDClanChat) as usize - ptr as usize },
3995 0usize,
3996 concat!(
3997 "Offset of field: ",
3998 stringify!(JoinClanChatRoomCompletionResult_t),
3999 "::",
4000 stringify!(m_steamIDClanChat)
4001 )
4002 );
4003 assert_eq!(
4004 unsafe { ::std::ptr::addr_of!((*ptr).m_eChatRoomEnterResponse) as usize - ptr as usize },
4005 8usize,
4006 concat!(
4007 "Offset of field: ",
4008 stringify!(JoinClanChatRoomCompletionResult_t),
4009 "::",
4010 stringify!(m_eChatRoomEnterResponse)
4011 )
4012 );
4013}
4014#[repr(C)]
4015#[derive(Copy, Clone)]
4016pub struct GameConnectedFriendChatMsg_t {
4017 pub m_steamIDUser: CSteamID,
4018 pub m_iMessageID: ::std::os::raw::c_int,
4019}
4020pub const GameConnectedFriendChatMsg_t_k_iCallback: GameConnectedFriendChatMsg_t__bindgen_ty_1 =
4021 GameConnectedFriendChatMsg_t__bindgen_ty_1::k_iCallback;
4022#[repr(u32)]
4023#[non_exhaustive]
4024#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4025pub enum GameConnectedFriendChatMsg_t__bindgen_ty_1 {
4026 k_iCallback = 343,
4027}
4028#[test]
4029fn bindgen_test_layout_GameConnectedFriendChatMsg_t() {
4030 const UNINIT: ::std::mem::MaybeUninit<GameConnectedFriendChatMsg_t> =
4031 ::std::mem::MaybeUninit::uninit();
4032 let ptr = UNINIT.as_ptr();
4033 assert_eq!(
4034 ::std::mem::size_of::<GameConnectedFriendChatMsg_t>(),
4035 12usize,
4036 concat!("Size of: ", stringify!(GameConnectedFriendChatMsg_t))
4037 );
4038 assert_eq!(
4039 ::std::mem::align_of::<GameConnectedFriendChatMsg_t>(),
4040 4usize,
4041 concat!("Alignment of ", stringify!(GameConnectedFriendChatMsg_t))
4042 );
4043 assert_eq!(
4044 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
4045 0usize,
4046 concat!(
4047 "Offset of field: ",
4048 stringify!(GameConnectedFriendChatMsg_t),
4049 "::",
4050 stringify!(m_steamIDUser)
4051 )
4052 );
4053 assert_eq!(
4054 unsafe { ::std::ptr::addr_of!((*ptr).m_iMessageID) as usize - ptr as usize },
4055 8usize,
4056 concat!(
4057 "Offset of field: ",
4058 stringify!(GameConnectedFriendChatMsg_t),
4059 "::",
4060 stringify!(m_iMessageID)
4061 )
4062 );
4063}
4064#[repr(C)]
4065#[derive(Copy, Clone)]
4066pub struct FriendsGetFollowerCount_t {
4067 pub m_eResult: EResult,
4068 pub m_steamID: CSteamID,
4069 pub m_nCount: ::std::os::raw::c_int,
4070}
4071pub const FriendsGetFollowerCount_t_k_iCallback: FriendsGetFollowerCount_t__bindgen_ty_1 =
4072 FriendsGetFollowerCount_t__bindgen_ty_1::k_iCallback;
4073#[repr(u32)]
4074#[non_exhaustive]
4075#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4076pub enum FriendsGetFollowerCount_t__bindgen_ty_1 {
4077 k_iCallback = 344,
4078}
4079#[test]
4080fn bindgen_test_layout_FriendsGetFollowerCount_t() {
4081 const UNINIT: ::std::mem::MaybeUninit<FriendsGetFollowerCount_t> =
4082 ::std::mem::MaybeUninit::uninit();
4083 let ptr = UNINIT.as_ptr();
4084 assert_eq!(
4085 ::std::mem::size_of::<FriendsGetFollowerCount_t>(),
4086 16usize,
4087 concat!("Size of: ", stringify!(FriendsGetFollowerCount_t))
4088 );
4089 assert_eq!(
4090 ::std::mem::align_of::<FriendsGetFollowerCount_t>(),
4091 4usize,
4092 concat!("Alignment of ", stringify!(FriendsGetFollowerCount_t))
4093 );
4094 assert_eq!(
4095 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
4096 0usize,
4097 concat!(
4098 "Offset of field: ",
4099 stringify!(FriendsGetFollowerCount_t),
4100 "::",
4101 stringify!(m_eResult)
4102 )
4103 );
4104 assert_eq!(
4105 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
4106 4usize,
4107 concat!(
4108 "Offset of field: ",
4109 stringify!(FriendsGetFollowerCount_t),
4110 "::",
4111 stringify!(m_steamID)
4112 )
4113 );
4114 assert_eq!(
4115 unsafe { ::std::ptr::addr_of!((*ptr).m_nCount) as usize - ptr as usize },
4116 12usize,
4117 concat!(
4118 "Offset of field: ",
4119 stringify!(FriendsGetFollowerCount_t),
4120 "::",
4121 stringify!(m_nCount)
4122 )
4123 );
4124}
4125#[repr(C)]
4126#[derive(Copy, Clone)]
4127pub struct FriendsIsFollowing_t {
4128 pub m_eResult: EResult,
4129 pub m_steamID: CSteamID,
4130 pub m_bIsFollowing: bool,
4131}
4132pub const FriendsIsFollowing_t_k_iCallback: FriendsIsFollowing_t__bindgen_ty_1 =
4133 FriendsIsFollowing_t__bindgen_ty_1::k_iCallback;
4134#[repr(u32)]
4135#[non_exhaustive]
4136#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4137pub enum FriendsIsFollowing_t__bindgen_ty_1 {
4138 k_iCallback = 345,
4139}
4140#[test]
4141fn bindgen_test_layout_FriendsIsFollowing_t() {
4142 const UNINIT: ::std::mem::MaybeUninit<FriendsIsFollowing_t> = ::std::mem::MaybeUninit::uninit();
4143 let ptr = UNINIT.as_ptr();
4144 assert_eq!(
4145 ::std::mem::size_of::<FriendsIsFollowing_t>(),
4146 16usize,
4147 concat!("Size of: ", stringify!(FriendsIsFollowing_t))
4148 );
4149 assert_eq!(
4150 ::std::mem::align_of::<FriendsIsFollowing_t>(),
4151 4usize,
4152 concat!("Alignment of ", stringify!(FriendsIsFollowing_t))
4153 );
4154 assert_eq!(
4155 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
4156 0usize,
4157 concat!(
4158 "Offset of field: ",
4159 stringify!(FriendsIsFollowing_t),
4160 "::",
4161 stringify!(m_eResult)
4162 )
4163 );
4164 assert_eq!(
4165 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
4166 4usize,
4167 concat!(
4168 "Offset of field: ",
4169 stringify!(FriendsIsFollowing_t),
4170 "::",
4171 stringify!(m_steamID)
4172 )
4173 );
4174 assert_eq!(
4175 unsafe { ::std::ptr::addr_of!((*ptr).m_bIsFollowing) as usize - ptr as usize },
4176 12usize,
4177 concat!(
4178 "Offset of field: ",
4179 stringify!(FriendsIsFollowing_t),
4180 "::",
4181 stringify!(m_bIsFollowing)
4182 )
4183 );
4184}
4185#[repr(C)]
4186#[derive(Copy, Clone)]
4187pub struct FriendsEnumerateFollowingList_t {
4188 pub m_eResult: EResult,
4189 pub m_rgSteamID: [CSteamID; 50usize],
4190 pub m_nResultsReturned: int32,
4191 pub m_nTotalResultCount: int32,
4192}
4193pub const FriendsEnumerateFollowingList_t_k_iCallback:
4194 FriendsEnumerateFollowingList_t__bindgen_ty_1 =
4195 FriendsEnumerateFollowingList_t__bindgen_ty_1::k_iCallback;
4196#[repr(u32)]
4197#[non_exhaustive]
4198#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4199pub enum FriendsEnumerateFollowingList_t__bindgen_ty_1 {
4200 k_iCallback = 346,
4201}
4202#[test]
4203fn bindgen_test_layout_FriendsEnumerateFollowingList_t() {
4204 const UNINIT: ::std::mem::MaybeUninit<FriendsEnumerateFollowingList_t> =
4205 ::std::mem::MaybeUninit::uninit();
4206 let ptr = UNINIT.as_ptr();
4207 assert_eq!(
4208 ::std::mem::size_of::<FriendsEnumerateFollowingList_t>(),
4209 412usize,
4210 concat!("Size of: ", stringify!(FriendsEnumerateFollowingList_t))
4211 );
4212 assert_eq!(
4213 ::std::mem::align_of::<FriendsEnumerateFollowingList_t>(),
4214 4usize,
4215 concat!("Alignment of ", stringify!(FriendsEnumerateFollowingList_t))
4216 );
4217 assert_eq!(
4218 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
4219 0usize,
4220 concat!(
4221 "Offset of field: ",
4222 stringify!(FriendsEnumerateFollowingList_t),
4223 "::",
4224 stringify!(m_eResult)
4225 )
4226 );
4227 assert_eq!(
4228 unsafe { ::std::ptr::addr_of!((*ptr).m_rgSteamID) as usize - ptr as usize },
4229 4usize,
4230 concat!(
4231 "Offset of field: ",
4232 stringify!(FriendsEnumerateFollowingList_t),
4233 "::",
4234 stringify!(m_rgSteamID)
4235 )
4236 );
4237 assert_eq!(
4238 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
4239 404usize,
4240 concat!(
4241 "Offset of field: ",
4242 stringify!(FriendsEnumerateFollowingList_t),
4243 "::",
4244 stringify!(m_nResultsReturned)
4245 )
4246 );
4247 assert_eq!(
4248 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
4249 408usize,
4250 concat!(
4251 "Offset of field: ",
4252 stringify!(FriendsEnumerateFollowingList_t),
4253 "::",
4254 stringify!(m_nTotalResultCount)
4255 )
4256 );
4257}
4258#[repr(C)]
4259#[derive(Debug, Copy, Clone)]
4260pub struct UnreadChatMessagesChanged_t {
4261 pub _address: u8,
4262}
4263pub const UnreadChatMessagesChanged_t_k_iCallback: UnreadChatMessagesChanged_t__bindgen_ty_1 =
4264 UnreadChatMessagesChanged_t__bindgen_ty_1::k_iCallback;
4265#[repr(u32)]
4266#[non_exhaustive]
4267#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4268pub enum UnreadChatMessagesChanged_t__bindgen_ty_1 {
4269 k_iCallback = 348,
4270}
4271#[test]
4272fn bindgen_test_layout_UnreadChatMessagesChanged_t() {
4273 assert_eq!(
4274 ::std::mem::size_of::<UnreadChatMessagesChanged_t>(),
4275 1usize,
4276 concat!("Size of: ", stringify!(UnreadChatMessagesChanged_t))
4277 );
4278 assert_eq!(
4279 ::std::mem::align_of::<UnreadChatMessagesChanged_t>(),
4280 1usize,
4281 concat!("Alignment of ", stringify!(UnreadChatMessagesChanged_t))
4282 );
4283}
4284#[repr(C)]
4285#[derive(Debug, Copy, Clone)]
4286pub struct OverlayBrowserProtocolNavigation_t {
4287 pub rgchURI: [::std::os::raw::c_char; 1024usize],
4288}
4289pub const OverlayBrowserProtocolNavigation_t_k_iCallback:
4290 OverlayBrowserProtocolNavigation_t__bindgen_ty_1 =
4291 OverlayBrowserProtocolNavigation_t__bindgen_ty_1::k_iCallback;
4292#[repr(u32)]
4293#[non_exhaustive]
4294#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4295pub enum OverlayBrowserProtocolNavigation_t__bindgen_ty_1 {
4296 k_iCallback = 349,
4297}
4298#[test]
4299fn bindgen_test_layout_OverlayBrowserProtocolNavigation_t() {
4300 const UNINIT: ::std::mem::MaybeUninit<OverlayBrowserProtocolNavigation_t> =
4301 ::std::mem::MaybeUninit::uninit();
4302 let ptr = UNINIT.as_ptr();
4303 assert_eq!(
4304 ::std::mem::size_of::<OverlayBrowserProtocolNavigation_t>(),
4305 1024usize,
4306 concat!("Size of: ", stringify!(OverlayBrowserProtocolNavigation_t))
4307 );
4308 assert_eq!(
4309 ::std::mem::align_of::<OverlayBrowserProtocolNavigation_t>(),
4310 1usize,
4311 concat!(
4312 "Alignment of ",
4313 stringify!(OverlayBrowserProtocolNavigation_t)
4314 )
4315 );
4316 assert_eq!(
4317 unsafe { ::std::ptr::addr_of!((*ptr).rgchURI) as usize - ptr as usize },
4318 0usize,
4319 concat!(
4320 "Offset of field: ",
4321 stringify!(OverlayBrowserProtocolNavigation_t),
4322 "::",
4323 stringify!(rgchURI)
4324 )
4325 );
4326}
4327#[repr(C)]
4328#[derive(Copy, Clone)]
4329pub struct EquippedProfileItemsChanged_t {
4330 pub m_steamID: CSteamID,
4331}
4332pub const EquippedProfileItemsChanged_t_k_iCallback: EquippedProfileItemsChanged_t__bindgen_ty_1 =
4333 EquippedProfileItemsChanged_t__bindgen_ty_1::k_iCallback;
4334#[repr(u32)]
4335#[non_exhaustive]
4336#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4337pub enum EquippedProfileItemsChanged_t__bindgen_ty_1 {
4338 k_iCallback = 350,
4339}
4340#[test]
4341fn bindgen_test_layout_EquippedProfileItemsChanged_t() {
4342 const UNINIT: ::std::mem::MaybeUninit<EquippedProfileItemsChanged_t> =
4343 ::std::mem::MaybeUninit::uninit();
4344 let ptr = UNINIT.as_ptr();
4345 assert_eq!(
4346 ::std::mem::size_of::<EquippedProfileItemsChanged_t>(),
4347 8usize,
4348 concat!("Size of: ", stringify!(EquippedProfileItemsChanged_t))
4349 );
4350 assert_eq!(
4351 ::std::mem::align_of::<EquippedProfileItemsChanged_t>(),
4352 1usize,
4353 concat!("Alignment of ", stringify!(EquippedProfileItemsChanged_t))
4354 );
4355 assert_eq!(
4356 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
4357 0usize,
4358 concat!(
4359 "Offset of field: ",
4360 stringify!(EquippedProfileItemsChanged_t),
4361 "::",
4362 stringify!(m_steamID)
4363 )
4364 );
4365}
4366#[repr(C)]
4367#[derive(Copy, Clone)]
4368pub struct EquippedProfileItems_t {
4369 pub m_eResult: EResult,
4370 pub m_steamID: CSteamID,
4371 pub m_bHasAnimatedAvatar: bool,
4372 pub m_bHasAvatarFrame: bool,
4373 pub m_bHasProfileModifier: bool,
4374 pub m_bHasProfileBackground: bool,
4375 pub m_bHasMiniProfileBackground: bool,
4376 pub m_bFromCache: bool,
4377}
4378pub const EquippedProfileItems_t_k_iCallback: EquippedProfileItems_t__bindgen_ty_1 =
4379 EquippedProfileItems_t__bindgen_ty_1::k_iCallback;
4380#[repr(u32)]
4381#[non_exhaustive]
4382#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4383pub enum EquippedProfileItems_t__bindgen_ty_1 {
4384 k_iCallback = 351,
4385}
4386#[test]
4387fn bindgen_test_layout_EquippedProfileItems_t() {
4388 const UNINIT: ::std::mem::MaybeUninit<EquippedProfileItems_t> =
4389 ::std::mem::MaybeUninit::uninit();
4390 let ptr = UNINIT.as_ptr();
4391 assert_eq!(
4392 ::std::mem::size_of::<EquippedProfileItems_t>(),
4393 20usize,
4394 concat!("Size of: ", stringify!(EquippedProfileItems_t))
4395 );
4396 assert_eq!(
4397 ::std::mem::align_of::<EquippedProfileItems_t>(),
4398 4usize,
4399 concat!("Alignment of ", stringify!(EquippedProfileItems_t))
4400 );
4401 assert_eq!(
4402 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
4403 0usize,
4404 concat!(
4405 "Offset of field: ",
4406 stringify!(EquippedProfileItems_t),
4407 "::",
4408 stringify!(m_eResult)
4409 )
4410 );
4411 assert_eq!(
4412 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
4413 4usize,
4414 concat!(
4415 "Offset of field: ",
4416 stringify!(EquippedProfileItems_t),
4417 "::",
4418 stringify!(m_steamID)
4419 )
4420 );
4421 assert_eq!(
4422 unsafe { ::std::ptr::addr_of!((*ptr).m_bHasAnimatedAvatar) as usize - ptr as usize },
4423 12usize,
4424 concat!(
4425 "Offset of field: ",
4426 stringify!(EquippedProfileItems_t),
4427 "::",
4428 stringify!(m_bHasAnimatedAvatar)
4429 )
4430 );
4431 assert_eq!(
4432 unsafe { ::std::ptr::addr_of!((*ptr).m_bHasAvatarFrame) as usize - ptr as usize },
4433 13usize,
4434 concat!(
4435 "Offset of field: ",
4436 stringify!(EquippedProfileItems_t),
4437 "::",
4438 stringify!(m_bHasAvatarFrame)
4439 )
4440 );
4441 assert_eq!(
4442 unsafe { ::std::ptr::addr_of!((*ptr).m_bHasProfileModifier) as usize - ptr as usize },
4443 14usize,
4444 concat!(
4445 "Offset of field: ",
4446 stringify!(EquippedProfileItems_t),
4447 "::",
4448 stringify!(m_bHasProfileModifier)
4449 )
4450 );
4451 assert_eq!(
4452 unsafe { ::std::ptr::addr_of!((*ptr).m_bHasProfileBackground) as usize - ptr as usize },
4453 15usize,
4454 concat!(
4455 "Offset of field: ",
4456 stringify!(EquippedProfileItems_t),
4457 "::",
4458 stringify!(m_bHasProfileBackground)
4459 )
4460 );
4461 assert_eq!(
4462 unsafe { ::std::ptr::addr_of!((*ptr).m_bHasMiniProfileBackground) as usize - ptr as usize },
4463 16usize,
4464 concat!(
4465 "Offset of field: ",
4466 stringify!(EquippedProfileItems_t),
4467 "::",
4468 stringify!(m_bHasMiniProfileBackground)
4469 )
4470 );
4471 assert_eq!(
4472 unsafe { ::std::ptr::addr_of!((*ptr).m_bFromCache) as usize - ptr as usize },
4473 17usize,
4474 concat!(
4475 "Offset of field: ",
4476 stringify!(EquippedProfileItems_t),
4477 "::",
4478 stringify!(m_bFromCache)
4479 )
4480 );
4481}
4482#[repr(i32)]
4483#[non_exhaustive]
4484#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4485pub enum ESteamAPICallFailure {
4486 k_ESteamAPICallFailureNone = -1,
4487 k_ESteamAPICallFailureSteamGone = 0,
4488 k_ESteamAPICallFailureNetworkFailure = 1,
4489 k_ESteamAPICallFailureInvalidHandle = 2,
4490 k_ESteamAPICallFailureMismatchedCallback = 3,
4491}
4492#[repr(u32)]
4493#[non_exhaustive]
4494#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4495pub enum EGamepadTextInputMode {
4496 k_EGamepadTextInputModeNormal = 0,
4497 k_EGamepadTextInputModePassword = 1,
4498}
4499#[repr(u32)]
4500#[non_exhaustive]
4501#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4502pub enum EGamepadTextInputLineMode {
4503 k_EGamepadTextInputLineModeSingleLine = 0,
4504 k_EGamepadTextInputLineModeMultipleLines = 1,
4505}
4506#[repr(u32)]
4507#[non_exhaustive]
4508#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4509pub enum EFloatingGamepadTextInputMode {
4510 k_EFloatingGamepadTextInputModeModeSingleLine = 0,
4511 k_EFloatingGamepadTextInputModeModeMultipleLines = 1,
4512 k_EFloatingGamepadTextInputModeModeEmail = 2,
4513 k_EFloatingGamepadTextInputModeModeNumeric = 3,
4514}
4515#[repr(u32)]
4516#[non_exhaustive]
4517#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4518pub enum ETextFilteringContext {
4519 k_ETextFilteringContextUnknown = 0,
4520 k_ETextFilteringContextGameContent = 1,
4521 k_ETextFilteringContextChat = 2,
4522 k_ETextFilteringContextName = 3,
4523}
4524#[repr(C)]
4525pub struct ISteamUtils__bindgen_vtable(::std::os::raw::c_void);
4526#[repr(C)]
4527#[derive(Debug, Copy, Clone)]
4528pub struct ISteamUtils {
4529 pub vtable_: *const ISteamUtils__bindgen_vtable,
4530}
4531#[test]
4532fn bindgen_test_layout_ISteamUtils() {
4533 assert_eq!(
4534 ::std::mem::size_of::<ISteamUtils>(),
4535 8usize,
4536 concat!("Size of: ", stringify!(ISteamUtils))
4537 );
4538 assert_eq!(
4539 ::std::mem::align_of::<ISteamUtils>(),
4540 8usize,
4541 concat!("Alignment of ", stringify!(ISteamUtils))
4542 );
4543}
4544#[repr(C)]
4545#[derive(Debug, Copy, Clone)]
4546pub struct IPCountry_t {
4547 pub _address: u8,
4548}
4549pub const IPCountry_t_k_iCallback: IPCountry_t__bindgen_ty_1 =
4550 IPCountry_t__bindgen_ty_1::k_iCallback;
4551#[repr(u32)]
4552#[non_exhaustive]
4553#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4554pub enum IPCountry_t__bindgen_ty_1 {
4555 k_iCallback = 701,
4556}
4557#[test]
4558fn bindgen_test_layout_IPCountry_t() {
4559 assert_eq!(
4560 ::std::mem::size_of::<IPCountry_t>(),
4561 1usize,
4562 concat!("Size of: ", stringify!(IPCountry_t))
4563 );
4564 assert_eq!(
4565 ::std::mem::align_of::<IPCountry_t>(),
4566 1usize,
4567 concat!("Alignment of ", stringify!(IPCountry_t))
4568 );
4569}
4570#[repr(C)]
4571#[derive(Debug, Copy, Clone)]
4572pub struct LowBatteryPower_t {
4573 pub m_nMinutesBatteryLeft: uint8,
4574}
4575pub const LowBatteryPower_t_k_iCallback: LowBatteryPower_t__bindgen_ty_1 =
4576 LowBatteryPower_t__bindgen_ty_1::k_iCallback;
4577#[repr(u32)]
4578#[non_exhaustive]
4579#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4580pub enum LowBatteryPower_t__bindgen_ty_1 {
4581 k_iCallback = 702,
4582}
4583#[test]
4584fn bindgen_test_layout_LowBatteryPower_t() {
4585 const UNINIT: ::std::mem::MaybeUninit<LowBatteryPower_t> = ::std::mem::MaybeUninit::uninit();
4586 let ptr = UNINIT.as_ptr();
4587 assert_eq!(
4588 ::std::mem::size_of::<LowBatteryPower_t>(),
4589 1usize,
4590 concat!("Size of: ", stringify!(LowBatteryPower_t))
4591 );
4592 assert_eq!(
4593 ::std::mem::align_of::<LowBatteryPower_t>(),
4594 1usize,
4595 concat!("Alignment of ", stringify!(LowBatteryPower_t))
4596 );
4597 assert_eq!(
4598 unsafe { ::std::ptr::addr_of!((*ptr).m_nMinutesBatteryLeft) as usize - ptr as usize },
4599 0usize,
4600 concat!(
4601 "Offset of field: ",
4602 stringify!(LowBatteryPower_t),
4603 "::",
4604 stringify!(m_nMinutesBatteryLeft)
4605 )
4606 );
4607}
4608#[repr(C, packed(4))]
4609#[derive(Debug, Copy, Clone)]
4610pub struct SteamAPICallCompleted_t {
4611 pub m_hAsyncCall: SteamAPICall_t,
4612 pub m_iCallback: ::std::os::raw::c_int,
4613 pub m_cubParam: uint32,
4614}
4615pub const SteamAPICallCompleted_t_k_iCallback: SteamAPICallCompleted_t__bindgen_ty_1 =
4616 SteamAPICallCompleted_t__bindgen_ty_1::k_iCallback;
4617#[repr(u32)]
4618#[non_exhaustive]
4619#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4620pub enum SteamAPICallCompleted_t__bindgen_ty_1 {
4621 k_iCallback = 703,
4622}
4623#[test]
4624fn bindgen_test_layout_SteamAPICallCompleted_t() {
4625 const UNINIT: ::std::mem::MaybeUninit<SteamAPICallCompleted_t> =
4626 ::std::mem::MaybeUninit::uninit();
4627 let ptr = UNINIT.as_ptr();
4628 assert_eq!(
4629 ::std::mem::size_of::<SteamAPICallCompleted_t>(),
4630 16usize,
4631 concat!("Size of: ", stringify!(SteamAPICallCompleted_t))
4632 );
4633 assert_eq!(
4634 ::std::mem::align_of::<SteamAPICallCompleted_t>(),
4635 4usize,
4636 concat!("Alignment of ", stringify!(SteamAPICallCompleted_t))
4637 );
4638 assert_eq!(
4639 unsafe { ::std::ptr::addr_of!((*ptr).m_hAsyncCall) as usize - ptr as usize },
4640 0usize,
4641 concat!(
4642 "Offset of field: ",
4643 stringify!(SteamAPICallCompleted_t),
4644 "::",
4645 stringify!(m_hAsyncCall)
4646 )
4647 );
4648 assert_eq!(
4649 unsafe { ::std::ptr::addr_of!((*ptr).m_iCallback) as usize - ptr as usize },
4650 8usize,
4651 concat!(
4652 "Offset of field: ",
4653 stringify!(SteamAPICallCompleted_t),
4654 "::",
4655 stringify!(m_iCallback)
4656 )
4657 );
4658 assert_eq!(
4659 unsafe { ::std::ptr::addr_of!((*ptr).m_cubParam) as usize - ptr as usize },
4660 12usize,
4661 concat!(
4662 "Offset of field: ",
4663 stringify!(SteamAPICallCompleted_t),
4664 "::",
4665 stringify!(m_cubParam)
4666 )
4667 );
4668}
4669#[repr(C)]
4670#[derive(Debug, Copy, Clone)]
4671pub struct SteamShutdown_t {
4672 pub _address: u8,
4673}
4674pub const SteamShutdown_t_k_iCallback: SteamShutdown_t__bindgen_ty_1 =
4675 SteamShutdown_t__bindgen_ty_1::k_iCallback;
4676#[repr(u32)]
4677#[non_exhaustive]
4678#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4679pub enum SteamShutdown_t__bindgen_ty_1 {
4680 k_iCallback = 704,
4681}
4682#[test]
4683fn bindgen_test_layout_SteamShutdown_t() {
4684 assert_eq!(
4685 ::std::mem::size_of::<SteamShutdown_t>(),
4686 1usize,
4687 concat!("Size of: ", stringify!(SteamShutdown_t))
4688 );
4689 assert_eq!(
4690 ::std::mem::align_of::<SteamShutdown_t>(),
4691 1usize,
4692 concat!("Alignment of ", stringify!(SteamShutdown_t))
4693 );
4694}
4695#[repr(u32)]
4696#[non_exhaustive]
4697#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4698pub enum ECheckFileSignature {
4699 k_ECheckFileSignatureInvalidSignature = 0,
4700 k_ECheckFileSignatureValidSignature = 1,
4701 k_ECheckFileSignatureFileNotFound = 2,
4702 k_ECheckFileSignatureNoSignaturesFoundForThisApp = 3,
4703 k_ECheckFileSignatureNoSignaturesFoundForThisFile = 4,
4704}
4705#[repr(C)]
4706#[derive(Debug, Copy, Clone)]
4707pub struct CheckFileSignature_t {
4708 pub m_eCheckFileSignature: ECheckFileSignature,
4709}
4710pub const CheckFileSignature_t_k_iCallback: CheckFileSignature_t__bindgen_ty_1 =
4711 CheckFileSignature_t__bindgen_ty_1::k_iCallback;
4712#[repr(u32)]
4713#[non_exhaustive]
4714#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4715pub enum CheckFileSignature_t__bindgen_ty_1 {
4716 k_iCallback = 705,
4717}
4718#[test]
4719fn bindgen_test_layout_CheckFileSignature_t() {
4720 const UNINIT: ::std::mem::MaybeUninit<CheckFileSignature_t> = ::std::mem::MaybeUninit::uninit();
4721 let ptr = UNINIT.as_ptr();
4722 assert_eq!(
4723 ::std::mem::size_of::<CheckFileSignature_t>(),
4724 4usize,
4725 concat!("Size of: ", stringify!(CheckFileSignature_t))
4726 );
4727 assert_eq!(
4728 ::std::mem::align_of::<CheckFileSignature_t>(),
4729 4usize,
4730 concat!("Alignment of ", stringify!(CheckFileSignature_t))
4731 );
4732 assert_eq!(
4733 unsafe { ::std::ptr::addr_of!((*ptr).m_eCheckFileSignature) as usize - ptr as usize },
4734 0usize,
4735 concat!(
4736 "Offset of field: ",
4737 stringify!(CheckFileSignature_t),
4738 "::",
4739 stringify!(m_eCheckFileSignature)
4740 )
4741 );
4742}
4743#[repr(C)]
4744#[derive(Debug, Copy, Clone)]
4745pub struct GamepadTextInputDismissed_t {
4746 pub m_bSubmitted: bool,
4747 pub m_unSubmittedText: uint32,
4748 pub m_unAppID: AppId_t,
4749}
4750pub const GamepadTextInputDismissed_t_k_iCallback: GamepadTextInputDismissed_t__bindgen_ty_1 =
4751 GamepadTextInputDismissed_t__bindgen_ty_1::k_iCallback;
4752#[repr(u32)]
4753#[non_exhaustive]
4754#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4755pub enum GamepadTextInputDismissed_t__bindgen_ty_1 {
4756 k_iCallback = 714,
4757}
4758#[test]
4759fn bindgen_test_layout_GamepadTextInputDismissed_t() {
4760 const UNINIT: ::std::mem::MaybeUninit<GamepadTextInputDismissed_t> =
4761 ::std::mem::MaybeUninit::uninit();
4762 let ptr = UNINIT.as_ptr();
4763 assert_eq!(
4764 ::std::mem::size_of::<GamepadTextInputDismissed_t>(),
4765 12usize,
4766 concat!("Size of: ", stringify!(GamepadTextInputDismissed_t))
4767 );
4768 assert_eq!(
4769 ::std::mem::align_of::<GamepadTextInputDismissed_t>(),
4770 4usize,
4771 concat!("Alignment of ", stringify!(GamepadTextInputDismissed_t))
4772 );
4773 assert_eq!(
4774 unsafe { ::std::ptr::addr_of!((*ptr).m_bSubmitted) as usize - ptr as usize },
4775 0usize,
4776 concat!(
4777 "Offset of field: ",
4778 stringify!(GamepadTextInputDismissed_t),
4779 "::",
4780 stringify!(m_bSubmitted)
4781 )
4782 );
4783 assert_eq!(
4784 unsafe { ::std::ptr::addr_of!((*ptr).m_unSubmittedText) as usize - ptr as usize },
4785 4usize,
4786 concat!(
4787 "Offset of field: ",
4788 stringify!(GamepadTextInputDismissed_t),
4789 "::",
4790 stringify!(m_unSubmittedText)
4791 )
4792 );
4793 assert_eq!(
4794 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
4795 8usize,
4796 concat!(
4797 "Offset of field: ",
4798 stringify!(GamepadTextInputDismissed_t),
4799 "::",
4800 stringify!(m_unAppID)
4801 )
4802 );
4803}
4804#[repr(C)]
4805#[derive(Debug, Copy, Clone)]
4806pub struct AppResumingFromSuspend_t {
4807 pub _address: u8,
4808}
4809pub const AppResumingFromSuspend_t_k_iCallback: AppResumingFromSuspend_t__bindgen_ty_1 =
4810 AppResumingFromSuspend_t__bindgen_ty_1::k_iCallback;
4811#[repr(u32)]
4812#[non_exhaustive]
4813#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4814pub enum AppResumingFromSuspend_t__bindgen_ty_1 {
4815 k_iCallback = 736,
4816}
4817#[test]
4818fn bindgen_test_layout_AppResumingFromSuspend_t() {
4819 assert_eq!(
4820 ::std::mem::size_of::<AppResumingFromSuspend_t>(),
4821 1usize,
4822 concat!("Size of: ", stringify!(AppResumingFromSuspend_t))
4823 );
4824 assert_eq!(
4825 ::std::mem::align_of::<AppResumingFromSuspend_t>(),
4826 1usize,
4827 concat!("Alignment of ", stringify!(AppResumingFromSuspend_t))
4828 );
4829}
4830#[repr(C)]
4831#[derive(Debug, Copy, Clone)]
4832pub struct FloatingGamepadTextInputDismissed_t {
4833 pub _address: u8,
4834}
4835pub const FloatingGamepadTextInputDismissed_t_k_iCallback:
4836 FloatingGamepadTextInputDismissed_t__bindgen_ty_1 =
4837 FloatingGamepadTextInputDismissed_t__bindgen_ty_1::k_iCallback;
4838#[repr(u32)]
4839#[non_exhaustive]
4840#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4841pub enum FloatingGamepadTextInputDismissed_t__bindgen_ty_1 {
4842 k_iCallback = 738,
4843}
4844#[test]
4845fn bindgen_test_layout_FloatingGamepadTextInputDismissed_t() {
4846 assert_eq!(
4847 ::std::mem::size_of::<FloatingGamepadTextInputDismissed_t>(),
4848 1usize,
4849 concat!("Size of: ", stringify!(FloatingGamepadTextInputDismissed_t))
4850 );
4851 assert_eq!(
4852 ::std::mem::align_of::<FloatingGamepadTextInputDismissed_t>(),
4853 1usize,
4854 concat!(
4855 "Alignment of ",
4856 stringify!(FloatingGamepadTextInputDismissed_t)
4857 )
4858 );
4859}
4860#[repr(C)]
4861#[derive(Debug, Copy, Clone)]
4862pub struct FilterTextDictionaryChanged_t {
4863 pub m_eLanguage: ::std::os::raw::c_int,
4864}
4865pub const FilterTextDictionaryChanged_t_k_iCallback: FilterTextDictionaryChanged_t__bindgen_ty_1 =
4866 FilterTextDictionaryChanged_t__bindgen_ty_1::k_iCallback;
4867#[repr(u32)]
4868#[non_exhaustive]
4869#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4870pub enum FilterTextDictionaryChanged_t__bindgen_ty_1 {
4871 k_iCallback = 739,
4872}
4873#[test]
4874fn bindgen_test_layout_FilterTextDictionaryChanged_t() {
4875 const UNINIT: ::std::mem::MaybeUninit<FilterTextDictionaryChanged_t> =
4876 ::std::mem::MaybeUninit::uninit();
4877 let ptr = UNINIT.as_ptr();
4878 assert_eq!(
4879 ::std::mem::size_of::<FilterTextDictionaryChanged_t>(),
4880 4usize,
4881 concat!("Size of: ", stringify!(FilterTextDictionaryChanged_t))
4882 );
4883 assert_eq!(
4884 ::std::mem::align_of::<FilterTextDictionaryChanged_t>(),
4885 4usize,
4886 concat!("Alignment of ", stringify!(FilterTextDictionaryChanged_t))
4887 );
4888 assert_eq!(
4889 unsafe { ::std::ptr::addr_of!((*ptr).m_eLanguage) as usize - ptr as usize },
4890 0usize,
4891 concat!(
4892 "Offset of field: ",
4893 stringify!(FilterTextDictionaryChanged_t),
4894 "::",
4895 stringify!(m_eLanguage)
4896 )
4897 );
4898}
4899pub type __gnuc_va_list = __builtin_va_list;
4900pub type __u_char = ::std::os::raw::c_uchar;
4901pub type __u_short = ::std::os::raw::c_ushort;
4902pub type __u_int = ::std::os::raw::c_uint;
4903pub type __u_long = ::std::os::raw::c_ulong;
4904pub type __int8_t = ::std::os::raw::c_schar;
4905pub type __uint8_t = ::std::os::raw::c_uchar;
4906pub type __int16_t = ::std::os::raw::c_short;
4907pub type __uint16_t = ::std::os::raw::c_ushort;
4908pub type __int32_t = ::std::os::raw::c_int;
4909pub type __uint32_t = ::std::os::raw::c_uint;
4910pub type __int64_t = ::std::os::raw::c_long;
4911pub type __uint64_t = ::std::os::raw::c_ulong;
4912pub type __int_least8_t = __int8_t;
4913pub type __uint_least8_t = __uint8_t;
4914pub type __int_least16_t = __int16_t;
4915pub type __uint_least16_t = __uint16_t;
4916pub type __int_least32_t = __int32_t;
4917pub type __uint_least32_t = __uint32_t;
4918pub type __int_least64_t = __int64_t;
4919pub type __uint_least64_t = __uint64_t;
4920pub type __quad_t = ::std::os::raw::c_long;
4921pub type __u_quad_t = ::std::os::raw::c_ulong;
4922pub type __intmax_t = ::std::os::raw::c_long;
4923pub type __uintmax_t = ::std::os::raw::c_ulong;
4924pub type __dev_t = ::std::os::raw::c_ulong;
4925pub type __uid_t = ::std::os::raw::c_uint;
4926pub type __gid_t = ::std::os::raw::c_uint;
4927pub type __ino_t = ::std::os::raw::c_ulong;
4928pub type __ino64_t = ::std::os::raw::c_ulong;
4929pub type __mode_t = ::std::os::raw::c_uint;
4930pub type __nlink_t = ::std::os::raw::c_ulong;
4931pub type __off_t = ::std::os::raw::c_long;
4932pub type __off64_t = ::std::os::raw::c_long;
4933pub type __pid_t = ::std::os::raw::c_int;
4934#[repr(C)]
4935#[derive(Debug, Copy, Clone)]
4936pub struct __fsid_t {
4937 pub __val: [::std::os::raw::c_int; 2usize],
4938}
4939#[test]
4940fn bindgen_test_layout___fsid_t() {
4941 const UNINIT: ::std::mem::MaybeUninit<__fsid_t> = ::std::mem::MaybeUninit::uninit();
4942 let ptr = UNINIT.as_ptr();
4943 assert_eq!(
4944 ::std::mem::size_of::<__fsid_t>(),
4945 8usize,
4946 concat!("Size of: ", stringify!(__fsid_t))
4947 );
4948 assert_eq!(
4949 ::std::mem::align_of::<__fsid_t>(),
4950 4usize,
4951 concat!("Alignment of ", stringify!(__fsid_t))
4952 );
4953 assert_eq!(
4954 unsafe { ::std::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
4955 0usize,
4956 concat!(
4957 "Offset of field: ",
4958 stringify!(__fsid_t),
4959 "::",
4960 stringify!(__val)
4961 )
4962 );
4963}
4964pub type __clock_t = ::std::os::raw::c_long;
4965pub type __rlim_t = ::std::os::raw::c_ulong;
4966pub type __rlim64_t = ::std::os::raw::c_ulong;
4967pub type __id_t = ::std::os::raw::c_uint;
4968pub type __time_t = ::std::os::raw::c_long;
4969pub type __useconds_t = ::std::os::raw::c_uint;
4970pub type __suseconds_t = ::std::os::raw::c_long;
4971pub type __suseconds64_t = ::std::os::raw::c_long;
4972pub type __daddr_t = ::std::os::raw::c_int;
4973pub type __key_t = ::std::os::raw::c_int;
4974pub type __clockid_t = ::std::os::raw::c_int;
4975pub type __timer_t = *mut ::std::os::raw::c_void;
4976pub type __blksize_t = ::std::os::raw::c_long;
4977pub type __blkcnt_t = ::std::os::raw::c_long;
4978pub type __blkcnt64_t = ::std::os::raw::c_long;
4979pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
4980pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
4981pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
4982pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
4983pub type __fsword_t = ::std::os::raw::c_long;
4984pub type __ssize_t = ::std::os::raw::c_long;
4985pub type __syscall_slong_t = ::std::os::raw::c_long;
4986pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
4987pub type __loff_t = __off64_t;
4988pub type __caddr_t = *mut ::std::os::raw::c_char;
4989pub type __intptr_t = ::std::os::raw::c_long;
4990pub type __socklen_t = ::std::os::raw::c_uint;
4991pub type __sig_atomic_t = ::std::os::raw::c_int;
4992#[repr(C)]
4993#[derive(Copy, Clone)]
4994pub struct __mbstate_t {
4995 pub __count: ::std::os::raw::c_int,
4996 pub __value: __mbstate_t__bindgen_ty_1,
4997}
4998#[repr(C)]
4999#[derive(Copy, Clone)]
5000pub union __mbstate_t__bindgen_ty_1 {
5001 pub __wch: ::std::os::raw::c_uint,
5002 pub __wchb: [::std::os::raw::c_char; 4usize],
5003}
5004#[test]
5005fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
5006 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t__bindgen_ty_1> =
5007 ::std::mem::MaybeUninit::uninit();
5008 let ptr = UNINIT.as_ptr();
5009 assert_eq!(
5010 ::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
5011 4usize,
5012 concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
5013 );
5014 assert_eq!(
5015 ::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
5016 4usize,
5017 concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
5018 );
5019 assert_eq!(
5020 unsafe { ::std::ptr::addr_of!((*ptr).__wch) as usize - ptr as usize },
5021 0usize,
5022 concat!(
5023 "Offset of field: ",
5024 stringify!(__mbstate_t__bindgen_ty_1),
5025 "::",
5026 stringify!(__wch)
5027 )
5028 );
5029 assert_eq!(
5030 unsafe { ::std::ptr::addr_of!((*ptr).__wchb) as usize - ptr as usize },
5031 0usize,
5032 concat!(
5033 "Offset of field: ",
5034 stringify!(__mbstate_t__bindgen_ty_1),
5035 "::",
5036 stringify!(__wchb)
5037 )
5038 );
5039}
5040#[test]
5041fn bindgen_test_layout___mbstate_t() {
5042 const UNINIT: ::std::mem::MaybeUninit<__mbstate_t> = ::std::mem::MaybeUninit::uninit();
5043 let ptr = UNINIT.as_ptr();
5044 assert_eq!(
5045 ::std::mem::size_of::<__mbstate_t>(),
5046 8usize,
5047 concat!("Size of: ", stringify!(__mbstate_t))
5048 );
5049 assert_eq!(
5050 ::std::mem::align_of::<__mbstate_t>(),
5051 4usize,
5052 concat!("Alignment of ", stringify!(__mbstate_t))
5053 );
5054 assert_eq!(
5055 unsafe { ::std::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
5056 0usize,
5057 concat!(
5058 "Offset of field: ",
5059 stringify!(__mbstate_t),
5060 "::",
5061 stringify!(__count)
5062 )
5063 );
5064 assert_eq!(
5065 unsafe { ::std::ptr::addr_of!((*ptr).__value) as usize - ptr as usize },
5066 4usize,
5067 concat!(
5068 "Offset of field: ",
5069 stringify!(__mbstate_t),
5070 "::",
5071 stringify!(__value)
5072 )
5073 );
5074}
5075#[repr(C)]
5076#[derive(Copy, Clone)]
5077pub struct _G_fpos_t {
5078 pub __pos: __off_t,
5079 pub __state: __mbstate_t,
5080}
5081#[test]
5082fn bindgen_test_layout__G_fpos_t() {
5083 const UNINIT: ::std::mem::MaybeUninit<_G_fpos_t> = ::std::mem::MaybeUninit::uninit();
5084 let ptr = UNINIT.as_ptr();
5085 assert_eq!(
5086 ::std::mem::size_of::<_G_fpos_t>(),
5087 16usize,
5088 concat!("Size of: ", stringify!(_G_fpos_t))
5089 );
5090 assert_eq!(
5091 ::std::mem::align_of::<_G_fpos_t>(),
5092 8usize,
5093 concat!("Alignment of ", stringify!(_G_fpos_t))
5094 );
5095 assert_eq!(
5096 unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
5097 0usize,
5098 concat!(
5099 "Offset of field: ",
5100 stringify!(_G_fpos_t),
5101 "::",
5102 stringify!(__pos)
5103 )
5104 );
5105 assert_eq!(
5106 unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
5107 8usize,
5108 concat!(
5109 "Offset of field: ",
5110 stringify!(_G_fpos_t),
5111 "::",
5112 stringify!(__state)
5113 )
5114 );
5115}
5116pub type __fpos_t = _G_fpos_t;
5117#[repr(C)]
5118#[derive(Copy, Clone)]
5119pub struct _G_fpos64_t {
5120 pub __pos: __off64_t,
5121 pub __state: __mbstate_t,
5122}
5123#[test]
5124fn bindgen_test_layout__G_fpos64_t() {
5125 const UNINIT: ::std::mem::MaybeUninit<_G_fpos64_t> = ::std::mem::MaybeUninit::uninit();
5126 let ptr = UNINIT.as_ptr();
5127 assert_eq!(
5128 ::std::mem::size_of::<_G_fpos64_t>(),
5129 16usize,
5130 concat!("Size of: ", stringify!(_G_fpos64_t))
5131 );
5132 assert_eq!(
5133 ::std::mem::align_of::<_G_fpos64_t>(),
5134 8usize,
5135 concat!("Alignment of ", stringify!(_G_fpos64_t))
5136 );
5137 assert_eq!(
5138 unsafe { ::std::ptr::addr_of!((*ptr).__pos) as usize - ptr as usize },
5139 0usize,
5140 concat!(
5141 "Offset of field: ",
5142 stringify!(_G_fpos64_t),
5143 "::",
5144 stringify!(__pos)
5145 )
5146 );
5147 assert_eq!(
5148 unsafe { ::std::ptr::addr_of!((*ptr).__state) as usize - ptr as usize },
5149 8usize,
5150 concat!(
5151 "Offset of field: ",
5152 stringify!(_G_fpos64_t),
5153 "::",
5154 stringify!(__state)
5155 )
5156 );
5157}
5158pub type __fpos64_t = _G_fpos64_t;
5159pub type __FILE = _IO_FILE;
5160pub type FILE = _IO_FILE;
5161#[repr(C)]
5162#[derive(Debug, Copy, Clone)]
5163pub struct _IO_marker {
5164 _unused: [u8; 0],
5165}
5166#[repr(C)]
5167#[derive(Debug, Copy, Clone)]
5168pub struct _IO_codecvt {
5169 _unused: [u8; 0],
5170}
5171#[repr(C)]
5172#[derive(Debug, Copy, Clone)]
5173pub struct _IO_wide_data {
5174 _unused: [u8; 0],
5175}
5176pub type _IO_lock_t = ::std::os::raw::c_void;
5177#[repr(C)]
5178#[derive(Debug, Copy, Clone)]
5179pub struct _IO_FILE {
5180 pub _flags: ::std::os::raw::c_int,
5181 pub _IO_read_ptr: *mut ::std::os::raw::c_char,
5182 pub _IO_read_end: *mut ::std::os::raw::c_char,
5183 pub _IO_read_base: *mut ::std::os::raw::c_char,
5184 pub _IO_write_base: *mut ::std::os::raw::c_char,
5185 pub _IO_write_ptr: *mut ::std::os::raw::c_char,
5186 pub _IO_write_end: *mut ::std::os::raw::c_char,
5187 pub _IO_buf_base: *mut ::std::os::raw::c_char,
5188 pub _IO_buf_end: *mut ::std::os::raw::c_char,
5189 pub _IO_save_base: *mut ::std::os::raw::c_char,
5190 pub _IO_backup_base: *mut ::std::os::raw::c_char,
5191 pub _IO_save_end: *mut ::std::os::raw::c_char,
5192 pub _markers: *mut _IO_marker,
5193 pub _chain: *mut _IO_FILE,
5194 pub _fileno: ::std::os::raw::c_int,
5195 pub _flags2: ::std::os::raw::c_int,
5196 pub _old_offset: __off_t,
5197 pub _cur_column: ::std::os::raw::c_ushort,
5198 pub _vtable_offset: ::std::os::raw::c_schar,
5199 pub _shortbuf: [::std::os::raw::c_char; 1usize],
5200 pub _lock: *mut _IO_lock_t,
5201 pub _offset: __off64_t,
5202 pub _codecvt: *mut _IO_codecvt,
5203 pub _wide_data: *mut _IO_wide_data,
5204 pub _freeres_list: *mut _IO_FILE,
5205 pub _freeres_buf: *mut ::std::os::raw::c_void,
5206 pub __pad5: usize,
5207 pub _mode: ::std::os::raw::c_int,
5208 pub _unused2: [::std::os::raw::c_char; 20usize],
5209}
5210#[test]
5211fn bindgen_test_layout__IO_FILE() {
5212 const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
5213 let ptr = UNINIT.as_ptr();
5214 assert_eq!(
5215 ::std::mem::size_of::<_IO_FILE>(),
5216 216usize,
5217 concat!("Size of: ", stringify!(_IO_FILE))
5218 );
5219 assert_eq!(
5220 ::std::mem::align_of::<_IO_FILE>(),
5221 8usize,
5222 concat!("Alignment of ", stringify!(_IO_FILE))
5223 );
5224 assert_eq!(
5225 unsafe { ::std::ptr::addr_of!((*ptr)._flags) as usize - ptr as usize },
5226 0usize,
5227 concat!(
5228 "Offset of field: ",
5229 stringify!(_IO_FILE),
5230 "::",
5231 stringify!(_flags)
5232 )
5233 );
5234 assert_eq!(
5235 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
5236 8usize,
5237 concat!(
5238 "Offset of field: ",
5239 stringify!(_IO_FILE),
5240 "::",
5241 stringify!(_IO_read_ptr)
5242 )
5243 );
5244 assert_eq!(
5245 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
5246 16usize,
5247 concat!(
5248 "Offset of field: ",
5249 stringify!(_IO_FILE),
5250 "::",
5251 stringify!(_IO_read_end)
5252 )
5253 );
5254 assert_eq!(
5255 unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
5256 24usize,
5257 concat!(
5258 "Offset of field: ",
5259 stringify!(_IO_FILE),
5260 "::",
5261 stringify!(_IO_read_base)
5262 )
5263 );
5264 assert_eq!(
5265 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
5266 32usize,
5267 concat!(
5268 "Offset of field: ",
5269 stringify!(_IO_FILE),
5270 "::",
5271 stringify!(_IO_write_base)
5272 )
5273 );
5274 assert_eq!(
5275 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
5276 40usize,
5277 concat!(
5278 "Offset of field: ",
5279 stringify!(_IO_FILE),
5280 "::",
5281 stringify!(_IO_write_ptr)
5282 )
5283 );
5284 assert_eq!(
5285 unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
5286 48usize,
5287 concat!(
5288 "Offset of field: ",
5289 stringify!(_IO_FILE),
5290 "::",
5291 stringify!(_IO_write_end)
5292 )
5293 );
5294 assert_eq!(
5295 unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
5296 56usize,
5297 concat!(
5298 "Offset of field: ",
5299 stringify!(_IO_FILE),
5300 "::",
5301 stringify!(_IO_buf_base)
5302 )
5303 );
5304 assert_eq!(
5305 unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
5306 64usize,
5307 concat!(
5308 "Offset of field: ",
5309 stringify!(_IO_FILE),
5310 "::",
5311 stringify!(_IO_buf_end)
5312 )
5313 );
5314 assert_eq!(
5315 unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
5316 72usize,
5317 concat!(
5318 "Offset of field: ",
5319 stringify!(_IO_FILE),
5320 "::",
5321 stringify!(_IO_save_base)
5322 )
5323 );
5324 assert_eq!(
5325 unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
5326 80usize,
5327 concat!(
5328 "Offset of field: ",
5329 stringify!(_IO_FILE),
5330 "::",
5331 stringify!(_IO_backup_base)
5332 )
5333 );
5334 assert_eq!(
5335 unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
5336 88usize,
5337 concat!(
5338 "Offset of field: ",
5339 stringify!(_IO_FILE),
5340 "::",
5341 stringify!(_IO_save_end)
5342 )
5343 );
5344 assert_eq!(
5345 unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
5346 96usize,
5347 concat!(
5348 "Offset of field: ",
5349 stringify!(_IO_FILE),
5350 "::",
5351 stringify!(_markers)
5352 )
5353 );
5354 assert_eq!(
5355 unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
5356 104usize,
5357 concat!(
5358 "Offset of field: ",
5359 stringify!(_IO_FILE),
5360 "::",
5361 stringify!(_chain)
5362 )
5363 );
5364 assert_eq!(
5365 unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
5366 112usize,
5367 concat!(
5368 "Offset of field: ",
5369 stringify!(_IO_FILE),
5370 "::",
5371 stringify!(_fileno)
5372 )
5373 );
5374 assert_eq!(
5375 unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
5376 116usize,
5377 concat!(
5378 "Offset of field: ",
5379 stringify!(_IO_FILE),
5380 "::",
5381 stringify!(_flags2)
5382 )
5383 );
5384 assert_eq!(
5385 unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
5386 120usize,
5387 concat!(
5388 "Offset of field: ",
5389 stringify!(_IO_FILE),
5390 "::",
5391 stringify!(_old_offset)
5392 )
5393 );
5394 assert_eq!(
5395 unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
5396 128usize,
5397 concat!(
5398 "Offset of field: ",
5399 stringify!(_IO_FILE),
5400 "::",
5401 stringify!(_cur_column)
5402 )
5403 );
5404 assert_eq!(
5405 unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
5406 130usize,
5407 concat!(
5408 "Offset of field: ",
5409 stringify!(_IO_FILE),
5410 "::",
5411 stringify!(_vtable_offset)
5412 )
5413 );
5414 assert_eq!(
5415 unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
5416 131usize,
5417 concat!(
5418 "Offset of field: ",
5419 stringify!(_IO_FILE),
5420 "::",
5421 stringify!(_shortbuf)
5422 )
5423 );
5424 assert_eq!(
5425 unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
5426 136usize,
5427 concat!(
5428 "Offset of field: ",
5429 stringify!(_IO_FILE),
5430 "::",
5431 stringify!(_lock)
5432 )
5433 );
5434 assert_eq!(
5435 unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
5436 144usize,
5437 concat!(
5438 "Offset of field: ",
5439 stringify!(_IO_FILE),
5440 "::",
5441 stringify!(_offset)
5442 )
5443 );
5444 assert_eq!(
5445 unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
5446 152usize,
5447 concat!(
5448 "Offset of field: ",
5449 stringify!(_IO_FILE),
5450 "::",
5451 stringify!(_codecvt)
5452 )
5453 );
5454 assert_eq!(
5455 unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
5456 160usize,
5457 concat!(
5458 "Offset of field: ",
5459 stringify!(_IO_FILE),
5460 "::",
5461 stringify!(_wide_data)
5462 )
5463 );
5464 assert_eq!(
5465 unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
5466 168usize,
5467 concat!(
5468 "Offset of field: ",
5469 stringify!(_IO_FILE),
5470 "::",
5471 stringify!(_freeres_list)
5472 )
5473 );
5474 assert_eq!(
5475 unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
5476 176usize,
5477 concat!(
5478 "Offset of field: ",
5479 stringify!(_IO_FILE),
5480 "::",
5481 stringify!(_freeres_buf)
5482 )
5483 );
5484 assert_eq!(
5485 unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
5486 184usize,
5487 concat!(
5488 "Offset of field: ",
5489 stringify!(_IO_FILE),
5490 "::",
5491 stringify!(__pad5)
5492 )
5493 );
5494 assert_eq!(
5495 unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
5496 192usize,
5497 concat!(
5498 "Offset of field: ",
5499 stringify!(_IO_FILE),
5500 "::",
5501 stringify!(_mode)
5502 )
5503 );
5504 assert_eq!(
5505 unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
5506 196usize,
5507 concat!(
5508 "Offset of field: ",
5509 stringify!(_IO_FILE),
5510 "::",
5511 stringify!(_unused2)
5512 )
5513 );
5514}
5515pub type cookie_read_function_t = ::std::option::Option<
5516 unsafe extern "C" fn(
5517 __cookie: *mut ::std::os::raw::c_void,
5518 __buf: *mut ::std::os::raw::c_char,
5519 __nbytes: usize,
5520 ) -> __ssize_t,
5521>;
5522pub type cookie_write_function_t = ::std::option::Option<
5523 unsafe extern "C" fn(
5524 __cookie: *mut ::std::os::raw::c_void,
5525 __buf: *const ::std::os::raw::c_char,
5526 __nbytes: usize,
5527 ) -> __ssize_t,
5528>;
5529pub type cookie_seek_function_t = ::std::option::Option<
5530 unsafe extern "C" fn(
5531 __cookie: *mut ::std::os::raw::c_void,
5532 __pos: *mut __off64_t,
5533 __w: ::std::os::raw::c_int,
5534 ) -> ::std::os::raw::c_int,
5535>;
5536pub type cookie_close_function_t = ::std::option::Option<
5537 unsafe extern "C" fn(__cookie: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
5538>;
5539#[repr(C)]
5540#[derive(Debug, Copy, Clone)]
5541pub struct _IO_cookie_io_functions_t {
5542 pub read: cookie_read_function_t,
5543 pub write: cookie_write_function_t,
5544 pub seek: cookie_seek_function_t,
5545 pub close: cookie_close_function_t,
5546}
5547#[test]
5548fn bindgen_test_layout__IO_cookie_io_functions_t() {
5549 const UNINIT: ::std::mem::MaybeUninit<_IO_cookie_io_functions_t> =
5550 ::std::mem::MaybeUninit::uninit();
5551 let ptr = UNINIT.as_ptr();
5552 assert_eq!(
5553 ::std::mem::size_of::<_IO_cookie_io_functions_t>(),
5554 32usize,
5555 concat!("Size of: ", stringify!(_IO_cookie_io_functions_t))
5556 );
5557 assert_eq!(
5558 ::std::mem::align_of::<_IO_cookie_io_functions_t>(),
5559 8usize,
5560 concat!("Alignment of ", stringify!(_IO_cookie_io_functions_t))
5561 );
5562 assert_eq!(
5563 unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
5564 0usize,
5565 concat!(
5566 "Offset of field: ",
5567 stringify!(_IO_cookie_io_functions_t),
5568 "::",
5569 stringify!(read)
5570 )
5571 );
5572 assert_eq!(
5573 unsafe { ::std::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
5574 8usize,
5575 concat!(
5576 "Offset of field: ",
5577 stringify!(_IO_cookie_io_functions_t),
5578 "::",
5579 stringify!(write)
5580 )
5581 );
5582 assert_eq!(
5583 unsafe { ::std::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
5584 16usize,
5585 concat!(
5586 "Offset of field: ",
5587 stringify!(_IO_cookie_io_functions_t),
5588 "::",
5589 stringify!(seek)
5590 )
5591 );
5592 assert_eq!(
5593 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
5594 24usize,
5595 concat!(
5596 "Offset of field: ",
5597 stringify!(_IO_cookie_io_functions_t),
5598 "::",
5599 stringify!(close)
5600 )
5601 );
5602}
5603pub type cookie_io_functions_t = _IO_cookie_io_functions_t;
5604pub type va_list = __gnuc_va_list;
5605pub type off_t = __off_t;
5606pub type off64_t = __off64_t;
5607pub type fpos_t = __fpos_t;
5608pub type fpos64_t = __fpos64_t;
5609extern "C" {
5610 pub static mut stdin: *mut FILE;
5611}
5612extern "C" {
5613 pub static mut stdout: *mut FILE;
5614}
5615extern "C" {
5616 pub static mut stderr: *mut FILE;
5617}
5618pub type _Float32 = f32;
5619pub type _Float64 = f64;
5620pub type _Float32x = f64;
5621pub type _Float64x = u128;
5622#[repr(C)]
5623#[derive(Debug, Copy, Clone)]
5624pub struct obstack {
5625 _unused: [u8; 0],
5626}
5627pub const k_cbMaxGameServerGameDir: ::std::os::raw::c_int = 32;
5628pub const k_cbMaxGameServerMapName: ::std::os::raw::c_int = 32;
5629pub const k_cbMaxGameServerGameDescription: ::std::os::raw::c_int = 64;
5630pub const k_cbMaxGameServerName: ::std::os::raw::c_int = 64;
5631pub const k_cbMaxGameServerTags: ::std::os::raw::c_int = 128;
5632pub const k_cbMaxGameServerGameData: ::std::os::raw::c_int = 2048;
5633#[doc = " Store key/value pair used in matchmaking queries.\n\n Actually, the name Key/Value is a bit misleading. The \"key\" is better\n understood as \"filter operation code\" and the \"value\" is the operand to this\n filter operation. The meaning of the operand depends upon the filter."]
5634#[repr(C)]
5635#[derive(Debug, Copy, Clone)]
5636pub struct MatchMakingKeyValuePair_t {
5637 pub m_szKey: [::std::os::raw::c_char; 256usize],
5638 pub m_szValue: [::std::os::raw::c_char; 256usize],
5639}
5640#[test]
5641fn bindgen_test_layout_MatchMakingKeyValuePair_t() {
5642 const UNINIT: ::std::mem::MaybeUninit<MatchMakingKeyValuePair_t> =
5643 ::std::mem::MaybeUninit::uninit();
5644 let ptr = UNINIT.as_ptr();
5645 assert_eq!(
5646 ::std::mem::size_of::<MatchMakingKeyValuePair_t>(),
5647 512usize,
5648 concat!("Size of: ", stringify!(MatchMakingKeyValuePair_t))
5649 );
5650 assert_eq!(
5651 ::std::mem::align_of::<MatchMakingKeyValuePair_t>(),
5652 1usize,
5653 concat!("Alignment of ", stringify!(MatchMakingKeyValuePair_t))
5654 );
5655 assert_eq!(
5656 unsafe { ::std::ptr::addr_of!((*ptr).m_szKey) as usize - ptr as usize },
5657 0usize,
5658 concat!(
5659 "Offset of field: ",
5660 stringify!(MatchMakingKeyValuePair_t),
5661 "::",
5662 stringify!(m_szKey)
5663 )
5664 );
5665 assert_eq!(
5666 unsafe { ::std::ptr::addr_of!((*ptr).m_szValue) as usize - ptr as usize },
5667 256usize,
5668 concat!(
5669 "Offset of field: ",
5670 stringify!(MatchMakingKeyValuePair_t),
5671 "::",
5672 stringify!(m_szValue)
5673 )
5674 );
5675}
5676#[repr(u32)]
5677#[non_exhaustive]
5678#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5679pub enum EMatchMakingServerResponse {
5680 eServerResponded = 0,
5681 eServerFailedToRespond = 1,
5682 eNoServersListedOnMasterServer = 2,
5683}
5684#[repr(C)]
5685#[derive(Debug, Copy, Clone)]
5686pub struct servernetadr_t {
5687 pub m_usConnectionPort: uint16,
5688 pub m_usQueryPort: uint16,
5689 pub m_unIP: uint32,
5690}
5691#[test]
5692fn bindgen_test_layout_servernetadr_t() {
5693 const UNINIT: ::std::mem::MaybeUninit<servernetadr_t> = ::std::mem::MaybeUninit::uninit();
5694 let ptr = UNINIT.as_ptr();
5695 assert_eq!(
5696 ::std::mem::size_of::<servernetadr_t>(),
5697 8usize,
5698 concat!("Size of: ", stringify!(servernetadr_t))
5699 );
5700 assert_eq!(
5701 ::std::mem::align_of::<servernetadr_t>(),
5702 4usize,
5703 concat!("Alignment of ", stringify!(servernetadr_t))
5704 );
5705 assert_eq!(
5706 unsafe { ::std::ptr::addr_of!((*ptr).m_usConnectionPort) as usize - ptr as usize },
5707 0usize,
5708 concat!(
5709 "Offset of field: ",
5710 stringify!(servernetadr_t),
5711 "::",
5712 stringify!(m_usConnectionPort)
5713 )
5714 );
5715 assert_eq!(
5716 unsafe { ::std::ptr::addr_of!((*ptr).m_usQueryPort) as usize - ptr as usize },
5717 2usize,
5718 concat!(
5719 "Offset of field: ",
5720 stringify!(servernetadr_t),
5721 "::",
5722 stringify!(m_usQueryPort)
5723 )
5724 );
5725 assert_eq!(
5726 unsafe { ::std::ptr::addr_of!((*ptr).m_unIP) as usize - ptr as usize },
5727 4usize,
5728 concat!(
5729 "Offset of field: ",
5730 stringify!(servernetadr_t),
5731 "::",
5732 stringify!(m_unIP)
5733 )
5734 );
5735}
5736#[repr(C)]
5737#[derive(Copy, Clone)]
5738pub struct gameserveritem_t {
5739 #[doc = "< IP/Query Port/Connection Port for this server"]
5740 pub m_NetAdr: servernetadr_t,
5741 #[doc = "< current ping time in milliseconds"]
5742 pub m_nPing: ::std::os::raw::c_int,
5743 #[doc = "< server has responded successfully in the past"]
5744 pub m_bHadSuccessfulResponse: bool,
5745 #[doc = "< server is marked as not responding and should no longer be refreshed"]
5746 pub m_bDoNotRefresh: bool,
5747 #[doc = "< current game directory"]
5748 pub m_szGameDir: [::std::os::raw::c_char; 32usize],
5749 #[doc = "< current map"]
5750 pub m_szMap: [::std::os::raw::c_char; 32usize],
5751 #[doc = "< game description"]
5752 pub m_szGameDescription: [::std::os::raw::c_char; 64usize],
5753 #[doc = "< Steam App ID of this server"]
5754 pub m_nAppID: uint32,
5755 #[doc = "< total number of players currently on the server. INCLUDES BOTS!!"]
5756 pub m_nPlayers: ::std::os::raw::c_int,
5757 #[doc = "< Maximum players that can join this server"]
5758 pub m_nMaxPlayers: ::std::os::raw::c_int,
5759 #[doc = "< Number of bots (i.e simulated players) on this server"]
5760 pub m_nBotPlayers: ::std::os::raw::c_int,
5761 #[doc = "< true if this server needs a password to join"]
5762 pub m_bPassword: bool,
5763 #[doc = "< Is this server protected by VAC"]
5764 pub m_bSecure: bool,
5765 #[doc = "< time (in unix time) when this server was last played on (for favorite/history servers)"]
5766 pub m_ulTimeLastPlayed: uint32,
5767 #[doc = "< server version as reported to Steam"]
5768 pub m_nServerVersion: ::std::os::raw::c_int,
5769 #[doc = " Game server name"]
5770 pub m_szServerName: [::std::os::raw::c_char; 64usize],
5771 #[doc = " the tags this server exposes"]
5772 pub m_szGameTags: [::std::os::raw::c_char; 128usize],
5773 #[doc = " steamID of the game server - invalid if it's doesn't have one (old server, or not connected to Steam)"]
5774 pub m_steamID: CSteamID,
5775}
5776#[test]
5777fn bindgen_test_layout_gameserveritem_t() {
5778 const UNINIT: ::std::mem::MaybeUninit<gameserveritem_t> = ::std::mem::MaybeUninit::uninit();
5779 let ptr = UNINIT.as_ptr();
5780 assert_eq!(
5781 ::std::mem::size_of::<gameserveritem_t>(),
5782 372usize,
5783 concat!("Size of: ", stringify!(gameserveritem_t))
5784 );
5785 assert_eq!(
5786 ::std::mem::align_of::<gameserveritem_t>(),
5787 4usize,
5788 concat!("Alignment of ", stringify!(gameserveritem_t))
5789 );
5790 assert_eq!(
5791 unsafe { ::std::ptr::addr_of!((*ptr).m_NetAdr) as usize - ptr as usize },
5792 0usize,
5793 concat!(
5794 "Offset of field: ",
5795 stringify!(gameserveritem_t),
5796 "::",
5797 stringify!(m_NetAdr)
5798 )
5799 );
5800 assert_eq!(
5801 unsafe { ::std::ptr::addr_of!((*ptr).m_nPing) as usize - ptr as usize },
5802 8usize,
5803 concat!(
5804 "Offset of field: ",
5805 stringify!(gameserveritem_t),
5806 "::",
5807 stringify!(m_nPing)
5808 )
5809 );
5810 assert_eq!(
5811 unsafe { ::std::ptr::addr_of!((*ptr).m_bHadSuccessfulResponse) as usize - ptr as usize },
5812 12usize,
5813 concat!(
5814 "Offset of field: ",
5815 stringify!(gameserveritem_t),
5816 "::",
5817 stringify!(m_bHadSuccessfulResponse)
5818 )
5819 );
5820 assert_eq!(
5821 unsafe { ::std::ptr::addr_of!((*ptr).m_bDoNotRefresh) as usize - ptr as usize },
5822 13usize,
5823 concat!(
5824 "Offset of field: ",
5825 stringify!(gameserveritem_t),
5826 "::",
5827 stringify!(m_bDoNotRefresh)
5828 )
5829 );
5830 assert_eq!(
5831 unsafe { ::std::ptr::addr_of!((*ptr).m_szGameDir) as usize - ptr as usize },
5832 14usize,
5833 concat!(
5834 "Offset of field: ",
5835 stringify!(gameserveritem_t),
5836 "::",
5837 stringify!(m_szGameDir)
5838 )
5839 );
5840 assert_eq!(
5841 unsafe { ::std::ptr::addr_of!((*ptr).m_szMap) as usize - ptr as usize },
5842 46usize,
5843 concat!(
5844 "Offset of field: ",
5845 stringify!(gameserveritem_t),
5846 "::",
5847 stringify!(m_szMap)
5848 )
5849 );
5850 assert_eq!(
5851 unsafe { ::std::ptr::addr_of!((*ptr).m_szGameDescription) as usize - ptr as usize },
5852 78usize,
5853 concat!(
5854 "Offset of field: ",
5855 stringify!(gameserveritem_t),
5856 "::",
5857 stringify!(m_szGameDescription)
5858 )
5859 );
5860 assert_eq!(
5861 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
5862 144usize,
5863 concat!(
5864 "Offset of field: ",
5865 stringify!(gameserveritem_t),
5866 "::",
5867 stringify!(m_nAppID)
5868 )
5869 );
5870 assert_eq!(
5871 unsafe { ::std::ptr::addr_of!((*ptr).m_nPlayers) as usize - ptr as usize },
5872 148usize,
5873 concat!(
5874 "Offset of field: ",
5875 stringify!(gameserveritem_t),
5876 "::",
5877 stringify!(m_nPlayers)
5878 )
5879 );
5880 assert_eq!(
5881 unsafe { ::std::ptr::addr_of!((*ptr).m_nMaxPlayers) as usize - ptr as usize },
5882 152usize,
5883 concat!(
5884 "Offset of field: ",
5885 stringify!(gameserveritem_t),
5886 "::",
5887 stringify!(m_nMaxPlayers)
5888 )
5889 );
5890 assert_eq!(
5891 unsafe { ::std::ptr::addr_of!((*ptr).m_nBotPlayers) as usize - ptr as usize },
5892 156usize,
5893 concat!(
5894 "Offset of field: ",
5895 stringify!(gameserveritem_t),
5896 "::",
5897 stringify!(m_nBotPlayers)
5898 )
5899 );
5900 assert_eq!(
5901 unsafe { ::std::ptr::addr_of!((*ptr).m_bPassword) as usize - ptr as usize },
5902 160usize,
5903 concat!(
5904 "Offset of field: ",
5905 stringify!(gameserveritem_t),
5906 "::",
5907 stringify!(m_bPassword)
5908 )
5909 );
5910 assert_eq!(
5911 unsafe { ::std::ptr::addr_of!((*ptr).m_bSecure) as usize - ptr as usize },
5912 161usize,
5913 concat!(
5914 "Offset of field: ",
5915 stringify!(gameserveritem_t),
5916 "::",
5917 stringify!(m_bSecure)
5918 )
5919 );
5920 assert_eq!(
5921 unsafe { ::std::ptr::addr_of!((*ptr).m_ulTimeLastPlayed) as usize - ptr as usize },
5922 164usize,
5923 concat!(
5924 "Offset of field: ",
5925 stringify!(gameserveritem_t),
5926 "::",
5927 stringify!(m_ulTimeLastPlayed)
5928 )
5929 );
5930 assert_eq!(
5931 unsafe { ::std::ptr::addr_of!((*ptr).m_nServerVersion) as usize - ptr as usize },
5932 168usize,
5933 concat!(
5934 "Offset of field: ",
5935 stringify!(gameserveritem_t),
5936 "::",
5937 stringify!(m_nServerVersion)
5938 )
5939 );
5940 assert_eq!(
5941 unsafe { ::std::ptr::addr_of!((*ptr).m_szServerName) as usize - ptr as usize },
5942 172usize,
5943 concat!(
5944 "Offset of field: ",
5945 stringify!(gameserveritem_t),
5946 "::",
5947 stringify!(m_szServerName)
5948 )
5949 );
5950 assert_eq!(
5951 unsafe { ::std::ptr::addr_of!((*ptr).m_szGameTags) as usize - ptr as usize },
5952 236usize,
5953 concat!(
5954 "Offset of field: ",
5955 stringify!(gameserveritem_t),
5956 "::",
5957 stringify!(m_szGameTags)
5958 )
5959 );
5960 assert_eq!(
5961 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
5962 364usize,
5963 concat!(
5964 "Offset of field: ",
5965 stringify!(gameserveritem_t),
5966 "::",
5967 stringify!(m_steamID)
5968 )
5969 );
5970}
5971#[repr(u32)]
5972#[non_exhaustive]
5973#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5974pub enum ELobbyType {
5975 k_ELobbyTypePrivate = 0,
5976 k_ELobbyTypeFriendsOnly = 1,
5977 k_ELobbyTypePublic = 2,
5978 k_ELobbyTypeInvisible = 3,
5979 k_ELobbyTypePrivateUnique = 4,
5980}
5981#[repr(i32)]
5982#[non_exhaustive]
5983#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5984pub enum ELobbyComparison {
5985 k_ELobbyComparisonEqualToOrLessThan = -2,
5986 k_ELobbyComparisonLessThan = -1,
5987 k_ELobbyComparisonEqual = 0,
5988 k_ELobbyComparisonGreaterThan = 1,
5989 k_ELobbyComparisonEqualToOrGreaterThan = 2,
5990 k_ELobbyComparisonNotEqual = 3,
5991}
5992#[repr(u32)]
5993#[non_exhaustive]
5994#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5995pub enum ELobbyDistanceFilter {
5996 k_ELobbyDistanceFilterClose = 0,
5997 k_ELobbyDistanceFilterDefault = 1,
5998 k_ELobbyDistanceFilterFar = 2,
5999 k_ELobbyDistanceFilterWorldwide = 3,
6000}
6001#[repr(C)]
6002pub struct ISteamMatchmaking__bindgen_vtable(::std::os::raw::c_void);
6003#[repr(C)]
6004#[derive(Debug, Copy, Clone)]
6005pub struct ISteamMatchmaking {
6006 pub vtable_: *const ISteamMatchmaking__bindgen_vtable,
6007}
6008#[test]
6009fn bindgen_test_layout_ISteamMatchmaking() {
6010 assert_eq!(
6011 ::std::mem::size_of::<ISteamMatchmaking>(),
6012 8usize,
6013 concat!("Size of: ", stringify!(ISteamMatchmaking))
6014 );
6015 assert_eq!(
6016 ::std::mem::align_of::<ISteamMatchmaking>(),
6017 8usize,
6018 concat!("Alignment of ", stringify!(ISteamMatchmaking))
6019 );
6020}
6021pub type HServerListRequest = *mut ::std::os::raw::c_void;
6022#[repr(C)]
6023pub struct ISteamMatchmakingServerListResponse__bindgen_vtable(::std::os::raw::c_void);
6024#[repr(C)]
6025#[derive(Debug, Copy, Clone)]
6026pub struct ISteamMatchmakingServerListResponse {
6027 pub vtable_: *const ISteamMatchmakingServerListResponse__bindgen_vtable,
6028}
6029#[test]
6030fn bindgen_test_layout_ISteamMatchmakingServerListResponse() {
6031 assert_eq!(
6032 ::std::mem::size_of::<ISteamMatchmakingServerListResponse>(),
6033 8usize,
6034 concat!("Size of: ", stringify!(ISteamMatchmakingServerListResponse))
6035 );
6036 assert_eq!(
6037 ::std::mem::align_of::<ISteamMatchmakingServerListResponse>(),
6038 8usize,
6039 concat!(
6040 "Alignment of ",
6041 stringify!(ISteamMatchmakingServerListResponse)
6042 )
6043 );
6044}
6045#[repr(C)]
6046pub struct ISteamMatchmakingPingResponse__bindgen_vtable(::std::os::raw::c_void);
6047#[repr(C)]
6048#[derive(Debug, Copy, Clone)]
6049pub struct ISteamMatchmakingPingResponse {
6050 pub vtable_: *const ISteamMatchmakingPingResponse__bindgen_vtable,
6051}
6052#[test]
6053fn bindgen_test_layout_ISteamMatchmakingPingResponse() {
6054 assert_eq!(
6055 ::std::mem::size_of::<ISteamMatchmakingPingResponse>(),
6056 8usize,
6057 concat!("Size of: ", stringify!(ISteamMatchmakingPingResponse))
6058 );
6059 assert_eq!(
6060 ::std::mem::align_of::<ISteamMatchmakingPingResponse>(),
6061 8usize,
6062 concat!("Alignment of ", stringify!(ISteamMatchmakingPingResponse))
6063 );
6064}
6065#[repr(C)]
6066pub struct ISteamMatchmakingPlayersResponse__bindgen_vtable(::std::os::raw::c_void);
6067#[repr(C)]
6068#[derive(Debug, Copy, Clone)]
6069pub struct ISteamMatchmakingPlayersResponse {
6070 pub vtable_: *const ISteamMatchmakingPlayersResponse__bindgen_vtable,
6071}
6072#[test]
6073fn bindgen_test_layout_ISteamMatchmakingPlayersResponse() {
6074 assert_eq!(
6075 ::std::mem::size_of::<ISteamMatchmakingPlayersResponse>(),
6076 8usize,
6077 concat!("Size of: ", stringify!(ISteamMatchmakingPlayersResponse))
6078 );
6079 assert_eq!(
6080 ::std::mem::align_of::<ISteamMatchmakingPlayersResponse>(),
6081 8usize,
6082 concat!(
6083 "Alignment of ",
6084 stringify!(ISteamMatchmakingPlayersResponse)
6085 )
6086 );
6087}
6088#[repr(C)]
6089pub struct ISteamMatchmakingRulesResponse__bindgen_vtable(::std::os::raw::c_void);
6090#[repr(C)]
6091#[derive(Debug, Copy, Clone)]
6092pub struct ISteamMatchmakingRulesResponse {
6093 pub vtable_: *const ISteamMatchmakingRulesResponse__bindgen_vtable,
6094}
6095#[test]
6096fn bindgen_test_layout_ISteamMatchmakingRulesResponse() {
6097 assert_eq!(
6098 ::std::mem::size_of::<ISteamMatchmakingRulesResponse>(),
6099 8usize,
6100 concat!("Size of: ", stringify!(ISteamMatchmakingRulesResponse))
6101 );
6102 assert_eq!(
6103 ::std::mem::align_of::<ISteamMatchmakingRulesResponse>(),
6104 8usize,
6105 concat!("Alignment of ", stringify!(ISteamMatchmakingRulesResponse))
6106 );
6107}
6108pub type HServerQuery = ::std::os::raw::c_int;
6109pub const HSERVERQUERY_INVALID: ::std::os::raw::c_int = -1;
6110#[repr(C)]
6111pub struct ISteamMatchmakingServers__bindgen_vtable(::std::os::raw::c_void);
6112#[repr(C)]
6113#[derive(Debug, Copy, Clone)]
6114pub struct ISteamMatchmakingServers {
6115 pub vtable_: *const ISteamMatchmakingServers__bindgen_vtable,
6116}
6117#[test]
6118fn bindgen_test_layout_ISteamMatchmakingServers() {
6119 assert_eq!(
6120 ::std::mem::size_of::<ISteamMatchmakingServers>(),
6121 8usize,
6122 concat!("Size of: ", stringify!(ISteamMatchmakingServers))
6123 );
6124 assert_eq!(
6125 ::std::mem::align_of::<ISteamMatchmakingServers>(),
6126 8usize,
6127 concat!("Alignment of ", stringify!(ISteamMatchmakingServers))
6128 );
6129}
6130pub const k_unFavoriteFlagNone: uint32 = 0;
6131pub const k_unFavoriteFlagFavorite: uint32 = 1;
6132pub const k_unFavoriteFlagHistory: uint32 = 2;
6133#[repr(u32)]
6134#[non_exhaustive]
6135#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6136pub enum EChatMemberStateChange {
6137 k_EChatMemberStateChangeEntered = 1,
6138 k_EChatMemberStateChangeLeft = 2,
6139 k_EChatMemberStateChangeDisconnected = 4,
6140 k_EChatMemberStateChangeKicked = 8,
6141 k_EChatMemberStateChangeBanned = 16,
6142}
6143#[repr(u32)]
6144#[non_exhaustive]
6145#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6146pub enum ESteamPartyBeaconLocationType {
6147 k_ESteamPartyBeaconLocationType_Invalid = 0,
6148 k_ESteamPartyBeaconLocationType_ChatGroup = 1,
6149 k_ESteamPartyBeaconLocationType_Max = 2,
6150}
6151#[repr(C, packed(4))]
6152#[derive(Debug, Copy, Clone)]
6153pub struct SteamPartyBeaconLocation_t {
6154 pub m_eType: ESteamPartyBeaconLocationType,
6155 pub m_ulLocationID: uint64,
6156}
6157#[test]
6158fn bindgen_test_layout_SteamPartyBeaconLocation_t() {
6159 const UNINIT: ::std::mem::MaybeUninit<SteamPartyBeaconLocation_t> =
6160 ::std::mem::MaybeUninit::uninit();
6161 let ptr = UNINIT.as_ptr();
6162 assert_eq!(
6163 ::std::mem::size_of::<SteamPartyBeaconLocation_t>(),
6164 12usize,
6165 concat!("Size of: ", stringify!(SteamPartyBeaconLocation_t))
6166 );
6167 assert_eq!(
6168 ::std::mem::align_of::<SteamPartyBeaconLocation_t>(),
6169 4usize,
6170 concat!("Alignment of ", stringify!(SteamPartyBeaconLocation_t))
6171 );
6172 assert_eq!(
6173 unsafe { ::std::ptr::addr_of!((*ptr).m_eType) as usize - ptr as usize },
6174 0usize,
6175 concat!(
6176 "Offset of field: ",
6177 stringify!(SteamPartyBeaconLocation_t),
6178 "::",
6179 stringify!(m_eType)
6180 )
6181 );
6182 assert_eq!(
6183 unsafe { ::std::ptr::addr_of!((*ptr).m_ulLocationID) as usize - ptr as usize },
6184 4usize,
6185 concat!(
6186 "Offset of field: ",
6187 stringify!(SteamPartyBeaconLocation_t),
6188 "::",
6189 stringify!(m_ulLocationID)
6190 )
6191 );
6192}
6193#[repr(u32)]
6194#[non_exhaustive]
6195#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6196pub enum ESteamPartyBeaconLocationData {
6197 k_ESteamPartyBeaconLocationDataInvalid = 0,
6198 k_ESteamPartyBeaconLocationDataName = 1,
6199 k_ESteamPartyBeaconLocationDataIconURLSmall = 2,
6200 k_ESteamPartyBeaconLocationDataIconURLMedium = 3,
6201 k_ESteamPartyBeaconLocationDataIconURLLarge = 4,
6202}
6203#[repr(C)]
6204pub struct ISteamParties__bindgen_vtable(::std::os::raw::c_void);
6205#[repr(C)]
6206#[derive(Debug, Copy, Clone)]
6207pub struct ISteamParties {
6208 pub vtable_: *const ISteamParties__bindgen_vtable,
6209}
6210#[test]
6211fn bindgen_test_layout_ISteamParties() {
6212 assert_eq!(
6213 ::std::mem::size_of::<ISteamParties>(),
6214 8usize,
6215 concat!("Size of: ", stringify!(ISteamParties))
6216 );
6217 assert_eq!(
6218 ::std::mem::align_of::<ISteamParties>(),
6219 4usize,
6220 concat!("Alignment of ", stringify!(ISteamParties))
6221 );
6222}
6223#[repr(C)]
6224#[derive(Debug, Copy, Clone)]
6225pub struct FavoritesListChanged_t {
6226 pub m_nIP: uint32,
6227 pub m_nQueryPort: uint32,
6228 pub m_nConnPort: uint32,
6229 pub m_nAppID: uint32,
6230 pub m_nFlags: uint32,
6231 pub m_bAdd: bool,
6232 pub m_unAccountId: AccountID_t,
6233}
6234pub const FavoritesListChanged_t_k_iCallback: FavoritesListChanged_t__bindgen_ty_1 =
6235 FavoritesListChanged_t__bindgen_ty_1::k_iCallback;
6236#[repr(u32)]
6237#[non_exhaustive]
6238#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6239pub enum FavoritesListChanged_t__bindgen_ty_1 {
6240 k_iCallback = 502,
6241}
6242#[test]
6243fn bindgen_test_layout_FavoritesListChanged_t() {
6244 const UNINIT: ::std::mem::MaybeUninit<FavoritesListChanged_t> =
6245 ::std::mem::MaybeUninit::uninit();
6246 let ptr = UNINIT.as_ptr();
6247 assert_eq!(
6248 ::std::mem::size_of::<FavoritesListChanged_t>(),
6249 28usize,
6250 concat!("Size of: ", stringify!(FavoritesListChanged_t))
6251 );
6252 assert_eq!(
6253 ::std::mem::align_of::<FavoritesListChanged_t>(),
6254 4usize,
6255 concat!("Alignment of ", stringify!(FavoritesListChanged_t))
6256 );
6257 assert_eq!(
6258 unsafe { ::std::ptr::addr_of!((*ptr).m_nIP) as usize - ptr as usize },
6259 0usize,
6260 concat!(
6261 "Offset of field: ",
6262 stringify!(FavoritesListChanged_t),
6263 "::",
6264 stringify!(m_nIP)
6265 )
6266 );
6267 assert_eq!(
6268 unsafe { ::std::ptr::addr_of!((*ptr).m_nQueryPort) as usize - ptr as usize },
6269 4usize,
6270 concat!(
6271 "Offset of field: ",
6272 stringify!(FavoritesListChanged_t),
6273 "::",
6274 stringify!(m_nQueryPort)
6275 )
6276 );
6277 assert_eq!(
6278 unsafe { ::std::ptr::addr_of!((*ptr).m_nConnPort) as usize - ptr as usize },
6279 8usize,
6280 concat!(
6281 "Offset of field: ",
6282 stringify!(FavoritesListChanged_t),
6283 "::",
6284 stringify!(m_nConnPort)
6285 )
6286 );
6287 assert_eq!(
6288 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
6289 12usize,
6290 concat!(
6291 "Offset of field: ",
6292 stringify!(FavoritesListChanged_t),
6293 "::",
6294 stringify!(m_nAppID)
6295 )
6296 );
6297 assert_eq!(
6298 unsafe { ::std::ptr::addr_of!((*ptr).m_nFlags) as usize - ptr as usize },
6299 16usize,
6300 concat!(
6301 "Offset of field: ",
6302 stringify!(FavoritesListChanged_t),
6303 "::",
6304 stringify!(m_nFlags)
6305 )
6306 );
6307 assert_eq!(
6308 unsafe { ::std::ptr::addr_of!((*ptr).m_bAdd) as usize - ptr as usize },
6309 20usize,
6310 concat!(
6311 "Offset of field: ",
6312 stringify!(FavoritesListChanged_t),
6313 "::",
6314 stringify!(m_bAdd)
6315 )
6316 );
6317 assert_eq!(
6318 unsafe { ::std::ptr::addr_of!((*ptr).m_unAccountId) as usize - ptr as usize },
6319 24usize,
6320 concat!(
6321 "Offset of field: ",
6322 stringify!(FavoritesListChanged_t),
6323 "::",
6324 stringify!(m_unAccountId)
6325 )
6326 );
6327}
6328#[repr(C, packed(4))]
6329#[derive(Debug, Copy, Clone)]
6330pub struct LobbyInvite_t {
6331 pub m_ulSteamIDUser: uint64,
6332 pub m_ulSteamIDLobby: uint64,
6333 pub m_ulGameID: uint64,
6334}
6335pub const LobbyInvite_t_k_iCallback: LobbyInvite_t__bindgen_ty_1 =
6336 LobbyInvite_t__bindgen_ty_1::k_iCallback;
6337#[repr(u32)]
6338#[non_exhaustive]
6339#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6340pub enum LobbyInvite_t__bindgen_ty_1 {
6341 k_iCallback = 503,
6342}
6343#[test]
6344fn bindgen_test_layout_LobbyInvite_t() {
6345 const UNINIT: ::std::mem::MaybeUninit<LobbyInvite_t> = ::std::mem::MaybeUninit::uninit();
6346 let ptr = UNINIT.as_ptr();
6347 assert_eq!(
6348 ::std::mem::size_of::<LobbyInvite_t>(),
6349 24usize,
6350 concat!("Size of: ", stringify!(LobbyInvite_t))
6351 );
6352 assert_eq!(
6353 ::std::mem::align_of::<LobbyInvite_t>(),
6354 4usize,
6355 concat!("Alignment of ", stringify!(LobbyInvite_t))
6356 );
6357 assert_eq!(
6358 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDUser) as usize - ptr as usize },
6359 0usize,
6360 concat!(
6361 "Offset of field: ",
6362 stringify!(LobbyInvite_t),
6363 "::",
6364 stringify!(m_ulSteamIDUser)
6365 )
6366 );
6367 assert_eq!(
6368 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6369 8usize,
6370 concat!(
6371 "Offset of field: ",
6372 stringify!(LobbyInvite_t),
6373 "::",
6374 stringify!(m_ulSteamIDLobby)
6375 )
6376 );
6377 assert_eq!(
6378 unsafe { ::std::ptr::addr_of!((*ptr).m_ulGameID) as usize - ptr as usize },
6379 16usize,
6380 concat!(
6381 "Offset of field: ",
6382 stringify!(LobbyInvite_t),
6383 "::",
6384 stringify!(m_ulGameID)
6385 )
6386 );
6387}
6388#[repr(C, packed(4))]
6389#[derive(Debug, Copy, Clone)]
6390pub struct LobbyEnter_t {
6391 pub m_ulSteamIDLobby: uint64,
6392 pub m_rgfChatPermissions: uint32,
6393 pub m_bLocked: bool,
6394 pub m_EChatRoomEnterResponse: uint32,
6395}
6396pub const LobbyEnter_t_k_iCallback: LobbyEnter_t__bindgen_ty_1 =
6397 LobbyEnter_t__bindgen_ty_1::k_iCallback;
6398#[repr(u32)]
6399#[non_exhaustive]
6400#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6401pub enum LobbyEnter_t__bindgen_ty_1 {
6402 k_iCallback = 504,
6403}
6404#[test]
6405fn bindgen_test_layout_LobbyEnter_t() {
6406 const UNINIT: ::std::mem::MaybeUninit<LobbyEnter_t> = ::std::mem::MaybeUninit::uninit();
6407 let ptr = UNINIT.as_ptr();
6408 assert_eq!(
6409 ::std::mem::size_of::<LobbyEnter_t>(),
6410 20usize,
6411 concat!("Size of: ", stringify!(LobbyEnter_t))
6412 );
6413 assert_eq!(
6414 ::std::mem::align_of::<LobbyEnter_t>(),
6415 4usize,
6416 concat!("Alignment of ", stringify!(LobbyEnter_t))
6417 );
6418 assert_eq!(
6419 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6420 0usize,
6421 concat!(
6422 "Offset of field: ",
6423 stringify!(LobbyEnter_t),
6424 "::",
6425 stringify!(m_ulSteamIDLobby)
6426 )
6427 );
6428 assert_eq!(
6429 unsafe { ::std::ptr::addr_of!((*ptr).m_rgfChatPermissions) as usize - ptr as usize },
6430 8usize,
6431 concat!(
6432 "Offset of field: ",
6433 stringify!(LobbyEnter_t),
6434 "::",
6435 stringify!(m_rgfChatPermissions)
6436 )
6437 );
6438 assert_eq!(
6439 unsafe { ::std::ptr::addr_of!((*ptr).m_bLocked) as usize - ptr as usize },
6440 12usize,
6441 concat!(
6442 "Offset of field: ",
6443 stringify!(LobbyEnter_t),
6444 "::",
6445 stringify!(m_bLocked)
6446 )
6447 );
6448 assert_eq!(
6449 unsafe { ::std::ptr::addr_of!((*ptr).m_EChatRoomEnterResponse) as usize - ptr as usize },
6450 16usize,
6451 concat!(
6452 "Offset of field: ",
6453 stringify!(LobbyEnter_t),
6454 "::",
6455 stringify!(m_EChatRoomEnterResponse)
6456 )
6457 );
6458}
6459#[repr(C, packed(4))]
6460#[derive(Debug, Copy, Clone)]
6461pub struct LobbyDataUpdate_t {
6462 pub m_ulSteamIDLobby: uint64,
6463 pub m_ulSteamIDMember: uint64,
6464 pub m_bSuccess: uint8,
6465}
6466pub const LobbyDataUpdate_t_k_iCallback: LobbyDataUpdate_t__bindgen_ty_1 =
6467 LobbyDataUpdate_t__bindgen_ty_1::k_iCallback;
6468#[repr(u32)]
6469#[non_exhaustive]
6470#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6471pub enum LobbyDataUpdate_t__bindgen_ty_1 {
6472 k_iCallback = 505,
6473}
6474#[test]
6475fn bindgen_test_layout_LobbyDataUpdate_t() {
6476 const UNINIT: ::std::mem::MaybeUninit<LobbyDataUpdate_t> = ::std::mem::MaybeUninit::uninit();
6477 let ptr = UNINIT.as_ptr();
6478 assert_eq!(
6479 ::std::mem::size_of::<LobbyDataUpdate_t>(),
6480 20usize,
6481 concat!("Size of: ", stringify!(LobbyDataUpdate_t))
6482 );
6483 assert_eq!(
6484 ::std::mem::align_of::<LobbyDataUpdate_t>(),
6485 4usize,
6486 concat!("Alignment of ", stringify!(LobbyDataUpdate_t))
6487 );
6488 assert_eq!(
6489 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6490 0usize,
6491 concat!(
6492 "Offset of field: ",
6493 stringify!(LobbyDataUpdate_t),
6494 "::",
6495 stringify!(m_ulSteamIDLobby)
6496 )
6497 );
6498 assert_eq!(
6499 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDMember) as usize - ptr as usize },
6500 8usize,
6501 concat!(
6502 "Offset of field: ",
6503 stringify!(LobbyDataUpdate_t),
6504 "::",
6505 stringify!(m_ulSteamIDMember)
6506 )
6507 );
6508 assert_eq!(
6509 unsafe { ::std::ptr::addr_of!((*ptr).m_bSuccess) as usize - ptr as usize },
6510 16usize,
6511 concat!(
6512 "Offset of field: ",
6513 stringify!(LobbyDataUpdate_t),
6514 "::",
6515 stringify!(m_bSuccess)
6516 )
6517 );
6518}
6519#[repr(C, packed(4))]
6520#[derive(Debug, Copy, Clone)]
6521pub struct LobbyChatUpdate_t {
6522 pub m_ulSteamIDLobby: uint64,
6523 pub m_ulSteamIDUserChanged: uint64,
6524 pub m_ulSteamIDMakingChange: uint64,
6525 pub m_rgfChatMemberStateChange: uint32,
6526}
6527pub const LobbyChatUpdate_t_k_iCallback: LobbyChatUpdate_t__bindgen_ty_1 =
6528 LobbyChatUpdate_t__bindgen_ty_1::k_iCallback;
6529#[repr(u32)]
6530#[non_exhaustive]
6531#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6532pub enum LobbyChatUpdate_t__bindgen_ty_1 {
6533 k_iCallback = 506,
6534}
6535#[test]
6536fn bindgen_test_layout_LobbyChatUpdate_t() {
6537 const UNINIT: ::std::mem::MaybeUninit<LobbyChatUpdate_t> = ::std::mem::MaybeUninit::uninit();
6538 let ptr = UNINIT.as_ptr();
6539 assert_eq!(
6540 ::std::mem::size_of::<LobbyChatUpdate_t>(),
6541 28usize,
6542 concat!("Size of: ", stringify!(LobbyChatUpdate_t))
6543 );
6544 assert_eq!(
6545 ::std::mem::align_of::<LobbyChatUpdate_t>(),
6546 4usize,
6547 concat!("Alignment of ", stringify!(LobbyChatUpdate_t))
6548 );
6549 assert_eq!(
6550 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6551 0usize,
6552 concat!(
6553 "Offset of field: ",
6554 stringify!(LobbyChatUpdate_t),
6555 "::",
6556 stringify!(m_ulSteamIDLobby)
6557 )
6558 );
6559 assert_eq!(
6560 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDUserChanged) as usize - ptr as usize },
6561 8usize,
6562 concat!(
6563 "Offset of field: ",
6564 stringify!(LobbyChatUpdate_t),
6565 "::",
6566 stringify!(m_ulSteamIDUserChanged)
6567 )
6568 );
6569 assert_eq!(
6570 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDMakingChange) as usize - ptr as usize },
6571 16usize,
6572 concat!(
6573 "Offset of field: ",
6574 stringify!(LobbyChatUpdate_t),
6575 "::",
6576 stringify!(m_ulSteamIDMakingChange)
6577 )
6578 );
6579 assert_eq!(
6580 unsafe { ::std::ptr::addr_of!((*ptr).m_rgfChatMemberStateChange) as usize - ptr as usize },
6581 24usize,
6582 concat!(
6583 "Offset of field: ",
6584 stringify!(LobbyChatUpdate_t),
6585 "::",
6586 stringify!(m_rgfChatMemberStateChange)
6587 )
6588 );
6589}
6590#[repr(C, packed(4))]
6591#[derive(Debug, Copy, Clone)]
6592pub struct LobbyChatMsg_t {
6593 pub m_ulSteamIDLobby: uint64,
6594 pub m_ulSteamIDUser: uint64,
6595 pub m_eChatEntryType: uint8,
6596 pub m_iChatID: uint32,
6597}
6598pub const LobbyChatMsg_t_k_iCallback: LobbyChatMsg_t__bindgen_ty_1 =
6599 LobbyChatMsg_t__bindgen_ty_1::k_iCallback;
6600#[repr(u32)]
6601#[non_exhaustive]
6602#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6603pub enum LobbyChatMsg_t__bindgen_ty_1 {
6604 k_iCallback = 507,
6605}
6606#[test]
6607fn bindgen_test_layout_LobbyChatMsg_t() {
6608 const UNINIT: ::std::mem::MaybeUninit<LobbyChatMsg_t> = ::std::mem::MaybeUninit::uninit();
6609 let ptr = UNINIT.as_ptr();
6610 assert_eq!(
6611 ::std::mem::size_of::<LobbyChatMsg_t>(),
6612 24usize,
6613 concat!("Size of: ", stringify!(LobbyChatMsg_t))
6614 );
6615 assert_eq!(
6616 ::std::mem::align_of::<LobbyChatMsg_t>(),
6617 4usize,
6618 concat!("Alignment of ", stringify!(LobbyChatMsg_t))
6619 );
6620 assert_eq!(
6621 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6622 0usize,
6623 concat!(
6624 "Offset of field: ",
6625 stringify!(LobbyChatMsg_t),
6626 "::",
6627 stringify!(m_ulSteamIDLobby)
6628 )
6629 );
6630 assert_eq!(
6631 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDUser) as usize - ptr as usize },
6632 8usize,
6633 concat!(
6634 "Offset of field: ",
6635 stringify!(LobbyChatMsg_t),
6636 "::",
6637 stringify!(m_ulSteamIDUser)
6638 )
6639 );
6640 assert_eq!(
6641 unsafe { ::std::ptr::addr_of!((*ptr).m_eChatEntryType) as usize - ptr as usize },
6642 16usize,
6643 concat!(
6644 "Offset of field: ",
6645 stringify!(LobbyChatMsg_t),
6646 "::",
6647 stringify!(m_eChatEntryType)
6648 )
6649 );
6650 assert_eq!(
6651 unsafe { ::std::ptr::addr_of!((*ptr).m_iChatID) as usize - ptr as usize },
6652 20usize,
6653 concat!(
6654 "Offset of field: ",
6655 stringify!(LobbyChatMsg_t),
6656 "::",
6657 stringify!(m_iChatID)
6658 )
6659 );
6660}
6661#[repr(C, packed(4))]
6662#[derive(Debug, Copy, Clone)]
6663pub struct LobbyGameCreated_t {
6664 pub m_ulSteamIDLobby: uint64,
6665 pub m_ulSteamIDGameServer: uint64,
6666 pub m_unIP: uint32,
6667 pub m_usPort: uint16,
6668}
6669pub const LobbyGameCreated_t_k_iCallback: LobbyGameCreated_t__bindgen_ty_1 =
6670 LobbyGameCreated_t__bindgen_ty_1::k_iCallback;
6671#[repr(u32)]
6672#[non_exhaustive]
6673#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6674pub enum LobbyGameCreated_t__bindgen_ty_1 {
6675 k_iCallback = 509,
6676}
6677#[test]
6678fn bindgen_test_layout_LobbyGameCreated_t() {
6679 const UNINIT: ::std::mem::MaybeUninit<LobbyGameCreated_t> = ::std::mem::MaybeUninit::uninit();
6680 let ptr = UNINIT.as_ptr();
6681 assert_eq!(
6682 ::std::mem::size_of::<LobbyGameCreated_t>(),
6683 24usize,
6684 concat!("Size of: ", stringify!(LobbyGameCreated_t))
6685 );
6686 assert_eq!(
6687 ::std::mem::align_of::<LobbyGameCreated_t>(),
6688 4usize,
6689 concat!("Alignment of ", stringify!(LobbyGameCreated_t))
6690 );
6691 assert_eq!(
6692 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6693 0usize,
6694 concat!(
6695 "Offset of field: ",
6696 stringify!(LobbyGameCreated_t),
6697 "::",
6698 stringify!(m_ulSteamIDLobby)
6699 )
6700 );
6701 assert_eq!(
6702 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDGameServer) as usize - ptr as usize },
6703 8usize,
6704 concat!(
6705 "Offset of field: ",
6706 stringify!(LobbyGameCreated_t),
6707 "::",
6708 stringify!(m_ulSteamIDGameServer)
6709 )
6710 );
6711 assert_eq!(
6712 unsafe { ::std::ptr::addr_of!((*ptr).m_unIP) as usize - ptr as usize },
6713 16usize,
6714 concat!(
6715 "Offset of field: ",
6716 stringify!(LobbyGameCreated_t),
6717 "::",
6718 stringify!(m_unIP)
6719 )
6720 );
6721 assert_eq!(
6722 unsafe { ::std::ptr::addr_of!((*ptr).m_usPort) as usize - ptr as usize },
6723 20usize,
6724 concat!(
6725 "Offset of field: ",
6726 stringify!(LobbyGameCreated_t),
6727 "::",
6728 stringify!(m_usPort)
6729 )
6730 );
6731}
6732#[repr(C)]
6733#[derive(Debug, Copy, Clone)]
6734pub struct LobbyMatchList_t {
6735 pub m_nLobbiesMatching: uint32,
6736}
6737pub const LobbyMatchList_t_k_iCallback: LobbyMatchList_t__bindgen_ty_1 =
6738 LobbyMatchList_t__bindgen_ty_1::k_iCallback;
6739#[repr(u32)]
6740#[non_exhaustive]
6741#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6742pub enum LobbyMatchList_t__bindgen_ty_1 {
6743 k_iCallback = 510,
6744}
6745#[test]
6746fn bindgen_test_layout_LobbyMatchList_t() {
6747 const UNINIT: ::std::mem::MaybeUninit<LobbyMatchList_t> = ::std::mem::MaybeUninit::uninit();
6748 let ptr = UNINIT.as_ptr();
6749 assert_eq!(
6750 ::std::mem::size_of::<LobbyMatchList_t>(),
6751 4usize,
6752 concat!("Size of: ", stringify!(LobbyMatchList_t))
6753 );
6754 assert_eq!(
6755 ::std::mem::align_of::<LobbyMatchList_t>(),
6756 4usize,
6757 concat!("Alignment of ", stringify!(LobbyMatchList_t))
6758 );
6759 assert_eq!(
6760 unsafe { ::std::ptr::addr_of!((*ptr).m_nLobbiesMatching) as usize - ptr as usize },
6761 0usize,
6762 concat!(
6763 "Offset of field: ",
6764 stringify!(LobbyMatchList_t),
6765 "::",
6766 stringify!(m_nLobbiesMatching)
6767 )
6768 );
6769}
6770#[repr(C, packed(4))]
6771#[derive(Debug, Copy, Clone)]
6772pub struct LobbyKicked_t {
6773 pub m_ulSteamIDLobby: uint64,
6774 pub m_ulSteamIDAdmin: uint64,
6775 pub m_bKickedDueToDisconnect: uint8,
6776}
6777pub const LobbyKicked_t_k_iCallback: LobbyKicked_t__bindgen_ty_1 =
6778 LobbyKicked_t__bindgen_ty_1::k_iCallback;
6779#[repr(u32)]
6780#[non_exhaustive]
6781#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6782pub enum LobbyKicked_t__bindgen_ty_1 {
6783 k_iCallback = 512,
6784}
6785#[test]
6786fn bindgen_test_layout_LobbyKicked_t() {
6787 const UNINIT: ::std::mem::MaybeUninit<LobbyKicked_t> = ::std::mem::MaybeUninit::uninit();
6788 let ptr = UNINIT.as_ptr();
6789 assert_eq!(
6790 ::std::mem::size_of::<LobbyKicked_t>(),
6791 20usize,
6792 concat!("Size of: ", stringify!(LobbyKicked_t))
6793 );
6794 assert_eq!(
6795 ::std::mem::align_of::<LobbyKicked_t>(),
6796 4usize,
6797 concat!("Alignment of ", stringify!(LobbyKicked_t))
6798 );
6799 assert_eq!(
6800 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6801 0usize,
6802 concat!(
6803 "Offset of field: ",
6804 stringify!(LobbyKicked_t),
6805 "::",
6806 stringify!(m_ulSteamIDLobby)
6807 )
6808 );
6809 assert_eq!(
6810 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDAdmin) as usize - ptr as usize },
6811 8usize,
6812 concat!(
6813 "Offset of field: ",
6814 stringify!(LobbyKicked_t),
6815 "::",
6816 stringify!(m_ulSteamIDAdmin)
6817 )
6818 );
6819 assert_eq!(
6820 unsafe { ::std::ptr::addr_of!((*ptr).m_bKickedDueToDisconnect) as usize - ptr as usize },
6821 16usize,
6822 concat!(
6823 "Offset of field: ",
6824 stringify!(LobbyKicked_t),
6825 "::",
6826 stringify!(m_bKickedDueToDisconnect)
6827 )
6828 );
6829}
6830#[repr(C, packed(4))]
6831#[derive(Debug, Copy, Clone)]
6832pub struct LobbyCreated_t {
6833 pub m_eResult: EResult,
6834 pub m_ulSteamIDLobby: uint64,
6835}
6836pub const LobbyCreated_t_k_iCallback: LobbyCreated_t__bindgen_ty_1 =
6837 LobbyCreated_t__bindgen_ty_1::k_iCallback;
6838#[repr(u32)]
6839#[non_exhaustive]
6840#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6841pub enum LobbyCreated_t__bindgen_ty_1 {
6842 k_iCallback = 513,
6843}
6844#[test]
6845fn bindgen_test_layout_LobbyCreated_t() {
6846 const UNINIT: ::std::mem::MaybeUninit<LobbyCreated_t> = ::std::mem::MaybeUninit::uninit();
6847 let ptr = UNINIT.as_ptr();
6848 assert_eq!(
6849 ::std::mem::size_of::<LobbyCreated_t>(),
6850 12usize,
6851 concat!("Size of: ", stringify!(LobbyCreated_t))
6852 );
6853 assert_eq!(
6854 ::std::mem::align_of::<LobbyCreated_t>(),
6855 4usize,
6856 concat!("Alignment of ", stringify!(LobbyCreated_t))
6857 );
6858 assert_eq!(
6859 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
6860 0usize,
6861 concat!(
6862 "Offset of field: ",
6863 stringify!(LobbyCreated_t),
6864 "::",
6865 stringify!(m_eResult)
6866 )
6867 );
6868 assert_eq!(
6869 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDLobby) as usize - ptr as usize },
6870 4usize,
6871 concat!(
6872 "Offset of field: ",
6873 stringify!(LobbyCreated_t),
6874 "::",
6875 stringify!(m_ulSteamIDLobby)
6876 )
6877 );
6878}
6879#[repr(C)]
6880#[derive(Debug, Copy, Clone)]
6881pub struct FavoritesListAccountsUpdated_t {
6882 pub m_eResult: EResult,
6883}
6884pub const FavoritesListAccountsUpdated_t_k_iCallback: FavoritesListAccountsUpdated_t__bindgen_ty_1 =
6885 FavoritesListAccountsUpdated_t__bindgen_ty_1::k_iCallback;
6886#[repr(u32)]
6887#[non_exhaustive]
6888#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6889pub enum FavoritesListAccountsUpdated_t__bindgen_ty_1 {
6890 k_iCallback = 516,
6891}
6892#[test]
6893fn bindgen_test_layout_FavoritesListAccountsUpdated_t() {
6894 const UNINIT: ::std::mem::MaybeUninit<FavoritesListAccountsUpdated_t> =
6895 ::std::mem::MaybeUninit::uninit();
6896 let ptr = UNINIT.as_ptr();
6897 assert_eq!(
6898 ::std::mem::size_of::<FavoritesListAccountsUpdated_t>(),
6899 4usize,
6900 concat!("Size of: ", stringify!(FavoritesListAccountsUpdated_t))
6901 );
6902 assert_eq!(
6903 ::std::mem::align_of::<FavoritesListAccountsUpdated_t>(),
6904 4usize,
6905 concat!("Alignment of ", stringify!(FavoritesListAccountsUpdated_t))
6906 );
6907 assert_eq!(
6908 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
6909 0usize,
6910 concat!(
6911 "Offset of field: ",
6912 stringify!(FavoritesListAccountsUpdated_t),
6913 "::",
6914 stringify!(m_eResult)
6915 )
6916 );
6917}
6918#[repr(C, packed(4))]
6919#[derive(Copy, Clone)]
6920pub struct JoinPartyCallback_t {
6921 pub m_eResult: EResult,
6922 pub m_ulBeaconID: PartyBeaconID_t,
6923 pub m_SteamIDBeaconOwner: CSteamID,
6924 pub m_rgchConnectString: [::std::os::raw::c_char; 256usize],
6925}
6926pub const JoinPartyCallback_t_k_iCallback: JoinPartyCallback_t__bindgen_ty_1 =
6927 JoinPartyCallback_t__bindgen_ty_1::k_iCallback;
6928#[repr(u32)]
6929#[non_exhaustive]
6930#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6931pub enum JoinPartyCallback_t__bindgen_ty_1 {
6932 k_iCallback = 5301,
6933}
6934#[test]
6935fn bindgen_test_layout_JoinPartyCallback_t() {
6936 const UNINIT: ::std::mem::MaybeUninit<JoinPartyCallback_t> = ::std::mem::MaybeUninit::uninit();
6937 let ptr = UNINIT.as_ptr();
6938 assert_eq!(
6939 ::std::mem::size_of::<JoinPartyCallback_t>(),
6940 276usize,
6941 concat!("Size of: ", stringify!(JoinPartyCallback_t))
6942 );
6943 assert_eq!(
6944 ::std::mem::align_of::<JoinPartyCallback_t>(),
6945 4usize,
6946 concat!("Alignment of ", stringify!(JoinPartyCallback_t))
6947 );
6948 assert_eq!(
6949 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
6950 0usize,
6951 concat!(
6952 "Offset of field: ",
6953 stringify!(JoinPartyCallback_t),
6954 "::",
6955 stringify!(m_eResult)
6956 )
6957 );
6958 assert_eq!(
6959 unsafe { ::std::ptr::addr_of!((*ptr).m_ulBeaconID) as usize - ptr as usize },
6960 4usize,
6961 concat!(
6962 "Offset of field: ",
6963 stringify!(JoinPartyCallback_t),
6964 "::",
6965 stringify!(m_ulBeaconID)
6966 )
6967 );
6968 assert_eq!(
6969 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamIDBeaconOwner) as usize - ptr as usize },
6970 12usize,
6971 concat!(
6972 "Offset of field: ",
6973 stringify!(JoinPartyCallback_t),
6974 "::",
6975 stringify!(m_SteamIDBeaconOwner)
6976 )
6977 );
6978 assert_eq!(
6979 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchConnectString) as usize - ptr as usize },
6980 20usize,
6981 concat!(
6982 "Offset of field: ",
6983 stringify!(JoinPartyCallback_t),
6984 "::",
6985 stringify!(m_rgchConnectString)
6986 )
6987 );
6988}
6989#[repr(C, packed(4))]
6990#[derive(Debug, Copy, Clone)]
6991pub struct CreateBeaconCallback_t {
6992 pub m_eResult: EResult,
6993 pub m_ulBeaconID: PartyBeaconID_t,
6994}
6995pub const CreateBeaconCallback_t_k_iCallback: CreateBeaconCallback_t__bindgen_ty_1 =
6996 CreateBeaconCallback_t__bindgen_ty_1::k_iCallback;
6997#[repr(u32)]
6998#[non_exhaustive]
6999#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7000pub enum CreateBeaconCallback_t__bindgen_ty_1 {
7001 k_iCallback = 5302,
7002}
7003#[test]
7004fn bindgen_test_layout_CreateBeaconCallback_t() {
7005 const UNINIT: ::std::mem::MaybeUninit<CreateBeaconCallback_t> =
7006 ::std::mem::MaybeUninit::uninit();
7007 let ptr = UNINIT.as_ptr();
7008 assert_eq!(
7009 ::std::mem::size_of::<CreateBeaconCallback_t>(),
7010 12usize,
7011 concat!("Size of: ", stringify!(CreateBeaconCallback_t))
7012 );
7013 assert_eq!(
7014 ::std::mem::align_of::<CreateBeaconCallback_t>(),
7015 4usize,
7016 concat!("Alignment of ", stringify!(CreateBeaconCallback_t))
7017 );
7018 assert_eq!(
7019 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7020 0usize,
7021 concat!(
7022 "Offset of field: ",
7023 stringify!(CreateBeaconCallback_t),
7024 "::",
7025 stringify!(m_eResult)
7026 )
7027 );
7028 assert_eq!(
7029 unsafe { ::std::ptr::addr_of!((*ptr).m_ulBeaconID) as usize - ptr as usize },
7030 4usize,
7031 concat!(
7032 "Offset of field: ",
7033 stringify!(CreateBeaconCallback_t),
7034 "::",
7035 stringify!(m_ulBeaconID)
7036 )
7037 );
7038}
7039#[repr(C, packed(4))]
7040#[derive(Copy, Clone)]
7041pub struct ReservationNotificationCallback_t {
7042 pub m_ulBeaconID: PartyBeaconID_t,
7043 pub m_steamIDJoiner: CSteamID,
7044}
7045pub const ReservationNotificationCallback_t_k_iCallback:
7046 ReservationNotificationCallback_t__bindgen_ty_1 =
7047 ReservationNotificationCallback_t__bindgen_ty_1::k_iCallback;
7048#[repr(u32)]
7049#[non_exhaustive]
7050#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7051pub enum ReservationNotificationCallback_t__bindgen_ty_1 {
7052 k_iCallback = 5303,
7053}
7054#[test]
7055fn bindgen_test_layout_ReservationNotificationCallback_t() {
7056 const UNINIT: ::std::mem::MaybeUninit<ReservationNotificationCallback_t> =
7057 ::std::mem::MaybeUninit::uninit();
7058 let ptr = UNINIT.as_ptr();
7059 assert_eq!(
7060 ::std::mem::size_of::<ReservationNotificationCallback_t>(),
7061 16usize,
7062 concat!("Size of: ", stringify!(ReservationNotificationCallback_t))
7063 );
7064 assert_eq!(
7065 ::std::mem::align_of::<ReservationNotificationCallback_t>(),
7066 4usize,
7067 concat!(
7068 "Alignment of ",
7069 stringify!(ReservationNotificationCallback_t)
7070 )
7071 );
7072 assert_eq!(
7073 unsafe { ::std::ptr::addr_of!((*ptr).m_ulBeaconID) as usize - ptr as usize },
7074 0usize,
7075 concat!(
7076 "Offset of field: ",
7077 stringify!(ReservationNotificationCallback_t),
7078 "::",
7079 stringify!(m_ulBeaconID)
7080 )
7081 );
7082 assert_eq!(
7083 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDJoiner) as usize - ptr as usize },
7084 8usize,
7085 concat!(
7086 "Offset of field: ",
7087 stringify!(ReservationNotificationCallback_t),
7088 "::",
7089 stringify!(m_steamIDJoiner)
7090 )
7091 );
7092}
7093#[repr(C)]
7094#[derive(Debug, Copy, Clone)]
7095pub struct ChangeNumOpenSlotsCallback_t {
7096 pub m_eResult: EResult,
7097}
7098pub const ChangeNumOpenSlotsCallback_t_k_iCallback: ChangeNumOpenSlotsCallback_t__bindgen_ty_1 =
7099 ChangeNumOpenSlotsCallback_t__bindgen_ty_1::k_iCallback;
7100#[repr(u32)]
7101#[non_exhaustive]
7102#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7103pub enum ChangeNumOpenSlotsCallback_t__bindgen_ty_1 {
7104 k_iCallback = 5304,
7105}
7106#[test]
7107fn bindgen_test_layout_ChangeNumOpenSlotsCallback_t() {
7108 const UNINIT: ::std::mem::MaybeUninit<ChangeNumOpenSlotsCallback_t> =
7109 ::std::mem::MaybeUninit::uninit();
7110 let ptr = UNINIT.as_ptr();
7111 assert_eq!(
7112 ::std::mem::size_of::<ChangeNumOpenSlotsCallback_t>(),
7113 4usize,
7114 concat!("Size of: ", stringify!(ChangeNumOpenSlotsCallback_t))
7115 );
7116 assert_eq!(
7117 ::std::mem::align_of::<ChangeNumOpenSlotsCallback_t>(),
7118 4usize,
7119 concat!("Alignment of ", stringify!(ChangeNumOpenSlotsCallback_t))
7120 );
7121 assert_eq!(
7122 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7123 0usize,
7124 concat!(
7125 "Offset of field: ",
7126 stringify!(ChangeNumOpenSlotsCallback_t),
7127 "::",
7128 stringify!(m_eResult)
7129 )
7130 );
7131}
7132#[repr(C)]
7133#[derive(Debug, Copy, Clone)]
7134pub struct AvailableBeaconLocationsUpdated_t {
7135 pub _address: u8,
7136}
7137pub const AvailableBeaconLocationsUpdated_t_k_iCallback:
7138 AvailableBeaconLocationsUpdated_t__bindgen_ty_1 =
7139 AvailableBeaconLocationsUpdated_t__bindgen_ty_1::k_iCallback;
7140#[repr(u32)]
7141#[non_exhaustive]
7142#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7143pub enum AvailableBeaconLocationsUpdated_t__bindgen_ty_1 {
7144 k_iCallback = 5305,
7145}
7146#[test]
7147fn bindgen_test_layout_AvailableBeaconLocationsUpdated_t() {
7148 assert_eq!(
7149 ::std::mem::size_of::<AvailableBeaconLocationsUpdated_t>(),
7150 1usize,
7151 concat!("Size of: ", stringify!(AvailableBeaconLocationsUpdated_t))
7152 );
7153 assert_eq!(
7154 ::std::mem::align_of::<AvailableBeaconLocationsUpdated_t>(),
7155 1usize,
7156 concat!(
7157 "Alignment of ",
7158 stringify!(AvailableBeaconLocationsUpdated_t)
7159 )
7160 );
7161}
7162#[repr(C)]
7163#[derive(Debug, Copy, Clone)]
7164pub struct ActiveBeaconsUpdated_t {
7165 pub _address: u8,
7166}
7167pub const ActiveBeaconsUpdated_t_k_iCallback: ActiveBeaconsUpdated_t__bindgen_ty_1 =
7168 ActiveBeaconsUpdated_t__bindgen_ty_1::k_iCallback;
7169#[repr(u32)]
7170#[non_exhaustive]
7171#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7172pub enum ActiveBeaconsUpdated_t__bindgen_ty_1 {
7173 k_iCallback = 5306,
7174}
7175#[test]
7176fn bindgen_test_layout_ActiveBeaconsUpdated_t() {
7177 assert_eq!(
7178 ::std::mem::size_of::<ActiveBeaconsUpdated_t>(),
7179 1usize,
7180 concat!("Size of: ", stringify!(ActiveBeaconsUpdated_t))
7181 );
7182 assert_eq!(
7183 ::std::mem::align_of::<ActiveBeaconsUpdated_t>(),
7184 1usize,
7185 concat!("Alignment of ", stringify!(ActiveBeaconsUpdated_t))
7186 );
7187}
7188pub const k_unMaxCloudFileChunkSize: uint32 = 104857600;
7189#[repr(C, packed(4))]
7190#[derive(Debug, Copy, Clone)]
7191pub struct SteamParamStringArray_t {
7192 pub m_ppStrings: *mut *const ::std::os::raw::c_char,
7193 pub m_nNumStrings: int32,
7194}
7195#[test]
7196fn bindgen_test_layout_SteamParamStringArray_t() {
7197 const UNINIT: ::std::mem::MaybeUninit<SteamParamStringArray_t> =
7198 ::std::mem::MaybeUninit::uninit();
7199 let ptr = UNINIT.as_ptr();
7200 assert_eq!(
7201 ::std::mem::size_of::<SteamParamStringArray_t>(),
7202 12usize,
7203 concat!("Size of: ", stringify!(SteamParamStringArray_t))
7204 );
7205 assert_eq!(
7206 ::std::mem::align_of::<SteamParamStringArray_t>(),
7207 4usize,
7208 concat!("Alignment of ", stringify!(SteamParamStringArray_t))
7209 );
7210 assert_eq!(
7211 unsafe { ::std::ptr::addr_of!((*ptr).m_ppStrings) as usize - ptr as usize },
7212 0usize,
7213 concat!(
7214 "Offset of field: ",
7215 stringify!(SteamParamStringArray_t),
7216 "::",
7217 stringify!(m_ppStrings)
7218 )
7219 );
7220 assert_eq!(
7221 unsafe { ::std::ptr::addr_of!((*ptr).m_nNumStrings) as usize - ptr as usize },
7222 8usize,
7223 concat!(
7224 "Offset of field: ",
7225 stringify!(SteamParamStringArray_t),
7226 "::",
7227 stringify!(m_nNumStrings)
7228 )
7229 );
7230}
7231pub type UGCHandle_t = uint64;
7232pub type PublishedFileUpdateHandle_t = uint64;
7233pub type PublishedFileId_t = uint64;
7234pub const k_PublishedFileIdInvalid: PublishedFileId_t = 0;
7235pub const k_UGCHandleInvalid: UGCHandle_t = 18446744073709551615;
7236pub const k_PublishedFileUpdateHandleInvalid: PublishedFileUpdateHandle_t = 18446744073709551615;
7237pub type UGCFileWriteStreamHandle_t = uint64;
7238pub const k_UGCFileStreamHandleInvalid: UGCFileWriteStreamHandle_t = 18446744073709551615;
7239pub const k_cchPublishedDocumentTitleMax: uint32 = 129;
7240pub const k_cchPublishedDocumentDescriptionMax: uint32 = 8000;
7241pub const k_cchPublishedDocumentChangeDescriptionMax: uint32 = 8000;
7242pub const k_unEnumeratePublishedFilesMaxResults: uint32 = 50;
7243pub const k_cchTagListMax: uint32 = 1025;
7244pub const k_cchFilenameMax: uint32 = 260;
7245pub const k_cchPublishedFileURLMax: uint32 = 256;
7246impl ERemoteStoragePlatform {
7247 pub const k_ERemoteStoragePlatformNone: ERemoteStoragePlatform = ERemoteStoragePlatform(0);
7248}
7249impl ERemoteStoragePlatform {
7250 pub const k_ERemoteStoragePlatformWindows: ERemoteStoragePlatform = ERemoteStoragePlatform(1);
7251}
7252impl ERemoteStoragePlatform {
7253 pub const k_ERemoteStoragePlatformOSX: ERemoteStoragePlatform = ERemoteStoragePlatform(2);
7254}
7255impl ERemoteStoragePlatform {
7256 pub const k_ERemoteStoragePlatformPS3: ERemoteStoragePlatform = ERemoteStoragePlatform(4);
7257}
7258impl ERemoteStoragePlatform {
7259 pub const k_ERemoteStoragePlatformLinux: ERemoteStoragePlatform = ERemoteStoragePlatform(8);
7260}
7261impl ERemoteStoragePlatform {
7262 pub const k_ERemoteStoragePlatformSwitch: ERemoteStoragePlatform = ERemoteStoragePlatform(16);
7263}
7264impl ERemoteStoragePlatform {
7265 pub const k_ERemoteStoragePlatformAndroid: ERemoteStoragePlatform = ERemoteStoragePlatform(32);
7266}
7267impl ERemoteStoragePlatform {
7268 pub const k_ERemoteStoragePlatformIOS: ERemoteStoragePlatform = ERemoteStoragePlatform(64);
7269}
7270impl ERemoteStoragePlatform {
7271 pub const k_ERemoteStoragePlatformAll: ERemoteStoragePlatform =
7272 ERemoteStoragePlatform(4294967295);
7273}
7274impl ::std::ops::BitOr<ERemoteStoragePlatform> for ERemoteStoragePlatform {
7275 type Output = Self;
7276 #[inline]
7277 fn bitor(self, other: Self) -> Self {
7278 ERemoteStoragePlatform(self.0 | other.0)
7279 }
7280}
7281impl ::std::ops::BitOrAssign for ERemoteStoragePlatform {
7282 #[inline]
7283 fn bitor_assign(&mut self, rhs: ERemoteStoragePlatform) {
7284 self.0 |= rhs.0;
7285 }
7286}
7287impl ::std::ops::BitAnd<ERemoteStoragePlatform> for ERemoteStoragePlatform {
7288 type Output = Self;
7289 #[inline]
7290 fn bitand(self, other: Self) -> Self {
7291 ERemoteStoragePlatform(self.0 & other.0)
7292 }
7293}
7294impl ::std::ops::BitAndAssign for ERemoteStoragePlatform {
7295 #[inline]
7296 fn bitand_assign(&mut self, rhs: ERemoteStoragePlatform) {
7297 self.0 &= rhs.0;
7298 }
7299}
7300#[repr(transparent)]
7301#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7302pub struct ERemoteStoragePlatform(pub ::std::os::raw::c_uint);
7303#[repr(u32)]
7304#[non_exhaustive]
7305#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7306pub enum ERemoteStoragePublishedFileVisibility {
7307 k_ERemoteStoragePublishedFileVisibilityPublic = 0,
7308 k_ERemoteStoragePublishedFileVisibilityFriendsOnly = 1,
7309 k_ERemoteStoragePublishedFileVisibilityPrivate = 2,
7310 k_ERemoteStoragePublishedFileVisibilityUnlisted = 3,
7311}
7312impl EWorkshopFileType {
7313 pub const k_EWorkshopFileTypeCommunity: EWorkshopFileType =
7314 EWorkshopFileType::k_EWorkshopFileTypeFirst;
7315}
7316#[repr(u32)]
7317#[non_exhaustive]
7318#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7319pub enum EWorkshopFileType {
7320 k_EWorkshopFileTypeFirst = 0,
7321 k_EWorkshopFileTypeMicrotransaction = 1,
7322 k_EWorkshopFileTypeCollection = 2,
7323 k_EWorkshopFileTypeArt = 3,
7324 k_EWorkshopFileTypeVideo = 4,
7325 k_EWorkshopFileTypeScreenshot = 5,
7326 k_EWorkshopFileTypeGame = 6,
7327 k_EWorkshopFileTypeSoftware = 7,
7328 k_EWorkshopFileTypeConcept = 8,
7329 k_EWorkshopFileTypeWebGuide = 9,
7330 k_EWorkshopFileTypeIntegratedGuide = 10,
7331 k_EWorkshopFileTypeMerch = 11,
7332 k_EWorkshopFileTypeControllerBinding = 12,
7333 k_EWorkshopFileTypeSteamworksAccessInvite = 13,
7334 k_EWorkshopFileTypeSteamVideo = 14,
7335 k_EWorkshopFileTypeGameManagedItem = 15,
7336 k_EWorkshopFileTypeClip = 16,
7337 k_EWorkshopFileTypeMax = 17,
7338}
7339#[repr(u32)]
7340#[non_exhaustive]
7341#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7342pub enum EWorkshopVote {
7343 k_EWorkshopVoteUnvoted = 0,
7344 k_EWorkshopVoteFor = 1,
7345 k_EWorkshopVoteAgainst = 2,
7346 k_EWorkshopVoteLater = 3,
7347}
7348#[repr(u32)]
7349#[non_exhaustive]
7350#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7351pub enum EWorkshopFileAction {
7352 k_EWorkshopFileActionPlayed = 0,
7353 k_EWorkshopFileActionCompleted = 1,
7354}
7355#[repr(u32)]
7356#[non_exhaustive]
7357#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7358pub enum EWorkshopEnumerationType {
7359 k_EWorkshopEnumerationTypeRankedByVote = 0,
7360 k_EWorkshopEnumerationTypeRecent = 1,
7361 k_EWorkshopEnumerationTypeTrending = 2,
7362 k_EWorkshopEnumerationTypeFavoritesOfFriends = 3,
7363 k_EWorkshopEnumerationTypeVotedByFriends = 4,
7364 k_EWorkshopEnumerationTypeContentByFriends = 5,
7365 k_EWorkshopEnumerationTypeRecentFromFollowedUsers = 6,
7366}
7367#[repr(u32)]
7368#[non_exhaustive]
7369#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7370pub enum EWorkshopVideoProvider {
7371 k_EWorkshopVideoProviderNone = 0,
7372 k_EWorkshopVideoProviderYoutube = 1,
7373}
7374#[repr(u32)]
7375#[non_exhaustive]
7376#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7377pub enum EUGCReadAction {
7378 k_EUGCRead_ContinueReadingUntilFinished = 0,
7379 k_EUGCRead_ContinueReading = 1,
7380 k_EUGCRead_Close = 2,
7381}
7382#[repr(u32)]
7383#[non_exhaustive]
7384#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7385pub enum ERemoteStorageLocalFileChange {
7386 k_ERemoteStorageLocalFileChange_Invalid = 0,
7387 k_ERemoteStorageLocalFileChange_FileUpdated = 1,
7388 k_ERemoteStorageLocalFileChange_FileDeleted = 2,
7389}
7390#[repr(u32)]
7391#[non_exhaustive]
7392#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7393pub enum ERemoteStorageFilePathType {
7394 k_ERemoteStorageFilePathType_Invalid = 0,
7395 k_ERemoteStorageFilePathType_Absolute = 1,
7396 k_ERemoteStorageFilePathType_APIFilename = 2,
7397}
7398#[repr(C)]
7399pub struct ISteamRemoteStorage__bindgen_vtable(::std::os::raw::c_void);
7400#[repr(C)]
7401#[derive(Debug, Copy, Clone)]
7402pub struct ISteamRemoteStorage {
7403 pub vtable_: *const ISteamRemoteStorage__bindgen_vtable,
7404}
7405#[test]
7406fn bindgen_test_layout_ISteamRemoteStorage() {
7407 assert_eq!(
7408 ::std::mem::size_of::<ISteamRemoteStorage>(),
7409 8usize,
7410 concat!("Size of: ", stringify!(ISteamRemoteStorage))
7411 );
7412 assert_eq!(
7413 ::std::mem::align_of::<ISteamRemoteStorage>(),
7414 8usize,
7415 concat!("Alignment of ", stringify!(ISteamRemoteStorage))
7416 );
7417}
7418#[repr(C, packed(4))]
7419#[derive(Debug, Copy, Clone)]
7420pub struct RemoteStorageFileShareResult_t {
7421 pub m_eResult: EResult,
7422 pub m_hFile: UGCHandle_t,
7423 pub m_rgchFilename: [::std::os::raw::c_char; 260usize],
7424}
7425pub const RemoteStorageFileShareResult_t_k_iCallback: RemoteStorageFileShareResult_t__bindgen_ty_1 =
7426 RemoteStorageFileShareResult_t__bindgen_ty_1::k_iCallback;
7427#[repr(u32)]
7428#[non_exhaustive]
7429#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7430pub enum RemoteStorageFileShareResult_t__bindgen_ty_1 {
7431 k_iCallback = 1307,
7432}
7433#[test]
7434fn bindgen_test_layout_RemoteStorageFileShareResult_t() {
7435 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageFileShareResult_t> =
7436 ::std::mem::MaybeUninit::uninit();
7437 let ptr = UNINIT.as_ptr();
7438 assert_eq!(
7439 ::std::mem::size_of::<RemoteStorageFileShareResult_t>(),
7440 272usize,
7441 concat!("Size of: ", stringify!(RemoteStorageFileShareResult_t))
7442 );
7443 assert_eq!(
7444 ::std::mem::align_of::<RemoteStorageFileShareResult_t>(),
7445 4usize,
7446 concat!("Alignment of ", stringify!(RemoteStorageFileShareResult_t))
7447 );
7448 assert_eq!(
7449 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7450 0usize,
7451 concat!(
7452 "Offset of field: ",
7453 stringify!(RemoteStorageFileShareResult_t),
7454 "::",
7455 stringify!(m_eResult)
7456 )
7457 );
7458 assert_eq!(
7459 unsafe { ::std::ptr::addr_of!((*ptr).m_hFile) as usize - ptr as usize },
7460 4usize,
7461 concat!(
7462 "Offset of field: ",
7463 stringify!(RemoteStorageFileShareResult_t),
7464 "::",
7465 stringify!(m_hFile)
7466 )
7467 );
7468 assert_eq!(
7469 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchFilename) as usize - ptr as usize },
7470 12usize,
7471 concat!(
7472 "Offset of field: ",
7473 stringify!(RemoteStorageFileShareResult_t),
7474 "::",
7475 stringify!(m_rgchFilename)
7476 )
7477 );
7478}
7479#[repr(C, packed(4))]
7480#[derive(Debug, Copy, Clone)]
7481pub struct RemoteStoragePublishFileResult_t {
7482 pub m_eResult: EResult,
7483 pub m_nPublishedFileId: PublishedFileId_t,
7484 pub m_bUserNeedsToAcceptWorkshopLegalAgreement: bool,
7485}
7486pub const RemoteStoragePublishFileResult_t_k_iCallback:
7487 RemoteStoragePublishFileResult_t__bindgen_ty_1 =
7488 RemoteStoragePublishFileResult_t__bindgen_ty_1::k_iCallback;
7489#[repr(u32)]
7490#[non_exhaustive]
7491#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7492pub enum RemoteStoragePublishFileResult_t__bindgen_ty_1 {
7493 k_iCallback = 1309,
7494}
7495#[test]
7496fn bindgen_test_layout_RemoteStoragePublishFileResult_t() {
7497 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishFileResult_t> =
7498 ::std::mem::MaybeUninit::uninit();
7499 let ptr = UNINIT.as_ptr();
7500 assert_eq!(
7501 ::std::mem::size_of::<RemoteStoragePublishFileResult_t>(),
7502 16usize,
7503 concat!("Size of: ", stringify!(RemoteStoragePublishFileResult_t))
7504 );
7505 assert_eq!(
7506 ::std::mem::align_of::<RemoteStoragePublishFileResult_t>(),
7507 4usize,
7508 concat!(
7509 "Alignment of ",
7510 stringify!(RemoteStoragePublishFileResult_t)
7511 )
7512 );
7513 assert_eq!(
7514 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7515 0usize,
7516 concat!(
7517 "Offset of field: ",
7518 stringify!(RemoteStoragePublishFileResult_t),
7519 "::",
7520 stringify!(m_eResult)
7521 )
7522 );
7523 assert_eq!(
7524 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
7525 4usize,
7526 concat!(
7527 "Offset of field: ",
7528 stringify!(RemoteStoragePublishFileResult_t),
7529 "::",
7530 stringify!(m_nPublishedFileId)
7531 )
7532 );
7533 assert_eq!(
7534 unsafe {
7535 ::std::ptr::addr_of!((*ptr).m_bUserNeedsToAcceptWorkshopLegalAgreement) as usize
7536 - ptr as usize
7537 },
7538 12usize,
7539 concat!(
7540 "Offset of field: ",
7541 stringify!(RemoteStoragePublishFileResult_t),
7542 "::",
7543 stringify!(m_bUserNeedsToAcceptWorkshopLegalAgreement)
7544 )
7545 );
7546}
7547#[repr(C, packed(4))]
7548#[derive(Debug, Copy, Clone)]
7549pub struct RemoteStorageDeletePublishedFileResult_t {
7550 pub m_eResult: EResult,
7551 pub m_nPublishedFileId: PublishedFileId_t,
7552}
7553pub const RemoteStorageDeletePublishedFileResult_t_k_iCallback:
7554 RemoteStorageDeletePublishedFileResult_t__bindgen_ty_1 =
7555 RemoteStorageDeletePublishedFileResult_t__bindgen_ty_1::k_iCallback;
7556#[repr(u32)]
7557#[non_exhaustive]
7558#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7559pub enum RemoteStorageDeletePublishedFileResult_t__bindgen_ty_1 {
7560 k_iCallback = 1311,
7561}
7562#[test]
7563fn bindgen_test_layout_RemoteStorageDeletePublishedFileResult_t() {
7564 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageDeletePublishedFileResult_t> =
7565 ::std::mem::MaybeUninit::uninit();
7566 let ptr = UNINIT.as_ptr();
7567 assert_eq!(
7568 ::std::mem::size_of::<RemoteStorageDeletePublishedFileResult_t>(),
7569 12usize,
7570 concat!(
7571 "Size of: ",
7572 stringify!(RemoteStorageDeletePublishedFileResult_t)
7573 )
7574 );
7575 assert_eq!(
7576 ::std::mem::align_of::<RemoteStorageDeletePublishedFileResult_t>(),
7577 4usize,
7578 concat!(
7579 "Alignment of ",
7580 stringify!(RemoteStorageDeletePublishedFileResult_t)
7581 )
7582 );
7583 assert_eq!(
7584 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7585 0usize,
7586 concat!(
7587 "Offset of field: ",
7588 stringify!(RemoteStorageDeletePublishedFileResult_t),
7589 "::",
7590 stringify!(m_eResult)
7591 )
7592 );
7593 assert_eq!(
7594 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
7595 4usize,
7596 concat!(
7597 "Offset of field: ",
7598 stringify!(RemoteStorageDeletePublishedFileResult_t),
7599 "::",
7600 stringify!(m_nPublishedFileId)
7601 )
7602 );
7603}
7604#[repr(C, packed(4))]
7605#[derive(Debug, Copy, Clone)]
7606pub struct RemoteStorageEnumerateUserPublishedFilesResult_t {
7607 pub m_eResult: EResult,
7608 pub m_nResultsReturned: int32,
7609 pub m_nTotalResultCount: int32,
7610 pub m_rgPublishedFileId: [PublishedFileId_t; 50usize],
7611}
7612pub const RemoteStorageEnumerateUserPublishedFilesResult_t_k_iCallback:
7613 RemoteStorageEnumerateUserPublishedFilesResult_t__bindgen_ty_1 =
7614 RemoteStorageEnumerateUserPublishedFilesResult_t__bindgen_ty_1::k_iCallback;
7615#[repr(u32)]
7616#[non_exhaustive]
7617#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7618pub enum RemoteStorageEnumerateUserPublishedFilesResult_t__bindgen_ty_1 {
7619 k_iCallback = 1312,
7620}
7621#[test]
7622fn bindgen_test_layout_RemoteStorageEnumerateUserPublishedFilesResult_t() {
7623 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageEnumerateUserPublishedFilesResult_t> =
7624 ::std::mem::MaybeUninit::uninit();
7625 let ptr = UNINIT.as_ptr();
7626 assert_eq!(
7627 ::std::mem::size_of::<RemoteStorageEnumerateUserPublishedFilesResult_t>(),
7628 412usize,
7629 concat!(
7630 "Size of: ",
7631 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t)
7632 )
7633 );
7634 assert_eq!(
7635 ::std::mem::align_of::<RemoteStorageEnumerateUserPublishedFilesResult_t>(),
7636 4usize,
7637 concat!(
7638 "Alignment of ",
7639 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t)
7640 )
7641 );
7642 assert_eq!(
7643 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7644 0usize,
7645 concat!(
7646 "Offset of field: ",
7647 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t),
7648 "::",
7649 stringify!(m_eResult)
7650 )
7651 );
7652 assert_eq!(
7653 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
7654 4usize,
7655 concat!(
7656 "Offset of field: ",
7657 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t),
7658 "::",
7659 stringify!(m_nResultsReturned)
7660 )
7661 );
7662 assert_eq!(
7663 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
7664 8usize,
7665 concat!(
7666 "Offset of field: ",
7667 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t),
7668 "::",
7669 stringify!(m_nTotalResultCount)
7670 )
7671 );
7672 assert_eq!(
7673 unsafe { ::std::ptr::addr_of!((*ptr).m_rgPublishedFileId) as usize - ptr as usize },
7674 12usize,
7675 concat!(
7676 "Offset of field: ",
7677 stringify!(RemoteStorageEnumerateUserPublishedFilesResult_t),
7678 "::",
7679 stringify!(m_rgPublishedFileId)
7680 )
7681 );
7682}
7683#[repr(C, packed(4))]
7684#[derive(Debug, Copy, Clone)]
7685pub struct RemoteStorageSubscribePublishedFileResult_t {
7686 pub m_eResult: EResult,
7687 pub m_nPublishedFileId: PublishedFileId_t,
7688}
7689pub const RemoteStorageSubscribePublishedFileResult_t_k_iCallback:
7690 RemoteStorageSubscribePublishedFileResult_t__bindgen_ty_1 =
7691 RemoteStorageSubscribePublishedFileResult_t__bindgen_ty_1::k_iCallback;
7692#[repr(u32)]
7693#[non_exhaustive]
7694#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7695pub enum RemoteStorageSubscribePublishedFileResult_t__bindgen_ty_1 {
7696 k_iCallback = 1313,
7697}
7698#[test]
7699fn bindgen_test_layout_RemoteStorageSubscribePublishedFileResult_t() {
7700 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageSubscribePublishedFileResult_t> =
7701 ::std::mem::MaybeUninit::uninit();
7702 let ptr = UNINIT.as_ptr();
7703 assert_eq!(
7704 ::std::mem::size_of::<RemoteStorageSubscribePublishedFileResult_t>(),
7705 12usize,
7706 concat!(
7707 "Size of: ",
7708 stringify!(RemoteStorageSubscribePublishedFileResult_t)
7709 )
7710 );
7711 assert_eq!(
7712 ::std::mem::align_of::<RemoteStorageSubscribePublishedFileResult_t>(),
7713 4usize,
7714 concat!(
7715 "Alignment of ",
7716 stringify!(RemoteStorageSubscribePublishedFileResult_t)
7717 )
7718 );
7719 assert_eq!(
7720 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7721 0usize,
7722 concat!(
7723 "Offset of field: ",
7724 stringify!(RemoteStorageSubscribePublishedFileResult_t),
7725 "::",
7726 stringify!(m_eResult)
7727 )
7728 );
7729 assert_eq!(
7730 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
7731 4usize,
7732 concat!(
7733 "Offset of field: ",
7734 stringify!(RemoteStorageSubscribePublishedFileResult_t),
7735 "::",
7736 stringify!(m_nPublishedFileId)
7737 )
7738 );
7739}
7740#[repr(C, packed(4))]
7741#[derive(Debug, Copy, Clone)]
7742pub struct RemoteStorageEnumerateUserSubscribedFilesResult_t {
7743 pub m_eResult: EResult,
7744 pub m_nResultsReturned: int32,
7745 pub m_nTotalResultCount: int32,
7746 pub m_rgPublishedFileId: [PublishedFileId_t; 50usize],
7747 pub m_rgRTimeSubscribed: [uint32; 50usize],
7748}
7749pub const RemoteStorageEnumerateUserSubscribedFilesResult_t_k_iCallback:
7750 RemoteStorageEnumerateUserSubscribedFilesResult_t__bindgen_ty_1 =
7751 RemoteStorageEnumerateUserSubscribedFilesResult_t__bindgen_ty_1::k_iCallback;
7752#[repr(u32)]
7753#[non_exhaustive]
7754#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7755pub enum RemoteStorageEnumerateUserSubscribedFilesResult_t__bindgen_ty_1 {
7756 k_iCallback = 1314,
7757}
7758#[test]
7759fn bindgen_test_layout_RemoteStorageEnumerateUserSubscribedFilesResult_t() {
7760 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageEnumerateUserSubscribedFilesResult_t> =
7761 ::std::mem::MaybeUninit::uninit();
7762 let ptr = UNINIT.as_ptr();
7763 assert_eq!(
7764 ::std::mem::size_of::<RemoteStorageEnumerateUserSubscribedFilesResult_t>(),
7765 612usize,
7766 concat!(
7767 "Size of: ",
7768 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t)
7769 )
7770 );
7771 assert_eq!(
7772 ::std::mem::align_of::<RemoteStorageEnumerateUserSubscribedFilesResult_t>(),
7773 4usize,
7774 concat!(
7775 "Alignment of ",
7776 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t)
7777 )
7778 );
7779 assert_eq!(
7780 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7781 0usize,
7782 concat!(
7783 "Offset of field: ",
7784 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t),
7785 "::",
7786 stringify!(m_eResult)
7787 )
7788 );
7789 assert_eq!(
7790 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
7791 4usize,
7792 concat!(
7793 "Offset of field: ",
7794 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t),
7795 "::",
7796 stringify!(m_nResultsReturned)
7797 )
7798 );
7799 assert_eq!(
7800 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
7801 8usize,
7802 concat!(
7803 "Offset of field: ",
7804 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t),
7805 "::",
7806 stringify!(m_nTotalResultCount)
7807 )
7808 );
7809 assert_eq!(
7810 unsafe { ::std::ptr::addr_of!((*ptr).m_rgPublishedFileId) as usize - ptr as usize },
7811 12usize,
7812 concat!(
7813 "Offset of field: ",
7814 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t),
7815 "::",
7816 stringify!(m_rgPublishedFileId)
7817 )
7818 );
7819 assert_eq!(
7820 unsafe { ::std::ptr::addr_of!((*ptr).m_rgRTimeSubscribed) as usize - ptr as usize },
7821 412usize,
7822 concat!(
7823 "Offset of field: ",
7824 stringify!(RemoteStorageEnumerateUserSubscribedFilesResult_t),
7825 "::",
7826 stringify!(m_rgRTimeSubscribed)
7827 )
7828 );
7829}
7830#[repr(C, packed(4))]
7831#[derive(Debug, Copy, Clone)]
7832pub struct RemoteStorageUnsubscribePublishedFileResult_t {
7833 pub m_eResult: EResult,
7834 pub m_nPublishedFileId: PublishedFileId_t,
7835}
7836pub const RemoteStorageUnsubscribePublishedFileResult_t_k_iCallback:
7837 RemoteStorageUnsubscribePublishedFileResult_t__bindgen_ty_1 =
7838 RemoteStorageUnsubscribePublishedFileResult_t__bindgen_ty_1::k_iCallback;
7839#[repr(u32)]
7840#[non_exhaustive]
7841#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7842pub enum RemoteStorageUnsubscribePublishedFileResult_t__bindgen_ty_1 {
7843 k_iCallback = 1315,
7844}
7845#[test]
7846fn bindgen_test_layout_RemoteStorageUnsubscribePublishedFileResult_t() {
7847 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageUnsubscribePublishedFileResult_t> =
7848 ::std::mem::MaybeUninit::uninit();
7849 let ptr = UNINIT.as_ptr();
7850 assert_eq!(
7851 ::std::mem::size_of::<RemoteStorageUnsubscribePublishedFileResult_t>(),
7852 12usize,
7853 concat!(
7854 "Size of: ",
7855 stringify!(RemoteStorageUnsubscribePublishedFileResult_t)
7856 )
7857 );
7858 assert_eq!(
7859 ::std::mem::align_of::<RemoteStorageUnsubscribePublishedFileResult_t>(),
7860 4usize,
7861 concat!(
7862 "Alignment of ",
7863 stringify!(RemoteStorageUnsubscribePublishedFileResult_t)
7864 )
7865 );
7866 assert_eq!(
7867 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7868 0usize,
7869 concat!(
7870 "Offset of field: ",
7871 stringify!(RemoteStorageUnsubscribePublishedFileResult_t),
7872 "::",
7873 stringify!(m_eResult)
7874 )
7875 );
7876 assert_eq!(
7877 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
7878 4usize,
7879 concat!(
7880 "Offset of field: ",
7881 stringify!(RemoteStorageUnsubscribePublishedFileResult_t),
7882 "::",
7883 stringify!(m_nPublishedFileId)
7884 )
7885 );
7886}
7887#[repr(C, packed(4))]
7888#[derive(Debug, Copy, Clone)]
7889pub struct RemoteStorageUpdatePublishedFileResult_t {
7890 pub m_eResult: EResult,
7891 pub m_nPublishedFileId: PublishedFileId_t,
7892 pub m_bUserNeedsToAcceptWorkshopLegalAgreement: bool,
7893}
7894pub const RemoteStorageUpdatePublishedFileResult_t_k_iCallback:
7895 RemoteStorageUpdatePublishedFileResult_t__bindgen_ty_1 =
7896 RemoteStorageUpdatePublishedFileResult_t__bindgen_ty_1::k_iCallback;
7897#[repr(u32)]
7898#[non_exhaustive]
7899#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7900pub enum RemoteStorageUpdatePublishedFileResult_t__bindgen_ty_1 {
7901 k_iCallback = 1316,
7902}
7903#[test]
7904fn bindgen_test_layout_RemoteStorageUpdatePublishedFileResult_t() {
7905 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageUpdatePublishedFileResult_t> =
7906 ::std::mem::MaybeUninit::uninit();
7907 let ptr = UNINIT.as_ptr();
7908 assert_eq!(
7909 ::std::mem::size_of::<RemoteStorageUpdatePublishedFileResult_t>(),
7910 16usize,
7911 concat!(
7912 "Size of: ",
7913 stringify!(RemoteStorageUpdatePublishedFileResult_t)
7914 )
7915 );
7916 assert_eq!(
7917 ::std::mem::align_of::<RemoteStorageUpdatePublishedFileResult_t>(),
7918 4usize,
7919 concat!(
7920 "Alignment of ",
7921 stringify!(RemoteStorageUpdatePublishedFileResult_t)
7922 )
7923 );
7924 assert_eq!(
7925 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7926 0usize,
7927 concat!(
7928 "Offset of field: ",
7929 stringify!(RemoteStorageUpdatePublishedFileResult_t),
7930 "::",
7931 stringify!(m_eResult)
7932 )
7933 );
7934 assert_eq!(
7935 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
7936 4usize,
7937 concat!(
7938 "Offset of field: ",
7939 stringify!(RemoteStorageUpdatePublishedFileResult_t),
7940 "::",
7941 stringify!(m_nPublishedFileId)
7942 )
7943 );
7944 assert_eq!(
7945 unsafe {
7946 ::std::ptr::addr_of!((*ptr).m_bUserNeedsToAcceptWorkshopLegalAgreement) as usize
7947 - ptr as usize
7948 },
7949 12usize,
7950 concat!(
7951 "Offset of field: ",
7952 stringify!(RemoteStorageUpdatePublishedFileResult_t),
7953 "::",
7954 stringify!(m_bUserNeedsToAcceptWorkshopLegalAgreement)
7955 )
7956 );
7957}
7958#[repr(C, packed(4))]
7959#[derive(Debug, Copy, Clone)]
7960pub struct RemoteStorageDownloadUGCResult_t {
7961 pub m_eResult: EResult,
7962 pub m_hFile: UGCHandle_t,
7963 pub m_nAppID: AppId_t,
7964 pub m_nSizeInBytes: int32,
7965 pub m_pchFileName: [::std::os::raw::c_char; 260usize],
7966 pub m_ulSteamIDOwner: uint64,
7967}
7968pub const RemoteStorageDownloadUGCResult_t_k_iCallback:
7969 RemoteStorageDownloadUGCResult_t__bindgen_ty_1 =
7970 RemoteStorageDownloadUGCResult_t__bindgen_ty_1::k_iCallback;
7971#[repr(u32)]
7972#[non_exhaustive]
7973#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7974pub enum RemoteStorageDownloadUGCResult_t__bindgen_ty_1 {
7975 k_iCallback = 1317,
7976}
7977#[test]
7978fn bindgen_test_layout_RemoteStorageDownloadUGCResult_t() {
7979 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageDownloadUGCResult_t> =
7980 ::std::mem::MaybeUninit::uninit();
7981 let ptr = UNINIT.as_ptr();
7982 assert_eq!(
7983 ::std::mem::size_of::<RemoteStorageDownloadUGCResult_t>(),
7984 288usize,
7985 concat!("Size of: ", stringify!(RemoteStorageDownloadUGCResult_t))
7986 );
7987 assert_eq!(
7988 ::std::mem::align_of::<RemoteStorageDownloadUGCResult_t>(),
7989 4usize,
7990 concat!(
7991 "Alignment of ",
7992 stringify!(RemoteStorageDownloadUGCResult_t)
7993 )
7994 );
7995 assert_eq!(
7996 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
7997 0usize,
7998 concat!(
7999 "Offset of field: ",
8000 stringify!(RemoteStorageDownloadUGCResult_t),
8001 "::",
8002 stringify!(m_eResult)
8003 )
8004 );
8005 assert_eq!(
8006 unsafe { ::std::ptr::addr_of!((*ptr).m_hFile) as usize - ptr as usize },
8007 4usize,
8008 concat!(
8009 "Offset of field: ",
8010 stringify!(RemoteStorageDownloadUGCResult_t),
8011 "::",
8012 stringify!(m_hFile)
8013 )
8014 );
8015 assert_eq!(
8016 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
8017 12usize,
8018 concat!(
8019 "Offset of field: ",
8020 stringify!(RemoteStorageDownloadUGCResult_t),
8021 "::",
8022 stringify!(m_nAppID)
8023 )
8024 );
8025 assert_eq!(
8026 unsafe { ::std::ptr::addr_of!((*ptr).m_nSizeInBytes) as usize - ptr as usize },
8027 16usize,
8028 concat!(
8029 "Offset of field: ",
8030 stringify!(RemoteStorageDownloadUGCResult_t),
8031 "::",
8032 stringify!(m_nSizeInBytes)
8033 )
8034 );
8035 assert_eq!(
8036 unsafe { ::std::ptr::addr_of!((*ptr).m_pchFileName) as usize - ptr as usize },
8037 20usize,
8038 concat!(
8039 "Offset of field: ",
8040 stringify!(RemoteStorageDownloadUGCResult_t),
8041 "::",
8042 stringify!(m_pchFileName)
8043 )
8044 );
8045 assert_eq!(
8046 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDOwner) as usize - ptr as usize },
8047 280usize,
8048 concat!(
8049 "Offset of field: ",
8050 stringify!(RemoteStorageDownloadUGCResult_t),
8051 "::",
8052 stringify!(m_ulSteamIDOwner)
8053 )
8054 );
8055}
8056#[repr(C, packed(4))]
8057#[derive(Debug, Copy, Clone)]
8058pub struct RemoteStorageGetPublishedFileDetailsResult_t {
8059 pub m_eResult: EResult,
8060 pub m_nPublishedFileId: PublishedFileId_t,
8061 pub m_nCreatorAppID: AppId_t,
8062 pub m_nConsumerAppID: AppId_t,
8063 pub m_rgchTitle: [::std::os::raw::c_char; 129usize],
8064 pub m_rgchDescription: [::std::os::raw::c_char; 8000usize],
8065 pub m_hFile: UGCHandle_t,
8066 pub m_hPreviewFile: UGCHandle_t,
8067 pub m_ulSteamIDOwner: uint64,
8068 pub m_rtimeCreated: uint32,
8069 pub m_rtimeUpdated: uint32,
8070 pub m_eVisibility: ERemoteStoragePublishedFileVisibility,
8071 pub m_bBanned: bool,
8072 pub m_rgchTags: [::std::os::raw::c_char; 1025usize],
8073 pub m_bTagsTruncated: bool,
8074 pub m_pchFileName: [::std::os::raw::c_char; 260usize],
8075 pub m_nFileSize: int32,
8076 pub m_nPreviewFileSize: int32,
8077 pub m_rgchURL: [::std::os::raw::c_char; 256usize],
8078 pub m_eFileType: EWorkshopFileType,
8079 pub m_bAcceptedForUse: bool,
8080}
8081pub const RemoteStorageGetPublishedFileDetailsResult_t_k_iCallback:
8082 RemoteStorageGetPublishedFileDetailsResult_t__bindgen_ty_1 =
8083 RemoteStorageGetPublishedFileDetailsResult_t__bindgen_ty_1::k_iCallback;
8084#[repr(u32)]
8085#[non_exhaustive]
8086#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8087pub enum RemoteStorageGetPublishedFileDetailsResult_t__bindgen_ty_1 {
8088 k_iCallback = 1318,
8089}
8090#[test]
8091fn bindgen_test_layout_RemoteStorageGetPublishedFileDetailsResult_t() {
8092 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageGetPublishedFileDetailsResult_t> =
8093 ::std::mem::MaybeUninit::uninit();
8094 let ptr = UNINIT.as_ptr();
8095 assert_eq!(
8096 ::std::mem::size_of::<RemoteStorageGetPublishedFileDetailsResult_t>(),
8097 9748usize,
8098 concat!(
8099 "Size of: ",
8100 stringify!(RemoteStorageGetPublishedFileDetailsResult_t)
8101 )
8102 );
8103 assert_eq!(
8104 ::std::mem::align_of::<RemoteStorageGetPublishedFileDetailsResult_t>(),
8105 4usize,
8106 concat!(
8107 "Alignment of ",
8108 stringify!(RemoteStorageGetPublishedFileDetailsResult_t)
8109 )
8110 );
8111 assert_eq!(
8112 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8113 0usize,
8114 concat!(
8115 "Offset of field: ",
8116 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8117 "::",
8118 stringify!(m_eResult)
8119 )
8120 );
8121 assert_eq!(
8122 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8123 4usize,
8124 concat!(
8125 "Offset of field: ",
8126 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8127 "::",
8128 stringify!(m_nPublishedFileId)
8129 )
8130 );
8131 assert_eq!(
8132 unsafe { ::std::ptr::addr_of!((*ptr).m_nCreatorAppID) as usize - ptr as usize },
8133 12usize,
8134 concat!(
8135 "Offset of field: ",
8136 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8137 "::",
8138 stringify!(m_nCreatorAppID)
8139 )
8140 );
8141 assert_eq!(
8142 unsafe { ::std::ptr::addr_of!((*ptr).m_nConsumerAppID) as usize - ptr as usize },
8143 16usize,
8144 concat!(
8145 "Offset of field: ",
8146 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8147 "::",
8148 stringify!(m_nConsumerAppID)
8149 )
8150 );
8151 assert_eq!(
8152 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchTitle) as usize - ptr as usize },
8153 20usize,
8154 concat!(
8155 "Offset of field: ",
8156 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8157 "::",
8158 stringify!(m_rgchTitle)
8159 )
8160 );
8161 assert_eq!(
8162 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchDescription) as usize - ptr as usize },
8163 149usize,
8164 concat!(
8165 "Offset of field: ",
8166 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8167 "::",
8168 stringify!(m_rgchDescription)
8169 )
8170 );
8171 assert_eq!(
8172 unsafe { ::std::ptr::addr_of!((*ptr).m_hFile) as usize - ptr as usize },
8173 8152usize,
8174 concat!(
8175 "Offset of field: ",
8176 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8177 "::",
8178 stringify!(m_hFile)
8179 )
8180 );
8181 assert_eq!(
8182 unsafe { ::std::ptr::addr_of!((*ptr).m_hPreviewFile) as usize - ptr as usize },
8183 8160usize,
8184 concat!(
8185 "Offset of field: ",
8186 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8187 "::",
8188 stringify!(m_hPreviewFile)
8189 )
8190 );
8191 assert_eq!(
8192 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDOwner) as usize - ptr as usize },
8193 8168usize,
8194 concat!(
8195 "Offset of field: ",
8196 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8197 "::",
8198 stringify!(m_ulSteamIDOwner)
8199 )
8200 );
8201 assert_eq!(
8202 unsafe { ::std::ptr::addr_of!((*ptr).m_rtimeCreated) as usize - ptr as usize },
8203 8176usize,
8204 concat!(
8205 "Offset of field: ",
8206 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8207 "::",
8208 stringify!(m_rtimeCreated)
8209 )
8210 );
8211 assert_eq!(
8212 unsafe { ::std::ptr::addr_of!((*ptr).m_rtimeUpdated) as usize - ptr as usize },
8213 8180usize,
8214 concat!(
8215 "Offset of field: ",
8216 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8217 "::",
8218 stringify!(m_rtimeUpdated)
8219 )
8220 );
8221 assert_eq!(
8222 unsafe { ::std::ptr::addr_of!((*ptr).m_eVisibility) as usize - ptr as usize },
8223 8184usize,
8224 concat!(
8225 "Offset of field: ",
8226 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8227 "::",
8228 stringify!(m_eVisibility)
8229 )
8230 );
8231 assert_eq!(
8232 unsafe { ::std::ptr::addr_of!((*ptr).m_bBanned) as usize - ptr as usize },
8233 8188usize,
8234 concat!(
8235 "Offset of field: ",
8236 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8237 "::",
8238 stringify!(m_bBanned)
8239 )
8240 );
8241 assert_eq!(
8242 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchTags) as usize - ptr as usize },
8243 8189usize,
8244 concat!(
8245 "Offset of field: ",
8246 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8247 "::",
8248 stringify!(m_rgchTags)
8249 )
8250 );
8251 assert_eq!(
8252 unsafe { ::std::ptr::addr_of!((*ptr).m_bTagsTruncated) as usize - ptr as usize },
8253 9214usize,
8254 concat!(
8255 "Offset of field: ",
8256 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8257 "::",
8258 stringify!(m_bTagsTruncated)
8259 )
8260 );
8261 assert_eq!(
8262 unsafe { ::std::ptr::addr_of!((*ptr).m_pchFileName) as usize - ptr as usize },
8263 9215usize,
8264 concat!(
8265 "Offset of field: ",
8266 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8267 "::",
8268 stringify!(m_pchFileName)
8269 )
8270 );
8271 assert_eq!(
8272 unsafe { ::std::ptr::addr_of!((*ptr).m_nFileSize) as usize - ptr as usize },
8273 9476usize,
8274 concat!(
8275 "Offset of field: ",
8276 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8277 "::",
8278 stringify!(m_nFileSize)
8279 )
8280 );
8281 assert_eq!(
8282 unsafe { ::std::ptr::addr_of!((*ptr).m_nPreviewFileSize) as usize - ptr as usize },
8283 9480usize,
8284 concat!(
8285 "Offset of field: ",
8286 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8287 "::",
8288 stringify!(m_nPreviewFileSize)
8289 )
8290 );
8291 assert_eq!(
8292 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchURL) as usize - ptr as usize },
8293 9484usize,
8294 concat!(
8295 "Offset of field: ",
8296 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8297 "::",
8298 stringify!(m_rgchURL)
8299 )
8300 );
8301 assert_eq!(
8302 unsafe { ::std::ptr::addr_of!((*ptr).m_eFileType) as usize - ptr as usize },
8303 9740usize,
8304 concat!(
8305 "Offset of field: ",
8306 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8307 "::",
8308 stringify!(m_eFileType)
8309 )
8310 );
8311 assert_eq!(
8312 unsafe { ::std::ptr::addr_of!((*ptr).m_bAcceptedForUse) as usize - ptr as usize },
8313 9744usize,
8314 concat!(
8315 "Offset of field: ",
8316 stringify!(RemoteStorageGetPublishedFileDetailsResult_t),
8317 "::",
8318 stringify!(m_bAcceptedForUse)
8319 )
8320 );
8321}
8322#[repr(C, packed(4))]
8323#[derive(Debug, Copy, Clone)]
8324pub struct RemoteStorageEnumerateWorkshopFilesResult_t {
8325 pub m_eResult: EResult,
8326 pub m_nResultsReturned: int32,
8327 pub m_nTotalResultCount: int32,
8328 pub m_rgPublishedFileId: [PublishedFileId_t; 50usize],
8329 pub m_rgScore: [f32; 50usize],
8330 pub m_nAppId: AppId_t,
8331 pub m_unStartIndex: uint32,
8332}
8333pub const RemoteStorageEnumerateWorkshopFilesResult_t_k_iCallback:
8334 RemoteStorageEnumerateWorkshopFilesResult_t__bindgen_ty_1 =
8335 RemoteStorageEnumerateWorkshopFilesResult_t__bindgen_ty_1::k_iCallback;
8336#[repr(u32)]
8337#[non_exhaustive]
8338#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8339pub enum RemoteStorageEnumerateWorkshopFilesResult_t__bindgen_ty_1 {
8340 k_iCallback = 1319,
8341}
8342#[test]
8343fn bindgen_test_layout_RemoteStorageEnumerateWorkshopFilesResult_t() {
8344 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageEnumerateWorkshopFilesResult_t> =
8345 ::std::mem::MaybeUninit::uninit();
8346 let ptr = UNINIT.as_ptr();
8347 assert_eq!(
8348 ::std::mem::size_of::<RemoteStorageEnumerateWorkshopFilesResult_t>(),
8349 620usize,
8350 concat!(
8351 "Size of: ",
8352 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t)
8353 )
8354 );
8355 assert_eq!(
8356 ::std::mem::align_of::<RemoteStorageEnumerateWorkshopFilesResult_t>(),
8357 4usize,
8358 concat!(
8359 "Alignment of ",
8360 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t)
8361 )
8362 );
8363 assert_eq!(
8364 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8365 0usize,
8366 concat!(
8367 "Offset of field: ",
8368 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8369 "::",
8370 stringify!(m_eResult)
8371 )
8372 );
8373 assert_eq!(
8374 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
8375 4usize,
8376 concat!(
8377 "Offset of field: ",
8378 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8379 "::",
8380 stringify!(m_nResultsReturned)
8381 )
8382 );
8383 assert_eq!(
8384 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
8385 8usize,
8386 concat!(
8387 "Offset of field: ",
8388 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8389 "::",
8390 stringify!(m_nTotalResultCount)
8391 )
8392 );
8393 assert_eq!(
8394 unsafe { ::std::ptr::addr_of!((*ptr).m_rgPublishedFileId) as usize - ptr as usize },
8395 12usize,
8396 concat!(
8397 "Offset of field: ",
8398 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8399 "::",
8400 stringify!(m_rgPublishedFileId)
8401 )
8402 );
8403 assert_eq!(
8404 unsafe { ::std::ptr::addr_of!((*ptr).m_rgScore) as usize - ptr as usize },
8405 412usize,
8406 concat!(
8407 "Offset of field: ",
8408 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8409 "::",
8410 stringify!(m_rgScore)
8411 )
8412 );
8413 assert_eq!(
8414 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppId) as usize - ptr as usize },
8415 612usize,
8416 concat!(
8417 "Offset of field: ",
8418 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8419 "::",
8420 stringify!(m_nAppId)
8421 )
8422 );
8423 assert_eq!(
8424 unsafe { ::std::ptr::addr_of!((*ptr).m_unStartIndex) as usize - ptr as usize },
8425 616usize,
8426 concat!(
8427 "Offset of field: ",
8428 stringify!(RemoteStorageEnumerateWorkshopFilesResult_t),
8429 "::",
8430 stringify!(m_unStartIndex)
8431 )
8432 );
8433}
8434#[repr(C, packed(4))]
8435#[derive(Debug, Copy, Clone)]
8436pub struct RemoteStorageGetPublishedItemVoteDetailsResult_t {
8437 pub m_eResult: EResult,
8438 pub m_unPublishedFileId: PublishedFileId_t,
8439 pub m_nVotesFor: int32,
8440 pub m_nVotesAgainst: int32,
8441 pub m_nReports: int32,
8442 pub m_fScore: f32,
8443}
8444pub const RemoteStorageGetPublishedItemVoteDetailsResult_t_k_iCallback:
8445 RemoteStorageGetPublishedItemVoteDetailsResult_t__bindgen_ty_1 =
8446 RemoteStorageGetPublishedItemVoteDetailsResult_t__bindgen_ty_1::k_iCallback;
8447#[repr(u32)]
8448#[non_exhaustive]
8449#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8450pub enum RemoteStorageGetPublishedItemVoteDetailsResult_t__bindgen_ty_1 {
8451 k_iCallback = 1320,
8452}
8453#[test]
8454fn bindgen_test_layout_RemoteStorageGetPublishedItemVoteDetailsResult_t() {
8455 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageGetPublishedItemVoteDetailsResult_t> =
8456 ::std::mem::MaybeUninit::uninit();
8457 let ptr = UNINIT.as_ptr();
8458 assert_eq!(
8459 ::std::mem::size_of::<RemoteStorageGetPublishedItemVoteDetailsResult_t>(),
8460 28usize,
8461 concat!(
8462 "Size of: ",
8463 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t)
8464 )
8465 );
8466 assert_eq!(
8467 ::std::mem::align_of::<RemoteStorageGetPublishedItemVoteDetailsResult_t>(),
8468 4usize,
8469 concat!(
8470 "Alignment of ",
8471 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t)
8472 )
8473 );
8474 assert_eq!(
8475 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8476 0usize,
8477 concat!(
8478 "Offset of field: ",
8479 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8480 "::",
8481 stringify!(m_eResult)
8482 )
8483 );
8484 assert_eq!(
8485 unsafe { ::std::ptr::addr_of!((*ptr).m_unPublishedFileId) as usize - ptr as usize },
8486 4usize,
8487 concat!(
8488 "Offset of field: ",
8489 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8490 "::",
8491 stringify!(m_unPublishedFileId)
8492 )
8493 );
8494 assert_eq!(
8495 unsafe { ::std::ptr::addr_of!((*ptr).m_nVotesFor) as usize - ptr as usize },
8496 12usize,
8497 concat!(
8498 "Offset of field: ",
8499 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8500 "::",
8501 stringify!(m_nVotesFor)
8502 )
8503 );
8504 assert_eq!(
8505 unsafe { ::std::ptr::addr_of!((*ptr).m_nVotesAgainst) as usize - ptr as usize },
8506 16usize,
8507 concat!(
8508 "Offset of field: ",
8509 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8510 "::",
8511 stringify!(m_nVotesAgainst)
8512 )
8513 );
8514 assert_eq!(
8515 unsafe { ::std::ptr::addr_of!((*ptr).m_nReports) as usize - ptr as usize },
8516 20usize,
8517 concat!(
8518 "Offset of field: ",
8519 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8520 "::",
8521 stringify!(m_nReports)
8522 )
8523 );
8524 assert_eq!(
8525 unsafe { ::std::ptr::addr_of!((*ptr).m_fScore) as usize - ptr as usize },
8526 24usize,
8527 concat!(
8528 "Offset of field: ",
8529 stringify!(RemoteStorageGetPublishedItemVoteDetailsResult_t),
8530 "::",
8531 stringify!(m_fScore)
8532 )
8533 );
8534}
8535#[repr(C, packed(4))]
8536#[derive(Debug, Copy, Clone)]
8537pub struct RemoteStoragePublishedFileSubscribed_t {
8538 pub m_nPublishedFileId: PublishedFileId_t,
8539 pub m_nAppID: AppId_t,
8540}
8541pub const RemoteStoragePublishedFileSubscribed_t_k_iCallback:
8542 RemoteStoragePublishedFileSubscribed_t__bindgen_ty_1 =
8543 RemoteStoragePublishedFileSubscribed_t__bindgen_ty_1::k_iCallback;
8544#[repr(u32)]
8545#[non_exhaustive]
8546#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8547pub enum RemoteStoragePublishedFileSubscribed_t__bindgen_ty_1 {
8548 k_iCallback = 1321,
8549}
8550#[test]
8551fn bindgen_test_layout_RemoteStoragePublishedFileSubscribed_t() {
8552 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishedFileSubscribed_t> =
8553 ::std::mem::MaybeUninit::uninit();
8554 let ptr = UNINIT.as_ptr();
8555 assert_eq!(
8556 ::std::mem::size_of::<RemoteStoragePublishedFileSubscribed_t>(),
8557 12usize,
8558 concat!(
8559 "Size of: ",
8560 stringify!(RemoteStoragePublishedFileSubscribed_t)
8561 )
8562 );
8563 assert_eq!(
8564 ::std::mem::align_of::<RemoteStoragePublishedFileSubscribed_t>(),
8565 4usize,
8566 concat!(
8567 "Alignment of ",
8568 stringify!(RemoteStoragePublishedFileSubscribed_t)
8569 )
8570 );
8571 assert_eq!(
8572 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8573 0usize,
8574 concat!(
8575 "Offset of field: ",
8576 stringify!(RemoteStoragePublishedFileSubscribed_t),
8577 "::",
8578 stringify!(m_nPublishedFileId)
8579 )
8580 );
8581 assert_eq!(
8582 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
8583 8usize,
8584 concat!(
8585 "Offset of field: ",
8586 stringify!(RemoteStoragePublishedFileSubscribed_t),
8587 "::",
8588 stringify!(m_nAppID)
8589 )
8590 );
8591}
8592#[repr(C, packed(4))]
8593#[derive(Debug, Copy, Clone)]
8594pub struct RemoteStoragePublishedFileUnsubscribed_t {
8595 pub m_nPublishedFileId: PublishedFileId_t,
8596 pub m_nAppID: AppId_t,
8597}
8598pub const RemoteStoragePublishedFileUnsubscribed_t_k_iCallback:
8599 RemoteStoragePublishedFileUnsubscribed_t__bindgen_ty_1 =
8600 RemoteStoragePublishedFileUnsubscribed_t__bindgen_ty_1::k_iCallback;
8601#[repr(u32)]
8602#[non_exhaustive]
8603#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8604pub enum RemoteStoragePublishedFileUnsubscribed_t__bindgen_ty_1 {
8605 k_iCallback = 1322,
8606}
8607#[test]
8608fn bindgen_test_layout_RemoteStoragePublishedFileUnsubscribed_t() {
8609 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishedFileUnsubscribed_t> =
8610 ::std::mem::MaybeUninit::uninit();
8611 let ptr = UNINIT.as_ptr();
8612 assert_eq!(
8613 ::std::mem::size_of::<RemoteStoragePublishedFileUnsubscribed_t>(),
8614 12usize,
8615 concat!(
8616 "Size of: ",
8617 stringify!(RemoteStoragePublishedFileUnsubscribed_t)
8618 )
8619 );
8620 assert_eq!(
8621 ::std::mem::align_of::<RemoteStoragePublishedFileUnsubscribed_t>(),
8622 4usize,
8623 concat!(
8624 "Alignment of ",
8625 stringify!(RemoteStoragePublishedFileUnsubscribed_t)
8626 )
8627 );
8628 assert_eq!(
8629 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8630 0usize,
8631 concat!(
8632 "Offset of field: ",
8633 stringify!(RemoteStoragePublishedFileUnsubscribed_t),
8634 "::",
8635 stringify!(m_nPublishedFileId)
8636 )
8637 );
8638 assert_eq!(
8639 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
8640 8usize,
8641 concat!(
8642 "Offset of field: ",
8643 stringify!(RemoteStoragePublishedFileUnsubscribed_t),
8644 "::",
8645 stringify!(m_nAppID)
8646 )
8647 );
8648}
8649#[repr(C, packed(4))]
8650#[derive(Debug, Copy, Clone)]
8651pub struct RemoteStoragePublishedFileDeleted_t {
8652 pub m_nPublishedFileId: PublishedFileId_t,
8653 pub m_nAppID: AppId_t,
8654}
8655pub const RemoteStoragePublishedFileDeleted_t_k_iCallback:
8656 RemoteStoragePublishedFileDeleted_t__bindgen_ty_1 =
8657 RemoteStoragePublishedFileDeleted_t__bindgen_ty_1::k_iCallback;
8658#[repr(u32)]
8659#[non_exhaustive]
8660#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8661pub enum RemoteStoragePublishedFileDeleted_t__bindgen_ty_1 {
8662 k_iCallback = 1323,
8663}
8664#[test]
8665fn bindgen_test_layout_RemoteStoragePublishedFileDeleted_t() {
8666 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishedFileDeleted_t> =
8667 ::std::mem::MaybeUninit::uninit();
8668 let ptr = UNINIT.as_ptr();
8669 assert_eq!(
8670 ::std::mem::size_of::<RemoteStoragePublishedFileDeleted_t>(),
8671 12usize,
8672 concat!("Size of: ", stringify!(RemoteStoragePublishedFileDeleted_t))
8673 );
8674 assert_eq!(
8675 ::std::mem::align_of::<RemoteStoragePublishedFileDeleted_t>(),
8676 4usize,
8677 concat!(
8678 "Alignment of ",
8679 stringify!(RemoteStoragePublishedFileDeleted_t)
8680 )
8681 );
8682 assert_eq!(
8683 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8684 0usize,
8685 concat!(
8686 "Offset of field: ",
8687 stringify!(RemoteStoragePublishedFileDeleted_t),
8688 "::",
8689 stringify!(m_nPublishedFileId)
8690 )
8691 );
8692 assert_eq!(
8693 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
8694 8usize,
8695 concat!(
8696 "Offset of field: ",
8697 stringify!(RemoteStoragePublishedFileDeleted_t),
8698 "::",
8699 stringify!(m_nAppID)
8700 )
8701 );
8702}
8703#[repr(C, packed(4))]
8704#[derive(Debug, Copy, Clone)]
8705pub struct RemoteStorageUpdateUserPublishedItemVoteResult_t {
8706 pub m_eResult: EResult,
8707 pub m_nPublishedFileId: PublishedFileId_t,
8708}
8709pub const RemoteStorageUpdateUserPublishedItemVoteResult_t_k_iCallback:
8710 RemoteStorageUpdateUserPublishedItemVoteResult_t__bindgen_ty_1 =
8711 RemoteStorageUpdateUserPublishedItemVoteResult_t__bindgen_ty_1::k_iCallback;
8712#[repr(u32)]
8713#[non_exhaustive]
8714#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8715pub enum RemoteStorageUpdateUserPublishedItemVoteResult_t__bindgen_ty_1 {
8716 k_iCallback = 1324,
8717}
8718#[test]
8719fn bindgen_test_layout_RemoteStorageUpdateUserPublishedItemVoteResult_t() {
8720 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageUpdateUserPublishedItemVoteResult_t> =
8721 ::std::mem::MaybeUninit::uninit();
8722 let ptr = UNINIT.as_ptr();
8723 assert_eq!(
8724 ::std::mem::size_of::<RemoteStorageUpdateUserPublishedItemVoteResult_t>(),
8725 12usize,
8726 concat!(
8727 "Size of: ",
8728 stringify!(RemoteStorageUpdateUserPublishedItemVoteResult_t)
8729 )
8730 );
8731 assert_eq!(
8732 ::std::mem::align_of::<RemoteStorageUpdateUserPublishedItemVoteResult_t>(),
8733 4usize,
8734 concat!(
8735 "Alignment of ",
8736 stringify!(RemoteStorageUpdateUserPublishedItemVoteResult_t)
8737 )
8738 );
8739 assert_eq!(
8740 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8741 0usize,
8742 concat!(
8743 "Offset of field: ",
8744 stringify!(RemoteStorageUpdateUserPublishedItemVoteResult_t),
8745 "::",
8746 stringify!(m_eResult)
8747 )
8748 );
8749 assert_eq!(
8750 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8751 4usize,
8752 concat!(
8753 "Offset of field: ",
8754 stringify!(RemoteStorageUpdateUserPublishedItemVoteResult_t),
8755 "::",
8756 stringify!(m_nPublishedFileId)
8757 )
8758 );
8759}
8760#[repr(C, packed(4))]
8761#[derive(Debug, Copy, Clone)]
8762pub struct RemoteStorageUserVoteDetails_t {
8763 pub m_eResult: EResult,
8764 pub m_nPublishedFileId: PublishedFileId_t,
8765 pub m_eVote: EWorkshopVote,
8766}
8767pub const RemoteStorageUserVoteDetails_t_k_iCallback: RemoteStorageUserVoteDetails_t__bindgen_ty_1 =
8768 RemoteStorageUserVoteDetails_t__bindgen_ty_1::k_iCallback;
8769#[repr(u32)]
8770#[non_exhaustive]
8771#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8772pub enum RemoteStorageUserVoteDetails_t__bindgen_ty_1 {
8773 k_iCallback = 1325,
8774}
8775#[test]
8776fn bindgen_test_layout_RemoteStorageUserVoteDetails_t() {
8777 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageUserVoteDetails_t> =
8778 ::std::mem::MaybeUninit::uninit();
8779 let ptr = UNINIT.as_ptr();
8780 assert_eq!(
8781 ::std::mem::size_of::<RemoteStorageUserVoteDetails_t>(),
8782 16usize,
8783 concat!("Size of: ", stringify!(RemoteStorageUserVoteDetails_t))
8784 );
8785 assert_eq!(
8786 ::std::mem::align_of::<RemoteStorageUserVoteDetails_t>(),
8787 4usize,
8788 concat!("Alignment of ", stringify!(RemoteStorageUserVoteDetails_t))
8789 );
8790 assert_eq!(
8791 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8792 0usize,
8793 concat!(
8794 "Offset of field: ",
8795 stringify!(RemoteStorageUserVoteDetails_t),
8796 "::",
8797 stringify!(m_eResult)
8798 )
8799 );
8800 assert_eq!(
8801 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8802 4usize,
8803 concat!(
8804 "Offset of field: ",
8805 stringify!(RemoteStorageUserVoteDetails_t),
8806 "::",
8807 stringify!(m_nPublishedFileId)
8808 )
8809 );
8810 assert_eq!(
8811 unsafe { ::std::ptr::addr_of!((*ptr).m_eVote) as usize - ptr as usize },
8812 12usize,
8813 concat!(
8814 "Offset of field: ",
8815 stringify!(RemoteStorageUserVoteDetails_t),
8816 "::",
8817 stringify!(m_eVote)
8818 )
8819 );
8820}
8821#[repr(C, packed(4))]
8822#[derive(Debug, Copy, Clone)]
8823pub struct RemoteStorageEnumerateUserSharedWorkshopFilesResult_t {
8824 pub m_eResult: EResult,
8825 pub m_nResultsReturned: int32,
8826 pub m_nTotalResultCount: int32,
8827 pub m_rgPublishedFileId: [PublishedFileId_t; 50usize],
8828}
8829pub const RemoteStorageEnumerateUserSharedWorkshopFilesResult_t_k_iCallback:
8830 RemoteStorageEnumerateUserSharedWorkshopFilesResult_t__bindgen_ty_1 =
8831 RemoteStorageEnumerateUserSharedWorkshopFilesResult_t__bindgen_ty_1::k_iCallback;
8832#[repr(u32)]
8833#[non_exhaustive]
8834#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8835pub enum RemoteStorageEnumerateUserSharedWorkshopFilesResult_t__bindgen_ty_1 {
8836 k_iCallback = 1326,
8837}
8838#[test]
8839fn bindgen_test_layout_RemoteStorageEnumerateUserSharedWorkshopFilesResult_t() {
8840 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageEnumerateUserSharedWorkshopFilesResult_t> =
8841 ::std::mem::MaybeUninit::uninit();
8842 let ptr = UNINIT.as_ptr();
8843 assert_eq!(
8844 ::std::mem::size_of::<RemoteStorageEnumerateUserSharedWorkshopFilesResult_t>(),
8845 412usize,
8846 concat!(
8847 "Size of: ",
8848 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t)
8849 )
8850 );
8851 assert_eq!(
8852 ::std::mem::align_of::<RemoteStorageEnumerateUserSharedWorkshopFilesResult_t>(),
8853 4usize,
8854 concat!(
8855 "Alignment of ",
8856 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t)
8857 )
8858 );
8859 assert_eq!(
8860 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8861 0usize,
8862 concat!(
8863 "Offset of field: ",
8864 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t),
8865 "::",
8866 stringify!(m_eResult)
8867 )
8868 );
8869 assert_eq!(
8870 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
8871 4usize,
8872 concat!(
8873 "Offset of field: ",
8874 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t),
8875 "::",
8876 stringify!(m_nResultsReturned)
8877 )
8878 );
8879 assert_eq!(
8880 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
8881 8usize,
8882 concat!(
8883 "Offset of field: ",
8884 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t),
8885 "::",
8886 stringify!(m_nTotalResultCount)
8887 )
8888 );
8889 assert_eq!(
8890 unsafe { ::std::ptr::addr_of!((*ptr).m_rgPublishedFileId) as usize - ptr as usize },
8891 12usize,
8892 concat!(
8893 "Offset of field: ",
8894 stringify!(RemoteStorageEnumerateUserSharedWorkshopFilesResult_t),
8895 "::",
8896 stringify!(m_rgPublishedFileId)
8897 )
8898 );
8899}
8900#[repr(C, packed(4))]
8901#[derive(Debug, Copy, Clone)]
8902pub struct RemoteStorageSetUserPublishedFileActionResult_t {
8903 pub m_eResult: EResult,
8904 pub m_nPublishedFileId: PublishedFileId_t,
8905 pub m_eAction: EWorkshopFileAction,
8906}
8907pub const RemoteStorageSetUserPublishedFileActionResult_t_k_iCallback:
8908 RemoteStorageSetUserPublishedFileActionResult_t__bindgen_ty_1 =
8909 RemoteStorageSetUserPublishedFileActionResult_t__bindgen_ty_1::k_iCallback;
8910#[repr(u32)]
8911#[non_exhaustive]
8912#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8913pub enum RemoteStorageSetUserPublishedFileActionResult_t__bindgen_ty_1 {
8914 k_iCallback = 1327,
8915}
8916#[test]
8917fn bindgen_test_layout_RemoteStorageSetUserPublishedFileActionResult_t() {
8918 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageSetUserPublishedFileActionResult_t> =
8919 ::std::mem::MaybeUninit::uninit();
8920 let ptr = UNINIT.as_ptr();
8921 assert_eq!(
8922 ::std::mem::size_of::<RemoteStorageSetUserPublishedFileActionResult_t>(),
8923 16usize,
8924 concat!(
8925 "Size of: ",
8926 stringify!(RemoteStorageSetUserPublishedFileActionResult_t)
8927 )
8928 );
8929 assert_eq!(
8930 ::std::mem::align_of::<RemoteStorageSetUserPublishedFileActionResult_t>(),
8931 4usize,
8932 concat!(
8933 "Alignment of ",
8934 stringify!(RemoteStorageSetUserPublishedFileActionResult_t)
8935 )
8936 );
8937 assert_eq!(
8938 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
8939 0usize,
8940 concat!(
8941 "Offset of field: ",
8942 stringify!(RemoteStorageSetUserPublishedFileActionResult_t),
8943 "::",
8944 stringify!(m_eResult)
8945 )
8946 );
8947 assert_eq!(
8948 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
8949 4usize,
8950 concat!(
8951 "Offset of field: ",
8952 stringify!(RemoteStorageSetUserPublishedFileActionResult_t),
8953 "::",
8954 stringify!(m_nPublishedFileId)
8955 )
8956 );
8957 assert_eq!(
8958 unsafe { ::std::ptr::addr_of!((*ptr).m_eAction) as usize - ptr as usize },
8959 12usize,
8960 concat!(
8961 "Offset of field: ",
8962 stringify!(RemoteStorageSetUserPublishedFileActionResult_t),
8963 "::",
8964 stringify!(m_eAction)
8965 )
8966 );
8967}
8968#[repr(C, packed(4))]
8969#[derive(Debug, Copy, Clone)]
8970pub struct RemoteStorageEnumeratePublishedFilesByUserActionResult_t {
8971 pub m_eResult: EResult,
8972 pub m_eAction: EWorkshopFileAction,
8973 pub m_nResultsReturned: int32,
8974 pub m_nTotalResultCount: int32,
8975 pub m_rgPublishedFileId: [PublishedFileId_t; 50usize],
8976 pub m_rgRTimeUpdated: [uint32; 50usize],
8977}
8978pub const RemoteStorageEnumeratePublishedFilesByUserActionResult_t_k_iCallback:
8979 RemoteStorageEnumeratePublishedFilesByUserActionResult_t__bindgen_ty_1 =
8980 RemoteStorageEnumeratePublishedFilesByUserActionResult_t__bindgen_ty_1::k_iCallback;
8981#[repr(u32)]
8982#[non_exhaustive]
8983#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
8984pub enum RemoteStorageEnumeratePublishedFilesByUserActionResult_t__bindgen_ty_1 {
8985 k_iCallback = 1328,
8986}
8987#[test]
8988fn bindgen_test_layout_RemoteStorageEnumeratePublishedFilesByUserActionResult_t() {
8989 const UNINIT: ::std::mem::MaybeUninit<
8990 RemoteStorageEnumeratePublishedFilesByUserActionResult_t,
8991 > = ::std::mem::MaybeUninit::uninit();
8992 let ptr = UNINIT.as_ptr();
8993 assert_eq!(
8994 ::std::mem::size_of::<RemoteStorageEnumeratePublishedFilesByUserActionResult_t>(),
8995 616usize,
8996 concat!(
8997 "Size of: ",
8998 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t)
8999 )
9000 );
9001 assert_eq!(
9002 ::std::mem::align_of::<RemoteStorageEnumeratePublishedFilesByUserActionResult_t>(),
9003 4usize,
9004 concat!(
9005 "Alignment of ",
9006 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t)
9007 )
9008 );
9009 assert_eq!(
9010 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
9011 0usize,
9012 concat!(
9013 "Offset of field: ",
9014 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9015 "::",
9016 stringify!(m_eResult)
9017 )
9018 );
9019 assert_eq!(
9020 unsafe { ::std::ptr::addr_of!((*ptr).m_eAction) as usize - ptr as usize },
9021 4usize,
9022 concat!(
9023 "Offset of field: ",
9024 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9025 "::",
9026 stringify!(m_eAction)
9027 )
9028 );
9029 assert_eq!(
9030 unsafe { ::std::ptr::addr_of!((*ptr).m_nResultsReturned) as usize - ptr as usize },
9031 8usize,
9032 concat!(
9033 "Offset of field: ",
9034 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9035 "::",
9036 stringify!(m_nResultsReturned)
9037 )
9038 );
9039 assert_eq!(
9040 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalResultCount) as usize - ptr as usize },
9041 12usize,
9042 concat!(
9043 "Offset of field: ",
9044 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9045 "::",
9046 stringify!(m_nTotalResultCount)
9047 )
9048 );
9049 assert_eq!(
9050 unsafe { ::std::ptr::addr_of!((*ptr).m_rgPublishedFileId) as usize - ptr as usize },
9051 16usize,
9052 concat!(
9053 "Offset of field: ",
9054 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9055 "::",
9056 stringify!(m_rgPublishedFileId)
9057 )
9058 );
9059 assert_eq!(
9060 unsafe { ::std::ptr::addr_of!((*ptr).m_rgRTimeUpdated) as usize - ptr as usize },
9061 416usize,
9062 concat!(
9063 "Offset of field: ",
9064 stringify!(RemoteStorageEnumeratePublishedFilesByUserActionResult_t),
9065 "::",
9066 stringify!(m_rgRTimeUpdated)
9067 )
9068 );
9069}
9070#[repr(C, packed(4))]
9071#[derive(Debug, Copy, Clone)]
9072pub struct RemoteStoragePublishFileProgress_t {
9073 pub m_dPercentFile: f64,
9074 pub m_bPreview: bool,
9075}
9076pub const RemoteStoragePublishFileProgress_t_k_iCallback:
9077 RemoteStoragePublishFileProgress_t__bindgen_ty_1 =
9078 RemoteStoragePublishFileProgress_t__bindgen_ty_1::k_iCallback;
9079#[repr(u32)]
9080#[non_exhaustive]
9081#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9082pub enum RemoteStoragePublishFileProgress_t__bindgen_ty_1 {
9083 k_iCallback = 1329,
9084}
9085#[test]
9086fn bindgen_test_layout_RemoteStoragePublishFileProgress_t() {
9087 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishFileProgress_t> =
9088 ::std::mem::MaybeUninit::uninit();
9089 let ptr = UNINIT.as_ptr();
9090 assert_eq!(
9091 ::std::mem::size_of::<RemoteStoragePublishFileProgress_t>(),
9092 12usize,
9093 concat!("Size of: ", stringify!(RemoteStoragePublishFileProgress_t))
9094 );
9095 assert_eq!(
9096 ::std::mem::align_of::<RemoteStoragePublishFileProgress_t>(),
9097 4usize,
9098 concat!(
9099 "Alignment of ",
9100 stringify!(RemoteStoragePublishFileProgress_t)
9101 )
9102 );
9103 assert_eq!(
9104 unsafe { ::std::ptr::addr_of!((*ptr).m_dPercentFile) as usize - ptr as usize },
9105 0usize,
9106 concat!(
9107 "Offset of field: ",
9108 stringify!(RemoteStoragePublishFileProgress_t),
9109 "::",
9110 stringify!(m_dPercentFile)
9111 )
9112 );
9113 assert_eq!(
9114 unsafe { ::std::ptr::addr_of!((*ptr).m_bPreview) as usize - ptr as usize },
9115 8usize,
9116 concat!(
9117 "Offset of field: ",
9118 stringify!(RemoteStoragePublishFileProgress_t),
9119 "::",
9120 stringify!(m_bPreview)
9121 )
9122 );
9123}
9124#[repr(C, packed(4))]
9125#[derive(Debug, Copy, Clone)]
9126pub struct RemoteStoragePublishedFileUpdated_t {
9127 pub m_nPublishedFileId: PublishedFileId_t,
9128 pub m_nAppID: AppId_t,
9129 pub m_ulUnused: uint64,
9130}
9131pub const RemoteStoragePublishedFileUpdated_t_k_iCallback:
9132 RemoteStoragePublishedFileUpdated_t__bindgen_ty_1 =
9133 RemoteStoragePublishedFileUpdated_t__bindgen_ty_1::k_iCallback;
9134#[repr(u32)]
9135#[non_exhaustive]
9136#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9137pub enum RemoteStoragePublishedFileUpdated_t__bindgen_ty_1 {
9138 k_iCallback = 1330,
9139}
9140#[test]
9141fn bindgen_test_layout_RemoteStoragePublishedFileUpdated_t() {
9142 const UNINIT: ::std::mem::MaybeUninit<RemoteStoragePublishedFileUpdated_t> =
9143 ::std::mem::MaybeUninit::uninit();
9144 let ptr = UNINIT.as_ptr();
9145 assert_eq!(
9146 ::std::mem::size_of::<RemoteStoragePublishedFileUpdated_t>(),
9147 20usize,
9148 concat!("Size of: ", stringify!(RemoteStoragePublishedFileUpdated_t))
9149 );
9150 assert_eq!(
9151 ::std::mem::align_of::<RemoteStoragePublishedFileUpdated_t>(),
9152 4usize,
9153 concat!(
9154 "Alignment of ",
9155 stringify!(RemoteStoragePublishedFileUpdated_t)
9156 )
9157 );
9158 assert_eq!(
9159 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
9160 0usize,
9161 concat!(
9162 "Offset of field: ",
9163 stringify!(RemoteStoragePublishedFileUpdated_t),
9164 "::",
9165 stringify!(m_nPublishedFileId)
9166 )
9167 );
9168 assert_eq!(
9169 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
9170 8usize,
9171 concat!(
9172 "Offset of field: ",
9173 stringify!(RemoteStoragePublishedFileUpdated_t),
9174 "::",
9175 stringify!(m_nAppID)
9176 )
9177 );
9178 assert_eq!(
9179 unsafe { ::std::ptr::addr_of!((*ptr).m_ulUnused) as usize - ptr as usize },
9180 12usize,
9181 concat!(
9182 "Offset of field: ",
9183 stringify!(RemoteStoragePublishedFileUpdated_t),
9184 "::",
9185 stringify!(m_ulUnused)
9186 )
9187 );
9188}
9189#[repr(C)]
9190#[derive(Debug, Copy, Clone)]
9191pub struct RemoteStorageFileWriteAsyncComplete_t {
9192 pub m_eResult: EResult,
9193}
9194pub const RemoteStorageFileWriteAsyncComplete_t_k_iCallback:
9195 RemoteStorageFileWriteAsyncComplete_t__bindgen_ty_1 =
9196 RemoteStorageFileWriteAsyncComplete_t__bindgen_ty_1::k_iCallback;
9197#[repr(u32)]
9198#[non_exhaustive]
9199#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9200pub enum RemoteStorageFileWriteAsyncComplete_t__bindgen_ty_1 {
9201 k_iCallback = 1331,
9202}
9203#[test]
9204fn bindgen_test_layout_RemoteStorageFileWriteAsyncComplete_t() {
9205 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageFileWriteAsyncComplete_t> =
9206 ::std::mem::MaybeUninit::uninit();
9207 let ptr = UNINIT.as_ptr();
9208 assert_eq!(
9209 ::std::mem::size_of::<RemoteStorageFileWriteAsyncComplete_t>(),
9210 4usize,
9211 concat!(
9212 "Size of: ",
9213 stringify!(RemoteStorageFileWriteAsyncComplete_t)
9214 )
9215 );
9216 assert_eq!(
9217 ::std::mem::align_of::<RemoteStorageFileWriteAsyncComplete_t>(),
9218 4usize,
9219 concat!(
9220 "Alignment of ",
9221 stringify!(RemoteStorageFileWriteAsyncComplete_t)
9222 )
9223 );
9224 assert_eq!(
9225 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
9226 0usize,
9227 concat!(
9228 "Offset of field: ",
9229 stringify!(RemoteStorageFileWriteAsyncComplete_t),
9230 "::",
9231 stringify!(m_eResult)
9232 )
9233 );
9234}
9235#[repr(C, packed(4))]
9236#[derive(Debug, Copy, Clone)]
9237pub struct RemoteStorageFileReadAsyncComplete_t {
9238 pub m_hFileReadAsync: SteamAPICall_t,
9239 pub m_eResult: EResult,
9240 pub m_nOffset: uint32,
9241 pub m_cubRead: uint32,
9242}
9243pub const RemoteStorageFileReadAsyncComplete_t_k_iCallback:
9244 RemoteStorageFileReadAsyncComplete_t__bindgen_ty_1 =
9245 RemoteStorageFileReadAsyncComplete_t__bindgen_ty_1::k_iCallback;
9246#[repr(u32)]
9247#[non_exhaustive]
9248#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9249pub enum RemoteStorageFileReadAsyncComplete_t__bindgen_ty_1 {
9250 k_iCallback = 1332,
9251}
9252#[test]
9253fn bindgen_test_layout_RemoteStorageFileReadAsyncComplete_t() {
9254 const UNINIT: ::std::mem::MaybeUninit<RemoteStorageFileReadAsyncComplete_t> =
9255 ::std::mem::MaybeUninit::uninit();
9256 let ptr = UNINIT.as_ptr();
9257 assert_eq!(
9258 ::std::mem::size_of::<RemoteStorageFileReadAsyncComplete_t>(),
9259 20usize,
9260 concat!(
9261 "Size of: ",
9262 stringify!(RemoteStorageFileReadAsyncComplete_t)
9263 )
9264 );
9265 assert_eq!(
9266 ::std::mem::align_of::<RemoteStorageFileReadAsyncComplete_t>(),
9267 4usize,
9268 concat!(
9269 "Alignment of ",
9270 stringify!(RemoteStorageFileReadAsyncComplete_t)
9271 )
9272 );
9273 assert_eq!(
9274 unsafe { ::std::ptr::addr_of!((*ptr).m_hFileReadAsync) as usize - ptr as usize },
9275 0usize,
9276 concat!(
9277 "Offset of field: ",
9278 stringify!(RemoteStorageFileReadAsyncComplete_t),
9279 "::",
9280 stringify!(m_hFileReadAsync)
9281 )
9282 );
9283 assert_eq!(
9284 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
9285 8usize,
9286 concat!(
9287 "Offset of field: ",
9288 stringify!(RemoteStorageFileReadAsyncComplete_t),
9289 "::",
9290 stringify!(m_eResult)
9291 )
9292 );
9293 assert_eq!(
9294 unsafe { ::std::ptr::addr_of!((*ptr).m_nOffset) as usize - ptr as usize },
9295 12usize,
9296 concat!(
9297 "Offset of field: ",
9298 stringify!(RemoteStorageFileReadAsyncComplete_t),
9299 "::",
9300 stringify!(m_nOffset)
9301 )
9302 );
9303 assert_eq!(
9304 unsafe { ::std::ptr::addr_of!((*ptr).m_cubRead) as usize - ptr as usize },
9305 16usize,
9306 concat!(
9307 "Offset of field: ",
9308 stringify!(RemoteStorageFileReadAsyncComplete_t),
9309 "::",
9310 stringify!(m_cubRead)
9311 )
9312 );
9313}
9314#[repr(C)]
9315#[derive(Debug, Copy, Clone)]
9316pub struct RemoteStorageLocalFileChange_t {
9317 pub _address: u8,
9318}
9319pub const RemoteStorageLocalFileChange_t_k_iCallback: RemoteStorageLocalFileChange_t__bindgen_ty_1 =
9320 RemoteStorageLocalFileChange_t__bindgen_ty_1::k_iCallback;
9321#[repr(u32)]
9322#[non_exhaustive]
9323#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9324pub enum RemoteStorageLocalFileChange_t__bindgen_ty_1 {
9325 k_iCallback = 1333,
9326}
9327#[test]
9328fn bindgen_test_layout_RemoteStorageLocalFileChange_t() {
9329 assert_eq!(
9330 ::std::mem::size_of::<RemoteStorageLocalFileChange_t>(),
9331 1usize,
9332 concat!("Size of: ", stringify!(RemoteStorageLocalFileChange_t))
9333 );
9334 assert_eq!(
9335 ::std::mem::align_of::<RemoteStorageLocalFileChange_t>(),
9336 1usize,
9337 concat!("Alignment of ", stringify!(RemoteStorageLocalFileChange_t))
9338 );
9339}
9340pub const k_cchStatNameMax: _bindgen_ty_42 = _bindgen_ty_42::k_cchStatNameMax;
9341#[repr(u32)]
9342#[non_exhaustive]
9343#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9344pub enum _bindgen_ty_42 {
9345 k_cchStatNameMax = 128,
9346}
9347pub const k_cchLeaderboardNameMax: _bindgen_ty_43 = _bindgen_ty_43::k_cchLeaderboardNameMax;
9348#[repr(u32)]
9349#[non_exhaustive]
9350#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9351pub enum _bindgen_ty_43 {
9352 k_cchLeaderboardNameMax = 128,
9353}
9354pub const k_cLeaderboardDetailsMax: _bindgen_ty_44 = _bindgen_ty_44::k_cLeaderboardDetailsMax;
9355#[repr(u32)]
9356#[non_exhaustive]
9357#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9358pub enum _bindgen_ty_44 {
9359 k_cLeaderboardDetailsMax = 64,
9360}
9361pub type SteamLeaderboard_t = uint64;
9362pub type SteamLeaderboardEntries_t = uint64;
9363#[repr(u32)]
9364#[non_exhaustive]
9365#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9366pub enum ELeaderboardDataRequest {
9367 k_ELeaderboardDataRequestGlobal = 0,
9368 k_ELeaderboardDataRequestGlobalAroundUser = 1,
9369 k_ELeaderboardDataRequestFriends = 2,
9370 k_ELeaderboardDataRequestUsers = 3,
9371}
9372#[repr(u32)]
9373#[non_exhaustive]
9374#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9375pub enum ELeaderboardSortMethod {
9376 k_ELeaderboardSortMethodNone = 0,
9377 k_ELeaderboardSortMethodAscending = 1,
9378 k_ELeaderboardSortMethodDescending = 2,
9379}
9380#[repr(u32)]
9381#[non_exhaustive]
9382#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9383pub enum ELeaderboardDisplayType {
9384 k_ELeaderboardDisplayTypeNone = 0,
9385 k_ELeaderboardDisplayTypeNumeric = 1,
9386 k_ELeaderboardDisplayTypeTimeSeconds = 2,
9387 k_ELeaderboardDisplayTypeTimeMilliSeconds = 3,
9388}
9389#[repr(u32)]
9390#[non_exhaustive]
9391#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9392pub enum ELeaderboardUploadScoreMethod {
9393 k_ELeaderboardUploadScoreMethodNone = 0,
9394 k_ELeaderboardUploadScoreMethodKeepBest = 1,
9395 k_ELeaderboardUploadScoreMethodForceUpdate = 2,
9396}
9397#[repr(C, packed(4))]
9398#[derive(Copy, Clone)]
9399pub struct LeaderboardEntry_t {
9400 pub m_steamIDUser: CSteamID,
9401 pub m_nGlobalRank: int32,
9402 pub m_nScore: int32,
9403 pub m_cDetails: int32,
9404 pub m_hUGC: UGCHandle_t,
9405}
9406#[test]
9407fn bindgen_test_layout_LeaderboardEntry_t() {
9408 const UNINIT: ::std::mem::MaybeUninit<LeaderboardEntry_t> = ::std::mem::MaybeUninit::uninit();
9409 let ptr = UNINIT.as_ptr();
9410 assert_eq!(
9411 ::std::mem::size_of::<LeaderboardEntry_t>(),
9412 28usize,
9413 concat!("Size of: ", stringify!(LeaderboardEntry_t))
9414 );
9415 assert_eq!(
9416 ::std::mem::align_of::<LeaderboardEntry_t>(),
9417 4usize,
9418 concat!("Alignment of ", stringify!(LeaderboardEntry_t))
9419 );
9420 assert_eq!(
9421 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
9422 0usize,
9423 concat!(
9424 "Offset of field: ",
9425 stringify!(LeaderboardEntry_t),
9426 "::",
9427 stringify!(m_steamIDUser)
9428 )
9429 );
9430 assert_eq!(
9431 unsafe { ::std::ptr::addr_of!((*ptr).m_nGlobalRank) as usize - ptr as usize },
9432 8usize,
9433 concat!(
9434 "Offset of field: ",
9435 stringify!(LeaderboardEntry_t),
9436 "::",
9437 stringify!(m_nGlobalRank)
9438 )
9439 );
9440 assert_eq!(
9441 unsafe { ::std::ptr::addr_of!((*ptr).m_nScore) as usize - ptr as usize },
9442 12usize,
9443 concat!(
9444 "Offset of field: ",
9445 stringify!(LeaderboardEntry_t),
9446 "::",
9447 stringify!(m_nScore)
9448 )
9449 );
9450 assert_eq!(
9451 unsafe { ::std::ptr::addr_of!((*ptr).m_cDetails) as usize - ptr as usize },
9452 16usize,
9453 concat!(
9454 "Offset of field: ",
9455 stringify!(LeaderboardEntry_t),
9456 "::",
9457 stringify!(m_cDetails)
9458 )
9459 );
9460 assert_eq!(
9461 unsafe { ::std::ptr::addr_of!((*ptr).m_hUGC) as usize - ptr as usize },
9462 20usize,
9463 concat!(
9464 "Offset of field: ",
9465 stringify!(LeaderboardEntry_t),
9466 "::",
9467 stringify!(m_hUGC)
9468 )
9469 );
9470}
9471#[repr(C)]
9472pub struct ISteamUserStats__bindgen_vtable(::std::os::raw::c_void);
9473#[repr(C)]
9474#[derive(Debug, Copy, Clone)]
9475pub struct ISteamUserStats {
9476 pub vtable_: *const ISteamUserStats__bindgen_vtable,
9477}
9478#[test]
9479fn bindgen_test_layout_ISteamUserStats() {
9480 assert_eq!(
9481 ::std::mem::size_of::<ISteamUserStats>(),
9482 8usize,
9483 concat!("Size of: ", stringify!(ISteamUserStats))
9484 );
9485 assert_eq!(
9486 ::std::mem::align_of::<ISteamUserStats>(),
9487 8usize,
9488 concat!("Alignment of ", stringify!(ISteamUserStats))
9489 );
9490}
9491#[repr(C, packed(4))]
9492#[derive(Copy, Clone)]
9493pub struct UserStatsReceived_t {
9494 pub m_nGameID: uint64,
9495 pub m_eResult: EResult,
9496 pub m_steamIDUser: CSteamID,
9497}
9498pub const UserStatsReceived_t_k_iCallback: UserStatsReceived_t__bindgen_ty_1 =
9499 UserStatsReceived_t__bindgen_ty_1::k_iCallback;
9500#[repr(u32)]
9501#[non_exhaustive]
9502#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9503pub enum UserStatsReceived_t__bindgen_ty_1 {
9504 k_iCallback = 1101,
9505}
9506#[test]
9507fn bindgen_test_layout_UserStatsReceived_t() {
9508 const UNINIT: ::std::mem::MaybeUninit<UserStatsReceived_t> = ::std::mem::MaybeUninit::uninit();
9509 let ptr = UNINIT.as_ptr();
9510 assert_eq!(
9511 ::std::mem::size_of::<UserStatsReceived_t>(),
9512 20usize,
9513 concat!("Size of: ", stringify!(UserStatsReceived_t))
9514 );
9515 assert_eq!(
9516 ::std::mem::align_of::<UserStatsReceived_t>(),
9517 4usize,
9518 concat!("Alignment of ", stringify!(UserStatsReceived_t))
9519 );
9520 assert_eq!(
9521 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
9522 0usize,
9523 concat!(
9524 "Offset of field: ",
9525 stringify!(UserStatsReceived_t),
9526 "::",
9527 stringify!(m_nGameID)
9528 )
9529 );
9530 assert_eq!(
9531 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
9532 8usize,
9533 concat!(
9534 "Offset of field: ",
9535 stringify!(UserStatsReceived_t),
9536 "::",
9537 stringify!(m_eResult)
9538 )
9539 );
9540 assert_eq!(
9541 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
9542 12usize,
9543 concat!(
9544 "Offset of field: ",
9545 stringify!(UserStatsReceived_t),
9546 "::",
9547 stringify!(m_steamIDUser)
9548 )
9549 );
9550}
9551#[repr(C, packed(4))]
9552#[derive(Debug, Copy, Clone)]
9553pub struct UserStatsStored_t {
9554 pub m_nGameID: uint64,
9555 pub m_eResult: EResult,
9556}
9557pub const UserStatsStored_t_k_iCallback: UserStatsStored_t__bindgen_ty_1 =
9558 UserStatsStored_t__bindgen_ty_1::k_iCallback;
9559#[repr(u32)]
9560#[non_exhaustive]
9561#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9562pub enum UserStatsStored_t__bindgen_ty_1 {
9563 k_iCallback = 1102,
9564}
9565#[test]
9566fn bindgen_test_layout_UserStatsStored_t() {
9567 const UNINIT: ::std::mem::MaybeUninit<UserStatsStored_t> = ::std::mem::MaybeUninit::uninit();
9568 let ptr = UNINIT.as_ptr();
9569 assert_eq!(
9570 ::std::mem::size_of::<UserStatsStored_t>(),
9571 12usize,
9572 concat!("Size of: ", stringify!(UserStatsStored_t))
9573 );
9574 assert_eq!(
9575 ::std::mem::align_of::<UserStatsStored_t>(),
9576 4usize,
9577 concat!("Alignment of ", stringify!(UserStatsStored_t))
9578 );
9579 assert_eq!(
9580 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
9581 0usize,
9582 concat!(
9583 "Offset of field: ",
9584 stringify!(UserStatsStored_t),
9585 "::",
9586 stringify!(m_nGameID)
9587 )
9588 );
9589 assert_eq!(
9590 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
9591 8usize,
9592 concat!(
9593 "Offset of field: ",
9594 stringify!(UserStatsStored_t),
9595 "::",
9596 stringify!(m_eResult)
9597 )
9598 );
9599}
9600#[repr(C, packed(4))]
9601#[derive(Debug, Copy, Clone)]
9602pub struct UserAchievementStored_t {
9603 pub m_nGameID: uint64,
9604 pub m_bGroupAchievement: bool,
9605 pub m_rgchAchievementName: [::std::os::raw::c_char; 128usize],
9606 pub m_nCurProgress: uint32,
9607 pub m_nMaxProgress: uint32,
9608}
9609pub const UserAchievementStored_t_k_iCallback: UserAchievementStored_t__bindgen_ty_1 =
9610 UserAchievementStored_t__bindgen_ty_1::k_iCallback;
9611#[repr(u32)]
9612#[non_exhaustive]
9613#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9614pub enum UserAchievementStored_t__bindgen_ty_1 {
9615 k_iCallback = 1103,
9616}
9617#[test]
9618fn bindgen_test_layout_UserAchievementStored_t() {
9619 const UNINIT: ::std::mem::MaybeUninit<UserAchievementStored_t> =
9620 ::std::mem::MaybeUninit::uninit();
9621 let ptr = UNINIT.as_ptr();
9622 assert_eq!(
9623 ::std::mem::size_of::<UserAchievementStored_t>(),
9624 148usize,
9625 concat!("Size of: ", stringify!(UserAchievementStored_t))
9626 );
9627 assert_eq!(
9628 ::std::mem::align_of::<UserAchievementStored_t>(),
9629 4usize,
9630 concat!("Alignment of ", stringify!(UserAchievementStored_t))
9631 );
9632 assert_eq!(
9633 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
9634 0usize,
9635 concat!(
9636 "Offset of field: ",
9637 stringify!(UserAchievementStored_t),
9638 "::",
9639 stringify!(m_nGameID)
9640 )
9641 );
9642 assert_eq!(
9643 unsafe { ::std::ptr::addr_of!((*ptr).m_bGroupAchievement) as usize - ptr as usize },
9644 8usize,
9645 concat!(
9646 "Offset of field: ",
9647 stringify!(UserAchievementStored_t),
9648 "::",
9649 stringify!(m_bGroupAchievement)
9650 )
9651 );
9652 assert_eq!(
9653 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchAchievementName) as usize - ptr as usize },
9654 9usize,
9655 concat!(
9656 "Offset of field: ",
9657 stringify!(UserAchievementStored_t),
9658 "::",
9659 stringify!(m_rgchAchievementName)
9660 )
9661 );
9662 assert_eq!(
9663 unsafe { ::std::ptr::addr_of!((*ptr).m_nCurProgress) as usize - ptr as usize },
9664 140usize,
9665 concat!(
9666 "Offset of field: ",
9667 stringify!(UserAchievementStored_t),
9668 "::",
9669 stringify!(m_nCurProgress)
9670 )
9671 );
9672 assert_eq!(
9673 unsafe { ::std::ptr::addr_of!((*ptr).m_nMaxProgress) as usize - ptr as usize },
9674 144usize,
9675 concat!(
9676 "Offset of field: ",
9677 stringify!(UserAchievementStored_t),
9678 "::",
9679 stringify!(m_nMaxProgress)
9680 )
9681 );
9682}
9683#[repr(C, packed(4))]
9684#[derive(Debug, Copy, Clone)]
9685pub struct LeaderboardFindResult_t {
9686 pub m_hSteamLeaderboard: SteamLeaderboard_t,
9687 pub m_bLeaderboardFound: uint8,
9688}
9689pub const LeaderboardFindResult_t_k_iCallback: LeaderboardFindResult_t__bindgen_ty_1 =
9690 LeaderboardFindResult_t__bindgen_ty_1::k_iCallback;
9691#[repr(u32)]
9692#[non_exhaustive]
9693#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9694pub enum LeaderboardFindResult_t__bindgen_ty_1 {
9695 k_iCallback = 1104,
9696}
9697#[test]
9698fn bindgen_test_layout_LeaderboardFindResult_t() {
9699 const UNINIT: ::std::mem::MaybeUninit<LeaderboardFindResult_t> =
9700 ::std::mem::MaybeUninit::uninit();
9701 let ptr = UNINIT.as_ptr();
9702 assert_eq!(
9703 ::std::mem::size_of::<LeaderboardFindResult_t>(),
9704 12usize,
9705 concat!("Size of: ", stringify!(LeaderboardFindResult_t))
9706 );
9707 assert_eq!(
9708 ::std::mem::align_of::<LeaderboardFindResult_t>(),
9709 4usize,
9710 concat!("Alignment of ", stringify!(LeaderboardFindResult_t))
9711 );
9712 assert_eq!(
9713 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamLeaderboard) as usize - ptr as usize },
9714 0usize,
9715 concat!(
9716 "Offset of field: ",
9717 stringify!(LeaderboardFindResult_t),
9718 "::",
9719 stringify!(m_hSteamLeaderboard)
9720 )
9721 );
9722 assert_eq!(
9723 unsafe { ::std::ptr::addr_of!((*ptr).m_bLeaderboardFound) as usize - ptr as usize },
9724 8usize,
9725 concat!(
9726 "Offset of field: ",
9727 stringify!(LeaderboardFindResult_t),
9728 "::",
9729 stringify!(m_bLeaderboardFound)
9730 )
9731 );
9732}
9733#[repr(C, packed(4))]
9734#[derive(Debug, Copy, Clone)]
9735pub struct LeaderboardScoresDownloaded_t {
9736 pub m_hSteamLeaderboard: SteamLeaderboard_t,
9737 pub m_hSteamLeaderboardEntries: SteamLeaderboardEntries_t,
9738 pub m_cEntryCount: ::std::os::raw::c_int,
9739}
9740pub const LeaderboardScoresDownloaded_t_k_iCallback: LeaderboardScoresDownloaded_t__bindgen_ty_1 =
9741 LeaderboardScoresDownloaded_t__bindgen_ty_1::k_iCallback;
9742#[repr(u32)]
9743#[non_exhaustive]
9744#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9745pub enum LeaderboardScoresDownloaded_t__bindgen_ty_1 {
9746 k_iCallback = 1105,
9747}
9748#[test]
9749fn bindgen_test_layout_LeaderboardScoresDownloaded_t() {
9750 const UNINIT: ::std::mem::MaybeUninit<LeaderboardScoresDownloaded_t> =
9751 ::std::mem::MaybeUninit::uninit();
9752 let ptr = UNINIT.as_ptr();
9753 assert_eq!(
9754 ::std::mem::size_of::<LeaderboardScoresDownloaded_t>(),
9755 20usize,
9756 concat!("Size of: ", stringify!(LeaderboardScoresDownloaded_t))
9757 );
9758 assert_eq!(
9759 ::std::mem::align_of::<LeaderboardScoresDownloaded_t>(),
9760 4usize,
9761 concat!("Alignment of ", stringify!(LeaderboardScoresDownloaded_t))
9762 );
9763 assert_eq!(
9764 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamLeaderboard) as usize - ptr as usize },
9765 0usize,
9766 concat!(
9767 "Offset of field: ",
9768 stringify!(LeaderboardScoresDownloaded_t),
9769 "::",
9770 stringify!(m_hSteamLeaderboard)
9771 )
9772 );
9773 assert_eq!(
9774 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamLeaderboardEntries) as usize - ptr as usize },
9775 8usize,
9776 concat!(
9777 "Offset of field: ",
9778 stringify!(LeaderboardScoresDownloaded_t),
9779 "::",
9780 stringify!(m_hSteamLeaderboardEntries)
9781 )
9782 );
9783 assert_eq!(
9784 unsafe { ::std::ptr::addr_of!((*ptr).m_cEntryCount) as usize - ptr as usize },
9785 16usize,
9786 concat!(
9787 "Offset of field: ",
9788 stringify!(LeaderboardScoresDownloaded_t),
9789 "::",
9790 stringify!(m_cEntryCount)
9791 )
9792 );
9793}
9794#[repr(C, packed(4))]
9795#[derive(Debug, Copy, Clone)]
9796pub struct LeaderboardScoreUploaded_t {
9797 pub m_bSuccess: uint8,
9798 pub m_hSteamLeaderboard: SteamLeaderboard_t,
9799 pub m_nScore: int32,
9800 pub m_bScoreChanged: uint8,
9801 pub m_nGlobalRankNew: ::std::os::raw::c_int,
9802 pub m_nGlobalRankPrevious: ::std::os::raw::c_int,
9803}
9804pub const LeaderboardScoreUploaded_t_k_iCallback: LeaderboardScoreUploaded_t__bindgen_ty_1 =
9805 LeaderboardScoreUploaded_t__bindgen_ty_1::k_iCallback;
9806#[repr(u32)]
9807#[non_exhaustive]
9808#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9809pub enum LeaderboardScoreUploaded_t__bindgen_ty_1 {
9810 k_iCallback = 1106,
9811}
9812#[test]
9813fn bindgen_test_layout_LeaderboardScoreUploaded_t() {
9814 const UNINIT: ::std::mem::MaybeUninit<LeaderboardScoreUploaded_t> =
9815 ::std::mem::MaybeUninit::uninit();
9816 let ptr = UNINIT.as_ptr();
9817 assert_eq!(
9818 ::std::mem::size_of::<LeaderboardScoreUploaded_t>(),
9819 28usize,
9820 concat!("Size of: ", stringify!(LeaderboardScoreUploaded_t))
9821 );
9822 assert_eq!(
9823 ::std::mem::align_of::<LeaderboardScoreUploaded_t>(),
9824 4usize,
9825 concat!("Alignment of ", stringify!(LeaderboardScoreUploaded_t))
9826 );
9827 assert_eq!(
9828 unsafe { ::std::ptr::addr_of!((*ptr).m_bSuccess) as usize - ptr as usize },
9829 0usize,
9830 concat!(
9831 "Offset of field: ",
9832 stringify!(LeaderboardScoreUploaded_t),
9833 "::",
9834 stringify!(m_bSuccess)
9835 )
9836 );
9837 assert_eq!(
9838 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamLeaderboard) as usize - ptr as usize },
9839 4usize,
9840 concat!(
9841 "Offset of field: ",
9842 stringify!(LeaderboardScoreUploaded_t),
9843 "::",
9844 stringify!(m_hSteamLeaderboard)
9845 )
9846 );
9847 assert_eq!(
9848 unsafe { ::std::ptr::addr_of!((*ptr).m_nScore) as usize - ptr as usize },
9849 12usize,
9850 concat!(
9851 "Offset of field: ",
9852 stringify!(LeaderboardScoreUploaded_t),
9853 "::",
9854 stringify!(m_nScore)
9855 )
9856 );
9857 assert_eq!(
9858 unsafe { ::std::ptr::addr_of!((*ptr).m_bScoreChanged) as usize - ptr as usize },
9859 16usize,
9860 concat!(
9861 "Offset of field: ",
9862 stringify!(LeaderboardScoreUploaded_t),
9863 "::",
9864 stringify!(m_bScoreChanged)
9865 )
9866 );
9867 assert_eq!(
9868 unsafe { ::std::ptr::addr_of!((*ptr).m_nGlobalRankNew) as usize - ptr as usize },
9869 20usize,
9870 concat!(
9871 "Offset of field: ",
9872 stringify!(LeaderboardScoreUploaded_t),
9873 "::",
9874 stringify!(m_nGlobalRankNew)
9875 )
9876 );
9877 assert_eq!(
9878 unsafe { ::std::ptr::addr_of!((*ptr).m_nGlobalRankPrevious) as usize - ptr as usize },
9879 24usize,
9880 concat!(
9881 "Offset of field: ",
9882 stringify!(LeaderboardScoreUploaded_t),
9883 "::",
9884 stringify!(m_nGlobalRankPrevious)
9885 )
9886 );
9887}
9888#[repr(C)]
9889#[derive(Debug, Copy, Clone)]
9890pub struct NumberOfCurrentPlayers_t {
9891 pub m_bSuccess: uint8,
9892 pub m_cPlayers: int32,
9893}
9894pub const NumberOfCurrentPlayers_t_k_iCallback: NumberOfCurrentPlayers_t__bindgen_ty_1 =
9895 NumberOfCurrentPlayers_t__bindgen_ty_1::k_iCallback;
9896#[repr(u32)]
9897#[non_exhaustive]
9898#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9899pub enum NumberOfCurrentPlayers_t__bindgen_ty_1 {
9900 k_iCallback = 1107,
9901}
9902#[test]
9903fn bindgen_test_layout_NumberOfCurrentPlayers_t() {
9904 const UNINIT: ::std::mem::MaybeUninit<NumberOfCurrentPlayers_t> =
9905 ::std::mem::MaybeUninit::uninit();
9906 let ptr = UNINIT.as_ptr();
9907 assert_eq!(
9908 ::std::mem::size_of::<NumberOfCurrentPlayers_t>(),
9909 8usize,
9910 concat!("Size of: ", stringify!(NumberOfCurrentPlayers_t))
9911 );
9912 assert_eq!(
9913 ::std::mem::align_of::<NumberOfCurrentPlayers_t>(),
9914 4usize,
9915 concat!("Alignment of ", stringify!(NumberOfCurrentPlayers_t))
9916 );
9917 assert_eq!(
9918 unsafe { ::std::ptr::addr_of!((*ptr).m_bSuccess) as usize - ptr as usize },
9919 0usize,
9920 concat!(
9921 "Offset of field: ",
9922 stringify!(NumberOfCurrentPlayers_t),
9923 "::",
9924 stringify!(m_bSuccess)
9925 )
9926 );
9927 assert_eq!(
9928 unsafe { ::std::ptr::addr_of!((*ptr).m_cPlayers) as usize - ptr as usize },
9929 4usize,
9930 concat!(
9931 "Offset of field: ",
9932 stringify!(NumberOfCurrentPlayers_t),
9933 "::",
9934 stringify!(m_cPlayers)
9935 )
9936 );
9937}
9938#[repr(C)]
9939#[derive(Copy, Clone)]
9940pub struct UserStatsUnloaded_t {
9941 pub m_steamIDUser: CSteamID,
9942}
9943pub const UserStatsUnloaded_t_k_iCallback: UserStatsUnloaded_t__bindgen_ty_1 =
9944 UserStatsUnloaded_t__bindgen_ty_1::k_iCallback;
9945#[repr(u32)]
9946#[non_exhaustive]
9947#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9948pub enum UserStatsUnloaded_t__bindgen_ty_1 {
9949 k_iCallback = 1108,
9950}
9951#[test]
9952fn bindgen_test_layout_UserStatsUnloaded_t() {
9953 const UNINIT: ::std::mem::MaybeUninit<UserStatsUnloaded_t> = ::std::mem::MaybeUninit::uninit();
9954 let ptr = UNINIT.as_ptr();
9955 assert_eq!(
9956 ::std::mem::size_of::<UserStatsUnloaded_t>(),
9957 8usize,
9958 concat!("Size of: ", stringify!(UserStatsUnloaded_t))
9959 );
9960 assert_eq!(
9961 ::std::mem::align_of::<UserStatsUnloaded_t>(),
9962 1usize,
9963 concat!("Alignment of ", stringify!(UserStatsUnloaded_t))
9964 );
9965 assert_eq!(
9966 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
9967 0usize,
9968 concat!(
9969 "Offset of field: ",
9970 stringify!(UserStatsUnloaded_t),
9971 "::",
9972 stringify!(m_steamIDUser)
9973 )
9974 );
9975}
9976#[repr(C)]
9977#[derive(Copy, Clone)]
9978pub struct UserAchievementIconFetched_t {
9979 pub m_nGameID: CGameID,
9980 pub m_rgchAchievementName: [::std::os::raw::c_char; 128usize],
9981 pub m_bAchieved: bool,
9982 pub m_nIconHandle: ::std::os::raw::c_int,
9983}
9984pub const UserAchievementIconFetched_t_k_iCallback: UserAchievementIconFetched_t__bindgen_ty_1 =
9985 UserAchievementIconFetched_t__bindgen_ty_1::k_iCallback;
9986#[repr(u32)]
9987#[non_exhaustive]
9988#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9989pub enum UserAchievementIconFetched_t__bindgen_ty_1 {
9990 k_iCallback = 1109,
9991}
9992#[test]
9993fn bindgen_test_layout_UserAchievementIconFetched_t() {
9994 const UNINIT: ::std::mem::MaybeUninit<UserAchievementIconFetched_t> =
9995 ::std::mem::MaybeUninit::uninit();
9996 let ptr = UNINIT.as_ptr();
9997 assert_eq!(
9998 ::std::mem::size_of::<UserAchievementIconFetched_t>(),
9999 144usize,
10000 concat!("Size of: ", stringify!(UserAchievementIconFetched_t))
10001 );
10002 assert_eq!(
10003 ::std::mem::align_of::<UserAchievementIconFetched_t>(),
10004 4usize,
10005 concat!("Alignment of ", stringify!(UserAchievementIconFetched_t))
10006 );
10007 assert_eq!(
10008 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
10009 0usize,
10010 concat!(
10011 "Offset of field: ",
10012 stringify!(UserAchievementIconFetched_t),
10013 "::",
10014 stringify!(m_nGameID)
10015 )
10016 );
10017 assert_eq!(
10018 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchAchievementName) as usize - ptr as usize },
10019 8usize,
10020 concat!(
10021 "Offset of field: ",
10022 stringify!(UserAchievementIconFetched_t),
10023 "::",
10024 stringify!(m_rgchAchievementName)
10025 )
10026 );
10027 assert_eq!(
10028 unsafe { ::std::ptr::addr_of!((*ptr).m_bAchieved) as usize - ptr as usize },
10029 136usize,
10030 concat!(
10031 "Offset of field: ",
10032 stringify!(UserAchievementIconFetched_t),
10033 "::",
10034 stringify!(m_bAchieved)
10035 )
10036 );
10037 assert_eq!(
10038 unsafe { ::std::ptr::addr_of!((*ptr).m_nIconHandle) as usize - ptr as usize },
10039 140usize,
10040 concat!(
10041 "Offset of field: ",
10042 stringify!(UserAchievementIconFetched_t),
10043 "::",
10044 stringify!(m_nIconHandle)
10045 )
10046 );
10047}
10048#[repr(C, packed(4))]
10049#[derive(Debug, Copy, Clone)]
10050pub struct GlobalAchievementPercentagesReady_t {
10051 pub m_nGameID: uint64,
10052 pub m_eResult: EResult,
10053}
10054pub const GlobalAchievementPercentagesReady_t_k_iCallback:
10055 GlobalAchievementPercentagesReady_t__bindgen_ty_1 =
10056 GlobalAchievementPercentagesReady_t__bindgen_ty_1::k_iCallback;
10057#[repr(u32)]
10058#[non_exhaustive]
10059#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10060pub enum GlobalAchievementPercentagesReady_t__bindgen_ty_1 {
10061 k_iCallback = 1110,
10062}
10063#[test]
10064fn bindgen_test_layout_GlobalAchievementPercentagesReady_t() {
10065 const UNINIT: ::std::mem::MaybeUninit<GlobalAchievementPercentagesReady_t> =
10066 ::std::mem::MaybeUninit::uninit();
10067 let ptr = UNINIT.as_ptr();
10068 assert_eq!(
10069 ::std::mem::size_of::<GlobalAchievementPercentagesReady_t>(),
10070 12usize,
10071 concat!("Size of: ", stringify!(GlobalAchievementPercentagesReady_t))
10072 );
10073 assert_eq!(
10074 ::std::mem::align_of::<GlobalAchievementPercentagesReady_t>(),
10075 4usize,
10076 concat!(
10077 "Alignment of ",
10078 stringify!(GlobalAchievementPercentagesReady_t)
10079 )
10080 );
10081 assert_eq!(
10082 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
10083 0usize,
10084 concat!(
10085 "Offset of field: ",
10086 stringify!(GlobalAchievementPercentagesReady_t),
10087 "::",
10088 stringify!(m_nGameID)
10089 )
10090 );
10091 assert_eq!(
10092 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10093 8usize,
10094 concat!(
10095 "Offset of field: ",
10096 stringify!(GlobalAchievementPercentagesReady_t),
10097 "::",
10098 stringify!(m_eResult)
10099 )
10100 );
10101}
10102#[repr(C, packed(4))]
10103#[derive(Debug, Copy, Clone)]
10104pub struct LeaderboardUGCSet_t {
10105 pub m_eResult: EResult,
10106 pub m_hSteamLeaderboard: SteamLeaderboard_t,
10107}
10108pub const LeaderboardUGCSet_t_k_iCallback: LeaderboardUGCSet_t__bindgen_ty_1 =
10109 LeaderboardUGCSet_t__bindgen_ty_1::k_iCallback;
10110#[repr(u32)]
10111#[non_exhaustive]
10112#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10113pub enum LeaderboardUGCSet_t__bindgen_ty_1 {
10114 k_iCallback = 1111,
10115}
10116#[test]
10117fn bindgen_test_layout_LeaderboardUGCSet_t() {
10118 const UNINIT: ::std::mem::MaybeUninit<LeaderboardUGCSet_t> = ::std::mem::MaybeUninit::uninit();
10119 let ptr = UNINIT.as_ptr();
10120 assert_eq!(
10121 ::std::mem::size_of::<LeaderboardUGCSet_t>(),
10122 12usize,
10123 concat!("Size of: ", stringify!(LeaderboardUGCSet_t))
10124 );
10125 assert_eq!(
10126 ::std::mem::align_of::<LeaderboardUGCSet_t>(),
10127 4usize,
10128 concat!("Alignment of ", stringify!(LeaderboardUGCSet_t))
10129 );
10130 assert_eq!(
10131 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10132 0usize,
10133 concat!(
10134 "Offset of field: ",
10135 stringify!(LeaderboardUGCSet_t),
10136 "::",
10137 stringify!(m_eResult)
10138 )
10139 );
10140 assert_eq!(
10141 unsafe { ::std::ptr::addr_of!((*ptr).m_hSteamLeaderboard) as usize - ptr as usize },
10142 4usize,
10143 concat!(
10144 "Offset of field: ",
10145 stringify!(LeaderboardUGCSet_t),
10146 "::",
10147 stringify!(m_hSteamLeaderboard)
10148 )
10149 );
10150}
10151#[repr(C, packed(4))]
10152#[derive(Debug, Copy, Clone)]
10153pub struct GlobalStatsReceived_t {
10154 pub m_nGameID: uint64,
10155 pub m_eResult: EResult,
10156}
10157pub const GlobalStatsReceived_t_k_iCallback: GlobalStatsReceived_t__bindgen_ty_1 =
10158 GlobalStatsReceived_t__bindgen_ty_1::k_iCallback;
10159#[repr(u32)]
10160#[non_exhaustive]
10161#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10162pub enum GlobalStatsReceived_t__bindgen_ty_1 {
10163 k_iCallback = 1112,
10164}
10165#[test]
10166fn bindgen_test_layout_GlobalStatsReceived_t() {
10167 const UNINIT: ::std::mem::MaybeUninit<GlobalStatsReceived_t> =
10168 ::std::mem::MaybeUninit::uninit();
10169 let ptr = UNINIT.as_ptr();
10170 assert_eq!(
10171 ::std::mem::size_of::<GlobalStatsReceived_t>(),
10172 12usize,
10173 concat!("Size of: ", stringify!(GlobalStatsReceived_t))
10174 );
10175 assert_eq!(
10176 ::std::mem::align_of::<GlobalStatsReceived_t>(),
10177 4usize,
10178 concat!("Alignment of ", stringify!(GlobalStatsReceived_t))
10179 );
10180 assert_eq!(
10181 unsafe { ::std::ptr::addr_of!((*ptr).m_nGameID) as usize - ptr as usize },
10182 0usize,
10183 concat!(
10184 "Offset of field: ",
10185 stringify!(GlobalStatsReceived_t),
10186 "::",
10187 stringify!(m_nGameID)
10188 )
10189 );
10190 assert_eq!(
10191 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10192 8usize,
10193 concat!(
10194 "Offset of field: ",
10195 stringify!(GlobalStatsReceived_t),
10196 "::",
10197 stringify!(m_eResult)
10198 )
10199 );
10200}
10201pub const k_cubAppProofOfPurchaseKeyMax: ::std::os::raw::c_int = 240;
10202#[repr(C)]
10203pub struct ISteamApps__bindgen_vtable(::std::os::raw::c_void);
10204#[repr(C)]
10205#[derive(Debug, Copy, Clone)]
10206pub struct ISteamApps {
10207 pub vtable_: *const ISteamApps__bindgen_vtable,
10208}
10209#[test]
10210fn bindgen_test_layout_ISteamApps() {
10211 assert_eq!(
10212 ::std::mem::size_of::<ISteamApps>(),
10213 8usize,
10214 concat!("Size of: ", stringify!(ISteamApps))
10215 );
10216 assert_eq!(
10217 ::std::mem::align_of::<ISteamApps>(),
10218 8usize,
10219 concat!("Alignment of ", stringify!(ISteamApps))
10220 );
10221}
10222#[repr(C)]
10223#[derive(Debug, Copy, Clone)]
10224pub struct DlcInstalled_t {
10225 pub m_nAppID: AppId_t,
10226}
10227pub const DlcInstalled_t_k_iCallback: DlcInstalled_t__bindgen_ty_1 =
10228 DlcInstalled_t__bindgen_ty_1::k_iCallback;
10229#[repr(u32)]
10230#[non_exhaustive]
10231#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10232pub enum DlcInstalled_t__bindgen_ty_1 {
10233 k_iCallback = 1005,
10234}
10235#[test]
10236fn bindgen_test_layout_DlcInstalled_t() {
10237 const UNINIT: ::std::mem::MaybeUninit<DlcInstalled_t> = ::std::mem::MaybeUninit::uninit();
10238 let ptr = UNINIT.as_ptr();
10239 assert_eq!(
10240 ::std::mem::size_of::<DlcInstalled_t>(),
10241 4usize,
10242 concat!("Size of: ", stringify!(DlcInstalled_t))
10243 );
10244 assert_eq!(
10245 ::std::mem::align_of::<DlcInstalled_t>(),
10246 4usize,
10247 concat!("Alignment of ", stringify!(DlcInstalled_t))
10248 );
10249 assert_eq!(
10250 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
10251 0usize,
10252 concat!(
10253 "Offset of field: ",
10254 stringify!(DlcInstalled_t),
10255 "::",
10256 stringify!(m_nAppID)
10257 )
10258 );
10259}
10260#[repr(C)]
10261#[derive(Debug, Copy, Clone)]
10262pub struct NewUrlLaunchParameters_t {
10263 pub _address: u8,
10264}
10265pub const NewUrlLaunchParameters_t_k_iCallback: NewUrlLaunchParameters_t__bindgen_ty_1 =
10266 NewUrlLaunchParameters_t__bindgen_ty_1::k_iCallback;
10267#[repr(u32)]
10268#[non_exhaustive]
10269#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10270pub enum NewUrlLaunchParameters_t__bindgen_ty_1 {
10271 k_iCallback = 1014,
10272}
10273#[test]
10274fn bindgen_test_layout_NewUrlLaunchParameters_t() {
10275 assert_eq!(
10276 ::std::mem::size_of::<NewUrlLaunchParameters_t>(),
10277 1usize,
10278 concat!("Size of: ", stringify!(NewUrlLaunchParameters_t))
10279 );
10280 assert_eq!(
10281 ::std::mem::align_of::<NewUrlLaunchParameters_t>(),
10282 1usize,
10283 concat!("Alignment of ", stringify!(NewUrlLaunchParameters_t))
10284 );
10285}
10286#[repr(C)]
10287#[derive(Debug, Copy, Clone)]
10288pub struct AppProofOfPurchaseKeyResponse_t {
10289 pub m_eResult: EResult,
10290 pub m_nAppID: uint32,
10291 pub m_cchKeyLength: uint32,
10292 pub m_rgchKey: [::std::os::raw::c_char; 240usize],
10293}
10294pub const AppProofOfPurchaseKeyResponse_t_k_iCallback:
10295 AppProofOfPurchaseKeyResponse_t__bindgen_ty_1 =
10296 AppProofOfPurchaseKeyResponse_t__bindgen_ty_1::k_iCallback;
10297#[repr(u32)]
10298#[non_exhaustive]
10299#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10300pub enum AppProofOfPurchaseKeyResponse_t__bindgen_ty_1 {
10301 k_iCallback = 1021,
10302}
10303#[test]
10304fn bindgen_test_layout_AppProofOfPurchaseKeyResponse_t() {
10305 const UNINIT: ::std::mem::MaybeUninit<AppProofOfPurchaseKeyResponse_t> =
10306 ::std::mem::MaybeUninit::uninit();
10307 let ptr = UNINIT.as_ptr();
10308 assert_eq!(
10309 ::std::mem::size_of::<AppProofOfPurchaseKeyResponse_t>(),
10310 252usize,
10311 concat!("Size of: ", stringify!(AppProofOfPurchaseKeyResponse_t))
10312 );
10313 assert_eq!(
10314 ::std::mem::align_of::<AppProofOfPurchaseKeyResponse_t>(),
10315 4usize,
10316 concat!("Alignment of ", stringify!(AppProofOfPurchaseKeyResponse_t))
10317 );
10318 assert_eq!(
10319 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10320 0usize,
10321 concat!(
10322 "Offset of field: ",
10323 stringify!(AppProofOfPurchaseKeyResponse_t),
10324 "::",
10325 stringify!(m_eResult)
10326 )
10327 );
10328 assert_eq!(
10329 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
10330 4usize,
10331 concat!(
10332 "Offset of field: ",
10333 stringify!(AppProofOfPurchaseKeyResponse_t),
10334 "::",
10335 stringify!(m_nAppID)
10336 )
10337 );
10338 assert_eq!(
10339 unsafe { ::std::ptr::addr_of!((*ptr).m_cchKeyLength) as usize - ptr as usize },
10340 8usize,
10341 concat!(
10342 "Offset of field: ",
10343 stringify!(AppProofOfPurchaseKeyResponse_t),
10344 "::",
10345 stringify!(m_cchKeyLength)
10346 )
10347 );
10348 assert_eq!(
10349 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchKey) as usize - ptr as usize },
10350 12usize,
10351 concat!(
10352 "Offset of field: ",
10353 stringify!(AppProofOfPurchaseKeyResponse_t),
10354 "::",
10355 stringify!(m_rgchKey)
10356 )
10357 );
10358}
10359#[repr(C, packed(4))]
10360#[derive(Debug, Copy, Clone)]
10361pub struct FileDetailsResult_t {
10362 pub m_eResult: EResult,
10363 pub m_ulFileSize: uint64,
10364 pub m_FileSHA: [uint8; 20usize],
10365 pub m_unFlags: uint32,
10366}
10367pub const FileDetailsResult_t_k_iCallback: FileDetailsResult_t__bindgen_ty_1 =
10368 FileDetailsResult_t__bindgen_ty_1::k_iCallback;
10369#[repr(u32)]
10370#[non_exhaustive]
10371#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10372pub enum FileDetailsResult_t__bindgen_ty_1 {
10373 k_iCallback = 1023,
10374}
10375#[test]
10376fn bindgen_test_layout_FileDetailsResult_t() {
10377 const UNINIT: ::std::mem::MaybeUninit<FileDetailsResult_t> = ::std::mem::MaybeUninit::uninit();
10378 let ptr = UNINIT.as_ptr();
10379 assert_eq!(
10380 ::std::mem::size_of::<FileDetailsResult_t>(),
10381 36usize,
10382 concat!("Size of: ", stringify!(FileDetailsResult_t))
10383 );
10384 assert_eq!(
10385 ::std::mem::align_of::<FileDetailsResult_t>(),
10386 4usize,
10387 concat!("Alignment of ", stringify!(FileDetailsResult_t))
10388 );
10389 assert_eq!(
10390 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10391 0usize,
10392 concat!(
10393 "Offset of field: ",
10394 stringify!(FileDetailsResult_t),
10395 "::",
10396 stringify!(m_eResult)
10397 )
10398 );
10399 assert_eq!(
10400 unsafe { ::std::ptr::addr_of!((*ptr).m_ulFileSize) as usize - ptr as usize },
10401 4usize,
10402 concat!(
10403 "Offset of field: ",
10404 stringify!(FileDetailsResult_t),
10405 "::",
10406 stringify!(m_ulFileSize)
10407 )
10408 );
10409 assert_eq!(
10410 unsafe { ::std::ptr::addr_of!((*ptr).m_FileSHA) as usize - ptr as usize },
10411 12usize,
10412 concat!(
10413 "Offset of field: ",
10414 stringify!(FileDetailsResult_t),
10415 "::",
10416 stringify!(m_FileSHA)
10417 )
10418 );
10419 assert_eq!(
10420 unsafe { ::std::ptr::addr_of!((*ptr).m_unFlags) as usize - ptr as usize },
10421 32usize,
10422 concat!(
10423 "Offset of field: ",
10424 stringify!(FileDetailsResult_t),
10425 "::",
10426 stringify!(m_unFlags)
10427 )
10428 );
10429}
10430#[repr(C)]
10431#[derive(Debug, Copy, Clone)]
10432pub struct TimedTrialStatus_t {
10433 pub m_unAppID: AppId_t,
10434 pub m_bIsOffline: bool,
10435 pub m_unSecondsAllowed: uint32,
10436 pub m_unSecondsPlayed: uint32,
10437}
10438pub const TimedTrialStatus_t_k_iCallback: TimedTrialStatus_t__bindgen_ty_1 =
10439 TimedTrialStatus_t__bindgen_ty_1::k_iCallback;
10440#[repr(u32)]
10441#[non_exhaustive]
10442#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10443pub enum TimedTrialStatus_t__bindgen_ty_1 {
10444 k_iCallback = 1030,
10445}
10446#[test]
10447fn bindgen_test_layout_TimedTrialStatus_t() {
10448 const UNINIT: ::std::mem::MaybeUninit<TimedTrialStatus_t> = ::std::mem::MaybeUninit::uninit();
10449 let ptr = UNINIT.as_ptr();
10450 assert_eq!(
10451 ::std::mem::size_of::<TimedTrialStatus_t>(),
10452 16usize,
10453 concat!("Size of: ", stringify!(TimedTrialStatus_t))
10454 );
10455 assert_eq!(
10456 ::std::mem::align_of::<TimedTrialStatus_t>(),
10457 4usize,
10458 concat!("Alignment of ", stringify!(TimedTrialStatus_t))
10459 );
10460 assert_eq!(
10461 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
10462 0usize,
10463 concat!(
10464 "Offset of field: ",
10465 stringify!(TimedTrialStatus_t),
10466 "::",
10467 stringify!(m_unAppID)
10468 )
10469 );
10470 assert_eq!(
10471 unsafe { ::std::ptr::addr_of!((*ptr).m_bIsOffline) as usize - ptr as usize },
10472 4usize,
10473 concat!(
10474 "Offset of field: ",
10475 stringify!(TimedTrialStatus_t),
10476 "::",
10477 stringify!(m_bIsOffline)
10478 )
10479 );
10480 assert_eq!(
10481 unsafe { ::std::ptr::addr_of!((*ptr).m_unSecondsAllowed) as usize - ptr as usize },
10482 8usize,
10483 concat!(
10484 "Offset of field: ",
10485 stringify!(TimedTrialStatus_t),
10486 "::",
10487 stringify!(m_unSecondsAllowed)
10488 )
10489 );
10490 assert_eq!(
10491 unsafe { ::std::ptr::addr_of!((*ptr).m_unSecondsPlayed) as usize - ptr as usize },
10492 12usize,
10493 concat!(
10494 "Offset of field: ",
10495 stringify!(TimedTrialStatus_t),
10496 "::",
10497 stringify!(m_unSecondsPlayed)
10498 )
10499 );
10500}
10501#[repr(u32)]
10502#[non_exhaustive]
10503#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10504pub enum EP2PSessionError {
10505 k_EP2PSessionErrorNone = 0,
10506 k_EP2PSessionErrorNoRightsToApp = 2,
10507 k_EP2PSessionErrorTimeout = 4,
10508 k_EP2PSessionErrorNotRunningApp_DELETED = 1,
10509 k_EP2PSessionErrorDestinationNotLoggedIn_DELETED = 3,
10510 k_EP2PSessionErrorMax = 5,
10511}
10512#[repr(u32)]
10513#[non_exhaustive]
10514#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10515pub enum EP2PSend {
10516 k_EP2PSendUnreliable = 0,
10517 k_EP2PSendUnreliableNoDelay = 1,
10518 k_EP2PSendReliable = 2,
10519 k_EP2PSendReliableWithBuffering = 3,
10520}
10521#[repr(C)]
10522#[derive(Debug, Copy, Clone)]
10523pub struct P2PSessionState_t {
10524 pub m_bConnectionActive: uint8,
10525 pub m_bConnecting: uint8,
10526 pub m_eP2PSessionError: uint8,
10527 pub m_bUsingRelay: uint8,
10528 pub m_nBytesQueuedForSend: int32,
10529 pub m_nPacketsQueuedForSend: int32,
10530 pub m_nRemoteIP: uint32,
10531 pub m_nRemotePort: uint16,
10532}
10533#[test]
10534fn bindgen_test_layout_P2PSessionState_t() {
10535 const UNINIT: ::std::mem::MaybeUninit<P2PSessionState_t> = ::std::mem::MaybeUninit::uninit();
10536 let ptr = UNINIT.as_ptr();
10537 assert_eq!(
10538 ::std::mem::size_of::<P2PSessionState_t>(),
10539 20usize,
10540 concat!("Size of: ", stringify!(P2PSessionState_t))
10541 );
10542 assert_eq!(
10543 ::std::mem::align_of::<P2PSessionState_t>(),
10544 4usize,
10545 concat!("Alignment of ", stringify!(P2PSessionState_t))
10546 );
10547 assert_eq!(
10548 unsafe { ::std::ptr::addr_of!((*ptr).m_bConnectionActive) as usize - ptr as usize },
10549 0usize,
10550 concat!(
10551 "Offset of field: ",
10552 stringify!(P2PSessionState_t),
10553 "::",
10554 stringify!(m_bConnectionActive)
10555 )
10556 );
10557 assert_eq!(
10558 unsafe { ::std::ptr::addr_of!((*ptr).m_bConnecting) as usize - ptr as usize },
10559 1usize,
10560 concat!(
10561 "Offset of field: ",
10562 stringify!(P2PSessionState_t),
10563 "::",
10564 stringify!(m_bConnecting)
10565 )
10566 );
10567 assert_eq!(
10568 unsafe { ::std::ptr::addr_of!((*ptr).m_eP2PSessionError) as usize - ptr as usize },
10569 2usize,
10570 concat!(
10571 "Offset of field: ",
10572 stringify!(P2PSessionState_t),
10573 "::",
10574 stringify!(m_eP2PSessionError)
10575 )
10576 );
10577 assert_eq!(
10578 unsafe { ::std::ptr::addr_of!((*ptr).m_bUsingRelay) as usize - ptr as usize },
10579 3usize,
10580 concat!(
10581 "Offset of field: ",
10582 stringify!(P2PSessionState_t),
10583 "::",
10584 stringify!(m_bUsingRelay)
10585 )
10586 );
10587 assert_eq!(
10588 unsafe { ::std::ptr::addr_of!((*ptr).m_nBytesQueuedForSend) as usize - ptr as usize },
10589 4usize,
10590 concat!(
10591 "Offset of field: ",
10592 stringify!(P2PSessionState_t),
10593 "::",
10594 stringify!(m_nBytesQueuedForSend)
10595 )
10596 );
10597 assert_eq!(
10598 unsafe { ::std::ptr::addr_of!((*ptr).m_nPacketsQueuedForSend) as usize - ptr as usize },
10599 8usize,
10600 concat!(
10601 "Offset of field: ",
10602 stringify!(P2PSessionState_t),
10603 "::",
10604 stringify!(m_nPacketsQueuedForSend)
10605 )
10606 );
10607 assert_eq!(
10608 unsafe { ::std::ptr::addr_of!((*ptr).m_nRemoteIP) as usize - ptr as usize },
10609 12usize,
10610 concat!(
10611 "Offset of field: ",
10612 stringify!(P2PSessionState_t),
10613 "::",
10614 stringify!(m_nRemoteIP)
10615 )
10616 );
10617 assert_eq!(
10618 unsafe { ::std::ptr::addr_of!((*ptr).m_nRemotePort) as usize - ptr as usize },
10619 16usize,
10620 concat!(
10621 "Offset of field: ",
10622 stringify!(P2PSessionState_t),
10623 "::",
10624 stringify!(m_nRemotePort)
10625 )
10626 );
10627}
10628pub type SNetSocket_t = uint32;
10629pub type SNetListenSocket_t = uint32;
10630#[repr(u32)]
10631#[non_exhaustive]
10632#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10633pub enum ESNetSocketState {
10634 k_ESNetSocketStateInvalid = 0,
10635 k_ESNetSocketStateConnected = 1,
10636 k_ESNetSocketStateInitiated = 10,
10637 k_ESNetSocketStateLocalCandidatesFound = 11,
10638 k_ESNetSocketStateReceivedRemoteCandidates = 12,
10639 k_ESNetSocketStateChallengeHandshake = 15,
10640 k_ESNetSocketStateDisconnecting = 21,
10641 k_ESNetSocketStateLocalDisconnect = 22,
10642 k_ESNetSocketStateTimeoutDuringConnect = 23,
10643 k_ESNetSocketStateRemoteEndDisconnected = 24,
10644 k_ESNetSocketStateConnectionBroken = 25,
10645}
10646#[repr(u32)]
10647#[non_exhaustive]
10648#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10649pub enum ESNetSocketConnectionType {
10650 k_ESNetSocketConnectionTypeNotConnected = 0,
10651 k_ESNetSocketConnectionTypeUDP = 1,
10652 k_ESNetSocketConnectionTypeUDPRelay = 2,
10653}
10654#[repr(C)]
10655pub struct ISteamNetworking__bindgen_vtable(::std::os::raw::c_void);
10656#[doc = " the Steamworks SDK. Please see ISteamNetworkingSockets and\n ISteamNetworkingMessages"]
10657#[repr(C)]
10658#[derive(Debug, Copy, Clone)]
10659pub struct ISteamNetworking {
10660 pub vtable_: *const ISteamNetworking__bindgen_vtable,
10661}
10662#[test]
10663fn bindgen_test_layout_ISteamNetworking() {
10664 assert_eq!(
10665 ::std::mem::size_of::<ISteamNetworking>(),
10666 8usize,
10667 concat!("Size of: ", stringify!(ISteamNetworking))
10668 );
10669 assert_eq!(
10670 ::std::mem::align_of::<ISteamNetworking>(),
10671 8usize,
10672 concat!("Alignment of ", stringify!(ISteamNetworking))
10673 );
10674}
10675#[repr(C)]
10676#[derive(Copy, Clone)]
10677pub struct P2PSessionRequest_t {
10678 pub m_steamIDRemote: CSteamID,
10679}
10680pub const P2PSessionRequest_t_k_iCallback: P2PSessionRequest_t__bindgen_ty_1 =
10681 P2PSessionRequest_t__bindgen_ty_1::k_iCallback;
10682#[repr(u32)]
10683#[non_exhaustive]
10684#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10685pub enum P2PSessionRequest_t__bindgen_ty_1 {
10686 k_iCallback = 1202,
10687}
10688#[test]
10689fn bindgen_test_layout_P2PSessionRequest_t() {
10690 const UNINIT: ::std::mem::MaybeUninit<P2PSessionRequest_t> = ::std::mem::MaybeUninit::uninit();
10691 let ptr = UNINIT.as_ptr();
10692 assert_eq!(
10693 ::std::mem::size_of::<P2PSessionRequest_t>(),
10694 8usize,
10695 concat!("Size of: ", stringify!(P2PSessionRequest_t))
10696 );
10697 assert_eq!(
10698 ::std::mem::align_of::<P2PSessionRequest_t>(),
10699 1usize,
10700 concat!("Alignment of ", stringify!(P2PSessionRequest_t))
10701 );
10702 assert_eq!(
10703 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDRemote) as usize - ptr as usize },
10704 0usize,
10705 concat!(
10706 "Offset of field: ",
10707 stringify!(P2PSessionRequest_t),
10708 "::",
10709 stringify!(m_steamIDRemote)
10710 )
10711 );
10712}
10713#[repr(C)]
10714#[derive(Copy, Clone)]
10715pub struct P2PSessionConnectFail_t {
10716 pub m_steamIDRemote: CSteamID,
10717 pub m_eP2PSessionError: uint8,
10718}
10719pub const P2PSessionConnectFail_t_k_iCallback: P2PSessionConnectFail_t__bindgen_ty_1 =
10720 P2PSessionConnectFail_t__bindgen_ty_1::k_iCallback;
10721#[repr(u32)]
10722#[non_exhaustive]
10723#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10724pub enum P2PSessionConnectFail_t__bindgen_ty_1 {
10725 k_iCallback = 1203,
10726}
10727#[test]
10728fn bindgen_test_layout_P2PSessionConnectFail_t() {
10729 const UNINIT: ::std::mem::MaybeUninit<P2PSessionConnectFail_t> =
10730 ::std::mem::MaybeUninit::uninit();
10731 let ptr = UNINIT.as_ptr();
10732 assert_eq!(
10733 ::std::mem::size_of::<P2PSessionConnectFail_t>(),
10734 9usize,
10735 concat!("Size of: ", stringify!(P2PSessionConnectFail_t))
10736 );
10737 assert_eq!(
10738 ::std::mem::align_of::<P2PSessionConnectFail_t>(),
10739 1usize,
10740 concat!("Alignment of ", stringify!(P2PSessionConnectFail_t))
10741 );
10742 assert_eq!(
10743 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDRemote) as usize - ptr as usize },
10744 0usize,
10745 concat!(
10746 "Offset of field: ",
10747 stringify!(P2PSessionConnectFail_t),
10748 "::",
10749 stringify!(m_steamIDRemote)
10750 )
10751 );
10752 assert_eq!(
10753 unsafe { ::std::ptr::addr_of!((*ptr).m_eP2PSessionError) as usize - ptr as usize },
10754 8usize,
10755 concat!(
10756 "Offset of field: ",
10757 stringify!(P2PSessionConnectFail_t),
10758 "::",
10759 stringify!(m_eP2PSessionError)
10760 )
10761 );
10762}
10763#[repr(C)]
10764#[derive(Copy, Clone)]
10765pub struct SocketStatusCallback_t {
10766 pub m_hSocket: SNetSocket_t,
10767 pub m_hListenSocket: SNetListenSocket_t,
10768 pub m_steamIDRemote: CSteamID,
10769 pub m_eSNetSocketState: ::std::os::raw::c_int,
10770}
10771pub const SocketStatusCallback_t_k_iCallback: SocketStatusCallback_t__bindgen_ty_1 =
10772 SocketStatusCallback_t__bindgen_ty_1::k_iCallback;
10773#[repr(u32)]
10774#[non_exhaustive]
10775#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10776pub enum SocketStatusCallback_t__bindgen_ty_1 {
10777 k_iCallback = 1201,
10778}
10779#[test]
10780fn bindgen_test_layout_SocketStatusCallback_t() {
10781 const UNINIT: ::std::mem::MaybeUninit<SocketStatusCallback_t> =
10782 ::std::mem::MaybeUninit::uninit();
10783 let ptr = UNINIT.as_ptr();
10784 assert_eq!(
10785 ::std::mem::size_of::<SocketStatusCallback_t>(),
10786 20usize,
10787 concat!("Size of: ", stringify!(SocketStatusCallback_t))
10788 );
10789 assert_eq!(
10790 ::std::mem::align_of::<SocketStatusCallback_t>(),
10791 4usize,
10792 concat!("Alignment of ", stringify!(SocketStatusCallback_t))
10793 );
10794 assert_eq!(
10795 unsafe { ::std::ptr::addr_of!((*ptr).m_hSocket) as usize - ptr as usize },
10796 0usize,
10797 concat!(
10798 "Offset of field: ",
10799 stringify!(SocketStatusCallback_t),
10800 "::",
10801 stringify!(m_hSocket)
10802 )
10803 );
10804 assert_eq!(
10805 unsafe { ::std::ptr::addr_of!((*ptr).m_hListenSocket) as usize - ptr as usize },
10806 4usize,
10807 concat!(
10808 "Offset of field: ",
10809 stringify!(SocketStatusCallback_t),
10810 "::",
10811 stringify!(m_hListenSocket)
10812 )
10813 );
10814 assert_eq!(
10815 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDRemote) as usize - ptr as usize },
10816 8usize,
10817 concat!(
10818 "Offset of field: ",
10819 stringify!(SocketStatusCallback_t),
10820 "::",
10821 stringify!(m_steamIDRemote)
10822 )
10823 );
10824 assert_eq!(
10825 unsafe { ::std::ptr::addr_of!((*ptr).m_eSNetSocketState) as usize - ptr as usize },
10826 16usize,
10827 concat!(
10828 "Offset of field: ",
10829 stringify!(SocketStatusCallback_t),
10830 "::",
10831 stringify!(m_eSNetSocketState)
10832 )
10833 );
10834}
10835pub const k_nScreenshotMaxTaggedUsers: uint32 = 32;
10836pub const k_nScreenshotMaxTaggedPublishedFiles: uint32 = 32;
10837pub const k_cubUFSTagTypeMax: ::std::os::raw::c_int = 255;
10838pub const k_cubUFSTagValueMax: ::std::os::raw::c_int = 255;
10839pub const k_ScreenshotThumbWidth: ::std::os::raw::c_int = 200;
10840pub type ScreenshotHandle = uint32;
10841#[repr(u32)]
10842#[non_exhaustive]
10843#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10844pub enum EVRScreenshotType {
10845 k_EVRScreenshotType_None = 0,
10846 k_EVRScreenshotType_Mono = 1,
10847 k_EVRScreenshotType_Stereo = 2,
10848 k_EVRScreenshotType_MonoCubemap = 3,
10849 k_EVRScreenshotType_MonoPanorama = 4,
10850 k_EVRScreenshotType_StereoPanorama = 5,
10851}
10852#[repr(C)]
10853pub struct ISteamScreenshots__bindgen_vtable(::std::os::raw::c_void);
10854#[repr(C)]
10855#[derive(Debug, Copy, Clone)]
10856pub struct ISteamScreenshots {
10857 pub vtable_: *const ISteamScreenshots__bindgen_vtable,
10858}
10859#[test]
10860fn bindgen_test_layout_ISteamScreenshots() {
10861 assert_eq!(
10862 ::std::mem::size_of::<ISteamScreenshots>(),
10863 8usize,
10864 concat!("Size of: ", stringify!(ISteamScreenshots))
10865 );
10866 assert_eq!(
10867 ::std::mem::align_of::<ISteamScreenshots>(),
10868 8usize,
10869 concat!("Alignment of ", stringify!(ISteamScreenshots))
10870 );
10871}
10872#[repr(C)]
10873#[derive(Debug, Copy, Clone)]
10874pub struct ScreenshotReady_t {
10875 pub m_hLocal: ScreenshotHandle,
10876 pub m_eResult: EResult,
10877}
10878pub const ScreenshotReady_t_k_iCallback: ScreenshotReady_t__bindgen_ty_1 =
10879 ScreenshotReady_t__bindgen_ty_1::k_iCallback;
10880#[repr(u32)]
10881#[non_exhaustive]
10882#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10883pub enum ScreenshotReady_t__bindgen_ty_1 {
10884 k_iCallback = 2301,
10885}
10886#[test]
10887fn bindgen_test_layout_ScreenshotReady_t() {
10888 const UNINIT: ::std::mem::MaybeUninit<ScreenshotReady_t> = ::std::mem::MaybeUninit::uninit();
10889 let ptr = UNINIT.as_ptr();
10890 assert_eq!(
10891 ::std::mem::size_of::<ScreenshotReady_t>(),
10892 8usize,
10893 concat!("Size of: ", stringify!(ScreenshotReady_t))
10894 );
10895 assert_eq!(
10896 ::std::mem::align_of::<ScreenshotReady_t>(),
10897 4usize,
10898 concat!("Alignment of ", stringify!(ScreenshotReady_t))
10899 );
10900 assert_eq!(
10901 unsafe { ::std::ptr::addr_of!((*ptr).m_hLocal) as usize - ptr as usize },
10902 0usize,
10903 concat!(
10904 "Offset of field: ",
10905 stringify!(ScreenshotReady_t),
10906 "::",
10907 stringify!(m_hLocal)
10908 )
10909 );
10910 assert_eq!(
10911 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
10912 4usize,
10913 concat!(
10914 "Offset of field: ",
10915 stringify!(ScreenshotReady_t),
10916 "::",
10917 stringify!(m_eResult)
10918 )
10919 );
10920}
10921#[repr(C)]
10922#[derive(Debug, Copy, Clone)]
10923pub struct ScreenshotRequested_t {
10924 pub _address: u8,
10925}
10926pub const ScreenshotRequested_t_k_iCallback: ScreenshotRequested_t__bindgen_ty_1 =
10927 ScreenshotRequested_t__bindgen_ty_1::k_iCallback;
10928#[repr(u32)]
10929#[non_exhaustive]
10930#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10931pub enum ScreenshotRequested_t__bindgen_ty_1 {
10932 k_iCallback = 2302,
10933}
10934#[test]
10935fn bindgen_test_layout_ScreenshotRequested_t() {
10936 assert_eq!(
10937 ::std::mem::size_of::<ScreenshotRequested_t>(),
10938 1usize,
10939 concat!("Size of: ", stringify!(ScreenshotRequested_t))
10940 );
10941 assert_eq!(
10942 ::std::mem::align_of::<ScreenshotRequested_t>(),
10943 1usize,
10944 concat!("Alignment of ", stringify!(ScreenshotRequested_t))
10945 );
10946}
10947#[repr(u32)]
10948#[non_exhaustive]
10949#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10950pub enum AudioPlayback_Status {
10951 AudioPlayback_Undefined = 0,
10952 AudioPlayback_Playing = 1,
10953 AudioPlayback_Paused = 2,
10954 AudioPlayback_Idle = 3,
10955}
10956#[repr(C)]
10957pub struct ISteamMusic__bindgen_vtable(::std::os::raw::c_void);
10958#[repr(C)]
10959#[derive(Debug, Copy, Clone)]
10960pub struct ISteamMusic {
10961 pub vtable_: *const ISteamMusic__bindgen_vtable,
10962}
10963#[test]
10964fn bindgen_test_layout_ISteamMusic() {
10965 assert_eq!(
10966 ::std::mem::size_of::<ISteamMusic>(),
10967 8usize,
10968 concat!("Size of: ", stringify!(ISteamMusic))
10969 );
10970 assert_eq!(
10971 ::std::mem::align_of::<ISteamMusic>(),
10972 8usize,
10973 concat!("Alignment of ", stringify!(ISteamMusic))
10974 );
10975}
10976#[repr(C)]
10977#[derive(Debug, Copy, Clone)]
10978pub struct PlaybackStatusHasChanged_t {
10979 pub _address: u8,
10980}
10981pub const PlaybackStatusHasChanged_t_k_iCallback: PlaybackStatusHasChanged_t__bindgen_ty_1 =
10982 PlaybackStatusHasChanged_t__bindgen_ty_1::k_iCallback;
10983#[repr(u32)]
10984#[non_exhaustive]
10985#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10986pub enum PlaybackStatusHasChanged_t__bindgen_ty_1 {
10987 k_iCallback = 4001,
10988}
10989#[test]
10990fn bindgen_test_layout_PlaybackStatusHasChanged_t() {
10991 assert_eq!(
10992 ::std::mem::size_of::<PlaybackStatusHasChanged_t>(),
10993 1usize,
10994 concat!("Size of: ", stringify!(PlaybackStatusHasChanged_t))
10995 );
10996 assert_eq!(
10997 ::std::mem::align_of::<PlaybackStatusHasChanged_t>(),
10998 1usize,
10999 concat!("Alignment of ", stringify!(PlaybackStatusHasChanged_t))
11000 );
11001}
11002#[repr(C)]
11003#[derive(Debug, Copy, Clone)]
11004pub struct VolumeHasChanged_t {
11005 pub m_flNewVolume: f32,
11006}
11007pub const VolumeHasChanged_t_k_iCallback: VolumeHasChanged_t__bindgen_ty_1 =
11008 VolumeHasChanged_t__bindgen_ty_1::k_iCallback;
11009#[repr(u32)]
11010#[non_exhaustive]
11011#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11012pub enum VolumeHasChanged_t__bindgen_ty_1 {
11013 k_iCallback = 4002,
11014}
11015#[test]
11016fn bindgen_test_layout_VolumeHasChanged_t() {
11017 const UNINIT: ::std::mem::MaybeUninit<VolumeHasChanged_t> = ::std::mem::MaybeUninit::uninit();
11018 let ptr = UNINIT.as_ptr();
11019 assert_eq!(
11020 ::std::mem::size_of::<VolumeHasChanged_t>(),
11021 4usize,
11022 concat!("Size of: ", stringify!(VolumeHasChanged_t))
11023 );
11024 assert_eq!(
11025 ::std::mem::align_of::<VolumeHasChanged_t>(),
11026 4usize,
11027 concat!("Alignment of ", stringify!(VolumeHasChanged_t))
11028 );
11029 assert_eq!(
11030 unsafe { ::std::ptr::addr_of!((*ptr).m_flNewVolume) as usize - ptr as usize },
11031 0usize,
11032 concat!(
11033 "Offset of field: ",
11034 stringify!(VolumeHasChanged_t),
11035 "::",
11036 stringify!(m_flNewVolume)
11037 )
11038 );
11039}
11040#[repr(u32)]
11041#[non_exhaustive]
11042#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11043pub enum EHTTPMethod {
11044 k_EHTTPMethodInvalid = 0,
11045 k_EHTTPMethodGET = 1,
11046 k_EHTTPMethodHEAD = 2,
11047 k_EHTTPMethodPOST = 3,
11048 k_EHTTPMethodPUT = 4,
11049 k_EHTTPMethodDELETE = 5,
11050 k_EHTTPMethodOPTIONS = 6,
11051 k_EHTTPMethodPATCH = 7,
11052}
11053#[repr(u32)]
11054#[non_exhaustive]
11055#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11056pub enum EHTTPStatusCode {
11057 k_EHTTPStatusCodeInvalid = 0,
11058 k_EHTTPStatusCode100Continue = 100,
11059 k_EHTTPStatusCode101SwitchingProtocols = 101,
11060 k_EHTTPStatusCode200OK = 200,
11061 k_EHTTPStatusCode201Created = 201,
11062 k_EHTTPStatusCode202Accepted = 202,
11063 k_EHTTPStatusCode203NonAuthoritative = 203,
11064 k_EHTTPStatusCode204NoContent = 204,
11065 k_EHTTPStatusCode205ResetContent = 205,
11066 k_EHTTPStatusCode206PartialContent = 206,
11067 k_EHTTPStatusCode300MultipleChoices = 300,
11068 k_EHTTPStatusCode301MovedPermanently = 301,
11069 k_EHTTPStatusCode302Found = 302,
11070 k_EHTTPStatusCode303SeeOther = 303,
11071 k_EHTTPStatusCode304NotModified = 304,
11072 k_EHTTPStatusCode305UseProxy = 305,
11073 k_EHTTPStatusCode307TemporaryRedirect = 307,
11074 k_EHTTPStatusCode308PermanentRedirect = 308,
11075 k_EHTTPStatusCode400BadRequest = 400,
11076 k_EHTTPStatusCode401Unauthorized = 401,
11077 k_EHTTPStatusCode402PaymentRequired = 402,
11078 k_EHTTPStatusCode403Forbidden = 403,
11079 k_EHTTPStatusCode404NotFound = 404,
11080 k_EHTTPStatusCode405MethodNotAllowed = 405,
11081 k_EHTTPStatusCode406NotAcceptable = 406,
11082 k_EHTTPStatusCode407ProxyAuthRequired = 407,
11083 k_EHTTPStatusCode408RequestTimeout = 408,
11084 k_EHTTPStatusCode409Conflict = 409,
11085 k_EHTTPStatusCode410Gone = 410,
11086 k_EHTTPStatusCode411LengthRequired = 411,
11087 k_EHTTPStatusCode412PreconditionFailed = 412,
11088 k_EHTTPStatusCode413RequestEntityTooLarge = 413,
11089 k_EHTTPStatusCode414RequestURITooLong = 414,
11090 k_EHTTPStatusCode415UnsupportedMediaType = 415,
11091 k_EHTTPStatusCode416RequestedRangeNotSatisfiable = 416,
11092 k_EHTTPStatusCode417ExpectationFailed = 417,
11093 k_EHTTPStatusCode4xxUnknown = 418,
11094 k_EHTTPStatusCode421MisdirectedRequest = 421,
11095 k_EHTTPStatusCode422UnprocessableContent = 422,
11096 k_EHTTPStatusCode423Locked = 423,
11097 k_EHTTPStatusCode424FailedDependency = 424,
11098 k_EHTTPStatusCode425TooEarly = 425,
11099 k_EHTTPStatusCode426UpgradeRequired = 426,
11100 k_EHTTPStatusCode428PreconditionRequired = 428,
11101 k_EHTTPStatusCode429TooManyRequests = 429,
11102 k_EHTTPStatusCode431RequestHeaderFieldsTooLarge = 431,
11103 k_EHTTPStatusCode444ConnectionClosed = 444,
11104 k_EHTTPStatusCode451UnavailableForLegalReasons = 451,
11105 k_EHTTPStatusCode500InternalServerError = 500,
11106 k_EHTTPStatusCode501NotImplemented = 501,
11107 k_EHTTPStatusCode502BadGateway = 502,
11108 k_EHTTPStatusCode503ServiceUnavailable = 503,
11109 k_EHTTPStatusCode504GatewayTimeout = 504,
11110 k_EHTTPStatusCode505HTTPVersionNotSupported = 505,
11111 k_EHTTPStatusCode506VariantAlsoNegotiates = 506,
11112 k_EHTTPStatusCode507InsufficientStorage = 507,
11113 k_EHTTPStatusCode508LoopDetected = 508,
11114 k_EHTTPStatusCode510NotExtended = 510,
11115 k_EHTTPStatusCode511NetworkAuthenticationRequired = 511,
11116 k_EHTTPStatusCode5xxUnknown = 599,
11117}
11118pub type HTTPRequestHandle = uint32;
11119pub type HTTPCookieContainerHandle = uint32;
11120#[repr(C)]
11121pub struct ISteamHTTP__bindgen_vtable(::std::os::raw::c_void);
11122#[repr(C)]
11123#[derive(Debug, Copy, Clone)]
11124pub struct ISteamHTTP {
11125 pub vtable_: *const ISteamHTTP__bindgen_vtable,
11126}
11127#[test]
11128fn bindgen_test_layout_ISteamHTTP() {
11129 assert_eq!(
11130 ::std::mem::size_of::<ISteamHTTP>(),
11131 8usize,
11132 concat!("Size of: ", stringify!(ISteamHTTP))
11133 );
11134 assert_eq!(
11135 ::std::mem::align_of::<ISteamHTTP>(),
11136 8usize,
11137 concat!("Alignment of ", stringify!(ISteamHTTP))
11138 );
11139}
11140#[repr(C, packed(4))]
11141#[derive(Debug, Copy, Clone)]
11142pub struct HTTPRequestCompleted_t {
11143 pub m_hRequest: HTTPRequestHandle,
11144 pub m_ulContextValue: uint64,
11145 pub m_bRequestSuccessful: bool,
11146 pub m_eStatusCode: EHTTPStatusCode,
11147 pub m_unBodySize: uint32,
11148}
11149pub const HTTPRequestCompleted_t_k_iCallback: HTTPRequestCompleted_t__bindgen_ty_1 =
11150 HTTPRequestCompleted_t__bindgen_ty_1::k_iCallback;
11151#[repr(u32)]
11152#[non_exhaustive]
11153#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11154pub enum HTTPRequestCompleted_t__bindgen_ty_1 {
11155 k_iCallback = 2101,
11156}
11157#[test]
11158fn bindgen_test_layout_HTTPRequestCompleted_t() {
11159 const UNINIT: ::std::mem::MaybeUninit<HTTPRequestCompleted_t> =
11160 ::std::mem::MaybeUninit::uninit();
11161 let ptr = UNINIT.as_ptr();
11162 assert_eq!(
11163 ::std::mem::size_of::<HTTPRequestCompleted_t>(),
11164 24usize,
11165 concat!("Size of: ", stringify!(HTTPRequestCompleted_t))
11166 );
11167 assert_eq!(
11168 ::std::mem::align_of::<HTTPRequestCompleted_t>(),
11169 4usize,
11170 concat!("Alignment of ", stringify!(HTTPRequestCompleted_t))
11171 );
11172 assert_eq!(
11173 unsafe { ::std::ptr::addr_of!((*ptr).m_hRequest) as usize - ptr as usize },
11174 0usize,
11175 concat!(
11176 "Offset of field: ",
11177 stringify!(HTTPRequestCompleted_t),
11178 "::",
11179 stringify!(m_hRequest)
11180 )
11181 );
11182 assert_eq!(
11183 unsafe { ::std::ptr::addr_of!((*ptr).m_ulContextValue) as usize - ptr as usize },
11184 4usize,
11185 concat!(
11186 "Offset of field: ",
11187 stringify!(HTTPRequestCompleted_t),
11188 "::",
11189 stringify!(m_ulContextValue)
11190 )
11191 );
11192 assert_eq!(
11193 unsafe { ::std::ptr::addr_of!((*ptr).m_bRequestSuccessful) as usize - ptr as usize },
11194 12usize,
11195 concat!(
11196 "Offset of field: ",
11197 stringify!(HTTPRequestCompleted_t),
11198 "::",
11199 stringify!(m_bRequestSuccessful)
11200 )
11201 );
11202 assert_eq!(
11203 unsafe { ::std::ptr::addr_of!((*ptr).m_eStatusCode) as usize - ptr as usize },
11204 16usize,
11205 concat!(
11206 "Offset of field: ",
11207 stringify!(HTTPRequestCompleted_t),
11208 "::",
11209 stringify!(m_eStatusCode)
11210 )
11211 );
11212 assert_eq!(
11213 unsafe { ::std::ptr::addr_of!((*ptr).m_unBodySize) as usize - ptr as usize },
11214 20usize,
11215 concat!(
11216 "Offset of field: ",
11217 stringify!(HTTPRequestCompleted_t),
11218 "::",
11219 stringify!(m_unBodySize)
11220 )
11221 );
11222}
11223#[repr(C, packed(4))]
11224#[derive(Debug, Copy, Clone)]
11225pub struct HTTPRequestHeadersReceived_t {
11226 pub m_hRequest: HTTPRequestHandle,
11227 pub m_ulContextValue: uint64,
11228}
11229pub const HTTPRequestHeadersReceived_t_k_iCallback: HTTPRequestHeadersReceived_t__bindgen_ty_1 =
11230 HTTPRequestHeadersReceived_t__bindgen_ty_1::k_iCallback;
11231#[repr(u32)]
11232#[non_exhaustive]
11233#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11234pub enum HTTPRequestHeadersReceived_t__bindgen_ty_1 {
11235 k_iCallback = 2102,
11236}
11237#[test]
11238fn bindgen_test_layout_HTTPRequestHeadersReceived_t() {
11239 const UNINIT: ::std::mem::MaybeUninit<HTTPRequestHeadersReceived_t> =
11240 ::std::mem::MaybeUninit::uninit();
11241 let ptr = UNINIT.as_ptr();
11242 assert_eq!(
11243 ::std::mem::size_of::<HTTPRequestHeadersReceived_t>(),
11244 12usize,
11245 concat!("Size of: ", stringify!(HTTPRequestHeadersReceived_t))
11246 );
11247 assert_eq!(
11248 ::std::mem::align_of::<HTTPRequestHeadersReceived_t>(),
11249 4usize,
11250 concat!("Alignment of ", stringify!(HTTPRequestHeadersReceived_t))
11251 );
11252 assert_eq!(
11253 unsafe { ::std::ptr::addr_of!((*ptr).m_hRequest) as usize - ptr as usize },
11254 0usize,
11255 concat!(
11256 "Offset of field: ",
11257 stringify!(HTTPRequestHeadersReceived_t),
11258 "::",
11259 stringify!(m_hRequest)
11260 )
11261 );
11262 assert_eq!(
11263 unsafe { ::std::ptr::addr_of!((*ptr).m_ulContextValue) as usize - ptr as usize },
11264 4usize,
11265 concat!(
11266 "Offset of field: ",
11267 stringify!(HTTPRequestHeadersReceived_t),
11268 "::",
11269 stringify!(m_ulContextValue)
11270 )
11271 );
11272}
11273#[repr(C, packed(4))]
11274#[derive(Debug, Copy, Clone)]
11275pub struct HTTPRequestDataReceived_t {
11276 pub m_hRequest: HTTPRequestHandle,
11277 pub m_ulContextValue: uint64,
11278 pub m_cOffset: uint32,
11279 pub m_cBytesReceived: uint32,
11280}
11281pub const HTTPRequestDataReceived_t_k_iCallback: HTTPRequestDataReceived_t__bindgen_ty_1 =
11282 HTTPRequestDataReceived_t__bindgen_ty_1::k_iCallback;
11283#[repr(u32)]
11284#[non_exhaustive]
11285#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11286pub enum HTTPRequestDataReceived_t__bindgen_ty_1 {
11287 k_iCallback = 2103,
11288}
11289#[test]
11290fn bindgen_test_layout_HTTPRequestDataReceived_t() {
11291 const UNINIT: ::std::mem::MaybeUninit<HTTPRequestDataReceived_t> =
11292 ::std::mem::MaybeUninit::uninit();
11293 let ptr = UNINIT.as_ptr();
11294 assert_eq!(
11295 ::std::mem::size_of::<HTTPRequestDataReceived_t>(),
11296 20usize,
11297 concat!("Size of: ", stringify!(HTTPRequestDataReceived_t))
11298 );
11299 assert_eq!(
11300 ::std::mem::align_of::<HTTPRequestDataReceived_t>(),
11301 4usize,
11302 concat!("Alignment of ", stringify!(HTTPRequestDataReceived_t))
11303 );
11304 assert_eq!(
11305 unsafe { ::std::ptr::addr_of!((*ptr).m_hRequest) as usize - ptr as usize },
11306 0usize,
11307 concat!(
11308 "Offset of field: ",
11309 stringify!(HTTPRequestDataReceived_t),
11310 "::",
11311 stringify!(m_hRequest)
11312 )
11313 );
11314 assert_eq!(
11315 unsafe { ::std::ptr::addr_of!((*ptr).m_ulContextValue) as usize - ptr as usize },
11316 4usize,
11317 concat!(
11318 "Offset of field: ",
11319 stringify!(HTTPRequestDataReceived_t),
11320 "::",
11321 stringify!(m_ulContextValue)
11322 )
11323 );
11324 assert_eq!(
11325 unsafe { ::std::ptr::addr_of!((*ptr).m_cOffset) as usize - ptr as usize },
11326 12usize,
11327 concat!(
11328 "Offset of field: ",
11329 stringify!(HTTPRequestDataReceived_t),
11330 "::",
11331 stringify!(m_cOffset)
11332 )
11333 );
11334 assert_eq!(
11335 unsafe { ::std::ptr::addr_of!((*ptr).m_cBytesReceived) as usize - ptr as usize },
11336 16usize,
11337 concat!(
11338 "Offset of field: ",
11339 stringify!(HTTPRequestDataReceived_t),
11340 "::",
11341 stringify!(m_cBytesReceived)
11342 )
11343 );
11344}
11345#[repr(u32)]
11346#[non_exhaustive]
11347#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11348pub enum EInputSourceMode {
11349 k_EInputSourceMode_None = 0,
11350 k_EInputSourceMode_Dpad = 1,
11351 k_EInputSourceMode_Buttons = 2,
11352 k_EInputSourceMode_FourButtons = 3,
11353 k_EInputSourceMode_AbsoluteMouse = 4,
11354 k_EInputSourceMode_RelativeMouse = 5,
11355 k_EInputSourceMode_JoystickMove = 6,
11356 k_EInputSourceMode_JoystickMouse = 7,
11357 k_EInputSourceMode_JoystickCamera = 8,
11358 k_EInputSourceMode_ScrollWheel = 9,
11359 k_EInputSourceMode_Trigger = 10,
11360 k_EInputSourceMode_TouchMenu = 11,
11361 k_EInputSourceMode_MouseJoystick = 12,
11362 k_EInputSourceMode_MouseRegion = 13,
11363 k_EInputSourceMode_RadialMenu = 14,
11364 k_EInputSourceMode_SingleButton = 15,
11365 k_EInputSourceMode_Switches = 16,
11366}
11367#[repr(u32)]
11368#[non_exhaustive]
11369#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11370pub enum EInputActionOrigin {
11371 k_EInputActionOrigin_None = 0,
11372 k_EInputActionOrigin_SteamController_A = 1,
11373 k_EInputActionOrigin_SteamController_B = 2,
11374 k_EInputActionOrigin_SteamController_X = 3,
11375 k_EInputActionOrigin_SteamController_Y = 4,
11376 k_EInputActionOrigin_SteamController_LeftBumper = 5,
11377 k_EInputActionOrigin_SteamController_RightBumper = 6,
11378 k_EInputActionOrigin_SteamController_LeftGrip = 7,
11379 k_EInputActionOrigin_SteamController_RightGrip = 8,
11380 k_EInputActionOrigin_SteamController_Start = 9,
11381 k_EInputActionOrigin_SteamController_Back = 10,
11382 k_EInputActionOrigin_SteamController_LeftPad_Touch = 11,
11383 k_EInputActionOrigin_SteamController_LeftPad_Swipe = 12,
11384 k_EInputActionOrigin_SteamController_LeftPad_Click = 13,
11385 k_EInputActionOrigin_SteamController_LeftPad_DPadNorth = 14,
11386 k_EInputActionOrigin_SteamController_LeftPad_DPadSouth = 15,
11387 k_EInputActionOrigin_SteamController_LeftPad_DPadWest = 16,
11388 k_EInputActionOrigin_SteamController_LeftPad_DPadEast = 17,
11389 k_EInputActionOrigin_SteamController_RightPad_Touch = 18,
11390 k_EInputActionOrigin_SteamController_RightPad_Swipe = 19,
11391 k_EInputActionOrigin_SteamController_RightPad_Click = 20,
11392 k_EInputActionOrigin_SteamController_RightPad_DPadNorth = 21,
11393 k_EInputActionOrigin_SteamController_RightPad_DPadSouth = 22,
11394 k_EInputActionOrigin_SteamController_RightPad_DPadWest = 23,
11395 k_EInputActionOrigin_SteamController_RightPad_DPadEast = 24,
11396 k_EInputActionOrigin_SteamController_LeftTrigger_Pull = 25,
11397 k_EInputActionOrigin_SteamController_LeftTrigger_Click = 26,
11398 k_EInputActionOrigin_SteamController_RightTrigger_Pull = 27,
11399 k_EInputActionOrigin_SteamController_RightTrigger_Click = 28,
11400 k_EInputActionOrigin_SteamController_LeftStick_Move = 29,
11401 k_EInputActionOrigin_SteamController_LeftStick_Click = 30,
11402 k_EInputActionOrigin_SteamController_LeftStick_DPadNorth = 31,
11403 k_EInputActionOrigin_SteamController_LeftStick_DPadSouth = 32,
11404 k_EInputActionOrigin_SteamController_LeftStick_DPadWest = 33,
11405 k_EInputActionOrigin_SteamController_LeftStick_DPadEast = 34,
11406 k_EInputActionOrigin_SteamController_Gyro_Move = 35,
11407 k_EInputActionOrigin_SteamController_Gyro_Pitch = 36,
11408 k_EInputActionOrigin_SteamController_Gyro_Yaw = 37,
11409 k_EInputActionOrigin_SteamController_Gyro_Roll = 38,
11410 k_EInputActionOrigin_SteamController_Reserved0 = 39,
11411 k_EInputActionOrigin_SteamController_Reserved1 = 40,
11412 k_EInputActionOrigin_SteamController_Reserved2 = 41,
11413 k_EInputActionOrigin_SteamController_Reserved3 = 42,
11414 k_EInputActionOrigin_SteamController_Reserved4 = 43,
11415 k_EInputActionOrigin_SteamController_Reserved5 = 44,
11416 k_EInputActionOrigin_SteamController_Reserved6 = 45,
11417 k_EInputActionOrigin_SteamController_Reserved7 = 46,
11418 k_EInputActionOrigin_SteamController_Reserved8 = 47,
11419 k_EInputActionOrigin_SteamController_Reserved9 = 48,
11420 k_EInputActionOrigin_SteamController_Reserved10 = 49,
11421 k_EInputActionOrigin_PS4_X = 50,
11422 k_EInputActionOrigin_PS4_Circle = 51,
11423 k_EInputActionOrigin_PS4_Triangle = 52,
11424 k_EInputActionOrigin_PS4_Square = 53,
11425 k_EInputActionOrigin_PS4_LeftBumper = 54,
11426 k_EInputActionOrigin_PS4_RightBumper = 55,
11427 k_EInputActionOrigin_PS4_Options = 56,
11428 k_EInputActionOrigin_PS4_Share = 57,
11429 k_EInputActionOrigin_PS4_LeftPad_Touch = 58,
11430 k_EInputActionOrigin_PS4_LeftPad_Swipe = 59,
11431 k_EInputActionOrigin_PS4_LeftPad_Click = 60,
11432 k_EInputActionOrigin_PS4_LeftPad_DPadNorth = 61,
11433 k_EInputActionOrigin_PS4_LeftPad_DPadSouth = 62,
11434 k_EInputActionOrigin_PS4_LeftPad_DPadWest = 63,
11435 k_EInputActionOrigin_PS4_LeftPad_DPadEast = 64,
11436 k_EInputActionOrigin_PS4_RightPad_Touch = 65,
11437 k_EInputActionOrigin_PS4_RightPad_Swipe = 66,
11438 k_EInputActionOrigin_PS4_RightPad_Click = 67,
11439 k_EInputActionOrigin_PS4_RightPad_DPadNorth = 68,
11440 k_EInputActionOrigin_PS4_RightPad_DPadSouth = 69,
11441 k_EInputActionOrigin_PS4_RightPad_DPadWest = 70,
11442 k_EInputActionOrigin_PS4_RightPad_DPadEast = 71,
11443 k_EInputActionOrigin_PS4_CenterPad_Touch = 72,
11444 k_EInputActionOrigin_PS4_CenterPad_Swipe = 73,
11445 k_EInputActionOrigin_PS4_CenterPad_Click = 74,
11446 k_EInputActionOrigin_PS4_CenterPad_DPadNorth = 75,
11447 k_EInputActionOrigin_PS4_CenterPad_DPadSouth = 76,
11448 k_EInputActionOrigin_PS4_CenterPad_DPadWest = 77,
11449 k_EInputActionOrigin_PS4_CenterPad_DPadEast = 78,
11450 k_EInputActionOrigin_PS4_LeftTrigger_Pull = 79,
11451 k_EInputActionOrigin_PS4_LeftTrigger_Click = 80,
11452 k_EInputActionOrigin_PS4_RightTrigger_Pull = 81,
11453 k_EInputActionOrigin_PS4_RightTrigger_Click = 82,
11454 k_EInputActionOrigin_PS4_LeftStick_Move = 83,
11455 k_EInputActionOrigin_PS4_LeftStick_Click = 84,
11456 k_EInputActionOrigin_PS4_LeftStick_DPadNorth = 85,
11457 k_EInputActionOrigin_PS4_LeftStick_DPadSouth = 86,
11458 k_EInputActionOrigin_PS4_LeftStick_DPadWest = 87,
11459 k_EInputActionOrigin_PS4_LeftStick_DPadEast = 88,
11460 k_EInputActionOrigin_PS4_RightStick_Move = 89,
11461 k_EInputActionOrigin_PS4_RightStick_Click = 90,
11462 k_EInputActionOrigin_PS4_RightStick_DPadNorth = 91,
11463 k_EInputActionOrigin_PS4_RightStick_DPadSouth = 92,
11464 k_EInputActionOrigin_PS4_RightStick_DPadWest = 93,
11465 k_EInputActionOrigin_PS4_RightStick_DPadEast = 94,
11466 k_EInputActionOrigin_PS4_DPad_North = 95,
11467 k_EInputActionOrigin_PS4_DPad_South = 96,
11468 k_EInputActionOrigin_PS4_DPad_West = 97,
11469 k_EInputActionOrigin_PS4_DPad_East = 98,
11470 k_EInputActionOrigin_PS4_Gyro_Move = 99,
11471 k_EInputActionOrigin_PS4_Gyro_Pitch = 100,
11472 k_EInputActionOrigin_PS4_Gyro_Yaw = 101,
11473 k_EInputActionOrigin_PS4_Gyro_Roll = 102,
11474 k_EInputActionOrigin_PS4_DPad_Move = 103,
11475 k_EInputActionOrigin_PS4_Reserved1 = 104,
11476 k_EInputActionOrigin_PS4_Reserved2 = 105,
11477 k_EInputActionOrigin_PS4_Reserved3 = 106,
11478 k_EInputActionOrigin_PS4_Reserved4 = 107,
11479 k_EInputActionOrigin_PS4_Reserved5 = 108,
11480 k_EInputActionOrigin_PS4_Reserved6 = 109,
11481 k_EInputActionOrigin_PS4_Reserved7 = 110,
11482 k_EInputActionOrigin_PS4_Reserved8 = 111,
11483 k_EInputActionOrigin_PS4_Reserved9 = 112,
11484 k_EInputActionOrigin_PS4_Reserved10 = 113,
11485 k_EInputActionOrigin_XBoxOne_A = 114,
11486 k_EInputActionOrigin_XBoxOne_B = 115,
11487 k_EInputActionOrigin_XBoxOne_X = 116,
11488 k_EInputActionOrigin_XBoxOne_Y = 117,
11489 k_EInputActionOrigin_XBoxOne_LeftBumper = 118,
11490 k_EInputActionOrigin_XBoxOne_RightBumper = 119,
11491 k_EInputActionOrigin_XBoxOne_Menu = 120,
11492 k_EInputActionOrigin_XBoxOne_View = 121,
11493 k_EInputActionOrigin_XBoxOne_LeftTrigger_Pull = 122,
11494 k_EInputActionOrigin_XBoxOne_LeftTrigger_Click = 123,
11495 k_EInputActionOrigin_XBoxOne_RightTrigger_Pull = 124,
11496 k_EInputActionOrigin_XBoxOne_RightTrigger_Click = 125,
11497 k_EInputActionOrigin_XBoxOne_LeftStick_Move = 126,
11498 k_EInputActionOrigin_XBoxOne_LeftStick_Click = 127,
11499 k_EInputActionOrigin_XBoxOne_LeftStick_DPadNorth = 128,
11500 k_EInputActionOrigin_XBoxOne_LeftStick_DPadSouth = 129,
11501 k_EInputActionOrigin_XBoxOne_LeftStick_DPadWest = 130,
11502 k_EInputActionOrigin_XBoxOne_LeftStick_DPadEast = 131,
11503 k_EInputActionOrigin_XBoxOne_RightStick_Move = 132,
11504 k_EInputActionOrigin_XBoxOne_RightStick_Click = 133,
11505 k_EInputActionOrigin_XBoxOne_RightStick_DPadNorth = 134,
11506 k_EInputActionOrigin_XBoxOne_RightStick_DPadSouth = 135,
11507 k_EInputActionOrigin_XBoxOne_RightStick_DPadWest = 136,
11508 k_EInputActionOrigin_XBoxOne_RightStick_DPadEast = 137,
11509 k_EInputActionOrigin_XBoxOne_DPad_North = 138,
11510 k_EInputActionOrigin_XBoxOne_DPad_South = 139,
11511 k_EInputActionOrigin_XBoxOne_DPad_West = 140,
11512 k_EInputActionOrigin_XBoxOne_DPad_East = 141,
11513 k_EInputActionOrigin_XBoxOne_DPad_Move = 142,
11514 k_EInputActionOrigin_XBoxOne_LeftGrip_Lower = 143,
11515 k_EInputActionOrigin_XBoxOne_LeftGrip_Upper = 144,
11516 k_EInputActionOrigin_XBoxOne_RightGrip_Lower = 145,
11517 k_EInputActionOrigin_XBoxOne_RightGrip_Upper = 146,
11518 k_EInputActionOrigin_XBoxOne_Share = 147,
11519 k_EInputActionOrigin_XBoxOne_Reserved6 = 148,
11520 k_EInputActionOrigin_XBoxOne_Reserved7 = 149,
11521 k_EInputActionOrigin_XBoxOne_Reserved8 = 150,
11522 k_EInputActionOrigin_XBoxOne_Reserved9 = 151,
11523 k_EInputActionOrigin_XBoxOne_Reserved10 = 152,
11524 k_EInputActionOrigin_XBox360_A = 153,
11525 k_EInputActionOrigin_XBox360_B = 154,
11526 k_EInputActionOrigin_XBox360_X = 155,
11527 k_EInputActionOrigin_XBox360_Y = 156,
11528 k_EInputActionOrigin_XBox360_LeftBumper = 157,
11529 k_EInputActionOrigin_XBox360_RightBumper = 158,
11530 k_EInputActionOrigin_XBox360_Start = 159,
11531 k_EInputActionOrigin_XBox360_Back = 160,
11532 k_EInputActionOrigin_XBox360_LeftTrigger_Pull = 161,
11533 k_EInputActionOrigin_XBox360_LeftTrigger_Click = 162,
11534 k_EInputActionOrigin_XBox360_RightTrigger_Pull = 163,
11535 k_EInputActionOrigin_XBox360_RightTrigger_Click = 164,
11536 k_EInputActionOrigin_XBox360_LeftStick_Move = 165,
11537 k_EInputActionOrigin_XBox360_LeftStick_Click = 166,
11538 k_EInputActionOrigin_XBox360_LeftStick_DPadNorth = 167,
11539 k_EInputActionOrigin_XBox360_LeftStick_DPadSouth = 168,
11540 k_EInputActionOrigin_XBox360_LeftStick_DPadWest = 169,
11541 k_EInputActionOrigin_XBox360_LeftStick_DPadEast = 170,
11542 k_EInputActionOrigin_XBox360_RightStick_Move = 171,
11543 k_EInputActionOrigin_XBox360_RightStick_Click = 172,
11544 k_EInputActionOrigin_XBox360_RightStick_DPadNorth = 173,
11545 k_EInputActionOrigin_XBox360_RightStick_DPadSouth = 174,
11546 k_EInputActionOrigin_XBox360_RightStick_DPadWest = 175,
11547 k_EInputActionOrigin_XBox360_RightStick_DPadEast = 176,
11548 k_EInputActionOrigin_XBox360_DPad_North = 177,
11549 k_EInputActionOrigin_XBox360_DPad_South = 178,
11550 k_EInputActionOrigin_XBox360_DPad_West = 179,
11551 k_EInputActionOrigin_XBox360_DPad_East = 180,
11552 k_EInputActionOrigin_XBox360_DPad_Move = 181,
11553 k_EInputActionOrigin_XBox360_Reserved1 = 182,
11554 k_EInputActionOrigin_XBox360_Reserved2 = 183,
11555 k_EInputActionOrigin_XBox360_Reserved3 = 184,
11556 k_EInputActionOrigin_XBox360_Reserved4 = 185,
11557 k_EInputActionOrigin_XBox360_Reserved5 = 186,
11558 k_EInputActionOrigin_XBox360_Reserved6 = 187,
11559 k_EInputActionOrigin_XBox360_Reserved7 = 188,
11560 k_EInputActionOrigin_XBox360_Reserved8 = 189,
11561 k_EInputActionOrigin_XBox360_Reserved9 = 190,
11562 k_EInputActionOrigin_XBox360_Reserved10 = 191,
11563 k_EInputActionOrigin_Switch_A = 192,
11564 k_EInputActionOrigin_Switch_B = 193,
11565 k_EInputActionOrigin_Switch_X = 194,
11566 k_EInputActionOrigin_Switch_Y = 195,
11567 k_EInputActionOrigin_Switch_LeftBumper = 196,
11568 k_EInputActionOrigin_Switch_RightBumper = 197,
11569 k_EInputActionOrigin_Switch_Plus = 198,
11570 k_EInputActionOrigin_Switch_Minus = 199,
11571 k_EInputActionOrigin_Switch_Capture = 200,
11572 k_EInputActionOrigin_Switch_LeftTrigger_Pull = 201,
11573 k_EInputActionOrigin_Switch_LeftTrigger_Click = 202,
11574 k_EInputActionOrigin_Switch_RightTrigger_Pull = 203,
11575 k_EInputActionOrigin_Switch_RightTrigger_Click = 204,
11576 k_EInputActionOrigin_Switch_LeftStick_Move = 205,
11577 k_EInputActionOrigin_Switch_LeftStick_Click = 206,
11578 k_EInputActionOrigin_Switch_LeftStick_DPadNorth = 207,
11579 k_EInputActionOrigin_Switch_LeftStick_DPadSouth = 208,
11580 k_EInputActionOrigin_Switch_LeftStick_DPadWest = 209,
11581 k_EInputActionOrigin_Switch_LeftStick_DPadEast = 210,
11582 k_EInputActionOrigin_Switch_RightStick_Move = 211,
11583 k_EInputActionOrigin_Switch_RightStick_Click = 212,
11584 k_EInputActionOrigin_Switch_RightStick_DPadNorth = 213,
11585 k_EInputActionOrigin_Switch_RightStick_DPadSouth = 214,
11586 k_EInputActionOrigin_Switch_RightStick_DPadWest = 215,
11587 k_EInputActionOrigin_Switch_RightStick_DPadEast = 216,
11588 k_EInputActionOrigin_Switch_DPad_North = 217,
11589 k_EInputActionOrigin_Switch_DPad_South = 218,
11590 k_EInputActionOrigin_Switch_DPad_West = 219,
11591 k_EInputActionOrigin_Switch_DPad_East = 220,
11592 k_EInputActionOrigin_Switch_ProGyro_Move = 221,
11593 k_EInputActionOrigin_Switch_ProGyro_Pitch = 222,
11594 k_EInputActionOrigin_Switch_ProGyro_Yaw = 223,
11595 k_EInputActionOrigin_Switch_ProGyro_Roll = 224,
11596 k_EInputActionOrigin_Switch_DPad_Move = 225,
11597 k_EInputActionOrigin_Switch_Reserved1 = 226,
11598 k_EInputActionOrigin_Switch_Reserved2 = 227,
11599 k_EInputActionOrigin_Switch_Reserved3 = 228,
11600 k_EInputActionOrigin_Switch_Reserved4 = 229,
11601 k_EInputActionOrigin_Switch_Reserved5 = 230,
11602 k_EInputActionOrigin_Switch_Reserved6 = 231,
11603 k_EInputActionOrigin_Switch_Reserved7 = 232,
11604 k_EInputActionOrigin_Switch_Reserved8 = 233,
11605 k_EInputActionOrigin_Switch_Reserved9 = 234,
11606 k_EInputActionOrigin_Switch_Reserved10 = 235,
11607 k_EInputActionOrigin_Switch_RightGyro_Move = 236,
11608 k_EInputActionOrigin_Switch_RightGyro_Pitch = 237,
11609 k_EInputActionOrigin_Switch_RightGyro_Yaw = 238,
11610 k_EInputActionOrigin_Switch_RightGyro_Roll = 239,
11611 k_EInputActionOrigin_Switch_LeftGyro_Move = 240,
11612 k_EInputActionOrigin_Switch_LeftGyro_Pitch = 241,
11613 k_EInputActionOrigin_Switch_LeftGyro_Yaw = 242,
11614 k_EInputActionOrigin_Switch_LeftGyro_Roll = 243,
11615 k_EInputActionOrigin_Switch_LeftGrip_Lower = 244,
11616 k_EInputActionOrigin_Switch_LeftGrip_Upper = 245,
11617 k_EInputActionOrigin_Switch_RightGrip_Lower = 246,
11618 k_EInputActionOrigin_Switch_RightGrip_Upper = 247,
11619 k_EInputActionOrigin_Switch_JoyConButton_N = 248,
11620 k_EInputActionOrigin_Switch_JoyConButton_E = 249,
11621 k_EInputActionOrigin_Switch_JoyConButton_S = 250,
11622 k_EInputActionOrigin_Switch_JoyConButton_W = 251,
11623 k_EInputActionOrigin_Switch_Reserved15 = 252,
11624 k_EInputActionOrigin_Switch_Reserved16 = 253,
11625 k_EInputActionOrigin_Switch_Reserved17 = 254,
11626 k_EInputActionOrigin_Switch_Reserved18 = 255,
11627 k_EInputActionOrigin_Switch_Reserved19 = 256,
11628 k_EInputActionOrigin_Switch_Reserved20 = 257,
11629 k_EInputActionOrigin_PS5_X = 258,
11630 k_EInputActionOrigin_PS5_Circle = 259,
11631 k_EInputActionOrigin_PS5_Triangle = 260,
11632 k_EInputActionOrigin_PS5_Square = 261,
11633 k_EInputActionOrigin_PS5_LeftBumper = 262,
11634 k_EInputActionOrigin_PS5_RightBumper = 263,
11635 k_EInputActionOrigin_PS5_Option = 264,
11636 k_EInputActionOrigin_PS5_Create = 265,
11637 k_EInputActionOrigin_PS5_Mute = 266,
11638 k_EInputActionOrigin_PS5_LeftPad_Touch = 267,
11639 k_EInputActionOrigin_PS5_LeftPad_Swipe = 268,
11640 k_EInputActionOrigin_PS5_LeftPad_Click = 269,
11641 k_EInputActionOrigin_PS5_LeftPad_DPadNorth = 270,
11642 k_EInputActionOrigin_PS5_LeftPad_DPadSouth = 271,
11643 k_EInputActionOrigin_PS5_LeftPad_DPadWest = 272,
11644 k_EInputActionOrigin_PS5_LeftPad_DPadEast = 273,
11645 k_EInputActionOrigin_PS5_RightPad_Touch = 274,
11646 k_EInputActionOrigin_PS5_RightPad_Swipe = 275,
11647 k_EInputActionOrigin_PS5_RightPad_Click = 276,
11648 k_EInputActionOrigin_PS5_RightPad_DPadNorth = 277,
11649 k_EInputActionOrigin_PS5_RightPad_DPadSouth = 278,
11650 k_EInputActionOrigin_PS5_RightPad_DPadWest = 279,
11651 k_EInputActionOrigin_PS5_RightPad_DPadEast = 280,
11652 k_EInputActionOrigin_PS5_CenterPad_Touch = 281,
11653 k_EInputActionOrigin_PS5_CenterPad_Swipe = 282,
11654 k_EInputActionOrigin_PS5_CenterPad_Click = 283,
11655 k_EInputActionOrigin_PS5_CenterPad_DPadNorth = 284,
11656 k_EInputActionOrigin_PS5_CenterPad_DPadSouth = 285,
11657 k_EInputActionOrigin_PS5_CenterPad_DPadWest = 286,
11658 k_EInputActionOrigin_PS5_CenterPad_DPadEast = 287,
11659 k_EInputActionOrigin_PS5_LeftTrigger_Pull = 288,
11660 k_EInputActionOrigin_PS5_LeftTrigger_Click = 289,
11661 k_EInputActionOrigin_PS5_RightTrigger_Pull = 290,
11662 k_EInputActionOrigin_PS5_RightTrigger_Click = 291,
11663 k_EInputActionOrigin_PS5_LeftStick_Move = 292,
11664 k_EInputActionOrigin_PS5_LeftStick_Click = 293,
11665 k_EInputActionOrigin_PS5_LeftStick_DPadNorth = 294,
11666 k_EInputActionOrigin_PS5_LeftStick_DPadSouth = 295,
11667 k_EInputActionOrigin_PS5_LeftStick_DPadWest = 296,
11668 k_EInputActionOrigin_PS5_LeftStick_DPadEast = 297,
11669 k_EInputActionOrigin_PS5_RightStick_Move = 298,
11670 k_EInputActionOrigin_PS5_RightStick_Click = 299,
11671 k_EInputActionOrigin_PS5_RightStick_DPadNorth = 300,
11672 k_EInputActionOrigin_PS5_RightStick_DPadSouth = 301,
11673 k_EInputActionOrigin_PS5_RightStick_DPadWest = 302,
11674 k_EInputActionOrigin_PS5_RightStick_DPadEast = 303,
11675 k_EInputActionOrigin_PS5_DPad_North = 304,
11676 k_EInputActionOrigin_PS5_DPad_South = 305,
11677 k_EInputActionOrigin_PS5_DPad_West = 306,
11678 k_EInputActionOrigin_PS5_DPad_East = 307,
11679 k_EInputActionOrigin_PS5_Gyro_Move = 308,
11680 k_EInputActionOrigin_PS5_Gyro_Pitch = 309,
11681 k_EInputActionOrigin_PS5_Gyro_Yaw = 310,
11682 k_EInputActionOrigin_PS5_Gyro_Roll = 311,
11683 k_EInputActionOrigin_PS5_DPad_Move = 312,
11684 k_EInputActionOrigin_PS5_LeftGrip = 313,
11685 k_EInputActionOrigin_PS5_RightGrip = 314,
11686 k_EInputActionOrigin_PS5_LeftFn = 315,
11687 k_EInputActionOrigin_PS5_RightFn = 316,
11688 k_EInputActionOrigin_PS5_Reserved5 = 317,
11689 k_EInputActionOrigin_PS5_Reserved6 = 318,
11690 k_EInputActionOrigin_PS5_Reserved7 = 319,
11691 k_EInputActionOrigin_PS5_Reserved8 = 320,
11692 k_EInputActionOrigin_PS5_Reserved9 = 321,
11693 k_EInputActionOrigin_PS5_Reserved10 = 322,
11694 k_EInputActionOrigin_PS5_Reserved11 = 323,
11695 k_EInputActionOrigin_PS5_Reserved12 = 324,
11696 k_EInputActionOrigin_PS5_Reserved13 = 325,
11697 k_EInputActionOrigin_PS5_Reserved14 = 326,
11698 k_EInputActionOrigin_PS5_Reserved15 = 327,
11699 k_EInputActionOrigin_PS5_Reserved16 = 328,
11700 k_EInputActionOrigin_PS5_Reserved17 = 329,
11701 k_EInputActionOrigin_PS5_Reserved18 = 330,
11702 k_EInputActionOrigin_PS5_Reserved19 = 331,
11703 k_EInputActionOrigin_PS5_Reserved20 = 332,
11704 k_EInputActionOrigin_SteamDeck_A = 333,
11705 k_EInputActionOrigin_SteamDeck_B = 334,
11706 k_EInputActionOrigin_SteamDeck_X = 335,
11707 k_EInputActionOrigin_SteamDeck_Y = 336,
11708 k_EInputActionOrigin_SteamDeck_L1 = 337,
11709 k_EInputActionOrigin_SteamDeck_R1 = 338,
11710 k_EInputActionOrigin_SteamDeck_Menu = 339,
11711 k_EInputActionOrigin_SteamDeck_View = 340,
11712 k_EInputActionOrigin_SteamDeck_LeftPad_Touch = 341,
11713 k_EInputActionOrigin_SteamDeck_LeftPad_Swipe = 342,
11714 k_EInputActionOrigin_SteamDeck_LeftPad_Click = 343,
11715 k_EInputActionOrigin_SteamDeck_LeftPad_DPadNorth = 344,
11716 k_EInputActionOrigin_SteamDeck_LeftPad_DPadSouth = 345,
11717 k_EInputActionOrigin_SteamDeck_LeftPad_DPadWest = 346,
11718 k_EInputActionOrigin_SteamDeck_LeftPad_DPadEast = 347,
11719 k_EInputActionOrigin_SteamDeck_RightPad_Touch = 348,
11720 k_EInputActionOrigin_SteamDeck_RightPad_Swipe = 349,
11721 k_EInputActionOrigin_SteamDeck_RightPad_Click = 350,
11722 k_EInputActionOrigin_SteamDeck_RightPad_DPadNorth = 351,
11723 k_EInputActionOrigin_SteamDeck_RightPad_DPadSouth = 352,
11724 k_EInputActionOrigin_SteamDeck_RightPad_DPadWest = 353,
11725 k_EInputActionOrigin_SteamDeck_RightPad_DPadEast = 354,
11726 k_EInputActionOrigin_SteamDeck_L2_SoftPull = 355,
11727 k_EInputActionOrigin_SteamDeck_L2 = 356,
11728 k_EInputActionOrigin_SteamDeck_R2_SoftPull = 357,
11729 k_EInputActionOrigin_SteamDeck_R2 = 358,
11730 k_EInputActionOrigin_SteamDeck_LeftStick_Move = 359,
11731 k_EInputActionOrigin_SteamDeck_L3 = 360,
11732 k_EInputActionOrigin_SteamDeck_LeftStick_DPadNorth = 361,
11733 k_EInputActionOrigin_SteamDeck_LeftStick_DPadSouth = 362,
11734 k_EInputActionOrigin_SteamDeck_LeftStick_DPadWest = 363,
11735 k_EInputActionOrigin_SteamDeck_LeftStick_DPadEast = 364,
11736 k_EInputActionOrigin_SteamDeck_LeftStick_Touch = 365,
11737 k_EInputActionOrigin_SteamDeck_RightStick_Move = 366,
11738 k_EInputActionOrigin_SteamDeck_R3 = 367,
11739 k_EInputActionOrigin_SteamDeck_RightStick_DPadNorth = 368,
11740 k_EInputActionOrigin_SteamDeck_RightStick_DPadSouth = 369,
11741 k_EInputActionOrigin_SteamDeck_RightStick_DPadWest = 370,
11742 k_EInputActionOrigin_SteamDeck_RightStick_DPadEast = 371,
11743 k_EInputActionOrigin_SteamDeck_RightStick_Touch = 372,
11744 k_EInputActionOrigin_SteamDeck_L4 = 373,
11745 k_EInputActionOrigin_SteamDeck_R4 = 374,
11746 k_EInputActionOrigin_SteamDeck_L5 = 375,
11747 k_EInputActionOrigin_SteamDeck_R5 = 376,
11748 k_EInputActionOrigin_SteamDeck_DPad_Move = 377,
11749 k_EInputActionOrigin_SteamDeck_DPad_North = 378,
11750 k_EInputActionOrigin_SteamDeck_DPad_South = 379,
11751 k_EInputActionOrigin_SteamDeck_DPad_West = 380,
11752 k_EInputActionOrigin_SteamDeck_DPad_East = 381,
11753 k_EInputActionOrigin_SteamDeck_Gyro_Move = 382,
11754 k_EInputActionOrigin_SteamDeck_Gyro_Pitch = 383,
11755 k_EInputActionOrigin_SteamDeck_Gyro_Yaw = 384,
11756 k_EInputActionOrigin_SteamDeck_Gyro_Roll = 385,
11757 k_EInputActionOrigin_SteamDeck_Reserved1 = 386,
11758 k_EInputActionOrigin_SteamDeck_Reserved2 = 387,
11759 k_EInputActionOrigin_SteamDeck_Reserved3 = 388,
11760 k_EInputActionOrigin_SteamDeck_Reserved4 = 389,
11761 k_EInputActionOrigin_SteamDeck_Reserved5 = 390,
11762 k_EInputActionOrigin_SteamDeck_Reserved6 = 391,
11763 k_EInputActionOrigin_SteamDeck_Reserved7 = 392,
11764 k_EInputActionOrigin_SteamDeck_Reserved8 = 393,
11765 k_EInputActionOrigin_SteamDeck_Reserved9 = 394,
11766 k_EInputActionOrigin_SteamDeck_Reserved10 = 395,
11767 k_EInputActionOrigin_SteamDeck_Reserved11 = 396,
11768 k_EInputActionOrigin_SteamDeck_Reserved12 = 397,
11769 k_EInputActionOrigin_SteamDeck_Reserved13 = 398,
11770 k_EInputActionOrigin_SteamDeck_Reserved14 = 399,
11771 k_EInputActionOrigin_SteamDeck_Reserved15 = 400,
11772 k_EInputActionOrigin_SteamDeck_Reserved16 = 401,
11773 k_EInputActionOrigin_SteamDeck_Reserved17 = 402,
11774 k_EInputActionOrigin_SteamDeck_Reserved18 = 403,
11775 k_EInputActionOrigin_SteamDeck_Reserved19 = 404,
11776 k_EInputActionOrigin_SteamDeck_Reserved20 = 405,
11777 k_EInputActionOrigin_Horipad_M1 = 406,
11778 k_EInputActionOrigin_Horipad_M2 = 407,
11779 k_EInputActionOrigin_Horipad_L4 = 408,
11780 k_EInputActionOrigin_Horipad_R4 = 409,
11781 k_EInputActionOrigin_LenovoLegionGo_A = 410,
11782 k_EInputActionOrigin_LenovoLegionGo_B = 411,
11783 k_EInputActionOrigin_LenovoLegionGo_X = 412,
11784 k_EInputActionOrigin_LenovoLegionGo_Y = 413,
11785 k_EInputActionOrigin_LenovoLegionGo_LB = 414,
11786 k_EInputActionOrigin_LenovoLegionGo_RB = 415,
11787 k_EInputActionOrigin_LenovoLegionGo_Menu = 416,
11788 k_EInputActionOrigin_LenovoLegionGo_View = 417,
11789 k_EInputActionOrigin_LenovoLegionGo_LeftPad_Touch = 418,
11790 k_EInputActionOrigin_LenovoLegionGo_LeftPad_Swipe = 419,
11791 k_EInputActionOrigin_LenovoLegionGo_LeftPad_Click = 420,
11792 k_EInputActionOrigin_LenovoLegionGo_LeftPad_DPadNorth = 421,
11793 k_EInputActionOrigin_LenovoLegionGo_LeftPad_DPadSouth = 422,
11794 k_EInputActionOrigin_LenovoLegionGo_LeftPad_DPadWest = 423,
11795 k_EInputActionOrigin_LenovoLegionGo_LeftPad_DPadEast = 424,
11796 k_EInputActionOrigin_LenovoLegionGo_RightPad_Touch = 425,
11797 k_EInputActionOrigin_LenovoLegionGo_RightPad_Swipe = 426,
11798 k_EInputActionOrigin_LenovoLegionGo_RightPad_Click = 427,
11799 k_EInputActionOrigin_LenovoLegionGo_RightPad_DPadNorth = 428,
11800 k_EInputActionOrigin_LenovoLegionGo_RightPad_DPadSouth = 429,
11801 k_EInputActionOrigin_LenovoLegionGo_RightPad_DPadWest = 430,
11802 k_EInputActionOrigin_LenovoLegionGo_RightPad_DPadEast = 431,
11803 k_EInputActionOrigin_LenovoLegionGo_LT_SoftPull = 432,
11804 k_EInputActionOrigin_LenovoLegionGo_LT = 433,
11805 k_EInputActionOrigin_LenovoLegionGo_RT_SoftPull = 434,
11806 k_EInputActionOrigin_LenovoLegionGo_RT = 435,
11807 k_EInputActionOrigin_LenovoLegionGo_LeftStick_Move = 436,
11808 k_EInputActionOrigin_LenovoLegionGo_LS = 437,
11809 k_EInputActionOrigin_LenovoLegionGo_LeftStick_DPadNorth = 438,
11810 k_EInputActionOrigin_LenovoLegionGo_LeftStick_DPadSouth = 439,
11811 k_EInputActionOrigin_LenovoLegionGo_LeftStick_DPadWest = 440,
11812 k_EInputActionOrigin_LenovoLegionGo_LeftStick_DPadEast = 441,
11813 k_EInputActionOrigin_LenovoLegionGo_RightStick_Move = 442,
11814 k_EInputActionOrigin_LenovoLegionGo_RS = 443,
11815 k_EInputActionOrigin_LenovoLegionGo_RightStick_DPadNorth = 444,
11816 k_EInputActionOrigin_LenovoLegionGo_RightStick_DPadSouth = 445,
11817 k_EInputActionOrigin_LenovoLegionGo_RightStick_DPadWest = 446,
11818 k_EInputActionOrigin_LenovoLegionGo_RightStick_DPadEast = 447,
11819 k_EInputActionOrigin_LenovoLegionGo_Y1 = 448,
11820 k_EInputActionOrigin_LenovoLegionGo_Y2 = 449,
11821 k_EInputActionOrigin_LenovoLegionGo_DPad_Move = 450,
11822 k_EInputActionOrigin_LenovoLegionGo_DPad_North = 451,
11823 k_EInputActionOrigin_LenovoLegionGo_DPad_South = 452,
11824 k_EInputActionOrigin_LenovoLegionGo_DPad_West = 453,
11825 k_EInputActionOrigin_LenovoLegionGo_DPad_East = 454,
11826 k_EInputActionOrigin_LenovoLegionGo_Gyro_Move = 455,
11827 k_EInputActionOrigin_LenovoLegionGo_Gyro_Pitch = 456,
11828 k_EInputActionOrigin_LenovoLegionGo_Gyro_Yaw = 457,
11829 k_EInputActionOrigin_LenovoLegionGo_Gyro_Roll = 458,
11830 k_EInputActionOrigin_LenovoLegionGo_Reserved1 = 459,
11831 k_EInputActionOrigin_LenovoLegionGo_Reserved2 = 460,
11832 k_EInputActionOrigin_LenovoLegionGo_Reserved3 = 461,
11833 k_EInputActionOrigin_LenovoLegionGo_Reserved4 = 462,
11834 k_EInputActionOrigin_LenovoLegionGo_Reserved5 = 463,
11835 k_EInputActionOrigin_LenovoLegionGo_Reserved6 = 464,
11836 k_EInputActionOrigin_LenovoLegionGo_Reserved7 = 465,
11837 k_EInputActionOrigin_LenovoLegionGo_Reserved8 = 466,
11838 k_EInputActionOrigin_LenovoLegionGo_Reserved9 = 467,
11839 k_EInputActionOrigin_LenovoLegionGo_Reserved10 = 468,
11840 k_EInputActionOrigin_LenovoLegionGo_Reserved11 = 469,
11841 k_EInputActionOrigin_LenovoLegionGo_Reserved12 = 470,
11842 k_EInputActionOrigin_LenovoLegionGo_Reserved13 = 471,
11843 k_EInputActionOrigin_LenovoLegionGo_Reserved14 = 472,
11844 k_EInputActionOrigin_LenovoLegionGo_Reserved15 = 473,
11845 k_EInputActionOrigin_LenovoLegionGo_Reserved16 = 474,
11846 k_EInputActionOrigin_LenovoLegionGo_Reserved17 = 475,
11847 k_EInputActionOrigin_LenovoLegionGo_Reserved18 = 476,
11848 k_EInputActionOrigin_LenovoLegionGo_Reserved19 = 477,
11849 k_EInputActionOrigin_LenovoLegionGo_Reserved20 = 478,
11850 k_EInputActionOrigin_Generic_L4 = 479,
11851 k_EInputActionOrigin_Generic_R4 = 480,
11852 k_EInputActionOrigin_Generic_L5 = 481,
11853 k_EInputActionOrigin_Generic_R5 = 482,
11854 k_EInputActionOrigin_Generic_PL = 483,
11855 k_EInputActionOrigin_Generic_PR = 484,
11856 k_EInputActionOrigin_Generic_C = 485,
11857 k_EInputActionOrigin_Generic_Z = 486,
11858 k_EInputActionOrigin_Generic_MISC1 = 487,
11859 k_EInputActionOrigin_Generic_MISC2 = 488,
11860 k_EInputActionOrigin_Generic_MISC3 = 489,
11861 k_EInputActionOrigin_Generic_MISC4 = 490,
11862 k_EInputActionOrigin_Generic_MISC5 = 491,
11863 k_EInputActionOrigin_Generic_MISC6 = 492,
11864 k_EInputActionOrigin_Generic_MISC7 = 493,
11865 k_EInputActionOrigin_Generic_MISC8 = 494,
11866 k_EInputActionOrigin_Count = 495,
11867 k_EInputActionOrigin_MaximumPossibleValue = 32767,
11868}
11869#[repr(u32)]
11870#[non_exhaustive]
11871#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11872pub enum EXboxOrigin {
11873 k_EXboxOrigin_A = 0,
11874 k_EXboxOrigin_B = 1,
11875 k_EXboxOrigin_X = 2,
11876 k_EXboxOrigin_Y = 3,
11877 k_EXboxOrigin_LeftBumper = 4,
11878 k_EXboxOrigin_RightBumper = 5,
11879 k_EXboxOrigin_Menu = 6,
11880 k_EXboxOrigin_View = 7,
11881 k_EXboxOrigin_LeftTrigger_Pull = 8,
11882 k_EXboxOrigin_LeftTrigger_Click = 9,
11883 k_EXboxOrigin_RightTrigger_Pull = 10,
11884 k_EXboxOrigin_RightTrigger_Click = 11,
11885 k_EXboxOrigin_LeftStick_Move = 12,
11886 k_EXboxOrigin_LeftStick_Click = 13,
11887 k_EXboxOrigin_LeftStick_DPadNorth = 14,
11888 k_EXboxOrigin_LeftStick_DPadSouth = 15,
11889 k_EXboxOrigin_LeftStick_DPadWest = 16,
11890 k_EXboxOrigin_LeftStick_DPadEast = 17,
11891 k_EXboxOrigin_RightStick_Move = 18,
11892 k_EXboxOrigin_RightStick_Click = 19,
11893 k_EXboxOrigin_RightStick_DPadNorth = 20,
11894 k_EXboxOrigin_RightStick_DPadSouth = 21,
11895 k_EXboxOrigin_RightStick_DPadWest = 22,
11896 k_EXboxOrigin_RightStick_DPadEast = 23,
11897 k_EXboxOrigin_DPad_North = 24,
11898 k_EXboxOrigin_DPad_South = 25,
11899 k_EXboxOrigin_DPad_West = 26,
11900 k_EXboxOrigin_DPad_East = 27,
11901 k_EXboxOrigin_Count = 28,
11902}
11903#[repr(u32)]
11904#[non_exhaustive]
11905#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11906pub enum ESteamControllerPad {
11907 k_ESteamControllerPad_Left = 0,
11908 k_ESteamControllerPad_Right = 1,
11909}
11910#[repr(u32)]
11911#[non_exhaustive]
11912#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11913pub enum EControllerHapticLocation {
11914 k_EControllerHapticLocation_Left = 1,
11915 k_EControllerHapticLocation_Right = 2,
11916 k_EControllerHapticLocation_Both = 3,
11917}
11918#[repr(u32)]
11919#[non_exhaustive]
11920#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11921pub enum EControllerHapticType {
11922 k_EControllerHapticType_Off = 0,
11923 k_EControllerHapticType_Tick = 1,
11924 k_EControllerHapticType_Click = 2,
11925}
11926#[repr(u32)]
11927#[non_exhaustive]
11928#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11929pub enum ESteamInputType {
11930 k_ESteamInputType_Unknown = 0,
11931 k_ESteamInputType_SteamController = 1,
11932 k_ESteamInputType_XBox360Controller = 2,
11933 k_ESteamInputType_XBoxOneController = 3,
11934 k_ESteamInputType_GenericGamepad = 4,
11935 k_ESteamInputType_PS4Controller = 5,
11936 k_ESteamInputType_AppleMFiController = 6,
11937 k_ESteamInputType_AndroidController = 7,
11938 k_ESteamInputType_SwitchJoyConPair = 8,
11939 k_ESteamInputType_SwitchJoyConSingle = 9,
11940 k_ESteamInputType_SwitchProController = 10,
11941 k_ESteamInputType_MobileTouch = 11,
11942 k_ESteamInputType_PS3Controller = 12,
11943 k_ESteamInputType_PS5Controller = 13,
11944 k_ESteamInputType_SteamDeckController = 14,
11945 k_ESteamInputType_Count = 15,
11946 k_ESteamInputType_MaximumPossibleValue = 255,
11947}
11948#[repr(u32)]
11949#[non_exhaustive]
11950#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11951pub enum ESteamInputConfigurationEnableType {
11952 k_ESteamInputConfigurationEnableType_None = 0,
11953 k_ESteamInputConfigurationEnableType_Playstation = 1,
11954 k_ESteamInputConfigurationEnableType_Xbox = 2,
11955 k_ESteamInputConfigurationEnableType_Generic = 4,
11956 k_ESteamInputConfigurationEnableType_Switch = 8,
11957}
11958#[repr(u32)]
11959#[non_exhaustive]
11960#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11961pub enum ESteamInputLEDFlag {
11962 k_ESteamInputLEDFlag_SetColor = 0,
11963 k_ESteamInputLEDFlag_RestoreUserDefault = 1,
11964}
11965#[repr(u32)]
11966#[non_exhaustive]
11967#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11968pub enum ESteamInputGlyphSize {
11969 k_ESteamInputGlyphSize_Small = 0,
11970 k_ESteamInputGlyphSize_Medium = 1,
11971 k_ESteamInputGlyphSize_Large = 2,
11972 k_ESteamInputGlyphSize_Count = 3,
11973}
11974#[repr(u32)]
11975#[non_exhaustive]
11976#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11977pub enum ESteamInputGlyphStyle {
11978 ESteamInputGlyphStyle_Knockout = 0,
11979 ESteamInputGlyphStyle_Light = 1,
11980 ESteamInputGlyphStyle_Dark = 2,
11981 ESteamInputGlyphStyle_NeutralColorABXY = 16,
11982 ESteamInputGlyphStyle_SolidABXY = 32,
11983}
11984#[repr(u32)]
11985#[non_exhaustive]
11986#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
11987pub enum ESteamInputActionEventType {
11988 ESteamInputActionEventType_DigitalAction = 0,
11989 ESteamInputActionEventType_AnalogAction = 1,
11990}
11991pub type InputHandle_t = uint64;
11992pub type InputActionSetHandle_t = uint64;
11993pub type InputDigitalActionHandle_t = uint64;
11994pub type InputAnalogActionHandle_t = uint64;
11995#[repr(C, packed)]
11996#[derive(Debug, Copy, Clone)]
11997pub struct InputAnalogActionData_t {
11998 pub eMode: EInputSourceMode,
11999 pub x: f32,
12000 pub y: f32,
12001 pub bActive: bool,
12002}
12003#[test]
12004fn bindgen_test_layout_InputAnalogActionData_t() {
12005 const UNINIT: ::std::mem::MaybeUninit<InputAnalogActionData_t> =
12006 ::std::mem::MaybeUninit::uninit();
12007 let ptr = UNINIT.as_ptr();
12008 assert_eq!(
12009 ::std::mem::size_of::<InputAnalogActionData_t>(),
12010 13usize,
12011 concat!("Size of: ", stringify!(InputAnalogActionData_t))
12012 );
12013 assert_eq!(
12014 ::std::mem::align_of::<InputAnalogActionData_t>(),
12015 1usize,
12016 concat!("Alignment of ", stringify!(InputAnalogActionData_t))
12017 );
12018 assert_eq!(
12019 unsafe { ::std::ptr::addr_of!((*ptr).eMode) as usize - ptr as usize },
12020 0usize,
12021 concat!(
12022 "Offset of field: ",
12023 stringify!(InputAnalogActionData_t),
12024 "::",
12025 stringify!(eMode)
12026 )
12027 );
12028 assert_eq!(
12029 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
12030 4usize,
12031 concat!(
12032 "Offset of field: ",
12033 stringify!(InputAnalogActionData_t),
12034 "::",
12035 stringify!(x)
12036 )
12037 );
12038 assert_eq!(
12039 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
12040 8usize,
12041 concat!(
12042 "Offset of field: ",
12043 stringify!(InputAnalogActionData_t),
12044 "::",
12045 stringify!(y)
12046 )
12047 );
12048 assert_eq!(
12049 unsafe { ::std::ptr::addr_of!((*ptr).bActive) as usize - ptr as usize },
12050 12usize,
12051 concat!(
12052 "Offset of field: ",
12053 stringify!(InputAnalogActionData_t),
12054 "::",
12055 stringify!(bActive)
12056 )
12057 );
12058}
12059#[repr(C)]
12060#[derive(Debug, Copy, Clone)]
12061pub struct InputDigitalActionData_t {
12062 pub bState: bool,
12063 pub bActive: bool,
12064}
12065#[test]
12066fn bindgen_test_layout_InputDigitalActionData_t() {
12067 const UNINIT: ::std::mem::MaybeUninit<InputDigitalActionData_t> =
12068 ::std::mem::MaybeUninit::uninit();
12069 let ptr = UNINIT.as_ptr();
12070 assert_eq!(
12071 ::std::mem::size_of::<InputDigitalActionData_t>(),
12072 2usize,
12073 concat!("Size of: ", stringify!(InputDigitalActionData_t))
12074 );
12075 assert_eq!(
12076 ::std::mem::align_of::<InputDigitalActionData_t>(),
12077 1usize,
12078 concat!("Alignment of ", stringify!(InputDigitalActionData_t))
12079 );
12080 assert_eq!(
12081 unsafe { ::std::ptr::addr_of!((*ptr).bState) as usize - ptr as usize },
12082 0usize,
12083 concat!(
12084 "Offset of field: ",
12085 stringify!(InputDigitalActionData_t),
12086 "::",
12087 stringify!(bState)
12088 )
12089 );
12090 assert_eq!(
12091 unsafe { ::std::ptr::addr_of!((*ptr).bActive) as usize - ptr as usize },
12092 1usize,
12093 concat!(
12094 "Offset of field: ",
12095 stringify!(InputDigitalActionData_t),
12096 "::",
12097 stringify!(bActive)
12098 )
12099 );
12100}
12101#[repr(C, packed)]
12102#[derive(Debug, Copy, Clone)]
12103pub struct InputMotionData_t {
12104 pub rotQuatX: f32,
12105 pub rotQuatY: f32,
12106 pub rotQuatZ: f32,
12107 pub rotQuatW: f32,
12108 pub posAccelX: f32,
12109 pub posAccelY: f32,
12110 pub posAccelZ: f32,
12111 pub rotVelX: f32,
12112 pub rotVelY: f32,
12113 pub rotVelZ: f32,
12114}
12115#[test]
12116fn bindgen_test_layout_InputMotionData_t() {
12117 const UNINIT: ::std::mem::MaybeUninit<InputMotionData_t> = ::std::mem::MaybeUninit::uninit();
12118 let ptr = UNINIT.as_ptr();
12119 assert_eq!(
12120 ::std::mem::size_of::<InputMotionData_t>(),
12121 40usize,
12122 concat!("Size of: ", stringify!(InputMotionData_t))
12123 );
12124 assert_eq!(
12125 ::std::mem::align_of::<InputMotionData_t>(),
12126 1usize,
12127 concat!("Alignment of ", stringify!(InputMotionData_t))
12128 );
12129 assert_eq!(
12130 unsafe { ::std::ptr::addr_of!((*ptr).rotQuatX) as usize - ptr as usize },
12131 0usize,
12132 concat!(
12133 "Offset of field: ",
12134 stringify!(InputMotionData_t),
12135 "::",
12136 stringify!(rotQuatX)
12137 )
12138 );
12139 assert_eq!(
12140 unsafe { ::std::ptr::addr_of!((*ptr).rotQuatY) as usize - ptr as usize },
12141 4usize,
12142 concat!(
12143 "Offset of field: ",
12144 stringify!(InputMotionData_t),
12145 "::",
12146 stringify!(rotQuatY)
12147 )
12148 );
12149 assert_eq!(
12150 unsafe { ::std::ptr::addr_of!((*ptr).rotQuatZ) as usize - ptr as usize },
12151 8usize,
12152 concat!(
12153 "Offset of field: ",
12154 stringify!(InputMotionData_t),
12155 "::",
12156 stringify!(rotQuatZ)
12157 )
12158 );
12159 assert_eq!(
12160 unsafe { ::std::ptr::addr_of!((*ptr).rotQuatW) as usize - ptr as usize },
12161 12usize,
12162 concat!(
12163 "Offset of field: ",
12164 stringify!(InputMotionData_t),
12165 "::",
12166 stringify!(rotQuatW)
12167 )
12168 );
12169 assert_eq!(
12170 unsafe { ::std::ptr::addr_of!((*ptr).posAccelX) as usize - ptr as usize },
12171 16usize,
12172 concat!(
12173 "Offset of field: ",
12174 stringify!(InputMotionData_t),
12175 "::",
12176 stringify!(posAccelX)
12177 )
12178 );
12179 assert_eq!(
12180 unsafe { ::std::ptr::addr_of!((*ptr).posAccelY) as usize - ptr as usize },
12181 20usize,
12182 concat!(
12183 "Offset of field: ",
12184 stringify!(InputMotionData_t),
12185 "::",
12186 stringify!(posAccelY)
12187 )
12188 );
12189 assert_eq!(
12190 unsafe { ::std::ptr::addr_of!((*ptr).posAccelZ) as usize - ptr as usize },
12191 24usize,
12192 concat!(
12193 "Offset of field: ",
12194 stringify!(InputMotionData_t),
12195 "::",
12196 stringify!(posAccelZ)
12197 )
12198 );
12199 assert_eq!(
12200 unsafe { ::std::ptr::addr_of!((*ptr).rotVelX) as usize - ptr as usize },
12201 28usize,
12202 concat!(
12203 "Offset of field: ",
12204 stringify!(InputMotionData_t),
12205 "::",
12206 stringify!(rotVelX)
12207 )
12208 );
12209 assert_eq!(
12210 unsafe { ::std::ptr::addr_of!((*ptr).rotVelY) as usize - ptr as usize },
12211 32usize,
12212 concat!(
12213 "Offset of field: ",
12214 stringify!(InputMotionData_t),
12215 "::",
12216 stringify!(rotVelY)
12217 )
12218 );
12219 assert_eq!(
12220 unsafe { ::std::ptr::addr_of!((*ptr).rotVelZ) as usize - ptr as usize },
12221 36usize,
12222 concat!(
12223 "Offset of field: ",
12224 stringify!(InputMotionData_t),
12225 "::",
12226 stringify!(rotVelZ)
12227 )
12228 );
12229}
12230#[repr(C, packed)]
12231#[derive(Copy, Clone)]
12232pub struct SteamInputActionEvent_t {
12233 pub controllerHandle: InputHandle_t,
12234 pub eEventType: ESteamInputActionEventType,
12235 pub __bindgen_anon_1: SteamInputActionEvent_t__bindgen_ty_1,
12236}
12237#[repr(C, packed)]
12238#[derive(Debug, Copy, Clone)]
12239pub struct SteamInputActionEvent_t_AnalogAction_t {
12240 pub actionHandle: InputAnalogActionHandle_t,
12241 pub analogActionData: InputAnalogActionData_t,
12242}
12243#[test]
12244fn bindgen_test_layout_SteamInputActionEvent_t_AnalogAction_t() {
12245 const UNINIT: ::std::mem::MaybeUninit<SteamInputActionEvent_t_AnalogAction_t> =
12246 ::std::mem::MaybeUninit::uninit();
12247 let ptr = UNINIT.as_ptr();
12248 assert_eq!(
12249 ::std::mem::size_of::<SteamInputActionEvent_t_AnalogAction_t>(),
12250 21usize,
12251 concat!(
12252 "Size of: ",
12253 stringify!(SteamInputActionEvent_t_AnalogAction_t)
12254 )
12255 );
12256 assert_eq!(
12257 ::std::mem::align_of::<SteamInputActionEvent_t_AnalogAction_t>(),
12258 1usize,
12259 concat!(
12260 "Alignment of ",
12261 stringify!(SteamInputActionEvent_t_AnalogAction_t)
12262 )
12263 );
12264 assert_eq!(
12265 unsafe { ::std::ptr::addr_of!((*ptr).actionHandle) as usize - ptr as usize },
12266 0usize,
12267 concat!(
12268 "Offset of field: ",
12269 stringify!(SteamInputActionEvent_t_AnalogAction_t),
12270 "::",
12271 stringify!(actionHandle)
12272 )
12273 );
12274 assert_eq!(
12275 unsafe { ::std::ptr::addr_of!((*ptr).analogActionData) as usize - ptr as usize },
12276 8usize,
12277 concat!(
12278 "Offset of field: ",
12279 stringify!(SteamInputActionEvent_t_AnalogAction_t),
12280 "::",
12281 stringify!(analogActionData)
12282 )
12283 );
12284}
12285#[repr(C, packed)]
12286#[derive(Debug, Copy, Clone)]
12287pub struct SteamInputActionEvent_t_DigitalAction_t {
12288 pub actionHandle: InputDigitalActionHandle_t,
12289 pub digitalActionData: InputDigitalActionData_t,
12290}
12291#[test]
12292fn bindgen_test_layout_SteamInputActionEvent_t_DigitalAction_t() {
12293 const UNINIT: ::std::mem::MaybeUninit<SteamInputActionEvent_t_DigitalAction_t> =
12294 ::std::mem::MaybeUninit::uninit();
12295 let ptr = UNINIT.as_ptr();
12296 assert_eq!(
12297 ::std::mem::size_of::<SteamInputActionEvent_t_DigitalAction_t>(),
12298 10usize,
12299 concat!(
12300 "Size of: ",
12301 stringify!(SteamInputActionEvent_t_DigitalAction_t)
12302 )
12303 );
12304 assert_eq!(
12305 ::std::mem::align_of::<SteamInputActionEvent_t_DigitalAction_t>(),
12306 1usize,
12307 concat!(
12308 "Alignment of ",
12309 stringify!(SteamInputActionEvent_t_DigitalAction_t)
12310 )
12311 );
12312 assert_eq!(
12313 unsafe { ::std::ptr::addr_of!((*ptr).actionHandle) as usize - ptr as usize },
12314 0usize,
12315 concat!(
12316 "Offset of field: ",
12317 stringify!(SteamInputActionEvent_t_DigitalAction_t),
12318 "::",
12319 stringify!(actionHandle)
12320 )
12321 );
12322 assert_eq!(
12323 unsafe { ::std::ptr::addr_of!((*ptr).digitalActionData) as usize - ptr as usize },
12324 8usize,
12325 concat!(
12326 "Offset of field: ",
12327 stringify!(SteamInputActionEvent_t_DigitalAction_t),
12328 "::",
12329 stringify!(digitalActionData)
12330 )
12331 );
12332}
12333#[repr(C)]
12334#[derive(Copy, Clone)]
12335pub union SteamInputActionEvent_t__bindgen_ty_1 {
12336 pub analogAction: SteamInputActionEvent_t_AnalogAction_t,
12337 pub digitalAction: SteamInputActionEvent_t_DigitalAction_t,
12338}
12339#[test]
12340fn bindgen_test_layout_SteamInputActionEvent_t__bindgen_ty_1() {
12341 const UNINIT: ::std::mem::MaybeUninit<SteamInputActionEvent_t__bindgen_ty_1> =
12342 ::std::mem::MaybeUninit::uninit();
12343 let ptr = UNINIT.as_ptr();
12344 assert_eq!(
12345 ::std::mem::size_of::<SteamInputActionEvent_t__bindgen_ty_1>(),
12346 21usize,
12347 concat!(
12348 "Size of: ",
12349 stringify!(SteamInputActionEvent_t__bindgen_ty_1)
12350 )
12351 );
12352 assert_eq!(
12353 ::std::mem::align_of::<SteamInputActionEvent_t__bindgen_ty_1>(),
12354 1usize,
12355 concat!(
12356 "Alignment of ",
12357 stringify!(SteamInputActionEvent_t__bindgen_ty_1)
12358 )
12359 );
12360 assert_eq!(
12361 unsafe { ::std::ptr::addr_of!((*ptr).analogAction) as usize - ptr as usize },
12362 0usize,
12363 concat!(
12364 "Offset of field: ",
12365 stringify!(SteamInputActionEvent_t__bindgen_ty_1),
12366 "::",
12367 stringify!(analogAction)
12368 )
12369 );
12370 assert_eq!(
12371 unsafe { ::std::ptr::addr_of!((*ptr).digitalAction) as usize - ptr as usize },
12372 0usize,
12373 concat!(
12374 "Offset of field: ",
12375 stringify!(SteamInputActionEvent_t__bindgen_ty_1),
12376 "::",
12377 stringify!(digitalAction)
12378 )
12379 );
12380}
12381#[test]
12382fn bindgen_test_layout_SteamInputActionEvent_t() {
12383 const UNINIT: ::std::mem::MaybeUninit<SteamInputActionEvent_t> =
12384 ::std::mem::MaybeUninit::uninit();
12385 let ptr = UNINIT.as_ptr();
12386 assert_eq!(
12387 ::std::mem::size_of::<SteamInputActionEvent_t>(),
12388 33usize,
12389 concat!("Size of: ", stringify!(SteamInputActionEvent_t))
12390 );
12391 assert_eq!(
12392 ::std::mem::align_of::<SteamInputActionEvent_t>(),
12393 1usize,
12394 concat!("Alignment of ", stringify!(SteamInputActionEvent_t))
12395 );
12396 assert_eq!(
12397 unsafe { ::std::ptr::addr_of!((*ptr).controllerHandle) as usize - ptr as usize },
12398 0usize,
12399 concat!(
12400 "Offset of field: ",
12401 stringify!(SteamInputActionEvent_t),
12402 "::",
12403 stringify!(controllerHandle)
12404 )
12405 );
12406 assert_eq!(
12407 unsafe { ::std::ptr::addr_of!((*ptr).eEventType) as usize - ptr as usize },
12408 8usize,
12409 concat!(
12410 "Offset of field: ",
12411 stringify!(SteamInputActionEvent_t),
12412 "::",
12413 stringify!(eEventType)
12414 )
12415 );
12416}
12417#[repr(C)]
12418#[derive(Debug, Copy, Clone)]
12419pub struct ScePadTriggerEffectParam {
12420 _unused: [u8; 0],
12421}
12422pub type SteamInputActionEventCallbackPointer =
12423 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamInputActionEvent_t)>;
12424#[repr(C)]
12425pub struct ISteamInput__bindgen_vtable(::std::os::raw::c_void);
12426#[repr(C)]
12427#[derive(Debug, Copy, Clone)]
12428pub struct ISteamInput {
12429 pub vtable_: *const ISteamInput__bindgen_vtable,
12430}
12431#[test]
12432fn bindgen_test_layout_ISteamInput() {
12433 assert_eq!(
12434 ::std::mem::size_of::<ISteamInput>(),
12435 8usize,
12436 concat!("Size of: ", stringify!(ISteamInput))
12437 );
12438 assert_eq!(
12439 ::std::mem::align_of::<ISteamInput>(),
12440 8usize,
12441 concat!("Alignment of ", stringify!(ISteamInput))
12442 );
12443}
12444#[repr(C, packed(4))]
12445#[derive(Debug, Copy, Clone)]
12446pub struct SteamInputDeviceConnected_t {
12447 pub m_ulConnectedDeviceHandle: InputHandle_t,
12448}
12449pub const SteamInputDeviceConnected_t_k_iCallback: SteamInputDeviceConnected_t__bindgen_ty_1 =
12450 SteamInputDeviceConnected_t__bindgen_ty_1::k_iCallback;
12451#[repr(u32)]
12452#[non_exhaustive]
12453#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
12454pub enum SteamInputDeviceConnected_t__bindgen_ty_1 {
12455 k_iCallback = 2801,
12456}
12457#[test]
12458fn bindgen_test_layout_SteamInputDeviceConnected_t() {
12459 const UNINIT: ::std::mem::MaybeUninit<SteamInputDeviceConnected_t> =
12460 ::std::mem::MaybeUninit::uninit();
12461 let ptr = UNINIT.as_ptr();
12462 assert_eq!(
12463 ::std::mem::size_of::<SteamInputDeviceConnected_t>(),
12464 8usize,
12465 concat!("Size of: ", stringify!(SteamInputDeviceConnected_t))
12466 );
12467 assert_eq!(
12468 ::std::mem::align_of::<SteamInputDeviceConnected_t>(),
12469 4usize,
12470 concat!("Alignment of ", stringify!(SteamInputDeviceConnected_t))
12471 );
12472 assert_eq!(
12473 unsafe { ::std::ptr::addr_of!((*ptr).m_ulConnectedDeviceHandle) as usize - ptr as usize },
12474 0usize,
12475 concat!(
12476 "Offset of field: ",
12477 stringify!(SteamInputDeviceConnected_t),
12478 "::",
12479 stringify!(m_ulConnectedDeviceHandle)
12480 )
12481 );
12482}
12483#[repr(C, packed(4))]
12484#[derive(Debug, Copy, Clone)]
12485pub struct SteamInputDeviceDisconnected_t {
12486 pub m_ulDisconnectedDeviceHandle: InputHandle_t,
12487}
12488pub const SteamInputDeviceDisconnected_t_k_iCallback: SteamInputDeviceDisconnected_t__bindgen_ty_1 =
12489 SteamInputDeviceDisconnected_t__bindgen_ty_1::k_iCallback;
12490#[repr(u32)]
12491#[non_exhaustive]
12492#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
12493pub enum SteamInputDeviceDisconnected_t__bindgen_ty_1 {
12494 k_iCallback = 2802,
12495}
12496#[test]
12497fn bindgen_test_layout_SteamInputDeviceDisconnected_t() {
12498 const UNINIT: ::std::mem::MaybeUninit<SteamInputDeviceDisconnected_t> =
12499 ::std::mem::MaybeUninit::uninit();
12500 let ptr = UNINIT.as_ptr();
12501 assert_eq!(
12502 ::std::mem::size_of::<SteamInputDeviceDisconnected_t>(),
12503 8usize,
12504 concat!("Size of: ", stringify!(SteamInputDeviceDisconnected_t))
12505 );
12506 assert_eq!(
12507 ::std::mem::align_of::<SteamInputDeviceDisconnected_t>(),
12508 4usize,
12509 concat!("Alignment of ", stringify!(SteamInputDeviceDisconnected_t))
12510 );
12511 assert_eq!(
12512 unsafe {
12513 ::std::ptr::addr_of!((*ptr).m_ulDisconnectedDeviceHandle) as usize - ptr as usize
12514 },
12515 0usize,
12516 concat!(
12517 "Offset of field: ",
12518 stringify!(SteamInputDeviceDisconnected_t),
12519 "::",
12520 stringify!(m_ulDisconnectedDeviceHandle)
12521 )
12522 );
12523}
12524#[repr(C, packed(4))]
12525#[derive(Copy, Clone)]
12526pub struct SteamInputConfigurationLoaded_t {
12527 pub m_unAppID: AppId_t,
12528 pub m_ulDeviceHandle: InputHandle_t,
12529 pub m_ulMappingCreator: CSteamID,
12530 pub m_unMajorRevision: uint32,
12531 pub m_unMinorRevision: uint32,
12532 pub m_bUsesSteamInputAPI: bool,
12533 pub m_bUsesGamepadAPI: bool,
12534}
12535pub const SteamInputConfigurationLoaded_t_k_iCallback:
12536 SteamInputConfigurationLoaded_t__bindgen_ty_1 =
12537 SteamInputConfigurationLoaded_t__bindgen_ty_1::k_iCallback;
12538#[repr(u32)]
12539#[non_exhaustive]
12540#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
12541pub enum SteamInputConfigurationLoaded_t__bindgen_ty_1 {
12542 k_iCallback = 2803,
12543}
12544#[test]
12545fn bindgen_test_layout_SteamInputConfigurationLoaded_t() {
12546 const UNINIT: ::std::mem::MaybeUninit<SteamInputConfigurationLoaded_t> =
12547 ::std::mem::MaybeUninit::uninit();
12548 let ptr = UNINIT.as_ptr();
12549 assert_eq!(
12550 ::std::mem::size_of::<SteamInputConfigurationLoaded_t>(),
12551 32usize,
12552 concat!("Size of: ", stringify!(SteamInputConfigurationLoaded_t))
12553 );
12554 assert_eq!(
12555 ::std::mem::align_of::<SteamInputConfigurationLoaded_t>(),
12556 4usize,
12557 concat!("Alignment of ", stringify!(SteamInputConfigurationLoaded_t))
12558 );
12559 assert_eq!(
12560 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
12561 0usize,
12562 concat!(
12563 "Offset of field: ",
12564 stringify!(SteamInputConfigurationLoaded_t),
12565 "::",
12566 stringify!(m_unAppID)
12567 )
12568 );
12569 assert_eq!(
12570 unsafe { ::std::ptr::addr_of!((*ptr).m_ulDeviceHandle) as usize - ptr as usize },
12571 4usize,
12572 concat!(
12573 "Offset of field: ",
12574 stringify!(SteamInputConfigurationLoaded_t),
12575 "::",
12576 stringify!(m_ulDeviceHandle)
12577 )
12578 );
12579 assert_eq!(
12580 unsafe { ::std::ptr::addr_of!((*ptr).m_ulMappingCreator) as usize - ptr as usize },
12581 12usize,
12582 concat!(
12583 "Offset of field: ",
12584 stringify!(SteamInputConfigurationLoaded_t),
12585 "::",
12586 stringify!(m_ulMappingCreator)
12587 )
12588 );
12589 assert_eq!(
12590 unsafe { ::std::ptr::addr_of!((*ptr).m_unMajorRevision) as usize - ptr as usize },
12591 20usize,
12592 concat!(
12593 "Offset of field: ",
12594 stringify!(SteamInputConfigurationLoaded_t),
12595 "::",
12596 stringify!(m_unMajorRevision)
12597 )
12598 );
12599 assert_eq!(
12600 unsafe { ::std::ptr::addr_of!((*ptr).m_unMinorRevision) as usize - ptr as usize },
12601 24usize,
12602 concat!(
12603 "Offset of field: ",
12604 stringify!(SteamInputConfigurationLoaded_t),
12605 "::",
12606 stringify!(m_unMinorRevision)
12607 )
12608 );
12609 assert_eq!(
12610 unsafe { ::std::ptr::addr_of!((*ptr).m_bUsesSteamInputAPI) as usize - ptr as usize },
12611 28usize,
12612 concat!(
12613 "Offset of field: ",
12614 stringify!(SteamInputConfigurationLoaded_t),
12615 "::",
12616 stringify!(m_bUsesSteamInputAPI)
12617 )
12618 );
12619 assert_eq!(
12620 unsafe { ::std::ptr::addr_of!((*ptr).m_bUsesGamepadAPI) as usize - ptr as usize },
12621 29usize,
12622 concat!(
12623 "Offset of field: ",
12624 stringify!(SteamInputConfigurationLoaded_t),
12625 "::",
12626 stringify!(m_bUsesGamepadAPI)
12627 )
12628 );
12629}
12630#[repr(C, packed(4))]
12631#[derive(Debug, Copy, Clone)]
12632pub struct SteamInputGamepadSlotChange_t {
12633 pub m_unAppID: AppId_t,
12634 pub m_ulDeviceHandle: InputHandle_t,
12635 pub m_eDeviceType: ESteamInputType,
12636 pub m_nOldGamepadSlot: ::std::os::raw::c_int,
12637 pub m_nNewGamepadSlot: ::std::os::raw::c_int,
12638}
12639pub const SteamInputGamepadSlotChange_t_k_iCallback: SteamInputGamepadSlotChange_t__bindgen_ty_1 =
12640 SteamInputGamepadSlotChange_t__bindgen_ty_1::k_iCallback;
12641#[repr(u32)]
12642#[non_exhaustive]
12643#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
12644pub enum SteamInputGamepadSlotChange_t__bindgen_ty_1 {
12645 k_iCallback = 2804,
12646}
12647#[test]
12648fn bindgen_test_layout_SteamInputGamepadSlotChange_t() {
12649 const UNINIT: ::std::mem::MaybeUninit<SteamInputGamepadSlotChange_t> =
12650 ::std::mem::MaybeUninit::uninit();
12651 let ptr = UNINIT.as_ptr();
12652 assert_eq!(
12653 ::std::mem::size_of::<SteamInputGamepadSlotChange_t>(),
12654 24usize,
12655 concat!("Size of: ", stringify!(SteamInputGamepadSlotChange_t))
12656 );
12657 assert_eq!(
12658 ::std::mem::align_of::<SteamInputGamepadSlotChange_t>(),
12659 4usize,
12660 concat!("Alignment of ", stringify!(SteamInputGamepadSlotChange_t))
12661 );
12662 assert_eq!(
12663 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
12664 0usize,
12665 concat!(
12666 "Offset of field: ",
12667 stringify!(SteamInputGamepadSlotChange_t),
12668 "::",
12669 stringify!(m_unAppID)
12670 )
12671 );
12672 assert_eq!(
12673 unsafe { ::std::ptr::addr_of!((*ptr).m_ulDeviceHandle) as usize - ptr as usize },
12674 4usize,
12675 concat!(
12676 "Offset of field: ",
12677 stringify!(SteamInputGamepadSlotChange_t),
12678 "::",
12679 stringify!(m_ulDeviceHandle)
12680 )
12681 );
12682 assert_eq!(
12683 unsafe { ::std::ptr::addr_of!((*ptr).m_eDeviceType) as usize - ptr as usize },
12684 12usize,
12685 concat!(
12686 "Offset of field: ",
12687 stringify!(SteamInputGamepadSlotChange_t),
12688 "::",
12689 stringify!(m_eDeviceType)
12690 )
12691 );
12692 assert_eq!(
12693 unsafe { ::std::ptr::addr_of!((*ptr).m_nOldGamepadSlot) as usize - ptr as usize },
12694 16usize,
12695 concat!(
12696 "Offset of field: ",
12697 stringify!(SteamInputGamepadSlotChange_t),
12698 "::",
12699 stringify!(m_nOldGamepadSlot)
12700 )
12701 );
12702 assert_eq!(
12703 unsafe { ::std::ptr::addr_of!((*ptr).m_nNewGamepadSlot) as usize - ptr as usize },
12704 20usize,
12705 concat!(
12706 "Offset of field: ",
12707 stringify!(SteamInputGamepadSlotChange_t),
12708 "::",
12709 stringify!(m_nNewGamepadSlot)
12710 )
12711 );
12712}
12713#[repr(u32)]
12714#[non_exhaustive]
12715#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
12716pub enum EControllerActionOrigin {
12717 k_EControllerActionOrigin_None = 0,
12718 k_EControllerActionOrigin_A = 1,
12719 k_EControllerActionOrigin_B = 2,
12720 k_EControllerActionOrigin_X = 3,
12721 k_EControllerActionOrigin_Y = 4,
12722 k_EControllerActionOrigin_LeftBumper = 5,
12723 k_EControllerActionOrigin_RightBumper = 6,
12724 k_EControllerActionOrigin_LeftGrip = 7,
12725 k_EControllerActionOrigin_RightGrip = 8,
12726 k_EControllerActionOrigin_Start = 9,
12727 k_EControllerActionOrigin_Back = 10,
12728 k_EControllerActionOrigin_LeftPad_Touch = 11,
12729 k_EControllerActionOrigin_LeftPad_Swipe = 12,
12730 k_EControllerActionOrigin_LeftPad_Click = 13,
12731 k_EControllerActionOrigin_LeftPad_DPadNorth = 14,
12732 k_EControllerActionOrigin_LeftPad_DPadSouth = 15,
12733 k_EControllerActionOrigin_LeftPad_DPadWest = 16,
12734 k_EControllerActionOrigin_LeftPad_DPadEast = 17,
12735 k_EControllerActionOrigin_RightPad_Touch = 18,
12736 k_EControllerActionOrigin_RightPad_Swipe = 19,
12737 k_EControllerActionOrigin_RightPad_Click = 20,
12738 k_EControllerActionOrigin_RightPad_DPadNorth = 21,
12739 k_EControllerActionOrigin_RightPad_DPadSouth = 22,
12740 k_EControllerActionOrigin_RightPad_DPadWest = 23,
12741 k_EControllerActionOrigin_RightPad_DPadEast = 24,
12742 k_EControllerActionOrigin_LeftTrigger_Pull = 25,
12743 k_EControllerActionOrigin_LeftTrigger_Click = 26,
12744 k_EControllerActionOrigin_RightTrigger_Pull = 27,
12745 k_EControllerActionOrigin_RightTrigger_Click = 28,
12746 k_EControllerActionOrigin_LeftStick_Move = 29,
12747 k_EControllerActionOrigin_LeftStick_Click = 30,
12748 k_EControllerActionOrigin_LeftStick_DPadNorth = 31,
12749 k_EControllerActionOrigin_LeftStick_DPadSouth = 32,
12750 k_EControllerActionOrigin_LeftStick_DPadWest = 33,
12751 k_EControllerActionOrigin_LeftStick_DPadEast = 34,
12752 k_EControllerActionOrigin_Gyro_Move = 35,
12753 k_EControllerActionOrigin_Gyro_Pitch = 36,
12754 k_EControllerActionOrigin_Gyro_Yaw = 37,
12755 k_EControllerActionOrigin_Gyro_Roll = 38,
12756 k_EControllerActionOrigin_PS4_X = 39,
12757 k_EControllerActionOrigin_PS4_Circle = 40,
12758 k_EControllerActionOrigin_PS4_Triangle = 41,
12759 k_EControllerActionOrigin_PS4_Square = 42,
12760 k_EControllerActionOrigin_PS4_LeftBumper = 43,
12761 k_EControllerActionOrigin_PS4_RightBumper = 44,
12762 k_EControllerActionOrigin_PS4_Options = 45,
12763 k_EControllerActionOrigin_PS4_Share = 46,
12764 k_EControllerActionOrigin_PS4_LeftPad_Touch = 47,
12765 k_EControllerActionOrigin_PS4_LeftPad_Swipe = 48,
12766 k_EControllerActionOrigin_PS4_LeftPad_Click = 49,
12767 k_EControllerActionOrigin_PS4_LeftPad_DPadNorth = 50,
12768 k_EControllerActionOrigin_PS4_LeftPad_DPadSouth = 51,
12769 k_EControllerActionOrigin_PS4_LeftPad_DPadWest = 52,
12770 k_EControllerActionOrigin_PS4_LeftPad_DPadEast = 53,
12771 k_EControllerActionOrigin_PS4_RightPad_Touch = 54,
12772 k_EControllerActionOrigin_PS4_RightPad_Swipe = 55,
12773 k_EControllerActionOrigin_PS4_RightPad_Click = 56,
12774 k_EControllerActionOrigin_PS4_RightPad_DPadNorth = 57,
12775 k_EControllerActionOrigin_PS4_RightPad_DPadSouth = 58,
12776 k_EControllerActionOrigin_PS4_RightPad_DPadWest = 59,
12777 k_EControllerActionOrigin_PS4_RightPad_DPadEast = 60,
12778 k_EControllerActionOrigin_PS4_CenterPad_Touch = 61,
12779 k_EControllerActionOrigin_PS4_CenterPad_Swipe = 62,
12780 k_EControllerActionOrigin_PS4_CenterPad_Click = 63,
12781 k_EControllerActionOrigin_PS4_CenterPad_DPadNorth = 64,
12782 k_EControllerActionOrigin_PS4_CenterPad_DPadSouth = 65,
12783 k_EControllerActionOrigin_PS4_CenterPad_DPadWest = 66,
12784 k_EControllerActionOrigin_PS4_CenterPad_DPadEast = 67,
12785 k_EControllerActionOrigin_PS4_LeftTrigger_Pull = 68,
12786 k_EControllerActionOrigin_PS4_LeftTrigger_Click = 69,
12787 k_EControllerActionOrigin_PS4_RightTrigger_Pull = 70,
12788 k_EControllerActionOrigin_PS4_RightTrigger_Click = 71,
12789 k_EControllerActionOrigin_PS4_LeftStick_Move = 72,
12790 k_EControllerActionOrigin_PS4_LeftStick_Click = 73,
12791 k_EControllerActionOrigin_PS4_LeftStick_DPadNorth = 74,
12792 k_EControllerActionOrigin_PS4_LeftStick_DPadSouth = 75,
12793 k_EControllerActionOrigin_PS4_LeftStick_DPadWest = 76,
12794 k_EControllerActionOrigin_PS4_LeftStick_DPadEast = 77,
12795 k_EControllerActionOrigin_PS4_RightStick_Move = 78,
12796 k_EControllerActionOrigin_PS4_RightStick_Click = 79,
12797 k_EControllerActionOrigin_PS4_RightStick_DPadNorth = 80,
12798 k_EControllerActionOrigin_PS4_RightStick_DPadSouth = 81,
12799 k_EControllerActionOrigin_PS4_RightStick_DPadWest = 82,
12800 k_EControllerActionOrigin_PS4_RightStick_DPadEast = 83,
12801 k_EControllerActionOrigin_PS4_DPad_North = 84,
12802 k_EControllerActionOrigin_PS4_DPad_South = 85,
12803 k_EControllerActionOrigin_PS4_DPad_West = 86,
12804 k_EControllerActionOrigin_PS4_DPad_East = 87,
12805 k_EControllerActionOrigin_PS4_Gyro_Move = 88,
12806 k_EControllerActionOrigin_PS4_Gyro_Pitch = 89,
12807 k_EControllerActionOrigin_PS4_Gyro_Yaw = 90,
12808 k_EControllerActionOrigin_PS4_Gyro_Roll = 91,
12809 k_EControllerActionOrigin_XBoxOne_A = 92,
12810 k_EControllerActionOrigin_XBoxOne_B = 93,
12811 k_EControllerActionOrigin_XBoxOne_X = 94,
12812 k_EControllerActionOrigin_XBoxOne_Y = 95,
12813 k_EControllerActionOrigin_XBoxOne_LeftBumper = 96,
12814 k_EControllerActionOrigin_XBoxOne_RightBumper = 97,
12815 k_EControllerActionOrigin_XBoxOne_Menu = 98,
12816 k_EControllerActionOrigin_XBoxOne_View = 99,
12817 k_EControllerActionOrigin_XBoxOne_LeftTrigger_Pull = 100,
12818 k_EControllerActionOrigin_XBoxOne_LeftTrigger_Click = 101,
12819 k_EControllerActionOrigin_XBoxOne_RightTrigger_Pull = 102,
12820 k_EControllerActionOrigin_XBoxOne_RightTrigger_Click = 103,
12821 k_EControllerActionOrigin_XBoxOne_LeftStick_Move = 104,
12822 k_EControllerActionOrigin_XBoxOne_LeftStick_Click = 105,
12823 k_EControllerActionOrigin_XBoxOne_LeftStick_DPadNorth = 106,
12824 k_EControllerActionOrigin_XBoxOne_LeftStick_DPadSouth = 107,
12825 k_EControllerActionOrigin_XBoxOne_LeftStick_DPadWest = 108,
12826 k_EControllerActionOrigin_XBoxOne_LeftStick_DPadEast = 109,
12827 k_EControllerActionOrigin_XBoxOne_RightStick_Move = 110,
12828 k_EControllerActionOrigin_XBoxOne_RightStick_Click = 111,
12829 k_EControllerActionOrigin_XBoxOne_RightStick_DPadNorth = 112,
12830 k_EControllerActionOrigin_XBoxOne_RightStick_DPadSouth = 113,
12831 k_EControllerActionOrigin_XBoxOne_RightStick_DPadWest = 114,
12832 k_EControllerActionOrigin_XBoxOne_RightStick_DPadEast = 115,
12833 k_EControllerActionOrigin_XBoxOne_DPad_North = 116,
12834 k_EControllerActionOrigin_XBoxOne_DPad_South = 117,
12835 k_EControllerActionOrigin_XBoxOne_DPad_West = 118,
12836 k_EControllerActionOrigin_XBoxOne_DPad_East = 119,
12837 k_EControllerActionOrigin_XBox360_A = 120,
12838 k_EControllerActionOrigin_XBox360_B = 121,
12839 k_EControllerActionOrigin_XBox360_X = 122,
12840 k_EControllerActionOrigin_XBox360_Y = 123,
12841 k_EControllerActionOrigin_XBox360_LeftBumper = 124,
12842 k_EControllerActionOrigin_XBox360_RightBumper = 125,
12843 k_EControllerActionOrigin_XBox360_Start = 126,
12844 k_EControllerActionOrigin_XBox360_Back = 127,
12845 k_EControllerActionOrigin_XBox360_LeftTrigger_Pull = 128,
12846 k_EControllerActionOrigin_XBox360_LeftTrigger_Click = 129,
12847 k_EControllerActionOrigin_XBox360_RightTrigger_Pull = 130,
12848 k_EControllerActionOrigin_XBox360_RightTrigger_Click = 131,
12849 k_EControllerActionOrigin_XBox360_LeftStick_Move = 132,
12850 k_EControllerActionOrigin_XBox360_LeftStick_Click = 133,
12851 k_EControllerActionOrigin_XBox360_LeftStick_DPadNorth = 134,
12852 k_EControllerActionOrigin_XBox360_LeftStick_DPadSouth = 135,
12853 k_EControllerActionOrigin_XBox360_LeftStick_DPadWest = 136,
12854 k_EControllerActionOrigin_XBox360_LeftStick_DPadEast = 137,
12855 k_EControllerActionOrigin_XBox360_RightStick_Move = 138,
12856 k_EControllerActionOrigin_XBox360_RightStick_Click = 139,
12857 k_EControllerActionOrigin_XBox360_RightStick_DPadNorth = 140,
12858 k_EControllerActionOrigin_XBox360_RightStick_DPadSouth = 141,
12859 k_EControllerActionOrigin_XBox360_RightStick_DPadWest = 142,
12860 k_EControllerActionOrigin_XBox360_RightStick_DPadEast = 143,
12861 k_EControllerActionOrigin_XBox360_DPad_North = 144,
12862 k_EControllerActionOrigin_XBox360_DPad_South = 145,
12863 k_EControllerActionOrigin_XBox360_DPad_West = 146,
12864 k_EControllerActionOrigin_XBox360_DPad_East = 147,
12865 k_EControllerActionOrigin_SteamV2_A = 148,
12866 k_EControllerActionOrigin_SteamV2_B = 149,
12867 k_EControllerActionOrigin_SteamV2_X = 150,
12868 k_EControllerActionOrigin_SteamV2_Y = 151,
12869 k_EControllerActionOrigin_SteamV2_LeftBumper = 152,
12870 k_EControllerActionOrigin_SteamV2_RightBumper = 153,
12871 k_EControllerActionOrigin_SteamV2_LeftGrip_Lower = 154,
12872 k_EControllerActionOrigin_SteamV2_LeftGrip_Upper = 155,
12873 k_EControllerActionOrigin_SteamV2_RightGrip_Lower = 156,
12874 k_EControllerActionOrigin_SteamV2_RightGrip_Upper = 157,
12875 k_EControllerActionOrigin_SteamV2_LeftBumper_Pressure = 158,
12876 k_EControllerActionOrigin_SteamV2_RightBumper_Pressure = 159,
12877 k_EControllerActionOrigin_SteamV2_LeftGrip_Pressure = 160,
12878 k_EControllerActionOrigin_SteamV2_RightGrip_Pressure = 161,
12879 k_EControllerActionOrigin_SteamV2_LeftGrip_Upper_Pressure = 162,
12880 k_EControllerActionOrigin_SteamV2_RightGrip_Upper_Pressure = 163,
12881 k_EControllerActionOrigin_SteamV2_Start = 164,
12882 k_EControllerActionOrigin_SteamV2_Back = 165,
12883 k_EControllerActionOrigin_SteamV2_LeftPad_Touch = 166,
12884 k_EControllerActionOrigin_SteamV2_LeftPad_Swipe = 167,
12885 k_EControllerActionOrigin_SteamV2_LeftPad_Click = 168,
12886 k_EControllerActionOrigin_SteamV2_LeftPad_Pressure = 169,
12887 k_EControllerActionOrigin_SteamV2_LeftPad_DPadNorth = 170,
12888 k_EControllerActionOrigin_SteamV2_LeftPad_DPadSouth = 171,
12889 k_EControllerActionOrigin_SteamV2_LeftPad_DPadWest = 172,
12890 k_EControllerActionOrigin_SteamV2_LeftPad_DPadEast = 173,
12891 k_EControllerActionOrigin_SteamV2_RightPad_Touch = 174,
12892 k_EControllerActionOrigin_SteamV2_RightPad_Swipe = 175,
12893 k_EControllerActionOrigin_SteamV2_RightPad_Click = 176,
12894 k_EControllerActionOrigin_SteamV2_RightPad_Pressure = 177,
12895 k_EControllerActionOrigin_SteamV2_RightPad_DPadNorth = 178,
12896 k_EControllerActionOrigin_SteamV2_RightPad_DPadSouth = 179,
12897 k_EControllerActionOrigin_SteamV2_RightPad_DPadWest = 180,
12898 k_EControllerActionOrigin_SteamV2_RightPad_DPadEast = 181,
12899 k_EControllerActionOrigin_SteamV2_LeftTrigger_Pull = 182,
12900 k_EControllerActionOrigin_SteamV2_LeftTrigger_Click = 183,
12901 k_EControllerActionOrigin_SteamV2_RightTrigger_Pull = 184,
12902 k_EControllerActionOrigin_SteamV2_RightTrigger_Click = 185,
12903 k_EControllerActionOrigin_SteamV2_LeftStick_Move = 186,
12904 k_EControllerActionOrigin_SteamV2_LeftStick_Click = 187,
12905 k_EControllerActionOrigin_SteamV2_LeftStick_DPadNorth = 188,
12906 k_EControllerActionOrigin_SteamV2_LeftStick_DPadSouth = 189,
12907 k_EControllerActionOrigin_SteamV2_LeftStick_DPadWest = 190,
12908 k_EControllerActionOrigin_SteamV2_LeftStick_DPadEast = 191,
12909 k_EControllerActionOrigin_SteamV2_Gyro_Move = 192,
12910 k_EControllerActionOrigin_SteamV2_Gyro_Pitch = 193,
12911 k_EControllerActionOrigin_SteamV2_Gyro_Yaw = 194,
12912 k_EControllerActionOrigin_SteamV2_Gyro_Roll = 195,
12913 k_EControllerActionOrigin_Switch_A = 196,
12914 k_EControllerActionOrigin_Switch_B = 197,
12915 k_EControllerActionOrigin_Switch_X = 198,
12916 k_EControllerActionOrigin_Switch_Y = 199,
12917 k_EControllerActionOrigin_Switch_LeftBumper = 200,
12918 k_EControllerActionOrigin_Switch_RightBumper = 201,
12919 k_EControllerActionOrigin_Switch_Plus = 202,
12920 k_EControllerActionOrigin_Switch_Minus = 203,
12921 k_EControllerActionOrigin_Switch_Capture = 204,
12922 k_EControllerActionOrigin_Switch_LeftTrigger_Pull = 205,
12923 k_EControllerActionOrigin_Switch_LeftTrigger_Click = 206,
12924 k_EControllerActionOrigin_Switch_RightTrigger_Pull = 207,
12925 k_EControllerActionOrigin_Switch_RightTrigger_Click = 208,
12926 k_EControllerActionOrigin_Switch_LeftStick_Move = 209,
12927 k_EControllerActionOrigin_Switch_LeftStick_Click = 210,
12928 k_EControllerActionOrigin_Switch_LeftStick_DPadNorth = 211,
12929 k_EControllerActionOrigin_Switch_LeftStick_DPadSouth = 212,
12930 k_EControllerActionOrigin_Switch_LeftStick_DPadWest = 213,
12931 k_EControllerActionOrigin_Switch_LeftStick_DPadEast = 214,
12932 k_EControllerActionOrigin_Switch_RightStick_Move = 215,
12933 k_EControllerActionOrigin_Switch_RightStick_Click = 216,
12934 k_EControllerActionOrigin_Switch_RightStick_DPadNorth = 217,
12935 k_EControllerActionOrigin_Switch_RightStick_DPadSouth = 218,
12936 k_EControllerActionOrigin_Switch_RightStick_DPadWest = 219,
12937 k_EControllerActionOrigin_Switch_RightStick_DPadEast = 220,
12938 k_EControllerActionOrigin_Switch_DPad_North = 221,
12939 k_EControllerActionOrigin_Switch_DPad_South = 222,
12940 k_EControllerActionOrigin_Switch_DPad_West = 223,
12941 k_EControllerActionOrigin_Switch_DPad_East = 224,
12942 k_EControllerActionOrigin_Switch_ProGyro_Move = 225,
12943 k_EControllerActionOrigin_Switch_ProGyro_Pitch = 226,
12944 k_EControllerActionOrigin_Switch_ProGyro_Yaw = 227,
12945 k_EControllerActionOrigin_Switch_ProGyro_Roll = 228,
12946 k_EControllerActionOrigin_Switch_RightGyro_Move = 229,
12947 k_EControllerActionOrigin_Switch_RightGyro_Pitch = 230,
12948 k_EControllerActionOrigin_Switch_RightGyro_Yaw = 231,
12949 k_EControllerActionOrigin_Switch_RightGyro_Roll = 232,
12950 k_EControllerActionOrigin_Switch_LeftGyro_Move = 233,
12951 k_EControllerActionOrigin_Switch_LeftGyro_Pitch = 234,
12952 k_EControllerActionOrigin_Switch_LeftGyro_Yaw = 235,
12953 k_EControllerActionOrigin_Switch_LeftGyro_Roll = 236,
12954 k_EControllerActionOrigin_Switch_LeftGrip_Lower = 237,
12955 k_EControllerActionOrigin_Switch_LeftGrip_Upper = 238,
12956 k_EControllerActionOrigin_Switch_RightGrip_Lower = 239,
12957 k_EControllerActionOrigin_Switch_RightGrip_Upper = 240,
12958 k_EControllerActionOrigin_PS4_DPad_Move = 241,
12959 k_EControllerActionOrigin_XBoxOne_DPad_Move = 242,
12960 k_EControllerActionOrigin_XBox360_DPad_Move = 243,
12961 k_EControllerActionOrigin_Switch_DPad_Move = 244,
12962 k_EControllerActionOrigin_PS5_X = 245,
12963 k_EControllerActionOrigin_PS5_Circle = 246,
12964 k_EControllerActionOrigin_PS5_Triangle = 247,
12965 k_EControllerActionOrigin_PS5_Square = 248,
12966 k_EControllerActionOrigin_PS5_LeftBumper = 249,
12967 k_EControllerActionOrigin_PS5_RightBumper = 250,
12968 k_EControllerActionOrigin_PS5_Option = 251,
12969 k_EControllerActionOrigin_PS5_Create = 252,
12970 k_EControllerActionOrigin_PS5_Mute = 253,
12971 k_EControllerActionOrigin_PS5_LeftPad_Touch = 254,
12972 k_EControllerActionOrigin_PS5_LeftPad_Swipe = 255,
12973 k_EControllerActionOrigin_PS5_LeftPad_Click = 256,
12974 k_EControllerActionOrigin_PS5_LeftPad_DPadNorth = 257,
12975 k_EControllerActionOrigin_PS5_LeftPad_DPadSouth = 258,
12976 k_EControllerActionOrigin_PS5_LeftPad_DPadWest = 259,
12977 k_EControllerActionOrigin_PS5_LeftPad_DPadEast = 260,
12978 k_EControllerActionOrigin_PS5_RightPad_Touch = 261,
12979 k_EControllerActionOrigin_PS5_RightPad_Swipe = 262,
12980 k_EControllerActionOrigin_PS5_RightPad_Click = 263,
12981 k_EControllerActionOrigin_PS5_RightPad_DPadNorth = 264,
12982 k_EControllerActionOrigin_PS5_RightPad_DPadSouth = 265,
12983 k_EControllerActionOrigin_PS5_RightPad_DPadWest = 266,
12984 k_EControllerActionOrigin_PS5_RightPad_DPadEast = 267,
12985 k_EControllerActionOrigin_PS5_CenterPad_Touch = 268,
12986 k_EControllerActionOrigin_PS5_CenterPad_Swipe = 269,
12987 k_EControllerActionOrigin_PS5_CenterPad_Click = 270,
12988 k_EControllerActionOrigin_PS5_CenterPad_DPadNorth = 271,
12989 k_EControllerActionOrigin_PS5_CenterPad_DPadSouth = 272,
12990 k_EControllerActionOrigin_PS5_CenterPad_DPadWest = 273,
12991 k_EControllerActionOrigin_PS5_CenterPad_DPadEast = 274,
12992 k_EControllerActionOrigin_PS5_LeftTrigger_Pull = 275,
12993 k_EControllerActionOrigin_PS5_LeftTrigger_Click = 276,
12994 k_EControllerActionOrigin_PS5_RightTrigger_Pull = 277,
12995 k_EControllerActionOrigin_PS5_RightTrigger_Click = 278,
12996 k_EControllerActionOrigin_PS5_LeftStick_Move = 279,
12997 k_EControllerActionOrigin_PS5_LeftStick_Click = 280,
12998 k_EControllerActionOrigin_PS5_LeftStick_DPadNorth = 281,
12999 k_EControllerActionOrigin_PS5_LeftStick_DPadSouth = 282,
13000 k_EControllerActionOrigin_PS5_LeftStick_DPadWest = 283,
13001 k_EControllerActionOrigin_PS5_LeftStick_DPadEast = 284,
13002 k_EControllerActionOrigin_PS5_RightStick_Move = 285,
13003 k_EControllerActionOrigin_PS5_RightStick_Click = 286,
13004 k_EControllerActionOrigin_PS5_RightStick_DPadNorth = 287,
13005 k_EControllerActionOrigin_PS5_RightStick_DPadSouth = 288,
13006 k_EControllerActionOrigin_PS5_RightStick_DPadWest = 289,
13007 k_EControllerActionOrigin_PS5_RightStick_DPadEast = 290,
13008 k_EControllerActionOrigin_PS5_DPad_Move = 291,
13009 k_EControllerActionOrigin_PS5_DPad_North = 292,
13010 k_EControllerActionOrigin_PS5_DPad_South = 293,
13011 k_EControllerActionOrigin_PS5_DPad_West = 294,
13012 k_EControllerActionOrigin_PS5_DPad_East = 295,
13013 k_EControllerActionOrigin_PS5_Gyro_Move = 296,
13014 k_EControllerActionOrigin_PS5_Gyro_Pitch = 297,
13015 k_EControllerActionOrigin_PS5_Gyro_Yaw = 298,
13016 k_EControllerActionOrigin_PS5_Gyro_Roll = 299,
13017 k_EControllerActionOrigin_XBoxOne_LeftGrip_Lower = 300,
13018 k_EControllerActionOrigin_XBoxOne_LeftGrip_Upper = 301,
13019 k_EControllerActionOrigin_XBoxOne_RightGrip_Lower = 302,
13020 k_EControllerActionOrigin_XBoxOne_RightGrip_Upper = 303,
13021 k_EControllerActionOrigin_XBoxOne_Share = 304,
13022 k_EControllerActionOrigin_SteamDeck_A = 305,
13023 k_EControllerActionOrigin_SteamDeck_B = 306,
13024 k_EControllerActionOrigin_SteamDeck_X = 307,
13025 k_EControllerActionOrigin_SteamDeck_Y = 308,
13026 k_EControllerActionOrigin_SteamDeck_L1 = 309,
13027 k_EControllerActionOrigin_SteamDeck_R1 = 310,
13028 k_EControllerActionOrigin_SteamDeck_Menu = 311,
13029 k_EControllerActionOrigin_SteamDeck_View = 312,
13030 k_EControllerActionOrigin_SteamDeck_LeftPad_Touch = 313,
13031 k_EControllerActionOrigin_SteamDeck_LeftPad_Swipe = 314,
13032 k_EControllerActionOrigin_SteamDeck_LeftPad_Click = 315,
13033 k_EControllerActionOrigin_SteamDeck_LeftPad_DPadNorth = 316,
13034 k_EControllerActionOrigin_SteamDeck_LeftPad_DPadSouth = 317,
13035 k_EControllerActionOrigin_SteamDeck_LeftPad_DPadWest = 318,
13036 k_EControllerActionOrigin_SteamDeck_LeftPad_DPadEast = 319,
13037 k_EControllerActionOrigin_SteamDeck_RightPad_Touch = 320,
13038 k_EControllerActionOrigin_SteamDeck_RightPad_Swipe = 321,
13039 k_EControllerActionOrigin_SteamDeck_RightPad_Click = 322,
13040 k_EControllerActionOrigin_SteamDeck_RightPad_DPadNorth = 323,
13041 k_EControllerActionOrigin_SteamDeck_RightPad_DPadSouth = 324,
13042 k_EControllerActionOrigin_SteamDeck_RightPad_DPadWest = 325,
13043 k_EControllerActionOrigin_SteamDeck_RightPad_DPadEast = 326,
13044 k_EControllerActionOrigin_SteamDeck_L2_SoftPull = 327,
13045 k_EControllerActionOrigin_SteamDeck_L2 = 328,
13046 k_EControllerActionOrigin_SteamDeck_R2_SoftPull = 329,
13047 k_EControllerActionOrigin_SteamDeck_R2 = 330,
13048 k_EControllerActionOrigin_SteamDeck_LeftStick_Move = 331,
13049 k_EControllerActionOrigin_SteamDeck_L3 = 332,
13050 k_EControllerActionOrigin_SteamDeck_LeftStick_DPadNorth = 333,
13051 k_EControllerActionOrigin_SteamDeck_LeftStick_DPadSouth = 334,
13052 k_EControllerActionOrigin_SteamDeck_LeftStick_DPadWest = 335,
13053 k_EControllerActionOrigin_SteamDeck_LeftStick_DPadEast = 336,
13054 k_EControllerActionOrigin_SteamDeck_LeftStick_Touch = 337,
13055 k_EControllerActionOrigin_SteamDeck_RightStick_Move = 338,
13056 k_EControllerActionOrigin_SteamDeck_R3 = 339,
13057 k_EControllerActionOrigin_SteamDeck_RightStick_DPadNorth = 340,
13058 k_EControllerActionOrigin_SteamDeck_RightStick_DPadSouth = 341,
13059 k_EControllerActionOrigin_SteamDeck_RightStick_DPadWest = 342,
13060 k_EControllerActionOrigin_SteamDeck_RightStick_DPadEast = 343,
13061 k_EControllerActionOrigin_SteamDeck_RightStick_Touch = 344,
13062 k_EControllerActionOrigin_SteamDeck_L4 = 345,
13063 k_EControllerActionOrigin_SteamDeck_R4 = 346,
13064 k_EControllerActionOrigin_SteamDeck_L5 = 347,
13065 k_EControllerActionOrigin_SteamDeck_R5 = 348,
13066 k_EControllerActionOrigin_SteamDeck_DPad_Move = 349,
13067 k_EControllerActionOrigin_SteamDeck_DPad_North = 350,
13068 k_EControllerActionOrigin_SteamDeck_DPad_South = 351,
13069 k_EControllerActionOrigin_SteamDeck_DPad_West = 352,
13070 k_EControllerActionOrigin_SteamDeck_DPad_East = 353,
13071 k_EControllerActionOrigin_SteamDeck_Gyro_Move = 354,
13072 k_EControllerActionOrigin_SteamDeck_Gyro_Pitch = 355,
13073 k_EControllerActionOrigin_SteamDeck_Gyro_Yaw = 356,
13074 k_EControllerActionOrigin_SteamDeck_Gyro_Roll = 357,
13075 k_EControllerActionOrigin_SteamDeck_Reserved1 = 358,
13076 k_EControllerActionOrigin_SteamDeck_Reserved2 = 359,
13077 k_EControllerActionOrigin_SteamDeck_Reserved3 = 360,
13078 k_EControllerActionOrigin_SteamDeck_Reserved4 = 361,
13079 k_EControllerActionOrigin_SteamDeck_Reserved5 = 362,
13080 k_EControllerActionOrigin_SteamDeck_Reserved6 = 363,
13081 k_EControllerActionOrigin_SteamDeck_Reserved7 = 364,
13082 k_EControllerActionOrigin_SteamDeck_Reserved8 = 365,
13083 k_EControllerActionOrigin_SteamDeck_Reserved9 = 366,
13084 k_EControllerActionOrigin_SteamDeck_Reserved10 = 367,
13085 k_EControllerActionOrigin_SteamDeck_Reserved11 = 368,
13086 k_EControllerActionOrigin_SteamDeck_Reserved12 = 369,
13087 k_EControllerActionOrigin_SteamDeck_Reserved13 = 370,
13088 k_EControllerActionOrigin_SteamDeck_Reserved14 = 371,
13089 k_EControllerActionOrigin_SteamDeck_Reserved15 = 372,
13090 k_EControllerActionOrigin_SteamDeck_Reserved16 = 373,
13091 k_EControllerActionOrigin_SteamDeck_Reserved17 = 374,
13092 k_EControllerActionOrigin_SteamDeck_Reserved18 = 375,
13093 k_EControllerActionOrigin_SteamDeck_Reserved19 = 376,
13094 k_EControllerActionOrigin_SteamDeck_Reserved20 = 377,
13095 k_EControllerActionOrigin_Switch_JoyConButton_N = 378,
13096 k_EControllerActionOrigin_Switch_JoyConButton_E = 379,
13097 k_EControllerActionOrigin_Switch_JoyConButton_S = 380,
13098 k_EControllerActionOrigin_Switch_JoyConButton_W = 381,
13099 k_EControllerActionOrigin_PS5_LeftGrip = 382,
13100 k_EControllerActionOrigin_PS5_RightGrip = 383,
13101 k_EControllerActionOrigin_PS5_LeftFn = 384,
13102 k_EControllerActionOrigin_PS5_RightFn = 385,
13103 k_EControllerActionOrigin_Horipad_M1 = 386,
13104 k_EControllerActionOrigin_Horipad_M2 = 387,
13105 k_EControllerActionOrigin_Horipad_L4 = 388,
13106 k_EControllerActionOrigin_Horipad_R4 = 389,
13107 k_EControllerActionOrigin_LenovoLegionGo_A = 390,
13108 k_EControllerActionOrigin_LenovoLegionGo_B = 391,
13109 k_EControllerActionOrigin_LenovoLegionGo_X = 392,
13110 k_EControllerActionOrigin_LenovoLegionGo_Y = 393,
13111 k_EControllerActionOrigin_LenovoLegionGo_LB = 394,
13112 k_EControllerActionOrigin_LenovoLegionGo_RB = 395,
13113 k_EControllerActionOrigin_LenovoLegionGo_Menu = 396,
13114 k_EControllerActionOrigin_LenovoLegionGo_View = 397,
13115 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_Touch = 398,
13116 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_Swipe = 399,
13117 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_Click = 400,
13118 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_DPadNorth = 401,
13119 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_DPadSouth = 402,
13120 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_DPadWest = 403,
13121 k_EControllerActionOrigin_LenovoLegionGo_LeftPad_DPadEast = 404,
13122 k_EControllerActionOrigin_LenovoLegionGo_RightPad_Touch = 405,
13123 k_EControllerActionOrigin_LenovoLegionGo_RightPad_Swipe = 406,
13124 k_EControllerActionOrigin_LenovoLegionGo_RightPad_Click = 407,
13125 k_EControllerActionOrigin_LenovoLegionGo_RightPad_DPadNorth = 408,
13126 k_EControllerActionOrigin_LenovoLegionGo_RightPad_DPadSouth = 409,
13127 k_EControllerActionOrigin_LenovoLegionGo_RightPad_DPadWest = 410,
13128 k_EControllerActionOrigin_LenovoLegionGo_RightPad_DPadEast = 411,
13129 k_EControllerActionOrigin_LenovoLegionGo_LT_SoftPull = 412,
13130 k_EControllerActionOrigin_LenovoLegionGo_LT = 413,
13131 k_EControllerActionOrigin_LenovoLegionGo_RT_SoftPull = 414,
13132 k_EControllerActionOrigin_LenovoLegionGo_RT = 415,
13133 k_EControllerActionOrigin_LenovoLegionGo_LeftStick_Move = 416,
13134 k_EControllerActionOrigin_LenovoLegionGo_LS = 417,
13135 k_EControllerActionOrigin_LenovoLegionGo_LeftStick_DPadNorth = 418,
13136 k_EControllerActionOrigin_LenovoLegionGo_LeftStick_DPadSouth = 419,
13137 k_EControllerActionOrigin_LenovoLegionGo_LeftStick_DPadWest = 420,
13138 k_EControllerActionOrigin_LenovoLegionGo_LeftStick_DPadEast = 421,
13139 k_EControllerActionOrigin_LenovoLegionGo_RightStick_Move = 422,
13140 k_EControllerActionOrigin_LenovoLegionGo_RS = 423,
13141 k_EControllerActionOrigin_LenovoLegionGo_RightStick_DPadNorth = 424,
13142 k_EControllerActionOrigin_LenovoLegionGo_RightStick_DPadSouth = 425,
13143 k_EControllerActionOrigin_LenovoLegionGo_RightStick_DPadWest = 426,
13144 k_EControllerActionOrigin_LenovoLegionGo_RightStick_DPadEast = 427,
13145 k_EControllerActionOrigin_LenovoLegionGo_Y1 = 428,
13146 k_EControllerActionOrigin_LenovoLegionGo_Y2 = 429,
13147 k_EControllerActionOrigin_LenovoLegionGo_DPad_Move = 430,
13148 k_EControllerActionOrigin_LenovoLegionGo_DPad_North = 431,
13149 k_EControllerActionOrigin_LenovoLegionGo_DPad_South = 432,
13150 k_EControllerActionOrigin_LenovoLegionGo_DPad_West = 433,
13151 k_EControllerActionOrigin_LenovoLegionGo_DPad_East = 434,
13152 k_EControllerActionOrigin_LenovoLegionGo_Gyro_Move = 435,
13153 k_EControllerActionOrigin_LenovoLegionGo_Gyro_Pitch = 436,
13154 k_EControllerActionOrigin_LenovoLegionGo_Gyro_Yaw = 437,
13155 k_EControllerActionOrigin_LenovoLegionGo_Gyro_Roll = 438,
13156 k_EControllerActionOrigin_LenovoLegionGo_Reserved1 = 439,
13157 k_EControllerActionOrigin_LenovoLegionGo_Reserved2 = 440,
13158 k_EControllerActionOrigin_LenovoLegionGo_Reserved3 = 441,
13159 k_EControllerActionOrigin_LenovoLegionGo_Reserved4 = 442,
13160 k_EControllerActionOrigin_LenovoLegionGo_Reserved5 = 443,
13161 k_EControllerActionOrigin_LenovoLegionGo_Reserved6 = 444,
13162 k_EControllerActionOrigin_LenovoLegionGo_Reserved7 = 445,
13163 k_EControllerActionOrigin_LenovoLegionGo_Reserved8 = 446,
13164 k_EControllerActionOrigin_LenovoLegionGo_Reserved9 = 447,
13165 k_EControllerActionOrigin_LenovoLegionGo_Reserved10 = 448,
13166 k_EControllerActionOrigin_LenovoLegionGo_Reserved11 = 449,
13167 k_EControllerActionOrigin_LenovoLegionGo_Reserved12 = 450,
13168 k_EControllerActionOrigin_LenovoLegionGo_Reserved13 = 451,
13169 k_EControllerActionOrigin_LenovoLegionGo_Reserved14 = 452,
13170 k_EControllerActionOrigin_LenovoLegionGo_Reserved15 = 453,
13171 k_EControllerActionOrigin_LenovoLegionGo_Reserved16 = 454,
13172 k_EControllerActionOrigin_LenovoLegionGo_Reserved17 = 455,
13173 k_EControllerActionOrigin_LenovoLegionGo_Reserved18 = 456,
13174 k_EControllerActionOrigin_LenovoLegionGo_Reserved19 = 457,
13175 k_EControllerActionOrigin_LenovoLegionGo_Reserved20 = 458,
13176 k_EControllerActionOrigin_Generic_L4 = 459,
13177 k_EControllerActionOrigin_Generic_R4 = 460,
13178 k_EControllerActionOrigin_Generic_L5 = 461,
13179 k_EControllerActionOrigin_Generic_R5 = 462,
13180 k_EControllerActionOrigin_Generic_PL = 463,
13181 k_EControllerActionOrigin_Generic_PR = 464,
13182 k_EControllerActionOrigin_Generic_C = 465,
13183 k_EControllerActionOrigin_Generic_Z = 466,
13184 k_EControllerActionOrigin_Generic_MISC1 = 467,
13185 k_EControllerActionOrigin_Generic_MISC2 = 468,
13186 k_EControllerActionOrigin_Generic_MISC3 = 469,
13187 k_EControllerActionOrigin_Generic_MISC4 = 470,
13188 k_EControllerActionOrigin_Generic_MISC5 = 471,
13189 k_EControllerActionOrigin_Generic_MISC6 = 472,
13190 k_EControllerActionOrigin_Generic_MISC7 = 473,
13191 k_EControllerActionOrigin_Generic_MISC8 = 474,
13192 k_EControllerActionOrigin_Count = 475,
13193 k_EControllerActionOrigin_MaximumPossibleValue = 32767,
13194}
13195#[repr(u32)]
13196#[non_exhaustive]
13197#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13198pub enum ESteamControllerLEDFlag {
13199 k_ESteamControllerLEDFlag_SetColor = 0,
13200 k_ESteamControllerLEDFlag_RestoreUserDefault = 1,
13201}
13202pub type ControllerHandle_t = uint64;
13203pub type ControllerActionSetHandle_t = uint64;
13204pub type ControllerDigitalActionHandle_t = uint64;
13205pub type ControllerAnalogActionHandle_t = uint64;
13206#[repr(C)]
13207pub struct ISteamController__bindgen_vtable(::std::os::raw::c_void);
13208#[repr(C)]
13209#[derive(Debug, Copy, Clone)]
13210pub struct ISteamController {
13211 pub vtable_: *const ISteamController__bindgen_vtable,
13212}
13213#[test]
13214fn bindgen_test_layout_ISteamController() {
13215 assert_eq!(
13216 ::std::mem::size_of::<ISteamController>(),
13217 8usize,
13218 concat!("Size of: ", stringify!(ISteamController))
13219 );
13220 assert_eq!(
13221 ::std::mem::align_of::<ISteamController>(),
13222 8usize,
13223 concat!("Alignment of ", stringify!(ISteamController))
13224 );
13225}
13226pub type UGCQueryHandle_t = uint64;
13227pub type UGCUpdateHandle_t = uint64;
13228pub const k_UGCQueryHandleInvalid: UGCQueryHandle_t = 18446744073709551615;
13229pub const k_UGCUpdateHandleInvalid: UGCUpdateHandle_t = 18446744073709551615;
13230#[repr(i32)]
13231#[non_exhaustive]
13232#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13233pub enum EUGCMatchingUGCType {
13234 k_EUGCMatchingUGCType_Items = 0,
13235 k_EUGCMatchingUGCType_Items_Mtx = 1,
13236 k_EUGCMatchingUGCType_Items_ReadyToUse = 2,
13237 k_EUGCMatchingUGCType_Collections = 3,
13238 k_EUGCMatchingUGCType_Artwork = 4,
13239 k_EUGCMatchingUGCType_Videos = 5,
13240 k_EUGCMatchingUGCType_Screenshots = 6,
13241 k_EUGCMatchingUGCType_AllGuides = 7,
13242 k_EUGCMatchingUGCType_WebGuides = 8,
13243 k_EUGCMatchingUGCType_IntegratedGuides = 9,
13244 k_EUGCMatchingUGCType_UsableInGame = 10,
13245 k_EUGCMatchingUGCType_ControllerBindings = 11,
13246 k_EUGCMatchingUGCType_GameManagedItems = 12,
13247 k_EUGCMatchingUGCType_All = -1,
13248}
13249#[repr(u32)]
13250#[non_exhaustive]
13251#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13252pub enum EUserUGCList {
13253 k_EUserUGCList_Published = 0,
13254 k_EUserUGCList_VotedOn = 1,
13255 k_EUserUGCList_VotedUp = 2,
13256 k_EUserUGCList_VotedDown = 3,
13257 k_EUserUGCList_WillVoteLater = 4,
13258 k_EUserUGCList_Favorited = 5,
13259 k_EUserUGCList_Subscribed = 6,
13260 k_EUserUGCList_UsedOrPlayed = 7,
13261 k_EUserUGCList_Followed = 8,
13262}
13263#[repr(u32)]
13264#[non_exhaustive]
13265#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13266pub enum EUserUGCListSortOrder {
13267 k_EUserUGCListSortOrder_CreationOrderDesc = 0,
13268 k_EUserUGCListSortOrder_CreationOrderAsc = 1,
13269 k_EUserUGCListSortOrder_TitleAsc = 2,
13270 k_EUserUGCListSortOrder_LastUpdatedDesc = 3,
13271 k_EUserUGCListSortOrder_SubscriptionDateDesc = 4,
13272 k_EUserUGCListSortOrder_VoteScoreDesc = 5,
13273 k_EUserUGCListSortOrder_ForModeration = 6,
13274}
13275#[repr(u32)]
13276#[non_exhaustive]
13277#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13278pub enum EUGCQuery {
13279 k_EUGCQuery_RankedByVote = 0,
13280 k_EUGCQuery_RankedByPublicationDate = 1,
13281 k_EUGCQuery_AcceptedForGameRankedByAcceptanceDate = 2,
13282 k_EUGCQuery_RankedByTrend = 3,
13283 k_EUGCQuery_FavoritedByFriendsRankedByPublicationDate = 4,
13284 k_EUGCQuery_CreatedByFriendsRankedByPublicationDate = 5,
13285 k_EUGCQuery_RankedByNumTimesReported = 6,
13286 k_EUGCQuery_CreatedByFollowedUsersRankedByPublicationDate = 7,
13287 k_EUGCQuery_NotYetRated = 8,
13288 k_EUGCQuery_RankedByTotalVotesAsc = 9,
13289 k_EUGCQuery_RankedByVotesUp = 10,
13290 k_EUGCQuery_RankedByTextSearch = 11,
13291 k_EUGCQuery_RankedByTotalUniqueSubscriptions = 12,
13292 k_EUGCQuery_RankedByPlaytimeTrend = 13,
13293 k_EUGCQuery_RankedByTotalPlaytime = 14,
13294 k_EUGCQuery_RankedByAveragePlaytimeTrend = 15,
13295 k_EUGCQuery_RankedByLifetimeAveragePlaytime = 16,
13296 k_EUGCQuery_RankedByPlaytimeSessionsTrend = 17,
13297 k_EUGCQuery_RankedByLifetimePlaytimeSessions = 18,
13298 k_EUGCQuery_RankedByLastUpdatedDate = 19,
13299}
13300#[repr(u32)]
13301#[non_exhaustive]
13302#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13303pub enum EItemUpdateStatus {
13304 k_EItemUpdateStatusInvalid = 0,
13305 k_EItemUpdateStatusPreparingConfig = 1,
13306 k_EItemUpdateStatusPreparingContent = 2,
13307 k_EItemUpdateStatusUploadingContent = 3,
13308 k_EItemUpdateStatusUploadingPreviewFile = 4,
13309 k_EItemUpdateStatusCommittingChanges = 5,
13310}
13311#[repr(u32)]
13312#[non_exhaustive]
13313#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13314pub enum EItemState {
13315 k_EItemStateNone = 0,
13316 k_EItemStateSubscribed = 1,
13317 k_EItemStateLegacyItem = 2,
13318 k_EItemStateInstalled = 4,
13319 k_EItemStateNeedsUpdate = 8,
13320 k_EItemStateDownloading = 16,
13321 k_EItemStateDownloadPending = 32,
13322 k_EItemStateDisabledLocally = 64,
13323}
13324#[repr(u32)]
13325#[non_exhaustive]
13326#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13327pub enum EItemStatistic {
13328 k_EItemStatistic_NumSubscriptions = 0,
13329 k_EItemStatistic_NumFavorites = 1,
13330 k_EItemStatistic_NumFollowers = 2,
13331 k_EItemStatistic_NumUniqueSubscriptions = 3,
13332 k_EItemStatistic_NumUniqueFavorites = 4,
13333 k_EItemStatistic_NumUniqueFollowers = 5,
13334 k_EItemStatistic_NumUniqueWebsiteViews = 6,
13335 k_EItemStatistic_ReportScore = 7,
13336 k_EItemStatistic_NumSecondsPlayed = 8,
13337 k_EItemStatistic_NumPlaytimeSessions = 9,
13338 k_EItemStatistic_NumComments = 10,
13339 k_EItemStatistic_NumSecondsPlayedDuringTimePeriod = 11,
13340 k_EItemStatistic_NumPlaytimeSessionsDuringTimePeriod = 12,
13341}
13342#[repr(u32)]
13343#[non_exhaustive]
13344#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13345pub enum EItemPreviewType {
13346 k_EItemPreviewType_Image = 0,
13347 k_EItemPreviewType_YouTubeVideo = 1,
13348 k_EItemPreviewType_Sketchfab = 2,
13349 k_EItemPreviewType_EnvironmentMap_HorizontalCross = 3,
13350 k_EItemPreviewType_EnvironmentMap_LatLong = 4,
13351 k_EItemPreviewType_Clip = 5,
13352 k_EItemPreviewType_ReservedMax = 255,
13353}
13354#[repr(u32)]
13355#[non_exhaustive]
13356#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13357pub enum EUGCContentDescriptorID {
13358 k_EUGCContentDescriptor_NudityOrSexualContent = 1,
13359 k_EUGCContentDescriptor_FrequentViolenceOrGore = 2,
13360 k_EUGCContentDescriptor_AdultOnlySexualContent = 3,
13361 k_EUGCContentDescriptor_GratuitousSexualContent = 4,
13362 k_EUGCContentDescriptor_AnyMatureContent = 5,
13363}
13364pub const kNumUGCResultsPerPage: uint32 = 50;
13365pub const k_cchDeveloperMetadataMax: uint32 = 5000;
13366#[repr(C, packed(4))]
13367#[derive(Debug, Copy, Clone)]
13368pub struct SteamUGCDetails_t {
13369 pub m_nPublishedFileId: PublishedFileId_t,
13370 pub m_eResult: EResult,
13371 pub m_eFileType: EWorkshopFileType,
13372 pub m_nCreatorAppID: AppId_t,
13373 pub m_nConsumerAppID: AppId_t,
13374 pub m_rgchTitle: [::std::os::raw::c_char; 129usize],
13375 pub m_rgchDescription: [::std::os::raw::c_char; 8000usize],
13376 pub m_ulSteamIDOwner: uint64,
13377 pub m_rtimeCreated: uint32,
13378 pub m_rtimeUpdated: uint32,
13379 pub m_rtimeAddedToUserList: uint32,
13380 pub m_eVisibility: ERemoteStoragePublishedFileVisibility,
13381 pub m_bBanned: bool,
13382 pub m_bAcceptedForUse: bool,
13383 pub m_bTagsTruncated: bool,
13384 pub m_rgchTags: [::std::os::raw::c_char; 1025usize],
13385 pub m_hFile: UGCHandle_t,
13386 pub m_hPreviewFile: UGCHandle_t,
13387 pub m_pchFileName: [::std::os::raw::c_char; 260usize],
13388 pub m_nFileSize: int32,
13389 pub m_nPreviewFileSize: int32,
13390 pub m_rgchURL: [::std::os::raw::c_char; 256usize],
13391 pub m_unVotesUp: uint32,
13392 pub m_unVotesDown: uint32,
13393 pub m_flScore: f32,
13394 pub m_unNumChildren: uint32,
13395 pub m_ulTotalFilesSize: uint64,
13396}
13397#[test]
13398fn bindgen_test_layout_SteamUGCDetails_t() {
13399 const UNINIT: ::std::mem::MaybeUninit<SteamUGCDetails_t> = ::std::mem::MaybeUninit::uninit();
13400 let ptr = UNINIT.as_ptr();
13401 assert_eq!(
13402 ::std::mem::size_of::<SteamUGCDetails_t>(),
13403 9772usize,
13404 concat!("Size of: ", stringify!(SteamUGCDetails_t))
13405 );
13406 assert_eq!(
13407 ::std::mem::align_of::<SteamUGCDetails_t>(),
13408 4usize,
13409 concat!("Alignment of ", stringify!(SteamUGCDetails_t))
13410 );
13411 assert_eq!(
13412 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
13413 0usize,
13414 concat!(
13415 "Offset of field: ",
13416 stringify!(SteamUGCDetails_t),
13417 "::",
13418 stringify!(m_nPublishedFileId)
13419 )
13420 );
13421 assert_eq!(
13422 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
13423 8usize,
13424 concat!(
13425 "Offset of field: ",
13426 stringify!(SteamUGCDetails_t),
13427 "::",
13428 stringify!(m_eResult)
13429 )
13430 );
13431 assert_eq!(
13432 unsafe { ::std::ptr::addr_of!((*ptr).m_eFileType) as usize - ptr as usize },
13433 12usize,
13434 concat!(
13435 "Offset of field: ",
13436 stringify!(SteamUGCDetails_t),
13437 "::",
13438 stringify!(m_eFileType)
13439 )
13440 );
13441 assert_eq!(
13442 unsafe { ::std::ptr::addr_of!((*ptr).m_nCreatorAppID) as usize - ptr as usize },
13443 16usize,
13444 concat!(
13445 "Offset of field: ",
13446 stringify!(SteamUGCDetails_t),
13447 "::",
13448 stringify!(m_nCreatorAppID)
13449 )
13450 );
13451 assert_eq!(
13452 unsafe { ::std::ptr::addr_of!((*ptr).m_nConsumerAppID) as usize - ptr as usize },
13453 20usize,
13454 concat!(
13455 "Offset of field: ",
13456 stringify!(SteamUGCDetails_t),
13457 "::",
13458 stringify!(m_nConsumerAppID)
13459 )
13460 );
13461 assert_eq!(
13462 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchTitle) as usize - ptr as usize },
13463 24usize,
13464 concat!(
13465 "Offset of field: ",
13466 stringify!(SteamUGCDetails_t),
13467 "::",
13468 stringify!(m_rgchTitle)
13469 )
13470 );
13471 assert_eq!(
13472 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchDescription) as usize - ptr as usize },
13473 153usize,
13474 concat!(
13475 "Offset of field: ",
13476 stringify!(SteamUGCDetails_t),
13477 "::",
13478 stringify!(m_rgchDescription)
13479 )
13480 );
13481 assert_eq!(
13482 unsafe { ::std::ptr::addr_of!((*ptr).m_ulSteamIDOwner) as usize - ptr as usize },
13483 8156usize,
13484 concat!(
13485 "Offset of field: ",
13486 stringify!(SteamUGCDetails_t),
13487 "::",
13488 stringify!(m_ulSteamIDOwner)
13489 )
13490 );
13491 assert_eq!(
13492 unsafe { ::std::ptr::addr_of!((*ptr).m_rtimeCreated) as usize - ptr as usize },
13493 8164usize,
13494 concat!(
13495 "Offset of field: ",
13496 stringify!(SteamUGCDetails_t),
13497 "::",
13498 stringify!(m_rtimeCreated)
13499 )
13500 );
13501 assert_eq!(
13502 unsafe { ::std::ptr::addr_of!((*ptr).m_rtimeUpdated) as usize - ptr as usize },
13503 8168usize,
13504 concat!(
13505 "Offset of field: ",
13506 stringify!(SteamUGCDetails_t),
13507 "::",
13508 stringify!(m_rtimeUpdated)
13509 )
13510 );
13511 assert_eq!(
13512 unsafe { ::std::ptr::addr_of!((*ptr).m_rtimeAddedToUserList) as usize - ptr as usize },
13513 8172usize,
13514 concat!(
13515 "Offset of field: ",
13516 stringify!(SteamUGCDetails_t),
13517 "::",
13518 stringify!(m_rtimeAddedToUserList)
13519 )
13520 );
13521 assert_eq!(
13522 unsafe { ::std::ptr::addr_of!((*ptr).m_eVisibility) as usize - ptr as usize },
13523 8176usize,
13524 concat!(
13525 "Offset of field: ",
13526 stringify!(SteamUGCDetails_t),
13527 "::",
13528 stringify!(m_eVisibility)
13529 )
13530 );
13531 assert_eq!(
13532 unsafe { ::std::ptr::addr_of!((*ptr).m_bBanned) as usize - ptr as usize },
13533 8180usize,
13534 concat!(
13535 "Offset of field: ",
13536 stringify!(SteamUGCDetails_t),
13537 "::",
13538 stringify!(m_bBanned)
13539 )
13540 );
13541 assert_eq!(
13542 unsafe { ::std::ptr::addr_of!((*ptr).m_bAcceptedForUse) as usize - ptr as usize },
13543 8181usize,
13544 concat!(
13545 "Offset of field: ",
13546 stringify!(SteamUGCDetails_t),
13547 "::",
13548 stringify!(m_bAcceptedForUse)
13549 )
13550 );
13551 assert_eq!(
13552 unsafe { ::std::ptr::addr_of!((*ptr).m_bTagsTruncated) as usize - ptr as usize },
13553 8182usize,
13554 concat!(
13555 "Offset of field: ",
13556 stringify!(SteamUGCDetails_t),
13557 "::",
13558 stringify!(m_bTagsTruncated)
13559 )
13560 );
13561 assert_eq!(
13562 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchTags) as usize - ptr as usize },
13563 8183usize,
13564 concat!(
13565 "Offset of field: ",
13566 stringify!(SteamUGCDetails_t),
13567 "::",
13568 stringify!(m_rgchTags)
13569 )
13570 );
13571 assert_eq!(
13572 unsafe { ::std::ptr::addr_of!((*ptr).m_hFile) as usize - ptr as usize },
13573 9208usize,
13574 concat!(
13575 "Offset of field: ",
13576 stringify!(SteamUGCDetails_t),
13577 "::",
13578 stringify!(m_hFile)
13579 )
13580 );
13581 assert_eq!(
13582 unsafe { ::std::ptr::addr_of!((*ptr).m_hPreviewFile) as usize - ptr as usize },
13583 9216usize,
13584 concat!(
13585 "Offset of field: ",
13586 stringify!(SteamUGCDetails_t),
13587 "::",
13588 stringify!(m_hPreviewFile)
13589 )
13590 );
13591 assert_eq!(
13592 unsafe { ::std::ptr::addr_of!((*ptr).m_pchFileName) as usize - ptr as usize },
13593 9224usize,
13594 concat!(
13595 "Offset of field: ",
13596 stringify!(SteamUGCDetails_t),
13597 "::",
13598 stringify!(m_pchFileName)
13599 )
13600 );
13601 assert_eq!(
13602 unsafe { ::std::ptr::addr_of!((*ptr).m_nFileSize) as usize - ptr as usize },
13603 9484usize,
13604 concat!(
13605 "Offset of field: ",
13606 stringify!(SteamUGCDetails_t),
13607 "::",
13608 stringify!(m_nFileSize)
13609 )
13610 );
13611 assert_eq!(
13612 unsafe { ::std::ptr::addr_of!((*ptr).m_nPreviewFileSize) as usize - ptr as usize },
13613 9488usize,
13614 concat!(
13615 "Offset of field: ",
13616 stringify!(SteamUGCDetails_t),
13617 "::",
13618 stringify!(m_nPreviewFileSize)
13619 )
13620 );
13621 assert_eq!(
13622 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchURL) as usize - ptr as usize },
13623 9492usize,
13624 concat!(
13625 "Offset of field: ",
13626 stringify!(SteamUGCDetails_t),
13627 "::",
13628 stringify!(m_rgchURL)
13629 )
13630 );
13631 assert_eq!(
13632 unsafe { ::std::ptr::addr_of!((*ptr).m_unVotesUp) as usize - ptr as usize },
13633 9748usize,
13634 concat!(
13635 "Offset of field: ",
13636 stringify!(SteamUGCDetails_t),
13637 "::",
13638 stringify!(m_unVotesUp)
13639 )
13640 );
13641 assert_eq!(
13642 unsafe { ::std::ptr::addr_of!((*ptr).m_unVotesDown) as usize - ptr as usize },
13643 9752usize,
13644 concat!(
13645 "Offset of field: ",
13646 stringify!(SteamUGCDetails_t),
13647 "::",
13648 stringify!(m_unVotesDown)
13649 )
13650 );
13651 assert_eq!(
13652 unsafe { ::std::ptr::addr_of!((*ptr).m_flScore) as usize - ptr as usize },
13653 9756usize,
13654 concat!(
13655 "Offset of field: ",
13656 stringify!(SteamUGCDetails_t),
13657 "::",
13658 stringify!(m_flScore)
13659 )
13660 );
13661 assert_eq!(
13662 unsafe { ::std::ptr::addr_of!((*ptr).m_unNumChildren) as usize - ptr as usize },
13663 9760usize,
13664 concat!(
13665 "Offset of field: ",
13666 stringify!(SteamUGCDetails_t),
13667 "::",
13668 stringify!(m_unNumChildren)
13669 )
13670 );
13671 assert_eq!(
13672 unsafe { ::std::ptr::addr_of!((*ptr).m_ulTotalFilesSize) as usize - ptr as usize },
13673 9764usize,
13674 concat!(
13675 "Offset of field: ",
13676 stringify!(SteamUGCDetails_t),
13677 "::",
13678 stringify!(m_ulTotalFilesSize)
13679 )
13680 );
13681}
13682#[repr(C)]
13683pub struct ISteamUGC__bindgen_vtable(::std::os::raw::c_void);
13684#[repr(C)]
13685#[derive(Debug, Copy, Clone)]
13686pub struct ISteamUGC {
13687 pub vtable_: *const ISteamUGC__bindgen_vtable,
13688}
13689#[test]
13690fn bindgen_test_layout_ISteamUGC() {
13691 assert_eq!(
13692 ::std::mem::size_of::<ISteamUGC>(),
13693 8usize,
13694 concat!("Size of: ", stringify!(ISteamUGC))
13695 );
13696 assert_eq!(
13697 ::std::mem::align_of::<ISteamUGC>(),
13698 4usize,
13699 concat!("Alignment of ", stringify!(ISteamUGC))
13700 );
13701}
13702#[repr(C, packed(4))]
13703#[derive(Debug, Copy, Clone)]
13704pub struct SteamUGCQueryCompleted_t {
13705 pub m_handle: UGCQueryHandle_t,
13706 pub m_eResult: EResult,
13707 pub m_unNumResultsReturned: uint32,
13708 pub m_unTotalMatchingResults: uint32,
13709 pub m_bCachedData: bool,
13710 pub m_rgchNextCursor: [::std::os::raw::c_char; 256usize],
13711}
13712pub const SteamUGCQueryCompleted_t_k_iCallback: SteamUGCQueryCompleted_t__bindgen_ty_1 =
13713 SteamUGCQueryCompleted_t__bindgen_ty_1::k_iCallback;
13714#[repr(u32)]
13715#[non_exhaustive]
13716#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13717pub enum SteamUGCQueryCompleted_t__bindgen_ty_1 {
13718 k_iCallback = 3401,
13719}
13720#[test]
13721fn bindgen_test_layout_SteamUGCQueryCompleted_t() {
13722 const UNINIT: ::std::mem::MaybeUninit<SteamUGCQueryCompleted_t> =
13723 ::std::mem::MaybeUninit::uninit();
13724 let ptr = UNINIT.as_ptr();
13725 assert_eq!(
13726 ::std::mem::size_of::<SteamUGCQueryCompleted_t>(),
13727 280usize,
13728 concat!("Size of: ", stringify!(SteamUGCQueryCompleted_t))
13729 );
13730 assert_eq!(
13731 ::std::mem::align_of::<SteamUGCQueryCompleted_t>(),
13732 4usize,
13733 concat!("Alignment of ", stringify!(SteamUGCQueryCompleted_t))
13734 );
13735 assert_eq!(
13736 unsafe { ::std::ptr::addr_of!((*ptr).m_handle) as usize - ptr as usize },
13737 0usize,
13738 concat!(
13739 "Offset of field: ",
13740 stringify!(SteamUGCQueryCompleted_t),
13741 "::",
13742 stringify!(m_handle)
13743 )
13744 );
13745 assert_eq!(
13746 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
13747 8usize,
13748 concat!(
13749 "Offset of field: ",
13750 stringify!(SteamUGCQueryCompleted_t),
13751 "::",
13752 stringify!(m_eResult)
13753 )
13754 );
13755 assert_eq!(
13756 unsafe { ::std::ptr::addr_of!((*ptr).m_unNumResultsReturned) as usize - ptr as usize },
13757 12usize,
13758 concat!(
13759 "Offset of field: ",
13760 stringify!(SteamUGCQueryCompleted_t),
13761 "::",
13762 stringify!(m_unNumResultsReturned)
13763 )
13764 );
13765 assert_eq!(
13766 unsafe { ::std::ptr::addr_of!((*ptr).m_unTotalMatchingResults) as usize - ptr as usize },
13767 16usize,
13768 concat!(
13769 "Offset of field: ",
13770 stringify!(SteamUGCQueryCompleted_t),
13771 "::",
13772 stringify!(m_unTotalMatchingResults)
13773 )
13774 );
13775 assert_eq!(
13776 unsafe { ::std::ptr::addr_of!((*ptr).m_bCachedData) as usize - ptr as usize },
13777 20usize,
13778 concat!(
13779 "Offset of field: ",
13780 stringify!(SteamUGCQueryCompleted_t),
13781 "::",
13782 stringify!(m_bCachedData)
13783 )
13784 );
13785 assert_eq!(
13786 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchNextCursor) as usize - ptr as usize },
13787 21usize,
13788 concat!(
13789 "Offset of field: ",
13790 stringify!(SteamUGCQueryCompleted_t),
13791 "::",
13792 stringify!(m_rgchNextCursor)
13793 )
13794 );
13795}
13796#[repr(C)]
13797#[derive(Debug, Copy, Clone)]
13798pub struct SteamUGCRequestUGCDetailsResult_t {
13799 pub m_details: SteamUGCDetails_t,
13800 pub m_bCachedData: bool,
13801}
13802pub const SteamUGCRequestUGCDetailsResult_t_k_iCallback:
13803 SteamUGCRequestUGCDetailsResult_t__bindgen_ty_1 =
13804 SteamUGCRequestUGCDetailsResult_t__bindgen_ty_1::k_iCallback;
13805#[repr(u32)]
13806#[non_exhaustive]
13807#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13808pub enum SteamUGCRequestUGCDetailsResult_t__bindgen_ty_1 {
13809 k_iCallback = 3402,
13810}
13811#[test]
13812fn bindgen_test_layout_SteamUGCRequestUGCDetailsResult_t() {
13813 const UNINIT: ::std::mem::MaybeUninit<SteamUGCRequestUGCDetailsResult_t> =
13814 ::std::mem::MaybeUninit::uninit();
13815 let ptr = UNINIT.as_ptr();
13816 assert_eq!(
13817 ::std::mem::size_of::<SteamUGCRequestUGCDetailsResult_t>(),
13818 9776usize,
13819 concat!("Size of: ", stringify!(SteamUGCRequestUGCDetailsResult_t))
13820 );
13821 assert_eq!(
13822 ::std::mem::align_of::<SteamUGCRequestUGCDetailsResult_t>(),
13823 4usize,
13824 concat!(
13825 "Alignment of ",
13826 stringify!(SteamUGCRequestUGCDetailsResult_t)
13827 )
13828 );
13829 assert_eq!(
13830 unsafe { ::std::ptr::addr_of!((*ptr).m_details) as usize - ptr as usize },
13831 0usize,
13832 concat!(
13833 "Offset of field: ",
13834 stringify!(SteamUGCRequestUGCDetailsResult_t),
13835 "::",
13836 stringify!(m_details)
13837 )
13838 );
13839 assert_eq!(
13840 unsafe { ::std::ptr::addr_of!((*ptr).m_bCachedData) as usize - ptr as usize },
13841 9772usize,
13842 concat!(
13843 "Offset of field: ",
13844 stringify!(SteamUGCRequestUGCDetailsResult_t),
13845 "::",
13846 stringify!(m_bCachedData)
13847 )
13848 );
13849}
13850#[repr(C, packed(4))]
13851#[derive(Debug, Copy, Clone)]
13852pub struct CreateItemResult_t {
13853 pub m_eResult: EResult,
13854 pub m_nPublishedFileId: PublishedFileId_t,
13855 pub m_bUserNeedsToAcceptWorkshopLegalAgreement: bool,
13856}
13857pub const CreateItemResult_t_k_iCallback: CreateItemResult_t__bindgen_ty_1 =
13858 CreateItemResult_t__bindgen_ty_1::k_iCallback;
13859#[repr(u32)]
13860#[non_exhaustive]
13861#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13862pub enum CreateItemResult_t__bindgen_ty_1 {
13863 k_iCallback = 3403,
13864}
13865#[test]
13866fn bindgen_test_layout_CreateItemResult_t() {
13867 const UNINIT: ::std::mem::MaybeUninit<CreateItemResult_t> = ::std::mem::MaybeUninit::uninit();
13868 let ptr = UNINIT.as_ptr();
13869 assert_eq!(
13870 ::std::mem::size_of::<CreateItemResult_t>(),
13871 16usize,
13872 concat!("Size of: ", stringify!(CreateItemResult_t))
13873 );
13874 assert_eq!(
13875 ::std::mem::align_of::<CreateItemResult_t>(),
13876 4usize,
13877 concat!("Alignment of ", stringify!(CreateItemResult_t))
13878 );
13879 assert_eq!(
13880 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
13881 0usize,
13882 concat!(
13883 "Offset of field: ",
13884 stringify!(CreateItemResult_t),
13885 "::",
13886 stringify!(m_eResult)
13887 )
13888 );
13889 assert_eq!(
13890 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
13891 4usize,
13892 concat!(
13893 "Offset of field: ",
13894 stringify!(CreateItemResult_t),
13895 "::",
13896 stringify!(m_nPublishedFileId)
13897 )
13898 );
13899 assert_eq!(
13900 unsafe {
13901 ::std::ptr::addr_of!((*ptr).m_bUserNeedsToAcceptWorkshopLegalAgreement) as usize
13902 - ptr as usize
13903 },
13904 12usize,
13905 concat!(
13906 "Offset of field: ",
13907 stringify!(CreateItemResult_t),
13908 "::",
13909 stringify!(m_bUserNeedsToAcceptWorkshopLegalAgreement)
13910 )
13911 );
13912}
13913#[repr(C, packed(4))]
13914#[derive(Debug, Copy, Clone)]
13915pub struct SubmitItemUpdateResult_t {
13916 pub m_eResult: EResult,
13917 pub m_bUserNeedsToAcceptWorkshopLegalAgreement: bool,
13918 pub m_nPublishedFileId: PublishedFileId_t,
13919}
13920pub const SubmitItemUpdateResult_t_k_iCallback: SubmitItemUpdateResult_t__bindgen_ty_1 =
13921 SubmitItemUpdateResult_t__bindgen_ty_1::k_iCallback;
13922#[repr(u32)]
13923#[non_exhaustive]
13924#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13925pub enum SubmitItemUpdateResult_t__bindgen_ty_1 {
13926 k_iCallback = 3404,
13927}
13928#[test]
13929fn bindgen_test_layout_SubmitItemUpdateResult_t() {
13930 const UNINIT: ::std::mem::MaybeUninit<SubmitItemUpdateResult_t> =
13931 ::std::mem::MaybeUninit::uninit();
13932 let ptr = UNINIT.as_ptr();
13933 assert_eq!(
13934 ::std::mem::size_of::<SubmitItemUpdateResult_t>(),
13935 16usize,
13936 concat!("Size of: ", stringify!(SubmitItemUpdateResult_t))
13937 );
13938 assert_eq!(
13939 ::std::mem::align_of::<SubmitItemUpdateResult_t>(),
13940 4usize,
13941 concat!("Alignment of ", stringify!(SubmitItemUpdateResult_t))
13942 );
13943 assert_eq!(
13944 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
13945 0usize,
13946 concat!(
13947 "Offset of field: ",
13948 stringify!(SubmitItemUpdateResult_t),
13949 "::",
13950 stringify!(m_eResult)
13951 )
13952 );
13953 assert_eq!(
13954 unsafe {
13955 ::std::ptr::addr_of!((*ptr).m_bUserNeedsToAcceptWorkshopLegalAgreement) as usize
13956 - ptr as usize
13957 },
13958 4usize,
13959 concat!(
13960 "Offset of field: ",
13961 stringify!(SubmitItemUpdateResult_t),
13962 "::",
13963 stringify!(m_bUserNeedsToAcceptWorkshopLegalAgreement)
13964 )
13965 );
13966 assert_eq!(
13967 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
13968 8usize,
13969 concat!(
13970 "Offset of field: ",
13971 stringify!(SubmitItemUpdateResult_t),
13972 "::",
13973 stringify!(m_nPublishedFileId)
13974 )
13975 );
13976}
13977#[repr(C, packed(4))]
13978#[derive(Debug, Copy, Clone)]
13979pub struct ItemInstalled_t {
13980 pub m_unAppID: AppId_t,
13981 pub m_nPublishedFileId: PublishedFileId_t,
13982 pub m_hLegacyContent: UGCHandle_t,
13983 pub m_unManifestID: uint64,
13984}
13985pub const ItemInstalled_t_k_iCallback: ItemInstalled_t__bindgen_ty_1 =
13986 ItemInstalled_t__bindgen_ty_1::k_iCallback;
13987#[repr(u32)]
13988#[non_exhaustive]
13989#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
13990pub enum ItemInstalled_t__bindgen_ty_1 {
13991 k_iCallback = 3405,
13992}
13993#[test]
13994fn bindgen_test_layout_ItemInstalled_t() {
13995 const UNINIT: ::std::mem::MaybeUninit<ItemInstalled_t> = ::std::mem::MaybeUninit::uninit();
13996 let ptr = UNINIT.as_ptr();
13997 assert_eq!(
13998 ::std::mem::size_of::<ItemInstalled_t>(),
13999 28usize,
14000 concat!("Size of: ", stringify!(ItemInstalled_t))
14001 );
14002 assert_eq!(
14003 ::std::mem::align_of::<ItemInstalled_t>(),
14004 4usize,
14005 concat!("Alignment of ", stringify!(ItemInstalled_t))
14006 );
14007 assert_eq!(
14008 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
14009 0usize,
14010 concat!(
14011 "Offset of field: ",
14012 stringify!(ItemInstalled_t),
14013 "::",
14014 stringify!(m_unAppID)
14015 )
14016 );
14017 assert_eq!(
14018 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14019 4usize,
14020 concat!(
14021 "Offset of field: ",
14022 stringify!(ItemInstalled_t),
14023 "::",
14024 stringify!(m_nPublishedFileId)
14025 )
14026 );
14027 assert_eq!(
14028 unsafe { ::std::ptr::addr_of!((*ptr).m_hLegacyContent) as usize - ptr as usize },
14029 12usize,
14030 concat!(
14031 "Offset of field: ",
14032 stringify!(ItemInstalled_t),
14033 "::",
14034 stringify!(m_hLegacyContent)
14035 )
14036 );
14037 assert_eq!(
14038 unsafe { ::std::ptr::addr_of!((*ptr).m_unManifestID) as usize - ptr as usize },
14039 20usize,
14040 concat!(
14041 "Offset of field: ",
14042 stringify!(ItemInstalled_t),
14043 "::",
14044 stringify!(m_unManifestID)
14045 )
14046 );
14047}
14048#[repr(C, packed(4))]
14049#[derive(Debug, Copy, Clone)]
14050pub struct DownloadItemResult_t {
14051 pub m_unAppID: AppId_t,
14052 pub m_nPublishedFileId: PublishedFileId_t,
14053 pub m_eResult: EResult,
14054}
14055pub const DownloadItemResult_t_k_iCallback: DownloadItemResult_t__bindgen_ty_1 =
14056 DownloadItemResult_t__bindgen_ty_1::k_iCallback;
14057#[repr(u32)]
14058#[non_exhaustive]
14059#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14060pub enum DownloadItemResult_t__bindgen_ty_1 {
14061 k_iCallback = 3406,
14062}
14063#[test]
14064fn bindgen_test_layout_DownloadItemResult_t() {
14065 const UNINIT: ::std::mem::MaybeUninit<DownloadItemResult_t> = ::std::mem::MaybeUninit::uninit();
14066 let ptr = UNINIT.as_ptr();
14067 assert_eq!(
14068 ::std::mem::size_of::<DownloadItemResult_t>(),
14069 16usize,
14070 concat!("Size of: ", stringify!(DownloadItemResult_t))
14071 );
14072 assert_eq!(
14073 ::std::mem::align_of::<DownloadItemResult_t>(),
14074 4usize,
14075 concat!("Alignment of ", stringify!(DownloadItemResult_t))
14076 );
14077 assert_eq!(
14078 unsafe { ::std::ptr::addr_of!((*ptr).m_unAppID) as usize - ptr as usize },
14079 0usize,
14080 concat!(
14081 "Offset of field: ",
14082 stringify!(DownloadItemResult_t),
14083 "::",
14084 stringify!(m_unAppID)
14085 )
14086 );
14087 assert_eq!(
14088 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14089 4usize,
14090 concat!(
14091 "Offset of field: ",
14092 stringify!(DownloadItemResult_t),
14093 "::",
14094 stringify!(m_nPublishedFileId)
14095 )
14096 );
14097 assert_eq!(
14098 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14099 12usize,
14100 concat!(
14101 "Offset of field: ",
14102 stringify!(DownloadItemResult_t),
14103 "::",
14104 stringify!(m_eResult)
14105 )
14106 );
14107}
14108#[repr(C, packed(4))]
14109#[derive(Debug, Copy, Clone)]
14110pub struct UserFavoriteItemsListChanged_t {
14111 pub m_nPublishedFileId: PublishedFileId_t,
14112 pub m_eResult: EResult,
14113 pub m_bWasAddRequest: bool,
14114}
14115pub const UserFavoriteItemsListChanged_t_k_iCallback: UserFavoriteItemsListChanged_t__bindgen_ty_1 =
14116 UserFavoriteItemsListChanged_t__bindgen_ty_1::k_iCallback;
14117#[repr(u32)]
14118#[non_exhaustive]
14119#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14120pub enum UserFavoriteItemsListChanged_t__bindgen_ty_1 {
14121 k_iCallback = 3407,
14122}
14123#[test]
14124fn bindgen_test_layout_UserFavoriteItemsListChanged_t() {
14125 const UNINIT: ::std::mem::MaybeUninit<UserFavoriteItemsListChanged_t> =
14126 ::std::mem::MaybeUninit::uninit();
14127 let ptr = UNINIT.as_ptr();
14128 assert_eq!(
14129 ::std::mem::size_of::<UserFavoriteItemsListChanged_t>(),
14130 16usize,
14131 concat!("Size of: ", stringify!(UserFavoriteItemsListChanged_t))
14132 );
14133 assert_eq!(
14134 ::std::mem::align_of::<UserFavoriteItemsListChanged_t>(),
14135 4usize,
14136 concat!("Alignment of ", stringify!(UserFavoriteItemsListChanged_t))
14137 );
14138 assert_eq!(
14139 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14140 0usize,
14141 concat!(
14142 "Offset of field: ",
14143 stringify!(UserFavoriteItemsListChanged_t),
14144 "::",
14145 stringify!(m_nPublishedFileId)
14146 )
14147 );
14148 assert_eq!(
14149 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14150 8usize,
14151 concat!(
14152 "Offset of field: ",
14153 stringify!(UserFavoriteItemsListChanged_t),
14154 "::",
14155 stringify!(m_eResult)
14156 )
14157 );
14158 assert_eq!(
14159 unsafe { ::std::ptr::addr_of!((*ptr).m_bWasAddRequest) as usize - ptr as usize },
14160 12usize,
14161 concat!(
14162 "Offset of field: ",
14163 stringify!(UserFavoriteItemsListChanged_t),
14164 "::",
14165 stringify!(m_bWasAddRequest)
14166 )
14167 );
14168}
14169#[repr(C, packed(4))]
14170#[derive(Debug, Copy, Clone)]
14171pub struct SetUserItemVoteResult_t {
14172 pub m_nPublishedFileId: PublishedFileId_t,
14173 pub m_eResult: EResult,
14174 pub m_bVoteUp: bool,
14175}
14176pub const SetUserItemVoteResult_t_k_iCallback: SetUserItemVoteResult_t__bindgen_ty_1 =
14177 SetUserItemVoteResult_t__bindgen_ty_1::k_iCallback;
14178#[repr(u32)]
14179#[non_exhaustive]
14180#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14181pub enum SetUserItemVoteResult_t__bindgen_ty_1 {
14182 k_iCallback = 3408,
14183}
14184#[test]
14185fn bindgen_test_layout_SetUserItemVoteResult_t() {
14186 const UNINIT: ::std::mem::MaybeUninit<SetUserItemVoteResult_t> =
14187 ::std::mem::MaybeUninit::uninit();
14188 let ptr = UNINIT.as_ptr();
14189 assert_eq!(
14190 ::std::mem::size_of::<SetUserItemVoteResult_t>(),
14191 16usize,
14192 concat!("Size of: ", stringify!(SetUserItemVoteResult_t))
14193 );
14194 assert_eq!(
14195 ::std::mem::align_of::<SetUserItemVoteResult_t>(),
14196 4usize,
14197 concat!("Alignment of ", stringify!(SetUserItemVoteResult_t))
14198 );
14199 assert_eq!(
14200 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14201 0usize,
14202 concat!(
14203 "Offset of field: ",
14204 stringify!(SetUserItemVoteResult_t),
14205 "::",
14206 stringify!(m_nPublishedFileId)
14207 )
14208 );
14209 assert_eq!(
14210 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14211 8usize,
14212 concat!(
14213 "Offset of field: ",
14214 stringify!(SetUserItemVoteResult_t),
14215 "::",
14216 stringify!(m_eResult)
14217 )
14218 );
14219 assert_eq!(
14220 unsafe { ::std::ptr::addr_of!((*ptr).m_bVoteUp) as usize - ptr as usize },
14221 12usize,
14222 concat!(
14223 "Offset of field: ",
14224 stringify!(SetUserItemVoteResult_t),
14225 "::",
14226 stringify!(m_bVoteUp)
14227 )
14228 );
14229}
14230#[repr(C, packed(4))]
14231#[derive(Debug, Copy, Clone)]
14232pub struct GetUserItemVoteResult_t {
14233 pub m_nPublishedFileId: PublishedFileId_t,
14234 pub m_eResult: EResult,
14235 pub m_bVotedUp: bool,
14236 pub m_bVotedDown: bool,
14237 pub m_bVoteSkipped: bool,
14238}
14239pub const GetUserItemVoteResult_t_k_iCallback: GetUserItemVoteResult_t__bindgen_ty_1 =
14240 GetUserItemVoteResult_t__bindgen_ty_1::k_iCallback;
14241#[repr(u32)]
14242#[non_exhaustive]
14243#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14244pub enum GetUserItemVoteResult_t__bindgen_ty_1 {
14245 k_iCallback = 3409,
14246}
14247#[test]
14248fn bindgen_test_layout_GetUserItemVoteResult_t() {
14249 const UNINIT: ::std::mem::MaybeUninit<GetUserItemVoteResult_t> =
14250 ::std::mem::MaybeUninit::uninit();
14251 let ptr = UNINIT.as_ptr();
14252 assert_eq!(
14253 ::std::mem::size_of::<GetUserItemVoteResult_t>(),
14254 16usize,
14255 concat!("Size of: ", stringify!(GetUserItemVoteResult_t))
14256 );
14257 assert_eq!(
14258 ::std::mem::align_of::<GetUserItemVoteResult_t>(),
14259 4usize,
14260 concat!("Alignment of ", stringify!(GetUserItemVoteResult_t))
14261 );
14262 assert_eq!(
14263 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14264 0usize,
14265 concat!(
14266 "Offset of field: ",
14267 stringify!(GetUserItemVoteResult_t),
14268 "::",
14269 stringify!(m_nPublishedFileId)
14270 )
14271 );
14272 assert_eq!(
14273 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14274 8usize,
14275 concat!(
14276 "Offset of field: ",
14277 stringify!(GetUserItemVoteResult_t),
14278 "::",
14279 stringify!(m_eResult)
14280 )
14281 );
14282 assert_eq!(
14283 unsafe { ::std::ptr::addr_of!((*ptr).m_bVotedUp) as usize - ptr as usize },
14284 12usize,
14285 concat!(
14286 "Offset of field: ",
14287 stringify!(GetUserItemVoteResult_t),
14288 "::",
14289 stringify!(m_bVotedUp)
14290 )
14291 );
14292 assert_eq!(
14293 unsafe { ::std::ptr::addr_of!((*ptr).m_bVotedDown) as usize - ptr as usize },
14294 13usize,
14295 concat!(
14296 "Offset of field: ",
14297 stringify!(GetUserItemVoteResult_t),
14298 "::",
14299 stringify!(m_bVotedDown)
14300 )
14301 );
14302 assert_eq!(
14303 unsafe { ::std::ptr::addr_of!((*ptr).m_bVoteSkipped) as usize - ptr as usize },
14304 14usize,
14305 concat!(
14306 "Offset of field: ",
14307 stringify!(GetUserItemVoteResult_t),
14308 "::",
14309 stringify!(m_bVoteSkipped)
14310 )
14311 );
14312}
14313#[repr(C)]
14314#[derive(Debug, Copy, Clone)]
14315pub struct StartPlaytimeTrackingResult_t {
14316 pub m_eResult: EResult,
14317}
14318pub const StartPlaytimeTrackingResult_t_k_iCallback: StartPlaytimeTrackingResult_t__bindgen_ty_1 =
14319 StartPlaytimeTrackingResult_t__bindgen_ty_1::k_iCallback;
14320#[repr(u32)]
14321#[non_exhaustive]
14322#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14323pub enum StartPlaytimeTrackingResult_t__bindgen_ty_1 {
14324 k_iCallback = 3410,
14325}
14326#[test]
14327fn bindgen_test_layout_StartPlaytimeTrackingResult_t() {
14328 const UNINIT: ::std::mem::MaybeUninit<StartPlaytimeTrackingResult_t> =
14329 ::std::mem::MaybeUninit::uninit();
14330 let ptr = UNINIT.as_ptr();
14331 assert_eq!(
14332 ::std::mem::size_of::<StartPlaytimeTrackingResult_t>(),
14333 4usize,
14334 concat!("Size of: ", stringify!(StartPlaytimeTrackingResult_t))
14335 );
14336 assert_eq!(
14337 ::std::mem::align_of::<StartPlaytimeTrackingResult_t>(),
14338 4usize,
14339 concat!("Alignment of ", stringify!(StartPlaytimeTrackingResult_t))
14340 );
14341 assert_eq!(
14342 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14343 0usize,
14344 concat!(
14345 "Offset of field: ",
14346 stringify!(StartPlaytimeTrackingResult_t),
14347 "::",
14348 stringify!(m_eResult)
14349 )
14350 );
14351}
14352#[repr(C)]
14353#[derive(Debug, Copy, Clone)]
14354pub struct StopPlaytimeTrackingResult_t {
14355 pub m_eResult: EResult,
14356}
14357pub const StopPlaytimeTrackingResult_t_k_iCallback: StopPlaytimeTrackingResult_t__bindgen_ty_1 =
14358 StopPlaytimeTrackingResult_t__bindgen_ty_1::k_iCallback;
14359#[repr(u32)]
14360#[non_exhaustive]
14361#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14362pub enum StopPlaytimeTrackingResult_t__bindgen_ty_1 {
14363 k_iCallback = 3411,
14364}
14365#[test]
14366fn bindgen_test_layout_StopPlaytimeTrackingResult_t() {
14367 const UNINIT: ::std::mem::MaybeUninit<StopPlaytimeTrackingResult_t> =
14368 ::std::mem::MaybeUninit::uninit();
14369 let ptr = UNINIT.as_ptr();
14370 assert_eq!(
14371 ::std::mem::size_of::<StopPlaytimeTrackingResult_t>(),
14372 4usize,
14373 concat!("Size of: ", stringify!(StopPlaytimeTrackingResult_t))
14374 );
14375 assert_eq!(
14376 ::std::mem::align_of::<StopPlaytimeTrackingResult_t>(),
14377 4usize,
14378 concat!("Alignment of ", stringify!(StopPlaytimeTrackingResult_t))
14379 );
14380 assert_eq!(
14381 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14382 0usize,
14383 concat!(
14384 "Offset of field: ",
14385 stringify!(StopPlaytimeTrackingResult_t),
14386 "::",
14387 stringify!(m_eResult)
14388 )
14389 );
14390}
14391#[repr(C, packed(4))]
14392#[derive(Debug, Copy, Clone)]
14393pub struct AddUGCDependencyResult_t {
14394 pub m_eResult: EResult,
14395 pub m_nPublishedFileId: PublishedFileId_t,
14396 pub m_nChildPublishedFileId: PublishedFileId_t,
14397}
14398pub const AddUGCDependencyResult_t_k_iCallback: AddUGCDependencyResult_t__bindgen_ty_1 =
14399 AddUGCDependencyResult_t__bindgen_ty_1::k_iCallback;
14400#[repr(u32)]
14401#[non_exhaustive]
14402#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14403pub enum AddUGCDependencyResult_t__bindgen_ty_1 {
14404 k_iCallback = 3412,
14405}
14406#[test]
14407fn bindgen_test_layout_AddUGCDependencyResult_t() {
14408 const UNINIT: ::std::mem::MaybeUninit<AddUGCDependencyResult_t> =
14409 ::std::mem::MaybeUninit::uninit();
14410 let ptr = UNINIT.as_ptr();
14411 assert_eq!(
14412 ::std::mem::size_of::<AddUGCDependencyResult_t>(),
14413 20usize,
14414 concat!("Size of: ", stringify!(AddUGCDependencyResult_t))
14415 );
14416 assert_eq!(
14417 ::std::mem::align_of::<AddUGCDependencyResult_t>(),
14418 4usize,
14419 concat!("Alignment of ", stringify!(AddUGCDependencyResult_t))
14420 );
14421 assert_eq!(
14422 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14423 0usize,
14424 concat!(
14425 "Offset of field: ",
14426 stringify!(AddUGCDependencyResult_t),
14427 "::",
14428 stringify!(m_eResult)
14429 )
14430 );
14431 assert_eq!(
14432 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14433 4usize,
14434 concat!(
14435 "Offset of field: ",
14436 stringify!(AddUGCDependencyResult_t),
14437 "::",
14438 stringify!(m_nPublishedFileId)
14439 )
14440 );
14441 assert_eq!(
14442 unsafe { ::std::ptr::addr_of!((*ptr).m_nChildPublishedFileId) as usize - ptr as usize },
14443 12usize,
14444 concat!(
14445 "Offset of field: ",
14446 stringify!(AddUGCDependencyResult_t),
14447 "::",
14448 stringify!(m_nChildPublishedFileId)
14449 )
14450 );
14451}
14452#[repr(C, packed(4))]
14453#[derive(Debug, Copy, Clone)]
14454pub struct RemoveUGCDependencyResult_t {
14455 pub m_eResult: EResult,
14456 pub m_nPublishedFileId: PublishedFileId_t,
14457 pub m_nChildPublishedFileId: PublishedFileId_t,
14458}
14459pub const RemoveUGCDependencyResult_t_k_iCallback: RemoveUGCDependencyResult_t__bindgen_ty_1 =
14460 RemoveUGCDependencyResult_t__bindgen_ty_1::k_iCallback;
14461#[repr(u32)]
14462#[non_exhaustive]
14463#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14464pub enum RemoveUGCDependencyResult_t__bindgen_ty_1 {
14465 k_iCallback = 3413,
14466}
14467#[test]
14468fn bindgen_test_layout_RemoveUGCDependencyResult_t() {
14469 const UNINIT: ::std::mem::MaybeUninit<RemoveUGCDependencyResult_t> =
14470 ::std::mem::MaybeUninit::uninit();
14471 let ptr = UNINIT.as_ptr();
14472 assert_eq!(
14473 ::std::mem::size_of::<RemoveUGCDependencyResult_t>(),
14474 20usize,
14475 concat!("Size of: ", stringify!(RemoveUGCDependencyResult_t))
14476 );
14477 assert_eq!(
14478 ::std::mem::align_of::<RemoveUGCDependencyResult_t>(),
14479 4usize,
14480 concat!("Alignment of ", stringify!(RemoveUGCDependencyResult_t))
14481 );
14482 assert_eq!(
14483 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14484 0usize,
14485 concat!(
14486 "Offset of field: ",
14487 stringify!(RemoveUGCDependencyResult_t),
14488 "::",
14489 stringify!(m_eResult)
14490 )
14491 );
14492 assert_eq!(
14493 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14494 4usize,
14495 concat!(
14496 "Offset of field: ",
14497 stringify!(RemoveUGCDependencyResult_t),
14498 "::",
14499 stringify!(m_nPublishedFileId)
14500 )
14501 );
14502 assert_eq!(
14503 unsafe { ::std::ptr::addr_of!((*ptr).m_nChildPublishedFileId) as usize - ptr as usize },
14504 12usize,
14505 concat!(
14506 "Offset of field: ",
14507 stringify!(RemoveUGCDependencyResult_t),
14508 "::",
14509 stringify!(m_nChildPublishedFileId)
14510 )
14511 );
14512}
14513#[repr(C, packed(4))]
14514#[derive(Debug, Copy, Clone)]
14515pub struct AddAppDependencyResult_t {
14516 pub m_eResult: EResult,
14517 pub m_nPublishedFileId: PublishedFileId_t,
14518 pub m_nAppID: AppId_t,
14519}
14520pub const AddAppDependencyResult_t_k_iCallback: AddAppDependencyResult_t__bindgen_ty_1 =
14521 AddAppDependencyResult_t__bindgen_ty_1::k_iCallback;
14522#[repr(u32)]
14523#[non_exhaustive]
14524#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14525pub enum AddAppDependencyResult_t__bindgen_ty_1 {
14526 k_iCallback = 3414,
14527}
14528#[test]
14529fn bindgen_test_layout_AddAppDependencyResult_t() {
14530 const UNINIT: ::std::mem::MaybeUninit<AddAppDependencyResult_t> =
14531 ::std::mem::MaybeUninit::uninit();
14532 let ptr = UNINIT.as_ptr();
14533 assert_eq!(
14534 ::std::mem::size_of::<AddAppDependencyResult_t>(),
14535 16usize,
14536 concat!("Size of: ", stringify!(AddAppDependencyResult_t))
14537 );
14538 assert_eq!(
14539 ::std::mem::align_of::<AddAppDependencyResult_t>(),
14540 4usize,
14541 concat!("Alignment of ", stringify!(AddAppDependencyResult_t))
14542 );
14543 assert_eq!(
14544 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14545 0usize,
14546 concat!(
14547 "Offset of field: ",
14548 stringify!(AddAppDependencyResult_t),
14549 "::",
14550 stringify!(m_eResult)
14551 )
14552 );
14553 assert_eq!(
14554 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14555 4usize,
14556 concat!(
14557 "Offset of field: ",
14558 stringify!(AddAppDependencyResult_t),
14559 "::",
14560 stringify!(m_nPublishedFileId)
14561 )
14562 );
14563 assert_eq!(
14564 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
14565 12usize,
14566 concat!(
14567 "Offset of field: ",
14568 stringify!(AddAppDependencyResult_t),
14569 "::",
14570 stringify!(m_nAppID)
14571 )
14572 );
14573}
14574#[repr(C, packed(4))]
14575#[derive(Debug, Copy, Clone)]
14576pub struct RemoveAppDependencyResult_t {
14577 pub m_eResult: EResult,
14578 pub m_nPublishedFileId: PublishedFileId_t,
14579 pub m_nAppID: AppId_t,
14580}
14581pub const RemoveAppDependencyResult_t_k_iCallback: RemoveAppDependencyResult_t__bindgen_ty_1 =
14582 RemoveAppDependencyResult_t__bindgen_ty_1::k_iCallback;
14583#[repr(u32)]
14584#[non_exhaustive]
14585#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14586pub enum RemoveAppDependencyResult_t__bindgen_ty_1 {
14587 k_iCallback = 3415,
14588}
14589#[test]
14590fn bindgen_test_layout_RemoveAppDependencyResult_t() {
14591 const UNINIT: ::std::mem::MaybeUninit<RemoveAppDependencyResult_t> =
14592 ::std::mem::MaybeUninit::uninit();
14593 let ptr = UNINIT.as_ptr();
14594 assert_eq!(
14595 ::std::mem::size_of::<RemoveAppDependencyResult_t>(),
14596 16usize,
14597 concat!("Size of: ", stringify!(RemoveAppDependencyResult_t))
14598 );
14599 assert_eq!(
14600 ::std::mem::align_of::<RemoveAppDependencyResult_t>(),
14601 4usize,
14602 concat!("Alignment of ", stringify!(RemoveAppDependencyResult_t))
14603 );
14604 assert_eq!(
14605 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14606 0usize,
14607 concat!(
14608 "Offset of field: ",
14609 stringify!(RemoveAppDependencyResult_t),
14610 "::",
14611 stringify!(m_eResult)
14612 )
14613 );
14614 assert_eq!(
14615 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14616 4usize,
14617 concat!(
14618 "Offset of field: ",
14619 stringify!(RemoveAppDependencyResult_t),
14620 "::",
14621 stringify!(m_nPublishedFileId)
14622 )
14623 );
14624 assert_eq!(
14625 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
14626 12usize,
14627 concat!(
14628 "Offset of field: ",
14629 stringify!(RemoveAppDependencyResult_t),
14630 "::",
14631 stringify!(m_nAppID)
14632 )
14633 );
14634}
14635#[repr(C, packed(4))]
14636#[derive(Debug, Copy, Clone)]
14637pub struct GetAppDependenciesResult_t {
14638 pub m_eResult: EResult,
14639 pub m_nPublishedFileId: PublishedFileId_t,
14640 pub m_rgAppIDs: [AppId_t; 32usize],
14641 pub m_nNumAppDependencies: uint32,
14642 pub m_nTotalNumAppDependencies: uint32,
14643}
14644pub const GetAppDependenciesResult_t_k_iCallback: GetAppDependenciesResult_t__bindgen_ty_1 =
14645 GetAppDependenciesResult_t__bindgen_ty_1::k_iCallback;
14646#[repr(u32)]
14647#[non_exhaustive]
14648#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14649pub enum GetAppDependenciesResult_t__bindgen_ty_1 {
14650 k_iCallback = 3416,
14651}
14652#[test]
14653fn bindgen_test_layout_GetAppDependenciesResult_t() {
14654 const UNINIT: ::std::mem::MaybeUninit<GetAppDependenciesResult_t> =
14655 ::std::mem::MaybeUninit::uninit();
14656 let ptr = UNINIT.as_ptr();
14657 assert_eq!(
14658 ::std::mem::size_of::<GetAppDependenciesResult_t>(),
14659 148usize,
14660 concat!("Size of: ", stringify!(GetAppDependenciesResult_t))
14661 );
14662 assert_eq!(
14663 ::std::mem::align_of::<GetAppDependenciesResult_t>(),
14664 4usize,
14665 concat!("Alignment of ", stringify!(GetAppDependenciesResult_t))
14666 );
14667 assert_eq!(
14668 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14669 0usize,
14670 concat!(
14671 "Offset of field: ",
14672 stringify!(GetAppDependenciesResult_t),
14673 "::",
14674 stringify!(m_eResult)
14675 )
14676 );
14677 assert_eq!(
14678 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14679 4usize,
14680 concat!(
14681 "Offset of field: ",
14682 stringify!(GetAppDependenciesResult_t),
14683 "::",
14684 stringify!(m_nPublishedFileId)
14685 )
14686 );
14687 assert_eq!(
14688 unsafe { ::std::ptr::addr_of!((*ptr).m_rgAppIDs) as usize - ptr as usize },
14689 12usize,
14690 concat!(
14691 "Offset of field: ",
14692 stringify!(GetAppDependenciesResult_t),
14693 "::",
14694 stringify!(m_rgAppIDs)
14695 )
14696 );
14697 assert_eq!(
14698 unsafe { ::std::ptr::addr_of!((*ptr).m_nNumAppDependencies) as usize - ptr as usize },
14699 140usize,
14700 concat!(
14701 "Offset of field: ",
14702 stringify!(GetAppDependenciesResult_t),
14703 "::",
14704 stringify!(m_nNumAppDependencies)
14705 )
14706 );
14707 assert_eq!(
14708 unsafe { ::std::ptr::addr_of!((*ptr).m_nTotalNumAppDependencies) as usize - ptr as usize },
14709 144usize,
14710 concat!(
14711 "Offset of field: ",
14712 stringify!(GetAppDependenciesResult_t),
14713 "::",
14714 stringify!(m_nTotalNumAppDependencies)
14715 )
14716 );
14717}
14718#[repr(C, packed(4))]
14719#[derive(Debug, Copy, Clone)]
14720pub struct DeleteItemResult_t {
14721 pub m_eResult: EResult,
14722 pub m_nPublishedFileId: PublishedFileId_t,
14723}
14724pub const DeleteItemResult_t_k_iCallback: DeleteItemResult_t__bindgen_ty_1 =
14725 DeleteItemResult_t__bindgen_ty_1::k_iCallback;
14726#[repr(u32)]
14727#[non_exhaustive]
14728#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14729pub enum DeleteItemResult_t__bindgen_ty_1 {
14730 k_iCallback = 3417,
14731}
14732#[test]
14733fn bindgen_test_layout_DeleteItemResult_t() {
14734 const UNINIT: ::std::mem::MaybeUninit<DeleteItemResult_t> = ::std::mem::MaybeUninit::uninit();
14735 let ptr = UNINIT.as_ptr();
14736 assert_eq!(
14737 ::std::mem::size_of::<DeleteItemResult_t>(),
14738 12usize,
14739 concat!("Size of: ", stringify!(DeleteItemResult_t))
14740 );
14741 assert_eq!(
14742 ::std::mem::align_of::<DeleteItemResult_t>(),
14743 4usize,
14744 concat!("Alignment of ", stringify!(DeleteItemResult_t))
14745 );
14746 assert_eq!(
14747 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14748 0usize,
14749 concat!(
14750 "Offset of field: ",
14751 stringify!(DeleteItemResult_t),
14752 "::",
14753 stringify!(m_eResult)
14754 )
14755 );
14756 assert_eq!(
14757 unsafe { ::std::ptr::addr_of!((*ptr).m_nPublishedFileId) as usize - ptr as usize },
14758 4usize,
14759 concat!(
14760 "Offset of field: ",
14761 stringify!(DeleteItemResult_t),
14762 "::",
14763 stringify!(m_nPublishedFileId)
14764 )
14765 );
14766}
14767#[repr(C)]
14768#[derive(Debug, Copy, Clone)]
14769pub struct UserSubscribedItemsListChanged_t {
14770 pub m_nAppID: AppId_t,
14771}
14772pub const UserSubscribedItemsListChanged_t_k_iCallback:
14773 UserSubscribedItemsListChanged_t__bindgen_ty_1 =
14774 UserSubscribedItemsListChanged_t__bindgen_ty_1::k_iCallback;
14775#[repr(u32)]
14776#[non_exhaustive]
14777#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14778pub enum UserSubscribedItemsListChanged_t__bindgen_ty_1 {
14779 k_iCallback = 3418,
14780}
14781#[test]
14782fn bindgen_test_layout_UserSubscribedItemsListChanged_t() {
14783 const UNINIT: ::std::mem::MaybeUninit<UserSubscribedItemsListChanged_t> =
14784 ::std::mem::MaybeUninit::uninit();
14785 let ptr = UNINIT.as_ptr();
14786 assert_eq!(
14787 ::std::mem::size_of::<UserSubscribedItemsListChanged_t>(),
14788 4usize,
14789 concat!("Size of: ", stringify!(UserSubscribedItemsListChanged_t))
14790 );
14791 assert_eq!(
14792 ::std::mem::align_of::<UserSubscribedItemsListChanged_t>(),
14793 4usize,
14794 concat!(
14795 "Alignment of ",
14796 stringify!(UserSubscribedItemsListChanged_t)
14797 )
14798 );
14799 assert_eq!(
14800 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
14801 0usize,
14802 concat!(
14803 "Offset of field: ",
14804 stringify!(UserSubscribedItemsListChanged_t),
14805 "::",
14806 stringify!(m_nAppID)
14807 )
14808 );
14809}
14810#[repr(C)]
14811#[derive(Debug, Copy, Clone)]
14812pub struct WorkshopEULAStatus_t {
14813 pub m_eResult: EResult,
14814 pub m_nAppID: AppId_t,
14815 pub m_unVersion: uint32,
14816 pub m_rtAction: RTime32,
14817 pub m_bAccepted: bool,
14818 pub m_bNeedsAction: bool,
14819}
14820pub const WorkshopEULAStatus_t_k_iCallback: WorkshopEULAStatus_t__bindgen_ty_1 =
14821 WorkshopEULAStatus_t__bindgen_ty_1::k_iCallback;
14822#[repr(u32)]
14823#[non_exhaustive]
14824#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14825pub enum WorkshopEULAStatus_t__bindgen_ty_1 {
14826 k_iCallback = 3420,
14827}
14828#[test]
14829fn bindgen_test_layout_WorkshopEULAStatus_t() {
14830 const UNINIT: ::std::mem::MaybeUninit<WorkshopEULAStatus_t> = ::std::mem::MaybeUninit::uninit();
14831 let ptr = UNINIT.as_ptr();
14832 assert_eq!(
14833 ::std::mem::size_of::<WorkshopEULAStatus_t>(),
14834 20usize,
14835 concat!("Size of: ", stringify!(WorkshopEULAStatus_t))
14836 );
14837 assert_eq!(
14838 ::std::mem::align_of::<WorkshopEULAStatus_t>(),
14839 4usize,
14840 concat!("Alignment of ", stringify!(WorkshopEULAStatus_t))
14841 );
14842 assert_eq!(
14843 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
14844 0usize,
14845 concat!(
14846 "Offset of field: ",
14847 stringify!(WorkshopEULAStatus_t),
14848 "::",
14849 stringify!(m_eResult)
14850 )
14851 );
14852 assert_eq!(
14853 unsafe { ::std::ptr::addr_of!((*ptr).m_nAppID) as usize - ptr as usize },
14854 4usize,
14855 concat!(
14856 "Offset of field: ",
14857 stringify!(WorkshopEULAStatus_t),
14858 "::",
14859 stringify!(m_nAppID)
14860 )
14861 );
14862 assert_eq!(
14863 unsafe { ::std::ptr::addr_of!((*ptr).m_unVersion) as usize - ptr as usize },
14864 8usize,
14865 concat!(
14866 "Offset of field: ",
14867 stringify!(WorkshopEULAStatus_t),
14868 "::",
14869 stringify!(m_unVersion)
14870 )
14871 );
14872 assert_eq!(
14873 unsafe { ::std::ptr::addr_of!((*ptr).m_rtAction) as usize - ptr as usize },
14874 12usize,
14875 concat!(
14876 "Offset of field: ",
14877 stringify!(WorkshopEULAStatus_t),
14878 "::",
14879 stringify!(m_rtAction)
14880 )
14881 );
14882 assert_eq!(
14883 unsafe { ::std::ptr::addr_of!((*ptr).m_bAccepted) as usize - ptr as usize },
14884 16usize,
14885 concat!(
14886 "Offset of field: ",
14887 stringify!(WorkshopEULAStatus_t),
14888 "::",
14889 stringify!(m_bAccepted)
14890 )
14891 );
14892 assert_eq!(
14893 unsafe { ::std::ptr::addr_of!((*ptr).m_bNeedsAction) as usize - ptr as usize },
14894 17usize,
14895 concat!(
14896 "Offset of field: ",
14897 stringify!(WorkshopEULAStatus_t),
14898 "::",
14899 stringify!(m_bNeedsAction)
14900 )
14901 );
14902}
14903pub type HHTMLBrowser = uint32;
14904pub const INVALID_HTMLBROWSER: uint32 = 0;
14905#[repr(C)]
14906pub struct ISteamHTMLSurface__bindgen_vtable(::std::os::raw::c_void);
14907#[repr(C)]
14908#[derive(Debug)]
14909pub struct ISteamHTMLSurface {
14910 pub vtable_: *const ISteamHTMLSurface__bindgen_vtable,
14911}
14912#[repr(u32)]
14913#[non_exhaustive]
14914#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14915pub enum ISteamHTMLSurface_EHTMLMouseButton {
14916 eHTMLMouseButton_Left = 0,
14917 eHTMLMouseButton_Right = 1,
14918 eHTMLMouseButton_Middle = 2,
14919}
14920#[repr(u32)]
14921#[non_exhaustive]
14922#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14923pub enum ISteamHTMLSurface_EHTMLMouseCursor {
14924 k_EHTMLMouseCursor_User = 0,
14925 k_EHTMLMouseCursor_None = 1,
14926 k_EHTMLMouseCursor_Arrow = 2,
14927 k_EHTMLMouseCursor_IBeam = 3,
14928 k_EHTMLMouseCursor_Hourglass = 4,
14929 k_EHTMLMouseCursor_WaitArrow = 5,
14930 k_EHTMLMouseCursor_Crosshair = 6,
14931 k_EHTMLMouseCursor_Up = 7,
14932 k_EHTMLMouseCursor_SizeNW = 8,
14933 k_EHTMLMouseCursor_SizeSE = 9,
14934 k_EHTMLMouseCursor_SizeNE = 10,
14935 k_EHTMLMouseCursor_SizeSW = 11,
14936 k_EHTMLMouseCursor_SizeW = 12,
14937 k_EHTMLMouseCursor_SizeE = 13,
14938 k_EHTMLMouseCursor_SizeN = 14,
14939 k_EHTMLMouseCursor_SizeS = 15,
14940 k_EHTMLMouseCursor_SizeWE = 16,
14941 k_EHTMLMouseCursor_SizeNS = 17,
14942 k_EHTMLMouseCursor_SizeAll = 18,
14943 k_EHTMLMouseCursor_No = 19,
14944 k_EHTMLMouseCursor_Hand = 20,
14945 k_EHTMLMouseCursor_Blank = 21,
14946 k_EHTMLMouseCursor_MiddlePan = 22,
14947 k_EHTMLMouseCursor_NorthPan = 23,
14948 k_EHTMLMouseCursor_NorthEastPan = 24,
14949 k_EHTMLMouseCursor_EastPan = 25,
14950 k_EHTMLMouseCursor_SouthEastPan = 26,
14951 k_EHTMLMouseCursor_SouthPan = 27,
14952 k_EHTMLMouseCursor_SouthWestPan = 28,
14953 k_EHTMLMouseCursor_WestPan = 29,
14954 k_EHTMLMouseCursor_NorthWestPan = 30,
14955 k_EHTMLMouseCursor_Alias = 31,
14956 k_EHTMLMouseCursor_Cell = 32,
14957 k_EHTMLMouseCursor_ColResize = 33,
14958 k_EHTMLMouseCursor_CopyCur = 34,
14959 k_EHTMLMouseCursor_VerticalText = 35,
14960 k_EHTMLMouseCursor_RowResize = 36,
14961 k_EHTMLMouseCursor_ZoomIn = 37,
14962 k_EHTMLMouseCursor_ZoomOut = 38,
14963 k_EHTMLMouseCursor_Help = 39,
14964 k_EHTMLMouseCursor_Custom = 40,
14965 k_EHTMLMouseCursor_SizeNWSE = 41,
14966 k_EHTMLMouseCursor_SizeNESW = 42,
14967 k_EHTMLMouseCursor_last = 43,
14968}
14969#[repr(u32)]
14970#[non_exhaustive]
14971#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
14972pub enum ISteamHTMLSurface_EHTMLKeyModifiers {
14973 k_eHTMLKeyModifier_None = 0,
14974 k_eHTMLKeyModifier_AltDown = 1,
14975 k_eHTMLKeyModifier_CtrlDown = 2,
14976 k_eHTMLKeyModifier_ShiftDown = 4,
14977}
14978#[test]
14979fn bindgen_test_layout_ISteamHTMLSurface() {
14980 assert_eq!(
14981 ::std::mem::size_of::<ISteamHTMLSurface>(),
14982 8usize,
14983 concat!("Size of: ", stringify!(ISteamHTMLSurface))
14984 );
14985 assert_eq!(
14986 ::std::mem::align_of::<ISteamHTMLSurface>(),
14987 8usize,
14988 concat!("Alignment of ", stringify!(ISteamHTMLSurface))
14989 );
14990}
14991#[repr(C)]
14992#[derive(Debug, Copy, Clone)]
14993pub struct HTML_BrowserReady_t {
14994 pub unBrowserHandle: HHTMLBrowser,
14995}
14996pub const HTML_BrowserReady_t_k_iCallback: HTML_BrowserReady_t__bindgen_ty_1 =
14997 HTML_BrowserReady_t__bindgen_ty_1::k_iCallback;
14998#[repr(u32)]
14999#[non_exhaustive]
15000#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15001pub enum HTML_BrowserReady_t__bindgen_ty_1 {
15002 k_iCallback = 4501,
15003}
15004#[test]
15005fn bindgen_test_layout_HTML_BrowserReady_t() {
15006 const UNINIT: ::std::mem::MaybeUninit<HTML_BrowserReady_t> = ::std::mem::MaybeUninit::uninit();
15007 let ptr = UNINIT.as_ptr();
15008 assert_eq!(
15009 ::std::mem::size_of::<HTML_BrowserReady_t>(),
15010 4usize,
15011 concat!("Size of: ", stringify!(HTML_BrowserReady_t))
15012 );
15013 assert_eq!(
15014 ::std::mem::align_of::<HTML_BrowserReady_t>(),
15015 4usize,
15016 concat!("Alignment of ", stringify!(HTML_BrowserReady_t))
15017 );
15018 assert_eq!(
15019 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15020 0usize,
15021 concat!(
15022 "Offset of field: ",
15023 stringify!(HTML_BrowserReady_t),
15024 "::",
15025 stringify!(unBrowserHandle)
15026 )
15027 );
15028}
15029#[repr(C, packed(4))]
15030#[derive(Debug, Copy, Clone)]
15031pub struct HTML_NeedsPaint_t {
15032 pub unBrowserHandle: HHTMLBrowser,
15033 pub pBGRA: *const ::std::os::raw::c_char,
15034 pub unWide: uint32,
15035 pub unTall: uint32,
15036 pub unUpdateX: uint32,
15037 pub unUpdateY: uint32,
15038 pub unUpdateWide: uint32,
15039 pub unUpdateTall: uint32,
15040 pub unScrollX: uint32,
15041 pub unScrollY: uint32,
15042 pub flPageScale: f32,
15043 pub unPageSerial: uint32,
15044}
15045pub const HTML_NeedsPaint_t_k_iCallback: HTML_NeedsPaint_t__bindgen_ty_1 =
15046 HTML_NeedsPaint_t__bindgen_ty_1::k_iCallback;
15047#[repr(u32)]
15048#[non_exhaustive]
15049#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15050pub enum HTML_NeedsPaint_t__bindgen_ty_1 {
15051 k_iCallback = 4502,
15052}
15053#[test]
15054fn bindgen_test_layout_HTML_NeedsPaint_t() {
15055 const UNINIT: ::std::mem::MaybeUninit<HTML_NeedsPaint_t> = ::std::mem::MaybeUninit::uninit();
15056 let ptr = UNINIT.as_ptr();
15057 assert_eq!(
15058 ::std::mem::size_of::<HTML_NeedsPaint_t>(),
15059 52usize,
15060 concat!("Size of: ", stringify!(HTML_NeedsPaint_t))
15061 );
15062 assert_eq!(
15063 ::std::mem::align_of::<HTML_NeedsPaint_t>(),
15064 4usize,
15065 concat!("Alignment of ", stringify!(HTML_NeedsPaint_t))
15066 );
15067 assert_eq!(
15068 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15069 0usize,
15070 concat!(
15071 "Offset of field: ",
15072 stringify!(HTML_NeedsPaint_t),
15073 "::",
15074 stringify!(unBrowserHandle)
15075 )
15076 );
15077 assert_eq!(
15078 unsafe { ::std::ptr::addr_of!((*ptr).pBGRA) as usize - ptr as usize },
15079 4usize,
15080 concat!(
15081 "Offset of field: ",
15082 stringify!(HTML_NeedsPaint_t),
15083 "::",
15084 stringify!(pBGRA)
15085 )
15086 );
15087 assert_eq!(
15088 unsafe { ::std::ptr::addr_of!((*ptr).unWide) as usize - ptr as usize },
15089 12usize,
15090 concat!(
15091 "Offset of field: ",
15092 stringify!(HTML_NeedsPaint_t),
15093 "::",
15094 stringify!(unWide)
15095 )
15096 );
15097 assert_eq!(
15098 unsafe { ::std::ptr::addr_of!((*ptr).unTall) as usize - ptr as usize },
15099 16usize,
15100 concat!(
15101 "Offset of field: ",
15102 stringify!(HTML_NeedsPaint_t),
15103 "::",
15104 stringify!(unTall)
15105 )
15106 );
15107 assert_eq!(
15108 unsafe { ::std::ptr::addr_of!((*ptr).unUpdateX) as usize - ptr as usize },
15109 20usize,
15110 concat!(
15111 "Offset of field: ",
15112 stringify!(HTML_NeedsPaint_t),
15113 "::",
15114 stringify!(unUpdateX)
15115 )
15116 );
15117 assert_eq!(
15118 unsafe { ::std::ptr::addr_of!((*ptr).unUpdateY) as usize - ptr as usize },
15119 24usize,
15120 concat!(
15121 "Offset of field: ",
15122 stringify!(HTML_NeedsPaint_t),
15123 "::",
15124 stringify!(unUpdateY)
15125 )
15126 );
15127 assert_eq!(
15128 unsafe { ::std::ptr::addr_of!((*ptr).unUpdateWide) as usize - ptr as usize },
15129 28usize,
15130 concat!(
15131 "Offset of field: ",
15132 stringify!(HTML_NeedsPaint_t),
15133 "::",
15134 stringify!(unUpdateWide)
15135 )
15136 );
15137 assert_eq!(
15138 unsafe { ::std::ptr::addr_of!((*ptr).unUpdateTall) as usize - ptr as usize },
15139 32usize,
15140 concat!(
15141 "Offset of field: ",
15142 stringify!(HTML_NeedsPaint_t),
15143 "::",
15144 stringify!(unUpdateTall)
15145 )
15146 );
15147 assert_eq!(
15148 unsafe { ::std::ptr::addr_of!((*ptr).unScrollX) as usize - ptr as usize },
15149 36usize,
15150 concat!(
15151 "Offset of field: ",
15152 stringify!(HTML_NeedsPaint_t),
15153 "::",
15154 stringify!(unScrollX)
15155 )
15156 );
15157 assert_eq!(
15158 unsafe { ::std::ptr::addr_of!((*ptr).unScrollY) as usize - ptr as usize },
15159 40usize,
15160 concat!(
15161 "Offset of field: ",
15162 stringify!(HTML_NeedsPaint_t),
15163 "::",
15164 stringify!(unScrollY)
15165 )
15166 );
15167 assert_eq!(
15168 unsafe { ::std::ptr::addr_of!((*ptr).flPageScale) as usize - ptr as usize },
15169 44usize,
15170 concat!(
15171 "Offset of field: ",
15172 stringify!(HTML_NeedsPaint_t),
15173 "::",
15174 stringify!(flPageScale)
15175 )
15176 );
15177 assert_eq!(
15178 unsafe { ::std::ptr::addr_of!((*ptr).unPageSerial) as usize - ptr as usize },
15179 48usize,
15180 concat!(
15181 "Offset of field: ",
15182 stringify!(HTML_NeedsPaint_t),
15183 "::",
15184 stringify!(unPageSerial)
15185 )
15186 );
15187}
15188#[repr(C, packed(4))]
15189#[derive(Debug, Copy, Clone)]
15190pub struct HTML_StartRequest_t {
15191 pub unBrowserHandle: HHTMLBrowser,
15192 pub pchURL: *const ::std::os::raw::c_char,
15193 pub pchTarget: *const ::std::os::raw::c_char,
15194 pub pchPostData: *const ::std::os::raw::c_char,
15195 pub bIsRedirect: bool,
15196}
15197pub const HTML_StartRequest_t_k_iCallback: HTML_StartRequest_t__bindgen_ty_1 =
15198 HTML_StartRequest_t__bindgen_ty_1::k_iCallback;
15199#[repr(u32)]
15200#[non_exhaustive]
15201#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15202pub enum HTML_StartRequest_t__bindgen_ty_1 {
15203 k_iCallback = 4503,
15204}
15205#[test]
15206fn bindgen_test_layout_HTML_StartRequest_t() {
15207 const UNINIT: ::std::mem::MaybeUninit<HTML_StartRequest_t> = ::std::mem::MaybeUninit::uninit();
15208 let ptr = UNINIT.as_ptr();
15209 assert_eq!(
15210 ::std::mem::size_of::<HTML_StartRequest_t>(),
15211 32usize,
15212 concat!("Size of: ", stringify!(HTML_StartRequest_t))
15213 );
15214 assert_eq!(
15215 ::std::mem::align_of::<HTML_StartRequest_t>(),
15216 4usize,
15217 concat!("Alignment of ", stringify!(HTML_StartRequest_t))
15218 );
15219 assert_eq!(
15220 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15221 0usize,
15222 concat!(
15223 "Offset of field: ",
15224 stringify!(HTML_StartRequest_t),
15225 "::",
15226 stringify!(unBrowserHandle)
15227 )
15228 );
15229 assert_eq!(
15230 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
15231 4usize,
15232 concat!(
15233 "Offset of field: ",
15234 stringify!(HTML_StartRequest_t),
15235 "::",
15236 stringify!(pchURL)
15237 )
15238 );
15239 assert_eq!(
15240 unsafe { ::std::ptr::addr_of!((*ptr).pchTarget) as usize - ptr as usize },
15241 12usize,
15242 concat!(
15243 "Offset of field: ",
15244 stringify!(HTML_StartRequest_t),
15245 "::",
15246 stringify!(pchTarget)
15247 )
15248 );
15249 assert_eq!(
15250 unsafe { ::std::ptr::addr_of!((*ptr).pchPostData) as usize - ptr as usize },
15251 20usize,
15252 concat!(
15253 "Offset of field: ",
15254 stringify!(HTML_StartRequest_t),
15255 "::",
15256 stringify!(pchPostData)
15257 )
15258 );
15259 assert_eq!(
15260 unsafe { ::std::ptr::addr_of!((*ptr).bIsRedirect) as usize - ptr as usize },
15261 28usize,
15262 concat!(
15263 "Offset of field: ",
15264 stringify!(HTML_StartRequest_t),
15265 "::",
15266 stringify!(bIsRedirect)
15267 )
15268 );
15269}
15270#[repr(C)]
15271#[derive(Debug, Copy, Clone)]
15272pub struct HTML_CloseBrowser_t {
15273 pub unBrowserHandle: HHTMLBrowser,
15274}
15275pub const HTML_CloseBrowser_t_k_iCallback: HTML_CloseBrowser_t__bindgen_ty_1 =
15276 HTML_CloseBrowser_t__bindgen_ty_1::k_iCallback;
15277#[repr(u32)]
15278#[non_exhaustive]
15279#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15280pub enum HTML_CloseBrowser_t__bindgen_ty_1 {
15281 k_iCallback = 4504,
15282}
15283#[test]
15284fn bindgen_test_layout_HTML_CloseBrowser_t() {
15285 const UNINIT: ::std::mem::MaybeUninit<HTML_CloseBrowser_t> = ::std::mem::MaybeUninit::uninit();
15286 let ptr = UNINIT.as_ptr();
15287 assert_eq!(
15288 ::std::mem::size_of::<HTML_CloseBrowser_t>(),
15289 4usize,
15290 concat!("Size of: ", stringify!(HTML_CloseBrowser_t))
15291 );
15292 assert_eq!(
15293 ::std::mem::align_of::<HTML_CloseBrowser_t>(),
15294 4usize,
15295 concat!("Alignment of ", stringify!(HTML_CloseBrowser_t))
15296 );
15297 assert_eq!(
15298 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15299 0usize,
15300 concat!(
15301 "Offset of field: ",
15302 stringify!(HTML_CloseBrowser_t),
15303 "::",
15304 stringify!(unBrowserHandle)
15305 )
15306 );
15307}
15308#[repr(C, packed(4))]
15309#[derive(Debug, Copy, Clone)]
15310pub struct HTML_URLChanged_t {
15311 pub unBrowserHandle: HHTMLBrowser,
15312 pub pchURL: *const ::std::os::raw::c_char,
15313 pub pchPostData: *const ::std::os::raw::c_char,
15314 pub bIsRedirect: bool,
15315 pub pchPageTitle: *const ::std::os::raw::c_char,
15316 pub bNewNavigation: bool,
15317}
15318pub const HTML_URLChanged_t_k_iCallback: HTML_URLChanged_t__bindgen_ty_1 =
15319 HTML_URLChanged_t__bindgen_ty_1::k_iCallback;
15320#[repr(u32)]
15321#[non_exhaustive]
15322#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15323pub enum HTML_URLChanged_t__bindgen_ty_1 {
15324 k_iCallback = 4505,
15325}
15326#[test]
15327fn bindgen_test_layout_HTML_URLChanged_t() {
15328 const UNINIT: ::std::mem::MaybeUninit<HTML_URLChanged_t> = ::std::mem::MaybeUninit::uninit();
15329 let ptr = UNINIT.as_ptr();
15330 assert_eq!(
15331 ::std::mem::size_of::<HTML_URLChanged_t>(),
15332 36usize,
15333 concat!("Size of: ", stringify!(HTML_URLChanged_t))
15334 );
15335 assert_eq!(
15336 ::std::mem::align_of::<HTML_URLChanged_t>(),
15337 4usize,
15338 concat!("Alignment of ", stringify!(HTML_URLChanged_t))
15339 );
15340 assert_eq!(
15341 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15342 0usize,
15343 concat!(
15344 "Offset of field: ",
15345 stringify!(HTML_URLChanged_t),
15346 "::",
15347 stringify!(unBrowserHandle)
15348 )
15349 );
15350 assert_eq!(
15351 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
15352 4usize,
15353 concat!(
15354 "Offset of field: ",
15355 stringify!(HTML_URLChanged_t),
15356 "::",
15357 stringify!(pchURL)
15358 )
15359 );
15360 assert_eq!(
15361 unsafe { ::std::ptr::addr_of!((*ptr).pchPostData) as usize - ptr as usize },
15362 12usize,
15363 concat!(
15364 "Offset of field: ",
15365 stringify!(HTML_URLChanged_t),
15366 "::",
15367 stringify!(pchPostData)
15368 )
15369 );
15370 assert_eq!(
15371 unsafe { ::std::ptr::addr_of!((*ptr).bIsRedirect) as usize - ptr as usize },
15372 20usize,
15373 concat!(
15374 "Offset of field: ",
15375 stringify!(HTML_URLChanged_t),
15376 "::",
15377 stringify!(bIsRedirect)
15378 )
15379 );
15380 assert_eq!(
15381 unsafe { ::std::ptr::addr_of!((*ptr).pchPageTitle) as usize - ptr as usize },
15382 24usize,
15383 concat!(
15384 "Offset of field: ",
15385 stringify!(HTML_URLChanged_t),
15386 "::",
15387 stringify!(pchPageTitle)
15388 )
15389 );
15390 assert_eq!(
15391 unsafe { ::std::ptr::addr_of!((*ptr).bNewNavigation) as usize - ptr as usize },
15392 32usize,
15393 concat!(
15394 "Offset of field: ",
15395 stringify!(HTML_URLChanged_t),
15396 "::",
15397 stringify!(bNewNavigation)
15398 )
15399 );
15400}
15401#[repr(C, packed(4))]
15402#[derive(Debug, Copy, Clone)]
15403pub struct HTML_FinishedRequest_t {
15404 pub unBrowserHandle: HHTMLBrowser,
15405 pub pchURL: *const ::std::os::raw::c_char,
15406 pub pchPageTitle: *const ::std::os::raw::c_char,
15407}
15408pub const HTML_FinishedRequest_t_k_iCallback: HTML_FinishedRequest_t__bindgen_ty_1 =
15409 HTML_FinishedRequest_t__bindgen_ty_1::k_iCallback;
15410#[repr(u32)]
15411#[non_exhaustive]
15412#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15413pub enum HTML_FinishedRequest_t__bindgen_ty_1 {
15414 k_iCallback = 4506,
15415}
15416#[test]
15417fn bindgen_test_layout_HTML_FinishedRequest_t() {
15418 const UNINIT: ::std::mem::MaybeUninit<HTML_FinishedRequest_t> =
15419 ::std::mem::MaybeUninit::uninit();
15420 let ptr = UNINIT.as_ptr();
15421 assert_eq!(
15422 ::std::mem::size_of::<HTML_FinishedRequest_t>(),
15423 20usize,
15424 concat!("Size of: ", stringify!(HTML_FinishedRequest_t))
15425 );
15426 assert_eq!(
15427 ::std::mem::align_of::<HTML_FinishedRequest_t>(),
15428 4usize,
15429 concat!("Alignment of ", stringify!(HTML_FinishedRequest_t))
15430 );
15431 assert_eq!(
15432 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15433 0usize,
15434 concat!(
15435 "Offset of field: ",
15436 stringify!(HTML_FinishedRequest_t),
15437 "::",
15438 stringify!(unBrowserHandle)
15439 )
15440 );
15441 assert_eq!(
15442 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
15443 4usize,
15444 concat!(
15445 "Offset of field: ",
15446 stringify!(HTML_FinishedRequest_t),
15447 "::",
15448 stringify!(pchURL)
15449 )
15450 );
15451 assert_eq!(
15452 unsafe { ::std::ptr::addr_of!((*ptr).pchPageTitle) as usize - ptr as usize },
15453 12usize,
15454 concat!(
15455 "Offset of field: ",
15456 stringify!(HTML_FinishedRequest_t),
15457 "::",
15458 stringify!(pchPageTitle)
15459 )
15460 );
15461}
15462#[repr(C, packed(4))]
15463#[derive(Debug, Copy, Clone)]
15464pub struct HTML_OpenLinkInNewTab_t {
15465 pub unBrowserHandle: HHTMLBrowser,
15466 pub pchURL: *const ::std::os::raw::c_char,
15467}
15468pub const HTML_OpenLinkInNewTab_t_k_iCallback: HTML_OpenLinkInNewTab_t__bindgen_ty_1 =
15469 HTML_OpenLinkInNewTab_t__bindgen_ty_1::k_iCallback;
15470#[repr(u32)]
15471#[non_exhaustive]
15472#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15473pub enum HTML_OpenLinkInNewTab_t__bindgen_ty_1 {
15474 k_iCallback = 4507,
15475}
15476#[test]
15477fn bindgen_test_layout_HTML_OpenLinkInNewTab_t() {
15478 const UNINIT: ::std::mem::MaybeUninit<HTML_OpenLinkInNewTab_t> =
15479 ::std::mem::MaybeUninit::uninit();
15480 let ptr = UNINIT.as_ptr();
15481 assert_eq!(
15482 ::std::mem::size_of::<HTML_OpenLinkInNewTab_t>(),
15483 12usize,
15484 concat!("Size of: ", stringify!(HTML_OpenLinkInNewTab_t))
15485 );
15486 assert_eq!(
15487 ::std::mem::align_of::<HTML_OpenLinkInNewTab_t>(),
15488 4usize,
15489 concat!("Alignment of ", stringify!(HTML_OpenLinkInNewTab_t))
15490 );
15491 assert_eq!(
15492 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15493 0usize,
15494 concat!(
15495 "Offset of field: ",
15496 stringify!(HTML_OpenLinkInNewTab_t),
15497 "::",
15498 stringify!(unBrowserHandle)
15499 )
15500 );
15501 assert_eq!(
15502 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
15503 4usize,
15504 concat!(
15505 "Offset of field: ",
15506 stringify!(HTML_OpenLinkInNewTab_t),
15507 "::",
15508 stringify!(pchURL)
15509 )
15510 );
15511}
15512#[repr(C, packed(4))]
15513#[derive(Debug, Copy, Clone)]
15514pub struct HTML_ChangedTitle_t {
15515 pub unBrowserHandle: HHTMLBrowser,
15516 pub pchTitle: *const ::std::os::raw::c_char,
15517}
15518pub const HTML_ChangedTitle_t_k_iCallback: HTML_ChangedTitle_t__bindgen_ty_1 =
15519 HTML_ChangedTitle_t__bindgen_ty_1::k_iCallback;
15520#[repr(u32)]
15521#[non_exhaustive]
15522#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15523pub enum HTML_ChangedTitle_t__bindgen_ty_1 {
15524 k_iCallback = 4508,
15525}
15526#[test]
15527fn bindgen_test_layout_HTML_ChangedTitle_t() {
15528 const UNINIT: ::std::mem::MaybeUninit<HTML_ChangedTitle_t> = ::std::mem::MaybeUninit::uninit();
15529 let ptr = UNINIT.as_ptr();
15530 assert_eq!(
15531 ::std::mem::size_of::<HTML_ChangedTitle_t>(),
15532 12usize,
15533 concat!("Size of: ", stringify!(HTML_ChangedTitle_t))
15534 );
15535 assert_eq!(
15536 ::std::mem::align_of::<HTML_ChangedTitle_t>(),
15537 4usize,
15538 concat!("Alignment of ", stringify!(HTML_ChangedTitle_t))
15539 );
15540 assert_eq!(
15541 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15542 0usize,
15543 concat!(
15544 "Offset of field: ",
15545 stringify!(HTML_ChangedTitle_t),
15546 "::",
15547 stringify!(unBrowserHandle)
15548 )
15549 );
15550 assert_eq!(
15551 unsafe { ::std::ptr::addr_of!((*ptr).pchTitle) as usize - ptr as usize },
15552 4usize,
15553 concat!(
15554 "Offset of field: ",
15555 stringify!(HTML_ChangedTitle_t),
15556 "::",
15557 stringify!(pchTitle)
15558 )
15559 );
15560}
15561#[repr(C)]
15562#[derive(Debug, Copy, Clone)]
15563pub struct HTML_SearchResults_t {
15564 pub unBrowserHandle: HHTMLBrowser,
15565 pub unResults: uint32,
15566 pub unCurrentMatch: uint32,
15567}
15568pub const HTML_SearchResults_t_k_iCallback: HTML_SearchResults_t__bindgen_ty_1 =
15569 HTML_SearchResults_t__bindgen_ty_1::k_iCallback;
15570#[repr(u32)]
15571#[non_exhaustive]
15572#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15573pub enum HTML_SearchResults_t__bindgen_ty_1 {
15574 k_iCallback = 4509,
15575}
15576#[test]
15577fn bindgen_test_layout_HTML_SearchResults_t() {
15578 const UNINIT: ::std::mem::MaybeUninit<HTML_SearchResults_t> = ::std::mem::MaybeUninit::uninit();
15579 let ptr = UNINIT.as_ptr();
15580 assert_eq!(
15581 ::std::mem::size_of::<HTML_SearchResults_t>(),
15582 12usize,
15583 concat!("Size of: ", stringify!(HTML_SearchResults_t))
15584 );
15585 assert_eq!(
15586 ::std::mem::align_of::<HTML_SearchResults_t>(),
15587 4usize,
15588 concat!("Alignment of ", stringify!(HTML_SearchResults_t))
15589 );
15590 assert_eq!(
15591 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15592 0usize,
15593 concat!(
15594 "Offset of field: ",
15595 stringify!(HTML_SearchResults_t),
15596 "::",
15597 stringify!(unBrowserHandle)
15598 )
15599 );
15600 assert_eq!(
15601 unsafe { ::std::ptr::addr_of!((*ptr).unResults) as usize - ptr as usize },
15602 4usize,
15603 concat!(
15604 "Offset of field: ",
15605 stringify!(HTML_SearchResults_t),
15606 "::",
15607 stringify!(unResults)
15608 )
15609 );
15610 assert_eq!(
15611 unsafe { ::std::ptr::addr_of!((*ptr).unCurrentMatch) as usize - ptr as usize },
15612 8usize,
15613 concat!(
15614 "Offset of field: ",
15615 stringify!(HTML_SearchResults_t),
15616 "::",
15617 stringify!(unCurrentMatch)
15618 )
15619 );
15620}
15621#[repr(C)]
15622#[derive(Debug, Copy, Clone)]
15623pub struct HTML_CanGoBackAndForward_t {
15624 pub unBrowserHandle: HHTMLBrowser,
15625 pub bCanGoBack: bool,
15626 pub bCanGoForward: bool,
15627}
15628pub const HTML_CanGoBackAndForward_t_k_iCallback: HTML_CanGoBackAndForward_t__bindgen_ty_1 =
15629 HTML_CanGoBackAndForward_t__bindgen_ty_1::k_iCallback;
15630#[repr(u32)]
15631#[non_exhaustive]
15632#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15633pub enum HTML_CanGoBackAndForward_t__bindgen_ty_1 {
15634 k_iCallback = 4510,
15635}
15636#[test]
15637fn bindgen_test_layout_HTML_CanGoBackAndForward_t() {
15638 const UNINIT: ::std::mem::MaybeUninit<HTML_CanGoBackAndForward_t> =
15639 ::std::mem::MaybeUninit::uninit();
15640 let ptr = UNINIT.as_ptr();
15641 assert_eq!(
15642 ::std::mem::size_of::<HTML_CanGoBackAndForward_t>(),
15643 8usize,
15644 concat!("Size of: ", stringify!(HTML_CanGoBackAndForward_t))
15645 );
15646 assert_eq!(
15647 ::std::mem::align_of::<HTML_CanGoBackAndForward_t>(),
15648 4usize,
15649 concat!("Alignment of ", stringify!(HTML_CanGoBackAndForward_t))
15650 );
15651 assert_eq!(
15652 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15653 0usize,
15654 concat!(
15655 "Offset of field: ",
15656 stringify!(HTML_CanGoBackAndForward_t),
15657 "::",
15658 stringify!(unBrowserHandle)
15659 )
15660 );
15661 assert_eq!(
15662 unsafe { ::std::ptr::addr_of!((*ptr).bCanGoBack) as usize - ptr as usize },
15663 4usize,
15664 concat!(
15665 "Offset of field: ",
15666 stringify!(HTML_CanGoBackAndForward_t),
15667 "::",
15668 stringify!(bCanGoBack)
15669 )
15670 );
15671 assert_eq!(
15672 unsafe { ::std::ptr::addr_of!((*ptr).bCanGoForward) as usize - ptr as usize },
15673 5usize,
15674 concat!(
15675 "Offset of field: ",
15676 stringify!(HTML_CanGoBackAndForward_t),
15677 "::",
15678 stringify!(bCanGoForward)
15679 )
15680 );
15681}
15682#[repr(C)]
15683#[derive(Debug, Copy, Clone)]
15684pub struct HTML_HorizontalScroll_t {
15685 pub unBrowserHandle: HHTMLBrowser,
15686 pub unScrollMax: uint32,
15687 pub unScrollCurrent: uint32,
15688 pub flPageScale: f32,
15689 pub bVisible: bool,
15690 pub unPageSize: uint32,
15691}
15692pub const HTML_HorizontalScroll_t_k_iCallback: HTML_HorizontalScroll_t__bindgen_ty_1 =
15693 HTML_HorizontalScroll_t__bindgen_ty_1::k_iCallback;
15694#[repr(u32)]
15695#[non_exhaustive]
15696#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15697pub enum HTML_HorizontalScroll_t__bindgen_ty_1 {
15698 k_iCallback = 4511,
15699}
15700#[test]
15701fn bindgen_test_layout_HTML_HorizontalScroll_t() {
15702 const UNINIT: ::std::mem::MaybeUninit<HTML_HorizontalScroll_t> =
15703 ::std::mem::MaybeUninit::uninit();
15704 let ptr = UNINIT.as_ptr();
15705 assert_eq!(
15706 ::std::mem::size_of::<HTML_HorizontalScroll_t>(),
15707 24usize,
15708 concat!("Size of: ", stringify!(HTML_HorizontalScroll_t))
15709 );
15710 assert_eq!(
15711 ::std::mem::align_of::<HTML_HorizontalScroll_t>(),
15712 4usize,
15713 concat!("Alignment of ", stringify!(HTML_HorizontalScroll_t))
15714 );
15715 assert_eq!(
15716 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15717 0usize,
15718 concat!(
15719 "Offset of field: ",
15720 stringify!(HTML_HorizontalScroll_t),
15721 "::",
15722 stringify!(unBrowserHandle)
15723 )
15724 );
15725 assert_eq!(
15726 unsafe { ::std::ptr::addr_of!((*ptr).unScrollMax) as usize - ptr as usize },
15727 4usize,
15728 concat!(
15729 "Offset of field: ",
15730 stringify!(HTML_HorizontalScroll_t),
15731 "::",
15732 stringify!(unScrollMax)
15733 )
15734 );
15735 assert_eq!(
15736 unsafe { ::std::ptr::addr_of!((*ptr).unScrollCurrent) as usize - ptr as usize },
15737 8usize,
15738 concat!(
15739 "Offset of field: ",
15740 stringify!(HTML_HorizontalScroll_t),
15741 "::",
15742 stringify!(unScrollCurrent)
15743 )
15744 );
15745 assert_eq!(
15746 unsafe { ::std::ptr::addr_of!((*ptr).flPageScale) as usize - ptr as usize },
15747 12usize,
15748 concat!(
15749 "Offset of field: ",
15750 stringify!(HTML_HorizontalScroll_t),
15751 "::",
15752 stringify!(flPageScale)
15753 )
15754 );
15755 assert_eq!(
15756 unsafe { ::std::ptr::addr_of!((*ptr).bVisible) as usize - ptr as usize },
15757 16usize,
15758 concat!(
15759 "Offset of field: ",
15760 stringify!(HTML_HorizontalScroll_t),
15761 "::",
15762 stringify!(bVisible)
15763 )
15764 );
15765 assert_eq!(
15766 unsafe { ::std::ptr::addr_of!((*ptr).unPageSize) as usize - ptr as usize },
15767 20usize,
15768 concat!(
15769 "Offset of field: ",
15770 stringify!(HTML_HorizontalScroll_t),
15771 "::",
15772 stringify!(unPageSize)
15773 )
15774 );
15775}
15776#[repr(C)]
15777#[derive(Debug, Copy, Clone)]
15778pub struct HTML_VerticalScroll_t {
15779 pub unBrowserHandle: HHTMLBrowser,
15780 pub unScrollMax: uint32,
15781 pub unScrollCurrent: uint32,
15782 pub flPageScale: f32,
15783 pub bVisible: bool,
15784 pub unPageSize: uint32,
15785}
15786pub const HTML_VerticalScroll_t_k_iCallback: HTML_VerticalScroll_t__bindgen_ty_1 =
15787 HTML_VerticalScroll_t__bindgen_ty_1::k_iCallback;
15788#[repr(u32)]
15789#[non_exhaustive]
15790#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15791pub enum HTML_VerticalScroll_t__bindgen_ty_1 {
15792 k_iCallback = 4512,
15793}
15794#[test]
15795fn bindgen_test_layout_HTML_VerticalScroll_t() {
15796 const UNINIT: ::std::mem::MaybeUninit<HTML_VerticalScroll_t> =
15797 ::std::mem::MaybeUninit::uninit();
15798 let ptr = UNINIT.as_ptr();
15799 assert_eq!(
15800 ::std::mem::size_of::<HTML_VerticalScroll_t>(),
15801 24usize,
15802 concat!("Size of: ", stringify!(HTML_VerticalScroll_t))
15803 );
15804 assert_eq!(
15805 ::std::mem::align_of::<HTML_VerticalScroll_t>(),
15806 4usize,
15807 concat!("Alignment of ", stringify!(HTML_VerticalScroll_t))
15808 );
15809 assert_eq!(
15810 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15811 0usize,
15812 concat!(
15813 "Offset of field: ",
15814 stringify!(HTML_VerticalScroll_t),
15815 "::",
15816 stringify!(unBrowserHandle)
15817 )
15818 );
15819 assert_eq!(
15820 unsafe { ::std::ptr::addr_of!((*ptr).unScrollMax) as usize - ptr as usize },
15821 4usize,
15822 concat!(
15823 "Offset of field: ",
15824 stringify!(HTML_VerticalScroll_t),
15825 "::",
15826 stringify!(unScrollMax)
15827 )
15828 );
15829 assert_eq!(
15830 unsafe { ::std::ptr::addr_of!((*ptr).unScrollCurrent) as usize - ptr as usize },
15831 8usize,
15832 concat!(
15833 "Offset of field: ",
15834 stringify!(HTML_VerticalScroll_t),
15835 "::",
15836 stringify!(unScrollCurrent)
15837 )
15838 );
15839 assert_eq!(
15840 unsafe { ::std::ptr::addr_of!((*ptr).flPageScale) as usize - ptr as usize },
15841 12usize,
15842 concat!(
15843 "Offset of field: ",
15844 stringify!(HTML_VerticalScroll_t),
15845 "::",
15846 stringify!(flPageScale)
15847 )
15848 );
15849 assert_eq!(
15850 unsafe { ::std::ptr::addr_of!((*ptr).bVisible) as usize - ptr as usize },
15851 16usize,
15852 concat!(
15853 "Offset of field: ",
15854 stringify!(HTML_VerticalScroll_t),
15855 "::",
15856 stringify!(bVisible)
15857 )
15858 );
15859 assert_eq!(
15860 unsafe { ::std::ptr::addr_of!((*ptr).unPageSize) as usize - ptr as usize },
15861 20usize,
15862 concat!(
15863 "Offset of field: ",
15864 stringify!(HTML_VerticalScroll_t),
15865 "::",
15866 stringify!(unPageSize)
15867 )
15868 );
15869}
15870#[repr(C, packed(4))]
15871#[derive(Debug, Copy, Clone)]
15872pub struct HTML_LinkAtPosition_t {
15873 pub unBrowserHandle: HHTMLBrowser,
15874 pub x: uint32,
15875 pub y: uint32,
15876 pub pchURL: *const ::std::os::raw::c_char,
15877 pub bInput: bool,
15878 pub bLiveLink: bool,
15879}
15880pub const HTML_LinkAtPosition_t_k_iCallback: HTML_LinkAtPosition_t__bindgen_ty_1 =
15881 HTML_LinkAtPosition_t__bindgen_ty_1::k_iCallback;
15882#[repr(u32)]
15883#[non_exhaustive]
15884#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15885pub enum HTML_LinkAtPosition_t__bindgen_ty_1 {
15886 k_iCallback = 4513,
15887}
15888#[test]
15889fn bindgen_test_layout_HTML_LinkAtPosition_t() {
15890 const UNINIT: ::std::mem::MaybeUninit<HTML_LinkAtPosition_t> =
15891 ::std::mem::MaybeUninit::uninit();
15892 let ptr = UNINIT.as_ptr();
15893 assert_eq!(
15894 ::std::mem::size_of::<HTML_LinkAtPosition_t>(),
15895 24usize,
15896 concat!("Size of: ", stringify!(HTML_LinkAtPosition_t))
15897 );
15898 assert_eq!(
15899 ::std::mem::align_of::<HTML_LinkAtPosition_t>(),
15900 4usize,
15901 concat!("Alignment of ", stringify!(HTML_LinkAtPosition_t))
15902 );
15903 assert_eq!(
15904 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15905 0usize,
15906 concat!(
15907 "Offset of field: ",
15908 stringify!(HTML_LinkAtPosition_t),
15909 "::",
15910 stringify!(unBrowserHandle)
15911 )
15912 );
15913 assert_eq!(
15914 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
15915 4usize,
15916 concat!(
15917 "Offset of field: ",
15918 stringify!(HTML_LinkAtPosition_t),
15919 "::",
15920 stringify!(x)
15921 )
15922 );
15923 assert_eq!(
15924 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
15925 8usize,
15926 concat!(
15927 "Offset of field: ",
15928 stringify!(HTML_LinkAtPosition_t),
15929 "::",
15930 stringify!(y)
15931 )
15932 );
15933 assert_eq!(
15934 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
15935 12usize,
15936 concat!(
15937 "Offset of field: ",
15938 stringify!(HTML_LinkAtPosition_t),
15939 "::",
15940 stringify!(pchURL)
15941 )
15942 );
15943 assert_eq!(
15944 unsafe { ::std::ptr::addr_of!((*ptr).bInput) as usize - ptr as usize },
15945 20usize,
15946 concat!(
15947 "Offset of field: ",
15948 stringify!(HTML_LinkAtPosition_t),
15949 "::",
15950 stringify!(bInput)
15951 )
15952 );
15953 assert_eq!(
15954 unsafe { ::std::ptr::addr_of!((*ptr).bLiveLink) as usize - ptr as usize },
15955 21usize,
15956 concat!(
15957 "Offset of field: ",
15958 stringify!(HTML_LinkAtPosition_t),
15959 "::",
15960 stringify!(bLiveLink)
15961 )
15962 );
15963}
15964#[repr(C, packed(4))]
15965#[derive(Debug, Copy, Clone)]
15966pub struct HTML_JSAlert_t {
15967 pub unBrowserHandle: HHTMLBrowser,
15968 pub pchMessage: *const ::std::os::raw::c_char,
15969}
15970pub const HTML_JSAlert_t_k_iCallback: HTML_JSAlert_t__bindgen_ty_1 =
15971 HTML_JSAlert_t__bindgen_ty_1::k_iCallback;
15972#[repr(u32)]
15973#[non_exhaustive]
15974#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
15975pub enum HTML_JSAlert_t__bindgen_ty_1 {
15976 k_iCallback = 4514,
15977}
15978#[test]
15979fn bindgen_test_layout_HTML_JSAlert_t() {
15980 const UNINIT: ::std::mem::MaybeUninit<HTML_JSAlert_t> = ::std::mem::MaybeUninit::uninit();
15981 let ptr = UNINIT.as_ptr();
15982 assert_eq!(
15983 ::std::mem::size_of::<HTML_JSAlert_t>(),
15984 12usize,
15985 concat!("Size of: ", stringify!(HTML_JSAlert_t))
15986 );
15987 assert_eq!(
15988 ::std::mem::align_of::<HTML_JSAlert_t>(),
15989 4usize,
15990 concat!("Alignment of ", stringify!(HTML_JSAlert_t))
15991 );
15992 assert_eq!(
15993 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
15994 0usize,
15995 concat!(
15996 "Offset of field: ",
15997 stringify!(HTML_JSAlert_t),
15998 "::",
15999 stringify!(unBrowserHandle)
16000 )
16001 );
16002 assert_eq!(
16003 unsafe { ::std::ptr::addr_of!((*ptr).pchMessage) as usize - ptr as usize },
16004 4usize,
16005 concat!(
16006 "Offset of field: ",
16007 stringify!(HTML_JSAlert_t),
16008 "::",
16009 stringify!(pchMessage)
16010 )
16011 );
16012}
16013#[repr(C, packed(4))]
16014#[derive(Debug, Copy, Clone)]
16015pub struct HTML_JSConfirm_t {
16016 pub unBrowserHandle: HHTMLBrowser,
16017 pub pchMessage: *const ::std::os::raw::c_char,
16018}
16019pub const HTML_JSConfirm_t_k_iCallback: HTML_JSConfirm_t__bindgen_ty_1 =
16020 HTML_JSConfirm_t__bindgen_ty_1::k_iCallback;
16021#[repr(u32)]
16022#[non_exhaustive]
16023#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16024pub enum HTML_JSConfirm_t__bindgen_ty_1 {
16025 k_iCallback = 4515,
16026}
16027#[test]
16028fn bindgen_test_layout_HTML_JSConfirm_t() {
16029 const UNINIT: ::std::mem::MaybeUninit<HTML_JSConfirm_t> = ::std::mem::MaybeUninit::uninit();
16030 let ptr = UNINIT.as_ptr();
16031 assert_eq!(
16032 ::std::mem::size_of::<HTML_JSConfirm_t>(),
16033 12usize,
16034 concat!("Size of: ", stringify!(HTML_JSConfirm_t))
16035 );
16036 assert_eq!(
16037 ::std::mem::align_of::<HTML_JSConfirm_t>(),
16038 4usize,
16039 concat!("Alignment of ", stringify!(HTML_JSConfirm_t))
16040 );
16041 assert_eq!(
16042 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16043 0usize,
16044 concat!(
16045 "Offset of field: ",
16046 stringify!(HTML_JSConfirm_t),
16047 "::",
16048 stringify!(unBrowserHandle)
16049 )
16050 );
16051 assert_eq!(
16052 unsafe { ::std::ptr::addr_of!((*ptr).pchMessage) as usize - ptr as usize },
16053 4usize,
16054 concat!(
16055 "Offset of field: ",
16056 stringify!(HTML_JSConfirm_t),
16057 "::",
16058 stringify!(pchMessage)
16059 )
16060 );
16061}
16062#[repr(C, packed(4))]
16063#[derive(Debug, Copy, Clone)]
16064pub struct HTML_FileOpenDialog_t {
16065 pub unBrowserHandle: HHTMLBrowser,
16066 pub pchTitle: *const ::std::os::raw::c_char,
16067 pub pchInitialFile: *const ::std::os::raw::c_char,
16068}
16069pub const HTML_FileOpenDialog_t_k_iCallback: HTML_FileOpenDialog_t__bindgen_ty_1 =
16070 HTML_FileOpenDialog_t__bindgen_ty_1::k_iCallback;
16071#[repr(u32)]
16072#[non_exhaustive]
16073#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16074pub enum HTML_FileOpenDialog_t__bindgen_ty_1 {
16075 k_iCallback = 4516,
16076}
16077#[test]
16078fn bindgen_test_layout_HTML_FileOpenDialog_t() {
16079 const UNINIT: ::std::mem::MaybeUninit<HTML_FileOpenDialog_t> =
16080 ::std::mem::MaybeUninit::uninit();
16081 let ptr = UNINIT.as_ptr();
16082 assert_eq!(
16083 ::std::mem::size_of::<HTML_FileOpenDialog_t>(),
16084 20usize,
16085 concat!("Size of: ", stringify!(HTML_FileOpenDialog_t))
16086 );
16087 assert_eq!(
16088 ::std::mem::align_of::<HTML_FileOpenDialog_t>(),
16089 4usize,
16090 concat!("Alignment of ", stringify!(HTML_FileOpenDialog_t))
16091 );
16092 assert_eq!(
16093 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16094 0usize,
16095 concat!(
16096 "Offset of field: ",
16097 stringify!(HTML_FileOpenDialog_t),
16098 "::",
16099 stringify!(unBrowserHandle)
16100 )
16101 );
16102 assert_eq!(
16103 unsafe { ::std::ptr::addr_of!((*ptr).pchTitle) as usize - ptr as usize },
16104 4usize,
16105 concat!(
16106 "Offset of field: ",
16107 stringify!(HTML_FileOpenDialog_t),
16108 "::",
16109 stringify!(pchTitle)
16110 )
16111 );
16112 assert_eq!(
16113 unsafe { ::std::ptr::addr_of!((*ptr).pchInitialFile) as usize - ptr as usize },
16114 12usize,
16115 concat!(
16116 "Offset of field: ",
16117 stringify!(HTML_FileOpenDialog_t),
16118 "::",
16119 stringify!(pchInitialFile)
16120 )
16121 );
16122}
16123#[repr(C, packed(4))]
16124#[derive(Debug, Copy, Clone)]
16125pub struct HTML_NewWindow_t {
16126 pub unBrowserHandle: HHTMLBrowser,
16127 pub pchURL: *const ::std::os::raw::c_char,
16128 pub unX: uint32,
16129 pub unY: uint32,
16130 pub unWide: uint32,
16131 pub unTall: uint32,
16132 pub unNewWindow_BrowserHandle_IGNORE: HHTMLBrowser,
16133}
16134pub const HTML_NewWindow_t_k_iCallback: HTML_NewWindow_t__bindgen_ty_1 =
16135 HTML_NewWindow_t__bindgen_ty_1::k_iCallback;
16136#[repr(u32)]
16137#[non_exhaustive]
16138#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16139pub enum HTML_NewWindow_t__bindgen_ty_1 {
16140 k_iCallback = 4521,
16141}
16142#[test]
16143fn bindgen_test_layout_HTML_NewWindow_t() {
16144 const UNINIT: ::std::mem::MaybeUninit<HTML_NewWindow_t> = ::std::mem::MaybeUninit::uninit();
16145 let ptr = UNINIT.as_ptr();
16146 assert_eq!(
16147 ::std::mem::size_of::<HTML_NewWindow_t>(),
16148 32usize,
16149 concat!("Size of: ", stringify!(HTML_NewWindow_t))
16150 );
16151 assert_eq!(
16152 ::std::mem::align_of::<HTML_NewWindow_t>(),
16153 4usize,
16154 concat!("Alignment of ", stringify!(HTML_NewWindow_t))
16155 );
16156 assert_eq!(
16157 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16158 0usize,
16159 concat!(
16160 "Offset of field: ",
16161 stringify!(HTML_NewWindow_t),
16162 "::",
16163 stringify!(unBrowserHandle)
16164 )
16165 );
16166 assert_eq!(
16167 unsafe { ::std::ptr::addr_of!((*ptr).pchURL) as usize - ptr as usize },
16168 4usize,
16169 concat!(
16170 "Offset of field: ",
16171 stringify!(HTML_NewWindow_t),
16172 "::",
16173 stringify!(pchURL)
16174 )
16175 );
16176 assert_eq!(
16177 unsafe { ::std::ptr::addr_of!((*ptr).unX) as usize - ptr as usize },
16178 12usize,
16179 concat!(
16180 "Offset of field: ",
16181 stringify!(HTML_NewWindow_t),
16182 "::",
16183 stringify!(unX)
16184 )
16185 );
16186 assert_eq!(
16187 unsafe { ::std::ptr::addr_of!((*ptr).unY) as usize - ptr as usize },
16188 16usize,
16189 concat!(
16190 "Offset of field: ",
16191 stringify!(HTML_NewWindow_t),
16192 "::",
16193 stringify!(unY)
16194 )
16195 );
16196 assert_eq!(
16197 unsafe { ::std::ptr::addr_of!((*ptr).unWide) as usize - ptr as usize },
16198 20usize,
16199 concat!(
16200 "Offset of field: ",
16201 stringify!(HTML_NewWindow_t),
16202 "::",
16203 stringify!(unWide)
16204 )
16205 );
16206 assert_eq!(
16207 unsafe { ::std::ptr::addr_of!((*ptr).unTall) as usize - ptr as usize },
16208 24usize,
16209 concat!(
16210 "Offset of field: ",
16211 stringify!(HTML_NewWindow_t),
16212 "::",
16213 stringify!(unTall)
16214 )
16215 );
16216 assert_eq!(
16217 unsafe {
16218 ::std::ptr::addr_of!((*ptr).unNewWindow_BrowserHandle_IGNORE) as usize - ptr as usize
16219 },
16220 28usize,
16221 concat!(
16222 "Offset of field: ",
16223 stringify!(HTML_NewWindow_t),
16224 "::",
16225 stringify!(unNewWindow_BrowserHandle_IGNORE)
16226 )
16227 );
16228}
16229#[repr(C)]
16230#[derive(Debug, Copy, Clone)]
16231pub struct HTML_SetCursor_t {
16232 pub unBrowserHandle: HHTMLBrowser,
16233 pub eMouseCursor: uint32,
16234}
16235pub const HTML_SetCursor_t_k_iCallback: HTML_SetCursor_t__bindgen_ty_1 =
16236 HTML_SetCursor_t__bindgen_ty_1::k_iCallback;
16237#[repr(u32)]
16238#[non_exhaustive]
16239#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16240pub enum HTML_SetCursor_t__bindgen_ty_1 {
16241 k_iCallback = 4522,
16242}
16243#[test]
16244fn bindgen_test_layout_HTML_SetCursor_t() {
16245 const UNINIT: ::std::mem::MaybeUninit<HTML_SetCursor_t> = ::std::mem::MaybeUninit::uninit();
16246 let ptr = UNINIT.as_ptr();
16247 assert_eq!(
16248 ::std::mem::size_of::<HTML_SetCursor_t>(),
16249 8usize,
16250 concat!("Size of: ", stringify!(HTML_SetCursor_t))
16251 );
16252 assert_eq!(
16253 ::std::mem::align_of::<HTML_SetCursor_t>(),
16254 4usize,
16255 concat!("Alignment of ", stringify!(HTML_SetCursor_t))
16256 );
16257 assert_eq!(
16258 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16259 0usize,
16260 concat!(
16261 "Offset of field: ",
16262 stringify!(HTML_SetCursor_t),
16263 "::",
16264 stringify!(unBrowserHandle)
16265 )
16266 );
16267 assert_eq!(
16268 unsafe { ::std::ptr::addr_of!((*ptr).eMouseCursor) as usize - ptr as usize },
16269 4usize,
16270 concat!(
16271 "Offset of field: ",
16272 stringify!(HTML_SetCursor_t),
16273 "::",
16274 stringify!(eMouseCursor)
16275 )
16276 );
16277}
16278#[repr(C, packed(4))]
16279#[derive(Debug, Copy, Clone)]
16280pub struct HTML_StatusText_t {
16281 pub unBrowserHandle: HHTMLBrowser,
16282 pub pchMsg: *const ::std::os::raw::c_char,
16283}
16284pub const HTML_StatusText_t_k_iCallback: HTML_StatusText_t__bindgen_ty_1 =
16285 HTML_StatusText_t__bindgen_ty_1::k_iCallback;
16286#[repr(u32)]
16287#[non_exhaustive]
16288#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16289pub enum HTML_StatusText_t__bindgen_ty_1 {
16290 k_iCallback = 4523,
16291}
16292#[test]
16293fn bindgen_test_layout_HTML_StatusText_t() {
16294 const UNINIT: ::std::mem::MaybeUninit<HTML_StatusText_t> = ::std::mem::MaybeUninit::uninit();
16295 let ptr = UNINIT.as_ptr();
16296 assert_eq!(
16297 ::std::mem::size_of::<HTML_StatusText_t>(),
16298 12usize,
16299 concat!("Size of: ", stringify!(HTML_StatusText_t))
16300 );
16301 assert_eq!(
16302 ::std::mem::align_of::<HTML_StatusText_t>(),
16303 4usize,
16304 concat!("Alignment of ", stringify!(HTML_StatusText_t))
16305 );
16306 assert_eq!(
16307 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16308 0usize,
16309 concat!(
16310 "Offset of field: ",
16311 stringify!(HTML_StatusText_t),
16312 "::",
16313 stringify!(unBrowserHandle)
16314 )
16315 );
16316 assert_eq!(
16317 unsafe { ::std::ptr::addr_of!((*ptr).pchMsg) as usize - ptr as usize },
16318 4usize,
16319 concat!(
16320 "Offset of field: ",
16321 stringify!(HTML_StatusText_t),
16322 "::",
16323 stringify!(pchMsg)
16324 )
16325 );
16326}
16327#[repr(C, packed(4))]
16328#[derive(Debug, Copy, Clone)]
16329pub struct HTML_ShowToolTip_t {
16330 pub unBrowserHandle: HHTMLBrowser,
16331 pub pchMsg: *const ::std::os::raw::c_char,
16332}
16333pub const HTML_ShowToolTip_t_k_iCallback: HTML_ShowToolTip_t__bindgen_ty_1 =
16334 HTML_ShowToolTip_t__bindgen_ty_1::k_iCallback;
16335#[repr(u32)]
16336#[non_exhaustive]
16337#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16338pub enum HTML_ShowToolTip_t__bindgen_ty_1 {
16339 k_iCallback = 4524,
16340}
16341#[test]
16342fn bindgen_test_layout_HTML_ShowToolTip_t() {
16343 const UNINIT: ::std::mem::MaybeUninit<HTML_ShowToolTip_t> = ::std::mem::MaybeUninit::uninit();
16344 let ptr = UNINIT.as_ptr();
16345 assert_eq!(
16346 ::std::mem::size_of::<HTML_ShowToolTip_t>(),
16347 12usize,
16348 concat!("Size of: ", stringify!(HTML_ShowToolTip_t))
16349 );
16350 assert_eq!(
16351 ::std::mem::align_of::<HTML_ShowToolTip_t>(),
16352 4usize,
16353 concat!("Alignment of ", stringify!(HTML_ShowToolTip_t))
16354 );
16355 assert_eq!(
16356 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16357 0usize,
16358 concat!(
16359 "Offset of field: ",
16360 stringify!(HTML_ShowToolTip_t),
16361 "::",
16362 stringify!(unBrowserHandle)
16363 )
16364 );
16365 assert_eq!(
16366 unsafe { ::std::ptr::addr_of!((*ptr).pchMsg) as usize - ptr as usize },
16367 4usize,
16368 concat!(
16369 "Offset of field: ",
16370 stringify!(HTML_ShowToolTip_t),
16371 "::",
16372 stringify!(pchMsg)
16373 )
16374 );
16375}
16376#[repr(C, packed(4))]
16377#[derive(Debug, Copy, Clone)]
16378pub struct HTML_UpdateToolTip_t {
16379 pub unBrowserHandle: HHTMLBrowser,
16380 pub pchMsg: *const ::std::os::raw::c_char,
16381}
16382pub const HTML_UpdateToolTip_t_k_iCallback: HTML_UpdateToolTip_t__bindgen_ty_1 =
16383 HTML_UpdateToolTip_t__bindgen_ty_1::k_iCallback;
16384#[repr(u32)]
16385#[non_exhaustive]
16386#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16387pub enum HTML_UpdateToolTip_t__bindgen_ty_1 {
16388 k_iCallback = 4525,
16389}
16390#[test]
16391fn bindgen_test_layout_HTML_UpdateToolTip_t() {
16392 const UNINIT: ::std::mem::MaybeUninit<HTML_UpdateToolTip_t> = ::std::mem::MaybeUninit::uninit();
16393 let ptr = UNINIT.as_ptr();
16394 assert_eq!(
16395 ::std::mem::size_of::<HTML_UpdateToolTip_t>(),
16396 12usize,
16397 concat!("Size of: ", stringify!(HTML_UpdateToolTip_t))
16398 );
16399 assert_eq!(
16400 ::std::mem::align_of::<HTML_UpdateToolTip_t>(),
16401 4usize,
16402 concat!("Alignment of ", stringify!(HTML_UpdateToolTip_t))
16403 );
16404 assert_eq!(
16405 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16406 0usize,
16407 concat!(
16408 "Offset of field: ",
16409 stringify!(HTML_UpdateToolTip_t),
16410 "::",
16411 stringify!(unBrowserHandle)
16412 )
16413 );
16414 assert_eq!(
16415 unsafe { ::std::ptr::addr_of!((*ptr).pchMsg) as usize - ptr as usize },
16416 4usize,
16417 concat!(
16418 "Offset of field: ",
16419 stringify!(HTML_UpdateToolTip_t),
16420 "::",
16421 stringify!(pchMsg)
16422 )
16423 );
16424}
16425#[repr(C)]
16426#[derive(Debug, Copy, Clone)]
16427pub struct HTML_HideToolTip_t {
16428 pub unBrowserHandle: HHTMLBrowser,
16429}
16430pub const HTML_HideToolTip_t_k_iCallback: HTML_HideToolTip_t__bindgen_ty_1 =
16431 HTML_HideToolTip_t__bindgen_ty_1::k_iCallback;
16432#[repr(u32)]
16433#[non_exhaustive]
16434#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16435pub enum HTML_HideToolTip_t__bindgen_ty_1 {
16436 k_iCallback = 4526,
16437}
16438#[test]
16439fn bindgen_test_layout_HTML_HideToolTip_t() {
16440 const UNINIT: ::std::mem::MaybeUninit<HTML_HideToolTip_t> = ::std::mem::MaybeUninit::uninit();
16441 let ptr = UNINIT.as_ptr();
16442 assert_eq!(
16443 ::std::mem::size_of::<HTML_HideToolTip_t>(),
16444 4usize,
16445 concat!("Size of: ", stringify!(HTML_HideToolTip_t))
16446 );
16447 assert_eq!(
16448 ::std::mem::align_of::<HTML_HideToolTip_t>(),
16449 4usize,
16450 concat!("Alignment of ", stringify!(HTML_HideToolTip_t))
16451 );
16452 assert_eq!(
16453 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16454 0usize,
16455 concat!(
16456 "Offset of field: ",
16457 stringify!(HTML_HideToolTip_t),
16458 "::",
16459 stringify!(unBrowserHandle)
16460 )
16461 );
16462}
16463#[repr(C)]
16464#[derive(Debug, Copy, Clone)]
16465pub struct HTML_BrowserRestarted_t {
16466 pub unBrowserHandle: HHTMLBrowser,
16467 pub unOldBrowserHandle: HHTMLBrowser,
16468}
16469pub const HTML_BrowserRestarted_t_k_iCallback: HTML_BrowserRestarted_t__bindgen_ty_1 =
16470 HTML_BrowserRestarted_t__bindgen_ty_1::k_iCallback;
16471#[repr(u32)]
16472#[non_exhaustive]
16473#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16474pub enum HTML_BrowserRestarted_t__bindgen_ty_1 {
16475 k_iCallback = 4527,
16476}
16477#[test]
16478fn bindgen_test_layout_HTML_BrowserRestarted_t() {
16479 const UNINIT: ::std::mem::MaybeUninit<HTML_BrowserRestarted_t> =
16480 ::std::mem::MaybeUninit::uninit();
16481 let ptr = UNINIT.as_ptr();
16482 assert_eq!(
16483 ::std::mem::size_of::<HTML_BrowserRestarted_t>(),
16484 8usize,
16485 concat!("Size of: ", stringify!(HTML_BrowserRestarted_t))
16486 );
16487 assert_eq!(
16488 ::std::mem::align_of::<HTML_BrowserRestarted_t>(),
16489 4usize,
16490 concat!("Alignment of ", stringify!(HTML_BrowserRestarted_t))
16491 );
16492 assert_eq!(
16493 unsafe { ::std::ptr::addr_of!((*ptr).unBrowserHandle) as usize - ptr as usize },
16494 0usize,
16495 concat!(
16496 "Offset of field: ",
16497 stringify!(HTML_BrowserRestarted_t),
16498 "::",
16499 stringify!(unBrowserHandle)
16500 )
16501 );
16502 assert_eq!(
16503 unsafe { ::std::ptr::addr_of!((*ptr).unOldBrowserHandle) as usize - ptr as usize },
16504 4usize,
16505 concat!(
16506 "Offset of field: ",
16507 stringify!(HTML_BrowserRestarted_t),
16508 "::",
16509 stringify!(unOldBrowserHandle)
16510 )
16511 );
16512}
16513pub type SteamItemInstanceID_t = uint64;
16514extern "C" {
16515 #[link_name = "\u{1}_ZL28k_SteamItemInstanceIDInvalid"]
16516 pub static k_SteamItemInstanceIDInvalid: SteamItemInstanceID_t;
16517}
16518pub type SteamItemDef_t = int32;
16519impl ESteamItemFlags {
16520 pub const k_ESteamItemNoTrade: ESteamItemFlags = ESteamItemFlags(1);
16521}
16522impl ESteamItemFlags {
16523 pub const k_ESteamItemRemoved: ESteamItemFlags = ESteamItemFlags(256);
16524}
16525impl ESteamItemFlags {
16526 pub const k_ESteamItemConsumed: ESteamItemFlags = ESteamItemFlags(512);
16527}
16528impl ::std::ops::BitOr<ESteamItemFlags> for ESteamItemFlags {
16529 type Output = Self;
16530 #[inline]
16531 fn bitor(self, other: Self) -> Self {
16532 ESteamItemFlags(self.0 | other.0)
16533 }
16534}
16535impl ::std::ops::BitOrAssign for ESteamItemFlags {
16536 #[inline]
16537 fn bitor_assign(&mut self, rhs: ESteamItemFlags) {
16538 self.0 |= rhs.0;
16539 }
16540}
16541impl ::std::ops::BitAnd<ESteamItemFlags> for ESteamItemFlags {
16542 type Output = Self;
16543 #[inline]
16544 fn bitand(self, other: Self) -> Self {
16545 ESteamItemFlags(self.0 & other.0)
16546 }
16547}
16548impl ::std::ops::BitAndAssign for ESteamItemFlags {
16549 #[inline]
16550 fn bitand_assign(&mut self, rhs: ESteamItemFlags) {
16551 self.0 &= rhs.0;
16552 }
16553}
16554#[repr(transparent)]
16555#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16556pub struct ESteamItemFlags(pub ::std::os::raw::c_uint);
16557#[repr(C, packed(4))]
16558#[derive(Debug, Copy, Clone)]
16559pub struct SteamItemDetails_t {
16560 pub m_itemId: SteamItemInstanceID_t,
16561 pub m_iDefinition: SteamItemDef_t,
16562 pub m_unQuantity: uint16,
16563 pub m_unFlags: uint16,
16564}
16565#[test]
16566fn bindgen_test_layout_SteamItemDetails_t() {
16567 const UNINIT: ::std::mem::MaybeUninit<SteamItemDetails_t> = ::std::mem::MaybeUninit::uninit();
16568 let ptr = UNINIT.as_ptr();
16569 assert_eq!(
16570 ::std::mem::size_of::<SteamItemDetails_t>(),
16571 16usize,
16572 concat!("Size of: ", stringify!(SteamItemDetails_t))
16573 );
16574 assert_eq!(
16575 ::std::mem::align_of::<SteamItemDetails_t>(),
16576 4usize,
16577 concat!("Alignment of ", stringify!(SteamItemDetails_t))
16578 );
16579 assert_eq!(
16580 unsafe { ::std::ptr::addr_of!((*ptr).m_itemId) as usize - ptr as usize },
16581 0usize,
16582 concat!(
16583 "Offset of field: ",
16584 stringify!(SteamItemDetails_t),
16585 "::",
16586 stringify!(m_itemId)
16587 )
16588 );
16589 assert_eq!(
16590 unsafe { ::std::ptr::addr_of!((*ptr).m_iDefinition) as usize - ptr as usize },
16591 8usize,
16592 concat!(
16593 "Offset of field: ",
16594 stringify!(SteamItemDetails_t),
16595 "::",
16596 stringify!(m_iDefinition)
16597 )
16598 );
16599 assert_eq!(
16600 unsafe { ::std::ptr::addr_of!((*ptr).m_unQuantity) as usize - ptr as usize },
16601 12usize,
16602 concat!(
16603 "Offset of field: ",
16604 stringify!(SteamItemDetails_t),
16605 "::",
16606 stringify!(m_unQuantity)
16607 )
16608 );
16609 assert_eq!(
16610 unsafe { ::std::ptr::addr_of!((*ptr).m_unFlags) as usize - ptr as usize },
16611 14usize,
16612 concat!(
16613 "Offset of field: ",
16614 stringify!(SteamItemDetails_t),
16615 "::",
16616 stringify!(m_unFlags)
16617 )
16618 );
16619}
16620pub type SteamInventoryResult_t = int32;
16621pub const k_SteamInventoryResultInvalid: SteamInventoryResult_t = -1;
16622pub type SteamInventoryUpdateHandle_t = uint64;
16623pub const k_SteamInventoryUpdateHandleInvalid: SteamInventoryUpdateHandle_t = 18446744073709551615;
16624#[repr(C)]
16625pub struct ISteamInventory__bindgen_vtable(::std::os::raw::c_void);
16626#[repr(C)]
16627#[derive(Debug, Copy, Clone)]
16628pub struct ISteamInventory {
16629 pub vtable_: *const ISteamInventory__bindgen_vtable,
16630}
16631#[test]
16632fn bindgen_test_layout_ISteamInventory() {
16633 assert_eq!(
16634 ::std::mem::size_of::<ISteamInventory>(),
16635 8usize,
16636 concat!("Size of: ", stringify!(ISteamInventory))
16637 );
16638 assert_eq!(
16639 ::std::mem::align_of::<ISteamInventory>(),
16640 4usize,
16641 concat!("Alignment of ", stringify!(ISteamInventory))
16642 );
16643}
16644#[repr(C)]
16645#[derive(Debug, Copy, Clone)]
16646pub struct SteamInventoryResultReady_t {
16647 pub m_handle: SteamInventoryResult_t,
16648 pub m_result: EResult,
16649}
16650pub const SteamInventoryResultReady_t_k_iCallback: SteamInventoryResultReady_t__bindgen_ty_1 =
16651 SteamInventoryResultReady_t__bindgen_ty_1::k_iCallback;
16652#[repr(u32)]
16653#[non_exhaustive]
16654#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16655pub enum SteamInventoryResultReady_t__bindgen_ty_1 {
16656 k_iCallback = 4700,
16657}
16658#[test]
16659fn bindgen_test_layout_SteamInventoryResultReady_t() {
16660 const UNINIT: ::std::mem::MaybeUninit<SteamInventoryResultReady_t> =
16661 ::std::mem::MaybeUninit::uninit();
16662 let ptr = UNINIT.as_ptr();
16663 assert_eq!(
16664 ::std::mem::size_of::<SteamInventoryResultReady_t>(),
16665 8usize,
16666 concat!("Size of: ", stringify!(SteamInventoryResultReady_t))
16667 );
16668 assert_eq!(
16669 ::std::mem::align_of::<SteamInventoryResultReady_t>(),
16670 4usize,
16671 concat!("Alignment of ", stringify!(SteamInventoryResultReady_t))
16672 );
16673 assert_eq!(
16674 unsafe { ::std::ptr::addr_of!((*ptr).m_handle) as usize - ptr as usize },
16675 0usize,
16676 concat!(
16677 "Offset of field: ",
16678 stringify!(SteamInventoryResultReady_t),
16679 "::",
16680 stringify!(m_handle)
16681 )
16682 );
16683 assert_eq!(
16684 unsafe { ::std::ptr::addr_of!((*ptr).m_result) as usize - ptr as usize },
16685 4usize,
16686 concat!(
16687 "Offset of field: ",
16688 stringify!(SteamInventoryResultReady_t),
16689 "::",
16690 stringify!(m_result)
16691 )
16692 );
16693}
16694#[repr(C)]
16695#[derive(Debug, Copy, Clone)]
16696pub struct SteamInventoryFullUpdate_t {
16697 pub m_handle: SteamInventoryResult_t,
16698}
16699pub const SteamInventoryFullUpdate_t_k_iCallback: SteamInventoryFullUpdate_t__bindgen_ty_1 =
16700 SteamInventoryFullUpdate_t__bindgen_ty_1::k_iCallback;
16701#[repr(u32)]
16702#[non_exhaustive]
16703#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16704pub enum SteamInventoryFullUpdate_t__bindgen_ty_1 {
16705 k_iCallback = 4701,
16706}
16707#[test]
16708fn bindgen_test_layout_SteamInventoryFullUpdate_t() {
16709 const UNINIT: ::std::mem::MaybeUninit<SteamInventoryFullUpdate_t> =
16710 ::std::mem::MaybeUninit::uninit();
16711 let ptr = UNINIT.as_ptr();
16712 assert_eq!(
16713 ::std::mem::size_of::<SteamInventoryFullUpdate_t>(),
16714 4usize,
16715 concat!("Size of: ", stringify!(SteamInventoryFullUpdate_t))
16716 );
16717 assert_eq!(
16718 ::std::mem::align_of::<SteamInventoryFullUpdate_t>(),
16719 4usize,
16720 concat!("Alignment of ", stringify!(SteamInventoryFullUpdate_t))
16721 );
16722 assert_eq!(
16723 unsafe { ::std::ptr::addr_of!((*ptr).m_handle) as usize - ptr as usize },
16724 0usize,
16725 concat!(
16726 "Offset of field: ",
16727 stringify!(SteamInventoryFullUpdate_t),
16728 "::",
16729 stringify!(m_handle)
16730 )
16731 );
16732}
16733#[repr(C)]
16734#[derive(Debug, Copy, Clone)]
16735pub struct SteamInventoryDefinitionUpdate_t {
16736 pub _address: u8,
16737}
16738pub const SteamInventoryDefinitionUpdate_t_k_iCallback:
16739 SteamInventoryDefinitionUpdate_t__bindgen_ty_1 =
16740 SteamInventoryDefinitionUpdate_t__bindgen_ty_1::k_iCallback;
16741#[repr(u32)]
16742#[non_exhaustive]
16743#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16744pub enum SteamInventoryDefinitionUpdate_t__bindgen_ty_1 {
16745 k_iCallback = 4702,
16746}
16747#[test]
16748fn bindgen_test_layout_SteamInventoryDefinitionUpdate_t() {
16749 assert_eq!(
16750 ::std::mem::size_of::<SteamInventoryDefinitionUpdate_t>(),
16751 1usize,
16752 concat!("Size of: ", stringify!(SteamInventoryDefinitionUpdate_t))
16753 );
16754 assert_eq!(
16755 ::std::mem::align_of::<SteamInventoryDefinitionUpdate_t>(),
16756 1usize,
16757 concat!(
16758 "Alignment of ",
16759 stringify!(SteamInventoryDefinitionUpdate_t)
16760 )
16761 );
16762}
16763#[repr(C)]
16764#[derive(Copy, Clone)]
16765pub struct SteamInventoryEligiblePromoItemDefIDs_t {
16766 pub m_result: EResult,
16767 pub m_steamID: CSteamID,
16768 pub m_numEligiblePromoItemDefs: ::std::os::raw::c_int,
16769 pub m_bCachedData: bool,
16770}
16771pub const SteamInventoryEligiblePromoItemDefIDs_t_k_iCallback:
16772 SteamInventoryEligiblePromoItemDefIDs_t__bindgen_ty_1 =
16773 SteamInventoryEligiblePromoItemDefIDs_t__bindgen_ty_1::k_iCallback;
16774#[repr(u32)]
16775#[non_exhaustive]
16776#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16777pub enum SteamInventoryEligiblePromoItemDefIDs_t__bindgen_ty_1 {
16778 k_iCallback = 4703,
16779}
16780#[test]
16781fn bindgen_test_layout_SteamInventoryEligiblePromoItemDefIDs_t() {
16782 const UNINIT: ::std::mem::MaybeUninit<SteamInventoryEligiblePromoItemDefIDs_t> =
16783 ::std::mem::MaybeUninit::uninit();
16784 let ptr = UNINIT.as_ptr();
16785 assert_eq!(
16786 ::std::mem::size_of::<SteamInventoryEligiblePromoItemDefIDs_t>(),
16787 20usize,
16788 concat!(
16789 "Size of: ",
16790 stringify!(SteamInventoryEligiblePromoItemDefIDs_t)
16791 )
16792 );
16793 assert_eq!(
16794 ::std::mem::align_of::<SteamInventoryEligiblePromoItemDefIDs_t>(),
16795 4usize,
16796 concat!(
16797 "Alignment of ",
16798 stringify!(SteamInventoryEligiblePromoItemDefIDs_t)
16799 )
16800 );
16801 assert_eq!(
16802 unsafe { ::std::ptr::addr_of!((*ptr).m_result) as usize - ptr as usize },
16803 0usize,
16804 concat!(
16805 "Offset of field: ",
16806 stringify!(SteamInventoryEligiblePromoItemDefIDs_t),
16807 "::",
16808 stringify!(m_result)
16809 )
16810 );
16811 assert_eq!(
16812 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID) as usize - ptr as usize },
16813 4usize,
16814 concat!(
16815 "Offset of field: ",
16816 stringify!(SteamInventoryEligiblePromoItemDefIDs_t),
16817 "::",
16818 stringify!(m_steamID)
16819 )
16820 );
16821 assert_eq!(
16822 unsafe { ::std::ptr::addr_of!((*ptr).m_numEligiblePromoItemDefs) as usize - ptr as usize },
16823 12usize,
16824 concat!(
16825 "Offset of field: ",
16826 stringify!(SteamInventoryEligiblePromoItemDefIDs_t),
16827 "::",
16828 stringify!(m_numEligiblePromoItemDefs)
16829 )
16830 );
16831 assert_eq!(
16832 unsafe { ::std::ptr::addr_of!((*ptr).m_bCachedData) as usize - ptr as usize },
16833 16usize,
16834 concat!(
16835 "Offset of field: ",
16836 stringify!(SteamInventoryEligiblePromoItemDefIDs_t),
16837 "::",
16838 stringify!(m_bCachedData)
16839 )
16840 );
16841}
16842#[repr(C, packed(4))]
16843#[derive(Debug, Copy, Clone)]
16844pub struct SteamInventoryStartPurchaseResult_t {
16845 pub m_result: EResult,
16846 pub m_ulOrderID: uint64,
16847 pub m_ulTransID: uint64,
16848}
16849pub const SteamInventoryStartPurchaseResult_t_k_iCallback:
16850 SteamInventoryStartPurchaseResult_t__bindgen_ty_1 =
16851 SteamInventoryStartPurchaseResult_t__bindgen_ty_1::k_iCallback;
16852#[repr(u32)]
16853#[non_exhaustive]
16854#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16855pub enum SteamInventoryStartPurchaseResult_t__bindgen_ty_1 {
16856 k_iCallback = 4704,
16857}
16858#[test]
16859fn bindgen_test_layout_SteamInventoryStartPurchaseResult_t() {
16860 const UNINIT: ::std::mem::MaybeUninit<SteamInventoryStartPurchaseResult_t> =
16861 ::std::mem::MaybeUninit::uninit();
16862 let ptr = UNINIT.as_ptr();
16863 assert_eq!(
16864 ::std::mem::size_of::<SteamInventoryStartPurchaseResult_t>(),
16865 20usize,
16866 concat!("Size of: ", stringify!(SteamInventoryStartPurchaseResult_t))
16867 );
16868 assert_eq!(
16869 ::std::mem::align_of::<SteamInventoryStartPurchaseResult_t>(),
16870 4usize,
16871 concat!(
16872 "Alignment of ",
16873 stringify!(SteamInventoryStartPurchaseResult_t)
16874 )
16875 );
16876 assert_eq!(
16877 unsafe { ::std::ptr::addr_of!((*ptr).m_result) as usize - ptr as usize },
16878 0usize,
16879 concat!(
16880 "Offset of field: ",
16881 stringify!(SteamInventoryStartPurchaseResult_t),
16882 "::",
16883 stringify!(m_result)
16884 )
16885 );
16886 assert_eq!(
16887 unsafe { ::std::ptr::addr_of!((*ptr).m_ulOrderID) as usize - ptr as usize },
16888 4usize,
16889 concat!(
16890 "Offset of field: ",
16891 stringify!(SteamInventoryStartPurchaseResult_t),
16892 "::",
16893 stringify!(m_ulOrderID)
16894 )
16895 );
16896 assert_eq!(
16897 unsafe { ::std::ptr::addr_of!((*ptr).m_ulTransID) as usize - ptr as usize },
16898 12usize,
16899 concat!(
16900 "Offset of field: ",
16901 stringify!(SteamInventoryStartPurchaseResult_t),
16902 "::",
16903 stringify!(m_ulTransID)
16904 )
16905 );
16906}
16907#[repr(C)]
16908#[derive(Debug, Copy, Clone)]
16909pub struct SteamInventoryRequestPricesResult_t {
16910 pub m_result: EResult,
16911 pub m_rgchCurrency: [::std::os::raw::c_char; 4usize],
16912}
16913pub const SteamInventoryRequestPricesResult_t_k_iCallback:
16914 SteamInventoryRequestPricesResult_t__bindgen_ty_1 =
16915 SteamInventoryRequestPricesResult_t__bindgen_ty_1::k_iCallback;
16916#[repr(u32)]
16917#[non_exhaustive]
16918#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16919pub enum SteamInventoryRequestPricesResult_t__bindgen_ty_1 {
16920 k_iCallback = 4705,
16921}
16922#[test]
16923fn bindgen_test_layout_SteamInventoryRequestPricesResult_t() {
16924 const UNINIT: ::std::mem::MaybeUninit<SteamInventoryRequestPricesResult_t> =
16925 ::std::mem::MaybeUninit::uninit();
16926 let ptr = UNINIT.as_ptr();
16927 assert_eq!(
16928 ::std::mem::size_of::<SteamInventoryRequestPricesResult_t>(),
16929 8usize,
16930 concat!("Size of: ", stringify!(SteamInventoryRequestPricesResult_t))
16931 );
16932 assert_eq!(
16933 ::std::mem::align_of::<SteamInventoryRequestPricesResult_t>(),
16934 4usize,
16935 concat!(
16936 "Alignment of ",
16937 stringify!(SteamInventoryRequestPricesResult_t)
16938 )
16939 );
16940 assert_eq!(
16941 unsafe { ::std::ptr::addr_of!((*ptr).m_result) as usize - ptr as usize },
16942 0usize,
16943 concat!(
16944 "Offset of field: ",
16945 stringify!(SteamInventoryRequestPricesResult_t),
16946 "::",
16947 stringify!(m_result)
16948 )
16949 );
16950 assert_eq!(
16951 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchCurrency) as usize - ptr as usize },
16952 4usize,
16953 concat!(
16954 "Offset of field: ",
16955 stringify!(SteamInventoryRequestPricesResult_t),
16956 "::",
16957 stringify!(m_rgchCurrency)
16958 )
16959 );
16960}
16961#[repr(u32)]
16962#[non_exhaustive]
16963#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16964pub enum ETimelineGameMode {
16965 k_ETimelineGameMode_Invalid = 0,
16966 k_ETimelineGameMode_Playing = 1,
16967 k_ETimelineGameMode_Staging = 2,
16968 k_ETimelineGameMode_Menus = 3,
16969 k_ETimelineGameMode_LoadingScreen = 4,
16970 k_ETimelineGameMode_Max = 5,
16971}
16972#[repr(u32)]
16973#[non_exhaustive]
16974#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
16975pub enum ETimelineEventClipPriority {
16976 k_ETimelineEventClipPriority_Invalid = 0,
16977 k_ETimelineEventClipPriority_None = 1,
16978 k_ETimelineEventClipPriority_Standard = 2,
16979 k_ETimelineEventClipPriority_Featured = 3,
16980}
16981pub const k_unMaxTimelinePriority: uint32 = 1000;
16982pub const k_unTimelinePriority_KeepCurrentValue: uint32 = 1000000;
16983pub const k_flMaxTimelineEventDuration: f32 = 600.0;
16984pub const k_cchMaxPhaseIDLength: uint32 = 64;
16985pub type TimelineEventHandle_t = uint64;
16986#[repr(C)]
16987pub struct ISteamTimeline__bindgen_vtable(::std::os::raw::c_void);
16988#[repr(C)]
16989#[derive(Debug, Copy, Clone)]
16990pub struct ISteamTimeline {
16991 pub vtable_: *const ISteamTimeline__bindgen_vtable,
16992}
16993#[test]
16994fn bindgen_test_layout_ISteamTimeline() {
16995 assert_eq!(
16996 ::std::mem::size_of::<ISteamTimeline>(),
16997 8usize,
16998 concat!("Size of: ", stringify!(ISteamTimeline))
16999 );
17000 assert_eq!(
17001 ::std::mem::align_of::<ISteamTimeline>(),
17002 4usize,
17003 concat!("Alignment of ", stringify!(ISteamTimeline))
17004 );
17005}
17006#[repr(C, packed(4))]
17007#[derive(Debug, Copy, Clone)]
17008pub struct SteamTimelineGamePhaseRecordingExists_t {
17009 pub m_rgchPhaseID: [::std::os::raw::c_char; 64usize],
17010 pub m_ulRecordingMS: uint64,
17011 pub m_ulLongestClipMS: uint64,
17012 pub m_unClipCount: uint32,
17013 pub m_unScreenshotCount: uint32,
17014}
17015pub const SteamTimelineGamePhaseRecordingExists_t_k_iCallback:
17016 SteamTimelineGamePhaseRecordingExists_t__bindgen_ty_1 =
17017 SteamTimelineGamePhaseRecordingExists_t__bindgen_ty_1::k_iCallback;
17018#[repr(u32)]
17019#[non_exhaustive]
17020#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17021pub enum SteamTimelineGamePhaseRecordingExists_t__bindgen_ty_1 {
17022 k_iCallback = 6001,
17023}
17024#[test]
17025fn bindgen_test_layout_SteamTimelineGamePhaseRecordingExists_t() {
17026 const UNINIT: ::std::mem::MaybeUninit<SteamTimelineGamePhaseRecordingExists_t> =
17027 ::std::mem::MaybeUninit::uninit();
17028 let ptr = UNINIT.as_ptr();
17029 assert_eq!(
17030 ::std::mem::size_of::<SteamTimelineGamePhaseRecordingExists_t>(),
17031 88usize,
17032 concat!(
17033 "Size of: ",
17034 stringify!(SteamTimelineGamePhaseRecordingExists_t)
17035 )
17036 );
17037 assert_eq!(
17038 ::std::mem::align_of::<SteamTimelineGamePhaseRecordingExists_t>(),
17039 4usize,
17040 concat!(
17041 "Alignment of ",
17042 stringify!(SteamTimelineGamePhaseRecordingExists_t)
17043 )
17044 );
17045 assert_eq!(
17046 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchPhaseID) as usize - ptr as usize },
17047 0usize,
17048 concat!(
17049 "Offset of field: ",
17050 stringify!(SteamTimelineGamePhaseRecordingExists_t),
17051 "::",
17052 stringify!(m_rgchPhaseID)
17053 )
17054 );
17055 assert_eq!(
17056 unsafe { ::std::ptr::addr_of!((*ptr).m_ulRecordingMS) as usize - ptr as usize },
17057 64usize,
17058 concat!(
17059 "Offset of field: ",
17060 stringify!(SteamTimelineGamePhaseRecordingExists_t),
17061 "::",
17062 stringify!(m_ulRecordingMS)
17063 )
17064 );
17065 assert_eq!(
17066 unsafe { ::std::ptr::addr_of!((*ptr).m_ulLongestClipMS) as usize - ptr as usize },
17067 72usize,
17068 concat!(
17069 "Offset of field: ",
17070 stringify!(SteamTimelineGamePhaseRecordingExists_t),
17071 "::",
17072 stringify!(m_ulLongestClipMS)
17073 )
17074 );
17075 assert_eq!(
17076 unsafe { ::std::ptr::addr_of!((*ptr).m_unClipCount) as usize - ptr as usize },
17077 80usize,
17078 concat!(
17079 "Offset of field: ",
17080 stringify!(SteamTimelineGamePhaseRecordingExists_t),
17081 "::",
17082 stringify!(m_unClipCount)
17083 )
17084 );
17085 assert_eq!(
17086 unsafe { ::std::ptr::addr_of!((*ptr).m_unScreenshotCount) as usize - ptr as usize },
17087 84usize,
17088 concat!(
17089 "Offset of field: ",
17090 stringify!(SteamTimelineGamePhaseRecordingExists_t),
17091 "::",
17092 stringify!(m_unScreenshotCount)
17093 )
17094 );
17095}
17096#[repr(C, packed(4))]
17097#[derive(Debug, Copy, Clone)]
17098pub struct SteamTimelineEventRecordingExists_t {
17099 pub m_ulEventID: uint64,
17100 pub m_bRecordingExists: bool,
17101}
17102pub const SteamTimelineEventRecordingExists_t_k_iCallback:
17103 SteamTimelineEventRecordingExists_t__bindgen_ty_1 =
17104 SteamTimelineEventRecordingExists_t__bindgen_ty_1::k_iCallback;
17105#[repr(u32)]
17106#[non_exhaustive]
17107#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17108pub enum SteamTimelineEventRecordingExists_t__bindgen_ty_1 {
17109 k_iCallback = 6002,
17110}
17111#[test]
17112fn bindgen_test_layout_SteamTimelineEventRecordingExists_t() {
17113 const UNINIT: ::std::mem::MaybeUninit<SteamTimelineEventRecordingExists_t> =
17114 ::std::mem::MaybeUninit::uninit();
17115 let ptr = UNINIT.as_ptr();
17116 assert_eq!(
17117 ::std::mem::size_of::<SteamTimelineEventRecordingExists_t>(),
17118 12usize,
17119 concat!("Size of: ", stringify!(SteamTimelineEventRecordingExists_t))
17120 );
17121 assert_eq!(
17122 ::std::mem::align_of::<SteamTimelineEventRecordingExists_t>(),
17123 4usize,
17124 concat!(
17125 "Alignment of ",
17126 stringify!(SteamTimelineEventRecordingExists_t)
17127 )
17128 );
17129 assert_eq!(
17130 unsafe { ::std::ptr::addr_of!((*ptr).m_ulEventID) as usize - ptr as usize },
17131 0usize,
17132 concat!(
17133 "Offset of field: ",
17134 stringify!(SteamTimelineEventRecordingExists_t),
17135 "::",
17136 stringify!(m_ulEventID)
17137 )
17138 );
17139 assert_eq!(
17140 unsafe { ::std::ptr::addr_of!((*ptr).m_bRecordingExists) as usize - ptr as usize },
17141 8usize,
17142 concat!(
17143 "Offset of field: ",
17144 stringify!(SteamTimelineEventRecordingExists_t),
17145 "::",
17146 stringify!(m_bRecordingExists)
17147 )
17148 );
17149}
17150#[repr(C)]
17151pub struct ISteamVideo__bindgen_vtable(::std::os::raw::c_void);
17152#[repr(C)]
17153#[derive(Debug, Copy, Clone)]
17154pub struct ISteamVideo {
17155 pub vtable_: *const ISteamVideo__bindgen_vtable,
17156}
17157#[test]
17158fn bindgen_test_layout_ISteamVideo() {
17159 assert_eq!(
17160 ::std::mem::size_of::<ISteamVideo>(),
17161 8usize,
17162 concat!("Size of: ", stringify!(ISteamVideo))
17163 );
17164 assert_eq!(
17165 ::std::mem::align_of::<ISteamVideo>(),
17166 4usize,
17167 concat!("Alignment of ", stringify!(ISteamVideo))
17168 );
17169}
17170#[repr(C)]
17171#[derive(Debug, Copy, Clone)]
17172pub struct GetVideoURLResult_t {
17173 pub m_eResult: EResult,
17174 pub m_unVideoAppID: AppId_t,
17175 pub m_rgchURL: [::std::os::raw::c_char; 256usize],
17176}
17177pub const GetVideoURLResult_t_k_iCallback: GetVideoURLResult_t__bindgen_ty_1 =
17178 GetVideoURLResult_t__bindgen_ty_1::k_iCallback;
17179#[repr(u32)]
17180#[non_exhaustive]
17181#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17182pub enum GetVideoURLResult_t__bindgen_ty_1 {
17183 k_iCallback = 4611,
17184}
17185#[test]
17186fn bindgen_test_layout_GetVideoURLResult_t() {
17187 const UNINIT: ::std::mem::MaybeUninit<GetVideoURLResult_t> = ::std::mem::MaybeUninit::uninit();
17188 let ptr = UNINIT.as_ptr();
17189 assert_eq!(
17190 ::std::mem::size_of::<GetVideoURLResult_t>(),
17191 264usize,
17192 concat!("Size of: ", stringify!(GetVideoURLResult_t))
17193 );
17194 assert_eq!(
17195 ::std::mem::align_of::<GetVideoURLResult_t>(),
17196 4usize,
17197 concat!("Alignment of ", stringify!(GetVideoURLResult_t))
17198 );
17199 assert_eq!(
17200 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
17201 0usize,
17202 concat!(
17203 "Offset of field: ",
17204 stringify!(GetVideoURLResult_t),
17205 "::",
17206 stringify!(m_eResult)
17207 )
17208 );
17209 assert_eq!(
17210 unsafe { ::std::ptr::addr_of!((*ptr).m_unVideoAppID) as usize - ptr as usize },
17211 4usize,
17212 concat!(
17213 "Offset of field: ",
17214 stringify!(GetVideoURLResult_t),
17215 "::",
17216 stringify!(m_unVideoAppID)
17217 )
17218 );
17219 assert_eq!(
17220 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchURL) as usize - ptr as usize },
17221 8usize,
17222 concat!(
17223 "Offset of field: ",
17224 stringify!(GetVideoURLResult_t),
17225 "::",
17226 stringify!(m_rgchURL)
17227 )
17228 );
17229}
17230#[repr(C)]
17231#[derive(Debug, Copy, Clone)]
17232pub struct GetOPFSettingsResult_t {
17233 pub m_eResult: EResult,
17234 pub m_unVideoAppID: AppId_t,
17235}
17236pub const GetOPFSettingsResult_t_k_iCallback: GetOPFSettingsResult_t__bindgen_ty_1 =
17237 GetOPFSettingsResult_t__bindgen_ty_1::k_iCallback;
17238#[repr(u32)]
17239#[non_exhaustive]
17240#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17241pub enum GetOPFSettingsResult_t__bindgen_ty_1 {
17242 k_iCallback = 4624,
17243}
17244#[test]
17245fn bindgen_test_layout_GetOPFSettingsResult_t() {
17246 const UNINIT: ::std::mem::MaybeUninit<GetOPFSettingsResult_t> =
17247 ::std::mem::MaybeUninit::uninit();
17248 let ptr = UNINIT.as_ptr();
17249 assert_eq!(
17250 ::std::mem::size_of::<GetOPFSettingsResult_t>(),
17251 8usize,
17252 concat!("Size of: ", stringify!(GetOPFSettingsResult_t))
17253 );
17254 assert_eq!(
17255 ::std::mem::align_of::<GetOPFSettingsResult_t>(),
17256 4usize,
17257 concat!("Alignment of ", stringify!(GetOPFSettingsResult_t))
17258 );
17259 assert_eq!(
17260 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
17261 0usize,
17262 concat!(
17263 "Offset of field: ",
17264 stringify!(GetOPFSettingsResult_t),
17265 "::",
17266 stringify!(m_eResult)
17267 )
17268 );
17269 assert_eq!(
17270 unsafe { ::std::ptr::addr_of!((*ptr).m_unVideoAppID) as usize - ptr as usize },
17271 4usize,
17272 concat!(
17273 "Offset of field: ",
17274 stringify!(GetOPFSettingsResult_t),
17275 "::",
17276 stringify!(m_unVideoAppID)
17277 )
17278 );
17279}
17280#[repr(C)]
17281#[derive(Debug, Copy, Clone)]
17282pub struct BroadcastUploadStart_t {
17283 pub m_bIsRTMP: bool,
17284}
17285pub const BroadcastUploadStart_t_k_iCallback: BroadcastUploadStart_t__bindgen_ty_1 =
17286 BroadcastUploadStart_t__bindgen_ty_1::k_iCallback;
17287#[repr(u32)]
17288#[non_exhaustive]
17289#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17290pub enum BroadcastUploadStart_t__bindgen_ty_1 {
17291 k_iCallback = 4604,
17292}
17293#[test]
17294fn bindgen_test_layout_BroadcastUploadStart_t() {
17295 const UNINIT: ::std::mem::MaybeUninit<BroadcastUploadStart_t> =
17296 ::std::mem::MaybeUninit::uninit();
17297 let ptr = UNINIT.as_ptr();
17298 assert_eq!(
17299 ::std::mem::size_of::<BroadcastUploadStart_t>(),
17300 1usize,
17301 concat!("Size of: ", stringify!(BroadcastUploadStart_t))
17302 );
17303 assert_eq!(
17304 ::std::mem::align_of::<BroadcastUploadStart_t>(),
17305 1usize,
17306 concat!("Alignment of ", stringify!(BroadcastUploadStart_t))
17307 );
17308 assert_eq!(
17309 unsafe { ::std::ptr::addr_of!((*ptr).m_bIsRTMP) as usize - ptr as usize },
17310 0usize,
17311 concat!(
17312 "Offset of field: ",
17313 stringify!(BroadcastUploadStart_t),
17314 "::",
17315 stringify!(m_bIsRTMP)
17316 )
17317 );
17318}
17319#[repr(C)]
17320#[derive(Debug, Copy, Clone)]
17321pub struct BroadcastUploadStop_t {
17322 pub m_eResult: EBroadcastUploadResult,
17323}
17324pub const BroadcastUploadStop_t_k_iCallback: BroadcastUploadStop_t__bindgen_ty_1 =
17325 BroadcastUploadStop_t__bindgen_ty_1::k_iCallback;
17326#[repr(u32)]
17327#[non_exhaustive]
17328#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17329pub enum BroadcastUploadStop_t__bindgen_ty_1 {
17330 k_iCallback = 4605,
17331}
17332#[test]
17333fn bindgen_test_layout_BroadcastUploadStop_t() {
17334 const UNINIT: ::std::mem::MaybeUninit<BroadcastUploadStop_t> =
17335 ::std::mem::MaybeUninit::uninit();
17336 let ptr = UNINIT.as_ptr();
17337 assert_eq!(
17338 ::std::mem::size_of::<BroadcastUploadStop_t>(),
17339 4usize,
17340 concat!("Size of: ", stringify!(BroadcastUploadStop_t))
17341 );
17342 assert_eq!(
17343 ::std::mem::align_of::<BroadcastUploadStop_t>(),
17344 4usize,
17345 concat!("Alignment of ", stringify!(BroadcastUploadStop_t))
17346 );
17347 assert_eq!(
17348 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
17349 0usize,
17350 concat!(
17351 "Offset of field: ",
17352 stringify!(BroadcastUploadStop_t),
17353 "::",
17354 stringify!(m_eResult)
17355 )
17356 );
17357}
17358#[repr(u32)]
17359#[non_exhaustive]
17360#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17361pub enum EParentalFeature {
17362 k_EFeatureInvalid = 0,
17363 k_EFeatureStore = 1,
17364 k_EFeatureCommunity = 2,
17365 k_EFeatureProfile = 3,
17366 k_EFeatureFriends = 4,
17367 k_EFeatureNews = 5,
17368 k_EFeatureTrading = 6,
17369 k_EFeatureSettings = 7,
17370 k_EFeatureConsole = 8,
17371 k_EFeatureBrowser = 9,
17372 k_EFeatureParentalSetup = 10,
17373 k_EFeatureLibrary = 11,
17374 k_EFeatureTest = 12,
17375 k_EFeatureSiteLicense = 13,
17376 k_EFeatureKioskMode_Deprecated = 14,
17377 k_EFeatureBlockAlways = 15,
17378 k_EFeatureDesktop = 16,
17379 k_EFeatureMax = 17,
17380}
17381#[repr(C)]
17382pub struct ISteamParentalSettings__bindgen_vtable(::std::os::raw::c_void);
17383#[repr(C)]
17384#[derive(Debug, Copy, Clone)]
17385pub struct ISteamParentalSettings {
17386 pub vtable_: *const ISteamParentalSettings__bindgen_vtable,
17387}
17388#[test]
17389fn bindgen_test_layout_ISteamParentalSettings() {
17390 assert_eq!(
17391 ::std::mem::size_of::<ISteamParentalSettings>(),
17392 8usize,
17393 concat!("Size of: ", stringify!(ISteamParentalSettings))
17394 );
17395 assert_eq!(
17396 ::std::mem::align_of::<ISteamParentalSettings>(),
17397 8usize,
17398 concat!("Alignment of ", stringify!(ISteamParentalSettings))
17399 );
17400}
17401#[repr(C)]
17402#[derive(Debug, Copy, Clone)]
17403pub struct SteamParentalSettingsChanged_t {
17404 pub _address: u8,
17405}
17406pub const SteamParentalSettingsChanged_t_k_iCallback: SteamParentalSettingsChanged_t__bindgen_ty_1 =
17407 SteamParentalSettingsChanged_t__bindgen_ty_1::k_iCallback;
17408#[repr(u32)]
17409#[non_exhaustive]
17410#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17411pub enum SteamParentalSettingsChanged_t__bindgen_ty_1 {
17412 k_iCallback = 5001,
17413}
17414#[test]
17415fn bindgen_test_layout_SteamParentalSettingsChanged_t() {
17416 assert_eq!(
17417 ::std::mem::size_of::<SteamParentalSettingsChanged_t>(),
17418 1usize,
17419 concat!("Size of: ", stringify!(SteamParentalSettingsChanged_t))
17420 );
17421 assert_eq!(
17422 ::std::mem::align_of::<SteamParentalSettingsChanged_t>(),
17423 1usize,
17424 concat!("Alignment of ", stringify!(SteamParentalSettingsChanged_t))
17425 );
17426}
17427#[repr(u32)]
17428#[non_exhaustive]
17429#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17430pub enum ESteamDeviceFormFactor {
17431 k_ESteamDeviceFormFactorUnknown = 0,
17432 k_ESteamDeviceFormFactorPhone = 1,
17433 k_ESteamDeviceFormFactorTablet = 2,
17434 k_ESteamDeviceFormFactorComputer = 3,
17435 k_ESteamDeviceFormFactorTV = 4,
17436 k_ESteamDeviceFormFactorVRHeadset = 5,
17437}
17438pub type RemotePlaySessionID_t = uint32;
17439pub type RemotePlayCursorID_t = uint32;
17440#[repr(u32)]
17441#[non_exhaustive]
17442#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17443pub enum ERemotePlayInputType {
17444 k_ERemotePlayInputUnknown = 0,
17445 k_ERemotePlayInputMouseMotion = 1,
17446 k_ERemotePlayInputMouseButtonDown = 2,
17447 k_ERemotePlayInputMouseButtonUp = 3,
17448 k_ERemotePlayInputMouseWheel = 4,
17449 k_ERemotePlayInputKeyDown = 5,
17450 k_ERemotePlayInputKeyUp = 6,
17451}
17452#[repr(u32)]
17453#[non_exhaustive]
17454#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17455pub enum ERemotePlayMouseButton {
17456 k_ERemotePlayMouseButtonLeft = 1,
17457 k_ERemotePlayMouseButtonRight = 2,
17458 k_ERemotePlayMouseButtonMiddle = 16,
17459 k_ERemotePlayMouseButtonX1 = 32,
17460 k_ERemotePlayMouseButtonX2 = 64,
17461}
17462#[repr(u32)]
17463#[non_exhaustive]
17464#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17465pub enum ERemotePlayMouseWheelDirection {
17466 k_ERemotePlayMouseWheelUp = 1,
17467 k_ERemotePlayMouseWheelDown = 2,
17468 k_ERemotePlayMouseWheelLeft = 3,
17469 k_ERemotePlayMouseWheelRight = 4,
17470}
17471#[repr(u32)]
17472#[non_exhaustive]
17473#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17474pub enum ERemotePlayScancode {
17475 k_ERemotePlayScancodeUnknown = 0,
17476 k_ERemotePlayScancodeA = 4,
17477 k_ERemotePlayScancodeB = 5,
17478 k_ERemotePlayScancodeC = 6,
17479 k_ERemotePlayScancodeD = 7,
17480 k_ERemotePlayScancodeE = 8,
17481 k_ERemotePlayScancodeF = 9,
17482 k_ERemotePlayScancodeG = 10,
17483 k_ERemotePlayScancodeH = 11,
17484 k_ERemotePlayScancodeI = 12,
17485 k_ERemotePlayScancodeJ = 13,
17486 k_ERemotePlayScancodeK = 14,
17487 k_ERemotePlayScancodeL = 15,
17488 k_ERemotePlayScancodeM = 16,
17489 k_ERemotePlayScancodeN = 17,
17490 k_ERemotePlayScancodeO = 18,
17491 k_ERemotePlayScancodeP = 19,
17492 k_ERemotePlayScancodeQ = 20,
17493 k_ERemotePlayScancodeR = 21,
17494 k_ERemotePlayScancodeS = 22,
17495 k_ERemotePlayScancodeT = 23,
17496 k_ERemotePlayScancodeU = 24,
17497 k_ERemotePlayScancodeV = 25,
17498 k_ERemotePlayScancodeW = 26,
17499 k_ERemotePlayScancodeX = 27,
17500 k_ERemotePlayScancodeY = 28,
17501 k_ERemotePlayScancodeZ = 29,
17502 k_ERemotePlayScancode1 = 30,
17503 k_ERemotePlayScancode2 = 31,
17504 k_ERemotePlayScancode3 = 32,
17505 k_ERemotePlayScancode4 = 33,
17506 k_ERemotePlayScancode5 = 34,
17507 k_ERemotePlayScancode6 = 35,
17508 k_ERemotePlayScancode7 = 36,
17509 k_ERemotePlayScancode8 = 37,
17510 k_ERemotePlayScancode9 = 38,
17511 k_ERemotePlayScancode0 = 39,
17512 k_ERemotePlayScancodeReturn = 40,
17513 k_ERemotePlayScancodeEscape = 41,
17514 k_ERemotePlayScancodeBackspace = 42,
17515 k_ERemotePlayScancodeTab = 43,
17516 k_ERemotePlayScancodeSpace = 44,
17517 k_ERemotePlayScancodeMinus = 45,
17518 k_ERemotePlayScancodeEquals = 46,
17519 k_ERemotePlayScancodeLeftBracket = 47,
17520 k_ERemotePlayScancodeRightBracket = 48,
17521 k_ERemotePlayScancodeBackslash = 49,
17522 k_ERemotePlayScancodeSemicolon = 51,
17523 k_ERemotePlayScancodeApostrophe = 52,
17524 k_ERemotePlayScancodeGrave = 53,
17525 k_ERemotePlayScancodeComma = 54,
17526 k_ERemotePlayScancodePeriod = 55,
17527 k_ERemotePlayScancodeSlash = 56,
17528 k_ERemotePlayScancodeCapsLock = 57,
17529 k_ERemotePlayScancodeF1 = 58,
17530 k_ERemotePlayScancodeF2 = 59,
17531 k_ERemotePlayScancodeF3 = 60,
17532 k_ERemotePlayScancodeF4 = 61,
17533 k_ERemotePlayScancodeF5 = 62,
17534 k_ERemotePlayScancodeF6 = 63,
17535 k_ERemotePlayScancodeF7 = 64,
17536 k_ERemotePlayScancodeF8 = 65,
17537 k_ERemotePlayScancodeF9 = 66,
17538 k_ERemotePlayScancodeF10 = 67,
17539 k_ERemotePlayScancodeF11 = 68,
17540 k_ERemotePlayScancodeF12 = 69,
17541 k_ERemotePlayScancodeInsert = 73,
17542 k_ERemotePlayScancodeHome = 74,
17543 k_ERemotePlayScancodePageUp = 75,
17544 k_ERemotePlayScancodeDelete = 76,
17545 k_ERemotePlayScancodeEnd = 77,
17546 k_ERemotePlayScancodePageDown = 78,
17547 k_ERemotePlayScancodeRight = 79,
17548 k_ERemotePlayScancodeLeft = 80,
17549 k_ERemotePlayScancodeDown = 81,
17550 k_ERemotePlayScancodeUp = 82,
17551 k_ERemotePlayScancodeKeypadDivide = 84,
17552 k_ERemotePlayScancodeKeypadMultiply = 85,
17553 k_ERemotePlayScancodeKeypadMinus = 86,
17554 k_ERemotePlayScancodeKeypadPlus = 87,
17555 k_ERemotePlayScancodeKeypadEnter = 88,
17556 k_ERemotePlayScancodeKeypad1 = 89,
17557 k_ERemotePlayScancodeKeypad2 = 90,
17558 k_ERemotePlayScancodeKeypad3 = 91,
17559 k_ERemotePlayScancodeKeypad4 = 92,
17560 k_ERemotePlayScancodeKeypad5 = 93,
17561 k_ERemotePlayScancodeKeypad6 = 94,
17562 k_ERemotePlayScancodeKeypad7 = 95,
17563 k_ERemotePlayScancodeKeypad8 = 96,
17564 k_ERemotePlayScancodeKeypad9 = 97,
17565 k_ERemotePlayScancodeKeypad0 = 98,
17566 k_ERemotePlayScancodeKeypadPeriod = 99,
17567 k_ERemotePlayScancodeLeftControl = 224,
17568 k_ERemotePlayScancodeLeftShift = 225,
17569 k_ERemotePlayScancodeLeftAlt = 226,
17570 k_ERemotePlayScancodeLeftGUI = 227,
17571 k_ERemotePlayScancodeRightControl = 228,
17572 k_ERemotePlayScancodeRightShift = 229,
17573 k_ERemotePlayScancodeRightALT = 230,
17574 k_ERemotePlayScancodeRightGUI = 231,
17575}
17576#[repr(u32)]
17577#[non_exhaustive]
17578#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17579pub enum ERemotePlayKeyModifier {
17580 k_ERemotePlayKeyModifierNone = 0,
17581 k_ERemotePlayKeyModifierLeftShift = 1,
17582 k_ERemotePlayKeyModifierRightShift = 2,
17583 k_ERemotePlayKeyModifierLeftControl = 64,
17584 k_ERemotePlayKeyModifierRightControl = 128,
17585 k_ERemotePlayKeyModifierLeftAlt = 256,
17586 k_ERemotePlayKeyModifierRightAlt = 512,
17587 k_ERemotePlayKeyModifierLeftGUI = 1024,
17588 k_ERemotePlayKeyModifierRightGUI = 2048,
17589 k_ERemotePlayKeyModifierNumLock = 4096,
17590 k_ERemotePlayKeyModifierCapsLock = 8192,
17591 k_ERemotePlayKeyModifierMask = 65535,
17592}
17593#[repr(C)]
17594#[derive(Debug, Copy, Clone)]
17595pub struct RemotePlayInputMouseMotion_t {
17596 pub m_bAbsolute: bool,
17597 pub m_flNormalizedX: f32,
17598 pub m_flNormalizedY: f32,
17599 pub m_nDeltaX: ::std::os::raw::c_int,
17600 pub m_nDeltaY: ::std::os::raw::c_int,
17601}
17602#[test]
17603fn bindgen_test_layout_RemotePlayInputMouseMotion_t() {
17604 const UNINIT: ::std::mem::MaybeUninit<RemotePlayInputMouseMotion_t> =
17605 ::std::mem::MaybeUninit::uninit();
17606 let ptr = UNINIT.as_ptr();
17607 assert_eq!(
17608 ::std::mem::size_of::<RemotePlayInputMouseMotion_t>(),
17609 20usize,
17610 concat!("Size of: ", stringify!(RemotePlayInputMouseMotion_t))
17611 );
17612 assert_eq!(
17613 ::std::mem::align_of::<RemotePlayInputMouseMotion_t>(),
17614 4usize,
17615 concat!("Alignment of ", stringify!(RemotePlayInputMouseMotion_t))
17616 );
17617 assert_eq!(
17618 unsafe { ::std::ptr::addr_of!((*ptr).m_bAbsolute) as usize - ptr as usize },
17619 0usize,
17620 concat!(
17621 "Offset of field: ",
17622 stringify!(RemotePlayInputMouseMotion_t),
17623 "::",
17624 stringify!(m_bAbsolute)
17625 )
17626 );
17627 assert_eq!(
17628 unsafe { ::std::ptr::addr_of!((*ptr).m_flNormalizedX) as usize - ptr as usize },
17629 4usize,
17630 concat!(
17631 "Offset of field: ",
17632 stringify!(RemotePlayInputMouseMotion_t),
17633 "::",
17634 stringify!(m_flNormalizedX)
17635 )
17636 );
17637 assert_eq!(
17638 unsafe { ::std::ptr::addr_of!((*ptr).m_flNormalizedY) as usize - ptr as usize },
17639 8usize,
17640 concat!(
17641 "Offset of field: ",
17642 stringify!(RemotePlayInputMouseMotion_t),
17643 "::",
17644 stringify!(m_flNormalizedY)
17645 )
17646 );
17647 assert_eq!(
17648 unsafe { ::std::ptr::addr_of!((*ptr).m_nDeltaX) as usize - ptr as usize },
17649 12usize,
17650 concat!(
17651 "Offset of field: ",
17652 stringify!(RemotePlayInputMouseMotion_t),
17653 "::",
17654 stringify!(m_nDeltaX)
17655 )
17656 );
17657 assert_eq!(
17658 unsafe { ::std::ptr::addr_of!((*ptr).m_nDeltaY) as usize - ptr as usize },
17659 16usize,
17660 concat!(
17661 "Offset of field: ",
17662 stringify!(RemotePlayInputMouseMotion_t),
17663 "::",
17664 stringify!(m_nDeltaY)
17665 )
17666 );
17667}
17668#[repr(C)]
17669#[derive(Debug, Copy, Clone)]
17670pub struct RemotePlayInputMouseWheel_t {
17671 pub m_eDirection: ERemotePlayMouseWheelDirection,
17672 pub m_flAmount: f32,
17673}
17674#[test]
17675fn bindgen_test_layout_RemotePlayInputMouseWheel_t() {
17676 const UNINIT: ::std::mem::MaybeUninit<RemotePlayInputMouseWheel_t> =
17677 ::std::mem::MaybeUninit::uninit();
17678 let ptr = UNINIT.as_ptr();
17679 assert_eq!(
17680 ::std::mem::size_of::<RemotePlayInputMouseWheel_t>(),
17681 8usize,
17682 concat!("Size of: ", stringify!(RemotePlayInputMouseWheel_t))
17683 );
17684 assert_eq!(
17685 ::std::mem::align_of::<RemotePlayInputMouseWheel_t>(),
17686 4usize,
17687 concat!("Alignment of ", stringify!(RemotePlayInputMouseWheel_t))
17688 );
17689 assert_eq!(
17690 unsafe { ::std::ptr::addr_of!((*ptr).m_eDirection) as usize - ptr as usize },
17691 0usize,
17692 concat!(
17693 "Offset of field: ",
17694 stringify!(RemotePlayInputMouseWheel_t),
17695 "::",
17696 stringify!(m_eDirection)
17697 )
17698 );
17699 assert_eq!(
17700 unsafe { ::std::ptr::addr_of!((*ptr).m_flAmount) as usize - ptr as usize },
17701 4usize,
17702 concat!(
17703 "Offset of field: ",
17704 stringify!(RemotePlayInputMouseWheel_t),
17705 "::",
17706 stringify!(m_flAmount)
17707 )
17708 );
17709}
17710#[repr(C)]
17711#[derive(Debug, Copy, Clone)]
17712pub struct RemotePlayInputKey_t {
17713 pub m_eScancode: ::std::os::raw::c_int,
17714 pub m_unModifiers: uint32,
17715 pub m_unKeycode: uint32,
17716}
17717#[test]
17718fn bindgen_test_layout_RemotePlayInputKey_t() {
17719 const UNINIT: ::std::mem::MaybeUninit<RemotePlayInputKey_t> = ::std::mem::MaybeUninit::uninit();
17720 let ptr = UNINIT.as_ptr();
17721 assert_eq!(
17722 ::std::mem::size_of::<RemotePlayInputKey_t>(),
17723 12usize,
17724 concat!("Size of: ", stringify!(RemotePlayInputKey_t))
17725 );
17726 assert_eq!(
17727 ::std::mem::align_of::<RemotePlayInputKey_t>(),
17728 4usize,
17729 concat!("Alignment of ", stringify!(RemotePlayInputKey_t))
17730 );
17731 assert_eq!(
17732 unsafe { ::std::ptr::addr_of!((*ptr).m_eScancode) as usize - ptr as usize },
17733 0usize,
17734 concat!(
17735 "Offset of field: ",
17736 stringify!(RemotePlayInputKey_t),
17737 "::",
17738 stringify!(m_eScancode)
17739 )
17740 );
17741 assert_eq!(
17742 unsafe { ::std::ptr::addr_of!((*ptr).m_unModifiers) as usize - ptr as usize },
17743 4usize,
17744 concat!(
17745 "Offset of field: ",
17746 stringify!(RemotePlayInputKey_t),
17747 "::",
17748 stringify!(m_unModifiers)
17749 )
17750 );
17751 assert_eq!(
17752 unsafe { ::std::ptr::addr_of!((*ptr).m_unKeycode) as usize - ptr as usize },
17753 8usize,
17754 concat!(
17755 "Offset of field: ",
17756 stringify!(RemotePlayInputKey_t),
17757 "::",
17758 stringify!(m_unKeycode)
17759 )
17760 );
17761}
17762#[repr(C)]
17763#[derive(Copy, Clone)]
17764pub struct RemotePlayInput_t {
17765 pub m_unSessionID: RemotePlaySessionID_t,
17766 pub m_eType: ERemotePlayInputType,
17767 pub __bindgen_anon_1: RemotePlayInput_t__bindgen_ty_1,
17768}
17769#[repr(C)]
17770#[derive(Copy, Clone)]
17771pub union RemotePlayInput_t__bindgen_ty_1 {
17772 pub m_MouseMotion: RemotePlayInputMouseMotion_t,
17773 pub m_eMouseButton: ERemotePlayMouseButton,
17774 pub m_MouseWheel: RemotePlayInputMouseWheel_t,
17775 pub m_Key: RemotePlayInputKey_t,
17776 pub padding: [::std::os::raw::c_char; 56usize],
17777}
17778#[test]
17779fn bindgen_test_layout_RemotePlayInput_t__bindgen_ty_1() {
17780 const UNINIT: ::std::mem::MaybeUninit<RemotePlayInput_t__bindgen_ty_1> =
17781 ::std::mem::MaybeUninit::uninit();
17782 let ptr = UNINIT.as_ptr();
17783 assert_eq!(
17784 ::std::mem::size_of::<RemotePlayInput_t__bindgen_ty_1>(),
17785 56usize,
17786 concat!("Size of: ", stringify!(RemotePlayInput_t__bindgen_ty_1))
17787 );
17788 assert_eq!(
17789 ::std::mem::align_of::<RemotePlayInput_t__bindgen_ty_1>(),
17790 4usize,
17791 concat!("Alignment of ", stringify!(RemotePlayInput_t__bindgen_ty_1))
17792 );
17793 assert_eq!(
17794 unsafe { ::std::ptr::addr_of!((*ptr).m_MouseMotion) as usize - ptr as usize },
17795 0usize,
17796 concat!(
17797 "Offset of field: ",
17798 stringify!(RemotePlayInput_t__bindgen_ty_1),
17799 "::",
17800 stringify!(m_MouseMotion)
17801 )
17802 );
17803 assert_eq!(
17804 unsafe { ::std::ptr::addr_of!((*ptr).m_eMouseButton) as usize - ptr as usize },
17805 0usize,
17806 concat!(
17807 "Offset of field: ",
17808 stringify!(RemotePlayInput_t__bindgen_ty_1),
17809 "::",
17810 stringify!(m_eMouseButton)
17811 )
17812 );
17813 assert_eq!(
17814 unsafe { ::std::ptr::addr_of!((*ptr).m_MouseWheel) as usize - ptr as usize },
17815 0usize,
17816 concat!(
17817 "Offset of field: ",
17818 stringify!(RemotePlayInput_t__bindgen_ty_1),
17819 "::",
17820 stringify!(m_MouseWheel)
17821 )
17822 );
17823 assert_eq!(
17824 unsafe { ::std::ptr::addr_of!((*ptr).m_Key) as usize - ptr as usize },
17825 0usize,
17826 concat!(
17827 "Offset of field: ",
17828 stringify!(RemotePlayInput_t__bindgen_ty_1),
17829 "::",
17830 stringify!(m_Key)
17831 )
17832 );
17833 assert_eq!(
17834 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
17835 0usize,
17836 concat!(
17837 "Offset of field: ",
17838 stringify!(RemotePlayInput_t__bindgen_ty_1),
17839 "::",
17840 stringify!(padding)
17841 )
17842 );
17843}
17844#[test]
17845fn bindgen_test_layout_RemotePlayInput_t() {
17846 const UNINIT: ::std::mem::MaybeUninit<RemotePlayInput_t> = ::std::mem::MaybeUninit::uninit();
17847 let ptr = UNINIT.as_ptr();
17848 assert_eq!(
17849 ::std::mem::size_of::<RemotePlayInput_t>(),
17850 64usize,
17851 concat!("Size of: ", stringify!(RemotePlayInput_t))
17852 );
17853 assert_eq!(
17854 ::std::mem::align_of::<RemotePlayInput_t>(),
17855 4usize,
17856 concat!("Alignment of ", stringify!(RemotePlayInput_t))
17857 );
17858 assert_eq!(
17859 unsafe { ::std::ptr::addr_of!((*ptr).m_unSessionID) as usize - ptr as usize },
17860 0usize,
17861 concat!(
17862 "Offset of field: ",
17863 stringify!(RemotePlayInput_t),
17864 "::",
17865 stringify!(m_unSessionID)
17866 )
17867 );
17868 assert_eq!(
17869 unsafe { ::std::ptr::addr_of!((*ptr).m_eType) as usize - ptr as usize },
17870 4usize,
17871 concat!(
17872 "Offset of field: ",
17873 stringify!(RemotePlayInput_t),
17874 "::",
17875 stringify!(m_eType)
17876 )
17877 );
17878}
17879#[repr(C)]
17880pub struct ISteamRemotePlay__bindgen_vtable(::std::os::raw::c_void);
17881#[repr(C)]
17882#[derive(Debug, Copy, Clone)]
17883pub struct ISteamRemotePlay {
17884 pub vtable_: *const ISteamRemotePlay__bindgen_vtable,
17885}
17886#[test]
17887fn bindgen_test_layout_ISteamRemotePlay() {
17888 assert_eq!(
17889 ::std::mem::size_of::<ISteamRemotePlay>(),
17890 8usize,
17891 concat!("Size of: ", stringify!(ISteamRemotePlay))
17892 );
17893 assert_eq!(
17894 ::std::mem::align_of::<ISteamRemotePlay>(),
17895 8usize,
17896 concat!("Alignment of ", stringify!(ISteamRemotePlay))
17897 );
17898}
17899#[repr(C)]
17900#[derive(Debug, Copy, Clone)]
17901pub struct SteamRemotePlaySessionConnected_t {
17902 pub m_unSessionID: RemotePlaySessionID_t,
17903}
17904pub const SteamRemotePlaySessionConnected_t_k_iCallback:
17905 SteamRemotePlaySessionConnected_t__bindgen_ty_1 =
17906 SteamRemotePlaySessionConnected_t__bindgen_ty_1::k_iCallback;
17907#[repr(u32)]
17908#[non_exhaustive]
17909#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17910pub enum SteamRemotePlaySessionConnected_t__bindgen_ty_1 {
17911 k_iCallback = 5701,
17912}
17913#[test]
17914fn bindgen_test_layout_SteamRemotePlaySessionConnected_t() {
17915 const UNINIT: ::std::mem::MaybeUninit<SteamRemotePlaySessionConnected_t> =
17916 ::std::mem::MaybeUninit::uninit();
17917 let ptr = UNINIT.as_ptr();
17918 assert_eq!(
17919 ::std::mem::size_of::<SteamRemotePlaySessionConnected_t>(),
17920 4usize,
17921 concat!("Size of: ", stringify!(SteamRemotePlaySessionConnected_t))
17922 );
17923 assert_eq!(
17924 ::std::mem::align_of::<SteamRemotePlaySessionConnected_t>(),
17925 4usize,
17926 concat!(
17927 "Alignment of ",
17928 stringify!(SteamRemotePlaySessionConnected_t)
17929 )
17930 );
17931 assert_eq!(
17932 unsafe { ::std::ptr::addr_of!((*ptr).m_unSessionID) as usize - ptr as usize },
17933 0usize,
17934 concat!(
17935 "Offset of field: ",
17936 stringify!(SteamRemotePlaySessionConnected_t),
17937 "::",
17938 stringify!(m_unSessionID)
17939 )
17940 );
17941}
17942#[repr(C)]
17943#[derive(Debug, Copy, Clone)]
17944pub struct SteamRemotePlaySessionDisconnected_t {
17945 pub m_unSessionID: RemotePlaySessionID_t,
17946}
17947pub const SteamRemotePlaySessionDisconnected_t_k_iCallback:
17948 SteamRemotePlaySessionDisconnected_t__bindgen_ty_1 =
17949 SteamRemotePlaySessionDisconnected_t__bindgen_ty_1::k_iCallback;
17950#[repr(u32)]
17951#[non_exhaustive]
17952#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17953pub enum SteamRemotePlaySessionDisconnected_t__bindgen_ty_1 {
17954 k_iCallback = 5702,
17955}
17956#[test]
17957fn bindgen_test_layout_SteamRemotePlaySessionDisconnected_t() {
17958 const UNINIT: ::std::mem::MaybeUninit<SteamRemotePlaySessionDisconnected_t> =
17959 ::std::mem::MaybeUninit::uninit();
17960 let ptr = UNINIT.as_ptr();
17961 assert_eq!(
17962 ::std::mem::size_of::<SteamRemotePlaySessionDisconnected_t>(),
17963 4usize,
17964 concat!(
17965 "Size of: ",
17966 stringify!(SteamRemotePlaySessionDisconnected_t)
17967 )
17968 );
17969 assert_eq!(
17970 ::std::mem::align_of::<SteamRemotePlaySessionDisconnected_t>(),
17971 4usize,
17972 concat!(
17973 "Alignment of ",
17974 stringify!(SteamRemotePlaySessionDisconnected_t)
17975 )
17976 );
17977 assert_eq!(
17978 unsafe { ::std::ptr::addr_of!((*ptr).m_unSessionID) as usize - ptr as usize },
17979 0usize,
17980 concat!(
17981 "Offset of field: ",
17982 stringify!(SteamRemotePlaySessionDisconnected_t),
17983 "::",
17984 stringify!(m_unSessionID)
17985 )
17986 );
17987}
17988#[repr(C)]
17989#[derive(Debug, Copy, Clone)]
17990pub struct SteamRemotePlayTogetherGuestInvite_t {
17991 pub m_szConnectURL: [::std::os::raw::c_char; 1024usize],
17992}
17993pub const SteamRemotePlayTogetherGuestInvite_t_k_iCallback:
17994 SteamRemotePlayTogetherGuestInvite_t__bindgen_ty_1 =
17995 SteamRemotePlayTogetherGuestInvite_t__bindgen_ty_1::k_iCallback;
17996#[repr(u32)]
17997#[non_exhaustive]
17998#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
17999pub enum SteamRemotePlayTogetherGuestInvite_t__bindgen_ty_1 {
18000 k_iCallback = 5703,
18001}
18002#[test]
18003fn bindgen_test_layout_SteamRemotePlayTogetherGuestInvite_t() {
18004 const UNINIT: ::std::mem::MaybeUninit<SteamRemotePlayTogetherGuestInvite_t> =
18005 ::std::mem::MaybeUninit::uninit();
18006 let ptr = UNINIT.as_ptr();
18007 assert_eq!(
18008 ::std::mem::size_of::<SteamRemotePlayTogetherGuestInvite_t>(),
18009 1024usize,
18010 concat!(
18011 "Size of: ",
18012 stringify!(SteamRemotePlayTogetherGuestInvite_t)
18013 )
18014 );
18015 assert_eq!(
18016 ::std::mem::align_of::<SteamRemotePlayTogetherGuestInvite_t>(),
18017 1usize,
18018 concat!(
18019 "Alignment of ",
18020 stringify!(SteamRemotePlayTogetherGuestInvite_t)
18021 )
18022 );
18023 assert_eq!(
18024 unsafe { ::std::ptr::addr_of!((*ptr).m_szConnectURL) as usize - ptr as usize },
18025 0usize,
18026 concat!(
18027 "Offset of field: ",
18028 stringify!(SteamRemotePlayTogetherGuestInvite_t),
18029 "::",
18030 stringify!(m_szConnectURL)
18031 )
18032 );
18033}
18034#[repr(C)]
18035#[derive(Debug, Copy, Clone)]
18036pub struct SteamRemotePlaySessionAvatarLoaded_t {
18037 pub m_unSessionID: RemotePlaySessionID_t,
18038 pub m_iImage: ::std::os::raw::c_int,
18039 pub m_iWide: ::std::os::raw::c_int,
18040 pub m_iTall: ::std::os::raw::c_int,
18041}
18042pub const SteamRemotePlaySessionAvatarLoaded_t_k_iCallback:
18043 SteamRemotePlaySessionAvatarLoaded_t__bindgen_ty_1 =
18044 SteamRemotePlaySessionAvatarLoaded_t__bindgen_ty_1::k_iCallback;
18045#[repr(u32)]
18046#[non_exhaustive]
18047#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18048pub enum SteamRemotePlaySessionAvatarLoaded_t__bindgen_ty_1 {
18049 k_iCallback = 5704,
18050}
18051#[test]
18052fn bindgen_test_layout_SteamRemotePlaySessionAvatarLoaded_t() {
18053 const UNINIT: ::std::mem::MaybeUninit<SteamRemotePlaySessionAvatarLoaded_t> =
18054 ::std::mem::MaybeUninit::uninit();
18055 let ptr = UNINIT.as_ptr();
18056 assert_eq!(
18057 ::std::mem::size_of::<SteamRemotePlaySessionAvatarLoaded_t>(),
18058 16usize,
18059 concat!(
18060 "Size of: ",
18061 stringify!(SteamRemotePlaySessionAvatarLoaded_t)
18062 )
18063 );
18064 assert_eq!(
18065 ::std::mem::align_of::<SteamRemotePlaySessionAvatarLoaded_t>(),
18066 4usize,
18067 concat!(
18068 "Alignment of ",
18069 stringify!(SteamRemotePlaySessionAvatarLoaded_t)
18070 )
18071 );
18072 assert_eq!(
18073 unsafe { ::std::ptr::addr_of!((*ptr).m_unSessionID) as usize - ptr as usize },
18074 0usize,
18075 concat!(
18076 "Offset of field: ",
18077 stringify!(SteamRemotePlaySessionAvatarLoaded_t),
18078 "::",
18079 stringify!(m_unSessionID)
18080 )
18081 );
18082 assert_eq!(
18083 unsafe { ::std::ptr::addr_of!((*ptr).m_iImage) as usize - ptr as usize },
18084 4usize,
18085 concat!(
18086 "Offset of field: ",
18087 stringify!(SteamRemotePlaySessionAvatarLoaded_t),
18088 "::",
18089 stringify!(m_iImage)
18090 )
18091 );
18092 assert_eq!(
18093 unsafe { ::std::ptr::addr_of!((*ptr).m_iWide) as usize - ptr as usize },
18094 8usize,
18095 concat!(
18096 "Offset of field: ",
18097 stringify!(SteamRemotePlaySessionAvatarLoaded_t),
18098 "::",
18099 stringify!(m_iWide)
18100 )
18101 );
18102 assert_eq!(
18103 unsafe { ::std::ptr::addr_of!((*ptr).m_iTall) as usize - ptr as usize },
18104 12usize,
18105 concat!(
18106 "Offset of field: ",
18107 stringify!(SteamRemotePlaySessionAvatarLoaded_t),
18108 "::",
18109 stringify!(m_iTall)
18110 )
18111 );
18112}
18113pub type int_least8_t = __int_least8_t;
18114pub type int_least16_t = __int_least16_t;
18115pub type int_least32_t = __int_least32_t;
18116pub type int_least64_t = __int_least64_t;
18117pub type uint_least8_t = __uint_least8_t;
18118pub type uint_least16_t = __uint_least16_t;
18119pub type uint_least32_t = __uint_least32_t;
18120pub type uint_least64_t = __uint_least64_t;
18121pub type int_fast8_t = ::std::os::raw::c_schar;
18122pub type int_fast16_t = ::std::os::raw::c_long;
18123pub type int_fast32_t = ::std::os::raw::c_long;
18124pub type int_fast64_t = ::std::os::raw::c_long;
18125pub type uint_fast8_t = ::std::os::raw::c_uchar;
18126pub type uint_fast16_t = ::std::os::raw::c_ulong;
18127pub type uint_fast32_t = ::std::os::raw::c_ulong;
18128pub type uint_fast64_t = ::std::os::raw::c_ulong;
18129pub type intmax_t = __intmax_t;
18130pub type uintmax_t = __uintmax_t;
18131#[repr(C)]
18132#[derive(Debug, Copy, Clone)]
18133pub struct SteamDatagramRelayAuthTicket {
18134 _unused: [u8; 0],
18135}
18136#[repr(C)]
18137#[derive(Debug, Copy, Clone)]
18138pub struct SteamDatagramHostedAddress {
18139 _unused: [u8; 0],
18140}
18141#[repr(C)]
18142#[derive(Debug, Copy, Clone)]
18143pub struct SteamDatagramGameCoordinatorServerLogin {
18144 _unused: [u8; 0],
18145}
18146#[repr(C)]
18147#[derive(Debug, Copy, Clone)]
18148pub struct SteamNetworkingFakeIPResult_t {
18149 _unused: [u8; 0],
18150}
18151pub type FnSteamNetConnectionStatusChanged = ::std::option::Option<
18152 unsafe extern "C" fn(arg1: *mut SteamNetConnectionStatusChangedCallback_t),
18153>;
18154pub type FnSteamNetAuthenticationStatusChanged =
18155 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamNetAuthenticationStatus_t)>;
18156pub type FnSteamRelayNetworkStatusChanged =
18157 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamRelayNetworkStatus_t)>;
18158pub type FnSteamNetworkingMessagesSessionRequest =
18159 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamNetworkingMessagesSessionRequest_t)>;
18160pub type FnSteamNetworkingMessagesSessionFailed =
18161 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamNetworkingMessagesSessionFailed_t)>;
18162pub type FnSteamNetworkingFakeIPResult =
18163 ::std::option::Option<unsafe extern "C" fn(arg1: *mut SteamNetworkingFakeIPResult_t)>;
18164#[doc = " Handle used to identify a connection to a remote host."]
18165pub type HSteamNetConnection = uint32;
18166pub const k_HSteamNetConnection_Invalid: HSteamNetConnection = 0;
18167#[doc = " Handle used to identify a \"listen socket\". Unlike traditional\n Berkeley sockets, a listen socket and a connection are two\n different abstractions."]
18168pub type HSteamListenSocket = uint32;
18169pub const k_HSteamListenSocket_Invalid: HSteamListenSocket = 0;
18170#[doc = " Handle used to identify a poll group, used to query many\n connections at once efficiently."]
18171pub type HSteamNetPollGroup = uint32;
18172pub const k_HSteamNetPollGroup_Invalid: HSteamNetPollGroup = 0;
18173#[doc = " Max length of diagnostic error message"]
18174pub const k_cchMaxSteamNetworkingErrMsg: ::std::os::raw::c_int = 1024;
18175#[doc = " Used to return English-language diagnostic error messages to caller.\n (For debugging or spewing to a console, etc. Not intended for UI.)"]
18176pub type SteamNetworkingErrMsg = [::std::os::raw::c_char; 1024usize];
18177#[doc = " Identifier used for a network location point of presence. (E.g. a Valve data center.)\n Typically you won't need to directly manipulate these."]
18178pub type SteamNetworkingPOPID = uint32;
18179#[doc = " A local timestamp. You can subtract two timestamps to get the number of elapsed\n microseconds. This is guaranteed to increase over time during the lifetime\n of a process, but not globally across runs. You don't need to worry about\n the value wrapping around. Note that the underlying clock might not actually have\n microsecond resolution."]
18180pub type SteamNetworkingMicroseconds = int64;
18181#[repr(i32)]
18182#[non_exhaustive]
18183#[doc = " Describe the status of a particular network resource"]
18184#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18185pub enum ESteamNetworkingAvailability {
18186 k_ESteamNetworkingAvailability_CannotTry = -102,
18187 k_ESteamNetworkingAvailability_Failed = -101,
18188 k_ESteamNetworkingAvailability_Previously = -100,
18189 k_ESteamNetworkingAvailability_Retrying = -10,
18190 k_ESteamNetworkingAvailability_NeverTried = 1,
18191 k_ESteamNetworkingAvailability_Waiting = 2,
18192 k_ESteamNetworkingAvailability_Attempting = 3,
18193 k_ESteamNetworkingAvailability_Current = 100,
18194 k_ESteamNetworkingAvailability_Unknown = 0,
18195 k_ESteamNetworkingAvailability__Force32bit = 2147483647,
18196}
18197#[repr(u32)]
18198#[non_exhaustive]
18199#[doc = " Different methods of describing the identity of a network host"]
18200#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18201pub enum ESteamNetworkingIdentityType {
18202 k_ESteamNetworkingIdentityType_Invalid = 0,
18203 k_ESteamNetworkingIdentityType_SteamID = 16,
18204 k_ESteamNetworkingIdentityType_XboxPairwiseID = 17,
18205 k_ESteamNetworkingIdentityType_SonyPSN = 18,
18206 k_ESteamNetworkingIdentityType_IPAddress = 1,
18207 k_ESteamNetworkingIdentityType_GenericString = 2,
18208 k_ESteamNetworkingIdentityType_GenericBytes = 3,
18209 k_ESteamNetworkingIdentityType_UnknownType = 4,
18210 k_ESteamNetworkingIdentityType__Force32bit = 2147483647,
18211}
18212#[repr(u32)]
18213#[non_exhaustive]
18214#[doc = " \"Fake IPs\" are assigned to hosts, to make it easier to interface with\n older code that assumed all hosts will have an IPv4 address"]
18215#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18216pub enum ESteamNetworkingFakeIPType {
18217 k_ESteamNetworkingFakeIPType_Invalid = 0,
18218 k_ESteamNetworkingFakeIPType_NotFake = 1,
18219 k_ESteamNetworkingFakeIPType_GlobalIPv4 = 2,
18220 k_ESteamNetworkingFakeIPType_LocalIPv4 = 3,
18221 k_ESteamNetworkingFakeIPType__Force32Bit = 2147483647,
18222}
18223#[doc = " Store an IP and port. IPv6 is always used; IPv4 is represented using\n \"IPv4-mapped\" addresses: IPv4 aa.bb.cc.dd => IPv6 ::ffff:aabb:ccdd\n (RFC 4291 section 2.5.5.2.)"]
18224#[repr(C, packed)]
18225#[derive(Copy, Clone)]
18226pub struct SteamNetworkingIPAddr {
18227 pub __bindgen_anon_1: SteamNetworkingIPAddr__bindgen_ty_2,
18228 pub m_port: uint16,
18229}
18230pub const SteamNetworkingIPAddr_k_cchMaxString: SteamNetworkingIPAddr__bindgen_ty_1 =
18231 SteamNetworkingIPAddr__bindgen_ty_1::k_cchMaxString;
18232#[repr(u32)]
18233#[non_exhaustive]
18234#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18235pub enum SteamNetworkingIPAddr__bindgen_ty_1 {
18236 k_cchMaxString = 48,
18237}
18238#[doc = " RFC4038, section 4.2"]
18239#[repr(C, packed)]
18240#[derive(Debug, Copy, Clone)]
18241pub struct SteamNetworkingIPAddr_IPv4MappedAddress {
18242 pub m_8zeros: uint64,
18243 pub m_0000: uint16,
18244 pub m_ffff: uint16,
18245 pub m_ip: [uint8; 4usize],
18246}
18247#[test]
18248fn bindgen_test_layout_SteamNetworkingIPAddr_IPv4MappedAddress() {
18249 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIPAddr_IPv4MappedAddress> =
18250 ::std::mem::MaybeUninit::uninit();
18251 let ptr = UNINIT.as_ptr();
18252 assert_eq!(
18253 ::std::mem::size_of::<SteamNetworkingIPAddr_IPv4MappedAddress>(),
18254 16usize,
18255 concat!(
18256 "Size of: ",
18257 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress)
18258 )
18259 );
18260 assert_eq!(
18261 ::std::mem::align_of::<SteamNetworkingIPAddr_IPv4MappedAddress>(),
18262 1usize,
18263 concat!(
18264 "Alignment of ",
18265 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress)
18266 )
18267 );
18268 assert_eq!(
18269 unsafe { ::std::ptr::addr_of!((*ptr).m_8zeros) as usize - ptr as usize },
18270 0usize,
18271 concat!(
18272 "Offset of field: ",
18273 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress),
18274 "::",
18275 stringify!(m_8zeros)
18276 )
18277 );
18278 assert_eq!(
18279 unsafe { ::std::ptr::addr_of!((*ptr).m_0000) as usize - ptr as usize },
18280 8usize,
18281 concat!(
18282 "Offset of field: ",
18283 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress),
18284 "::",
18285 stringify!(m_0000)
18286 )
18287 );
18288 assert_eq!(
18289 unsafe { ::std::ptr::addr_of!((*ptr).m_ffff) as usize - ptr as usize },
18290 10usize,
18291 concat!(
18292 "Offset of field: ",
18293 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress),
18294 "::",
18295 stringify!(m_ffff)
18296 )
18297 );
18298 assert_eq!(
18299 unsafe { ::std::ptr::addr_of!((*ptr).m_ip) as usize - ptr as usize },
18300 12usize,
18301 concat!(
18302 "Offset of field: ",
18303 stringify!(SteamNetworkingIPAddr_IPv4MappedAddress),
18304 "::",
18305 stringify!(m_ip)
18306 )
18307 );
18308}
18309#[repr(C)]
18310#[derive(Copy, Clone)]
18311pub union SteamNetworkingIPAddr__bindgen_ty_2 {
18312 pub m_ipv6: [uint8; 16usize],
18313 pub m_ipv4: SteamNetworkingIPAddr_IPv4MappedAddress,
18314}
18315#[test]
18316fn bindgen_test_layout_SteamNetworkingIPAddr__bindgen_ty_2() {
18317 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIPAddr__bindgen_ty_2> =
18318 ::std::mem::MaybeUninit::uninit();
18319 let ptr = UNINIT.as_ptr();
18320 assert_eq!(
18321 ::std::mem::size_of::<SteamNetworkingIPAddr__bindgen_ty_2>(),
18322 16usize,
18323 concat!("Size of: ", stringify!(SteamNetworkingIPAddr__bindgen_ty_2))
18324 );
18325 assert_eq!(
18326 ::std::mem::align_of::<SteamNetworkingIPAddr__bindgen_ty_2>(),
18327 1usize,
18328 concat!(
18329 "Alignment of ",
18330 stringify!(SteamNetworkingIPAddr__bindgen_ty_2)
18331 )
18332 );
18333 assert_eq!(
18334 unsafe { ::std::ptr::addr_of!((*ptr).m_ipv6) as usize - ptr as usize },
18335 0usize,
18336 concat!(
18337 "Offset of field: ",
18338 stringify!(SteamNetworkingIPAddr__bindgen_ty_2),
18339 "::",
18340 stringify!(m_ipv6)
18341 )
18342 );
18343 assert_eq!(
18344 unsafe { ::std::ptr::addr_of!((*ptr).m_ipv4) as usize - ptr as usize },
18345 0usize,
18346 concat!(
18347 "Offset of field: ",
18348 stringify!(SteamNetworkingIPAddr__bindgen_ty_2),
18349 "::",
18350 stringify!(m_ipv4)
18351 )
18352 );
18353}
18354#[test]
18355fn bindgen_test_layout_SteamNetworkingIPAddr() {
18356 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIPAddr> =
18357 ::std::mem::MaybeUninit::uninit();
18358 let ptr = UNINIT.as_ptr();
18359 assert_eq!(
18360 ::std::mem::size_of::<SteamNetworkingIPAddr>(),
18361 18usize,
18362 concat!("Size of: ", stringify!(SteamNetworkingIPAddr))
18363 );
18364 assert_eq!(
18365 ::std::mem::align_of::<SteamNetworkingIPAddr>(),
18366 1usize,
18367 concat!("Alignment of ", stringify!(SteamNetworkingIPAddr))
18368 );
18369 assert_eq!(
18370 unsafe { ::std::ptr::addr_of!((*ptr).m_port) as usize - ptr as usize },
18371 16usize,
18372 concat!(
18373 "Offset of field: ",
18374 stringify!(SteamNetworkingIPAddr),
18375 "::",
18376 stringify!(m_port)
18377 )
18378 );
18379}
18380#[doc = " An abstract way to represent the identity of a network host. All identities can\n be represented as simple string. Furthermore, this string representation is actually\n used on the wire in several places, even though it is less efficient, in order to\n facilitate forward compatibility. (Old client code can handle an identity type that\n it doesn't understand.)"]
18381#[repr(C, packed)]
18382#[derive(Copy, Clone)]
18383pub struct SteamNetworkingIdentity {
18384 #[doc = " Type of identity."]
18385 pub m_eType: ESteamNetworkingIdentityType,
18386 pub m_cbSize: ::std::os::raw::c_int,
18387 pub __bindgen_anon_1: SteamNetworkingIdentity__bindgen_ty_2,
18388}
18389pub const SteamNetworkingIdentity_k_cchMaxString: SteamNetworkingIdentity__bindgen_ty_1 =
18390 SteamNetworkingIdentity__bindgen_ty_1::k_cchMaxString;
18391pub const SteamNetworkingIdentity_k_cchMaxGenericString: SteamNetworkingIdentity__bindgen_ty_1 =
18392 SteamNetworkingIdentity__bindgen_ty_1::k_cchMaxGenericString;
18393pub const SteamNetworkingIdentity_k_cchMaxXboxPairwiseID: SteamNetworkingIdentity__bindgen_ty_1 =
18394 SteamNetworkingIdentity__bindgen_ty_1::k_cchMaxXboxPairwiseID;
18395pub const SteamNetworkingIdentity_k_cbMaxGenericBytes: SteamNetworkingIdentity__bindgen_ty_1 =
18396 SteamNetworkingIdentity__bindgen_ty_1::k_cchMaxGenericString;
18397#[repr(u32)]
18398#[non_exhaustive]
18399#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18400pub enum SteamNetworkingIdentity__bindgen_ty_1 {
18401 k_cchMaxString = 128,
18402 k_cchMaxGenericString = 32,
18403 k_cchMaxXboxPairwiseID = 33,
18404}
18405#[repr(C, packed)]
18406#[derive(Copy, Clone)]
18407pub union SteamNetworkingIdentity__bindgen_ty_2 {
18408 pub m_steamID64: uint64,
18409 pub m_PSNID: uint64,
18410 pub m_szGenericString: [::std::os::raw::c_char; 32usize],
18411 pub m_szXboxPairwiseID: [::std::os::raw::c_char; 33usize],
18412 pub m_genericBytes: [uint8; 32usize],
18413 pub m_szUnknownRawString: [::std::os::raw::c_char; 128usize],
18414 pub m_ip: SteamNetworkingIPAddr,
18415 pub m_reserved: [uint32; 32usize],
18416}
18417#[test]
18418fn bindgen_test_layout_SteamNetworkingIdentity__bindgen_ty_2() {
18419 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIdentity__bindgen_ty_2> =
18420 ::std::mem::MaybeUninit::uninit();
18421 let ptr = UNINIT.as_ptr();
18422 assert_eq!(
18423 ::std::mem::size_of::<SteamNetworkingIdentity__bindgen_ty_2>(),
18424 128usize,
18425 concat!(
18426 "Size of: ",
18427 stringify!(SteamNetworkingIdentity__bindgen_ty_2)
18428 )
18429 );
18430 assert_eq!(
18431 ::std::mem::align_of::<SteamNetworkingIdentity__bindgen_ty_2>(),
18432 1usize,
18433 concat!(
18434 "Alignment of ",
18435 stringify!(SteamNetworkingIdentity__bindgen_ty_2)
18436 )
18437 );
18438 assert_eq!(
18439 unsafe { ::std::ptr::addr_of!((*ptr).m_steamID64) as usize - ptr as usize },
18440 0usize,
18441 concat!(
18442 "Offset of field: ",
18443 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18444 "::",
18445 stringify!(m_steamID64)
18446 )
18447 );
18448 assert_eq!(
18449 unsafe { ::std::ptr::addr_of!((*ptr).m_PSNID) as usize - ptr as usize },
18450 0usize,
18451 concat!(
18452 "Offset of field: ",
18453 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18454 "::",
18455 stringify!(m_PSNID)
18456 )
18457 );
18458 assert_eq!(
18459 unsafe { ::std::ptr::addr_of!((*ptr).m_szGenericString) as usize - ptr as usize },
18460 0usize,
18461 concat!(
18462 "Offset of field: ",
18463 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18464 "::",
18465 stringify!(m_szGenericString)
18466 )
18467 );
18468 assert_eq!(
18469 unsafe { ::std::ptr::addr_of!((*ptr).m_szXboxPairwiseID) as usize - ptr as usize },
18470 0usize,
18471 concat!(
18472 "Offset of field: ",
18473 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18474 "::",
18475 stringify!(m_szXboxPairwiseID)
18476 )
18477 );
18478 assert_eq!(
18479 unsafe { ::std::ptr::addr_of!((*ptr).m_genericBytes) as usize - ptr as usize },
18480 0usize,
18481 concat!(
18482 "Offset of field: ",
18483 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18484 "::",
18485 stringify!(m_genericBytes)
18486 )
18487 );
18488 assert_eq!(
18489 unsafe { ::std::ptr::addr_of!((*ptr).m_szUnknownRawString) as usize - ptr as usize },
18490 0usize,
18491 concat!(
18492 "Offset of field: ",
18493 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18494 "::",
18495 stringify!(m_szUnknownRawString)
18496 )
18497 );
18498 assert_eq!(
18499 unsafe { ::std::ptr::addr_of!((*ptr).m_ip) as usize - ptr as usize },
18500 0usize,
18501 concat!(
18502 "Offset of field: ",
18503 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18504 "::",
18505 stringify!(m_ip)
18506 )
18507 );
18508 assert_eq!(
18509 unsafe { ::std::ptr::addr_of!((*ptr).m_reserved) as usize - ptr as usize },
18510 0usize,
18511 concat!(
18512 "Offset of field: ",
18513 stringify!(SteamNetworkingIdentity__bindgen_ty_2),
18514 "::",
18515 stringify!(m_reserved)
18516 )
18517 );
18518}
18519#[test]
18520fn bindgen_test_layout_SteamNetworkingIdentity() {
18521 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIdentity> =
18522 ::std::mem::MaybeUninit::uninit();
18523 let ptr = UNINIT.as_ptr();
18524 assert_eq!(
18525 ::std::mem::size_of::<SteamNetworkingIdentity>(),
18526 136usize,
18527 concat!("Size of: ", stringify!(SteamNetworkingIdentity))
18528 );
18529 assert_eq!(
18530 ::std::mem::align_of::<SteamNetworkingIdentity>(),
18531 1usize,
18532 concat!("Alignment of ", stringify!(SteamNetworkingIdentity))
18533 );
18534 assert_eq!(
18535 unsafe { ::std::ptr::addr_of!((*ptr).m_eType) as usize - ptr as usize },
18536 0usize,
18537 concat!(
18538 "Offset of field: ",
18539 stringify!(SteamNetworkingIdentity),
18540 "::",
18541 stringify!(m_eType)
18542 )
18543 );
18544 assert_eq!(
18545 unsafe { ::std::ptr::addr_of!((*ptr).m_cbSize) as usize - ptr as usize },
18546 4usize,
18547 concat!(
18548 "Offset of field: ",
18549 stringify!(SteamNetworkingIdentity),
18550 "::",
18551 stringify!(m_cbSize)
18552 )
18553 );
18554}
18555#[repr(i32)]
18556#[non_exhaustive]
18557#[doc = " High level connection status"]
18558#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18559pub enum ESteamNetworkingConnectionState {
18560 #[doc = " Dummy value used to indicate an error condition in the API.\n Specified connection doesn't exist or has already been closed."]
18561 k_ESteamNetworkingConnectionState_None = 0,
18562 #[doc = " We are trying to establish whether peers can talk to each other,\n whether they WANT to talk to each other, perform basic auth,\n and exchange crypt keys.\n\n - For connections on the \"client\" side (initiated locally):\n We're in the process of trying to establish a connection.\n Depending on the connection type, we might not know who they are.\n Note that it is not possible to tell if we are waiting on the\n network to complete handshake packets, or for the application layer\n to accept the connection.\n\n - For connections on the \"server\" side (accepted through listen socket):\n We have completed some basic handshake and the client has presented\n some proof of identity. The connection is ready to be accepted\n using AcceptConnection().\n\n In either case, any unreliable packets sent now are almost certain\n to be dropped. Attempts to receive packets are guaranteed to fail.\n You may send messages if the send mode allows for them to be queued.\n but if you close the connection before the connection is actually\n established, any queued messages will be discarded immediately.\n (We will not attempt to flush the queue and confirm delivery to the\n remote host, which ordinarily happens when a connection is closed.)"]
18563 k_ESteamNetworkingConnectionState_Connecting = 1,
18564 #[doc = " Some connection types use a back channel or trusted 3rd party\n for earliest communication. If the server accepts the connection,\n then these connections switch into the rendezvous state. During this\n state, we still have not yet established an end-to-end route (through\n the relay network), and so if you send any messages unreliable, they\n are going to be discarded."]
18565 k_ESteamNetworkingConnectionState_FindingRoute = 2,
18566 #[doc = " We've received communications from our peer (and we know\n who they are) and are all good. If you close the connection now,\n we will make our best effort to flush out any reliable sent data that\n has not been acknowledged by the peer. (But note that this happens\n from within the application process, so unlike a TCP connection, you are\n not totally handing it off to the operating system to deal with it.)"]
18567 k_ESteamNetworkingConnectionState_Connected = 3,
18568 #[doc = " Connection has been closed by our peer, but not closed locally.\n The connection still exists from an API perspective. You must close the\n handle to free up resources. If there are any messages in the inbound queue,\n you may retrieve them. Otherwise, nothing may be done with the connection\n except to close it.\n\n This stats is similar to CLOSE_WAIT in the TCP state machine."]
18569 k_ESteamNetworkingConnectionState_ClosedByPeer = 4,
18570 #[doc = " A disruption in the connection has been detected locally. (E.g. timeout,\n local internet connection disrupted, etc.)\n\n The connection still exists from an API perspective. You must close the\n handle to free up resources.\n\n Attempts to send further messages will fail. Any remaining received messages\n in the queue are available."]
18571 k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 5,
18572 #[doc = " We've disconnected on our side, and from an API perspective the connection is closed.\n No more data may be sent or received. All reliable data has been flushed, or else\n we've given up and discarded it. We do not yet know for sure that the peer knows\n the connection has been closed, however, so we're just hanging around so that if we do\n get a packet from them, we can send them the appropriate packets so that they can\n know why the connection was closed (and not have to rely on a timeout, which makes\n it appear as if something is wrong)."]
18573 k_ESteamNetworkingConnectionState_FinWait = -1,
18574 #[doc = " We've disconnected on our side, and from an API perspective the connection is closed.\n No more data may be sent or received. From a network perspective, however, on the wire,\n we have not yet given any indication to the peer that the connection is closed.\n We are in the process of flushing out the last bit of reliable data. Once that is done,\n we will inform the peer that the connection has been closed, and transition to the\n FinWait state.\n\n Note that no indication is given to the remote host that we have closed the connection,\n until the data has been flushed. If the remote host attempts to send us data, we will\n do whatever is necessary to keep the connection alive until it can be closed properly.\n But in fact the data will be discarded, since there is no way for the application to\n read it back. Typically this is not a problem, as application protocols that utilize\n the lingering functionality are designed for the remote host to wait for the response\n before sending any more data."]
18575 k_ESteamNetworkingConnectionState_Linger = -2,
18576 #[doc = " Connection is completely inactive and ready to be destroyed"]
18577 k_ESteamNetworkingConnectionState_Dead = -3,
18578 #[doc = " Connection is completely inactive and ready to be destroyed"]
18579 k_ESteamNetworkingConnectionState__Force32Bit = 2147483647,
18580}
18581impl ESteamNetConnectionEnd {
18582 pub const k_ESteamNetConnectionEnd_App_Generic: ESteamNetConnectionEnd =
18583 ESteamNetConnectionEnd::k_ESteamNetConnectionEnd_App_Min;
18584}
18585impl ESteamNetConnectionEnd {
18586 pub const k_ESteamNetConnectionEnd_AppException_Generic: ESteamNetConnectionEnd =
18587 ESteamNetConnectionEnd::k_ESteamNetConnectionEnd_AppException_Min;
18588}
18589#[repr(u32)]
18590#[non_exhaustive]
18591#[doc = " Enumerate various causes of connection termination. These are designed to work similar\n to HTTP error codes: the numeric range gives you a rough classification as to the source\n of the problem."]
18592#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
18593pub enum ESteamNetConnectionEnd {
18594 k_ESteamNetConnectionEnd_Invalid = 0,
18595 k_ESteamNetConnectionEnd_App_Min = 1000,
18596 k_ESteamNetConnectionEnd_App_Max = 1999,
18597 k_ESteamNetConnectionEnd_AppException_Min = 2000,
18598 k_ESteamNetConnectionEnd_AppException_Max = 2999,
18599 k_ESteamNetConnectionEnd_Local_Min = 3000,
18600 k_ESteamNetConnectionEnd_Local_OfflineMode = 3001,
18601 k_ESteamNetConnectionEnd_Local_ManyRelayConnectivity = 3002,
18602 k_ESteamNetConnectionEnd_Local_HostedServerPrimaryRelay = 3003,
18603 k_ESteamNetConnectionEnd_Local_NetworkConfig = 3004,
18604 k_ESteamNetConnectionEnd_Local_Rights = 3005,
18605 k_ESteamNetConnectionEnd_Local_P2P_ICE_NoPublicAddresses = 3006,
18606 k_ESteamNetConnectionEnd_Local_Max = 3999,
18607 k_ESteamNetConnectionEnd_Remote_Min = 4000,
18608 k_ESteamNetConnectionEnd_Remote_Timeout = 4001,
18609 k_ESteamNetConnectionEnd_Remote_BadCrypt = 4002,
18610 k_ESteamNetConnectionEnd_Remote_BadCert = 4003,
18611 k_ESteamNetConnectionEnd_Remote_BadProtocolVersion = 4006,
18612 k_ESteamNetConnectionEnd_Remote_P2P_ICE_NoPublicAddresses = 4007,
18613 k_ESteamNetConnectionEnd_Remote_Max = 4999,
18614 k_ESteamNetConnectionEnd_Misc_Min = 5000,
18615 k_ESteamNetConnectionEnd_Misc_Generic = 5001,
18616 k_ESteamNetConnectionEnd_Misc_InternalError = 5002,
18617 k_ESteamNetConnectionEnd_Misc_Timeout = 5003,
18618 k_ESteamNetConnectionEnd_Misc_SteamConnectivity = 5005,
18619 k_ESteamNetConnectionEnd_Misc_NoRelaySessionsToClient = 5006,
18620 k_ESteamNetConnectionEnd_Misc_P2P_Rendezvous = 5008,
18621 k_ESteamNetConnectionEnd_Misc_P2P_NAT_Firewall = 5009,
18622 k_ESteamNetConnectionEnd_Misc_PeerSentNoConnection = 5010,
18623 k_ESteamNetConnectionEnd_Misc_Max = 5999,
18624 k_ESteamNetConnectionEnd__Force32Bit = 2147483647,
18625}
18626#[doc = " Max length, in bytes (including null terminator) of the reason string\n when a connection is closed."]
18627pub const k_cchSteamNetworkingMaxConnectionCloseReason: ::std::os::raw::c_int = 128;
18628#[doc = " Max length, in bytes (include null terminator) of debug description\n of a connection."]
18629pub const k_cchSteamNetworkingMaxConnectionDescription: ::std::os::raw::c_int = 128;
18630#[doc = " Max length of the app's part of the description"]
18631pub const k_cchSteamNetworkingMaxConnectionAppName: ::std::os::raw::c_int = 32;
18632pub const k_nSteamNetworkConnectionInfoFlags_Unauthenticated: ::std::os::raw::c_int = 1;
18633pub const k_nSteamNetworkConnectionInfoFlags_Unencrypted: ::std::os::raw::c_int = 2;
18634pub const k_nSteamNetworkConnectionInfoFlags_LoopbackBuffers: ::std::os::raw::c_int = 4;
18635pub const k_nSteamNetworkConnectionInfoFlags_Fast: ::std::os::raw::c_int = 8;
18636pub const k_nSteamNetworkConnectionInfoFlags_Relayed: ::std::os::raw::c_int = 16;
18637pub const k_nSteamNetworkConnectionInfoFlags_DualWifi: ::std::os::raw::c_int = 32;
18638#[doc = " Describe the state of a connection."]
18639#[repr(C, packed(4))]
18640#[derive(Copy, Clone)]
18641pub struct SteamNetConnectionInfo_t {
18642 #[doc = " Who is on the other end? Depending on the connection type and phase of the connection, we might not know"]
18643 pub m_identityRemote: SteamNetworkingIdentity,
18644 #[doc = " Arbitrary user data set by the local application code"]
18645 pub m_nUserData: int64,
18646 #[doc = " Handle to listen socket this was connected on, or k_HSteamListenSocket_Invalid if we initiated the connection"]
18647 pub m_hListenSocket: HSteamListenSocket,
18648 #[doc = " Remote address. Might be all 0's if we don't know it, or if this is N/A.\n (E.g. Basically everything except direct UDP connection.)"]
18649 pub m_addrRemote: SteamNetworkingIPAddr,
18650 pub m__pad1: uint16,
18651 #[doc = " What data center is the remote host in? (0 if we don't know.)"]
18652 pub m_idPOPRemote: SteamNetworkingPOPID,
18653 #[doc = " What relay are we using to communicate with the remote host?\n (0 if not applicable.)"]
18654 pub m_idPOPRelay: SteamNetworkingPOPID,
18655 #[doc = " High level state of the connection"]
18656 pub m_eState: ESteamNetworkingConnectionState,
18657 #[doc = " Basic cause of the connection termination or problem.\n See ESteamNetConnectionEnd for the values used"]
18658 pub m_eEndReason: ::std::os::raw::c_int,
18659 #[doc = " Human-readable, but non-localized explanation for connection\n termination or problem. This is intended for debugging /\n diagnostic purposes only, not to display to users. It might\n have some details specific to the issue."]
18660 pub m_szEndDebug: [::std::os::raw::c_char; 128usize],
18661 #[doc = " Debug description. This includes the internal connection ID,\n connection type (and peer information), and any name\n given to the connection by the app. This string is used in various\n internal logging messages.\n\n Note that the connection ID *usually* matches the HSteamNetConnection\n handle, but in certain cases with symmetric connections it might not."]
18662 pub m_szConnectionDescription: [::std::os::raw::c_char; 128usize],
18663 #[doc = " Misc flags. Bitmask of k_nSteamNetworkConnectionInfoFlags_Xxxx"]
18664 pub m_nFlags: ::std::os::raw::c_int,
18665 #[doc = " Internal stuff, room to change API easily"]
18666 pub reserved: [uint32; 63usize],
18667}
18668#[test]
18669fn bindgen_test_layout_SteamNetConnectionInfo_t() {
18670 const UNINIT: ::std::mem::MaybeUninit<SteamNetConnectionInfo_t> =
18671 ::std::mem::MaybeUninit::uninit();
18672 let ptr = UNINIT.as_ptr();
18673 assert_eq!(
18674 ::std::mem::size_of::<SteamNetConnectionInfo_t>(),
18675 696usize,
18676 concat!("Size of: ", stringify!(SteamNetConnectionInfo_t))
18677 );
18678 assert_eq!(
18679 ::std::mem::align_of::<SteamNetConnectionInfo_t>(),
18680 4usize,
18681 concat!("Alignment of ", stringify!(SteamNetConnectionInfo_t))
18682 );
18683 assert_eq!(
18684 unsafe { ::std::ptr::addr_of!((*ptr).m_identityRemote) as usize - ptr as usize },
18685 0usize,
18686 concat!(
18687 "Offset of field: ",
18688 stringify!(SteamNetConnectionInfo_t),
18689 "::",
18690 stringify!(m_identityRemote)
18691 )
18692 );
18693 assert_eq!(
18694 unsafe { ::std::ptr::addr_of!((*ptr).m_nUserData) as usize - ptr as usize },
18695 136usize,
18696 concat!(
18697 "Offset of field: ",
18698 stringify!(SteamNetConnectionInfo_t),
18699 "::",
18700 stringify!(m_nUserData)
18701 )
18702 );
18703 assert_eq!(
18704 unsafe { ::std::ptr::addr_of!((*ptr).m_hListenSocket) as usize - ptr as usize },
18705 144usize,
18706 concat!(
18707 "Offset of field: ",
18708 stringify!(SteamNetConnectionInfo_t),
18709 "::",
18710 stringify!(m_hListenSocket)
18711 )
18712 );
18713 assert_eq!(
18714 unsafe { ::std::ptr::addr_of!((*ptr).m_addrRemote) as usize - ptr as usize },
18715 148usize,
18716 concat!(
18717 "Offset of field: ",
18718 stringify!(SteamNetConnectionInfo_t),
18719 "::",
18720 stringify!(m_addrRemote)
18721 )
18722 );
18723 assert_eq!(
18724 unsafe { ::std::ptr::addr_of!((*ptr).m__pad1) as usize - ptr as usize },
18725 166usize,
18726 concat!(
18727 "Offset of field: ",
18728 stringify!(SteamNetConnectionInfo_t),
18729 "::",
18730 stringify!(m__pad1)
18731 )
18732 );
18733 assert_eq!(
18734 unsafe { ::std::ptr::addr_of!((*ptr).m_idPOPRemote) as usize - ptr as usize },
18735 168usize,
18736 concat!(
18737 "Offset of field: ",
18738 stringify!(SteamNetConnectionInfo_t),
18739 "::",
18740 stringify!(m_idPOPRemote)
18741 )
18742 );
18743 assert_eq!(
18744 unsafe { ::std::ptr::addr_of!((*ptr).m_idPOPRelay) as usize - ptr as usize },
18745 172usize,
18746 concat!(
18747 "Offset of field: ",
18748 stringify!(SteamNetConnectionInfo_t),
18749 "::",
18750 stringify!(m_idPOPRelay)
18751 )
18752 );
18753 assert_eq!(
18754 unsafe { ::std::ptr::addr_of!((*ptr).m_eState) as usize - ptr as usize },
18755 176usize,
18756 concat!(
18757 "Offset of field: ",
18758 stringify!(SteamNetConnectionInfo_t),
18759 "::",
18760 stringify!(m_eState)
18761 )
18762 );
18763 assert_eq!(
18764 unsafe { ::std::ptr::addr_of!((*ptr).m_eEndReason) as usize - ptr as usize },
18765 180usize,
18766 concat!(
18767 "Offset of field: ",
18768 stringify!(SteamNetConnectionInfo_t),
18769 "::",
18770 stringify!(m_eEndReason)
18771 )
18772 );
18773 assert_eq!(
18774 unsafe { ::std::ptr::addr_of!((*ptr).m_szEndDebug) as usize - ptr as usize },
18775 184usize,
18776 concat!(
18777 "Offset of field: ",
18778 stringify!(SteamNetConnectionInfo_t),
18779 "::",
18780 stringify!(m_szEndDebug)
18781 )
18782 );
18783 assert_eq!(
18784 unsafe { ::std::ptr::addr_of!((*ptr).m_szConnectionDescription) as usize - ptr as usize },
18785 312usize,
18786 concat!(
18787 "Offset of field: ",
18788 stringify!(SteamNetConnectionInfo_t),
18789 "::",
18790 stringify!(m_szConnectionDescription)
18791 )
18792 );
18793 assert_eq!(
18794 unsafe { ::std::ptr::addr_of!((*ptr).m_nFlags) as usize - ptr as usize },
18795 440usize,
18796 concat!(
18797 "Offset of field: ",
18798 stringify!(SteamNetConnectionInfo_t),
18799 "::",
18800 stringify!(m_nFlags)
18801 )
18802 );
18803 assert_eq!(
18804 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
18805 444usize,
18806 concat!(
18807 "Offset of field: ",
18808 stringify!(SteamNetConnectionInfo_t),
18809 "::",
18810 stringify!(reserved)
18811 )
18812 );
18813}
18814#[doc = " Quick connection state, pared down to something you could call\n more frequently without it being too big of a perf hit."]
18815#[repr(C, packed(4))]
18816#[derive(Debug, Copy, Clone)]
18817pub struct SteamNetConnectionRealTimeStatus_t {
18818 #[doc = " High level state of the connection"]
18819 pub m_eState: ESteamNetworkingConnectionState,
18820 #[doc = " Current ping (ms)"]
18821 pub m_nPing: ::std::os::raw::c_int,
18822 #[doc = " Connection quality measured locally, 0...1. (Percentage of packets delivered\n end-to-end in order)."]
18823 pub m_flConnectionQualityLocal: f32,
18824 #[doc = " Packet delivery success rate as observed from remote host"]
18825 pub m_flConnectionQualityRemote: f32,
18826 #[doc = " Current data rates from recent history."]
18827 pub m_flOutPacketsPerSec: f32,
18828 pub m_flOutBytesPerSec: f32,
18829 pub m_flInPacketsPerSec: f32,
18830 pub m_flInBytesPerSec: f32,
18831 #[doc = " Estimate rate that we believe that we can send data to our peer.\n Note that this could be significantly higher than m_flOutBytesPerSec,\n meaning the capacity of the channel is higher than you are sending data.\n (That's OK!)"]
18832 pub m_nSendRateBytesPerSecond: ::std::os::raw::c_int,
18833 #[doc = " Number of bytes pending to be sent. This is data that you have recently\n requested to be sent but has not yet actually been put on the wire. The\n reliable number ALSO includes data that was previously placed on the wire,\n but has now been scheduled for re-transmission. Thus, it's possible to\n observe m_cbPendingReliable increasing between two checks, even if no\n calls were made to send reliable data between the checks. Data that is\n awaiting the Nagle delay will appear in these numbers."]
18834 pub m_cbPendingUnreliable: ::std::os::raw::c_int,
18835 pub m_cbPendingReliable: ::std::os::raw::c_int,
18836 #[doc = " Number of bytes of reliable data that has been placed the wire, but\n for which we have not yet received an acknowledgment, and thus we may\n have to re-transmit."]
18837 pub m_cbSentUnackedReliable: ::std::os::raw::c_int,
18838 #[doc = " If you queued a message right now, approximately how long would that message\n wait in the queue before we actually started putting its data on the wire in\n a packet?\n\n In general, data that is sent by the application is limited by the bandwidth\n of the channel. If you send data faster than this, it must be queued and\n put on the wire at a metered rate. Even sending a small amount of data (e.g.\n a few MTU, say ~3k) will require some of the data to be delayed a bit.\n\n Ignoring multiple lanes, the estimated delay will be approximately equal to\n\n\t\t( m_cbPendingUnreliable+m_cbPendingReliable ) / m_nSendRateBytesPerSecond\n\n plus or minus one MTU. It depends on how much time has elapsed since the last\n packet was put on the wire. For example, the queue might have *just* been emptied,\n and the last packet placed on the wire, and we are exactly up against the send\n rate limit. In that case we might need to wait for one packet's worth of time to\n elapse before we can send again. On the other extreme, the queue might have data\n in it waiting for Nagle. (This will always be less than one packet, because as\n soon as we have a complete packet we would send it.) In that case, we might be\n ready to send data now, and this value will be 0.\n\n This value is only valid if multiple lanes are not used. If multiple lanes are\n in use, then the queue time will be different for each lane, and you must use\n the value in SteamNetConnectionRealTimeLaneStatus_t.\n\n Nagle delay is ignored for the purposes of this calculation."]
18839 pub m_usecQueueTime: SteamNetworkingMicroseconds,
18840 #[doc = " Highest packet jitter experienced, since the last time this information\n was returned. (The high water mark is cleared each time you fetch the info.)\n\n - The units are microseconds, although the measurement precision is usually\n not nearly this precise.\n - A negative value means \"no data available\".\n - Not all connections are able to measure jitter."]
18841 pub m_usecMaxJitter: int32,
18842 pub reserved: [uint32; 15usize],
18843}
18844#[test]
18845fn bindgen_test_layout_SteamNetConnectionRealTimeStatus_t() {
18846 const UNINIT: ::std::mem::MaybeUninit<SteamNetConnectionRealTimeStatus_t> =
18847 ::std::mem::MaybeUninit::uninit();
18848 let ptr = UNINIT.as_ptr();
18849 assert_eq!(
18850 ::std::mem::size_of::<SteamNetConnectionRealTimeStatus_t>(),
18851 120usize,
18852 concat!("Size of: ", stringify!(SteamNetConnectionRealTimeStatus_t))
18853 );
18854 assert_eq!(
18855 ::std::mem::align_of::<SteamNetConnectionRealTimeStatus_t>(),
18856 4usize,
18857 concat!(
18858 "Alignment of ",
18859 stringify!(SteamNetConnectionRealTimeStatus_t)
18860 )
18861 );
18862 assert_eq!(
18863 unsafe { ::std::ptr::addr_of!((*ptr).m_eState) as usize - ptr as usize },
18864 0usize,
18865 concat!(
18866 "Offset of field: ",
18867 stringify!(SteamNetConnectionRealTimeStatus_t),
18868 "::",
18869 stringify!(m_eState)
18870 )
18871 );
18872 assert_eq!(
18873 unsafe { ::std::ptr::addr_of!((*ptr).m_nPing) as usize - ptr as usize },
18874 4usize,
18875 concat!(
18876 "Offset of field: ",
18877 stringify!(SteamNetConnectionRealTimeStatus_t),
18878 "::",
18879 stringify!(m_nPing)
18880 )
18881 );
18882 assert_eq!(
18883 unsafe { ::std::ptr::addr_of!((*ptr).m_flConnectionQualityLocal) as usize - ptr as usize },
18884 8usize,
18885 concat!(
18886 "Offset of field: ",
18887 stringify!(SteamNetConnectionRealTimeStatus_t),
18888 "::",
18889 stringify!(m_flConnectionQualityLocal)
18890 )
18891 );
18892 assert_eq!(
18893 unsafe { ::std::ptr::addr_of!((*ptr).m_flConnectionQualityRemote) as usize - ptr as usize },
18894 12usize,
18895 concat!(
18896 "Offset of field: ",
18897 stringify!(SteamNetConnectionRealTimeStatus_t),
18898 "::",
18899 stringify!(m_flConnectionQualityRemote)
18900 )
18901 );
18902 assert_eq!(
18903 unsafe { ::std::ptr::addr_of!((*ptr).m_flOutPacketsPerSec) as usize - ptr as usize },
18904 16usize,
18905 concat!(
18906 "Offset of field: ",
18907 stringify!(SteamNetConnectionRealTimeStatus_t),
18908 "::",
18909 stringify!(m_flOutPacketsPerSec)
18910 )
18911 );
18912 assert_eq!(
18913 unsafe { ::std::ptr::addr_of!((*ptr).m_flOutBytesPerSec) as usize - ptr as usize },
18914 20usize,
18915 concat!(
18916 "Offset of field: ",
18917 stringify!(SteamNetConnectionRealTimeStatus_t),
18918 "::",
18919 stringify!(m_flOutBytesPerSec)
18920 )
18921 );
18922 assert_eq!(
18923 unsafe { ::std::ptr::addr_of!((*ptr).m_flInPacketsPerSec) as usize - ptr as usize },
18924 24usize,
18925 concat!(
18926 "Offset of field: ",
18927 stringify!(SteamNetConnectionRealTimeStatus_t),
18928 "::",
18929 stringify!(m_flInPacketsPerSec)
18930 )
18931 );
18932 assert_eq!(
18933 unsafe { ::std::ptr::addr_of!((*ptr).m_flInBytesPerSec) as usize - ptr as usize },
18934 28usize,
18935 concat!(
18936 "Offset of field: ",
18937 stringify!(SteamNetConnectionRealTimeStatus_t),
18938 "::",
18939 stringify!(m_flInBytesPerSec)
18940 )
18941 );
18942 assert_eq!(
18943 unsafe { ::std::ptr::addr_of!((*ptr).m_nSendRateBytesPerSecond) as usize - ptr as usize },
18944 32usize,
18945 concat!(
18946 "Offset of field: ",
18947 stringify!(SteamNetConnectionRealTimeStatus_t),
18948 "::",
18949 stringify!(m_nSendRateBytesPerSecond)
18950 )
18951 );
18952 assert_eq!(
18953 unsafe { ::std::ptr::addr_of!((*ptr).m_cbPendingUnreliable) as usize - ptr as usize },
18954 36usize,
18955 concat!(
18956 "Offset of field: ",
18957 stringify!(SteamNetConnectionRealTimeStatus_t),
18958 "::",
18959 stringify!(m_cbPendingUnreliable)
18960 )
18961 );
18962 assert_eq!(
18963 unsafe { ::std::ptr::addr_of!((*ptr).m_cbPendingReliable) as usize - ptr as usize },
18964 40usize,
18965 concat!(
18966 "Offset of field: ",
18967 stringify!(SteamNetConnectionRealTimeStatus_t),
18968 "::",
18969 stringify!(m_cbPendingReliable)
18970 )
18971 );
18972 assert_eq!(
18973 unsafe { ::std::ptr::addr_of!((*ptr).m_cbSentUnackedReliable) as usize - ptr as usize },
18974 44usize,
18975 concat!(
18976 "Offset of field: ",
18977 stringify!(SteamNetConnectionRealTimeStatus_t),
18978 "::",
18979 stringify!(m_cbSentUnackedReliable)
18980 )
18981 );
18982 assert_eq!(
18983 unsafe { ::std::ptr::addr_of!((*ptr).m_usecQueueTime) as usize - ptr as usize },
18984 48usize,
18985 concat!(
18986 "Offset of field: ",
18987 stringify!(SteamNetConnectionRealTimeStatus_t),
18988 "::",
18989 stringify!(m_usecQueueTime)
18990 )
18991 );
18992 assert_eq!(
18993 unsafe { ::std::ptr::addr_of!((*ptr).m_usecMaxJitter) as usize - ptr as usize },
18994 56usize,
18995 concat!(
18996 "Offset of field: ",
18997 stringify!(SteamNetConnectionRealTimeStatus_t),
18998 "::",
18999 stringify!(m_usecMaxJitter)
19000 )
19001 );
19002 assert_eq!(
19003 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
19004 60usize,
19005 concat!(
19006 "Offset of field: ",
19007 stringify!(SteamNetConnectionRealTimeStatus_t),
19008 "::",
19009 stringify!(reserved)
19010 )
19011 );
19012}
19013#[doc = " Quick status of a particular lane"]
19014#[repr(C, packed(4))]
19015#[derive(Debug, Copy, Clone)]
19016pub struct SteamNetConnectionRealTimeLaneStatus_t {
19017 pub m_cbPendingUnreliable: ::std::os::raw::c_int,
19018 pub m_cbPendingReliable: ::std::os::raw::c_int,
19019 pub m_cbSentUnackedReliable: ::std::os::raw::c_int,
19020 pub _reservePad1: ::std::os::raw::c_int,
19021 #[doc = " Lane-specific queue time. This value takes into consideration lane priorities\n and weights, and how much data is queued in each lane, and attempts to predict\n how any data currently queued will be sent out."]
19022 pub m_usecQueueTime: SteamNetworkingMicroseconds,
19023 pub reserved: [uint32; 10usize],
19024}
19025#[test]
19026fn bindgen_test_layout_SteamNetConnectionRealTimeLaneStatus_t() {
19027 const UNINIT: ::std::mem::MaybeUninit<SteamNetConnectionRealTimeLaneStatus_t> =
19028 ::std::mem::MaybeUninit::uninit();
19029 let ptr = UNINIT.as_ptr();
19030 assert_eq!(
19031 ::std::mem::size_of::<SteamNetConnectionRealTimeLaneStatus_t>(),
19032 64usize,
19033 concat!(
19034 "Size of: ",
19035 stringify!(SteamNetConnectionRealTimeLaneStatus_t)
19036 )
19037 );
19038 assert_eq!(
19039 ::std::mem::align_of::<SteamNetConnectionRealTimeLaneStatus_t>(),
19040 4usize,
19041 concat!(
19042 "Alignment of ",
19043 stringify!(SteamNetConnectionRealTimeLaneStatus_t)
19044 )
19045 );
19046 assert_eq!(
19047 unsafe { ::std::ptr::addr_of!((*ptr).m_cbPendingUnreliable) as usize - ptr as usize },
19048 0usize,
19049 concat!(
19050 "Offset of field: ",
19051 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19052 "::",
19053 stringify!(m_cbPendingUnreliable)
19054 )
19055 );
19056 assert_eq!(
19057 unsafe { ::std::ptr::addr_of!((*ptr).m_cbPendingReliable) as usize - ptr as usize },
19058 4usize,
19059 concat!(
19060 "Offset of field: ",
19061 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19062 "::",
19063 stringify!(m_cbPendingReliable)
19064 )
19065 );
19066 assert_eq!(
19067 unsafe { ::std::ptr::addr_of!((*ptr).m_cbSentUnackedReliable) as usize - ptr as usize },
19068 8usize,
19069 concat!(
19070 "Offset of field: ",
19071 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19072 "::",
19073 stringify!(m_cbSentUnackedReliable)
19074 )
19075 );
19076 assert_eq!(
19077 unsafe { ::std::ptr::addr_of!((*ptr)._reservePad1) as usize - ptr as usize },
19078 12usize,
19079 concat!(
19080 "Offset of field: ",
19081 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19082 "::",
19083 stringify!(_reservePad1)
19084 )
19085 );
19086 assert_eq!(
19087 unsafe { ::std::ptr::addr_of!((*ptr).m_usecQueueTime) as usize - ptr as usize },
19088 16usize,
19089 concat!(
19090 "Offset of field: ",
19091 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19092 "::",
19093 stringify!(m_usecQueueTime)
19094 )
19095 );
19096 assert_eq!(
19097 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
19098 24usize,
19099 concat!(
19100 "Offset of field: ",
19101 stringify!(SteamNetConnectionRealTimeLaneStatus_t),
19102 "::",
19103 stringify!(reserved)
19104 )
19105 );
19106}
19107#[doc = " Max size of a single message that we can SEND.\n Note: We might be wiling to receive larger messages,\n and our peer might, too."]
19108pub const k_cbMaxSteamNetworkingSocketsMessageSizeSend: ::std::os::raw::c_int = 524288;
19109#[doc = " A message that has been received."]
19110#[repr(C)]
19111pub struct SteamNetworkingMessage_t {
19112 #[doc = " Message payload"]
19113 pub m_pData: *mut ::std::os::raw::c_void,
19114 #[doc = " Size of the payload."]
19115 pub m_cbSize: ::std::os::raw::c_int,
19116 #[doc = " For messages received on connections: what connection did this come from?\n For outgoing messages: what connection to send it to?\n Not used when using the ISteamNetworkingMessages interface"]
19117 pub m_conn: HSteamNetConnection,
19118 #[doc = " For inbound messages: Who sent this to us?\n For outbound messages on connections: not used.\n For outbound messages on the ad-hoc ISteamNetworkingMessages interface: who should we send this to?"]
19119 pub m_identityPeer: SteamNetworkingIdentity,
19120 #[doc = " For messages received on connections, this is the user data\n associated with the connection.\n\n This is *usually* the same as calling GetConnection() and then\n fetching the user data associated with that connection, but for\n the following subtle differences:\n\n - This user data will match the connection's user data at the time\n is captured at the time the message is returned by the API.\n If you subsequently change the userdata on the connection,\n this won't be updated.\n - This is an inline call, so it's *much* faster.\n - You might have closed the connection, so fetching the user data\n would not be possible.\n\n Not used when sending messages."]
19121 pub m_nConnUserData: int64,
19122 #[doc = " Local timestamp when the message was received\n Not used for outbound messages."]
19123 pub m_usecTimeReceived: SteamNetworkingMicroseconds,
19124 #[doc = " Message number assigned by the sender. This is not used for outbound\n messages. Note that if multiple lanes are used, each lane has its own\n message numbers, which are assigned sequentially, so messages from\n different lanes will share the same numbers."]
19125 pub m_nMessageNumber: int64,
19126 #[doc = " Function used to free up m_pData. This mechanism exists so that\n apps can create messages with buffers allocated from their own\n heap, and pass them into the library. This function will\n usually be something like:\n\n free( pMsg->m_pData );"]
19127 pub m_pfnFreeData:
19128 ::std::option::Option<unsafe extern "C" fn(pMsg: *mut SteamNetworkingMessage_t)>,
19129 #[doc = " Function to used to decrement the internal reference count and, if\n it's zero, release the message. You should not set this function pointer,\n or need to access this directly! Use the Release() function instead!"]
19130 pub m_pfnRelease:
19131 ::std::option::Option<unsafe extern "C" fn(pMsg: *mut SteamNetworkingMessage_t)>,
19132 #[doc = " When using ISteamNetworkingMessages, the channel number the message was received on\n (Not used for messages sent or received on \"connections\")"]
19133 pub m_nChannel: ::std::os::raw::c_int,
19134 #[doc = " Bitmask of k_nSteamNetworkingSend_xxx flags.\n For received messages, only the k_nSteamNetworkingSend_Reliable bit is valid.\n For outbound messages, all bits are relevant"]
19135 pub m_nFlags: ::std::os::raw::c_int,
19136 #[doc = " Arbitrary user data that you can use when sending messages using\n ISteamNetworkingUtils::AllocateMessage and ISteamNetworkingSockets::SendMessage.\n (The callback you set in m_pfnFreeData might use this field.)\n\n Not used for received messages."]
19137 pub m_nUserData: int64,
19138 #[doc = " For outbound messages, which lane to use? See ISteamNetworkingSockets::ConfigureConnectionLanes.\n For inbound messages, what lane was the message received on?"]
19139 pub m_idxLane: uint16,
19140 pub _pad1__: uint16,
19141}
19142#[test]
19143fn bindgen_test_layout_SteamNetworkingMessage_t() {
19144 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingMessage_t> =
19145 ::std::mem::MaybeUninit::uninit();
19146 let ptr = UNINIT.as_ptr();
19147 assert_eq!(
19148 ::std::mem::size_of::<SteamNetworkingMessage_t>(),
19149 216usize,
19150 concat!("Size of: ", stringify!(SteamNetworkingMessage_t))
19151 );
19152 assert_eq!(
19153 ::std::mem::align_of::<SteamNetworkingMessage_t>(),
19154 8usize,
19155 concat!("Alignment of ", stringify!(SteamNetworkingMessage_t))
19156 );
19157 assert_eq!(
19158 unsafe { ::std::ptr::addr_of!((*ptr).m_pData) as usize - ptr as usize },
19159 0usize,
19160 concat!(
19161 "Offset of field: ",
19162 stringify!(SteamNetworkingMessage_t),
19163 "::",
19164 stringify!(m_pData)
19165 )
19166 );
19167 assert_eq!(
19168 unsafe { ::std::ptr::addr_of!((*ptr).m_cbSize) as usize - ptr as usize },
19169 8usize,
19170 concat!(
19171 "Offset of field: ",
19172 stringify!(SteamNetworkingMessage_t),
19173 "::",
19174 stringify!(m_cbSize)
19175 )
19176 );
19177 assert_eq!(
19178 unsafe { ::std::ptr::addr_of!((*ptr).m_conn) as usize - ptr as usize },
19179 12usize,
19180 concat!(
19181 "Offset of field: ",
19182 stringify!(SteamNetworkingMessage_t),
19183 "::",
19184 stringify!(m_conn)
19185 )
19186 );
19187 assert_eq!(
19188 unsafe { ::std::ptr::addr_of!((*ptr).m_identityPeer) as usize - ptr as usize },
19189 16usize,
19190 concat!(
19191 "Offset of field: ",
19192 stringify!(SteamNetworkingMessage_t),
19193 "::",
19194 stringify!(m_identityPeer)
19195 )
19196 );
19197 assert_eq!(
19198 unsafe { ::std::ptr::addr_of!((*ptr).m_nConnUserData) as usize - ptr as usize },
19199 152usize,
19200 concat!(
19201 "Offset of field: ",
19202 stringify!(SteamNetworkingMessage_t),
19203 "::",
19204 stringify!(m_nConnUserData)
19205 )
19206 );
19207 assert_eq!(
19208 unsafe { ::std::ptr::addr_of!((*ptr).m_usecTimeReceived) as usize - ptr as usize },
19209 160usize,
19210 concat!(
19211 "Offset of field: ",
19212 stringify!(SteamNetworkingMessage_t),
19213 "::",
19214 stringify!(m_usecTimeReceived)
19215 )
19216 );
19217 assert_eq!(
19218 unsafe { ::std::ptr::addr_of!((*ptr).m_nMessageNumber) as usize - ptr as usize },
19219 168usize,
19220 concat!(
19221 "Offset of field: ",
19222 stringify!(SteamNetworkingMessage_t),
19223 "::",
19224 stringify!(m_nMessageNumber)
19225 )
19226 );
19227 assert_eq!(
19228 unsafe { ::std::ptr::addr_of!((*ptr).m_pfnFreeData) as usize - ptr as usize },
19229 176usize,
19230 concat!(
19231 "Offset of field: ",
19232 stringify!(SteamNetworkingMessage_t),
19233 "::",
19234 stringify!(m_pfnFreeData)
19235 )
19236 );
19237 assert_eq!(
19238 unsafe { ::std::ptr::addr_of!((*ptr).m_pfnRelease) as usize - ptr as usize },
19239 184usize,
19240 concat!(
19241 "Offset of field: ",
19242 stringify!(SteamNetworkingMessage_t),
19243 "::",
19244 stringify!(m_pfnRelease)
19245 )
19246 );
19247 assert_eq!(
19248 unsafe { ::std::ptr::addr_of!((*ptr).m_nChannel) as usize - ptr as usize },
19249 192usize,
19250 concat!(
19251 "Offset of field: ",
19252 stringify!(SteamNetworkingMessage_t),
19253 "::",
19254 stringify!(m_nChannel)
19255 )
19256 );
19257 assert_eq!(
19258 unsafe { ::std::ptr::addr_of!((*ptr).m_nFlags) as usize - ptr as usize },
19259 196usize,
19260 concat!(
19261 "Offset of field: ",
19262 stringify!(SteamNetworkingMessage_t),
19263 "::",
19264 stringify!(m_nFlags)
19265 )
19266 );
19267 assert_eq!(
19268 unsafe { ::std::ptr::addr_of!((*ptr).m_nUserData) as usize - ptr as usize },
19269 200usize,
19270 concat!(
19271 "Offset of field: ",
19272 stringify!(SteamNetworkingMessage_t),
19273 "::",
19274 stringify!(m_nUserData)
19275 )
19276 );
19277 assert_eq!(
19278 unsafe { ::std::ptr::addr_of!((*ptr).m_idxLane) as usize - ptr as usize },
19279 208usize,
19280 concat!(
19281 "Offset of field: ",
19282 stringify!(SteamNetworkingMessage_t),
19283 "::",
19284 stringify!(m_idxLane)
19285 )
19286 );
19287 assert_eq!(
19288 unsafe { ::std::ptr::addr_of!((*ptr)._pad1__) as usize - ptr as usize },
19289 210usize,
19290 concat!(
19291 "Offset of field: ",
19292 stringify!(SteamNetworkingMessage_t),
19293 "::",
19294 stringify!(_pad1__)
19295 )
19296 );
19297}
19298pub const k_nSteamNetworkingSend_Unreliable: ::std::os::raw::c_int = 0;
19299pub const k_nSteamNetworkingSend_NoNagle: ::std::os::raw::c_int = 1;
19300pub const k_nSteamNetworkingSend_UnreliableNoNagle: ::std::os::raw::c_int = 1;
19301pub const k_nSteamNetworkingSend_NoDelay: ::std::os::raw::c_int = 4;
19302pub const k_nSteamNetworkingSend_UnreliableNoDelay: ::std::os::raw::c_int = 5;
19303pub const k_nSteamNetworkingSend_Reliable: ::std::os::raw::c_int = 8;
19304pub const k_nSteamNetworkingSend_ReliableNoNagle: ::std::os::raw::c_int = 9;
19305pub const k_nSteamNetworkingSend_UseCurrentThread: ::std::os::raw::c_int = 16;
19306pub const k_nSteamNetworkingSend_AutoRestartBrokenSession: ::std::os::raw::c_int = 32;
19307#[doc = " Object that describes a \"location\" on the Internet with sufficient\n detail that we can reasonably estimate an upper bound on the ping between\n the two hosts, even if a direct route between the hosts is not possible,\n and the connection must be routed through the Steam Datagram Relay network.\n This does not contain any information that identifies the host. Indeed,\n if two hosts are in the same building or otherwise have nearly identical\n networking characteristics, then it's valid to use the same location\n object for both of them.\n\n NOTE: This object should only be used in the same process! Do not serialize it,\n send it over the wire, or persist it in a file or database! If you need\n to do that, convert it to a string representation using the methods in\n ISteamNetworkingUtils()."]
19308#[repr(C)]
19309#[derive(Debug, Copy, Clone)]
19310pub struct SteamNetworkPingLocation_t {
19311 pub m_data: [uint8; 512usize],
19312}
19313#[test]
19314fn bindgen_test_layout_SteamNetworkPingLocation_t() {
19315 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkPingLocation_t> =
19316 ::std::mem::MaybeUninit::uninit();
19317 let ptr = UNINIT.as_ptr();
19318 assert_eq!(
19319 ::std::mem::size_of::<SteamNetworkPingLocation_t>(),
19320 512usize,
19321 concat!("Size of: ", stringify!(SteamNetworkPingLocation_t))
19322 );
19323 assert_eq!(
19324 ::std::mem::align_of::<SteamNetworkPingLocation_t>(),
19325 1usize,
19326 concat!("Alignment of ", stringify!(SteamNetworkPingLocation_t))
19327 );
19328 assert_eq!(
19329 unsafe { ::std::ptr::addr_of!((*ptr).m_data) as usize - ptr as usize },
19330 0usize,
19331 concat!(
19332 "Offset of field: ",
19333 stringify!(SteamNetworkPingLocation_t),
19334 "::",
19335 stringify!(m_data)
19336 )
19337 );
19338}
19339#[doc = " Max possible length of a ping location, in string format. This is\n an extremely conservative worst case value which leaves room for future\n syntax enhancements. Most strings in practice are a lot shorter.\n If you are storing many of these, you will very likely benefit from\n using dynamic memory."]
19340pub const k_cchMaxSteamNetworkingPingLocationString: ::std::os::raw::c_int = 1024;
19341#[doc = " Special values that are returned by some functions that return a ping."]
19342pub const k_nSteamNetworkingPing_Failed: ::std::os::raw::c_int = -1;
19343pub const k_nSteamNetworkingPing_Unknown: ::std::os::raw::c_int = -2;
19344#[repr(u32)]
19345#[non_exhaustive]
19346#[doc = " Configuration values can be applied to different types of objects."]
19347#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19348pub enum ESteamNetworkingConfigScope {
19349 #[doc = " Get/set global option, or defaults. Even options that apply to more specific scopes\n have global scope, and you may be able to just change the global defaults. If you\n need different settings per connection (for example), then you will need to set those\n options at the more specific scope."]
19350 k_ESteamNetworkingConfig_Global = 1,
19351 #[doc = " Some options are specific to a particular interface. Note that all connection\n and listen socket settings can also be set at the interface level, and they will\n apply to objects created through those interfaces."]
19352 k_ESteamNetworkingConfig_SocketsInterface = 2,
19353 #[doc = " Options for a listen socket. Listen socket options can be set at the interface layer,\n if you have multiple listen sockets and they all use the same options.\n You can also set connection options on a listen socket, and they set the defaults\n for all connections accepted through this listen socket. (They will be used if you don't\n set a connection option.)"]
19354 k_ESteamNetworkingConfig_ListenSocket = 3,
19355 #[doc = " Options for a specific connection."]
19356 k_ESteamNetworkingConfig_Connection = 4,
19357 #[doc = " Options for a specific connection."]
19358 k_ESteamNetworkingConfigScope__Force32Bit = 2147483647,
19359}
19360#[repr(u32)]
19361#[non_exhaustive]
19362#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19363pub enum ESteamNetworkingConfigDataType {
19364 k_ESteamNetworkingConfig_Int32 = 1,
19365 k_ESteamNetworkingConfig_Int64 = 2,
19366 k_ESteamNetworkingConfig_Float = 3,
19367 k_ESteamNetworkingConfig_String = 4,
19368 k_ESteamNetworkingConfig_Ptr = 5,
19369 k_ESteamNetworkingConfigDataType__Force32Bit = 2147483647,
19370}
19371#[repr(u32)]
19372#[non_exhaustive]
19373#[doc = " Configuration options"]
19374#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19375pub enum ESteamNetworkingConfigValue {
19376 k_ESteamNetworkingConfig_Invalid = 0,
19377 #[doc = " [connection int32] Timeout value (in ms) to use when first connecting"]
19378 k_ESteamNetworkingConfig_TimeoutInitial = 24,
19379 #[doc = " [connection int32] Timeout value (in ms) to use after connection is established"]
19380 k_ESteamNetworkingConfig_TimeoutConnected = 25,
19381 #[doc = " [connection int32] Upper limit of buffered pending bytes to be sent,\n if this is reached SendMessage will return k_EResultLimitExceeded\n Default is 512k (524288 bytes)"]
19382 k_ESteamNetworkingConfig_SendBufferSize = 9,
19383 #[doc = " [connection int32] Upper limit on total size (in bytes) of received messages\n that will be buffered waiting to be processed by the application. If this limit\n is exceeded, packets will be dropped. This is to protect us from a malicious\n peer flooding us with messages faster than we can process them.\n\n This must be bigger than k_ESteamNetworkingConfig_RecvMaxMessageSize"]
19384 k_ESteamNetworkingConfig_RecvBufferSize = 47,
19385 #[doc = " [connection int32] Upper limit on the number of received messages that will\n that will be buffered waiting to be processed by the application. If this limit\n is exceeded, packets will be dropped. This is to protect us from a malicious\n peer flooding us with messages faster than we can pull them off the wire."]
19386 k_ESteamNetworkingConfig_RecvBufferMessages = 48,
19387 #[doc = " [connection int32] Maximum message size that we are willing to receive.\n if a client attempts to send us a message larger than this, the connection\n will be immediately closed.\n\n Default is 512k (524288 bytes). Note that the peer needs to be able to\n send a message this big. (See k_cbMaxSteamNetworkingSocketsMessageSizeSend.)"]
19388 k_ESteamNetworkingConfig_RecvMaxMessageSize = 49,
19389 #[doc = " [connection int32] Max number of message segments that can be received\n in a single UDP packet. While decoding a packet, if the number of segments\n exceeds this, we will abort further packet processing.\n\n The default is effectively unlimited. If you know that you very rarely\n send small packets, you can protect yourself from malicious senders by\n lowering this number.\n\n In particular, if you are NOT using the reliability layer and are only using\n SteamNetworkingSockets for datagram transport, setting this to a very low\n number may be beneficial. (We recommend a value of 2.) Make sure your sender\n disables Nagle!"]
19390 k_ESteamNetworkingConfig_RecvMaxSegmentsPerPacket = 50,
19391 #[doc = " [connection int64] Get/set userdata as a configuration option.\n The default value is -1. You may want to set the user data as\n a config value, instead of using ISteamNetworkingSockets::SetConnectionUserData\n in two specific instances:\n\n - You wish to set the userdata atomically when creating\n an outbound connection, so that the userdata is filled in properly\n for any callbacks that happen. However, note that this trick\n only works for connections initiated locally! For incoming\n connections, multiple state transitions may happen and\n callbacks be queued, before you are able to service the first\n callback! Be careful!\n\n - You can set the default userdata for all newly created connections\n by setting this value at a higher level (e.g. on the listen\n socket or at the global level.) Then this default\n value will be inherited when the connection is created.\n This is useful in case -1 is a valid userdata value, and you\n wish to use something else as the default value so you can\n tell if it has been set or not.\n\n HOWEVER: once a connection is created, the effective value is\n then bound to the connection. Unlike other connection options,\n if you change it again at a higher level, the new value will not\n be inherited by connections.\n\n Using the userdata field in callback structs is not advised because\n of tricky race conditions. Instead, you might try one of these methods:\n\n - Use a separate map with the HSteamNetConnection as the key.\n - Fetch the userdata from the connection in your callback\n using ISteamNetworkingSockets::GetConnectionUserData, to"]
19392 k_ESteamNetworkingConfig_ConnectionUserData = 40,
19393 #[doc = " [connection int32] Minimum/maximum send rate clamp, in bytes/sec.\n At the time of this writing these two options should always be set to\n the same value, to manually configure a specific send rate. The default\n value is 256K. Eventually we hope to have the library estimate the bandwidth\n of the channel and set the send rate to that estimated bandwidth, and these\n values will only set limits on that send rate."]
19394 k_ESteamNetworkingConfig_SendRateMin = 10,
19395 #[doc = " [connection int32] Minimum/maximum send rate clamp, in bytes/sec.\n At the time of this writing these two options should always be set to\n the same value, to manually configure a specific send rate. The default\n value is 256K. Eventually we hope to have the library estimate the bandwidth\n of the channel and set the send rate to that estimated bandwidth, and these\n values will only set limits on that send rate."]
19396 k_ESteamNetworkingConfig_SendRateMax = 11,
19397 #[doc = " [connection int32] Nagle time, in microseconds. When SendMessage is called, if\n the outgoing message is less than the size of the MTU, it will be\n queued for a delay equal to the Nagle timer value. This is to ensure\n that if the application sends several small messages rapidly, they are\n coalesced into a single packet.\n See historical RFC 896. Value is in microseconds.\n Default is 5000us (5ms)."]
19398 k_ESteamNetworkingConfig_NagleTime = 12,
19399 #[doc = " [connection int32] Don't automatically fail IP connections that don't have\n strong auth. On clients, this means we will attempt the connection even if\n we don't know our identity or can't get a cert. On the server, it means that\n we won't automatically reject a connection due to a failure to authenticate.\n (You can examine the incoming connection and decide whether to accept it.)\n\n 0: Don't attempt or accept unauthorized connections\n 1: Attempt authorization when connecting, and allow unauthorized peers, but emit warnings\n 2: don't attempt authentication, or complain if peer is unauthenticated\n\n This is a dev configuration value, and you should not let users modify it in\n production."]
19400 k_ESteamNetworkingConfig_IP_AllowWithoutAuth = 23,
19401 #[doc = " [connection int32] The same as IP_AllowWithoutAuth, but will only apply\n for connections to/from localhost addresses. Whichever value is larger\n (more permissive) will be used."]
19402 k_ESteamNetworkingConfig_IPLocalHost_AllowWithoutAuth = 52,
19403 #[doc = " [connection int32] Do not send UDP packets with a payload of\n larger than N bytes. If you set this, k_ESteamNetworkingConfig_MTU_DataSize\n is automatically adjusted"]
19404 k_ESteamNetworkingConfig_MTU_PacketSize = 32,
19405 #[doc = " [connection int32] (read only) Maximum message size you can send that\n will not fragment, based on k_ESteamNetworkingConfig_MTU_PacketSize"]
19406 k_ESteamNetworkingConfig_MTU_DataSize = 33,
19407 #[doc = " [connection int32] Allow unencrypted (and unauthenticated) communication.\n 0: Not allowed (the default)\n 1: Allowed, but prefer encrypted\n 2: Allowed, and preferred\n 3: Required. (Fail the connection if the peer requires encryption.)\n\n This is a dev configuration value, since its purpose is to disable encryption.\n You should not let users modify it in production. (But note that it requires\n the peer to also modify their value in order for encryption to be disabled.)"]
19408 k_ESteamNetworkingConfig_Unencrypted = 34,
19409 #[doc = " [connection int32] Set this to 1 on outbound connections and listen sockets,\n to enable \"symmetric connect mode\", which is useful in the following\n common peer-to-peer use case:\n\n - The two peers are \"equal\" to each other. (Neither is clearly the \"client\"\n or \"server\".)\n - Either peer may initiate the connection, and indeed they may do this\n at the same time\n - The peers only desire a single connection to each other, and if both\n peers initiate connections simultaneously, a protocol is needed for them\n to resolve the conflict, so that we end up with a single connection.\n\n This use case is both common, and involves subtle race conditions and tricky\n pitfalls, which is why the API has support for dealing with it.\n\n If an incoming connection arrives on a listen socket or via custom signaling,\n and the application has not attempted to make a matching outbound connection\n in symmetric mode, then the incoming connection can be accepted as usual.\n A \"matching\" connection means that the relevant endpoint information matches.\n (At the time this comment is being written, this is only supported for P2P\n connections, which means that the peer identities must match, and the virtual\n port must match. At a later time, symmetric mode may be supported for other\n connection types.)\n\n If connections are initiated by both peers simultaneously, race conditions\n can arise, but fortunately, most of them are handled internally and do not\n require any special awareness from the application. However, there\n is one important case that application code must be aware of:\n If application code attempts an outbound connection using a ConnectXxx\n function in symmetric mode, and a matching incoming connection is already\n waiting on a listen socket, then instead of forming a new connection,\n the ConnectXxx call will accept the existing incoming connection, and return\n a connection handle to this accepted connection.\n IMPORTANT: in this case, a SteamNetConnectionStatusChangedCallback_t\n has probably *already* been posted to the queue for the incoming connection!\n (Once callbacks are posted to the queue, they are not modified.) It doesn't\n matter if the callback has not been consumed by the app. Thus, application\n code that makes use of symmetric connections must be aware that, when processing a\n SteamNetConnectionStatusChangedCallback_t for an incoming connection, the\n m_hConn may refer to a new connection that the app has has not\n seen before (the usual case), but it may also refer to a connection that\n has already been accepted implicitly through a call to Connect()! In this\n case, AcceptConnection() will return k_EResultDuplicateRequest.\n\n Only one symmetric connection to a given peer (on a given virtual port)\n may exist at any given time. If client code attempts to create a connection,\n and a (live) connection already exists on the local host, then either the\n existing connection will be accepted as described above, or the attempt\n to create a new connection will fail. Furthermore, linger mode functionality\n is not supported on symmetric connections.\n\n A more complicated race condition can arise if both peers initiate a connection\n at roughly the same time. In this situation, each peer will receive an incoming\n connection from the other peer, when the application code has already initiated\n an outgoing connection to that peer. The peers must resolve this conflict and\n decide who is going to act as the \"server\" and who will act as the \"client\".\n Typically the application does not need to be aware of this case as it is handled\n internally. On both sides, the will observe their outbound connection being\n \"accepted\", although one of them one have been converted internally to act\n as the \"server\".\n\n In general, symmetric mode should be all-or-nothing: do not mix symmetric\n connections with a non-symmetric connection that it might possible \"match\"\n with. If you use symmetric mode on any connections, then both peers should\n use it on all connections, and the corresponding listen socket, if any. The\n behaviour when symmetric and ordinary connections are mixed is not defined by\n this API, and you should not rely on it. (This advice only applies when connections\n might possibly \"match\". For example, it's OK to use all symmetric mode\n connections on one virtual port, and all ordinary, non-symmetric connections\n on a different virtual port, as there is no potential for ambiguity.)\n\n When using the feature, you should set it in the following situations on\n applicable objects:\n\n - When creating an outbound connection using ConnectXxx function\n - When creating a listen socket. (Note that this will automatically cause\n any accepted connections to inherit the flag.)\n - When using custom signaling, before accepting an incoming connection.\n\n Setting the flag on listen socket and accepted connections will enable the\n API to automatically deal with duplicate incoming connections, even if the\n local host has not made any outbound requests. (In general, such duplicate\n requests from a peer are ignored internally and will not be visible to the\n application code. The previous connection must be closed or resolved first.)"]
19410 k_ESteamNetworkingConfig_SymmetricConnect = 37,
19411 #[doc = " [connection int32] For connection types that use \"virtual ports\", this can be used\n to assign a local virtual port. For incoming connections, this will always be the\n virtual port of the listen socket (or the port requested by the remote host if custom\n signaling is used and the connection is accepted), and cannot be changed. For\n connections initiated locally, the local virtual port will default to the same as the\n requested remote virtual port, if you do not specify a different option when creating\n the connection. The local port is only relevant for symmetric connections, when\n determining if two connections \"match.\" In this case, if you need the local and remote\n port to differ, you can set this value.\n\n You can also read back this value on listen sockets.\n\n This value should not be read or written in any other context."]
19412 k_ESteamNetworkingConfig_LocalVirtualPort = 38,
19413 #[doc = " [connection int32] Enable Dual wifi band support for this connection\n 0 = no, 1 = yes, 2 = simulate it for debugging, even if dual wifi not available"]
19414 k_ESteamNetworkingConfig_DualWifi_Enable = 39,
19415 #[doc = " [connection int32] True to enable diagnostics reporting through\n generic platform UI. (Only available on Steam.)"]
19416 k_ESteamNetworkingConfig_EnableDiagnosticsUI = 46,
19417 #[doc = " [connection int32] Send of time-since-previous-packet values in each UDP packet.\n This add a small amount of packet overhead but allows for detailed jitter measurements\n to be made by the receiver.\n\n - 0: disables the sending\n - 1: enables sending\n - -1: (the default) Use the default for the connection type. For plain UDP connections,\n this is disabled, and for relayed connections, it is enabled. Note that relays\n always send the value."]
19418 k_ESteamNetworkingConfig_SendTimeSincePreviousPacket = 59,
19419 #[doc = " [global float, 0--100] Randomly discard N pct of packets instead of sending/recv\n This is a global option only, since it is applied at a low level\n where we don't have much context"]
19420 k_ESteamNetworkingConfig_FakePacketLoss_Send = 2,
19421 #[doc = " [global float, 0--100] Randomly discard N pct of packets instead of sending/recv\n This is a global option only, since it is applied at a low level\n where we don't have much context"]
19422 k_ESteamNetworkingConfig_FakePacketLoss_Recv = 3,
19423 #[doc = " [global int32]. Delay all outbound/inbound packets by N ms"]
19424 k_ESteamNetworkingConfig_FakePacketLag_Send = 4,
19425 #[doc = " [global int32]. Delay all outbound/inbound packets by N ms"]
19426 k_ESteamNetworkingConfig_FakePacketLag_Recv = 5,
19427 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19428 k_ESteamNetworkingConfig_FakePacketJitter_Send_Avg = 53,
19429 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19430 k_ESteamNetworkingConfig_FakePacketJitter_Send_Max = 54,
19431 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19432 k_ESteamNetworkingConfig_FakePacketJitter_Send_Pct = 55,
19433 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19434 k_ESteamNetworkingConfig_FakePacketJitter_Recv_Avg = 56,
19435 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19436 k_ESteamNetworkingConfig_FakePacketJitter_Recv_Max = 57,
19437 #[doc = " Simulated jitter/clumping.\n\n For each packet, a jitter value is determined (which may\n be zero). This amount is added as extra delay to the\n packet. When a subsequent packet is queued, it receives its\n own random jitter amount from the current time. if this would\n result in the packets being delivered out of order, the later\n packet queue time is adjusted to happen after the first packet.\n Thus simulating jitter by itself will not reorder packets, but it\n can \"clump\" them.\n\n\t- Avg: A random jitter time is generated using an exponential\n distribution using this value as the mean (ms). The default\n is zero, which disables random jitter.\n - Max: Limit the random jitter time to this value (ms).\n\t- Pct: odds (0-100) that a random jitter value for the packet\n will be generated. Otherwise, a jitter value of zero\n is used, and the packet will only be delayed by the jitter\n system if necessary to retain order, due to the jitter of a\n previous packet.\n\n All values are [global float]\n\n Fake jitter is simulated after fake lag, but before reordering."]
19438 k_ESteamNetworkingConfig_FakePacketJitter_Recv_Pct = 58,
19439 #[doc = " [global float] 0-100 Percentage of packets we will add additional\n delay to. If other packet(s) are sent/received within this delay\n window (that doesn't also randomly receive the same extra delay),\n then the packets become reordered.\n\n This mechanism is primarily intended to generate out-of-order\n packets. To simulate random jitter, use the FakePacketJitter.\n Fake packet reordering is applied after fake lag and jitter"]
19440 k_ESteamNetworkingConfig_FakePacketReorder_Send = 6,
19441 #[doc = " [global float] 0-100 Percentage of packets we will add additional\n delay to. If other packet(s) are sent/received within this delay\n window (that doesn't also randomly receive the same extra delay),\n then the packets become reordered.\n\n This mechanism is primarily intended to generate out-of-order\n packets. To simulate random jitter, use the FakePacketJitter.\n Fake packet reordering is applied after fake lag and jitter"]
19442 k_ESteamNetworkingConfig_FakePacketReorder_Recv = 7,
19443 #[doc = " [global int32] Extra delay, in ms, to apply to reordered\n packets. The same time value is used for sending and receiving."]
19444 k_ESteamNetworkingConfig_FakePacketReorder_Time = 8,
19445 #[doc = " [global float 0--100] Globally duplicate some percentage of packets."]
19446 k_ESteamNetworkingConfig_FakePacketDup_Send = 26,
19447 #[doc = " [global float 0--100] Globally duplicate some percentage of packets."]
19448 k_ESteamNetworkingConfig_FakePacketDup_Recv = 27,
19449 #[doc = " [global int32] Amount of delay, in ms, to delay duplicated packets.\n (We chose a random delay between 0 and this value)"]
19450 k_ESteamNetworkingConfig_FakePacketDup_TimeMax = 28,
19451 #[doc = " [global int32] Trace every UDP packet, similar to Wireshark or tcpdump.\n Value is max number of bytes to dump. -1 disables tracing."]
19452 k_ESteamNetworkingConfig_PacketTraceMaxBytes = 41,
19453 k_ESteamNetworkingConfig_FakeRateLimit_Send_Rate = 42,
19454 k_ESteamNetworkingConfig_FakeRateLimit_Send_Burst = 43,
19455 k_ESteamNetworkingConfig_FakeRateLimit_Recv_Rate = 44,
19456 k_ESteamNetworkingConfig_FakeRateLimit_Recv_Burst = 45,
19457 k_ESteamNetworkingConfig_OutOfOrderCorrectionWindowMicroseconds = 51,
19458 #[doc = " [connection FnSteamNetConnectionStatusChanged] Callback that will be invoked\n when the state of a connection changes.\n\n IMPORTANT: callbacks are dispatched to the handler that is in effect at the time\n the event occurs, which might be in another thread. For example, immediately after\n creating a listen socket, you may receive an incoming connection. And then immediately\n after this, the remote host may close the connection. All of this could happen\n before the function to create the listen socket has returned. For this reason,\n callbacks usually must be in effect at the time of object creation. This means\n you should set them when you are creating the listen socket or connection, or have\n them in effect so they will be inherited at the time of object creation.\n\n For example:\n\n exterm void MyStatusChangedFunc( SteamNetConnectionStatusChangedCallback_t *info );\n SteamNetworkingConfigValue_t opt; opt.SetPtr( k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged, MyStatusChangedFunc );\n SteamNetworkingIPAddr localAddress; localAddress.Clear();\n HSteamListenSocket hListenSock = SteamNetworkingSockets()->CreateListenSocketIP( localAddress, 1, &opt );\n\n When accepting an incoming connection, there is no atomic way to switch the\n callback. However, if the connection is DOA, AcceptConnection() will fail, and\n you can fetch the state of the connection at that time.\n\n If all connections and listen sockets can use the same callback, the simplest\n method is to set it globally before you create any listen sockets or connections."]
19459 k_ESteamNetworkingConfig_Callback_ConnectionStatusChanged = 201,
19460 #[doc = " [global FnSteamNetAuthenticationStatusChanged] Callback that will be invoked\n when our auth state changes. If you use this, install the callback before creating\n any connections or listen sockets, and don't change it.\n See: ISteamNetworkingUtils::SetGlobalCallback_SteamNetAuthenticationStatusChanged"]
19461 k_ESteamNetworkingConfig_Callback_AuthStatusChanged = 202,
19462 #[doc = " [global FnSteamRelayNetworkStatusChanged] Callback that will be invoked\n when our auth state changes. If you use this, install the callback before creating\n any connections or listen sockets, and don't change it.\n See: ISteamNetworkingUtils::SetGlobalCallback_SteamRelayNetworkStatusChanged"]
19463 k_ESteamNetworkingConfig_Callback_RelayNetworkStatusChanged = 203,
19464 #[doc = " [global FnSteamNetworkingMessagesSessionRequest] Callback that will be invoked\n when a peer wants to initiate a SteamNetworkingMessagesSessionRequest.\n See: ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionRequest"]
19465 k_ESteamNetworkingConfig_Callback_MessagesSessionRequest = 204,
19466 #[doc = " [global FnSteamNetworkingMessagesSessionFailed] Callback that will be invoked\n when a session you have initiated, or accepted either fails to connect, or loses\n connection in some unexpected way.\n See: ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionFailed"]
19467 k_ESteamNetworkingConfig_Callback_MessagesSessionFailed = 205,
19468 #[doc = " [global FnSteamNetworkingSocketsCreateConnectionSignaling] Callback that will\n be invoked when we need to create a signaling object for a connection\n initiated locally. See: ISteamNetworkingSockets::ConnectP2P,\n ISteamNetworkingMessages."]
19469 k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling = 206,
19470 #[doc = " [global FnSteamNetworkingFakeIPResult] Callback that's invoked when\n a FakeIP allocation finishes. See: ISteamNetworkingSockets::BeginAsyncRequestFakeIP,\n ISteamNetworkingUtils::SetGlobalCallback_FakeIPResult"]
19471 k_ESteamNetworkingConfig_Callback_FakeIPResult = 207,
19472 #[doc = " [connection string] Comma-separated list of STUN servers that can be used\n for NAT piercing. If you set this to an empty string, NAT piercing will\n not be attempted. Also if \"public\" candidates are not allowed for\n P2P_Transport_ICE_Enable, then this is ignored."]
19473 k_ESteamNetworkingConfig_P2P_STUN_ServerList = 103,
19474 #[doc = " [connection int32] What types of ICE candidates to share with the peer.\n See k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_xxx values"]
19475 k_ESteamNetworkingConfig_P2P_Transport_ICE_Enable = 104,
19476 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19477 k_ESteamNetworkingConfig_P2P_Transport_ICE_Penalty = 105,
19478 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19479 k_ESteamNetworkingConfig_P2P_Transport_SDR_Penalty = 106,
19480 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19481 k_ESteamNetworkingConfig_P2P_TURN_ServerList = 107,
19482 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19483 k_ESteamNetworkingConfig_P2P_TURN_UserList = 108,
19484 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19485 k_ESteamNetworkingConfig_P2P_TURN_PassList = 109,
19486 #[doc = " [connection int32] When selecting P2P transport, add various\n penalties to the scores for selected transports. (Route selection\n scores are on a scale of milliseconds. The score begins with the\n route ping time and is then adjusted.)"]
19487 k_ESteamNetworkingConfig_P2P_Transport_ICE_Implementation = 110,
19488 #[doc = " [global int32] If the first N pings to a port all fail, mark that port as unavailable for\n a while, and try a different one. Some ISPs and routers may drop the first\n packet, so setting this to 1 may greatly disrupt communications."]
19489 k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFailInitial = 19,
19490 #[doc = " [global int32] If N consecutive pings to a port fail, after having received successful\n communication, mark that port as unavailable for a while, and try a\n different one."]
19491 k_ESteamNetworkingConfig_SDRClient_ConsecutitivePingTimeoutsFail = 20,
19492 #[doc = " [global int32] Minimum number of lifetime pings we need to send, before we think our estimate\n is solid. The first ping to each cluster is very often delayed because of NAT,\n routers not having the best route, etc. Until we've sent a sufficient number\n of pings, our estimate is often inaccurate. Keep pinging until we get this\n many pings."]
19493 k_ESteamNetworkingConfig_SDRClient_MinPingsBeforePingAccurate = 21,
19494 #[doc = " [global int32] Set all steam datagram traffic to originate from the same\n local port. By default, we open up a new UDP socket (on a different local\n port) for each relay. This is slightly less optimal, but it works around\n some routers that don't implement NAT properly. If you have intermittent\n problems talking to relays that might be NAT related, try toggling\n this flag"]
19495 k_ESteamNetworkingConfig_SDRClient_SingleSocket = 22,
19496 #[doc = " [global string] Code of relay cluster to force use. If not empty, we will\n only use relays in that cluster. E.g. 'iad'"]
19497 k_ESteamNetworkingConfig_SDRClient_ForceRelayCluster = 29,
19498 #[doc = " [connection string] For development, a base-64 encoded ticket generated\n using the cert tool. This can be used to connect to a gameserver via SDR\n without a ticket generated using the game coordinator. (You will still\n need a key that is trusted for your app, however.)\n\n This can also be passed using the SDR_DEVTICKET environment variable"]
19499 k_ESteamNetworkingConfig_SDRClient_DevTicket = 30,
19500 #[doc = " [global string] For debugging. Override list of relays from the config with\n this set (maybe just one). Comma-separated list."]
19501 k_ESteamNetworkingConfig_SDRClient_ForceProxyAddr = 31,
19502 #[doc = " [global string] For debugging. Force ping times to clusters to be the specified\n values. A comma separated list of <cluster>=<ms> values. E.g. \"sto=32,iad=100\"\n\n This is a dev configuration value, you probably should not let users modify it\n in production."]
19503 k_ESteamNetworkingConfig_SDRClient_FakeClusterPing = 36,
19504 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19505 k_ESteamNetworkingConfig_SDRClient_LimitPingProbesToNearestN = 60,
19506 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19507 k_ESteamNetworkingConfig_LogLevel_AckRTT = 13,
19508 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19509 k_ESteamNetworkingConfig_LogLevel_PacketDecode = 14,
19510 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19511 k_ESteamNetworkingConfig_LogLevel_Message = 15,
19512 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19513 k_ESteamNetworkingConfig_LogLevel_PacketGaps = 16,
19514 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19515 k_ESteamNetworkingConfig_LogLevel_P2PRendezvous = 17,
19516 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19517 k_ESteamNetworkingConfig_LogLevel_SDRRelayPings = 18,
19518 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19519 k_ESteamNetworkingConfig_ECN = 999,
19520 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19521 k_ESteamNetworkingConfig_SDRClient_EnableTOSProbes = 998,
19522 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19523 k_ESteamNetworkingConfig_DELETED_EnumerateDevVars = 35,
19524 #[doc = " [global int32] When probing the SteamDatagram network, we limit exploration\n to the closest N POPs, based on our current best approximated ping to that POP."]
19525 k_ESteamNetworkingConfigValue__Force32Bit = 2147483647,
19526}
19527pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Default: ::std::os::raw::c_int = -1;
19528pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Disable: ::std::os::raw::c_int = 0;
19529pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Relay: ::std::os::raw::c_int = 1;
19530pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Private: ::std::os::raw::c_int = 2;
19531pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_Public: ::std::os::raw::c_int = 4;
19532pub const k_nSteamNetworkingConfig_P2P_Transport_ICE_Enable_All: ::std::os::raw::c_int = 2147483647;
19533#[doc = " In a few places we need to set configuration options on listen sockets and connections, and\n have them take effect *before* the listen socket or connection really starts doing anything.\n Creating the object and then setting the options \"immediately\" after creation doesn't work\n completely, because network packets could be received between the time the object is created and\n when the options are applied. To set options at creation time in a reliable way, they must be\n passed to the creation function. This structure is used to pass those options.\n\n For the meaning of these fields, see ISteamNetworkingUtils::SetConfigValue. Basically\n when the object is created, we just iterate over the list of options and call\n ISteamNetworkingUtils::SetConfigValueStruct, where the scope arguments are supplied by the\n object being created."]
19534#[repr(C)]
19535#[derive(Copy, Clone)]
19536pub struct SteamNetworkingConfigValue_t {
19537 #[doc = " Which option is being set"]
19538 pub m_eValue: ESteamNetworkingConfigValue,
19539 #[doc = " Which field below did you fill in?"]
19540 pub m_eDataType: ESteamNetworkingConfigDataType,
19541 pub m_val: SteamNetworkingConfigValue_t__bindgen_ty_1,
19542}
19543#[doc = " Option value"]
19544#[repr(C)]
19545#[derive(Copy, Clone)]
19546pub union SteamNetworkingConfigValue_t__bindgen_ty_1 {
19547 pub m_int32: i32,
19548 pub m_int64: i64,
19549 pub m_float: f32,
19550 pub m_string: *const ::std::os::raw::c_char,
19551 pub m_ptr: *mut ::std::os::raw::c_void,
19552}
19553#[test]
19554fn bindgen_test_layout_SteamNetworkingConfigValue_t__bindgen_ty_1() {
19555 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingConfigValue_t__bindgen_ty_1> =
19556 ::std::mem::MaybeUninit::uninit();
19557 let ptr = UNINIT.as_ptr();
19558 assert_eq!(
19559 ::std::mem::size_of::<SteamNetworkingConfigValue_t__bindgen_ty_1>(),
19560 8usize,
19561 concat!(
19562 "Size of: ",
19563 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1)
19564 )
19565 );
19566 assert_eq!(
19567 ::std::mem::align_of::<SteamNetworkingConfigValue_t__bindgen_ty_1>(),
19568 8usize,
19569 concat!(
19570 "Alignment of ",
19571 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1)
19572 )
19573 );
19574 assert_eq!(
19575 unsafe { ::std::ptr::addr_of!((*ptr).m_int32) as usize - ptr as usize },
19576 0usize,
19577 concat!(
19578 "Offset of field: ",
19579 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1),
19580 "::",
19581 stringify!(m_int32)
19582 )
19583 );
19584 assert_eq!(
19585 unsafe { ::std::ptr::addr_of!((*ptr).m_int64) as usize - ptr as usize },
19586 0usize,
19587 concat!(
19588 "Offset of field: ",
19589 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1),
19590 "::",
19591 stringify!(m_int64)
19592 )
19593 );
19594 assert_eq!(
19595 unsafe { ::std::ptr::addr_of!((*ptr).m_float) as usize - ptr as usize },
19596 0usize,
19597 concat!(
19598 "Offset of field: ",
19599 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1),
19600 "::",
19601 stringify!(m_float)
19602 )
19603 );
19604 assert_eq!(
19605 unsafe { ::std::ptr::addr_of!((*ptr).m_string) as usize - ptr as usize },
19606 0usize,
19607 concat!(
19608 "Offset of field: ",
19609 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1),
19610 "::",
19611 stringify!(m_string)
19612 )
19613 );
19614 assert_eq!(
19615 unsafe { ::std::ptr::addr_of!((*ptr).m_ptr) as usize - ptr as usize },
19616 0usize,
19617 concat!(
19618 "Offset of field: ",
19619 stringify!(SteamNetworkingConfigValue_t__bindgen_ty_1),
19620 "::",
19621 stringify!(m_ptr)
19622 )
19623 );
19624}
19625#[test]
19626fn bindgen_test_layout_SteamNetworkingConfigValue_t() {
19627 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingConfigValue_t> =
19628 ::std::mem::MaybeUninit::uninit();
19629 let ptr = UNINIT.as_ptr();
19630 assert_eq!(
19631 ::std::mem::size_of::<SteamNetworkingConfigValue_t>(),
19632 16usize,
19633 concat!("Size of: ", stringify!(SteamNetworkingConfigValue_t))
19634 );
19635 assert_eq!(
19636 ::std::mem::align_of::<SteamNetworkingConfigValue_t>(),
19637 8usize,
19638 concat!("Alignment of ", stringify!(SteamNetworkingConfigValue_t))
19639 );
19640 assert_eq!(
19641 unsafe { ::std::ptr::addr_of!((*ptr).m_eValue) as usize - ptr as usize },
19642 0usize,
19643 concat!(
19644 "Offset of field: ",
19645 stringify!(SteamNetworkingConfigValue_t),
19646 "::",
19647 stringify!(m_eValue)
19648 )
19649 );
19650 assert_eq!(
19651 unsafe { ::std::ptr::addr_of!((*ptr).m_eDataType) as usize - ptr as usize },
19652 4usize,
19653 concat!(
19654 "Offset of field: ",
19655 stringify!(SteamNetworkingConfigValue_t),
19656 "::",
19657 stringify!(m_eDataType)
19658 )
19659 );
19660 assert_eq!(
19661 unsafe { ::std::ptr::addr_of!((*ptr).m_val) as usize - ptr as usize },
19662 8usize,
19663 concat!(
19664 "Offset of field: ",
19665 stringify!(SteamNetworkingConfigValue_t),
19666 "::",
19667 stringify!(m_val)
19668 )
19669 );
19670}
19671#[repr(i32)]
19672#[non_exhaustive]
19673#[doc = " Return value of ISteamNetworkintgUtils::GetConfigValue"]
19674#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19675pub enum ESteamNetworkingGetConfigValueResult {
19676 k_ESteamNetworkingGetConfigValue_BadValue = -1,
19677 k_ESteamNetworkingGetConfigValue_BadScopeObj = -2,
19678 k_ESteamNetworkingGetConfigValue_BufferTooSmall = -3,
19679 k_ESteamNetworkingGetConfigValue_OK = 1,
19680 k_ESteamNetworkingGetConfigValue_OKInherited = 2,
19681 k_ESteamNetworkingGetConfigValueResult__Force32Bit = 2147483647,
19682}
19683#[repr(u32)]
19684#[non_exhaustive]
19685#[doc = " Detail level for diagnostic output callback.\n See ISteamNetworkingUtils::SetDebugOutputFunction"]
19686#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19687pub enum ESteamNetworkingSocketsDebugOutputType {
19688 k_ESteamNetworkingSocketsDebugOutputType_None = 0,
19689 k_ESteamNetworkingSocketsDebugOutputType_Bug = 1,
19690 k_ESteamNetworkingSocketsDebugOutputType_Error = 2,
19691 k_ESteamNetworkingSocketsDebugOutputType_Important = 3,
19692 k_ESteamNetworkingSocketsDebugOutputType_Warning = 4,
19693 k_ESteamNetworkingSocketsDebugOutputType_Msg = 5,
19694 k_ESteamNetworkingSocketsDebugOutputType_Verbose = 6,
19695 k_ESteamNetworkingSocketsDebugOutputType_Debug = 7,
19696 k_ESteamNetworkingSocketsDebugOutputType_Everything = 8,
19697 k_ESteamNetworkingSocketsDebugOutputType__Force32Bit = 2147483647,
19698}
19699#[doc = " Setup callback for debug output, and the desired verbosity you want."]
19700pub type FSteamNetworkingSocketsDebugOutput = ::std::option::Option<
19701 unsafe extern "C" fn(
19702 nType: ESteamNetworkingSocketsDebugOutputType,
19703 pszMsg: *const ::std::os::raw::c_char,
19704 ),
19705>;
19706#[doc = " The POPID \"dev\" is used in non-production environments for testing."]
19707pub const k_SteamDatagramPOPID_dev: SteamNetworkingPOPID = 6579574;
19708#[doc = " Utility class for printing a SteamNetworkingPOPID."]
19709#[repr(C)]
19710#[derive(Debug, Copy, Clone)]
19711pub struct SteamNetworkingPOPIDRender {
19712 pub buf: [::std::os::raw::c_char; 8usize],
19713}
19714#[test]
19715fn bindgen_test_layout_SteamNetworkingPOPIDRender() {
19716 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingPOPIDRender> =
19717 ::std::mem::MaybeUninit::uninit();
19718 let ptr = UNINIT.as_ptr();
19719 assert_eq!(
19720 ::std::mem::size_of::<SteamNetworkingPOPIDRender>(),
19721 8usize,
19722 concat!("Size of: ", stringify!(SteamNetworkingPOPIDRender))
19723 );
19724 assert_eq!(
19725 ::std::mem::align_of::<SteamNetworkingPOPIDRender>(),
19726 1usize,
19727 concat!("Alignment of ", stringify!(SteamNetworkingPOPIDRender))
19728 );
19729 assert_eq!(
19730 unsafe { ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize },
19731 0usize,
19732 concat!(
19733 "Offset of field: ",
19734 stringify!(SteamNetworkingPOPIDRender),
19735 "::",
19736 stringify!(buf)
19737 )
19738 );
19739}
19740#[doc = " A message that has been received."]
19741pub type ISteamNetworkingMessage = SteamNetworkingMessage_t;
19742pub type SteamDatagramErrMsg = SteamNetworkingErrMsg;
19743#[repr(C)]
19744pub struct ISteamNetworkingMessages__bindgen_vtable(::std::os::raw::c_void);
19745#[doc = " The non-connection-oriented interface to send and receive messages\n (whether they be \"clients\" or \"servers\").\n\n ISteamNetworkingSockets is connection-oriented (like TCP), meaning you\n need to listen and connect, and then you send messages using a connection\n handle. ISteamNetworkingMessages is more like UDP, in that you can just send\n messages to arbitrary peers at any time. The underlying connections are\n established implicitly.\n\n Under the hood ISteamNetworkingMessages works on top of the ISteamNetworkingSockets\n code, so you get the same routing and messaging efficiency. The difference is\n mainly in your responsibility to explicitly establish a connection and\n the type of feedback you get about the state of the connection. Both\n interfaces can do \"P2P\" communications, and both support both unreliable\n and reliable messages, fragmentation and reassembly.\n\n The primary purpose of this interface is to be \"like UDP\", so that UDP-based code\n can be ported easily to take advantage of relayed connections. If you find\n yourself needing more low level information or control, or to be able to better\n handle failure, then you probably need to use ISteamNetworkingSockets directly.\n Also, note that if your main goal is to obtain a connection between two peers\n without concerning yourself with assigning roles of \"client\" and \"server\",\n you may find the symmetric connection mode of ISteamNetworkingSockets useful.\n (See k_ESteamNetworkingConfig_SymmetricConnect.)\n"]
19746#[repr(C)]
19747#[derive(Debug, Copy, Clone)]
19748pub struct ISteamNetworkingMessages {
19749 pub vtable_: *const ISteamNetworkingMessages__bindgen_vtable,
19750}
19751#[test]
19752fn bindgen_test_layout_ISteamNetworkingMessages() {
19753 assert_eq!(
19754 ::std::mem::size_of::<ISteamNetworkingMessages>(),
19755 8usize,
19756 concat!("Size of: ", stringify!(ISteamNetworkingMessages))
19757 );
19758 assert_eq!(
19759 ::std::mem::align_of::<ISteamNetworkingMessages>(),
19760 8usize,
19761 concat!("Alignment of ", stringify!(ISteamNetworkingMessages))
19762 );
19763}
19764#[doc = " Posted when a remote host is sending us a message, and we do not already have a session with them"]
19765#[repr(C)]
19766#[derive(Copy, Clone)]
19767pub struct SteamNetworkingMessagesSessionRequest_t {
19768 pub m_identityRemote: SteamNetworkingIdentity,
19769}
19770pub const SteamNetworkingMessagesSessionRequest_t_k_iCallback:
19771 SteamNetworkingMessagesSessionRequest_t__bindgen_ty_1 =
19772 SteamNetworkingMessagesSessionRequest_t__bindgen_ty_1::k_iCallback;
19773#[repr(u32)]
19774#[non_exhaustive]
19775#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19776pub enum SteamNetworkingMessagesSessionRequest_t__bindgen_ty_1 {
19777 k_iCallback = 1251,
19778}
19779#[test]
19780fn bindgen_test_layout_SteamNetworkingMessagesSessionRequest_t() {
19781 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingMessagesSessionRequest_t> =
19782 ::std::mem::MaybeUninit::uninit();
19783 let ptr = UNINIT.as_ptr();
19784 assert_eq!(
19785 ::std::mem::size_of::<SteamNetworkingMessagesSessionRequest_t>(),
19786 136usize,
19787 concat!(
19788 "Size of: ",
19789 stringify!(SteamNetworkingMessagesSessionRequest_t)
19790 )
19791 );
19792 assert_eq!(
19793 ::std::mem::align_of::<SteamNetworkingMessagesSessionRequest_t>(),
19794 1usize,
19795 concat!(
19796 "Alignment of ",
19797 stringify!(SteamNetworkingMessagesSessionRequest_t)
19798 )
19799 );
19800 assert_eq!(
19801 unsafe { ::std::ptr::addr_of!((*ptr).m_identityRemote) as usize - ptr as usize },
19802 0usize,
19803 concat!(
19804 "Offset of field: ",
19805 stringify!(SteamNetworkingMessagesSessionRequest_t),
19806 "::",
19807 stringify!(m_identityRemote)
19808 )
19809 );
19810}
19811#[doc = " Posted when we fail to establish a connection, or we detect that communications\n have been disrupted it an unusual way. There is no notification when a peer proactively\n closes the session. (\"Closed by peer\" is not a concept of UDP-style communications, and\n SteamNetworkingMessages is primarily intended to make porting UDP code easy.)\n\n Remember: callbacks are asynchronous. See notes on SendMessageToUser,\n and k_nSteamNetworkingSend_AutoRestartBrokenSession in particular.\n\n Also, if a session times out due to inactivity, no callbacks will be posted. The only\n way to detect that this is happening is that querying the session state may return\n none, connecting, and findingroute again."]
19812#[repr(C, packed)]
19813#[derive(Copy, Clone)]
19814pub struct SteamNetworkingMessagesSessionFailed_t {
19815 #[doc = " Detailed info about the session that failed.\n SteamNetConnectionInfo_t::m_identityRemote indicates who this session\n was with."]
19816 pub m_info: SteamNetConnectionInfo_t,
19817}
19818pub const SteamNetworkingMessagesSessionFailed_t_k_iCallback:
19819 SteamNetworkingMessagesSessionFailed_t__bindgen_ty_1 =
19820 SteamNetworkingMessagesSessionFailed_t__bindgen_ty_1::k_iCallback;
19821#[repr(u32)]
19822#[non_exhaustive]
19823#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19824pub enum SteamNetworkingMessagesSessionFailed_t__bindgen_ty_1 {
19825 k_iCallback = 1252,
19826}
19827#[test]
19828fn bindgen_test_layout_SteamNetworkingMessagesSessionFailed_t() {
19829 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingMessagesSessionFailed_t> =
19830 ::std::mem::MaybeUninit::uninit();
19831 let ptr = UNINIT.as_ptr();
19832 assert_eq!(
19833 ::std::mem::size_of::<SteamNetworkingMessagesSessionFailed_t>(),
19834 696usize,
19835 concat!(
19836 "Size of: ",
19837 stringify!(SteamNetworkingMessagesSessionFailed_t)
19838 )
19839 );
19840 assert_eq!(
19841 ::std::mem::align_of::<SteamNetworkingMessagesSessionFailed_t>(),
19842 1usize,
19843 concat!(
19844 "Alignment of ",
19845 stringify!(SteamNetworkingMessagesSessionFailed_t)
19846 )
19847 );
19848 assert_eq!(
19849 unsafe { ::std::ptr::addr_of!((*ptr).m_info) as usize - ptr as usize },
19850 0usize,
19851 concat!(
19852 "Offset of field: ",
19853 stringify!(SteamNetworkingMessagesSessionFailed_t),
19854 "::",
19855 stringify!(m_info)
19856 )
19857 );
19858}
19859#[repr(C)]
19860#[derive(Debug, Copy, Clone)]
19861pub struct ISteamNetworkingConnectionSignaling {
19862 _unused: [u8; 0],
19863}
19864#[repr(C)]
19865#[derive(Debug, Copy, Clone)]
19866pub struct ISteamNetworkingSignalingRecvContext {
19867 _unused: [u8; 0],
19868}
19869#[repr(C)]
19870#[derive(Debug, Copy, Clone)]
19871pub struct ISteamNetworkingFakeUDPPort {
19872 _unused: [u8; 0],
19873}
19874#[repr(C)]
19875pub struct ISteamNetworkingSockets__bindgen_vtable(::std::os::raw::c_void);
19876#[doc = " Lower level networking API.\n\n - Connection-oriented API (like TCP, not UDP). When sending and receiving\n messages, a connection handle is used. (For a UDP-style interface, where\n the peer is identified by their address with each send/recv call, see\n ISteamNetworkingMessages.) The typical pattern is for a \"server\" to \"listen\"\n on a \"listen socket.\" A \"client\" will \"connect\" to the server, and the\n server will \"accept\" the connection. If you have a symmetric situation\n where either peer may initiate the connection and server/client roles are\n not clearly defined, check out k_ESteamNetworkingConfig_SymmetricConnect.\n - But unlike TCP, it's message-oriented, not stream-oriented.\n - Mix of reliable and unreliable messages\n - Fragmentation and reassembly\n - Supports connectivity over plain UDP\n - Also supports SDR (\"Steam Datagram Relay\") connections, which are\n addressed by the identity of the peer. There is a \"P2P\" use case and\n a \"hosted dedicated server\" use case.\n\n Note that neither of the terms \"connection\" nor \"socket\" necessarily correspond\n one-to-one with an underlying UDP socket. An attempt has been made to\n keep the semantics as similar to the standard socket model when appropriate,\n but some deviations do exist.\n\n See also: ISteamNetworkingMessages, the UDP-style interface. This API might be\n easier to use, especially when porting existing UDP code."]
19877#[repr(C)]
19878#[derive(Debug)]
19879pub struct ISteamNetworkingSockets {
19880 pub vtable_: *const ISteamNetworkingSockets__bindgen_vtable,
19881}
19882#[test]
19883fn bindgen_test_layout_ISteamNetworkingSockets() {
19884 assert_eq!(
19885 ::std::mem::size_of::<ISteamNetworkingSockets>(),
19886 8usize,
19887 concat!("Size of: ", stringify!(ISteamNetworkingSockets))
19888 );
19889 assert_eq!(
19890 ::std::mem::align_of::<ISteamNetworkingSockets>(),
19891 8usize,
19892 concat!("Alignment of ", stringify!(ISteamNetworkingSockets))
19893 );
19894}
19895extern "C" {
19896 #[link_name = "\u{1}_ZN23ISteamNetworkingSocketsD1Ev"]
19897 pub fn ISteamNetworkingSockets_ISteamNetworkingSockets_destructor(
19898 this: *mut ISteamNetworkingSockets,
19899 );
19900}
19901impl ISteamNetworkingSockets {
19902 #[inline]
19903 pub unsafe fn destruct(&mut self) {
19904 ISteamNetworkingSockets_ISteamNetworkingSockets_destructor(self)
19905 }
19906}
19907#[doc = " This callback is posted whenever a connection is created, destroyed, or changes state.\n The m_info field will contain a complete description of the connection at the time the\n change occurred and the callback was posted. In particular, m_eState will have the\n new connection state.\n\n You will usually need to listen for this callback to know when:\n - A new connection arrives on a listen socket.\n m_info.m_hListenSocket will be set, m_eOldState = k_ESteamNetworkingConnectionState_None,\n and m_info.m_eState = k_ESteamNetworkingConnectionState_Connecting.\n See ISteamNetworkigSockets::AcceptConnection.\n - A connection you initiated has been accepted by the remote host.\n m_eOldState = k_ESteamNetworkingConnectionState_Connecting, and\n m_info.m_eState = k_ESteamNetworkingConnectionState_Connected.\n Some connections might transition to k_ESteamNetworkingConnectionState_FindingRoute first.\n - A connection has been actively rejected or closed by the remote host.\n m_eOldState = k_ESteamNetworkingConnectionState_Connecting or k_ESteamNetworkingConnectionState_Connected,\n and m_info.m_eState = k_ESteamNetworkingConnectionState_ClosedByPeer. m_info.m_eEndReason\n and m_info.m_szEndDebug will have for more details.\n NOTE: upon receiving this callback, you must still destroy the connection using\n ISteamNetworkingSockets::CloseConnection to free up local resources. (The details\n passed to the function are not used in this case, since the connection is already closed.)\n - A problem was detected with the connection, and it has been closed by the local host.\n The most common failure is timeout, but other configuration or authentication failures\n can cause this. m_eOldState = k_ESteamNetworkingConnectionState_Connecting or\n k_ESteamNetworkingConnectionState_Connected, and m_info.m_eState = k_ESteamNetworkingConnectionState_ProblemDetectedLocally.\n m_info.m_eEndReason and m_info.m_szEndDebug will have for more details.\n NOTE: upon receiving this callback, you must still destroy the connection using\n ISteamNetworkingSockets::CloseConnection to free up local resources. (The details\n passed to the function are not used in this case, since the connection is already closed.)\n\n Remember that callbacks are posted to a queue, and networking connections can\n change at any time. It is possible that the connection has already changed\n state by the time you process this callback.\n\n Also note that callbacks will be posted when connections are created and destroyed by your own API calls."]
19908#[repr(C)]
19909#[derive(Copy, Clone)]
19910pub struct SteamNetConnectionStatusChangedCallback_t {
19911 #[doc = " Connection handle"]
19912 pub m_hConn: HSteamNetConnection,
19913 #[doc = " Full connection info"]
19914 pub m_info: SteamNetConnectionInfo_t,
19915 #[doc = " Previous state. (Current state is in m_info.m_eState)"]
19916 pub m_eOldState: ESteamNetworkingConnectionState,
19917}
19918pub const SteamNetConnectionStatusChangedCallback_t_k_iCallback:
19919 SteamNetConnectionStatusChangedCallback_t__bindgen_ty_1 =
19920 SteamNetConnectionStatusChangedCallback_t__bindgen_ty_1::k_iCallback;
19921#[repr(u32)]
19922#[non_exhaustive]
19923#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19924pub enum SteamNetConnectionStatusChangedCallback_t__bindgen_ty_1 {
19925 k_iCallback = 1221,
19926}
19927#[test]
19928fn bindgen_test_layout_SteamNetConnectionStatusChangedCallback_t() {
19929 const UNINIT: ::std::mem::MaybeUninit<SteamNetConnectionStatusChangedCallback_t> =
19930 ::std::mem::MaybeUninit::uninit();
19931 let ptr = UNINIT.as_ptr();
19932 assert_eq!(
19933 ::std::mem::size_of::<SteamNetConnectionStatusChangedCallback_t>(),
19934 704usize,
19935 concat!(
19936 "Size of: ",
19937 stringify!(SteamNetConnectionStatusChangedCallback_t)
19938 )
19939 );
19940 assert_eq!(
19941 ::std::mem::align_of::<SteamNetConnectionStatusChangedCallback_t>(),
19942 4usize,
19943 concat!(
19944 "Alignment of ",
19945 stringify!(SteamNetConnectionStatusChangedCallback_t)
19946 )
19947 );
19948 assert_eq!(
19949 unsafe { ::std::ptr::addr_of!((*ptr).m_hConn) as usize - ptr as usize },
19950 0usize,
19951 concat!(
19952 "Offset of field: ",
19953 stringify!(SteamNetConnectionStatusChangedCallback_t),
19954 "::",
19955 stringify!(m_hConn)
19956 )
19957 );
19958 assert_eq!(
19959 unsafe { ::std::ptr::addr_of!((*ptr).m_info) as usize - ptr as usize },
19960 4usize,
19961 concat!(
19962 "Offset of field: ",
19963 stringify!(SteamNetConnectionStatusChangedCallback_t),
19964 "::",
19965 stringify!(m_info)
19966 )
19967 );
19968 assert_eq!(
19969 unsafe { ::std::ptr::addr_of!((*ptr).m_eOldState) as usize - ptr as usize },
19970 700usize,
19971 concat!(
19972 "Offset of field: ",
19973 stringify!(SteamNetConnectionStatusChangedCallback_t),
19974 "::",
19975 stringify!(m_eOldState)
19976 )
19977 );
19978}
19979#[doc = " A struct used to describe our readiness to participate in authenticated,\n encrypted communication. In order to do this we need:\n\n - The list of trusted CA certificates that might be relevant for this\n app.\n - A valid certificate issued by a CA.\n\n This callback is posted whenever the state of our readiness changes."]
19980#[repr(C)]
19981#[derive(Debug, Copy, Clone)]
19982pub struct SteamNetAuthenticationStatus_t {
19983 #[doc = " Status"]
19984 pub m_eAvail: ESteamNetworkingAvailability,
19985 #[doc = " Non-localized English language status. For diagnostic/debugging\n purposes only."]
19986 pub m_debugMsg: [::std::os::raw::c_char; 256usize],
19987}
19988pub const SteamNetAuthenticationStatus_t_k_iCallback: SteamNetAuthenticationStatus_t__bindgen_ty_1 =
19989 SteamNetAuthenticationStatus_t__bindgen_ty_1::k_iCallback;
19990#[repr(u32)]
19991#[non_exhaustive]
19992#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
19993pub enum SteamNetAuthenticationStatus_t__bindgen_ty_1 {
19994 k_iCallback = 1222,
19995}
19996#[test]
19997fn bindgen_test_layout_SteamNetAuthenticationStatus_t() {
19998 const UNINIT: ::std::mem::MaybeUninit<SteamNetAuthenticationStatus_t> =
19999 ::std::mem::MaybeUninit::uninit();
20000 let ptr = UNINIT.as_ptr();
20001 assert_eq!(
20002 ::std::mem::size_of::<SteamNetAuthenticationStatus_t>(),
20003 260usize,
20004 concat!("Size of: ", stringify!(SteamNetAuthenticationStatus_t))
20005 );
20006 assert_eq!(
20007 ::std::mem::align_of::<SteamNetAuthenticationStatus_t>(),
20008 4usize,
20009 concat!("Alignment of ", stringify!(SteamNetAuthenticationStatus_t))
20010 );
20011 assert_eq!(
20012 unsafe { ::std::ptr::addr_of!((*ptr).m_eAvail) as usize - ptr as usize },
20013 0usize,
20014 concat!(
20015 "Offset of field: ",
20016 stringify!(SteamNetAuthenticationStatus_t),
20017 "::",
20018 stringify!(m_eAvail)
20019 )
20020 );
20021 assert_eq!(
20022 unsafe { ::std::ptr::addr_of!((*ptr).m_debugMsg) as usize - ptr as usize },
20023 4usize,
20024 concat!(
20025 "Offset of field: ",
20026 stringify!(SteamNetAuthenticationStatus_t),
20027 "::",
20028 stringify!(m_debugMsg)
20029 )
20030 );
20031}
20032#[repr(C)]
20033pub struct ISteamNetworkingUtils__bindgen_vtable(::std::os::raw::c_void);
20034#[doc = " Misc networking utilities for checking the local networking environment\n and estimating pings."]
20035#[repr(C)]
20036#[derive(Debug)]
20037pub struct ISteamNetworkingUtils {
20038 pub vtable_: *const ISteamNetworkingUtils__bindgen_vtable,
20039}
20040#[test]
20041fn bindgen_test_layout_ISteamNetworkingUtils() {
20042 assert_eq!(
20043 ::std::mem::size_of::<ISteamNetworkingUtils>(),
20044 8usize,
20045 concat!("Size of: ", stringify!(ISteamNetworkingUtils))
20046 );
20047 assert_eq!(
20048 ::std::mem::align_of::<ISteamNetworkingUtils>(),
20049 8usize,
20050 concat!("Alignment of ", stringify!(ISteamNetworkingUtils))
20051 );
20052}
20053extern "C" {
20054 #[link_name = "\u{1}_ZN21ISteamNetworkingUtilsD1Ev"]
20055 pub fn ISteamNetworkingUtils_ISteamNetworkingUtils_destructor(this: *mut ISteamNetworkingUtils);
20056}
20057impl ISteamNetworkingUtils {
20058 #[inline]
20059 pub unsafe fn destruct(&mut self) {
20060 ISteamNetworkingUtils_ISteamNetworkingUtils_destructor(self)
20061 }
20062}
20063#[doc = " A struct used to describe our readiness to use the relay network.\n To do this we first need to fetch the network configuration,\n which describes what POPs are available."]
20064#[repr(C)]
20065#[derive(Debug, Copy, Clone)]
20066pub struct SteamRelayNetworkStatus_t {
20067 #[doc = " Summary status. When this is \"current\", initialization has\n completed. Anything else means you are not ready yet, or\n there is a significant problem."]
20068 pub m_eAvail: ESteamNetworkingAvailability,
20069 #[doc = " Nonzero if latency measurement is in progress (or pending,\n awaiting a prerequisite)."]
20070 pub m_bPingMeasurementInProgress: ::std::os::raw::c_int,
20071 #[doc = " Status obtaining the network config. This is a prerequisite\n for relay network access.\n\n Failure to obtain the network config almost always indicates\n a problem with the local internet connection."]
20072 pub m_eAvailNetworkConfig: ESteamNetworkingAvailability,
20073 #[doc = " Current ability to communicate with ANY relay. Note that\n the complete failure to communicate with any relays almost\n always indicates a problem with the local Internet connection.\n (However, just because you can reach a single relay doesn't\n mean that the local connection is in perfect health.)"]
20074 pub m_eAvailAnyRelay: ESteamNetworkingAvailability,
20075 #[doc = " Non-localized English language status. For diagnostic/debugging\n purposes only."]
20076 pub m_debugMsg: [::std::os::raw::c_char; 256usize],
20077}
20078pub const SteamRelayNetworkStatus_t_k_iCallback: SteamRelayNetworkStatus_t__bindgen_ty_1 =
20079 SteamRelayNetworkStatus_t__bindgen_ty_1::k_iCallback;
20080#[repr(u32)]
20081#[non_exhaustive]
20082#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20083pub enum SteamRelayNetworkStatus_t__bindgen_ty_1 {
20084 k_iCallback = 1281,
20085}
20086#[test]
20087fn bindgen_test_layout_SteamRelayNetworkStatus_t() {
20088 const UNINIT: ::std::mem::MaybeUninit<SteamRelayNetworkStatus_t> =
20089 ::std::mem::MaybeUninit::uninit();
20090 let ptr = UNINIT.as_ptr();
20091 assert_eq!(
20092 ::std::mem::size_of::<SteamRelayNetworkStatus_t>(),
20093 272usize,
20094 concat!("Size of: ", stringify!(SteamRelayNetworkStatus_t))
20095 );
20096 assert_eq!(
20097 ::std::mem::align_of::<SteamRelayNetworkStatus_t>(),
20098 4usize,
20099 concat!("Alignment of ", stringify!(SteamRelayNetworkStatus_t))
20100 );
20101 assert_eq!(
20102 unsafe { ::std::ptr::addr_of!((*ptr).m_eAvail) as usize - ptr as usize },
20103 0usize,
20104 concat!(
20105 "Offset of field: ",
20106 stringify!(SteamRelayNetworkStatus_t),
20107 "::",
20108 stringify!(m_eAvail)
20109 )
20110 );
20111 assert_eq!(
20112 unsafe {
20113 ::std::ptr::addr_of!((*ptr).m_bPingMeasurementInProgress) as usize - ptr as usize
20114 },
20115 4usize,
20116 concat!(
20117 "Offset of field: ",
20118 stringify!(SteamRelayNetworkStatus_t),
20119 "::",
20120 stringify!(m_bPingMeasurementInProgress)
20121 )
20122 );
20123 assert_eq!(
20124 unsafe { ::std::ptr::addr_of!((*ptr).m_eAvailNetworkConfig) as usize - ptr as usize },
20125 8usize,
20126 concat!(
20127 "Offset of field: ",
20128 stringify!(SteamRelayNetworkStatus_t),
20129 "::",
20130 stringify!(m_eAvailNetworkConfig)
20131 )
20132 );
20133 assert_eq!(
20134 unsafe { ::std::ptr::addr_of!((*ptr).m_eAvailAnyRelay) as usize - ptr as usize },
20135 12usize,
20136 concat!(
20137 "Offset of field: ",
20138 stringify!(SteamRelayNetworkStatus_t),
20139 "::",
20140 stringify!(m_eAvailAnyRelay)
20141 )
20142 );
20143 assert_eq!(
20144 unsafe { ::std::ptr::addr_of!((*ptr).m_debugMsg) as usize - ptr as usize },
20145 16usize,
20146 concat!(
20147 "Offset of field: ",
20148 stringify!(SteamRelayNetworkStatus_t),
20149 "::",
20150 stringify!(m_debugMsg)
20151 )
20152 );
20153}
20154#[doc = " Utility class for printing a SteamNetworkingIdentity.\n E.g. printf( \"Identity is '%s'\\n\", SteamNetworkingIdentityRender( identity ).c_str() );"]
20155#[repr(C)]
20156#[derive(Debug, Copy, Clone)]
20157pub struct SteamNetworkingIdentityRender {
20158 pub buf: [::std::os::raw::c_char; 128usize],
20159}
20160#[test]
20161fn bindgen_test_layout_SteamNetworkingIdentityRender() {
20162 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIdentityRender> =
20163 ::std::mem::MaybeUninit::uninit();
20164 let ptr = UNINIT.as_ptr();
20165 assert_eq!(
20166 ::std::mem::size_of::<SteamNetworkingIdentityRender>(),
20167 128usize,
20168 concat!("Size of: ", stringify!(SteamNetworkingIdentityRender))
20169 );
20170 assert_eq!(
20171 ::std::mem::align_of::<SteamNetworkingIdentityRender>(),
20172 1usize,
20173 concat!("Alignment of ", stringify!(SteamNetworkingIdentityRender))
20174 );
20175 assert_eq!(
20176 unsafe { ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize },
20177 0usize,
20178 concat!(
20179 "Offset of field: ",
20180 stringify!(SteamNetworkingIdentityRender),
20181 "::",
20182 stringify!(buf)
20183 )
20184 );
20185}
20186#[doc = " Utility class for printing a SteamNetworkingIPAddrRender."]
20187#[repr(C)]
20188#[derive(Debug, Copy, Clone)]
20189pub struct SteamNetworkingIPAddrRender {
20190 pub buf: [::std::os::raw::c_char; 48usize],
20191}
20192#[test]
20193fn bindgen_test_layout_SteamNetworkingIPAddrRender() {
20194 const UNINIT: ::std::mem::MaybeUninit<SteamNetworkingIPAddrRender> =
20195 ::std::mem::MaybeUninit::uninit();
20196 let ptr = UNINIT.as_ptr();
20197 assert_eq!(
20198 ::std::mem::size_of::<SteamNetworkingIPAddrRender>(),
20199 48usize,
20200 concat!("Size of: ", stringify!(SteamNetworkingIPAddrRender))
20201 );
20202 assert_eq!(
20203 ::std::mem::align_of::<SteamNetworkingIPAddrRender>(),
20204 1usize,
20205 concat!("Alignment of ", stringify!(SteamNetworkingIPAddrRender))
20206 );
20207 assert_eq!(
20208 unsafe { ::std::ptr::addr_of!((*ptr).buf) as usize - ptr as usize },
20209 0usize,
20210 concat!(
20211 "Offset of field: ",
20212 stringify!(SteamNetworkingIPAddrRender),
20213 "::",
20214 stringify!(buf)
20215 )
20216 );
20217}
20218#[repr(u32)]
20219#[non_exhaustive]
20220#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20221pub enum ESteamAPIInitResult {
20222 k_ESteamAPIInitResult_OK = 0,
20223 k_ESteamAPIInitResult_FailedGeneric = 1,
20224 k_ESteamAPIInitResult_NoSteamClient = 2,
20225 k_ESteamAPIInitResult_VersionMismatch = 3,
20226}
20227extern "C" {
20228 pub fn SteamAPI_InitFlat(pOutErrMsg: *mut SteamErrMsg) -> ESteamAPIInitResult;
20229}
20230extern "C" {
20231 pub fn SteamAPI_Shutdown();
20232}
20233extern "C" {
20234 pub fn SteamAPI_RestartAppIfNecessary(unOwnAppID: uint32) -> bool;
20235}
20236extern "C" {
20237 pub fn SteamAPI_ReleaseCurrentThreadMemory();
20238}
20239extern "C" {
20240 pub fn SteamAPI_WriteMiniDump(
20241 uStructuredExceptionCode: uint32,
20242 pvExceptionInfo: *mut ::std::os::raw::c_void,
20243 uBuildID: uint32,
20244 );
20245}
20246extern "C" {
20247 pub fn SteamAPI_SetMiniDumpComment(pchMsg: *const ::std::os::raw::c_char);
20248}
20249extern "C" {
20250 pub fn SteamAPI_IsSteamRunning() -> bool;
20251}
20252extern "C" {
20253 pub fn SteamAPI_GetSteamInstallPath() -> *const ::std::os::raw::c_char;
20254}
20255extern "C" {
20256 pub fn SteamAPI_SetTryCatchCallbacks(bTryCatchCallbacks: bool);
20257}
20258extern "C" {
20259 #[doc = " Inform the API that you wish to use manual event dispatch. This must be called after SteamAPI_Init, but before\n you use any of the other manual dispatch functions below."]
20260 pub fn SteamAPI_ManualDispatch_Init();
20261}
20262extern "C" {
20263 #[doc = " Perform certain periodic actions that need to be performed."]
20264 pub fn SteamAPI_ManualDispatch_RunFrame(hSteamPipe: HSteamPipe);
20265}
20266extern "C" {
20267 #[doc = " Fetch the next pending callback on the given pipe, if any. If a callback is available, true is returned\n and the structure is populated. In this case, you MUST call SteamAPI_ManualDispatch_FreeLastCallback\n (after dispatching the callback) before calling SteamAPI_ManualDispatch_GetNextCallback again."]
20268 pub fn SteamAPI_ManualDispatch_GetNextCallback(
20269 hSteamPipe: HSteamPipe,
20270 pCallbackMsg: *mut CallbackMsg_t,
20271 ) -> bool;
20272}
20273extern "C" {
20274 #[doc = " You must call this after dispatching the callback, if SteamAPI_ManualDispatch_GetNextCallback returns true."]
20275 pub fn SteamAPI_ManualDispatch_FreeLastCallback(hSteamPipe: HSteamPipe);
20276}
20277extern "C" {
20278 #[doc = " Return the call result for the specified call on the specified pipe. You really should\n only call this in a handler for SteamAPICallCompleted_t callback."]
20279 pub fn SteamAPI_ManualDispatch_GetAPICallResult(
20280 hSteamPipe: HSteamPipe,
20281 hSteamAPICall: SteamAPICall_t,
20282 pCallback: *mut ::std::os::raw::c_void,
20283 cubCallback: ::std::os::raw::c_int,
20284 iCallbackExpected: ::std::os::raw::c_int,
20285 pbFailed: *mut bool,
20286 ) -> bool;
20287}
20288extern "C" {
20289 pub fn SteamInternal_SteamAPI_Init(
20290 pszInternalCheckInterfaceVersions: *const ::std::os::raw::c_char,
20291 pOutErrMsg: *mut SteamErrMsg,
20292 ) -> ESteamAPIInitResult;
20293}
20294#[repr(C)]
20295pub struct ISteamGameServer__bindgen_vtable(::std::os::raw::c_void);
20296#[repr(C)]
20297#[derive(Debug, Copy, Clone)]
20298pub struct ISteamGameServer {
20299 pub vtable_: *const ISteamGameServer__bindgen_vtable,
20300}
20301#[test]
20302fn bindgen_test_layout_ISteamGameServer() {
20303 assert_eq!(
20304 ::std::mem::size_of::<ISteamGameServer>(),
20305 8usize,
20306 concat!("Size of: ", stringify!(ISteamGameServer))
20307 );
20308 assert_eq!(
20309 ::std::mem::align_of::<ISteamGameServer>(),
20310 8usize,
20311 concat!("Alignment of ", stringify!(ISteamGameServer))
20312 );
20313}
20314#[repr(C)]
20315#[derive(Copy, Clone)]
20316pub struct GSClientApprove_t {
20317 pub m_SteamID: CSteamID,
20318 pub m_OwnerSteamID: CSteamID,
20319}
20320pub const GSClientApprove_t_k_iCallback: GSClientApprove_t__bindgen_ty_1 =
20321 GSClientApprove_t__bindgen_ty_1::k_iCallback;
20322#[repr(u32)]
20323#[non_exhaustive]
20324#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20325pub enum GSClientApprove_t__bindgen_ty_1 {
20326 k_iCallback = 201,
20327}
20328#[test]
20329fn bindgen_test_layout_GSClientApprove_t() {
20330 const UNINIT: ::std::mem::MaybeUninit<GSClientApprove_t> = ::std::mem::MaybeUninit::uninit();
20331 let ptr = UNINIT.as_ptr();
20332 assert_eq!(
20333 ::std::mem::size_of::<GSClientApprove_t>(),
20334 16usize,
20335 concat!("Size of: ", stringify!(GSClientApprove_t))
20336 );
20337 assert_eq!(
20338 ::std::mem::align_of::<GSClientApprove_t>(),
20339 1usize,
20340 concat!("Alignment of ", stringify!(GSClientApprove_t))
20341 );
20342 assert_eq!(
20343 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamID) as usize - ptr as usize },
20344 0usize,
20345 concat!(
20346 "Offset of field: ",
20347 stringify!(GSClientApprove_t),
20348 "::",
20349 stringify!(m_SteamID)
20350 )
20351 );
20352 assert_eq!(
20353 unsafe { ::std::ptr::addr_of!((*ptr).m_OwnerSteamID) as usize - ptr as usize },
20354 8usize,
20355 concat!(
20356 "Offset of field: ",
20357 stringify!(GSClientApprove_t),
20358 "::",
20359 stringify!(m_OwnerSteamID)
20360 )
20361 );
20362}
20363#[repr(C)]
20364#[derive(Copy, Clone)]
20365pub struct GSClientDeny_t {
20366 pub m_SteamID: CSteamID,
20367 pub m_eDenyReason: EDenyReason,
20368 pub m_rgchOptionalText: [::std::os::raw::c_char; 128usize],
20369}
20370pub const GSClientDeny_t_k_iCallback: GSClientDeny_t__bindgen_ty_1 =
20371 GSClientDeny_t__bindgen_ty_1::k_iCallback;
20372#[repr(u32)]
20373#[non_exhaustive]
20374#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20375pub enum GSClientDeny_t__bindgen_ty_1 {
20376 k_iCallback = 202,
20377}
20378#[test]
20379fn bindgen_test_layout_GSClientDeny_t() {
20380 const UNINIT: ::std::mem::MaybeUninit<GSClientDeny_t> = ::std::mem::MaybeUninit::uninit();
20381 let ptr = UNINIT.as_ptr();
20382 assert_eq!(
20383 ::std::mem::size_of::<GSClientDeny_t>(),
20384 140usize,
20385 concat!("Size of: ", stringify!(GSClientDeny_t))
20386 );
20387 assert_eq!(
20388 ::std::mem::align_of::<GSClientDeny_t>(),
20389 4usize,
20390 concat!("Alignment of ", stringify!(GSClientDeny_t))
20391 );
20392 assert_eq!(
20393 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamID) as usize - ptr as usize },
20394 0usize,
20395 concat!(
20396 "Offset of field: ",
20397 stringify!(GSClientDeny_t),
20398 "::",
20399 stringify!(m_SteamID)
20400 )
20401 );
20402 assert_eq!(
20403 unsafe { ::std::ptr::addr_of!((*ptr).m_eDenyReason) as usize - ptr as usize },
20404 8usize,
20405 concat!(
20406 "Offset of field: ",
20407 stringify!(GSClientDeny_t),
20408 "::",
20409 stringify!(m_eDenyReason)
20410 )
20411 );
20412 assert_eq!(
20413 unsafe { ::std::ptr::addr_of!((*ptr).m_rgchOptionalText) as usize - ptr as usize },
20414 12usize,
20415 concat!(
20416 "Offset of field: ",
20417 stringify!(GSClientDeny_t),
20418 "::",
20419 stringify!(m_rgchOptionalText)
20420 )
20421 );
20422}
20423#[repr(C)]
20424#[derive(Copy, Clone)]
20425pub struct GSClientKick_t {
20426 pub m_SteamID: CSteamID,
20427 pub m_eDenyReason: EDenyReason,
20428}
20429pub const GSClientKick_t_k_iCallback: GSClientKick_t__bindgen_ty_1 =
20430 GSClientKick_t__bindgen_ty_1::k_iCallback;
20431#[repr(u32)]
20432#[non_exhaustive]
20433#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20434pub enum GSClientKick_t__bindgen_ty_1 {
20435 k_iCallback = 203,
20436}
20437#[test]
20438fn bindgen_test_layout_GSClientKick_t() {
20439 const UNINIT: ::std::mem::MaybeUninit<GSClientKick_t> = ::std::mem::MaybeUninit::uninit();
20440 let ptr = UNINIT.as_ptr();
20441 assert_eq!(
20442 ::std::mem::size_of::<GSClientKick_t>(),
20443 12usize,
20444 concat!("Size of: ", stringify!(GSClientKick_t))
20445 );
20446 assert_eq!(
20447 ::std::mem::align_of::<GSClientKick_t>(),
20448 4usize,
20449 concat!("Alignment of ", stringify!(GSClientKick_t))
20450 );
20451 assert_eq!(
20452 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamID) as usize - ptr as usize },
20453 0usize,
20454 concat!(
20455 "Offset of field: ",
20456 stringify!(GSClientKick_t),
20457 "::",
20458 stringify!(m_SteamID)
20459 )
20460 );
20461 assert_eq!(
20462 unsafe { ::std::ptr::addr_of!((*ptr).m_eDenyReason) as usize - ptr as usize },
20463 8usize,
20464 concat!(
20465 "Offset of field: ",
20466 stringify!(GSClientKick_t),
20467 "::",
20468 stringify!(m_eDenyReason)
20469 )
20470 );
20471}
20472#[repr(C, packed(4))]
20473#[derive(Debug, Copy, Clone)]
20474pub struct GSClientAchievementStatus_t {
20475 pub m_SteamID: uint64,
20476 pub m_pchAchievement: [::std::os::raw::c_char; 128usize],
20477 pub m_bUnlocked: bool,
20478}
20479pub const GSClientAchievementStatus_t_k_iCallback: GSClientAchievementStatus_t__bindgen_ty_1 =
20480 GSClientAchievementStatus_t__bindgen_ty_1::k_iCallback;
20481#[repr(u32)]
20482#[non_exhaustive]
20483#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20484pub enum GSClientAchievementStatus_t__bindgen_ty_1 {
20485 k_iCallback = 206,
20486}
20487#[test]
20488fn bindgen_test_layout_GSClientAchievementStatus_t() {
20489 const UNINIT: ::std::mem::MaybeUninit<GSClientAchievementStatus_t> =
20490 ::std::mem::MaybeUninit::uninit();
20491 let ptr = UNINIT.as_ptr();
20492 assert_eq!(
20493 ::std::mem::size_of::<GSClientAchievementStatus_t>(),
20494 140usize,
20495 concat!("Size of: ", stringify!(GSClientAchievementStatus_t))
20496 );
20497 assert_eq!(
20498 ::std::mem::align_of::<GSClientAchievementStatus_t>(),
20499 4usize,
20500 concat!("Alignment of ", stringify!(GSClientAchievementStatus_t))
20501 );
20502 assert_eq!(
20503 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamID) as usize - ptr as usize },
20504 0usize,
20505 concat!(
20506 "Offset of field: ",
20507 stringify!(GSClientAchievementStatus_t),
20508 "::",
20509 stringify!(m_SteamID)
20510 )
20511 );
20512 assert_eq!(
20513 unsafe { ::std::ptr::addr_of!((*ptr).m_pchAchievement) as usize - ptr as usize },
20514 8usize,
20515 concat!(
20516 "Offset of field: ",
20517 stringify!(GSClientAchievementStatus_t),
20518 "::",
20519 stringify!(m_pchAchievement)
20520 )
20521 );
20522 assert_eq!(
20523 unsafe { ::std::ptr::addr_of!((*ptr).m_bUnlocked) as usize - ptr as usize },
20524 136usize,
20525 concat!(
20526 "Offset of field: ",
20527 stringify!(GSClientAchievementStatus_t),
20528 "::",
20529 stringify!(m_bUnlocked)
20530 )
20531 );
20532}
20533#[repr(C)]
20534#[derive(Debug, Copy, Clone)]
20535pub struct GSPolicyResponse_t {
20536 pub m_bSecure: uint8,
20537}
20538pub const GSPolicyResponse_t_k_iCallback: GSPolicyResponse_t__bindgen_ty_1 =
20539 GSPolicyResponse_t__bindgen_ty_1::k_iCallback;
20540#[repr(u32)]
20541#[non_exhaustive]
20542#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20543pub enum GSPolicyResponse_t__bindgen_ty_1 {
20544 k_iCallback = 115,
20545}
20546#[test]
20547fn bindgen_test_layout_GSPolicyResponse_t() {
20548 const UNINIT: ::std::mem::MaybeUninit<GSPolicyResponse_t> = ::std::mem::MaybeUninit::uninit();
20549 let ptr = UNINIT.as_ptr();
20550 assert_eq!(
20551 ::std::mem::size_of::<GSPolicyResponse_t>(),
20552 1usize,
20553 concat!("Size of: ", stringify!(GSPolicyResponse_t))
20554 );
20555 assert_eq!(
20556 ::std::mem::align_of::<GSPolicyResponse_t>(),
20557 1usize,
20558 concat!("Alignment of ", stringify!(GSPolicyResponse_t))
20559 );
20560 assert_eq!(
20561 unsafe { ::std::ptr::addr_of!((*ptr).m_bSecure) as usize - ptr as usize },
20562 0usize,
20563 concat!(
20564 "Offset of field: ",
20565 stringify!(GSPolicyResponse_t),
20566 "::",
20567 stringify!(m_bSecure)
20568 )
20569 );
20570}
20571#[repr(C)]
20572#[derive(Debug, Copy, Clone)]
20573pub struct GSGameplayStats_t {
20574 pub m_eResult: EResult,
20575 pub m_nRank: int32,
20576 pub m_unTotalConnects: uint32,
20577 pub m_unTotalMinutesPlayed: uint32,
20578}
20579pub const GSGameplayStats_t_k_iCallback: GSGameplayStats_t__bindgen_ty_1 =
20580 GSGameplayStats_t__bindgen_ty_1::k_iCallback;
20581#[repr(u32)]
20582#[non_exhaustive]
20583#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20584pub enum GSGameplayStats_t__bindgen_ty_1 {
20585 k_iCallback = 207,
20586}
20587#[test]
20588fn bindgen_test_layout_GSGameplayStats_t() {
20589 const UNINIT: ::std::mem::MaybeUninit<GSGameplayStats_t> = ::std::mem::MaybeUninit::uninit();
20590 let ptr = UNINIT.as_ptr();
20591 assert_eq!(
20592 ::std::mem::size_of::<GSGameplayStats_t>(),
20593 16usize,
20594 concat!("Size of: ", stringify!(GSGameplayStats_t))
20595 );
20596 assert_eq!(
20597 ::std::mem::align_of::<GSGameplayStats_t>(),
20598 4usize,
20599 concat!("Alignment of ", stringify!(GSGameplayStats_t))
20600 );
20601 assert_eq!(
20602 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
20603 0usize,
20604 concat!(
20605 "Offset of field: ",
20606 stringify!(GSGameplayStats_t),
20607 "::",
20608 stringify!(m_eResult)
20609 )
20610 );
20611 assert_eq!(
20612 unsafe { ::std::ptr::addr_of!((*ptr).m_nRank) as usize - ptr as usize },
20613 4usize,
20614 concat!(
20615 "Offset of field: ",
20616 stringify!(GSGameplayStats_t),
20617 "::",
20618 stringify!(m_nRank)
20619 )
20620 );
20621 assert_eq!(
20622 unsafe { ::std::ptr::addr_of!((*ptr).m_unTotalConnects) as usize - ptr as usize },
20623 8usize,
20624 concat!(
20625 "Offset of field: ",
20626 stringify!(GSGameplayStats_t),
20627 "::",
20628 stringify!(m_unTotalConnects)
20629 )
20630 );
20631 assert_eq!(
20632 unsafe { ::std::ptr::addr_of!((*ptr).m_unTotalMinutesPlayed) as usize - ptr as usize },
20633 12usize,
20634 concat!(
20635 "Offset of field: ",
20636 stringify!(GSGameplayStats_t),
20637 "::",
20638 stringify!(m_unTotalMinutesPlayed)
20639 )
20640 );
20641}
20642#[repr(C)]
20643#[derive(Copy, Clone)]
20644pub struct GSClientGroupStatus_t {
20645 pub m_SteamIDUser: CSteamID,
20646 pub m_SteamIDGroup: CSteamID,
20647 pub m_bMember: bool,
20648 pub m_bOfficer: bool,
20649}
20650pub const GSClientGroupStatus_t_k_iCallback: GSClientGroupStatus_t__bindgen_ty_1 =
20651 GSClientGroupStatus_t__bindgen_ty_1::k_iCallback;
20652#[repr(u32)]
20653#[non_exhaustive]
20654#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20655pub enum GSClientGroupStatus_t__bindgen_ty_1 {
20656 k_iCallback = 208,
20657}
20658#[test]
20659fn bindgen_test_layout_GSClientGroupStatus_t() {
20660 const UNINIT: ::std::mem::MaybeUninit<GSClientGroupStatus_t> =
20661 ::std::mem::MaybeUninit::uninit();
20662 let ptr = UNINIT.as_ptr();
20663 assert_eq!(
20664 ::std::mem::size_of::<GSClientGroupStatus_t>(),
20665 18usize,
20666 concat!("Size of: ", stringify!(GSClientGroupStatus_t))
20667 );
20668 assert_eq!(
20669 ::std::mem::align_of::<GSClientGroupStatus_t>(),
20670 1usize,
20671 concat!("Alignment of ", stringify!(GSClientGroupStatus_t))
20672 );
20673 assert_eq!(
20674 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamIDUser) as usize - ptr as usize },
20675 0usize,
20676 concat!(
20677 "Offset of field: ",
20678 stringify!(GSClientGroupStatus_t),
20679 "::",
20680 stringify!(m_SteamIDUser)
20681 )
20682 );
20683 assert_eq!(
20684 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamIDGroup) as usize - ptr as usize },
20685 8usize,
20686 concat!(
20687 "Offset of field: ",
20688 stringify!(GSClientGroupStatus_t),
20689 "::",
20690 stringify!(m_SteamIDGroup)
20691 )
20692 );
20693 assert_eq!(
20694 unsafe { ::std::ptr::addr_of!((*ptr).m_bMember) as usize - ptr as usize },
20695 16usize,
20696 concat!(
20697 "Offset of field: ",
20698 stringify!(GSClientGroupStatus_t),
20699 "::",
20700 stringify!(m_bMember)
20701 )
20702 );
20703 assert_eq!(
20704 unsafe { ::std::ptr::addr_of!((*ptr).m_bOfficer) as usize - ptr as usize },
20705 17usize,
20706 concat!(
20707 "Offset of field: ",
20708 stringify!(GSClientGroupStatus_t),
20709 "::",
20710 stringify!(m_bOfficer)
20711 )
20712 );
20713}
20714#[repr(C, packed(4))]
20715#[derive(Debug, Copy, Clone)]
20716pub struct GSReputation_t {
20717 pub m_eResult: EResult,
20718 pub m_unReputationScore: uint32,
20719 pub m_bBanned: bool,
20720 pub m_unBannedIP: uint32,
20721 pub m_usBannedPort: uint16,
20722 pub m_ulBannedGameID: uint64,
20723 pub m_unBanExpires: uint32,
20724}
20725pub const GSReputation_t_k_iCallback: GSReputation_t__bindgen_ty_1 =
20726 GSReputation_t__bindgen_ty_1::k_iCallback;
20727#[repr(u32)]
20728#[non_exhaustive]
20729#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20730pub enum GSReputation_t__bindgen_ty_1 {
20731 k_iCallback = 209,
20732}
20733#[test]
20734fn bindgen_test_layout_GSReputation_t() {
20735 const UNINIT: ::std::mem::MaybeUninit<GSReputation_t> = ::std::mem::MaybeUninit::uninit();
20736 let ptr = UNINIT.as_ptr();
20737 assert_eq!(
20738 ::std::mem::size_of::<GSReputation_t>(),
20739 32usize,
20740 concat!("Size of: ", stringify!(GSReputation_t))
20741 );
20742 assert_eq!(
20743 ::std::mem::align_of::<GSReputation_t>(),
20744 4usize,
20745 concat!("Alignment of ", stringify!(GSReputation_t))
20746 );
20747 assert_eq!(
20748 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
20749 0usize,
20750 concat!(
20751 "Offset of field: ",
20752 stringify!(GSReputation_t),
20753 "::",
20754 stringify!(m_eResult)
20755 )
20756 );
20757 assert_eq!(
20758 unsafe { ::std::ptr::addr_of!((*ptr).m_unReputationScore) as usize - ptr as usize },
20759 4usize,
20760 concat!(
20761 "Offset of field: ",
20762 stringify!(GSReputation_t),
20763 "::",
20764 stringify!(m_unReputationScore)
20765 )
20766 );
20767 assert_eq!(
20768 unsafe { ::std::ptr::addr_of!((*ptr).m_bBanned) as usize - ptr as usize },
20769 8usize,
20770 concat!(
20771 "Offset of field: ",
20772 stringify!(GSReputation_t),
20773 "::",
20774 stringify!(m_bBanned)
20775 )
20776 );
20777 assert_eq!(
20778 unsafe { ::std::ptr::addr_of!((*ptr).m_unBannedIP) as usize - ptr as usize },
20779 12usize,
20780 concat!(
20781 "Offset of field: ",
20782 stringify!(GSReputation_t),
20783 "::",
20784 stringify!(m_unBannedIP)
20785 )
20786 );
20787 assert_eq!(
20788 unsafe { ::std::ptr::addr_of!((*ptr).m_usBannedPort) as usize - ptr as usize },
20789 16usize,
20790 concat!(
20791 "Offset of field: ",
20792 stringify!(GSReputation_t),
20793 "::",
20794 stringify!(m_usBannedPort)
20795 )
20796 );
20797 assert_eq!(
20798 unsafe { ::std::ptr::addr_of!((*ptr).m_ulBannedGameID) as usize - ptr as usize },
20799 20usize,
20800 concat!(
20801 "Offset of field: ",
20802 stringify!(GSReputation_t),
20803 "::",
20804 stringify!(m_ulBannedGameID)
20805 )
20806 );
20807 assert_eq!(
20808 unsafe { ::std::ptr::addr_of!((*ptr).m_unBanExpires) as usize - ptr as usize },
20809 28usize,
20810 concat!(
20811 "Offset of field: ",
20812 stringify!(GSReputation_t),
20813 "::",
20814 stringify!(m_unBanExpires)
20815 )
20816 );
20817}
20818#[repr(C)]
20819#[derive(Debug, Copy, Clone)]
20820pub struct AssociateWithClanResult_t {
20821 pub m_eResult: EResult,
20822}
20823pub const AssociateWithClanResult_t_k_iCallback: AssociateWithClanResult_t__bindgen_ty_1 =
20824 AssociateWithClanResult_t__bindgen_ty_1::k_iCallback;
20825#[repr(u32)]
20826#[non_exhaustive]
20827#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20828pub enum AssociateWithClanResult_t__bindgen_ty_1 {
20829 k_iCallback = 210,
20830}
20831#[test]
20832fn bindgen_test_layout_AssociateWithClanResult_t() {
20833 const UNINIT: ::std::mem::MaybeUninit<AssociateWithClanResult_t> =
20834 ::std::mem::MaybeUninit::uninit();
20835 let ptr = UNINIT.as_ptr();
20836 assert_eq!(
20837 ::std::mem::size_of::<AssociateWithClanResult_t>(),
20838 4usize,
20839 concat!("Size of: ", stringify!(AssociateWithClanResult_t))
20840 );
20841 assert_eq!(
20842 ::std::mem::align_of::<AssociateWithClanResult_t>(),
20843 4usize,
20844 concat!("Alignment of ", stringify!(AssociateWithClanResult_t))
20845 );
20846 assert_eq!(
20847 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
20848 0usize,
20849 concat!(
20850 "Offset of field: ",
20851 stringify!(AssociateWithClanResult_t),
20852 "::",
20853 stringify!(m_eResult)
20854 )
20855 );
20856}
20857#[repr(C)]
20858#[derive(Copy, Clone)]
20859pub struct ComputeNewPlayerCompatibilityResult_t {
20860 pub m_eResult: EResult,
20861 pub m_cPlayersThatDontLikeCandidate: ::std::os::raw::c_int,
20862 pub m_cPlayersThatCandidateDoesntLike: ::std::os::raw::c_int,
20863 pub m_cClanPlayersThatDontLikeCandidate: ::std::os::raw::c_int,
20864 pub m_SteamIDCandidate: CSteamID,
20865}
20866pub const ComputeNewPlayerCompatibilityResult_t_k_iCallback:
20867 ComputeNewPlayerCompatibilityResult_t__bindgen_ty_1 =
20868 ComputeNewPlayerCompatibilityResult_t__bindgen_ty_1::k_iCallback;
20869#[repr(u32)]
20870#[non_exhaustive]
20871#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20872pub enum ComputeNewPlayerCompatibilityResult_t__bindgen_ty_1 {
20873 k_iCallback = 211,
20874}
20875#[test]
20876fn bindgen_test_layout_ComputeNewPlayerCompatibilityResult_t() {
20877 const UNINIT: ::std::mem::MaybeUninit<ComputeNewPlayerCompatibilityResult_t> =
20878 ::std::mem::MaybeUninit::uninit();
20879 let ptr = UNINIT.as_ptr();
20880 assert_eq!(
20881 ::std::mem::size_of::<ComputeNewPlayerCompatibilityResult_t>(),
20882 24usize,
20883 concat!(
20884 "Size of: ",
20885 stringify!(ComputeNewPlayerCompatibilityResult_t)
20886 )
20887 );
20888 assert_eq!(
20889 ::std::mem::align_of::<ComputeNewPlayerCompatibilityResult_t>(),
20890 4usize,
20891 concat!(
20892 "Alignment of ",
20893 stringify!(ComputeNewPlayerCompatibilityResult_t)
20894 )
20895 );
20896 assert_eq!(
20897 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
20898 0usize,
20899 concat!(
20900 "Offset of field: ",
20901 stringify!(ComputeNewPlayerCompatibilityResult_t),
20902 "::",
20903 stringify!(m_eResult)
20904 )
20905 );
20906 assert_eq!(
20907 unsafe {
20908 ::std::ptr::addr_of!((*ptr).m_cPlayersThatDontLikeCandidate) as usize - ptr as usize
20909 },
20910 4usize,
20911 concat!(
20912 "Offset of field: ",
20913 stringify!(ComputeNewPlayerCompatibilityResult_t),
20914 "::",
20915 stringify!(m_cPlayersThatDontLikeCandidate)
20916 )
20917 );
20918 assert_eq!(
20919 unsafe {
20920 ::std::ptr::addr_of!((*ptr).m_cPlayersThatCandidateDoesntLike) as usize - ptr as usize
20921 },
20922 8usize,
20923 concat!(
20924 "Offset of field: ",
20925 stringify!(ComputeNewPlayerCompatibilityResult_t),
20926 "::",
20927 stringify!(m_cPlayersThatCandidateDoesntLike)
20928 )
20929 );
20930 assert_eq!(
20931 unsafe {
20932 ::std::ptr::addr_of!((*ptr).m_cClanPlayersThatDontLikeCandidate) as usize - ptr as usize
20933 },
20934 12usize,
20935 concat!(
20936 "Offset of field: ",
20937 stringify!(ComputeNewPlayerCompatibilityResult_t),
20938 "::",
20939 stringify!(m_cClanPlayersThatDontLikeCandidate)
20940 )
20941 );
20942 assert_eq!(
20943 unsafe { ::std::ptr::addr_of!((*ptr).m_SteamIDCandidate) as usize - ptr as usize },
20944 16usize,
20945 concat!(
20946 "Offset of field: ",
20947 stringify!(ComputeNewPlayerCompatibilityResult_t),
20948 "::",
20949 stringify!(m_SteamIDCandidate)
20950 )
20951 );
20952}
20953#[repr(C)]
20954pub struct ISteamGameServerStats__bindgen_vtable(::std::os::raw::c_void);
20955#[repr(C)]
20956#[derive(Debug, Copy, Clone)]
20957pub struct ISteamGameServerStats {
20958 pub vtable_: *const ISteamGameServerStats__bindgen_vtable,
20959}
20960#[test]
20961fn bindgen_test_layout_ISteamGameServerStats() {
20962 assert_eq!(
20963 ::std::mem::size_of::<ISteamGameServerStats>(),
20964 8usize,
20965 concat!("Size of: ", stringify!(ISteamGameServerStats))
20966 );
20967 assert_eq!(
20968 ::std::mem::align_of::<ISteamGameServerStats>(),
20969 8usize,
20970 concat!("Alignment of ", stringify!(ISteamGameServerStats))
20971 );
20972}
20973#[repr(C)]
20974#[derive(Copy, Clone)]
20975pub struct GSStatsReceived_t {
20976 pub m_eResult: EResult,
20977 pub m_steamIDUser: CSteamID,
20978}
20979pub const GSStatsReceived_t_k_iCallback: GSStatsReceived_t__bindgen_ty_1 =
20980 GSStatsReceived_t__bindgen_ty_1::k_iCallback;
20981#[repr(u32)]
20982#[non_exhaustive]
20983#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
20984pub enum GSStatsReceived_t__bindgen_ty_1 {
20985 k_iCallback = 1800,
20986}
20987#[test]
20988fn bindgen_test_layout_GSStatsReceived_t() {
20989 const UNINIT: ::std::mem::MaybeUninit<GSStatsReceived_t> = ::std::mem::MaybeUninit::uninit();
20990 let ptr = UNINIT.as_ptr();
20991 assert_eq!(
20992 ::std::mem::size_of::<GSStatsReceived_t>(),
20993 12usize,
20994 concat!("Size of: ", stringify!(GSStatsReceived_t))
20995 );
20996 assert_eq!(
20997 ::std::mem::align_of::<GSStatsReceived_t>(),
20998 4usize,
20999 concat!("Alignment of ", stringify!(GSStatsReceived_t))
21000 );
21001 assert_eq!(
21002 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
21003 0usize,
21004 concat!(
21005 "Offset of field: ",
21006 stringify!(GSStatsReceived_t),
21007 "::",
21008 stringify!(m_eResult)
21009 )
21010 );
21011 assert_eq!(
21012 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
21013 4usize,
21014 concat!(
21015 "Offset of field: ",
21016 stringify!(GSStatsReceived_t),
21017 "::",
21018 stringify!(m_steamIDUser)
21019 )
21020 );
21021}
21022#[repr(C)]
21023#[derive(Copy, Clone)]
21024pub struct GSStatsStored_t {
21025 pub m_eResult: EResult,
21026 pub m_steamIDUser: CSteamID,
21027}
21028pub const GSStatsStored_t_k_iCallback: GSStatsStored_t__bindgen_ty_1 =
21029 GSStatsStored_t__bindgen_ty_1::k_iCallback;
21030#[repr(u32)]
21031#[non_exhaustive]
21032#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
21033pub enum GSStatsStored_t__bindgen_ty_1 {
21034 k_iCallback = 1801,
21035}
21036#[test]
21037fn bindgen_test_layout_GSStatsStored_t() {
21038 const UNINIT: ::std::mem::MaybeUninit<GSStatsStored_t> = ::std::mem::MaybeUninit::uninit();
21039 let ptr = UNINIT.as_ptr();
21040 assert_eq!(
21041 ::std::mem::size_of::<GSStatsStored_t>(),
21042 12usize,
21043 concat!("Size of: ", stringify!(GSStatsStored_t))
21044 );
21045 assert_eq!(
21046 ::std::mem::align_of::<GSStatsStored_t>(),
21047 4usize,
21048 concat!("Alignment of ", stringify!(GSStatsStored_t))
21049 );
21050 assert_eq!(
21051 unsafe { ::std::ptr::addr_of!((*ptr).m_eResult) as usize - ptr as usize },
21052 0usize,
21053 concat!(
21054 "Offset of field: ",
21055 stringify!(GSStatsStored_t),
21056 "::",
21057 stringify!(m_eResult)
21058 )
21059 );
21060 assert_eq!(
21061 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
21062 4usize,
21063 concat!(
21064 "Offset of field: ",
21065 stringify!(GSStatsStored_t),
21066 "::",
21067 stringify!(m_steamIDUser)
21068 )
21069 );
21070}
21071#[repr(C)]
21072#[derive(Copy, Clone)]
21073pub struct GSStatsUnloaded_t {
21074 pub m_steamIDUser: CSteamID,
21075}
21076pub const GSStatsUnloaded_t_k_iCallback: GSStatsUnloaded_t__bindgen_ty_1 =
21077 GSStatsUnloaded_t__bindgen_ty_1::k_iCallback;
21078#[repr(u32)]
21079#[non_exhaustive]
21080#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
21081pub enum GSStatsUnloaded_t__bindgen_ty_1 {
21082 k_iCallback = 1108,
21083}
21084#[test]
21085fn bindgen_test_layout_GSStatsUnloaded_t() {
21086 const UNINIT: ::std::mem::MaybeUninit<GSStatsUnloaded_t> = ::std::mem::MaybeUninit::uninit();
21087 let ptr = UNINIT.as_ptr();
21088 assert_eq!(
21089 ::std::mem::size_of::<GSStatsUnloaded_t>(),
21090 8usize,
21091 concat!("Size of: ", stringify!(GSStatsUnloaded_t))
21092 );
21093 assert_eq!(
21094 ::std::mem::align_of::<GSStatsUnloaded_t>(),
21095 1usize,
21096 concat!("Alignment of ", stringify!(GSStatsUnloaded_t))
21097 );
21098 assert_eq!(
21099 unsafe { ::std::ptr::addr_of!((*ptr).m_steamIDUser) as usize - ptr as usize },
21100 0usize,
21101 concat!(
21102 "Offset of field: ",
21103 stringify!(GSStatsUnloaded_t),
21104 "::",
21105 stringify!(m_steamIDUser)
21106 )
21107 );
21108}
21109pub type uint64_steamid = uint64;
21110pub type uint64_gameid = uint64;
21111extern "C" {
21112 pub fn SteamAPI_ISteamClient_CreateSteamPipe(self_: *mut ISteamClient) -> HSteamPipe;
21113}
21114extern "C" {
21115 pub fn SteamAPI_ISteamClient_BReleaseSteamPipe(
21116 self_: *mut ISteamClient,
21117 hSteamPipe: HSteamPipe,
21118 ) -> bool;
21119}
21120extern "C" {
21121 pub fn SteamAPI_ISteamClient_ConnectToGlobalUser(
21122 self_: *mut ISteamClient,
21123 hSteamPipe: HSteamPipe,
21124 ) -> HSteamUser;
21125}
21126extern "C" {
21127 pub fn SteamAPI_ISteamClient_CreateLocalUser(
21128 self_: *mut ISteamClient,
21129 phSteamPipe: *mut HSteamPipe,
21130 eAccountType: EAccountType,
21131 ) -> HSteamUser;
21132}
21133extern "C" {
21134 pub fn SteamAPI_ISteamClient_ReleaseUser(
21135 self_: *mut ISteamClient,
21136 hSteamPipe: HSteamPipe,
21137 hUser: HSteamUser,
21138 );
21139}
21140extern "C" {
21141 pub fn SteamAPI_ISteamClient_GetISteamUser(
21142 self_: *mut ISteamClient,
21143 hSteamUser: HSteamUser,
21144 hSteamPipe: HSteamPipe,
21145 pchVersion: *const ::std::os::raw::c_char,
21146 ) -> *mut ISteamUser;
21147}
21148extern "C" {
21149 pub fn SteamAPI_ISteamClient_GetISteamGameServer(
21150 self_: *mut ISteamClient,
21151 hSteamUser: HSteamUser,
21152 hSteamPipe: HSteamPipe,
21153 pchVersion: *const ::std::os::raw::c_char,
21154 ) -> *mut ISteamGameServer;
21155}
21156extern "C" {
21157 pub fn SteamAPI_ISteamClient_SetLocalIPBinding(
21158 self_: *mut ISteamClient,
21159 unIP: *const SteamIPAddress_t,
21160 usPort: uint16,
21161 );
21162}
21163extern "C" {
21164 pub fn SteamAPI_ISteamClient_GetISteamFriends(
21165 self_: *mut ISteamClient,
21166 hSteamUser: HSteamUser,
21167 hSteamPipe: HSteamPipe,
21168 pchVersion: *const ::std::os::raw::c_char,
21169 ) -> *mut ISteamFriends;
21170}
21171extern "C" {
21172 pub fn SteamAPI_ISteamClient_GetISteamUtils(
21173 self_: *mut ISteamClient,
21174 hSteamPipe: HSteamPipe,
21175 pchVersion: *const ::std::os::raw::c_char,
21176 ) -> *mut ISteamUtils;
21177}
21178extern "C" {
21179 pub fn SteamAPI_ISteamClient_GetISteamMatchmaking(
21180 self_: *mut ISteamClient,
21181 hSteamUser: HSteamUser,
21182 hSteamPipe: HSteamPipe,
21183 pchVersion: *const ::std::os::raw::c_char,
21184 ) -> *mut ISteamMatchmaking;
21185}
21186extern "C" {
21187 pub fn SteamAPI_ISteamClient_GetISteamMatchmakingServers(
21188 self_: *mut ISteamClient,
21189 hSteamUser: HSteamUser,
21190 hSteamPipe: HSteamPipe,
21191 pchVersion: *const ::std::os::raw::c_char,
21192 ) -> *mut ISteamMatchmakingServers;
21193}
21194extern "C" {
21195 pub fn SteamAPI_ISteamClient_GetISteamGenericInterface(
21196 self_: *mut ISteamClient,
21197 hSteamUser: HSteamUser,
21198 hSteamPipe: HSteamPipe,
21199 pchVersion: *const ::std::os::raw::c_char,
21200 ) -> *mut ::std::os::raw::c_void;
21201}
21202extern "C" {
21203 pub fn SteamAPI_ISteamClient_GetISteamUserStats(
21204 self_: *mut ISteamClient,
21205 hSteamUser: HSteamUser,
21206 hSteamPipe: HSteamPipe,
21207 pchVersion: *const ::std::os::raw::c_char,
21208 ) -> *mut ISteamUserStats;
21209}
21210extern "C" {
21211 pub fn SteamAPI_ISteamClient_GetISteamGameServerStats(
21212 self_: *mut ISteamClient,
21213 hSteamuser: HSteamUser,
21214 hSteamPipe: HSteamPipe,
21215 pchVersion: *const ::std::os::raw::c_char,
21216 ) -> *mut ISteamGameServerStats;
21217}
21218extern "C" {
21219 pub fn SteamAPI_ISteamClient_GetISteamApps(
21220 self_: *mut ISteamClient,
21221 hSteamUser: HSteamUser,
21222 hSteamPipe: HSteamPipe,
21223 pchVersion: *const ::std::os::raw::c_char,
21224 ) -> *mut ISteamApps;
21225}
21226extern "C" {
21227 pub fn SteamAPI_ISteamClient_GetISteamNetworking(
21228 self_: *mut ISteamClient,
21229 hSteamUser: HSteamUser,
21230 hSteamPipe: HSteamPipe,
21231 pchVersion: *const ::std::os::raw::c_char,
21232 ) -> *mut ISteamNetworking;
21233}
21234extern "C" {
21235 pub fn SteamAPI_ISteamClient_GetISteamRemoteStorage(
21236 self_: *mut ISteamClient,
21237 hSteamuser: HSteamUser,
21238 hSteamPipe: HSteamPipe,
21239 pchVersion: *const ::std::os::raw::c_char,
21240 ) -> *mut ISteamRemoteStorage;
21241}
21242extern "C" {
21243 pub fn SteamAPI_ISteamClient_GetISteamScreenshots(
21244 self_: *mut ISteamClient,
21245 hSteamuser: HSteamUser,
21246 hSteamPipe: HSteamPipe,
21247 pchVersion: *const ::std::os::raw::c_char,
21248 ) -> *mut ISteamScreenshots;
21249}
21250extern "C" {
21251 pub fn SteamAPI_ISteamClient_GetIPCCallCount(self_: *mut ISteamClient) -> uint32;
21252}
21253extern "C" {
21254 pub fn SteamAPI_ISteamClient_SetWarningMessageHook(
21255 self_: *mut ISteamClient,
21256 pFunction: SteamAPIWarningMessageHook_t,
21257 );
21258}
21259extern "C" {
21260 pub fn SteamAPI_ISteamClient_BShutdownIfAllPipesClosed(self_: *mut ISteamClient) -> bool;
21261}
21262extern "C" {
21263 pub fn SteamAPI_ISteamClient_GetISteamHTTP(
21264 self_: *mut ISteamClient,
21265 hSteamuser: HSteamUser,
21266 hSteamPipe: HSteamPipe,
21267 pchVersion: *const ::std::os::raw::c_char,
21268 ) -> *mut ISteamHTTP;
21269}
21270extern "C" {
21271 pub fn SteamAPI_ISteamClient_GetISteamController(
21272 self_: *mut ISteamClient,
21273 hSteamUser: HSteamUser,
21274 hSteamPipe: HSteamPipe,
21275 pchVersion: *const ::std::os::raw::c_char,
21276 ) -> *mut ISteamController;
21277}
21278extern "C" {
21279 pub fn SteamAPI_ISteamClient_GetISteamUGC(
21280 self_: *mut ISteamClient,
21281 hSteamUser: HSteamUser,
21282 hSteamPipe: HSteamPipe,
21283 pchVersion: *const ::std::os::raw::c_char,
21284 ) -> *mut ISteamUGC;
21285}
21286extern "C" {
21287 pub fn SteamAPI_ISteamClient_GetISteamMusic(
21288 self_: *mut ISteamClient,
21289 hSteamuser: HSteamUser,
21290 hSteamPipe: HSteamPipe,
21291 pchVersion: *const ::std::os::raw::c_char,
21292 ) -> *mut ISteamMusic;
21293}
21294extern "C" {
21295 pub fn SteamAPI_ISteamClient_GetISteamHTMLSurface(
21296 self_: *mut ISteamClient,
21297 hSteamuser: HSteamUser,
21298 hSteamPipe: HSteamPipe,
21299 pchVersion: *const ::std::os::raw::c_char,
21300 ) -> *mut ISteamHTMLSurface;
21301}
21302extern "C" {
21303 pub fn SteamAPI_ISteamClient_GetISteamInventory(
21304 self_: *mut ISteamClient,
21305 hSteamuser: HSteamUser,
21306 hSteamPipe: HSteamPipe,
21307 pchVersion: *const ::std::os::raw::c_char,
21308 ) -> *mut ISteamInventory;
21309}
21310extern "C" {
21311 pub fn SteamAPI_ISteamClient_GetISteamVideo(
21312 self_: *mut ISteamClient,
21313 hSteamuser: HSteamUser,
21314 hSteamPipe: HSteamPipe,
21315 pchVersion: *const ::std::os::raw::c_char,
21316 ) -> *mut ISteamVideo;
21317}
21318extern "C" {
21319 pub fn SteamAPI_ISteamClient_GetISteamParentalSettings(
21320 self_: *mut ISteamClient,
21321 hSteamuser: HSteamUser,
21322 hSteamPipe: HSteamPipe,
21323 pchVersion: *const ::std::os::raw::c_char,
21324 ) -> *mut ISteamParentalSettings;
21325}
21326extern "C" {
21327 pub fn SteamAPI_ISteamClient_GetISteamInput(
21328 self_: *mut ISteamClient,
21329 hSteamUser: HSteamUser,
21330 hSteamPipe: HSteamPipe,
21331 pchVersion: *const ::std::os::raw::c_char,
21332 ) -> *mut ISteamInput;
21333}
21334extern "C" {
21335 pub fn SteamAPI_ISteamClient_GetISteamParties(
21336 self_: *mut ISteamClient,
21337 hSteamUser: HSteamUser,
21338 hSteamPipe: HSteamPipe,
21339 pchVersion: *const ::std::os::raw::c_char,
21340 ) -> *mut ISteamParties;
21341}
21342extern "C" {
21343 pub fn SteamAPI_ISteamClient_GetISteamRemotePlay(
21344 self_: *mut ISteamClient,
21345 hSteamUser: HSteamUser,
21346 hSteamPipe: HSteamPipe,
21347 pchVersion: *const ::std::os::raw::c_char,
21348 ) -> *mut ISteamRemotePlay;
21349}
21350extern "C" {
21351 pub fn SteamAPI_SteamUser_v023() -> *mut ISteamUser;
21352}
21353extern "C" {
21354 pub fn SteamAPI_ISteamUser_GetHSteamUser(self_: *mut ISteamUser) -> HSteamUser;
21355}
21356extern "C" {
21357 pub fn SteamAPI_ISteamUser_BLoggedOn(self_: *mut ISteamUser) -> bool;
21358}
21359extern "C" {
21360 pub fn SteamAPI_ISteamUser_GetSteamID(self_: *mut ISteamUser) -> uint64_steamid;
21361}
21362extern "C" {
21363 pub fn SteamAPI_ISteamUser_InitiateGameConnection_DEPRECATED(
21364 self_: *mut ISteamUser,
21365 pAuthBlob: *mut ::std::os::raw::c_void,
21366 cbMaxAuthBlob: ::std::os::raw::c_int,
21367 steamIDGameServer: uint64_steamid,
21368 unIPServer: uint32,
21369 usPortServer: uint16,
21370 bSecure: bool,
21371 ) -> ::std::os::raw::c_int;
21372}
21373extern "C" {
21374 pub fn SteamAPI_ISteamUser_TerminateGameConnection_DEPRECATED(
21375 self_: *mut ISteamUser,
21376 unIPServer: uint32,
21377 usPortServer: uint16,
21378 );
21379}
21380extern "C" {
21381 pub fn SteamAPI_ISteamUser_TrackAppUsageEvent(
21382 self_: *mut ISteamUser,
21383 gameID: uint64_gameid,
21384 eAppUsageEvent: ::std::os::raw::c_int,
21385 pchExtraInfo: *const ::std::os::raw::c_char,
21386 );
21387}
21388extern "C" {
21389 pub fn SteamAPI_ISteamUser_GetUserDataFolder(
21390 self_: *mut ISteamUser,
21391 pchBuffer: *mut ::std::os::raw::c_char,
21392 cubBuffer: ::std::os::raw::c_int,
21393 ) -> bool;
21394}
21395extern "C" {
21396 pub fn SteamAPI_ISteamUser_StartVoiceRecording(self_: *mut ISteamUser);
21397}
21398extern "C" {
21399 pub fn SteamAPI_ISteamUser_StopVoiceRecording(self_: *mut ISteamUser);
21400}
21401extern "C" {
21402 pub fn SteamAPI_ISteamUser_GetAvailableVoice(
21403 self_: *mut ISteamUser,
21404 pcbCompressed: *mut uint32,
21405 pcbUncompressed_Deprecated: *mut uint32,
21406 nUncompressedVoiceDesiredSampleRate_Deprecated: uint32,
21407 ) -> EVoiceResult;
21408}
21409extern "C" {
21410 pub fn SteamAPI_ISteamUser_GetVoice(
21411 self_: *mut ISteamUser,
21412 bWantCompressed: bool,
21413 pDestBuffer: *mut ::std::os::raw::c_void,
21414 cbDestBufferSize: uint32,
21415 nBytesWritten: *mut uint32,
21416 bWantUncompressed_Deprecated: bool,
21417 pUncompressedDestBuffer_Deprecated: *mut ::std::os::raw::c_void,
21418 cbUncompressedDestBufferSize_Deprecated: uint32,
21419 nUncompressBytesWritten_Deprecated: *mut uint32,
21420 nUncompressedVoiceDesiredSampleRate_Deprecated: uint32,
21421 ) -> EVoiceResult;
21422}
21423extern "C" {
21424 pub fn SteamAPI_ISteamUser_DecompressVoice(
21425 self_: *mut ISteamUser,
21426 pCompressed: *const ::std::os::raw::c_void,
21427 cbCompressed: uint32,
21428 pDestBuffer: *mut ::std::os::raw::c_void,
21429 cbDestBufferSize: uint32,
21430 nBytesWritten: *mut uint32,
21431 nDesiredSampleRate: uint32,
21432 ) -> EVoiceResult;
21433}
21434extern "C" {
21435 pub fn SteamAPI_ISteamUser_GetVoiceOptimalSampleRate(self_: *mut ISteamUser) -> uint32;
21436}
21437extern "C" {
21438 pub fn SteamAPI_ISteamUser_GetAuthSessionTicket(
21439 self_: *mut ISteamUser,
21440 pTicket: *mut ::std::os::raw::c_void,
21441 cbMaxTicket: ::std::os::raw::c_int,
21442 pcbTicket: *mut uint32,
21443 pSteamNetworkingIdentity: *const SteamNetworkingIdentity,
21444 ) -> HAuthTicket;
21445}
21446extern "C" {
21447 pub fn SteamAPI_ISteamUser_GetAuthTicketForWebApi(
21448 self_: *mut ISteamUser,
21449 pchIdentity: *const ::std::os::raw::c_char,
21450 ) -> HAuthTicket;
21451}
21452extern "C" {
21453 pub fn SteamAPI_ISteamUser_BeginAuthSession(
21454 self_: *mut ISteamUser,
21455 pAuthTicket: *const ::std::os::raw::c_void,
21456 cbAuthTicket: ::std::os::raw::c_int,
21457 steamID: uint64_steamid,
21458 ) -> EBeginAuthSessionResult;
21459}
21460extern "C" {
21461 pub fn SteamAPI_ISteamUser_EndAuthSession(self_: *mut ISteamUser, steamID: uint64_steamid);
21462}
21463extern "C" {
21464 pub fn SteamAPI_ISteamUser_CancelAuthTicket(self_: *mut ISteamUser, hAuthTicket: HAuthTicket);
21465}
21466extern "C" {
21467 pub fn SteamAPI_ISteamUser_UserHasLicenseForApp(
21468 self_: *mut ISteamUser,
21469 steamID: uint64_steamid,
21470 appID: AppId_t,
21471 ) -> EUserHasLicenseForAppResult;
21472}
21473extern "C" {
21474 pub fn SteamAPI_ISteamUser_BIsBehindNAT(self_: *mut ISteamUser) -> bool;
21475}
21476extern "C" {
21477 pub fn SteamAPI_ISteamUser_AdvertiseGame(
21478 self_: *mut ISteamUser,
21479 steamIDGameServer: uint64_steamid,
21480 unIPServer: uint32,
21481 usPortServer: uint16,
21482 );
21483}
21484extern "C" {
21485 pub fn SteamAPI_ISteamUser_RequestEncryptedAppTicket(
21486 self_: *mut ISteamUser,
21487 pDataToInclude: *mut ::std::os::raw::c_void,
21488 cbDataToInclude: ::std::os::raw::c_int,
21489 ) -> SteamAPICall_t;
21490}
21491extern "C" {
21492 pub fn SteamAPI_ISteamUser_GetEncryptedAppTicket(
21493 self_: *mut ISteamUser,
21494 pTicket: *mut ::std::os::raw::c_void,
21495 cbMaxTicket: ::std::os::raw::c_int,
21496 pcbTicket: *mut uint32,
21497 ) -> bool;
21498}
21499extern "C" {
21500 pub fn SteamAPI_ISteamUser_GetGameBadgeLevel(
21501 self_: *mut ISteamUser,
21502 nSeries: ::std::os::raw::c_int,
21503 bFoil: bool,
21504 ) -> ::std::os::raw::c_int;
21505}
21506extern "C" {
21507 pub fn SteamAPI_ISteamUser_GetPlayerSteamLevel(self_: *mut ISteamUser)
21508 -> ::std::os::raw::c_int;
21509}
21510extern "C" {
21511 pub fn SteamAPI_ISteamUser_RequestStoreAuthURL(
21512 self_: *mut ISteamUser,
21513 pchRedirectURL: *const ::std::os::raw::c_char,
21514 ) -> SteamAPICall_t;
21515}
21516extern "C" {
21517 pub fn SteamAPI_ISteamUser_BIsPhoneVerified(self_: *mut ISteamUser) -> bool;
21518}
21519extern "C" {
21520 pub fn SteamAPI_ISteamUser_BIsTwoFactorEnabled(self_: *mut ISteamUser) -> bool;
21521}
21522extern "C" {
21523 pub fn SteamAPI_ISteamUser_BIsPhoneIdentifying(self_: *mut ISteamUser) -> bool;
21524}
21525extern "C" {
21526 pub fn SteamAPI_ISteamUser_BIsPhoneRequiringVerification(self_: *mut ISteamUser) -> bool;
21527}
21528extern "C" {
21529 pub fn SteamAPI_ISteamUser_GetMarketEligibility(self_: *mut ISteamUser) -> SteamAPICall_t;
21530}
21531extern "C" {
21532 pub fn SteamAPI_ISteamUser_GetDurationControl(self_: *mut ISteamUser) -> SteamAPICall_t;
21533}
21534extern "C" {
21535 pub fn SteamAPI_ISteamUser_BSetDurationControlOnlineState(
21536 self_: *mut ISteamUser,
21537 eNewState: EDurationControlOnlineState,
21538 ) -> bool;
21539}
21540extern "C" {
21541 pub fn SteamAPI_SteamFriends_v018() -> *mut ISteamFriends;
21542}
21543extern "C" {
21544 pub fn SteamAPI_ISteamFriends_GetPersonaName(
21545 self_: *mut ISteamFriends,
21546 ) -> *const ::std::os::raw::c_char;
21547}
21548extern "C" {
21549 pub fn SteamAPI_ISteamFriends_GetPersonaState(self_: *mut ISteamFriends) -> EPersonaState;
21550}
21551extern "C" {
21552 pub fn SteamAPI_ISteamFriends_GetFriendCount(
21553 self_: *mut ISteamFriends,
21554 iFriendFlags: ::std::os::raw::c_int,
21555 ) -> ::std::os::raw::c_int;
21556}
21557extern "C" {
21558 pub fn SteamAPI_ISteamFriends_GetFriendByIndex(
21559 self_: *mut ISteamFriends,
21560 iFriend: ::std::os::raw::c_int,
21561 iFriendFlags: ::std::os::raw::c_int,
21562 ) -> uint64_steamid;
21563}
21564extern "C" {
21565 pub fn SteamAPI_ISteamFriends_GetFriendRelationship(
21566 self_: *mut ISteamFriends,
21567 steamIDFriend: uint64_steamid,
21568 ) -> EFriendRelationship;
21569}
21570extern "C" {
21571 pub fn SteamAPI_ISteamFriends_GetFriendPersonaState(
21572 self_: *mut ISteamFriends,
21573 steamIDFriend: uint64_steamid,
21574 ) -> EPersonaState;
21575}
21576extern "C" {
21577 pub fn SteamAPI_ISteamFriends_GetFriendPersonaName(
21578 self_: *mut ISteamFriends,
21579 steamIDFriend: uint64_steamid,
21580 ) -> *const ::std::os::raw::c_char;
21581}
21582extern "C" {
21583 pub fn SteamAPI_ISteamFriends_GetFriendGamePlayed(
21584 self_: *mut ISteamFriends,
21585 steamIDFriend: uint64_steamid,
21586 pFriendGameInfo: *mut FriendGameInfo_t,
21587 ) -> bool;
21588}
21589extern "C" {
21590 pub fn SteamAPI_ISteamFriends_GetFriendPersonaNameHistory(
21591 self_: *mut ISteamFriends,
21592 steamIDFriend: uint64_steamid,
21593 iPersonaName: ::std::os::raw::c_int,
21594 ) -> *const ::std::os::raw::c_char;
21595}
21596extern "C" {
21597 pub fn SteamAPI_ISteamFriends_GetFriendSteamLevel(
21598 self_: *mut ISteamFriends,
21599 steamIDFriend: uint64_steamid,
21600 ) -> ::std::os::raw::c_int;
21601}
21602extern "C" {
21603 pub fn SteamAPI_ISteamFriends_GetPlayerNickname(
21604 self_: *mut ISteamFriends,
21605 steamIDPlayer: uint64_steamid,
21606 ) -> *const ::std::os::raw::c_char;
21607}
21608extern "C" {
21609 pub fn SteamAPI_ISteamFriends_GetFriendsGroupCount(
21610 self_: *mut ISteamFriends,
21611 ) -> ::std::os::raw::c_int;
21612}
21613extern "C" {
21614 pub fn SteamAPI_ISteamFriends_GetFriendsGroupIDByIndex(
21615 self_: *mut ISteamFriends,
21616 iFG: ::std::os::raw::c_int,
21617 ) -> FriendsGroupID_t;
21618}
21619extern "C" {
21620 pub fn SteamAPI_ISteamFriends_GetFriendsGroupName(
21621 self_: *mut ISteamFriends,
21622 friendsGroupID: FriendsGroupID_t,
21623 ) -> *const ::std::os::raw::c_char;
21624}
21625extern "C" {
21626 pub fn SteamAPI_ISteamFriends_GetFriendsGroupMembersCount(
21627 self_: *mut ISteamFriends,
21628 friendsGroupID: FriendsGroupID_t,
21629 ) -> ::std::os::raw::c_int;
21630}
21631extern "C" {
21632 pub fn SteamAPI_ISteamFriends_GetFriendsGroupMembersList(
21633 self_: *mut ISteamFriends,
21634 friendsGroupID: FriendsGroupID_t,
21635 pOutSteamIDMembers: *mut CSteamID,
21636 nMembersCount: ::std::os::raw::c_int,
21637 );
21638}
21639extern "C" {
21640 pub fn SteamAPI_ISteamFriends_HasFriend(
21641 self_: *mut ISteamFriends,
21642 steamIDFriend: uint64_steamid,
21643 iFriendFlags: ::std::os::raw::c_int,
21644 ) -> bool;
21645}
21646extern "C" {
21647 pub fn SteamAPI_ISteamFriends_GetClanCount(self_: *mut ISteamFriends) -> ::std::os::raw::c_int;
21648}
21649extern "C" {
21650 pub fn SteamAPI_ISteamFriends_GetClanByIndex(
21651 self_: *mut ISteamFriends,
21652 iClan: ::std::os::raw::c_int,
21653 ) -> uint64_steamid;
21654}
21655extern "C" {
21656 pub fn SteamAPI_ISteamFriends_GetClanName(
21657 self_: *mut ISteamFriends,
21658 steamIDClan: uint64_steamid,
21659 ) -> *const ::std::os::raw::c_char;
21660}
21661extern "C" {
21662 pub fn SteamAPI_ISteamFriends_GetClanTag(
21663 self_: *mut ISteamFriends,
21664 steamIDClan: uint64_steamid,
21665 ) -> *const ::std::os::raw::c_char;
21666}
21667extern "C" {
21668 pub fn SteamAPI_ISteamFriends_GetClanActivityCounts(
21669 self_: *mut ISteamFriends,
21670 steamIDClan: uint64_steamid,
21671 pnOnline: *mut ::std::os::raw::c_int,
21672 pnInGame: *mut ::std::os::raw::c_int,
21673 pnChatting: *mut ::std::os::raw::c_int,
21674 ) -> bool;
21675}
21676extern "C" {
21677 pub fn SteamAPI_ISteamFriends_DownloadClanActivityCounts(
21678 self_: *mut ISteamFriends,
21679 psteamIDClans: *mut CSteamID,
21680 cClansToRequest: ::std::os::raw::c_int,
21681 ) -> SteamAPICall_t;
21682}
21683extern "C" {
21684 pub fn SteamAPI_ISteamFriends_GetFriendCountFromSource(
21685 self_: *mut ISteamFriends,
21686 steamIDSource: uint64_steamid,
21687 ) -> ::std::os::raw::c_int;
21688}
21689extern "C" {
21690 pub fn SteamAPI_ISteamFriends_GetFriendFromSourceByIndex(
21691 self_: *mut ISteamFriends,
21692 steamIDSource: uint64_steamid,
21693 iFriend: ::std::os::raw::c_int,
21694 ) -> uint64_steamid;
21695}
21696extern "C" {
21697 pub fn SteamAPI_ISteamFriends_IsUserInSource(
21698 self_: *mut ISteamFriends,
21699 steamIDUser: uint64_steamid,
21700 steamIDSource: uint64_steamid,
21701 ) -> bool;
21702}
21703extern "C" {
21704 pub fn SteamAPI_ISteamFriends_SetInGameVoiceSpeaking(
21705 self_: *mut ISteamFriends,
21706 steamIDUser: uint64_steamid,
21707 bSpeaking: bool,
21708 );
21709}
21710extern "C" {
21711 pub fn SteamAPI_ISteamFriends_ActivateGameOverlay(
21712 self_: *mut ISteamFriends,
21713 pchDialog: *const ::std::os::raw::c_char,
21714 );
21715}
21716extern "C" {
21717 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayToUser(
21718 self_: *mut ISteamFriends,
21719 pchDialog: *const ::std::os::raw::c_char,
21720 steamID: uint64_steamid,
21721 );
21722}
21723extern "C" {
21724 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayToWebPage(
21725 self_: *mut ISteamFriends,
21726 pchURL: *const ::std::os::raw::c_char,
21727 eMode: EActivateGameOverlayToWebPageMode,
21728 );
21729}
21730extern "C" {
21731 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayToStore(
21732 self_: *mut ISteamFriends,
21733 nAppID: AppId_t,
21734 eFlag: EOverlayToStoreFlag,
21735 );
21736}
21737extern "C" {
21738 pub fn SteamAPI_ISteamFriends_SetPlayedWith(
21739 self_: *mut ISteamFriends,
21740 steamIDUserPlayedWith: uint64_steamid,
21741 );
21742}
21743extern "C" {
21744 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialog(
21745 self_: *mut ISteamFriends,
21746 steamIDLobby: uint64_steamid,
21747 );
21748}
21749extern "C" {
21750 pub fn SteamAPI_ISteamFriends_GetSmallFriendAvatar(
21751 self_: *mut ISteamFriends,
21752 steamIDFriend: uint64_steamid,
21753 ) -> ::std::os::raw::c_int;
21754}
21755extern "C" {
21756 pub fn SteamAPI_ISteamFriends_GetMediumFriendAvatar(
21757 self_: *mut ISteamFriends,
21758 steamIDFriend: uint64_steamid,
21759 ) -> ::std::os::raw::c_int;
21760}
21761extern "C" {
21762 pub fn SteamAPI_ISteamFriends_GetLargeFriendAvatar(
21763 self_: *mut ISteamFriends,
21764 steamIDFriend: uint64_steamid,
21765 ) -> ::std::os::raw::c_int;
21766}
21767extern "C" {
21768 pub fn SteamAPI_ISteamFriends_RequestUserInformation(
21769 self_: *mut ISteamFriends,
21770 steamIDUser: uint64_steamid,
21771 bRequireNameOnly: bool,
21772 ) -> bool;
21773}
21774extern "C" {
21775 pub fn SteamAPI_ISteamFriends_RequestClanOfficerList(
21776 self_: *mut ISteamFriends,
21777 steamIDClan: uint64_steamid,
21778 ) -> SteamAPICall_t;
21779}
21780extern "C" {
21781 pub fn SteamAPI_ISteamFriends_GetClanOwner(
21782 self_: *mut ISteamFriends,
21783 steamIDClan: uint64_steamid,
21784 ) -> uint64_steamid;
21785}
21786extern "C" {
21787 pub fn SteamAPI_ISteamFriends_GetClanOfficerCount(
21788 self_: *mut ISteamFriends,
21789 steamIDClan: uint64_steamid,
21790 ) -> ::std::os::raw::c_int;
21791}
21792extern "C" {
21793 pub fn SteamAPI_ISteamFriends_GetClanOfficerByIndex(
21794 self_: *mut ISteamFriends,
21795 steamIDClan: uint64_steamid,
21796 iOfficer: ::std::os::raw::c_int,
21797 ) -> uint64_steamid;
21798}
21799extern "C" {
21800 pub fn SteamAPI_ISteamFriends_SetRichPresence(
21801 self_: *mut ISteamFriends,
21802 pchKey: *const ::std::os::raw::c_char,
21803 pchValue: *const ::std::os::raw::c_char,
21804 ) -> bool;
21805}
21806extern "C" {
21807 pub fn SteamAPI_ISteamFriends_ClearRichPresence(self_: *mut ISteamFriends);
21808}
21809extern "C" {
21810 pub fn SteamAPI_ISteamFriends_GetFriendRichPresence(
21811 self_: *mut ISteamFriends,
21812 steamIDFriend: uint64_steamid,
21813 pchKey: *const ::std::os::raw::c_char,
21814 ) -> *const ::std::os::raw::c_char;
21815}
21816extern "C" {
21817 pub fn SteamAPI_ISteamFriends_GetFriendRichPresenceKeyCount(
21818 self_: *mut ISteamFriends,
21819 steamIDFriend: uint64_steamid,
21820 ) -> ::std::os::raw::c_int;
21821}
21822extern "C" {
21823 pub fn SteamAPI_ISteamFriends_GetFriendRichPresenceKeyByIndex(
21824 self_: *mut ISteamFriends,
21825 steamIDFriend: uint64_steamid,
21826 iKey: ::std::os::raw::c_int,
21827 ) -> *const ::std::os::raw::c_char;
21828}
21829extern "C" {
21830 pub fn SteamAPI_ISteamFriends_RequestFriendRichPresence(
21831 self_: *mut ISteamFriends,
21832 steamIDFriend: uint64_steamid,
21833 );
21834}
21835extern "C" {
21836 pub fn SteamAPI_ISteamFriends_InviteUserToGame(
21837 self_: *mut ISteamFriends,
21838 steamIDFriend: uint64_steamid,
21839 pchConnectString: *const ::std::os::raw::c_char,
21840 ) -> bool;
21841}
21842extern "C" {
21843 pub fn SteamAPI_ISteamFriends_GetCoplayFriendCount(
21844 self_: *mut ISteamFriends,
21845 ) -> ::std::os::raw::c_int;
21846}
21847extern "C" {
21848 pub fn SteamAPI_ISteamFriends_GetCoplayFriend(
21849 self_: *mut ISteamFriends,
21850 iCoplayFriend: ::std::os::raw::c_int,
21851 ) -> uint64_steamid;
21852}
21853extern "C" {
21854 pub fn SteamAPI_ISteamFriends_GetFriendCoplayTime(
21855 self_: *mut ISteamFriends,
21856 steamIDFriend: uint64_steamid,
21857 ) -> ::std::os::raw::c_int;
21858}
21859extern "C" {
21860 pub fn SteamAPI_ISteamFriends_GetFriendCoplayGame(
21861 self_: *mut ISteamFriends,
21862 steamIDFriend: uint64_steamid,
21863 ) -> AppId_t;
21864}
21865extern "C" {
21866 pub fn SteamAPI_ISteamFriends_JoinClanChatRoom(
21867 self_: *mut ISteamFriends,
21868 steamIDClan: uint64_steamid,
21869 ) -> SteamAPICall_t;
21870}
21871extern "C" {
21872 pub fn SteamAPI_ISteamFriends_LeaveClanChatRoom(
21873 self_: *mut ISteamFriends,
21874 steamIDClan: uint64_steamid,
21875 ) -> bool;
21876}
21877extern "C" {
21878 pub fn SteamAPI_ISteamFriends_GetClanChatMemberCount(
21879 self_: *mut ISteamFriends,
21880 steamIDClan: uint64_steamid,
21881 ) -> ::std::os::raw::c_int;
21882}
21883extern "C" {
21884 pub fn SteamAPI_ISteamFriends_GetChatMemberByIndex(
21885 self_: *mut ISteamFriends,
21886 steamIDClan: uint64_steamid,
21887 iUser: ::std::os::raw::c_int,
21888 ) -> uint64_steamid;
21889}
21890extern "C" {
21891 pub fn SteamAPI_ISteamFriends_SendClanChatMessage(
21892 self_: *mut ISteamFriends,
21893 steamIDClanChat: uint64_steamid,
21894 pchText: *const ::std::os::raw::c_char,
21895 ) -> bool;
21896}
21897extern "C" {
21898 pub fn SteamAPI_ISteamFriends_GetClanChatMessage(
21899 self_: *mut ISteamFriends,
21900 steamIDClanChat: uint64_steamid,
21901 iMessage: ::std::os::raw::c_int,
21902 prgchText: *mut ::std::os::raw::c_void,
21903 cchTextMax: ::std::os::raw::c_int,
21904 peChatEntryType: *mut EChatEntryType,
21905 psteamidChatter: *mut CSteamID,
21906 ) -> ::std::os::raw::c_int;
21907}
21908extern "C" {
21909 pub fn SteamAPI_ISteamFriends_IsClanChatAdmin(
21910 self_: *mut ISteamFriends,
21911 steamIDClanChat: uint64_steamid,
21912 steamIDUser: uint64_steamid,
21913 ) -> bool;
21914}
21915extern "C" {
21916 pub fn SteamAPI_ISteamFriends_IsClanChatWindowOpenInSteam(
21917 self_: *mut ISteamFriends,
21918 steamIDClanChat: uint64_steamid,
21919 ) -> bool;
21920}
21921extern "C" {
21922 pub fn SteamAPI_ISteamFriends_OpenClanChatWindowInSteam(
21923 self_: *mut ISteamFriends,
21924 steamIDClanChat: uint64_steamid,
21925 ) -> bool;
21926}
21927extern "C" {
21928 pub fn SteamAPI_ISteamFriends_CloseClanChatWindowInSteam(
21929 self_: *mut ISteamFriends,
21930 steamIDClanChat: uint64_steamid,
21931 ) -> bool;
21932}
21933extern "C" {
21934 pub fn SteamAPI_ISteamFriends_SetListenForFriendsMessages(
21935 self_: *mut ISteamFriends,
21936 bInterceptEnabled: bool,
21937 ) -> bool;
21938}
21939extern "C" {
21940 pub fn SteamAPI_ISteamFriends_ReplyToFriendMessage(
21941 self_: *mut ISteamFriends,
21942 steamIDFriend: uint64_steamid,
21943 pchMsgToSend: *const ::std::os::raw::c_char,
21944 ) -> bool;
21945}
21946extern "C" {
21947 pub fn SteamAPI_ISteamFriends_GetFriendMessage(
21948 self_: *mut ISteamFriends,
21949 steamIDFriend: uint64_steamid,
21950 iMessageID: ::std::os::raw::c_int,
21951 pvData: *mut ::std::os::raw::c_void,
21952 cubData: ::std::os::raw::c_int,
21953 peChatEntryType: *mut EChatEntryType,
21954 ) -> ::std::os::raw::c_int;
21955}
21956extern "C" {
21957 pub fn SteamAPI_ISteamFriends_GetFollowerCount(
21958 self_: *mut ISteamFriends,
21959 steamID: uint64_steamid,
21960 ) -> SteamAPICall_t;
21961}
21962extern "C" {
21963 pub fn SteamAPI_ISteamFriends_IsFollowing(
21964 self_: *mut ISteamFriends,
21965 steamID: uint64_steamid,
21966 ) -> SteamAPICall_t;
21967}
21968extern "C" {
21969 pub fn SteamAPI_ISteamFriends_EnumerateFollowingList(
21970 self_: *mut ISteamFriends,
21971 unStartIndex: uint32,
21972 ) -> SteamAPICall_t;
21973}
21974extern "C" {
21975 pub fn SteamAPI_ISteamFriends_IsClanPublic(
21976 self_: *mut ISteamFriends,
21977 steamIDClan: uint64_steamid,
21978 ) -> bool;
21979}
21980extern "C" {
21981 pub fn SteamAPI_ISteamFriends_IsClanOfficialGameGroup(
21982 self_: *mut ISteamFriends,
21983 steamIDClan: uint64_steamid,
21984 ) -> bool;
21985}
21986extern "C" {
21987 pub fn SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages(
21988 self_: *mut ISteamFriends,
21989 ) -> ::std::os::raw::c_int;
21990}
21991extern "C" {
21992 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog(
21993 self_: *mut ISteamFriends,
21994 steamIDLobby: uint64_steamid,
21995 );
21996}
21997extern "C" {
21998 pub fn SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser(
21999 self_: *mut ISteamFriends,
22000 pchProtocol: *const ::std::os::raw::c_char,
22001 ) -> bool;
22002}
22003extern "C" {
22004 pub fn SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString(
22005 self_: *mut ISteamFriends,
22006 pchConnectString: *const ::std::os::raw::c_char,
22007 );
22008}
22009extern "C" {
22010 pub fn SteamAPI_ISteamFriends_RequestEquippedProfileItems(
22011 self_: *mut ISteamFriends,
22012 steamID: uint64_steamid,
22013 ) -> SteamAPICall_t;
22014}
22015extern "C" {
22016 pub fn SteamAPI_ISteamFriends_BHasEquippedProfileItem(
22017 self_: *mut ISteamFriends,
22018 steamID: uint64_steamid,
22019 itemType: ECommunityProfileItemType,
22020 ) -> bool;
22021}
22022extern "C" {
22023 pub fn SteamAPI_ISteamFriends_GetProfileItemPropertyString(
22024 self_: *mut ISteamFriends,
22025 steamID: uint64_steamid,
22026 itemType: ECommunityProfileItemType,
22027 prop: ECommunityProfileItemProperty,
22028 ) -> *const ::std::os::raw::c_char;
22029}
22030extern "C" {
22031 pub fn SteamAPI_ISteamFriends_GetProfileItemPropertyUint(
22032 self_: *mut ISteamFriends,
22033 steamID: uint64_steamid,
22034 itemType: ECommunityProfileItemType,
22035 prop: ECommunityProfileItemProperty,
22036 ) -> uint32;
22037}
22038extern "C" {
22039 pub fn SteamAPI_SteamUtils_v010() -> *mut ISteamUtils;
22040}
22041extern "C" {
22042 pub fn SteamAPI_SteamGameServerUtils_v010() -> *mut ISteamUtils;
22043}
22044extern "C" {
22045 pub fn SteamAPI_ISteamUtils_GetSecondsSinceAppActive(self_: *mut ISteamUtils) -> uint32;
22046}
22047extern "C" {
22048 pub fn SteamAPI_ISteamUtils_GetSecondsSinceComputerActive(self_: *mut ISteamUtils) -> uint32;
22049}
22050extern "C" {
22051 pub fn SteamAPI_ISteamUtils_GetConnectedUniverse(self_: *mut ISteamUtils) -> EUniverse;
22052}
22053extern "C" {
22054 pub fn SteamAPI_ISteamUtils_GetServerRealTime(self_: *mut ISteamUtils) -> uint32;
22055}
22056extern "C" {
22057 pub fn SteamAPI_ISteamUtils_GetIPCountry(
22058 self_: *mut ISteamUtils,
22059 ) -> *const ::std::os::raw::c_char;
22060}
22061extern "C" {
22062 pub fn SteamAPI_ISteamUtils_GetImageSize(
22063 self_: *mut ISteamUtils,
22064 iImage: ::std::os::raw::c_int,
22065 pnWidth: *mut uint32,
22066 pnHeight: *mut uint32,
22067 ) -> bool;
22068}
22069extern "C" {
22070 pub fn SteamAPI_ISteamUtils_GetImageRGBA(
22071 self_: *mut ISteamUtils,
22072 iImage: ::std::os::raw::c_int,
22073 pubDest: *mut uint8,
22074 nDestBufferSize: ::std::os::raw::c_int,
22075 ) -> bool;
22076}
22077extern "C" {
22078 pub fn SteamAPI_ISteamUtils_GetCurrentBatteryPower(self_: *mut ISteamUtils) -> uint8;
22079}
22080extern "C" {
22081 pub fn SteamAPI_ISteamUtils_GetAppID(self_: *mut ISteamUtils) -> uint32;
22082}
22083extern "C" {
22084 pub fn SteamAPI_ISteamUtils_SetOverlayNotificationPosition(
22085 self_: *mut ISteamUtils,
22086 eNotificationPosition: ENotificationPosition,
22087 );
22088}
22089extern "C" {
22090 pub fn SteamAPI_ISteamUtils_IsAPICallCompleted(
22091 self_: *mut ISteamUtils,
22092 hSteamAPICall: SteamAPICall_t,
22093 pbFailed: *mut bool,
22094 ) -> bool;
22095}
22096extern "C" {
22097 pub fn SteamAPI_ISteamUtils_GetAPICallFailureReason(
22098 self_: *mut ISteamUtils,
22099 hSteamAPICall: SteamAPICall_t,
22100 ) -> ESteamAPICallFailure;
22101}
22102extern "C" {
22103 pub fn SteamAPI_ISteamUtils_GetAPICallResult(
22104 self_: *mut ISteamUtils,
22105 hSteamAPICall: SteamAPICall_t,
22106 pCallback: *mut ::std::os::raw::c_void,
22107 cubCallback: ::std::os::raw::c_int,
22108 iCallbackExpected: ::std::os::raw::c_int,
22109 pbFailed: *mut bool,
22110 ) -> bool;
22111}
22112extern "C" {
22113 pub fn SteamAPI_ISteamUtils_GetIPCCallCount(self_: *mut ISteamUtils) -> uint32;
22114}
22115extern "C" {
22116 pub fn SteamAPI_ISteamUtils_SetWarningMessageHook(
22117 self_: *mut ISteamUtils,
22118 pFunction: SteamAPIWarningMessageHook_t,
22119 );
22120}
22121extern "C" {
22122 pub fn SteamAPI_ISteamUtils_IsOverlayEnabled(self_: *mut ISteamUtils) -> bool;
22123}
22124extern "C" {
22125 pub fn SteamAPI_ISteamUtils_BOverlayNeedsPresent(self_: *mut ISteamUtils) -> bool;
22126}
22127extern "C" {
22128 pub fn SteamAPI_ISteamUtils_CheckFileSignature(
22129 self_: *mut ISteamUtils,
22130 szFileName: *const ::std::os::raw::c_char,
22131 ) -> SteamAPICall_t;
22132}
22133extern "C" {
22134 pub fn SteamAPI_ISteamUtils_ShowGamepadTextInput(
22135 self_: *mut ISteamUtils,
22136 eInputMode: EGamepadTextInputMode,
22137 eLineInputMode: EGamepadTextInputLineMode,
22138 pchDescription: *const ::std::os::raw::c_char,
22139 unCharMax: uint32,
22140 pchExistingText: *const ::std::os::raw::c_char,
22141 ) -> bool;
22142}
22143extern "C" {
22144 pub fn SteamAPI_ISteamUtils_GetEnteredGamepadTextLength(self_: *mut ISteamUtils) -> uint32;
22145}
22146extern "C" {
22147 pub fn SteamAPI_ISteamUtils_GetEnteredGamepadTextInput(
22148 self_: *mut ISteamUtils,
22149 pchText: *mut ::std::os::raw::c_char,
22150 cchText: uint32,
22151 ) -> bool;
22152}
22153extern "C" {
22154 pub fn SteamAPI_ISteamUtils_GetSteamUILanguage(
22155 self_: *mut ISteamUtils,
22156 ) -> *const ::std::os::raw::c_char;
22157}
22158extern "C" {
22159 pub fn SteamAPI_ISteamUtils_IsSteamRunningInVR(self_: *mut ISteamUtils) -> bool;
22160}
22161extern "C" {
22162 pub fn SteamAPI_ISteamUtils_SetOverlayNotificationInset(
22163 self_: *mut ISteamUtils,
22164 nHorizontalInset: ::std::os::raw::c_int,
22165 nVerticalInset: ::std::os::raw::c_int,
22166 );
22167}
22168extern "C" {
22169 pub fn SteamAPI_ISteamUtils_IsSteamInBigPictureMode(self_: *mut ISteamUtils) -> bool;
22170}
22171extern "C" {
22172 pub fn SteamAPI_ISteamUtils_StartVRDashboard(self_: *mut ISteamUtils);
22173}
22174extern "C" {
22175 pub fn SteamAPI_ISteamUtils_IsVRHeadsetStreamingEnabled(self_: *mut ISteamUtils) -> bool;
22176}
22177extern "C" {
22178 pub fn SteamAPI_ISteamUtils_SetVRHeadsetStreamingEnabled(
22179 self_: *mut ISteamUtils,
22180 bEnabled: bool,
22181 );
22182}
22183extern "C" {
22184 pub fn SteamAPI_ISteamUtils_IsSteamChinaLauncher(self_: *mut ISteamUtils) -> bool;
22185}
22186extern "C" {
22187 pub fn SteamAPI_ISteamUtils_InitFilterText(
22188 self_: *mut ISteamUtils,
22189 unFilterOptions: uint32,
22190 ) -> bool;
22191}
22192extern "C" {
22193 pub fn SteamAPI_ISteamUtils_FilterText(
22194 self_: *mut ISteamUtils,
22195 eContext: ETextFilteringContext,
22196 sourceSteamID: uint64_steamid,
22197 pchInputMessage: *const ::std::os::raw::c_char,
22198 pchOutFilteredText: *mut ::std::os::raw::c_char,
22199 nByteSizeOutFilteredText: uint32,
22200 ) -> ::std::os::raw::c_int;
22201}
22202extern "C" {
22203 pub fn SteamAPI_ISteamUtils_GetIPv6ConnectivityState(
22204 self_: *mut ISteamUtils,
22205 eProtocol: ESteamIPv6ConnectivityProtocol,
22206 ) -> ESteamIPv6ConnectivityState;
22207}
22208extern "C" {
22209 pub fn SteamAPI_ISteamUtils_IsSteamRunningOnSteamDeck(self_: *mut ISteamUtils) -> bool;
22210}
22211extern "C" {
22212 pub fn SteamAPI_ISteamUtils_ShowFloatingGamepadTextInput(
22213 self_: *mut ISteamUtils,
22214 eKeyboardMode: EFloatingGamepadTextInputMode,
22215 nTextFieldXPosition: ::std::os::raw::c_int,
22216 nTextFieldYPosition: ::std::os::raw::c_int,
22217 nTextFieldWidth: ::std::os::raw::c_int,
22218 nTextFieldHeight: ::std::os::raw::c_int,
22219 ) -> bool;
22220}
22221extern "C" {
22222 pub fn SteamAPI_ISteamUtils_SetGameLauncherMode(self_: *mut ISteamUtils, bLauncherMode: bool);
22223}
22224extern "C" {
22225 pub fn SteamAPI_ISteamUtils_DismissFloatingGamepadTextInput(self_: *mut ISteamUtils) -> bool;
22226}
22227extern "C" {
22228 pub fn SteamAPI_ISteamUtils_DismissGamepadTextInput(self_: *mut ISteamUtils) -> bool;
22229}
22230extern "C" {
22231 pub fn SteamAPI_SteamMatchmaking_v009() -> *mut ISteamMatchmaking;
22232}
22233extern "C" {
22234 pub fn SteamAPI_ISteamMatchmaking_GetFavoriteGameCount(
22235 self_: *mut ISteamMatchmaking,
22236 ) -> ::std::os::raw::c_int;
22237}
22238extern "C" {
22239 pub fn SteamAPI_ISteamMatchmaking_GetFavoriteGame(
22240 self_: *mut ISteamMatchmaking,
22241 iGame: ::std::os::raw::c_int,
22242 pnAppID: *mut AppId_t,
22243 pnIP: *mut uint32,
22244 pnConnPort: *mut uint16,
22245 pnQueryPort: *mut uint16,
22246 punFlags: *mut uint32,
22247 pRTime32LastPlayedOnServer: *mut uint32,
22248 ) -> bool;
22249}
22250extern "C" {
22251 pub fn SteamAPI_ISteamMatchmaking_AddFavoriteGame(
22252 self_: *mut ISteamMatchmaking,
22253 nAppID: AppId_t,
22254 nIP: uint32,
22255 nConnPort: uint16,
22256 nQueryPort: uint16,
22257 unFlags: uint32,
22258 rTime32LastPlayedOnServer: uint32,
22259 ) -> ::std::os::raw::c_int;
22260}
22261extern "C" {
22262 pub fn SteamAPI_ISteamMatchmaking_RemoveFavoriteGame(
22263 self_: *mut ISteamMatchmaking,
22264 nAppID: AppId_t,
22265 nIP: uint32,
22266 nConnPort: uint16,
22267 nQueryPort: uint16,
22268 unFlags: uint32,
22269 ) -> bool;
22270}
22271extern "C" {
22272 pub fn SteamAPI_ISteamMatchmaking_RequestLobbyList(
22273 self_: *mut ISteamMatchmaking,
22274 ) -> SteamAPICall_t;
22275}
22276extern "C" {
22277 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListStringFilter(
22278 self_: *mut ISteamMatchmaking,
22279 pchKeyToMatch: *const ::std::os::raw::c_char,
22280 pchValueToMatch: *const ::std::os::raw::c_char,
22281 eComparisonType: ELobbyComparison,
22282 );
22283}
22284extern "C" {
22285 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListNumericalFilter(
22286 self_: *mut ISteamMatchmaking,
22287 pchKeyToMatch: *const ::std::os::raw::c_char,
22288 nValueToMatch: ::std::os::raw::c_int,
22289 eComparisonType: ELobbyComparison,
22290 );
22291}
22292extern "C" {
22293 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListNearValueFilter(
22294 self_: *mut ISteamMatchmaking,
22295 pchKeyToMatch: *const ::std::os::raw::c_char,
22296 nValueToBeCloseTo: ::std::os::raw::c_int,
22297 );
22298}
22299extern "C" {
22300 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListFilterSlotsAvailable(
22301 self_: *mut ISteamMatchmaking,
22302 nSlotsAvailable: ::std::os::raw::c_int,
22303 );
22304}
22305extern "C" {
22306 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListDistanceFilter(
22307 self_: *mut ISteamMatchmaking,
22308 eLobbyDistanceFilter: ELobbyDistanceFilter,
22309 );
22310}
22311extern "C" {
22312 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListResultCountFilter(
22313 self_: *mut ISteamMatchmaking,
22314 cMaxResults: ::std::os::raw::c_int,
22315 );
22316}
22317extern "C" {
22318 pub fn SteamAPI_ISteamMatchmaking_AddRequestLobbyListCompatibleMembersFilter(
22319 self_: *mut ISteamMatchmaking,
22320 steamIDLobby: uint64_steamid,
22321 );
22322}
22323extern "C" {
22324 pub fn SteamAPI_ISteamMatchmaking_GetLobbyByIndex(
22325 self_: *mut ISteamMatchmaking,
22326 iLobby: ::std::os::raw::c_int,
22327 ) -> uint64_steamid;
22328}
22329extern "C" {
22330 pub fn SteamAPI_ISteamMatchmaking_CreateLobby(
22331 self_: *mut ISteamMatchmaking,
22332 eLobbyType: ELobbyType,
22333 cMaxMembers: ::std::os::raw::c_int,
22334 ) -> SteamAPICall_t;
22335}
22336extern "C" {
22337 pub fn SteamAPI_ISteamMatchmaking_JoinLobby(
22338 self_: *mut ISteamMatchmaking,
22339 steamIDLobby: uint64_steamid,
22340 ) -> SteamAPICall_t;
22341}
22342extern "C" {
22343 pub fn SteamAPI_ISteamMatchmaking_LeaveLobby(
22344 self_: *mut ISteamMatchmaking,
22345 steamIDLobby: uint64_steamid,
22346 );
22347}
22348extern "C" {
22349 pub fn SteamAPI_ISteamMatchmaking_InviteUserToLobby(
22350 self_: *mut ISteamMatchmaking,
22351 steamIDLobby: uint64_steamid,
22352 steamIDInvitee: uint64_steamid,
22353 ) -> bool;
22354}
22355extern "C" {
22356 pub fn SteamAPI_ISteamMatchmaking_GetNumLobbyMembers(
22357 self_: *mut ISteamMatchmaking,
22358 steamIDLobby: uint64_steamid,
22359 ) -> ::std::os::raw::c_int;
22360}
22361extern "C" {
22362 pub fn SteamAPI_ISteamMatchmaking_GetLobbyMemberByIndex(
22363 self_: *mut ISteamMatchmaking,
22364 steamIDLobby: uint64_steamid,
22365 iMember: ::std::os::raw::c_int,
22366 ) -> uint64_steamid;
22367}
22368extern "C" {
22369 pub fn SteamAPI_ISteamMatchmaking_GetLobbyData(
22370 self_: *mut ISteamMatchmaking,
22371 steamIDLobby: uint64_steamid,
22372 pchKey: *const ::std::os::raw::c_char,
22373 ) -> *const ::std::os::raw::c_char;
22374}
22375extern "C" {
22376 pub fn SteamAPI_ISteamMatchmaking_SetLobbyData(
22377 self_: *mut ISteamMatchmaking,
22378 steamIDLobby: uint64_steamid,
22379 pchKey: *const ::std::os::raw::c_char,
22380 pchValue: *const ::std::os::raw::c_char,
22381 ) -> bool;
22382}
22383extern "C" {
22384 pub fn SteamAPI_ISteamMatchmaking_GetLobbyDataCount(
22385 self_: *mut ISteamMatchmaking,
22386 steamIDLobby: uint64_steamid,
22387 ) -> ::std::os::raw::c_int;
22388}
22389extern "C" {
22390 pub fn SteamAPI_ISteamMatchmaking_GetLobbyDataByIndex(
22391 self_: *mut ISteamMatchmaking,
22392 steamIDLobby: uint64_steamid,
22393 iLobbyData: ::std::os::raw::c_int,
22394 pchKey: *mut ::std::os::raw::c_char,
22395 cchKeyBufferSize: ::std::os::raw::c_int,
22396 pchValue: *mut ::std::os::raw::c_char,
22397 cchValueBufferSize: ::std::os::raw::c_int,
22398 ) -> bool;
22399}
22400extern "C" {
22401 pub fn SteamAPI_ISteamMatchmaking_DeleteLobbyData(
22402 self_: *mut ISteamMatchmaking,
22403 steamIDLobby: uint64_steamid,
22404 pchKey: *const ::std::os::raw::c_char,
22405 ) -> bool;
22406}
22407extern "C" {
22408 pub fn SteamAPI_ISteamMatchmaking_GetLobbyMemberData(
22409 self_: *mut ISteamMatchmaking,
22410 steamIDLobby: uint64_steamid,
22411 steamIDUser: uint64_steamid,
22412 pchKey: *const ::std::os::raw::c_char,
22413 ) -> *const ::std::os::raw::c_char;
22414}
22415extern "C" {
22416 pub fn SteamAPI_ISteamMatchmaking_SetLobbyMemberData(
22417 self_: *mut ISteamMatchmaking,
22418 steamIDLobby: uint64_steamid,
22419 pchKey: *const ::std::os::raw::c_char,
22420 pchValue: *const ::std::os::raw::c_char,
22421 );
22422}
22423extern "C" {
22424 pub fn SteamAPI_ISteamMatchmaking_SendLobbyChatMsg(
22425 self_: *mut ISteamMatchmaking,
22426 steamIDLobby: uint64_steamid,
22427 pvMsgBody: *const ::std::os::raw::c_void,
22428 cubMsgBody: ::std::os::raw::c_int,
22429 ) -> bool;
22430}
22431extern "C" {
22432 pub fn SteamAPI_ISteamMatchmaking_GetLobbyChatEntry(
22433 self_: *mut ISteamMatchmaking,
22434 steamIDLobby: uint64_steamid,
22435 iChatID: ::std::os::raw::c_int,
22436 pSteamIDUser: *mut CSteamID,
22437 pvData: *mut ::std::os::raw::c_void,
22438 cubData: ::std::os::raw::c_int,
22439 peChatEntryType: *mut EChatEntryType,
22440 ) -> ::std::os::raw::c_int;
22441}
22442extern "C" {
22443 pub fn SteamAPI_ISteamMatchmaking_RequestLobbyData(
22444 self_: *mut ISteamMatchmaking,
22445 steamIDLobby: uint64_steamid,
22446 ) -> bool;
22447}
22448extern "C" {
22449 pub fn SteamAPI_ISteamMatchmaking_SetLobbyGameServer(
22450 self_: *mut ISteamMatchmaking,
22451 steamIDLobby: uint64_steamid,
22452 unGameServerIP: uint32,
22453 unGameServerPort: uint16,
22454 steamIDGameServer: uint64_steamid,
22455 );
22456}
22457extern "C" {
22458 pub fn SteamAPI_ISteamMatchmaking_GetLobbyGameServer(
22459 self_: *mut ISteamMatchmaking,
22460 steamIDLobby: uint64_steamid,
22461 punGameServerIP: *mut uint32,
22462 punGameServerPort: *mut uint16,
22463 psteamIDGameServer: *mut CSteamID,
22464 ) -> bool;
22465}
22466extern "C" {
22467 pub fn SteamAPI_ISteamMatchmaking_SetLobbyMemberLimit(
22468 self_: *mut ISteamMatchmaking,
22469 steamIDLobby: uint64_steamid,
22470 cMaxMembers: ::std::os::raw::c_int,
22471 ) -> bool;
22472}
22473extern "C" {
22474 pub fn SteamAPI_ISteamMatchmaking_GetLobbyMemberLimit(
22475 self_: *mut ISteamMatchmaking,
22476 steamIDLobby: uint64_steamid,
22477 ) -> ::std::os::raw::c_int;
22478}
22479extern "C" {
22480 pub fn SteamAPI_ISteamMatchmaking_SetLobbyType(
22481 self_: *mut ISteamMatchmaking,
22482 steamIDLobby: uint64_steamid,
22483 eLobbyType: ELobbyType,
22484 ) -> bool;
22485}
22486extern "C" {
22487 pub fn SteamAPI_ISteamMatchmaking_SetLobbyJoinable(
22488 self_: *mut ISteamMatchmaking,
22489 steamIDLobby: uint64_steamid,
22490 bLobbyJoinable: bool,
22491 ) -> bool;
22492}
22493extern "C" {
22494 pub fn SteamAPI_ISteamMatchmaking_GetLobbyOwner(
22495 self_: *mut ISteamMatchmaking,
22496 steamIDLobby: uint64_steamid,
22497 ) -> uint64_steamid;
22498}
22499extern "C" {
22500 pub fn SteamAPI_ISteamMatchmaking_SetLobbyOwner(
22501 self_: *mut ISteamMatchmaking,
22502 steamIDLobby: uint64_steamid,
22503 steamIDNewOwner: uint64_steamid,
22504 ) -> bool;
22505}
22506extern "C" {
22507 pub fn SteamAPI_ISteamMatchmaking_SetLinkedLobby(
22508 self_: *mut ISteamMatchmaking,
22509 steamIDLobby: uint64_steamid,
22510 steamIDLobbyDependent: uint64_steamid,
22511 ) -> bool;
22512}
22513extern "C" {
22514 pub fn SteamAPI_ISteamMatchmakingServerListResponse_ServerResponded(
22515 self_: *mut ISteamMatchmakingServerListResponse,
22516 hRequest: HServerListRequest,
22517 iServer: ::std::os::raw::c_int,
22518 );
22519}
22520extern "C" {
22521 pub fn SteamAPI_ISteamMatchmakingServerListResponse_ServerFailedToRespond(
22522 self_: *mut ISteamMatchmakingServerListResponse,
22523 hRequest: HServerListRequest,
22524 iServer: ::std::os::raw::c_int,
22525 );
22526}
22527extern "C" {
22528 pub fn SteamAPI_ISteamMatchmakingServerListResponse_RefreshComplete(
22529 self_: *mut ISteamMatchmakingServerListResponse,
22530 hRequest: HServerListRequest,
22531 response: EMatchMakingServerResponse,
22532 );
22533}
22534extern "C" {
22535 pub fn SteamAPI_ISteamMatchmakingPingResponse_ServerResponded(
22536 self_: *mut ISteamMatchmakingPingResponse,
22537 server: *mut gameserveritem_t,
22538 );
22539}
22540extern "C" {
22541 pub fn SteamAPI_ISteamMatchmakingPingResponse_ServerFailedToRespond(
22542 self_: *mut ISteamMatchmakingPingResponse,
22543 );
22544}
22545extern "C" {
22546 pub fn SteamAPI_ISteamMatchmakingPlayersResponse_AddPlayerToList(
22547 self_: *mut ISteamMatchmakingPlayersResponse,
22548 pchName: *const ::std::os::raw::c_char,
22549 nScore: ::std::os::raw::c_int,
22550 flTimePlayed: f32,
22551 );
22552}
22553extern "C" {
22554 pub fn SteamAPI_ISteamMatchmakingPlayersResponse_PlayersFailedToRespond(
22555 self_: *mut ISteamMatchmakingPlayersResponse,
22556 );
22557}
22558extern "C" {
22559 pub fn SteamAPI_ISteamMatchmakingPlayersResponse_PlayersRefreshComplete(
22560 self_: *mut ISteamMatchmakingPlayersResponse,
22561 );
22562}
22563extern "C" {
22564 pub fn SteamAPI_ISteamMatchmakingRulesResponse_RulesResponded(
22565 self_: *mut ISteamMatchmakingRulesResponse,
22566 pchRule: *const ::std::os::raw::c_char,
22567 pchValue: *const ::std::os::raw::c_char,
22568 );
22569}
22570extern "C" {
22571 pub fn SteamAPI_ISteamMatchmakingRulesResponse_RulesFailedToRespond(
22572 self_: *mut ISteamMatchmakingRulesResponse,
22573 );
22574}
22575extern "C" {
22576 pub fn SteamAPI_ISteamMatchmakingRulesResponse_RulesRefreshComplete(
22577 self_: *mut ISteamMatchmakingRulesResponse,
22578 );
22579}
22580extern "C" {
22581 pub fn SteamAPI_SteamMatchmakingServers_v002() -> *mut ISteamMatchmakingServers;
22582}
22583extern "C" {
22584 pub fn SteamAPI_ISteamMatchmakingServers_RequestInternetServerList(
22585 self_: *mut ISteamMatchmakingServers,
22586 iApp: AppId_t,
22587 ppchFilters: *mut *mut MatchMakingKeyValuePair_t,
22588 nFilters: uint32,
22589 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22590 ) -> HServerListRequest;
22591}
22592extern "C" {
22593 pub fn SteamAPI_ISteamMatchmakingServers_RequestLANServerList(
22594 self_: *mut ISteamMatchmakingServers,
22595 iApp: AppId_t,
22596 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22597 ) -> HServerListRequest;
22598}
22599extern "C" {
22600 pub fn SteamAPI_ISteamMatchmakingServers_RequestFriendsServerList(
22601 self_: *mut ISteamMatchmakingServers,
22602 iApp: AppId_t,
22603 ppchFilters: *mut *mut MatchMakingKeyValuePair_t,
22604 nFilters: uint32,
22605 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22606 ) -> HServerListRequest;
22607}
22608extern "C" {
22609 pub fn SteamAPI_ISteamMatchmakingServers_RequestFavoritesServerList(
22610 self_: *mut ISteamMatchmakingServers,
22611 iApp: AppId_t,
22612 ppchFilters: *mut *mut MatchMakingKeyValuePair_t,
22613 nFilters: uint32,
22614 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22615 ) -> HServerListRequest;
22616}
22617extern "C" {
22618 pub fn SteamAPI_ISteamMatchmakingServers_RequestHistoryServerList(
22619 self_: *mut ISteamMatchmakingServers,
22620 iApp: AppId_t,
22621 ppchFilters: *mut *mut MatchMakingKeyValuePair_t,
22622 nFilters: uint32,
22623 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22624 ) -> HServerListRequest;
22625}
22626extern "C" {
22627 pub fn SteamAPI_ISteamMatchmakingServers_RequestSpectatorServerList(
22628 self_: *mut ISteamMatchmakingServers,
22629 iApp: AppId_t,
22630 ppchFilters: *mut *mut MatchMakingKeyValuePair_t,
22631 nFilters: uint32,
22632 pRequestServersResponse: *mut ISteamMatchmakingServerListResponse,
22633 ) -> HServerListRequest;
22634}
22635extern "C" {
22636 pub fn SteamAPI_ISteamMatchmakingServers_ReleaseRequest(
22637 self_: *mut ISteamMatchmakingServers,
22638 hServerListRequest: HServerListRequest,
22639 );
22640}
22641extern "C" {
22642 pub fn SteamAPI_ISteamMatchmakingServers_GetServerDetails(
22643 self_: *mut ISteamMatchmakingServers,
22644 hRequest: HServerListRequest,
22645 iServer: ::std::os::raw::c_int,
22646 ) -> *mut gameserveritem_t;
22647}
22648extern "C" {
22649 pub fn SteamAPI_ISteamMatchmakingServers_CancelQuery(
22650 self_: *mut ISteamMatchmakingServers,
22651 hRequest: HServerListRequest,
22652 );
22653}
22654extern "C" {
22655 pub fn SteamAPI_ISteamMatchmakingServers_RefreshQuery(
22656 self_: *mut ISteamMatchmakingServers,
22657 hRequest: HServerListRequest,
22658 );
22659}
22660extern "C" {
22661 pub fn SteamAPI_ISteamMatchmakingServers_IsRefreshing(
22662 self_: *mut ISteamMatchmakingServers,
22663 hRequest: HServerListRequest,
22664 ) -> bool;
22665}
22666extern "C" {
22667 pub fn SteamAPI_ISteamMatchmakingServers_GetServerCount(
22668 self_: *mut ISteamMatchmakingServers,
22669 hRequest: HServerListRequest,
22670 ) -> ::std::os::raw::c_int;
22671}
22672extern "C" {
22673 pub fn SteamAPI_ISteamMatchmakingServers_RefreshServer(
22674 self_: *mut ISteamMatchmakingServers,
22675 hRequest: HServerListRequest,
22676 iServer: ::std::os::raw::c_int,
22677 );
22678}
22679extern "C" {
22680 pub fn SteamAPI_ISteamMatchmakingServers_PingServer(
22681 self_: *mut ISteamMatchmakingServers,
22682 unIP: uint32,
22683 usPort: uint16,
22684 pRequestServersResponse: *mut ISteamMatchmakingPingResponse,
22685 ) -> HServerQuery;
22686}
22687extern "C" {
22688 pub fn SteamAPI_ISteamMatchmakingServers_PlayerDetails(
22689 self_: *mut ISteamMatchmakingServers,
22690 unIP: uint32,
22691 usPort: uint16,
22692 pRequestServersResponse: *mut ISteamMatchmakingPlayersResponse,
22693 ) -> HServerQuery;
22694}
22695extern "C" {
22696 pub fn SteamAPI_ISteamMatchmakingServers_ServerRules(
22697 self_: *mut ISteamMatchmakingServers,
22698 unIP: uint32,
22699 usPort: uint16,
22700 pRequestServersResponse: *mut ISteamMatchmakingRulesResponse,
22701 ) -> HServerQuery;
22702}
22703extern "C" {
22704 pub fn SteamAPI_ISteamMatchmakingServers_CancelServerQuery(
22705 self_: *mut ISteamMatchmakingServers,
22706 hServerQuery: HServerQuery,
22707 );
22708}
22709extern "C" {
22710 pub fn SteamAPI_SteamParties_v002() -> *mut ISteamParties;
22711}
22712extern "C" {
22713 pub fn SteamAPI_ISteamParties_GetNumActiveBeacons(self_: *mut ISteamParties) -> uint32;
22714}
22715extern "C" {
22716 pub fn SteamAPI_ISteamParties_GetBeaconByIndex(
22717 self_: *mut ISteamParties,
22718 unIndex: uint32,
22719 ) -> PartyBeaconID_t;
22720}
22721extern "C" {
22722 pub fn SteamAPI_ISteamParties_GetBeaconDetails(
22723 self_: *mut ISteamParties,
22724 ulBeaconID: PartyBeaconID_t,
22725 pSteamIDBeaconOwner: *mut CSteamID,
22726 pLocation: *mut SteamPartyBeaconLocation_t,
22727 pchMetadata: *mut ::std::os::raw::c_char,
22728 cchMetadata: ::std::os::raw::c_int,
22729 ) -> bool;
22730}
22731extern "C" {
22732 pub fn SteamAPI_ISteamParties_JoinParty(
22733 self_: *mut ISteamParties,
22734 ulBeaconID: PartyBeaconID_t,
22735 ) -> SteamAPICall_t;
22736}
22737extern "C" {
22738 pub fn SteamAPI_ISteamParties_GetNumAvailableBeaconLocations(
22739 self_: *mut ISteamParties,
22740 puNumLocations: *mut uint32,
22741 ) -> bool;
22742}
22743extern "C" {
22744 pub fn SteamAPI_ISteamParties_GetAvailableBeaconLocations(
22745 self_: *mut ISteamParties,
22746 pLocationList: *mut SteamPartyBeaconLocation_t,
22747 uMaxNumLocations: uint32,
22748 ) -> bool;
22749}
22750extern "C" {
22751 pub fn SteamAPI_ISteamParties_CreateBeacon(
22752 self_: *mut ISteamParties,
22753 unOpenSlots: uint32,
22754 pBeaconLocation: *mut SteamPartyBeaconLocation_t,
22755 pchConnectString: *const ::std::os::raw::c_char,
22756 pchMetadata: *const ::std::os::raw::c_char,
22757 ) -> SteamAPICall_t;
22758}
22759extern "C" {
22760 pub fn SteamAPI_ISteamParties_OnReservationCompleted(
22761 self_: *mut ISteamParties,
22762 ulBeacon: PartyBeaconID_t,
22763 steamIDUser: uint64_steamid,
22764 );
22765}
22766extern "C" {
22767 pub fn SteamAPI_ISteamParties_CancelReservation(
22768 self_: *mut ISteamParties,
22769 ulBeacon: PartyBeaconID_t,
22770 steamIDUser: uint64_steamid,
22771 );
22772}
22773extern "C" {
22774 pub fn SteamAPI_ISteamParties_ChangeNumOpenSlots(
22775 self_: *mut ISteamParties,
22776 ulBeacon: PartyBeaconID_t,
22777 unOpenSlots: uint32,
22778 ) -> SteamAPICall_t;
22779}
22780extern "C" {
22781 pub fn SteamAPI_ISteamParties_DestroyBeacon(
22782 self_: *mut ISteamParties,
22783 ulBeacon: PartyBeaconID_t,
22784 ) -> bool;
22785}
22786extern "C" {
22787 pub fn SteamAPI_ISteamParties_GetBeaconLocationData(
22788 self_: *mut ISteamParties,
22789 BeaconLocation: SteamPartyBeaconLocation_t,
22790 eData: ESteamPartyBeaconLocationData,
22791 pchDataStringOut: *mut ::std::os::raw::c_char,
22792 cchDataStringOut: ::std::os::raw::c_int,
22793 ) -> bool;
22794}
22795extern "C" {
22796 pub fn SteamAPI_SteamRemoteStorage_v016() -> *mut ISteamRemoteStorage;
22797}
22798extern "C" {
22799 pub fn SteamAPI_ISteamRemoteStorage_FileWrite(
22800 self_: *mut ISteamRemoteStorage,
22801 pchFile: *const ::std::os::raw::c_char,
22802 pvData: *const ::std::os::raw::c_void,
22803 cubData: int32,
22804 ) -> bool;
22805}
22806extern "C" {
22807 pub fn SteamAPI_ISteamRemoteStorage_FileRead(
22808 self_: *mut ISteamRemoteStorage,
22809 pchFile: *const ::std::os::raw::c_char,
22810 pvData: *mut ::std::os::raw::c_void,
22811 cubDataToRead: int32,
22812 ) -> int32;
22813}
22814extern "C" {
22815 pub fn SteamAPI_ISteamRemoteStorage_FileWriteAsync(
22816 self_: *mut ISteamRemoteStorage,
22817 pchFile: *const ::std::os::raw::c_char,
22818 pvData: *const ::std::os::raw::c_void,
22819 cubData: uint32,
22820 ) -> SteamAPICall_t;
22821}
22822extern "C" {
22823 pub fn SteamAPI_ISteamRemoteStorage_FileReadAsync(
22824 self_: *mut ISteamRemoteStorage,
22825 pchFile: *const ::std::os::raw::c_char,
22826 nOffset: uint32,
22827 cubToRead: uint32,
22828 ) -> SteamAPICall_t;
22829}
22830extern "C" {
22831 pub fn SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete(
22832 self_: *mut ISteamRemoteStorage,
22833 hReadCall: SteamAPICall_t,
22834 pvBuffer: *mut ::std::os::raw::c_void,
22835 cubToRead: uint32,
22836 ) -> bool;
22837}
22838extern "C" {
22839 pub fn SteamAPI_ISteamRemoteStorage_FileForget(
22840 self_: *mut ISteamRemoteStorage,
22841 pchFile: *const ::std::os::raw::c_char,
22842 ) -> bool;
22843}
22844extern "C" {
22845 pub fn SteamAPI_ISteamRemoteStorage_FileDelete(
22846 self_: *mut ISteamRemoteStorage,
22847 pchFile: *const ::std::os::raw::c_char,
22848 ) -> bool;
22849}
22850extern "C" {
22851 pub fn SteamAPI_ISteamRemoteStorage_FileShare(
22852 self_: *mut ISteamRemoteStorage,
22853 pchFile: *const ::std::os::raw::c_char,
22854 ) -> SteamAPICall_t;
22855}
22856extern "C" {
22857 pub fn SteamAPI_ISteamRemoteStorage_SetSyncPlatforms(
22858 self_: *mut ISteamRemoteStorage,
22859 pchFile: *const ::std::os::raw::c_char,
22860 eRemoteStoragePlatform: ERemoteStoragePlatform,
22861 ) -> bool;
22862}
22863extern "C" {
22864 pub fn SteamAPI_ISteamRemoteStorage_FileWriteStreamOpen(
22865 self_: *mut ISteamRemoteStorage,
22866 pchFile: *const ::std::os::raw::c_char,
22867 ) -> UGCFileWriteStreamHandle_t;
22868}
22869extern "C" {
22870 pub fn SteamAPI_ISteamRemoteStorage_FileWriteStreamWriteChunk(
22871 self_: *mut ISteamRemoteStorage,
22872 writeHandle: UGCFileWriteStreamHandle_t,
22873 pvData: *const ::std::os::raw::c_void,
22874 cubData: int32,
22875 ) -> bool;
22876}
22877extern "C" {
22878 pub fn SteamAPI_ISteamRemoteStorage_FileWriteStreamClose(
22879 self_: *mut ISteamRemoteStorage,
22880 writeHandle: UGCFileWriteStreamHandle_t,
22881 ) -> bool;
22882}
22883extern "C" {
22884 pub fn SteamAPI_ISteamRemoteStorage_FileWriteStreamCancel(
22885 self_: *mut ISteamRemoteStorage,
22886 writeHandle: UGCFileWriteStreamHandle_t,
22887 ) -> bool;
22888}
22889extern "C" {
22890 pub fn SteamAPI_ISteamRemoteStorage_FileExists(
22891 self_: *mut ISteamRemoteStorage,
22892 pchFile: *const ::std::os::raw::c_char,
22893 ) -> bool;
22894}
22895extern "C" {
22896 pub fn SteamAPI_ISteamRemoteStorage_FilePersisted(
22897 self_: *mut ISteamRemoteStorage,
22898 pchFile: *const ::std::os::raw::c_char,
22899 ) -> bool;
22900}
22901extern "C" {
22902 pub fn SteamAPI_ISteamRemoteStorage_GetFileSize(
22903 self_: *mut ISteamRemoteStorage,
22904 pchFile: *const ::std::os::raw::c_char,
22905 ) -> int32;
22906}
22907extern "C" {
22908 pub fn SteamAPI_ISteamRemoteStorage_GetFileTimestamp(
22909 self_: *mut ISteamRemoteStorage,
22910 pchFile: *const ::std::os::raw::c_char,
22911 ) -> int64;
22912}
22913extern "C" {
22914 pub fn SteamAPI_ISteamRemoteStorage_GetSyncPlatforms(
22915 self_: *mut ISteamRemoteStorage,
22916 pchFile: *const ::std::os::raw::c_char,
22917 ) -> ERemoteStoragePlatform;
22918}
22919extern "C" {
22920 pub fn SteamAPI_ISteamRemoteStorage_GetFileCount(self_: *mut ISteamRemoteStorage) -> int32;
22921}
22922extern "C" {
22923 pub fn SteamAPI_ISteamRemoteStorage_GetFileNameAndSize(
22924 self_: *mut ISteamRemoteStorage,
22925 iFile: ::std::os::raw::c_int,
22926 pnFileSizeInBytes: *mut int32,
22927 ) -> *const ::std::os::raw::c_char;
22928}
22929extern "C" {
22930 pub fn SteamAPI_ISteamRemoteStorage_GetQuota(
22931 self_: *mut ISteamRemoteStorage,
22932 pnTotalBytes: *mut uint64,
22933 puAvailableBytes: *mut uint64,
22934 ) -> bool;
22935}
22936extern "C" {
22937 pub fn SteamAPI_ISteamRemoteStorage_IsCloudEnabledForAccount(
22938 self_: *mut ISteamRemoteStorage,
22939 ) -> bool;
22940}
22941extern "C" {
22942 pub fn SteamAPI_ISteamRemoteStorage_IsCloudEnabledForApp(
22943 self_: *mut ISteamRemoteStorage,
22944 ) -> bool;
22945}
22946extern "C" {
22947 pub fn SteamAPI_ISteamRemoteStorage_SetCloudEnabledForApp(
22948 self_: *mut ISteamRemoteStorage,
22949 bEnabled: bool,
22950 );
22951}
22952extern "C" {
22953 pub fn SteamAPI_ISteamRemoteStorage_UGCDownload(
22954 self_: *mut ISteamRemoteStorage,
22955 hContent: UGCHandle_t,
22956 unPriority: uint32,
22957 ) -> SteamAPICall_t;
22958}
22959extern "C" {
22960 pub fn SteamAPI_ISteamRemoteStorage_GetUGCDownloadProgress(
22961 self_: *mut ISteamRemoteStorage,
22962 hContent: UGCHandle_t,
22963 pnBytesDownloaded: *mut int32,
22964 pnBytesExpected: *mut int32,
22965 ) -> bool;
22966}
22967extern "C" {
22968 pub fn SteamAPI_ISteamRemoteStorage_GetUGCDetails(
22969 self_: *mut ISteamRemoteStorage,
22970 hContent: UGCHandle_t,
22971 pnAppID: *mut AppId_t,
22972 ppchName: *mut *mut ::std::os::raw::c_char,
22973 pnFileSizeInBytes: *mut int32,
22974 pSteamIDOwner: *mut CSteamID,
22975 ) -> bool;
22976}
22977extern "C" {
22978 pub fn SteamAPI_ISteamRemoteStorage_UGCRead(
22979 self_: *mut ISteamRemoteStorage,
22980 hContent: UGCHandle_t,
22981 pvData: *mut ::std::os::raw::c_void,
22982 cubDataToRead: int32,
22983 cOffset: uint32,
22984 eAction: EUGCReadAction,
22985 ) -> int32;
22986}
22987extern "C" {
22988 pub fn SteamAPI_ISteamRemoteStorage_GetCachedUGCCount(self_: *mut ISteamRemoteStorage)
22989 -> int32;
22990}
22991extern "C" {
22992 pub fn SteamAPI_ISteamRemoteStorage_GetCachedUGCHandle(
22993 self_: *mut ISteamRemoteStorage,
22994 iCachedContent: int32,
22995 ) -> UGCHandle_t;
22996}
22997extern "C" {
22998 pub fn SteamAPI_ISteamRemoteStorage_PublishWorkshopFile(
22999 self_: *mut ISteamRemoteStorage,
23000 pchFile: *const ::std::os::raw::c_char,
23001 pchPreviewFile: *const ::std::os::raw::c_char,
23002 nConsumerAppId: AppId_t,
23003 pchTitle: *const ::std::os::raw::c_char,
23004 pchDescription: *const ::std::os::raw::c_char,
23005 eVisibility: ERemoteStoragePublishedFileVisibility,
23006 pTags: *mut SteamParamStringArray_t,
23007 eWorkshopFileType: EWorkshopFileType,
23008 ) -> SteamAPICall_t;
23009}
23010extern "C" {
23011 pub fn SteamAPI_ISteamRemoteStorage_CreatePublishedFileUpdateRequest(
23012 self_: *mut ISteamRemoteStorage,
23013 unPublishedFileId: PublishedFileId_t,
23014 ) -> PublishedFileUpdateHandle_t;
23015}
23016extern "C" {
23017 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileFile(
23018 self_: *mut ISteamRemoteStorage,
23019 updateHandle: PublishedFileUpdateHandle_t,
23020 pchFile: *const ::std::os::raw::c_char,
23021 ) -> bool;
23022}
23023extern "C" {
23024 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFilePreviewFile(
23025 self_: *mut ISteamRemoteStorage,
23026 updateHandle: PublishedFileUpdateHandle_t,
23027 pchPreviewFile: *const ::std::os::raw::c_char,
23028 ) -> bool;
23029}
23030extern "C" {
23031 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTitle(
23032 self_: *mut ISteamRemoteStorage,
23033 updateHandle: PublishedFileUpdateHandle_t,
23034 pchTitle: *const ::std::os::raw::c_char,
23035 ) -> bool;
23036}
23037extern "C" {
23038 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileDescription(
23039 self_: *mut ISteamRemoteStorage,
23040 updateHandle: PublishedFileUpdateHandle_t,
23041 pchDescription: *const ::std::os::raw::c_char,
23042 ) -> bool;
23043}
23044extern "C" {
23045 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileVisibility(
23046 self_: *mut ISteamRemoteStorage,
23047 updateHandle: PublishedFileUpdateHandle_t,
23048 eVisibility: ERemoteStoragePublishedFileVisibility,
23049 ) -> bool;
23050}
23051extern "C" {
23052 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileTags(
23053 self_: *mut ISteamRemoteStorage,
23054 updateHandle: PublishedFileUpdateHandle_t,
23055 pTags: *mut SteamParamStringArray_t,
23056 ) -> bool;
23057}
23058extern "C" {
23059 pub fn SteamAPI_ISteamRemoteStorage_CommitPublishedFileUpdate(
23060 self_: *mut ISteamRemoteStorage,
23061 updateHandle: PublishedFileUpdateHandle_t,
23062 ) -> SteamAPICall_t;
23063}
23064extern "C" {
23065 pub fn SteamAPI_ISteamRemoteStorage_GetPublishedFileDetails(
23066 self_: *mut ISteamRemoteStorage,
23067 unPublishedFileId: PublishedFileId_t,
23068 unMaxSecondsOld: uint32,
23069 ) -> SteamAPICall_t;
23070}
23071extern "C" {
23072 pub fn SteamAPI_ISteamRemoteStorage_DeletePublishedFile(
23073 self_: *mut ISteamRemoteStorage,
23074 unPublishedFileId: PublishedFileId_t,
23075 ) -> SteamAPICall_t;
23076}
23077extern "C" {
23078 pub fn SteamAPI_ISteamRemoteStorage_EnumerateUserPublishedFiles(
23079 self_: *mut ISteamRemoteStorage,
23080 unStartIndex: uint32,
23081 ) -> SteamAPICall_t;
23082}
23083extern "C" {
23084 pub fn SteamAPI_ISteamRemoteStorage_SubscribePublishedFile(
23085 self_: *mut ISteamRemoteStorage,
23086 unPublishedFileId: PublishedFileId_t,
23087 ) -> SteamAPICall_t;
23088}
23089extern "C" {
23090 pub fn SteamAPI_ISteamRemoteStorage_EnumerateUserSubscribedFiles(
23091 self_: *mut ISteamRemoteStorage,
23092 unStartIndex: uint32,
23093 ) -> SteamAPICall_t;
23094}
23095extern "C" {
23096 pub fn SteamAPI_ISteamRemoteStorage_UnsubscribePublishedFile(
23097 self_: *mut ISteamRemoteStorage,
23098 unPublishedFileId: PublishedFileId_t,
23099 ) -> SteamAPICall_t;
23100}
23101extern "C" {
23102 pub fn SteamAPI_ISteamRemoteStorage_UpdatePublishedFileSetChangeDescription(
23103 self_: *mut ISteamRemoteStorage,
23104 updateHandle: PublishedFileUpdateHandle_t,
23105 pchChangeDescription: *const ::std::os::raw::c_char,
23106 ) -> bool;
23107}
23108extern "C" {
23109 pub fn SteamAPI_ISteamRemoteStorage_GetPublishedItemVoteDetails(
23110 self_: *mut ISteamRemoteStorage,
23111 unPublishedFileId: PublishedFileId_t,
23112 ) -> SteamAPICall_t;
23113}
23114extern "C" {
23115 pub fn SteamAPI_ISteamRemoteStorage_UpdateUserPublishedItemVote(
23116 self_: *mut ISteamRemoteStorage,
23117 unPublishedFileId: PublishedFileId_t,
23118 bVoteUp: bool,
23119 ) -> SteamAPICall_t;
23120}
23121extern "C" {
23122 pub fn SteamAPI_ISteamRemoteStorage_GetUserPublishedItemVoteDetails(
23123 self_: *mut ISteamRemoteStorage,
23124 unPublishedFileId: PublishedFileId_t,
23125 ) -> SteamAPICall_t;
23126}
23127extern "C" {
23128 pub fn SteamAPI_ISteamRemoteStorage_EnumerateUserSharedWorkshopFiles(
23129 self_: *mut ISteamRemoteStorage,
23130 steamId: uint64_steamid,
23131 unStartIndex: uint32,
23132 pRequiredTags: *mut SteamParamStringArray_t,
23133 pExcludedTags: *mut SteamParamStringArray_t,
23134 ) -> SteamAPICall_t;
23135}
23136extern "C" {
23137 pub fn SteamAPI_ISteamRemoteStorage_PublishVideo(
23138 self_: *mut ISteamRemoteStorage,
23139 eVideoProvider: EWorkshopVideoProvider,
23140 pchVideoAccount: *const ::std::os::raw::c_char,
23141 pchVideoIdentifier: *const ::std::os::raw::c_char,
23142 pchPreviewFile: *const ::std::os::raw::c_char,
23143 nConsumerAppId: AppId_t,
23144 pchTitle: *const ::std::os::raw::c_char,
23145 pchDescription: *const ::std::os::raw::c_char,
23146 eVisibility: ERemoteStoragePublishedFileVisibility,
23147 pTags: *mut SteamParamStringArray_t,
23148 ) -> SteamAPICall_t;
23149}
23150extern "C" {
23151 pub fn SteamAPI_ISteamRemoteStorage_SetUserPublishedFileAction(
23152 self_: *mut ISteamRemoteStorage,
23153 unPublishedFileId: PublishedFileId_t,
23154 eAction: EWorkshopFileAction,
23155 ) -> SteamAPICall_t;
23156}
23157extern "C" {
23158 pub fn SteamAPI_ISteamRemoteStorage_EnumeratePublishedFilesByUserAction(
23159 self_: *mut ISteamRemoteStorage,
23160 eAction: EWorkshopFileAction,
23161 unStartIndex: uint32,
23162 ) -> SteamAPICall_t;
23163}
23164extern "C" {
23165 pub fn SteamAPI_ISteamRemoteStorage_EnumeratePublishedWorkshopFiles(
23166 self_: *mut ISteamRemoteStorage,
23167 eEnumerationType: EWorkshopEnumerationType,
23168 unStartIndex: uint32,
23169 unCount: uint32,
23170 unDays: uint32,
23171 pTags: *mut SteamParamStringArray_t,
23172 pUserTags: *mut SteamParamStringArray_t,
23173 ) -> SteamAPICall_t;
23174}
23175extern "C" {
23176 pub fn SteamAPI_ISteamRemoteStorage_UGCDownloadToLocation(
23177 self_: *mut ISteamRemoteStorage,
23178 hContent: UGCHandle_t,
23179 pchLocation: *const ::std::os::raw::c_char,
23180 unPriority: uint32,
23181 ) -> SteamAPICall_t;
23182}
23183extern "C" {
23184 pub fn SteamAPI_ISteamRemoteStorage_GetLocalFileChangeCount(
23185 self_: *mut ISteamRemoteStorage,
23186 ) -> int32;
23187}
23188extern "C" {
23189 pub fn SteamAPI_ISteamRemoteStorage_GetLocalFileChange(
23190 self_: *mut ISteamRemoteStorage,
23191 iFile: ::std::os::raw::c_int,
23192 pEChangeType: *mut ERemoteStorageLocalFileChange,
23193 pEFilePathType: *mut ERemoteStorageFilePathType,
23194 ) -> *const ::std::os::raw::c_char;
23195}
23196extern "C" {
23197 pub fn SteamAPI_ISteamRemoteStorage_BeginFileWriteBatch(
23198 self_: *mut ISteamRemoteStorage,
23199 ) -> bool;
23200}
23201extern "C" {
23202 pub fn SteamAPI_ISteamRemoteStorage_EndFileWriteBatch(self_: *mut ISteamRemoteStorage) -> bool;
23203}
23204extern "C" {
23205 pub fn SteamAPI_SteamUserStats_v013() -> *mut ISteamUserStats;
23206}
23207extern "C" {
23208 pub fn SteamAPI_ISteamUserStats_GetStatInt32(
23209 self_: *mut ISteamUserStats,
23210 pchName: *const ::std::os::raw::c_char,
23211 pData: *mut int32,
23212 ) -> bool;
23213}
23214extern "C" {
23215 pub fn SteamAPI_ISteamUserStats_GetStatFloat(
23216 self_: *mut ISteamUserStats,
23217 pchName: *const ::std::os::raw::c_char,
23218 pData: *mut f32,
23219 ) -> bool;
23220}
23221extern "C" {
23222 pub fn SteamAPI_ISteamUserStats_SetStatInt32(
23223 self_: *mut ISteamUserStats,
23224 pchName: *const ::std::os::raw::c_char,
23225 nData: int32,
23226 ) -> bool;
23227}
23228extern "C" {
23229 pub fn SteamAPI_ISteamUserStats_SetStatFloat(
23230 self_: *mut ISteamUserStats,
23231 pchName: *const ::std::os::raw::c_char,
23232 fData: f32,
23233 ) -> bool;
23234}
23235extern "C" {
23236 pub fn SteamAPI_ISteamUserStats_UpdateAvgRateStat(
23237 self_: *mut ISteamUserStats,
23238 pchName: *const ::std::os::raw::c_char,
23239 flCountThisSession: f32,
23240 dSessionLength: f64,
23241 ) -> bool;
23242}
23243extern "C" {
23244 pub fn SteamAPI_ISteamUserStats_GetAchievement(
23245 self_: *mut ISteamUserStats,
23246 pchName: *const ::std::os::raw::c_char,
23247 pbAchieved: *mut bool,
23248 ) -> bool;
23249}
23250extern "C" {
23251 pub fn SteamAPI_ISteamUserStats_SetAchievement(
23252 self_: *mut ISteamUserStats,
23253 pchName: *const ::std::os::raw::c_char,
23254 ) -> bool;
23255}
23256extern "C" {
23257 pub fn SteamAPI_ISteamUserStats_ClearAchievement(
23258 self_: *mut ISteamUserStats,
23259 pchName: *const ::std::os::raw::c_char,
23260 ) -> bool;
23261}
23262extern "C" {
23263 pub fn SteamAPI_ISteamUserStats_GetAchievementAndUnlockTime(
23264 self_: *mut ISteamUserStats,
23265 pchName: *const ::std::os::raw::c_char,
23266 pbAchieved: *mut bool,
23267 punUnlockTime: *mut uint32,
23268 ) -> bool;
23269}
23270extern "C" {
23271 pub fn SteamAPI_ISteamUserStats_StoreStats(self_: *mut ISteamUserStats) -> bool;
23272}
23273extern "C" {
23274 pub fn SteamAPI_ISteamUserStats_GetAchievementIcon(
23275 self_: *mut ISteamUserStats,
23276 pchName: *const ::std::os::raw::c_char,
23277 ) -> ::std::os::raw::c_int;
23278}
23279extern "C" {
23280 pub fn SteamAPI_ISteamUserStats_GetAchievementDisplayAttribute(
23281 self_: *mut ISteamUserStats,
23282 pchName: *const ::std::os::raw::c_char,
23283 pchKey: *const ::std::os::raw::c_char,
23284 ) -> *const ::std::os::raw::c_char;
23285}
23286extern "C" {
23287 pub fn SteamAPI_ISteamUserStats_IndicateAchievementProgress(
23288 self_: *mut ISteamUserStats,
23289 pchName: *const ::std::os::raw::c_char,
23290 nCurProgress: uint32,
23291 nMaxProgress: uint32,
23292 ) -> bool;
23293}
23294extern "C" {
23295 pub fn SteamAPI_ISteamUserStats_GetNumAchievements(self_: *mut ISteamUserStats) -> uint32;
23296}
23297extern "C" {
23298 pub fn SteamAPI_ISteamUserStats_GetAchievementName(
23299 self_: *mut ISteamUserStats,
23300 iAchievement: uint32,
23301 ) -> *const ::std::os::raw::c_char;
23302}
23303extern "C" {
23304 pub fn SteamAPI_ISteamUserStats_RequestUserStats(
23305 self_: *mut ISteamUserStats,
23306 steamIDUser: uint64_steamid,
23307 ) -> SteamAPICall_t;
23308}
23309extern "C" {
23310 pub fn SteamAPI_ISteamUserStats_GetUserStatInt32(
23311 self_: *mut ISteamUserStats,
23312 steamIDUser: uint64_steamid,
23313 pchName: *const ::std::os::raw::c_char,
23314 pData: *mut int32,
23315 ) -> bool;
23316}
23317extern "C" {
23318 pub fn SteamAPI_ISteamUserStats_GetUserStatFloat(
23319 self_: *mut ISteamUserStats,
23320 steamIDUser: uint64_steamid,
23321 pchName: *const ::std::os::raw::c_char,
23322 pData: *mut f32,
23323 ) -> bool;
23324}
23325extern "C" {
23326 pub fn SteamAPI_ISteamUserStats_GetUserAchievement(
23327 self_: *mut ISteamUserStats,
23328 steamIDUser: uint64_steamid,
23329 pchName: *const ::std::os::raw::c_char,
23330 pbAchieved: *mut bool,
23331 ) -> bool;
23332}
23333extern "C" {
23334 pub fn SteamAPI_ISteamUserStats_GetUserAchievementAndUnlockTime(
23335 self_: *mut ISteamUserStats,
23336 steamIDUser: uint64_steamid,
23337 pchName: *const ::std::os::raw::c_char,
23338 pbAchieved: *mut bool,
23339 punUnlockTime: *mut uint32,
23340 ) -> bool;
23341}
23342extern "C" {
23343 pub fn SteamAPI_ISteamUserStats_ResetAllStats(
23344 self_: *mut ISteamUserStats,
23345 bAchievementsToo: bool,
23346 ) -> bool;
23347}
23348extern "C" {
23349 pub fn SteamAPI_ISteamUserStats_FindOrCreateLeaderboard(
23350 self_: *mut ISteamUserStats,
23351 pchLeaderboardName: *const ::std::os::raw::c_char,
23352 eLeaderboardSortMethod: ELeaderboardSortMethod,
23353 eLeaderboardDisplayType: ELeaderboardDisplayType,
23354 ) -> SteamAPICall_t;
23355}
23356extern "C" {
23357 pub fn SteamAPI_ISteamUserStats_FindLeaderboard(
23358 self_: *mut ISteamUserStats,
23359 pchLeaderboardName: *const ::std::os::raw::c_char,
23360 ) -> SteamAPICall_t;
23361}
23362extern "C" {
23363 pub fn SteamAPI_ISteamUserStats_GetLeaderboardName(
23364 self_: *mut ISteamUserStats,
23365 hSteamLeaderboard: SteamLeaderboard_t,
23366 ) -> *const ::std::os::raw::c_char;
23367}
23368extern "C" {
23369 pub fn SteamAPI_ISteamUserStats_GetLeaderboardEntryCount(
23370 self_: *mut ISteamUserStats,
23371 hSteamLeaderboard: SteamLeaderboard_t,
23372 ) -> ::std::os::raw::c_int;
23373}
23374extern "C" {
23375 pub fn SteamAPI_ISteamUserStats_GetLeaderboardSortMethod(
23376 self_: *mut ISteamUserStats,
23377 hSteamLeaderboard: SteamLeaderboard_t,
23378 ) -> ELeaderboardSortMethod;
23379}
23380extern "C" {
23381 pub fn SteamAPI_ISteamUserStats_GetLeaderboardDisplayType(
23382 self_: *mut ISteamUserStats,
23383 hSteamLeaderboard: SteamLeaderboard_t,
23384 ) -> ELeaderboardDisplayType;
23385}
23386extern "C" {
23387 pub fn SteamAPI_ISteamUserStats_DownloadLeaderboardEntries(
23388 self_: *mut ISteamUserStats,
23389 hSteamLeaderboard: SteamLeaderboard_t,
23390 eLeaderboardDataRequest: ELeaderboardDataRequest,
23391 nRangeStart: ::std::os::raw::c_int,
23392 nRangeEnd: ::std::os::raw::c_int,
23393 ) -> SteamAPICall_t;
23394}
23395extern "C" {
23396 pub fn SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers(
23397 self_: *mut ISteamUserStats,
23398 hSteamLeaderboard: SteamLeaderboard_t,
23399 prgUsers: *mut CSteamID,
23400 cUsers: ::std::os::raw::c_int,
23401 ) -> SteamAPICall_t;
23402}
23403extern "C" {
23404 pub fn SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry(
23405 self_: *mut ISteamUserStats,
23406 hSteamLeaderboardEntries: SteamLeaderboardEntries_t,
23407 index: ::std::os::raw::c_int,
23408 pLeaderboardEntry: *mut LeaderboardEntry_t,
23409 pDetails: *mut int32,
23410 cDetailsMax: ::std::os::raw::c_int,
23411 ) -> bool;
23412}
23413extern "C" {
23414 pub fn SteamAPI_ISteamUserStats_UploadLeaderboardScore(
23415 self_: *mut ISteamUserStats,
23416 hSteamLeaderboard: SteamLeaderboard_t,
23417 eLeaderboardUploadScoreMethod: ELeaderboardUploadScoreMethod,
23418 nScore: int32,
23419 pScoreDetails: *const int32,
23420 cScoreDetailsCount: ::std::os::raw::c_int,
23421 ) -> SteamAPICall_t;
23422}
23423extern "C" {
23424 pub fn SteamAPI_ISteamUserStats_AttachLeaderboardUGC(
23425 self_: *mut ISteamUserStats,
23426 hSteamLeaderboard: SteamLeaderboard_t,
23427 hUGC: UGCHandle_t,
23428 ) -> SteamAPICall_t;
23429}
23430extern "C" {
23431 pub fn SteamAPI_ISteamUserStats_GetNumberOfCurrentPlayers(
23432 self_: *mut ISteamUserStats,
23433 ) -> SteamAPICall_t;
23434}
23435extern "C" {
23436 pub fn SteamAPI_ISteamUserStats_RequestGlobalAchievementPercentages(
23437 self_: *mut ISteamUserStats,
23438 ) -> SteamAPICall_t;
23439}
23440extern "C" {
23441 pub fn SteamAPI_ISteamUserStats_GetMostAchievedAchievementInfo(
23442 self_: *mut ISteamUserStats,
23443 pchName: *mut ::std::os::raw::c_char,
23444 unNameBufLen: uint32,
23445 pflPercent: *mut f32,
23446 pbAchieved: *mut bool,
23447 ) -> ::std::os::raw::c_int;
23448}
23449extern "C" {
23450 pub fn SteamAPI_ISteamUserStats_GetNextMostAchievedAchievementInfo(
23451 self_: *mut ISteamUserStats,
23452 iIteratorPrevious: ::std::os::raw::c_int,
23453 pchName: *mut ::std::os::raw::c_char,
23454 unNameBufLen: uint32,
23455 pflPercent: *mut f32,
23456 pbAchieved: *mut bool,
23457 ) -> ::std::os::raw::c_int;
23458}
23459extern "C" {
23460 pub fn SteamAPI_ISteamUserStats_GetAchievementAchievedPercent(
23461 self_: *mut ISteamUserStats,
23462 pchName: *const ::std::os::raw::c_char,
23463 pflPercent: *mut f32,
23464 ) -> bool;
23465}
23466extern "C" {
23467 pub fn SteamAPI_ISteamUserStats_RequestGlobalStats(
23468 self_: *mut ISteamUserStats,
23469 nHistoryDays: ::std::os::raw::c_int,
23470 ) -> SteamAPICall_t;
23471}
23472extern "C" {
23473 pub fn SteamAPI_ISteamUserStats_GetGlobalStatInt64(
23474 self_: *mut ISteamUserStats,
23475 pchStatName: *const ::std::os::raw::c_char,
23476 pData: *mut int64,
23477 ) -> bool;
23478}
23479extern "C" {
23480 pub fn SteamAPI_ISteamUserStats_GetGlobalStatDouble(
23481 self_: *mut ISteamUserStats,
23482 pchStatName: *const ::std::os::raw::c_char,
23483 pData: *mut f64,
23484 ) -> bool;
23485}
23486extern "C" {
23487 pub fn SteamAPI_ISteamUserStats_GetGlobalStatHistoryInt64(
23488 self_: *mut ISteamUserStats,
23489 pchStatName: *const ::std::os::raw::c_char,
23490 pData: *mut int64,
23491 cubData: uint32,
23492 ) -> int32;
23493}
23494extern "C" {
23495 pub fn SteamAPI_ISteamUserStats_GetGlobalStatHistoryDouble(
23496 self_: *mut ISteamUserStats,
23497 pchStatName: *const ::std::os::raw::c_char,
23498 pData: *mut f64,
23499 cubData: uint32,
23500 ) -> int32;
23501}
23502extern "C" {
23503 pub fn SteamAPI_ISteamUserStats_GetAchievementProgressLimitsInt32(
23504 self_: *mut ISteamUserStats,
23505 pchName: *const ::std::os::raw::c_char,
23506 pnMinProgress: *mut int32,
23507 pnMaxProgress: *mut int32,
23508 ) -> bool;
23509}
23510extern "C" {
23511 pub fn SteamAPI_ISteamUserStats_GetAchievementProgressLimitsFloat(
23512 self_: *mut ISteamUserStats,
23513 pchName: *const ::std::os::raw::c_char,
23514 pfMinProgress: *mut f32,
23515 pfMaxProgress: *mut f32,
23516 ) -> bool;
23517}
23518extern "C" {
23519 pub fn SteamAPI_SteamApps_v009() -> *mut ISteamApps;
23520}
23521extern "C" {
23522 pub fn SteamAPI_ISteamApps_BIsSubscribed(self_: *mut ISteamApps) -> bool;
23523}
23524extern "C" {
23525 pub fn SteamAPI_ISteamApps_BIsLowViolence(self_: *mut ISteamApps) -> bool;
23526}
23527extern "C" {
23528 pub fn SteamAPI_ISteamApps_BIsCybercafe(self_: *mut ISteamApps) -> bool;
23529}
23530extern "C" {
23531 pub fn SteamAPI_ISteamApps_BIsVACBanned(self_: *mut ISteamApps) -> bool;
23532}
23533extern "C" {
23534 pub fn SteamAPI_ISteamApps_GetCurrentGameLanguage(
23535 self_: *mut ISteamApps,
23536 ) -> *const ::std::os::raw::c_char;
23537}
23538extern "C" {
23539 pub fn SteamAPI_ISteamApps_GetAvailableGameLanguages(
23540 self_: *mut ISteamApps,
23541 ) -> *const ::std::os::raw::c_char;
23542}
23543extern "C" {
23544 pub fn SteamAPI_ISteamApps_BIsSubscribedApp(self_: *mut ISteamApps, appID: AppId_t) -> bool;
23545}
23546extern "C" {
23547 pub fn SteamAPI_ISteamApps_BIsDlcInstalled(self_: *mut ISteamApps, appID: AppId_t) -> bool;
23548}
23549extern "C" {
23550 pub fn SteamAPI_ISteamApps_GetEarliestPurchaseUnixTime(
23551 self_: *mut ISteamApps,
23552 nAppID: AppId_t,
23553 ) -> uint32;
23554}
23555extern "C" {
23556 pub fn SteamAPI_ISteamApps_BIsSubscribedFromFreeWeekend(self_: *mut ISteamApps) -> bool;
23557}
23558extern "C" {
23559 pub fn SteamAPI_ISteamApps_GetDLCCount(self_: *mut ISteamApps) -> ::std::os::raw::c_int;
23560}
23561extern "C" {
23562 pub fn SteamAPI_ISteamApps_BGetDLCDataByIndex(
23563 self_: *mut ISteamApps,
23564 iDLC: ::std::os::raw::c_int,
23565 pAppID: *mut AppId_t,
23566 pbAvailable: *mut bool,
23567 pchName: *mut ::std::os::raw::c_char,
23568 cchNameBufferSize: ::std::os::raw::c_int,
23569 ) -> bool;
23570}
23571extern "C" {
23572 pub fn SteamAPI_ISteamApps_InstallDLC(self_: *mut ISteamApps, nAppID: AppId_t);
23573}
23574extern "C" {
23575 pub fn SteamAPI_ISteamApps_UninstallDLC(self_: *mut ISteamApps, nAppID: AppId_t);
23576}
23577extern "C" {
23578 pub fn SteamAPI_ISteamApps_RequestAppProofOfPurchaseKey(
23579 self_: *mut ISteamApps,
23580 nAppID: AppId_t,
23581 );
23582}
23583extern "C" {
23584 pub fn SteamAPI_ISteamApps_GetCurrentBetaName(
23585 self_: *mut ISteamApps,
23586 pchName: *mut ::std::os::raw::c_char,
23587 cchNameBufferSize: ::std::os::raw::c_int,
23588 ) -> bool;
23589}
23590extern "C" {
23591 pub fn SteamAPI_ISteamApps_MarkContentCorrupt(
23592 self_: *mut ISteamApps,
23593 bMissingFilesOnly: bool,
23594 ) -> bool;
23595}
23596extern "C" {
23597 pub fn SteamAPI_ISteamApps_GetInstalledDepots(
23598 self_: *mut ISteamApps,
23599 appID: AppId_t,
23600 pvecDepots: *mut DepotId_t,
23601 cMaxDepots: uint32,
23602 ) -> uint32;
23603}
23604extern "C" {
23605 pub fn SteamAPI_ISteamApps_GetAppInstallDir(
23606 self_: *mut ISteamApps,
23607 appID: AppId_t,
23608 pchFolder: *mut ::std::os::raw::c_char,
23609 cchFolderBufferSize: uint32,
23610 ) -> uint32;
23611}
23612extern "C" {
23613 pub fn SteamAPI_ISteamApps_BIsAppInstalled(self_: *mut ISteamApps, appID: AppId_t) -> bool;
23614}
23615extern "C" {
23616 pub fn SteamAPI_ISteamApps_GetAppOwner(self_: *mut ISteamApps) -> uint64_steamid;
23617}
23618extern "C" {
23619 pub fn SteamAPI_ISteamApps_GetLaunchQueryParam(
23620 self_: *mut ISteamApps,
23621 pchKey: *const ::std::os::raw::c_char,
23622 ) -> *const ::std::os::raw::c_char;
23623}
23624extern "C" {
23625 pub fn SteamAPI_ISteamApps_GetDlcDownloadProgress(
23626 self_: *mut ISteamApps,
23627 nAppID: AppId_t,
23628 punBytesDownloaded: *mut uint64,
23629 punBytesTotal: *mut uint64,
23630 ) -> bool;
23631}
23632extern "C" {
23633 pub fn SteamAPI_ISteamApps_GetAppBuildId(self_: *mut ISteamApps) -> ::std::os::raw::c_int;
23634}
23635extern "C" {
23636 pub fn SteamAPI_ISteamApps_RequestAllProofOfPurchaseKeys(self_: *mut ISteamApps);
23637}
23638extern "C" {
23639 pub fn SteamAPI_ISteamApps_GetFileDetails(
23640 self_: *mut ISteamApps,
23641 pszFileName: *const ::std::os::raw::c_char,
23642 ) -> SteamAPICall_t;
23643}
23644extern "C" {
23645 pub fn SteamAPI_ISteamApps_GetLaunchCommandLine(
23646 self_: *mut ISteamApps,
23647 pszCommandLine: *mut ::std::os::raw::c_char,
23648 cubCommandLine: ::std::os::raw::c_int,
23649 ) -> ::std::os::raw::c_int;
23650}
23651extern "C" {
23652 pub fn SteamAPI_ISteamApps_BIsSubscribedFromFamilySharing(self_: *mut ISteamApps) -> bool;
23653}
23654extern "C" {
23655 pub fn SteamAPI_ISteamApps_BIsTimedTrial(
23656 self_: *mut ISteamApps,
23657 punSecondsAllowed: *mut uint32,
23658 punSecondsPlayed: *mut uint32,
23659 ) -> bool;
23660}
23661extern "C" {
23662 pub fn SteamAPI_ISteamApps_SetDlcContext(self_: *mut ISteamApps, nAppID: AppId_t) -> bool;
23663}
23664extern "C" {
23665 pub fn SteamAPI_ISteamApps_GetNumBetas(
23666 self_: *mut ISteamApps,
23667 pnAvailable: *mut ::std::os::raw::c_int,
23668 pnPrivate: *mut ::std::os::raw::c_int,
23669 ) -> ::std::os::raw::c_int;
23670}
23671extern "C" {
23672 pub fn SteamAPI_ISteamApps_GetBetaInfo(
23673 self_: *mut ISteamApps,
23674 iBetaIndex: ::std::os::raw::c_int,
23675 punFlags: *mut uint32,
23676 punBuildID: *mut uint32,
23677 pchBetaName: *mut ::std::os::raw::c_char,
23678 cchBetaName: ::std::os::raw::c_int,
23679 pchDescription: *mut ::std::os::raw::c_char,
23680 cchDescription: ::std::os::raw::c_int,
23681 punLastUpdated: *mut uint32,
23682 ) -> bool;
23683}
23684extern "C" {
23685 pub fn SteamAPI_ISteamApps_SetActiveBeta(
23686 self_: *mut ISteamApps,
23687 pchBetaName: *const ::std::os::raw::c_char,
23688 ) -> bool;
23689}
23690extern "C" {
23691 pub fn SteamAPI_SteamNetworking_v006() -> *mut ISteamNetworking;
23692}
23693extern "C" {
23694 pub fn SteamAPI_SteamGameServerNetworking_v006() -> *mut ISteamNetworking;
23695}
23696extern "C" {
23697 pub fn SteamAPI_ISteamNetworking_SendP2PPacket(
23698 self_: *mut ISteamNetworking,
23699 steamIDRemote: uint64_steamid,
23700 pubData: *const ::std::os::raw::c_void,
23701 cubData: uint32,
23702 eP2PSendType: EP2PSend,
23703 nChannel: ::std::os::raw::c_int,
23704 ) -> bool;
23705}
23706extern "C" {
23707 pub fn SteamAPI_ISteamNetworking_IsP2PPacketAvailable(
23708 self_: *mut ISteamNetworking,
23709 pcubMsgSize: *mut uint32,
23710 nChannel: ::std::os::raw::c_int,
23711 ) -> bool;
23712}
23713extern "C" {
23714 pub fn SteamAPI_ISteamNetworking_ReadP2PPacket(
23715 self_: *mut ISteamNetworking,
23716 pubDest: *mut ::std::os::raw::c_void,
23717 cubDest: uint32,
23718 pcubMsgSize: *mut uint32,
23719 psteamIDRemote: *mut CSteamID,
23720 nChannel: ::std::os::raw::c_int,
23721 ) -> bool;
23722}
23723extern "C" {
23724 pub fn SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser(
23725 self_: *mut ISteamNetworking,
23726 steamIDRemote: uint64_steamid,
23727 ) -> bool;
23728}
23729extern "C" {
23730 pub fn SteamAPI_ISteamNetworking_CloseP2PSessionWithUser(
23731 self_: *mut ISteamNetworking,
23732 steamIDRemote: uint64_steamid,
23733 ) -> bool;
23734}
23735extern "C" {
23736 pub fn SteamAPI_ISteamNetworking_CloseP2PChannelWithUser(
23737 self_: *mut ISteamNetworking,
23738 steamIDRemote: uint64_steamid,
23739 nChannel: ::std::os::raw::c_int,
23740 ) -> bool;
23741}
23742extern "C" {
23743 pub fn SteamAPI_ISteamNetworking_GetP2PSessionState(
23744 self_: *mut ISteamNetworking,
23745 steamIDRemote: uint64_steamid,
23746 pConnectionState: *mut P2PSessionState_t,
23747 ) -> bool;
23748}
23749extern "C" {
23750 pub fn SteamAPI_ISteamNetworking_AllowP2PPacketRelay(
23751 self_: *mut ISteamNetworking,
23752 bAllow: bool,
23753 ) -> bool;
23754}
23755extern "C" {
23756 pub fn SteamAPI_ISteamNetworking_CreateListenSocket(
23757 self_: *mut ISteamNetworking,
23758 nVirtualP2PPort: ::std::os::raw::c_int,
23759 nIP: SteamIPAddress_t,
23760 nPort: uint16,
23761 bAllowUseOfPacketRelay: bool,
23762 ) -> SNetListenSocket_t;
23763}
23764extern "C" {
23765 pub fn SteamAPI_ISteamNetworking_CreateP2PConnectionSocket(
23766 self_: *mut ISteamNetworking,
23767 steamIDTarget: uint64_steamid,
23768 nVirtualPort: ::std::os::raw::c_int,
23769 nTimeoutSec: ::std::os::raw::c_int,
23770 bAllowUseOfPacketRelay: bool,
23771 ) -> SNetSocket_t;
23772}
23773extern "C" {
23774 pub fn SteamAPI_ISteamNetworking_CreateConnectionSocket(
23775 self_: *mut ISteamNetworking,
23776 nIP: SteamIPAddress_t,
23777 nPort: uint16,
23778 nTimeoutSec: ::std::os::raw::c_int,
23779 ) -> SNetSocket_t;
23780}
23781extern "C" {
23782 pub fn SteamAPI_ISteamNetworking_DestroySocket(
23783 self_: *mut ISteamNetworking,
23784 hSocket: SNetSocket_t,
23785 bNotifyRemoteEnd: bool,
23786 ) -> bool;
23787}
23788extern "C" {
23789 pub fn SteamAPI_ISteamNetworking_DestroyListenSocket(
23790 self_: *mut ISteamNetworking,
23791 hSocket: SNetListenSocket_t,
23792 bNotifyRemoteEnd: bool,
23793 ) -> bool;
23794}
23795extern "C" {
23796 pub fn SteamAPI_ISteamNetworking_SendDataOnSocket(
23797 self_: *mut ISteamNetworking,
23798 hSocket: SNetSocket_t,
23799 pubData: *mut ::std::os::raw::c_void,
23800 cubData: uint32,
23801 bReliable: bool,
23802 ) -> bool;
23803}
23804extern "C" {
23805 pub fn SteamAPI_ISteamNetworking_IsDataAvailableOnSocket(
23806 self_: *mut ISteamNetworking,
23807 hSocket: SNetSocket_t,
23808 pcubMsgSize: *mut uint32,
23809 ) -> bool;
23810}
23811extern "C" {
23812 pub fn SteamAPI_ISteamNetworking_RetrieveDataFromSocket(
23813 self_: *mut ISteamNetworking,
23814 hSocket: SNetSocket_t,
23815 pubDest: *mut ::std::os::raw::c_void,
23816 cubDest: uint32,
23817 pcubMsgSize: *mut uint32,
23818 ) -> bool;
23819}
23820extern "C" {
23821 pub fn SteamAPI_ISteamNetworking_IsDataAvailable(
23822 self_: *mut ISteamNetworking,
23823 hListenSocket: SNetListenSocket_t,
23824 pcubMsgSize: *mut uint32,
23825 phSocket: *mut SNetSocket_t,
23826 ) -> bool;
23827}
23828extern "C" {
23829 pub fn SteamAPI_ISteamNetworking_RetrieveData(
23830 self_: *mut ISteamNetworking,
23831 hListenSocket: SNetListenSocket_t,
23832 pubDest: *mut ::std::os::raw::c_void,
23833 cubDest: uint32,
23834 pcubMsgSize: *mut uint32,
23835 phSocket: *mut SNetSocket_t,
23836 ) -> bool;
23837}
23838extern "C" {
23839 pub fn SteamAPI_ISteamNetworking_GetSocketInfo(
23840 self_: *mut ISteamNetworking,
23841 hSocket: SNetSocket_t,
23842 pSteamIDRemote: *mut CSteamID,
23843 peSocketStatus: *mut ::std::os::raw::c_int,
23844 punIPRemote: *mut SteamIPAddress_t,
23845 punPortRemote: *mut uint16,
23846 ) -> bool;
23847}
23848extern "C" {
23849 pub fn SteamAPI_ISteamNetworking_GetListenSocketInfo(
23850 self_: *mut ISteamNetworking,
23851 hListenSocket: SNetListenSocket_t,
23852 pnIP: *mut SteamIPAddress_t,
23853 pnPort: *mut uint16,
23854 ) -> bool;
23855}
23856extern "C" {
23857 pub fn SteamAPI_ISteamNetworking_GetSocketConnectionType(
23858 self_: *mut ISteamNetworking,
23859 hSocket: SNetSocket_t,
23860 ) -> ESNetSocketConnectionType;
23861}
23862extern "C" {
23863 pub fn SteamAPI_ISteamNetworking_GetMaxPacketSize(
23864 self_: *mut ISteamNetworking,
23865 hSocket: SNetSocket_t,
23866 ) -> ::std::os::raw::c_int;
23867}
23868extern "C" {
23869 pub fn SteamAPI_SteamScreenshots_v003() -> *mut ISteamScreenshots;
23870}
23871extern "C" {
23872 pub fn SteamAPI_ISteamScreenshots_WriteScreenshot(
23873 self_: *mut ISteamScreenshots,
23874 pubRGB: *mut ::std::os::raw::c_void,
23875 cubRGB: uint32,
23876 nWidth: ::std::os::raw::c_int,
23877 nHeight: ::std::os::raw::c_int,
23878 ) -> ScreenshotHandle;
23879}
23880extern "C" {
23881 pub fn SteamAPI_ISteamScreenshots_AddScreenshotToLibrary(
23882 self_: *mut ISteamScreenshots,
23883 pchFilename: *const ::std::os::raw::c_char,
23884 pchThumbnailFilename: *const ::std::os::raw::c_char,
23885 nWidth: ::std::os::raw::c_int,
23886 nHeight: ::std::os::raw::c_int,
23887 ) -> ScreenshotHandle;
23888}
23889extern "C" {
23890 pub fn SteamAPI_ISteamScreenshots_TriggerScreenshot(self_: *mut ISteamScreenshots);
23891}
23892extern "C" {
23893 pub fn SteamAPI_ISteamScreenshots_HookScreenshots(self_: *mut ISteamScreenshots, bHook: bool);
23894}
23895extern "C" {
23896 pub fn SteamAPI_ISteamScreenshots_SetLocation(
23897 self_: *mut ISteamScreenshots,
23898 hScreenshot: ScreenshotHandle,
23899 pchLocation: *const ::std::os::raw::c_char,
23900 ) -> bool;
23901}
23902extern "C" {
23903 pub fn SteamAPI_ISteamScreenshots_TagUser(
23904 self_: *mut ISteamScreenshots,
23905 hScreenshot: ScreenshotHandle,
23906 steamID: uint64_steamid,
23907 ) -> bool;
23908}
23909extern "C" {
23910 pub fn SteamAPI_ISteamScreenshots_TagPublishedFile(
23911 self_: *mut ISteamScreenshots,
23912 hScreenshot: ScreenshotHandle,
23913 unPublishedFileID: PublishedFileId_t,
23914 ) -> bool;
23915}
23916extern "C" {
23917 pub fn SteamAPI_ISteamScreenshots_IsScreenshotsHooked(self_: *mut ISteamScreenshots) -> bool;
23918}
23919extern "C" {
23920 pub fn SteamAPI_ISteamScreenshots_AddVRScreenshotToLibrary(
23921 self_: *mut ISteamScreenshots,
23922 eType: EVRScreenshotType,
23923 pchFilename: *const ::std::os::raw::c_char,
23924 pchVRFilename: *const ::std::os::raw::c_char,
23925 ) -> ScreenshotHandle;
23926}
23927extern "C" {
23928 pub fn SteamAPI_SteamMusic_v001() -> *mut ISteamMusic;
23929}
23930extern "C" {
23931 pub fn SteamAPI_ISteamMusic_BIsEnabled(self_: *mut ISteamMusic) -> bool;
23932}
23933extern "C" {
23934 pub fn SteamAPI_ISteamMusic_BIsPlaying(self_: *mut ISteamMusic) -> bool;
23935}
23936extern "C" {
23937 pub fn SteamAPI_ISteamMusic_GetPlaybackStatus(self_: *mut ISteamMusic) -> AudioPlayback_Status;
23938}
23939extern "C" {
23940 pub fn SteamAPI_ISteamMusic_Play(self_: *mut ISteamMusic);
23941}
23942extern "C" {
23943 pub fn SteamAPI_ISteamMusic_Pause(self_: *mut ISteamMusic);
23944}
23945extern "C" {
23946 pub fn SteamAPI_ISteamMusic_PlayPrevious(self_: *mut ISteamMusic);
23947}
23948extern "C" {
23949 pub fn SteamAPI_ISteamMusic_PlayNext(self_: *mut ISteamMusic);
23950}
23951extern "C" {
23952 pub fn SteamAPI_ISteamMusic_SetVolume(self_: *mut ISteamMusic, flVolume: f32);
23953}
23954extern "C" {
23955 pub fn SteamAPI_ISteamMusic_GetVolume(self_: *mut ISteamMusic) -> f32;
23956}
23957extern "C" {
23958 pub fn SteamAPI_SteamHTTP_v003() -> *mut ISteamHTTP;
23959}
23960extern "C" {
23961 pub fn SteamAPI_SteamGameServerHTTP_v003() -> *mut ISteamHTTP;
23962}
23963extern "C" {
23964 pub fn SteamAPI_ISteamHTTP_CreateHTTPRequest(
23965 self_: *mut ISteamHTTP,
23966 eHTTPRequestMethod: EHTTPMethod,
23967 pchAbsoluteURL: *const ::std::os::raw::c_char,
23968 ) -> HTTPRequestHandle;
23969}
23970extern "C" {
23971 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestContextValue(
23972 self_: *mut ISteamHTTP,
23973 hRequest: HTTPRequestHandle,
23974 ulContextValue: uint64,
23975 ) -> bool;
23976}
23977extern "C" {
23978 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestNetworkActivityTimeout(
23979 self_: *mut ISteamHTTP,
23980 hRequest: HTTPRequestHandle,
23981 unTimeoutSeconds: uint32,
23982 ) -> bool;
23983}
23984extern "C" {
23985 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestHeaderValue(
23986 self_: *mut ISteamHTTP,
23987 hRequest: HTTPRequestHandle,
23988 pchHeaderName: *const ::std::os::raw::c_char,
23989 pchHeaderValue: *const ::std::os::raw::c_char,
23990 ) -> bool;
23991}
23992extern "C" {
23993 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestGetOrPostParameter(
23994 self_: *mut ISteamHTTP,
23995 hRequest: HTTPRequestHandle,
23996 pchParamName: *const ::std::os::raw::c_char,
23997 pchParamValue: *const ::std::os::raw::c_char,
23998 ) -> bool;
23999}
24000extern "C" {
24001 pub fn SteamAPI_ISteamHTTP_SendHTTPRequest(
24002 self_: *mut ISteamHTTP,
24003 hRequest: HTTPRequestHandle,
24004 pCallHandle: *mut SteamAPICall_t,
24005 ) -> bool;
24006}
24007extern "C" {
24008 pub fn SteamAPI_ISteamHTTP_SendHTTPRequestAndStreamResponse(
24009 self_: *mut ISteamHTTP,
24010 hRequest: HTTPRequestHandle,
24011 pCallHandle: *mut SteamAPICall_t,
24012 ) -> bool;
24013}
24014extern "C" {
24015 pub fn SteamAPI_ISteamHTTP_DeferHTTPRequest(
24016 self_: *mut ISteamHTTP,
24017 hRequest: HTTPRequestHandle,
24018 ) -> bool;
24019}
24020extern "C" {
24021 pub fn SteamAPI_ISteamHTTP_PrioritizeHTTPRequest(
24022 self_: *mut ISteamHTTP,
24023 hRequest: HTTPRequestHandle,
24024 ) -> bool;
24025}
24026extern "C" {
24027 pub fn SteamAPI_ISteamHTTP_GetHTTPResponseHeaderSize(
24028 self_: *mut ISteamHTTP,
24029 hRequest: HTTPRequestHandle,
24030 pchHeaderName: *const ::std::os::raw::c_char,
24031 unResponseHeaderSize: *mut uint32,
24032 ) -> bool;
24033}
24034extern "C" {
24035 pub fn SteamAPI_ISteamHTTP_GetHTTPResponseHeaderValue(
24036 self_: *mut ISteamHTTP,
24037 hRequest: HTTPRequestHandle,
24038 pchHeaderName: *const ::std::os::raw::c_char,
24039 pHeaderValueBuffer: *mut uint8,
24040 unBufferSize: uint32,
24041 ) -> bool;
24042}
24043extern "C" {
24044 pub fn SteamAPI_ISteamHTTP_GetHTTPResponseBodySize(
24045 self_: *mut ISteamHTTP,
24046 hRequest: HTTPRequestHandle,
24047 unBodySize: *mut uint32,
24048 ) -> bool;
24049}
24050extern "C" {
24051 pub fn SteamAPI_ISteamHTTP_GetHTTPResponseBodyData(
24052 self_: *mut ISteamHTTP,
24053 hRequest: HTTPRequestHandle,
24054 pBodyDataBuffer: *mut uint8,
24055 unBufferSize: uint32,
24056 ) -> bool;
24057}
24058extern "C" {
24059 pub fn SteamAPI_ISteamHTTP_GetHTTPStreamingResponseBodyData(
24060 self_: *mut ISteamHTTP,
24061 hRequest: HTTPRequestHandle,
24062 cOffset: uint32,
24063 pBodyDataBuffer: *mut uint8,
24064 unBufferSize: uint32,
24065 ) -> bool;
24066}
24067extern "C" {
24068 pub fn SteamAPI_ISteamHTTP_ReleaseHTTPRequest(
24069 self_: *mut ISteamHTTP,
24070 hRequest: HTTPRequestHandle,
24071 ) -> bool;
24072}
24073extern "C" {
24074 pub fn SteamAPI_ISteamHTTP_GetHTTPDownloadProgressPct(
24075 self_: *mut ISteamHTTP,
24076 hRequest: HTTPRequestHandle,
24077 pflPercentOut: *mut f32,
24078 ) -> bool;
24079}
24080extern "C" {
24081 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestRawPostBody(
24082 self_: *mut ISteamHTTP,
24083 hRequest: HTTPRequestHandle,
24084 pchContentType: *const ::std::os::raw::c_char,
24085 pubBody: *mut uint8,
24086 unBodyLen: uint32,
24087 ) -> bool;
24088}
24089extern "C" {
24090 pub fn SteamAPI_ISteamHTTP_CreateCookieContainer(
24091 self_: *mut ISteamHTTP,
24092 bAllowResponsesToModify: bool,
24093 ) -> HTTPCookieContainerHandle;
24094}
24095extern "C" {
24096 pub fn SteamAPI_ISteamHTTP_ReleaseCookieContainer(
24097 self_: *mut ISteamHTTP,
24098 hCookieContainer: HTTPCookieContainerHandle,
24099 ) -> bool;
24100}
24101extern "C" {
24102 pub fn SteamAPI_ISteamHTTP_SetCookie(
24103 self_: *mut ISteamHTTP,
24104 hCookieContainer: HTTPCookieContainerHandle,
24105 pchHost: *const ::std::os::raw::c_char,
24106 pchUrl: *const ::std::os::raw::c_char,
24107 pchCookie: *const ::std::os::raw::c_char,
24108 ) -> bool;
24109}
24110extern "C" {
24111 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestCookieContainer(
24112 self_: *mut ISteamHTTP,
24113 hRequest: HTTPRequestHandle,
24114 hCookieContainer: HTTPCookieContainerHandle,
24115 ) -> bool;
24116}
24117extern "C" {
24118 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestUserAgentInfo(
24119 self_: *mut ISteamHTTP,
24120 hRequest: HTTPRequestHandle,
24121 pchUserAgentInfo: *const ::std::os::raw::c_char,
24122 ) -> bool;
24123}
24124extern "C" {
24125 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestRequiresVerifiedCertificate(
24126 self_: *mut ISteamHTTP,
24127 hRequest: HTTPRequestHandle,
24128 bRequireVerifiedCertificate: bool,
24129 ) -> bool;
24130}
24131extern "C" {
24132 pub fn SteamAPI_ISteamHTTP_SetHTTPRequestAbsoluteTimeoutMS(
24133 self_: *mut ISteamHTTP,
24134 hRequest: HTTPRequestHandle,
24135 unMilliseconds: uint32,
24136 ) -> bool;
24137}
24138extern "C" {
24139 pub fn SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut(
24140 self_: *mut ISteamHTTP,
24141 hRequest: HTTPRequestHandle,
24142 pbWasTimedOut: *mut bool,
24143 ) -> bool;
24144}
24145extern "C" {
24146 pub fn SteamAPI_SteamInput_v006() -> *mut ISteamInput;
24147}
24148extern "C" {
24149 pub fn SteamAPI_ISteamInput_Init(
24150 self_: *mut ISteamInput,
24151 bExplicitlyCallRunFrame: bool,
24152 ) -> bool;
24153}
24154extern "C" {
24155 pub fn SteamAPI_ISteamInput_Shutdown(self_: *mut ISteamInput) -> bool;
24156}
24157extern "C" {
24158 pub fn SteamAPI_ISteamInput_SetInputActionManifestFilePath(
24159 self_: *mut ISteamInput,
24160 pchInputActionManifestAbsolutePath: *const ::std::os::raw::c_char,
24161 ) -> bool;
24162}
24163extern "C" {
24164 pub fn SteamAPI_ISteamInput_RunFrame(self_: *mut ISteamInput, bReservedValue: bool);
24165}
24166extern "C" {
24167 pub fn SteamAPI_ISteamInput_BWaitForData(
24168 self_: *mut ISteamInput,
24169 bWaitForever: bool,
24170 unTimeout: uint32,
24171 ) -> bool;
24172}
24173extern "C" {
24174 pub fn SteamAPI_ISteamInput_BNewDataAvailable(self_: *mut ISteamInput) -> bool;
24175}
24176extern "C" {
24177 pub fn SteamAPI_ISteamInput_GetConnectedControllers(
24178 self_: *mut ISteamInput,
24179 handlesOut: *mut InputHandle_t,
24180 ) -> ::std::os::raw::c_int;
24181}
24182extern "C" {
24183 pub fn SteamAPI_ISteamInput_EnableDeviceCallbacks(self_: *mut ISteamInput);
24184}
24185extern "C" {
24186 pub fn SteamAPI_ISteamInput_EnableActionEventCallbacks(
24187 self_: *mut ISteamInput,
24188 pCallback: SteamInputActionEventCallbackPointer,
24189 );
24190}
24191extern "C" {
24192 pub fn SteamAPI_ISteamInput_GetActionSetHandle(
24193 self_: *mut ISteamInput,
24194 pszActionSetName: *const ::std::os::raw::c_char,
24195 ) -> InputActionSetHandle_t;
24196}
24197extern "C" {
24198 pub fn SteamAPI_ISteamInput_ActivateActionSet(
24199 self_: *mut ISteamInput,
24200 inputHandle: InputHandle_t,
24201 actionSetHandle: InputActionSetHandle_t,
24202 );
24203}
24204extern "C" {
24205 pub fn SteamAPI_ISteamInput_GetCurrentActionSet(
24206 self_: *mut ISteamInput,
24207 inputHandle: InputHandle_t,
24208 ) -> InputActionSetHandle_t;
24209}
24210extern "C" {
24211 pub fn SteamAPI_ISteamInput_ActivateActionSetLayer(
24212 self_: *mut ISteamInput,
24213 inputHandle: InputHandle_t,
24214 actionSetLayerHandle: InputActionSetHandle_t,
24215 );
24216}
24217extern "C" {
24218 pub fn SteamAPI_ISteamInput_DeactivateActionSetLayer(
24219 self_: *mut ISteamInput,
24220 inputHandle: InputHandle_t,
24221 actionSetLayerHandle: InputActionSetHandle_t,
24222 );
24223}
24224extern "C" {
24225 pub fn SteamAPI_ISteamInput_DeactivateAllActionSetLayers(
24226 self_: *mut ISteamInput,
24227 inputHandle: InputHandle_t,
24228 );
24229}
24230extern "C" {
24231 pub fn SteamAPI_ISteamInput_GetActiveActionSetLayers(
24232 self_: *mut ISteamInput,
24233 inputHandle: InputHandle_t,
24234 handlesOut: *mut InputActionSetHandle_t,
24235 ) -> ::std::os::raw::c_int;
24236}
24237extern "C" {
24238 pub fn SteamAPI_ISteamInput_GetDigitalActionHandle(
24239 self_: *mut ISteamInput,
24240 pszActionName: *const ::std::os::raw::c_char,
24241 ) -> InputDigitalActionHandle_t;
24242}
24243extern "C" {
24244 pub fn SteamAPI_ISteamInput_GetDigitalActionData(
24245 self_: *mut ISteamInput,
24246 inputHandle: InputHandle_t,
24247 digitalActionHandle: InputDigitalActionHandle_t,
24248 ) -> InputDigitalActionData_t;
24249}
24250extern "C" {
24251 pub fn SteamAPI_ISteamInput_GetDigitalActionOrigins(
24252 self_: *mut ISteamInput,
24253 inputHandle: InputHandle_t,
24254 actionSetHandle: InputActionSetHandle_t,
24255 digitalActionHandle: InputDigitalActionHandle_t,
24256 originsOut: *mut EInputActionOrigin,
24257 ) -> ::std::os::raw::c_int;
24258}
24259extern "C" {
24260 pub fn SteamAPI_ISteamInput_GetStringForDigitalActionName(
24261 self_: *mut ISteamInput,
24262 eActionHandle: InputDigitalActionHandle_t,
24263 ) -> *const ::std::os::raw::c_char;
24264}
24265extern "C" {
24266 pub fn SteamAPI_ISteamInput_GetAnalogActionHandle(
24267 self_: *mut ISteamInput,
24268 pszActionName: *const ::std::os::raw::c_char,
24269 ) -> InputAnalogActionHandle_t;
24270}
24271extern "C" {
24272 pub fn SteamAPI_ISteamInput_GetAnalogActionData(
24273 self_: *mut ISteamInput,
24274 inputHandle: InputHandle_t,
24275 analogActionHandle: InputAnalogActionHandle_t,
24276 ) -> InputAnalogActionData_t;
24277}
24278extern "C" {
24279 pub fn SteamAPI_ISteamInput_GetAnalogActionOrigins(
24280 self_: *mut ISteamInput,
24281 inputHandle: InputHandle_t,
24282 actionSetHandle: InputActionSetHandle_t,
24283 analogActionHandle: InputAnalogActionHandle_t,
24284 originsOut: *mut EInputActionOrigin,
24285 ) -> ::std::os::raw::c_int;
24286}
24287extern "C" {
24288 pub fn SteamAPI_ISteamInput_GetGlyphPNGForActionOrigin(
24289 self_: *mut ISteamInput,
24290 eOrigin: EInputActionOrigin,
24291 eSize: ESteamInputGlyphSize,
24292 unFlags: uint32,
24293 ) -> *const ::std::os::raw::c_char;
24294}
24295extern "C" {
24296 pub fn SteamAPI_ISteamInput_GetGlyphSVGForActionOrigin(
24297 self_: *mut ISteamInput,
24298 eOrigin: EInputActionOrigin,
24299 unFlags: uint32,
24300 ) -> *const ::std::os::raw::c_char;
24301}
24302extern "C" {
24303 pub fn SteamAPI_ISteamInput_GetGlyphForActionOrigin_Legacy(
24304 self_: *mut ISteamInput,
24305 eOrigin: EInputActionOrigin,
24306 ) -> *const ::std::os::raw::c_char;
24307}
24308extern "C" {
24309 pub fn SteamAPI_ISteamInput_GetStringForActionOrigin(
24310 self_: *mut ISteamInput,
24311 eOrigin: EInputActionOrigin,
24312 ) -> *const ::std::os::raw::c_char;
24313}
24314extern "C" {
24315 pub fn SteamAPI_ISteamInput_GetStringForAnalogActionName(
24316 self_: *mut ISteamInput,
24317 eActionHandle: InputAnalogActionHandle_t,
24318 ) -> *const ::std::os::raw::c_char;
24319}
24320extern "C" {
24321 pub fn SteamAPI_ISteamInput_StopAnalogActionMomentum(
24322 self_: *mut ISteamInput,
24323 inputHandle: InputHandle_t,
24324 eAction: InputAnalogActionHandle_t,
24325 );
24326}
24327extern "C" {
24328 pub fn SteamAPI_ISteamInput_GetMotionData(
24329 self_: *mut ISteamInput,
24330 inputHandle: InputHandle_t,
24331 ) -> InputMotionData_t;
24332}
24333extern "C" {
24334 pub fn SteamAPI_ISteamInput_TriggerVibration(
24335 self_: *mut ISteamInput,
24336 inputHandle: InputHandle_t,
24337 usLeftSpeed: ::std::os::raw::c_ushort,
24338 usRightSpeed: ::std::os::raw::c_ushort,
24339 );
24340}
24341extern "C" {
24342 pub fn SteamAPI_ISteamInput_TriggerVibrationExtended(
24343 self_: *mut ISteamInput,
24344 inputHandle: InputHandle_t,
24345 usLeftSpeed: ::std::os::raw::c_ushort,
24346 usRightSpeed: ::std::os::raw::c_ushort,
24347 usLeftTriggerSpeed: ::std::os::raw::c_ushort,
24348 usRightTriggerSpeed: ::std::os::raw::c_ushort,
24349 );
24350}
24351extern "C" {
24352 pub fn SteamAPI_ISteamInput_TriggerSimpleHapticEvent(
24353 self_: *mut ISteamInput,
24354 inputHandle: InputHandle_t,
24355 eHapticLocation: EControllerHapticLocation,
24356 nIntensity: uint8,
24357 nGainDB: ::std::os::raw::c_char,
24358 nOtherIntensity: uint8,
24359 nOtherGainDB: ::std::os::raw::c_char,
24360 );
24361}
24362extern "C" {
24363 pub fn SteamAPI_ISteamInput_SetLEDColor(
24364 self_: *mut ISteamInput,
24365 inputHandle: InputHandle_t,
24366 nColorR: uint8,
24367 nColorG: uint8,
24368 nColorB: uint8,
24369 nFlags: ::std::os::raw::c_uint,
24370 );
24371}
24372extern "C" {
24373 pub fn SteamAPI_ISteamInput_Legacy_TriggerHapticPulse(
24374 self_: *mut ISteamInput,
24375 inputHandle: InputHandle_t,
24376 eTargetPad: ESteamControllerPad,
24377 usDurationMicroSec: ::std::os::raw::c_ushort,
24378 );
24379}
24380extern "C" {
24381 pub fn SteamAPI_ISteamInput_Legacy_TriggerRepeatedHapticPulse(
24382 self_: *mut ISteamInput,
24383 inputHandle: InputHandle_t,
24384 eTargetPad: ESteamControllerPad,
24385 usDurationMicroSec: ::std::os::raw::c_ushort,
24386 usOffMicroSec: ::std::os::raw::c_ushort,
24387 unRepeat: ::std::os::raw::c_ushort,
24388 nFlags: ::std::os::raw::c_uint,
24389 );
24390}
24391extern "C" {
24392 pub fn SteamAPI_ISteamInput_ShowBindingPanel(
24393 self_: *mut ISteamInput,
24394 inputHandle: InputHandle_t,
24395 ) -> bool;
24396}
24397extern "C" {
24398 pub fn SteamAPI_ISteamInput_GetInputTypeForHandle(
24399 self_: *mut ISteamInput,
24400 inputHandle: InputHandle_t,
24401 ) -> ESteamInputType;
24402}
24403extern "C" {
24404 pub fn SteamAPI_ISteamInput_GetControllerForGamepadIndex(
24405 self_: *mut ISteamInput,
24406 nIndex: ::std::os::raw::c_int,
24407 ) -> InputHandle_t;
24408}
24409extern "C" {
24410 pub fn SteamAPI_ISteamInput_GetGamepadIndexForController(
24411 self_: *mut ISteamInput,
24412 ulinputHandle: InputHandle_t,
24413 ) -> ::std::os::raw::c_int;
24414}
24415extern "C" {
24416 pub fn SteamAPI_ISteamInput_GetStringForXboxOrigin(
24417 self_: *mut ISteamInput,
24418 eOrigin: EXboxOrigin,
24419 ) -> *const ::std::os::raw::c_char;
24420}
24421extern "C" {
24422 pub fn SteamAPI_ISteamInput_GetGlyphForXboxOrigin(
24423 self_: *mut ISteamInput,
24424 eOrigin: EXboxOrigin,
24425 ) -> *const ::std::os::raw::c_char;
24426}
24427extern "C" {
24428 pub fn SteamAPI_ISteamInput_GetActionOriginFromXboxOrigin(
24429 self_: *mut ISteamInput,
24430 inputHandle: InputHandle_t,
24431 eOrigin: EXboxOrigin,
24432 ) -> EInputActionOrigin;
24433}
24434extern "C" {
24435 pub fn SteamAPI_ISteamInput_TranslateActionOrigin(
24436 self_: *mut ISteamInput,
24437 eDestinationInputType: ESteamInputType,
24438 eSourceOrigin: EInputActionOrigin,
24439 ) -> EInputActionOrigin;
24440}
24441extern "C" {
24442 pub fn SteamAPI_ISteamInput_GetDeviceBindingRevision(
24443 self_: *mut ISteamInput,
24444 inputHandle: InputHandle_t,
24445 pMajor: *mut ::std::os::raw::c_int,
24446 pMinor: *mut ::std::os::raw::c_int,
24447 ) -> bool;
24448}
24449extern "C" {
24450 pub fn SteamAPI_ISteamInput_GetRemotePlaySessionID(
24451 self_: *mut ISteamInput,
24452 inputHandle: InputHandle_t,
24453 ) -> uint32;
24454}
24455extern "C" {
24456 pub fn SteamAPI_ISteamInput_GetSessionInputConfigurationSettings(
24457 self_: *mut ISteamInput,
24458 ) -> uint16;
24459}
24460extern "C" {
24461 pub fn SteamAPI_ISteamInput_SetDualSenseTriggerEffect(
24462 self_: *mut ISteamInput,
24463 inputHandle: InputHandle_t,
24464 pParam: *const ScePadTriggerEffectParam,
24465 );
24466}
24467extern "C" {
24468 pub fn SteamAPI_SteamController_v008() -> *mut ISteamController;
24469}
24470extern "C" {
24471 pub fn SteamAPI_ISteamController_Init(self_: *mut ISteamController) -> bool;
24472}
24473extern "C" {
24474 pub fn SteamAPI_ISteamController_Shutdown(self_: *mut ISteamController) -> bool;
24475}
24476extern "C" {
24477 pub fn SteamAPI_ISteamController_RunFrame(self_: *mut ISteamController);
24478}
24479extern "C" {
24480 pub fn SteamAPI_ISteamController_GetConnectedControllers(
24481 self_: *mut ISteamController,
24482 handlesOut: *mut ControllerHandle_t,
24483 ) -> ::std::os::raw::c_int;
24484}
24485extern "C" {
24486 pub fn SteamAPI_ISteamController_GetActionSetHandle(
24487 self_: *mut ISteamController,
24488 pszActionSetName: *const ::std::os::raw::c_char,
24489 ) -> ControllerActionSetHandle_t;
24490}
24491extern "C" {
24492 pub fn SteamAPI_ISteamController_ActivateActionSet(
24493 self_: *mut ISteamController,
24494 controllerHandle: ControllerHandle_t,
24495 actionSetHandle: ControllerActionSetHandle_t,
24496 );
24497}
24498extern "C" {
24499 pub fn SteamAPI_ISteamController_GetCurrentActionSet(
24500 self_: *mut ISteamController,
24501 controllerHandle: ControllerHandle_t,
24502 ) -> ControllerActionSetHandle_t;
24503}
24504extern "C" {
24505 pub fn SteamAPI_ISteamController_ActivateActionSetLayer(
24506 self_: *mut ISteamController,
24507 controllerHandle: ControllerHandle_t,
24508 actionSetLayerHandle: ControllerActionSetHandle_t,
24509 );
24510}
24511extern "C" {
24512 pub fn SteamAPI_ISteamController_DeactivateActionSetLayer(
24513 self_: *mut ISteamController,
24514 controllerHandle: ControllerHandle_t,
24515 actionSetLayerHandle: ControllerActionSetHandle_t,
24516 );
24517}
24518extern "C" {
24519 pub fn SteamAPI_ISteamController_DeactivateAllActionSetLayers(
24520 self_: *mut ISteamController,
24521 controllerHandle: ControllerHandle_t,
24522 );
24523}
24524extern "C" {
24525 pub fn SteamAPI_ISteamController_GetActiveActionSetLayers(
24526 self_: *mut ISteamController,
24527 controllerHandle: ControllerHandle_t,
24528 handlesOut: *mut ControllerActionSetHandle_t,
24529 ) -> ::std::os::raw::c_int;
24530}
24531extern "C" {
24532 pub fn SteamAPI_ISteamController_GetDigitalActionHandle(
24533 self_: *mut ISteamController,
24534 pszActionName: *const ::std::os::raw::c_char,
24535 ) -> ControllerDigitalActionHandle_t;
24536}
24537extern "C" {
24538 pub fn SteamAPI_ISteamController_GetDigitalActionData(
24539 self_: *mut ISteamController,
24540 controllerHandle: ControllerHandle_t,
24541 digitalActionHandle: ControllerDigitalActionHandle_t,
24542 ) -> InputDigitalActionData_t;
24543}
24544extern "C" {
24545 pub fn SteamAPI_ISteamController_GetDigitalActionOrigins(
24546 self_: *mut ISteamController,
24547 controllerHandle: ControllerHandle_t,
24548 actionSetHandle: ControllerActionSetHandle_t,
24549 digitalActionHandle: ControllerDigitalActionHandle_t,
24550 originsOut: *mut EControllerActionOrigin,
24551 ) -> ::std::os::raw::c_int;
24552}
24553extern "C" {
24554 pub fn SteamAPI_ISteamController_GetAnalogActionHandle(
24555 self_: *mut ISteamController,
24556 pszActionName: *const ::std::os::raw::c_char,
24557 ) -> ControllerAnalogActionHandle_t;
24558}
24559extern "C" {
24560 pub fn SteamAPI_ISteamController_GetAnalogActionData(
24561 self_: *mut ISteamController,
24562 controllerHandle: ControllerHandle_t,
24563 analogActionHandle: ControllerAnalogActionHandle_t,
24564 ) -> InputAnalogActionData_t;
24565}
24566extern "C" {
24567 pub fn SteamAPI_ISteamController_GetAnalogActionOrigins(
24568 self_: *mut ISteamController,
24569 controllerHandle: ControllerHandle_t,
24570 actionSetHandle: ControllerActionSetHandle_t,
24571 analogActionHandle: ControllerAnalogActionHandle_t,
24572 originsOut: *mut EControllerActionOrigin,
24573 ) -> ::std::os::raw::c_int;
24574}
24575extern "C" {
24576 pub fn SteamAPI_ISteamController_GetGlyphForActionOrigin(
24577 self_: *mut ISteamController,
24578 eOrigin: EControllerActionOrigin,
24579 ) -> *const ::std::os::raw::c_char;
24580}
24581extern "C" {
24582 pub fn SteamAPI_ISteamController_GetStringForActionOrigin(
24583 self_: *mut ISteamController,
24584 eOrigin: EControllerActionOrigin,
24585 ) -> *const ::std::os::raw::c_char;
24586}
24587extern "C" {
24588 pub fn SteamAPI_ISteamController_StopAnalogActionMomentum(
24589 self_: *mut ISteamController,
24590 controllerHandle: ControllerHandle_t,
24591 eAction: ControllerAnalogActionHandle_t,
24592 );
24593}
24594extern "C" {
24595 pub fn SteamAPI_ISteamController_GetMotionData(
24596 self_: *mut ISteamController,
24597 controllerHandle: ControllerHandle_t,
24598 ) -> InputMotionData_t;
24599}
24600extern "C" {
24601 pub fn SteamAPI_ISteamController_TriggerHapticPulse(
24602 self_: *mut ISteamController,
24603 controllerHandle: ControllerHandle_t,
24604 eTargetPad: ESteamControllerPad,
24605 usDurationMicroSec: ::std::os::raw::c_ushort,
24606 );
24607}
24608extern "C" {
24609 pub fn SteamAPI_ISteamController_TriggerRepeatedHapticPulse(
24610 self_: *mut ISteamController,
24611 controllerHandle: ControllerHandle_t,
24612 eTargetPad: ESteamControllerPad,
24613 usDurationMicroSec: ::std::os::raw::c_ushort,
24614 usOffMicroSec: ::std::os::raw::c_ushort,
24615 unRepeat: ::std::os::raw::c_ushort,
24616 nFlags: ::std::os::raw::c_uint,
24617 );
24618}
24619extern "C" {
24620 pub fn SteamAPI_ISteamController_TriggerVibration(
24621 self_: *mut ISteamController,
24622 controllerHandle: ControllerHandle_t,
24623 usLeftSpeed: ::std::os::raw::c_ushort,
24624 usRightSpeed: ::std::os::raw::c_ushort,
24625 );
24626}
24627extern "C" {
24628 pub fn SteamAPI_ISteamController_SetLEDColor(
24629 self_: *mut ISteamController,
24630 controllerHandle: ControllerHandle_t,
24631 nColorR: uint8,
24632 nColorG: uint8,
24633 nColorB: uint8,
24634 nFlags: ::std::os::raw::c_uint,
24635 );
24636}
24637extern "C" {
24638 pub fn SteamAPI_ISteamController_ShowBindingPanel(
24639 self_: *mut ISteamController,
24640 controllerHandle: ControllerHandle_t,
24641 ) -> bool;
24642}
24643extern "C" {
24644 pub fn SteamAPI_ISteamController_GetInputTypeForHandle(
24645 self_: *mut ISteamController,
24646 controllerHandle: ControllerHandle_t,
24647 ) -> ESteamInputType;
24648}
24649extern "C" {
24650 pub fn SteamAPI_ISteamController_GetControllerForGamepadIndex(
24651 self_: *mut ISteamController,
24652 nIndex: ::std::os::raw::c_int,
24653 ) -> ControllerHandle_t;
24654}
24655extern "C" {
24656 pub fn SteamAPI_ISteamController_GetGamepadIndexForController(
24657 self_: *mut ISteamController,
24658 ulControllerHandle: ControllerHandle_t,
24659 ) -> ::std::os::raw::c_int;
24660}
24661extern "C" {
24662 pub fn SteamAPI_ISteamController_GetStringForXboxOrigin(
24663 self_: *mut ISteamController,
24664 eOrigin: EXboxOrigin,
24665 ) -> *const ::std::os::raw::c_char;
24666}
24667extern "C" {
24668 pub fn SteamAPI_ISteamController_GetGlyphForXboxOrigin(
24669 self_: *mut ISteamController,
24670 eOrigin: EXboxOrigin,
24671 ) -> *const ::std::os::raw::c_char;
24672}
24673extern "C" {
24674 pub fn SteamAPI_ISteamController_GetActionOriginFromXboxOrigin(
24675 self_: *mut ISteamController,
24676 controllerHandle: ControllerHandle_t,
24677 eOrigin: EXboxOrigin,
24678 ) -> EControllerActionOrigin;
24679}
24680extern "C" {
24681 pub fn SteamAPI_ISteamController_TranslateActionOrigin(
24682 self_: *mut ISteamController,
24683 eDestinationInputType: ESteamInputType,
24684 eSourceOrigin: EControllerActionOrigin,
24685 ) -> EControllerActionOrigin;
24686}
24687extern "C" {
24688 pub fn SteamAPI_ISteamController_GetControllerBindingRevision(
24689 self_: *mut ISteamController,
24690 controllerHandle: ControllerHandle_t,
24691 pMajor: *mut ::std::os::raw::c_int,
24692 pMinor: *mut ::std::os::raw::c_int,
24693 ) -> bool;
24694}
24695extern "C" {
24696 pub fn SteamAPI_SteamUGC_v021() -> *mut ISteamUGC;
24697}
24698extern "C" {
24699 pub fn SteamAPI_SteamGameServerUGC_v021() -> *mut ISteamUGC;
24700}
24701extern "C" {
24702 pub fn SteamAPI_ISteamUGC_CreateQueryUserUGCRequest(
24703 self_: *mut ISteamUGC,
24704 unAccountID: AccountID_t,
24705 eListType: EUserUGCList,
24706 eMatchingUGCType: EUGCMatchingUGCType,
24707 eSortOrder: EUserUGCListSortOrder,
24708 nCreatorAppID: AppId_t,
24709 nConsumerAppID: AppId_t,
24710 unPage: uint32,
24711 ) -> UGCQueryHandle_t;
24712}
24713extern "C" {
24714 pub fn SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage(
24715 self_: *mut ISteamUGC,
24716 eQueryType: EUGCQuery,
24717 eMatchingeMatchingUGCTypeFileType: EUGCMatchingUGCType,
24718 nCreatorAppID: AppId_t,
24719 nConsumerAppID: AppId_t,
24720 unPage: uint32,
24721 ) -> UGCQueryHandle_t;
24722}
24723extern "C" {
24724 pub fn SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor(
24725 self_: *mut ISteamUGC,
24726 eQueryType: EUGCQuery,
24727 eMatchingeMatchingUGCTypeFileType: EUGCMatchingUGCType,
24728 nCreatorAppID: AppId_t,
24729 nConsumerAppID: AppId_t,
24730 pchCursor: *const ::std::os::raw::c_char,
24731 ) -> UGCQueryHandle_t;
24732}
24733extern "C" {
24734 pub fn SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest(
24735 self_: *mut ISteamUGC,
24736 pvecPublishedFileID: *mut PublishedFileId_t,
24737 unNumPublishedFileIDs: uint32,
24738 ) -> UGCQueryHandle_t;
24739}
24740extern "C" {
24741 pub fn SteamAPI_ISteamUGC_SendQueryUGCRequest(
24742 self_: *mut ISteamUGC,
24743 handle: UGCQueryHandle_t,
24744 ) -> SteamAPICall_t;
24745}
24746extern "C" {
24747 pub fn SteamAPI_ISteamUGC_GetQueryUGCResult(
24748 self_: *mut ISteamUGC,
24749 handle: UGCQueryHandle_t,
24750 index: uint32,
24751 pDetails: *mut SteamUGCDetails_t,
24752 ) -> bool;
24753}
24754extern "C" {
24755 pub fn SteamAPI_ISteamUGC_GetQueryUGCNumTags(
24756 self_: *mut ISteamUGC,
24757 handle: UGCQueryHandle_t,
24758 index: uint32,
24759 ) -> uint32;
24760}
24761extern "C" {
24762 pub fn SteamAPI_ISteamUGC_GetQueryUGCTag(
24763 self_: *mut ISteamUGC,
24764 handle: UGCQueryHandle_t,
24765 index: uint32,
24766 indexTag: uint32,
24767 pchValue: *mut ::std::os::raw::c_char,
24768 cchValueSize: uint32,
24769 ) -> bool;
24770}
24771extern "C" {
24772 pub fn SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName(
24773 self_: *mut ISteamUGC,
24774 handle: UGCQueryHandle_t,
24775 index: uint32,
24776 indexTag: uint32,
24777 pchValue: *mut ::std::os::raw::c_char,
24778 cchValueSize: uint32,
24779 ) -> bool;
24780}
24781extern "C" {
24782 pub fn SteamAPI_ISteamUGC_GetQueryUGCPreviewURL(
24783 self_: *mut ISteamUGC,
24784 handle: UGCQueryHandle_t,
24785 index: uint32,
24786 pchURL: *mut ::std::os::raw::c_char,
24787 cchURLSize: uint32,
24788 ) -> bool;
24789}
24790extern "C" {
24791 pub fn SteamAPI_ISteamUGC_GetQueryUGCMetadata(
24792 self_: *mut ISteamUGC,
24793 handle: UGCQueryHandle_t,
24794 index: uint32,
24795 pchMetadata: *mut ::std::os::raw::c_char,
24796 cchMetadatasize: uint32,
24797 ) -> bool;
24798}
24799extern "C" {
24800 pub fn SteamAPI_ISteamUGC_GetQueryUGCChildren(
24801 self_: *mut ISteamUGC,
24802 handle: UGCQueryHandle_t,
24803 index: uint32,
24804 pvecPublishedFileID: *mut PublishedFileId_t,
24805 cMaxEntries: uint32,
24806 ) -> bool;
24807}
24808extern "C" {
24809 pub fn SteamAPI_ISteamUGC_GetQueryUGCStatistic(
24810 self_: *mut ISteamUGC,
24811 handle: UGCQueryHandle_t,
24812 index: uint32,
24813 eStatType: EItemStatistic,
24814 pStatValue: *mut uint64,
24815 ) -> bool;
24816}
24817extern "C" {
24818 pub fn SteamAPI_ISteamUGC_GetQueryUGCNumAdditionalPreviews(
24819 self_: *mut ISteamUGC,
24820 handle: UGCQueryHandle_t,
24821 index: uint32,
24822 ) -> uint32;
24823}
24824extern "C" {
24825 pub fn SteamAPI_ISteamUGC_GetQueryUGCAdditionalPreview(
24826 self_: *mut ISteamUGC,
24827 handle: UGCQueryHandle_t,
24828 index: uint32,
24829 previewIndex: uint32,
24830 pchURLOrVideoID: *mut ::std::os::raw::c_char,
24831 cchURLSize: uint32,
24832 pchOriginalFileName: *mut ::std::os::raw::c_char,
24833 cchOriginalFileNameSize: uint32,
24834 pPreviewType: *mut EItemPreviewType,
24835 ) -> bool;
24836}
24837extern "C" {
24838 pub fn SteamAPI_ISteamUGC_GetQueryUGCNumKeyValueTags(
24839 self_: *mut ISteamUGC,
24840 handle: UGCQueryHandle_t,
24841 index: uint32,
24842 ) -> uint32;
24843}
24844extern "C" {
24845 pub fn SteamAPI_ISteamUGC_GetQueryUGCKeyValueTag(
24846 self_: *mut ISteamUGC,
24847 handle: UGCQueryHandle_t,
24848 index: uint32,
24849 keyValueTagIndex: uint32,
24850 pchKey: *mut ::std::os::raw::c_char,
24851 cchKeySize: uint32,
24852 pchValue: *mut ::std::os::raw::c_char,
24853 cchValueSize: uint32,
24854 ) -> bool;
24855}
24856extern "C" {
24857 pub fn SteamAPI_ISteamUGC_GetQueryFirstUGCKeyValueTag(
24858 self_: *mut ISteamUGC,
24859 handle: UGCQueryHandle_t,
24860 index: uint32,
24861 pchKey: *const ::std::os::raw::c_char,
24862 pchValue: *mut ::std::os::raw::c_char,
24863 cchValueSize: uint32,
24864 ) -> bool;
24865}
24866extern "C" {
24867 pub fn SteamAPI_ISteamUGC_GetNumSupportedGameVersions(
24868 self_: *mut ISteamUGC,
24869 handle: UGCQueryHandle_t,
24870 index: uint32,
24871 ) -> uint32;
24872}
24873extern "C" {
24874 pub fn SteamAPI_ISteamUGC_GetSupportedGameVersionData(
24875 self_: *mut ISteamUGC,
24876 handle: UGCQueryHandle_t,
24877 index: uint32,
24878 versionIndex: uint32,
24879 pchGameBranchMin: *mut ::std::os::raw::c_char,
24880 pchGameBranchMax: *mut ::std::os::raw::c_char,
24881 cchGameBranchSize: uint32,
24882 ) -> bool;
24883}
24884extern "C" {
24885 pub fn SteamAPI_ISteamUGC_GetQueryUGCContentDescriptors(
24886 self_: *mut ISteamUGC,
24887 handle: UGCQueryHandle_t,
24888 index: uint32,
24889 pvecDescriptors: *mut EUGCContentDescriptorID,
24890 cMaxEntries: uint32,
24891 ) -> uint32;
24892}
24893extern "C" {
24894 pub fn SteamAPI_ISteamUGC_ReleaseQueryUGCRequest(
24895 self_: *mut ISteamUGC,
24896 handle: UGCQueryHandle_t,
24897 ) -> bool;
24898}
24899extern "C" {
24900 pub fn SteamAPI_ISteamUGC_AddRequiredTag(
24901 self_: *mut ISteamUGC,
24902 handle: UGCQueryHandle_t,
24903 pTagName: *const ::std::os::raw::c_char,
24904 ) -> bool;
24905}
24906extern "C" {
24907 pub fn SteamAPI_ISteamUGC_AddRequiredTagGroup(
24908 self_: *mut ISteamUGC,
24909 handle: UGCQueryHandle_t,
24910 pTagGroups: *const SteamParamStringArray_t,
24911 ) -> bool;
24912}
24913extern "C" {
24914 pub fn SteamAPI_ISteamUGC_AddExcludedTag(
24915 self_: *mut ISteamUGC,
24916 handle: UGCQueryHandle_t,
24917 pTagName: *const ::std::os::raw::c_char,
24918 ) -> bool;
24919}
24920extern "C" {
24921 pub fn SteamAPI_ISteamUGC_SetReturnOnlyIDs(
24922 self_: *mut ISteamUGC,
24923 handle: UGCQueryHandle_t,
24924 bReturnOnlyIDs: bool,
24925 ) -> bool;
24926}
24927extern "C" {
24928 pub fn SteamAPI_ISteamUGC_SetReturnKeyValueTags(
24929 self_: *mut ISteamUGC,
24930 handle: UGCQueryHandle_t,
24931 bReturnKeyValueTags: bool,
24932 ) -> bool;
24933}
24934extern "C" {
24935 pub fn SteamAPI_ISteamUGC_SetReturnLongDescription(
24936 self_: *mut ISteamUGC,
24937 handle: UGCQueryHandle_t,
24938 bReturnLongDescription: bool,
24939 ) -> bool;
24940}
24941extern "C" {
24942 pub fn SteamAPI_ISteamUGC_SetReturnMetadata(
24943 self_: *mut ISteamUGC,
24944 handle: UGCQueryHandle_t,
24945 bReturnMetadata: bool,
24946 ) -> bool;
24947}
24948extern "C" {
24949 pub fn SteamAPI_ISteamUGC_SetReturnChildren(
24950 self_: *mut ISteamUGC,
24951 handle: UGCQueryHandle_t,
24952 bReturnChildren: bool,
24953 ) -> bool;
24954}
24955extern "C" {
24956 pub fn SteamAPI_ISteamUGC_SetReturnAdditionalPreviews(
24957 self_: *mut ISteamUGC,
24958 handle: UGCQueryHandle_t,
24959 bReturnAdditionalPreviews: bool,
24960 ) -> bool;
24961}
24962extern "C" {
24963 pub fn SteamAPI_ISteamUGC_SetReturnTotalOnly(
24964 self_: *mut ISteamUGC,
24965 handle: UGCQueryHandle_t,
24966 bReturnTotalOnly: bool,
24967 ) -> bool;
24968}
24969extern "C" {
24970 pub fn SteamAPI_ISteamUGC_SetReturnPlaytimeStats(
24971 self_: *mut ISteamUGC,
24972 handle: UGCQueryHandle_t,
24973 unDays: uint32,
24974 ) -> bool;
24975}
24976extern "C" {
24977 pub fn SteamAPI_ISteamUGC_SetLanguage(
24978 self_: *mut ISteamUGC,
24979 handle: UGCQueryHandle_t,
24980 pchLanguage: *const ::std::os::raw::c_char,
24981 ) -> bool;
24982}
24983extern "C" {
24984 pub fn SteamAPI_ISteamUGC_SetAllowCachedResponse(
24985 self_: *mut ISteamUGC,
24986 handle: UGCQueryHandle_t,
24987 unMaxAgeSeconds: uint32,
24988 ) -> bool;
24989}
24990extern "C" {
24991 pub fn SteamAPI_ISteamUGC_SetAdminQuery(
24992 self_: *mut ISteamUGC,
24993 handle: UGCUpdateHandle_t,
24994 bAdminQuery: bool,
24995 ) -> bool;
24996}
24997extern "C" {
24998 pub fn SteamAPI_ISteamUGC_SetCloudFileNameFilter(
24999 self_: *mut ISteamUGC,
25000 handle: UGCQueryHandle_t,
25001 pMatchCloudFileName: *const ::std::os::raw::c_char,
25002 ) -> bool;
25003}
25004extern "C" {
25005 pub fn SteamAPI_ISteamUGC_SetMatchAnyTag(
25006 self_: *mut ISteamUGC,
25007 handle: UGCQueryHandle_t,
25008 bMatchAnyTag: bool,
25009 ) -> bool;
25010}
25011extern "C" {
25012 pub fn SteamAPI_ISteamUGC_SetSearchText(
25013 self_: *mut ISteamUGC,
25014 handle: UGCQueryHandle_t,
25015 pSearchText: *const ::std::os::raw::c_char,
25016 ) -> bool;
25017}
25018extern "C" {
25019 pub fn SteamAPI_ISteamUGC_SetRankedByTrendDays(
25020 self_: *mut ISteamUGC,
25021 handle: UGCQueryHandle_t,
25022 unDays: uint32,
25023 ) -> bool;
25024}
25025extern "C" {
25026 pub fn SteamAPI_ISteamUGC_SetTimeCreatedDateRange(
25027 self_: *mut ISteamUGC,
25028 handle: UGCQueryHandle_t,
25029 rtStart: RTime32,
25030 rtEnd: RTime32,
25031 ) -> bool;
25032}
25033extern "C" {
25034 pub fn SteamAPI_ISteamUGC_SetTimeUpdatedDateRange(
25035 self_: *mut ISteamUGC,
25036 handle: UGCQueryHandle_t,
25037 rtStart: RTime32,
25038 rtEnd: RTime32,
25039 ) -> bool;
25040}
25041extern "C" {
25042 pub fn SteamAPI_ISteamUGC_AddRequiredKeyValueTag(
25043 self_: *mut ISteamUGC,
25044 handle: UGCQueryHandle_t,
25045 pKey: *const ::std::os::raw::c_char,
25046 pValue: *const ::std::os::raw::c_char,
25047 ) -> bool;
25048}
25049extern "C" {
25050 pub fn SteamAPI_ISteamUGC_RequestUGCDetails(
25051 self_: *mut ISteamUGC,
25052 nPublishedFileID: PublishedFileId_t,
25053 unMaxAgeSeconds: uint32,
25054 ) -> SteamAPICall_t;
25055}
25056extern "C" {
25057 pub fn SteamAPI_ISteamUGC_CreateItem(
25058 self_: *mut ISteamUGC,
25059 nConsumerAppId: AppId_t,
25060 eFileType: EWorkshopFileType,
25061 ) -> SteamAPICall_t;
25062}
25063extern "C" {
25064 pub fn SteamAPI_ISteamUGC_StartItemUpdate(
25065 self_: *mut ISteamUGC,
25066 nConsumerAppId: AppId_t,
25067 nPublishedFileID: PublishedFileId_t,
25068 ) -> UGCUpdateHandle_t;
25069}
25070extern "C" {
25071 pub fn SteamAPI_ISteamUGC_SetItemTitle(
25072 self_: *mut ISteamUGC,
25073 handle: UGCUpdateHandle_t,
25074 pchTitle: *const ::std::os::raw::c_char,
25075 ) -> bool;
25076}
25077extern "C" {
25078 pub fn SteamAPI_ISteamUGC_SetItemDescription(
25079 self_: *mut ISteamUGC,
25080 handle: UGCUpdateHandle_t,
25081 pchDescription: *const ::std::os::raw::c_char,
25082 ) -> bool;
25083}
25084extern "C" {
25085 pub fn SteamAPI_ISteamUGC_SetItemUpdateLanguage(
25086 self_: *mut ISteamUGC,
25087 handle: UGCUpdateHandle_t,
25088 pchLanguage: *const ::std::os::raw::c_char,
25089 ) -> bool;
25090}
25091extern "C" {
25092 pub fn SteamAPI_ISteamUGC_SetItemMetadata(
25093 self_: *mut ISteamUGC,
25094 handle: UGCUpdateHandle_t,
25095 pchMetaData: *const ::std::os::raw::c_char,
25096 ) -> bool;
25097}
25098extern "C" {
25099 pub fn SteamAPI_ISteamUGC_SetItemVisibility(
25100 self_: *mut ISteamUGC,
25101 handle: UGCUpdateHandle_t,
25102 eVisibility: ERemoteStoragePublishedFileVisibility,
25103 ) -> bool;
25104}
25105extern "C" {
25106 pub fn SteamAPI_ISteamUGC_SetItemTags(
25107 self_: *mut ISteamUGC,
25108 updateHandle: UGCUpdateHandle_t,
25109 pTags: *const SteamParamStringArray_t,
25110 bAllowAdminTags: bool,
25111 ) -> bool;
25112}
25113extern "C" {
25114 pub fn SteamAPI_ISteamUGC_SetItemContent(
25115 self_: *mut ISteamUGC,
25116 handle: UGCUpdateHandle_t,
25117 pszContentFolder: *const ::std::os::raw::c_char,
25118 ) -> bool;
25119}
25120extern "C" {
25121 pub fn SteamAPI_ISteamUGC_SetItemPreview(
25122 self_: *mut ISteamUGC,
25123 handle: UGCUpdateHandle_t,
25124 pszPreviewFile: *const ::std::os::raw::c_char,
25125 ) -> bool;
25126}
25127extern "C" {
25128 pub fn SteamAPI_ISteamUGC_SetAllowLegacyUpload(
25129 self_: *mut ISteamUGC,
25130 handle: UGCUpdateHandle_t,
25131 bAllowLegacyUpload: bool,
25132 ) -> bool;
25133}
25134extern "C" {
25135 pub fn SteamAPI_ISteamUGC_RemoveAllItemKeyValueTags(
25136 self_: *mut ISteamUGC,
25137 handle: UGCUpdateHandle_t,
25138 ) -> bool;
25139}
25140extern "C" {
25141 pub fn SteamAPI_ISteamUGC_RemoveItemKeyValueTags(
25142 self_: *mut ISteamUGC,
25143 handle: UGCUpdateHandle_t,
25144 pchKey: *const ::std::os::raw::c_char,
25145 ) -> bool;
25146}
25147extern "C" {
25148 pub fn SteamAPI_ISteamUGC_AddItemKeyValueTag(
25149 self_: *mut ISteamUGC,
25150 handle: UGCUpdateHandle_t,
25151 pchKey: *const ::std::os::raw::c_char,
25152 pchValue: *const ::std::os::raw::c_char,
25153 ) -> bool;
25154}
25155extern "C" {
25156 pub fn SteamAPI_ISteamUGC_AddItemPreviewFile(
25157 self_: *mut ISteamUGC,
25158 handle: UGCUpdateHandle_t,
25159 pszPreviewFile: *const ::std::os::raw::c_char,
25160 type_: EItemPreviewType,
25161 ) -> bool;
25162}
25163extern "C" {
25164 pub fn SteamAPI_ISteamUGC_AddItemPreviewVideo(
25165 self_: *mut ISteamUGC,
25166 handle: UGCUpdateHandle_t,
25167 pszVideoID: *const ::std::os::raw::c_char,
25168 ) -> bool;
25169}
25170extern "C" {
25171 pub fn SteamAPI_ISteamUGC_UpdateItemPreviewFile(
25172 self_: *mut ISteamUGC,
25173 handle: UGCUpdateHandle_t,
25174 index: uint32,
25175 pszPreviewFile: *const ::std::os::raw::c_char,
25176 ) -> bool;
25177}
25178extern "C" {
25179 pub fn SteamAPI_ISteamUGC_UpdateItemPreviewVideo(
25180 self_: *mut ISteamUGC,
25181 handle: UGCUpdateHandle_t,
25182 index: uint32,
25183 pszVideoID: *const ::std::os::raw::c_char,
25184 ) -> bool;
25185}
25186extern "C" {
25187 pub fn SteamAPI_ISteamUGC_RemoveItemPreview(
25188 self_: *mut ISteamUGC,
25189 handle: UGCUpdateHandle_t,
25190 index: uint32,
25191 ) -> bool;
25192}
25193extern "C" {
25194 pub fn SteamAPI_ISteamUGC_AddContentDescriptor(
25195 self_: *mut ISteamUGC,
25196 handle: UGCUpdateHandle_t,
25197 descid: EUGCContentDescriptorID,
25198 ) -> bool;
25199}
25200extern "C" {
25201 pub fn SteamAPI_ISteamUGC_RemoveContentDescriptor(
25202 self_: *mut ISteamUGC,
25203 handle: UGCUpdateHandle_t,
25204 descid: EUGCContentDescriptorID,
25205 ) -> bool;
25206}
25207extern "C" {
25208 pub fn SteamAPI_ISteamUGC_SetRequiredGameVersions(
25209 self_: *mut ISteamUGC,
25210 handle: UGCUpdateHandle_t,
25211 pszGameBranchMin: *const ::std::os::raw::c_char,
25212 pszGameBranchMax: *const ::std::os::raw::c_char,
25213 ) -> bool;
25214}
25215extern "C" {
25216 pub fn SteamAPI_ISteamUGC_SubmitItemUpdate(
25217 self_: *mut ISteamUGC,
25218 handle: UGCUpdateHandle_t,
25219 pchChangeNote: *const ::std::os::raw::c_char,
25220 ) -> SteamAPICall_t;
25221}
25222extern "C" {
25223 pub fn SteamAPI_ISteamUGC_GetItemUpdateProgress(
25224 self_: *mut ISteamUGC,
25225 handle: UGCUpdateHandle_t,
25226 punBytesProcessed: *mut uint64,
25227 punBytesTotal: *mut uint64,
25228 ) -> EItemUpdateStatus;
25229}
25230extern "C" {
25231 pub fn SteamAPI_ISteamUGC_SetUserItemVote(
25232 self_: *mut ISteamUGC,
25233 nPublishedFileID: PublishedFileId_t,
25234 bVoteUp: bool,
25235 ) -> SteamAPICall_t;
25236}
25237extern "C" {
25238 pub fn SteamAPI_ISteamUGC_GetUserItemVote(
25239 self_: *mut ISteamUGC,
25240 nPublishedFileID: PublishedFileId_t,
25241 ) -> SteamAPICall_t;
25242}
25243extern "C" {
25244 pub fn SteamAPI_ISteamUGC_AddItemToFavorites(
25245 self_: *mut ISteamUGC,
25246 nAppId: AppId_t,
25247 nPublishedFileID: PublishedFileId_t,
25248 ) -> SteamAPICall_t;
25249}
25250extern "C" {
25251 pub fn SteamAPI_ISteamUGC_RemoveItemFromFavorites(
25252 self_: *mut ISteamUGC,
25253 nAppId: AppId_t,
25254 nPublishedFileID: PublishedFileId_t,
25255 ) -> SteamAPICall_t;
25256}
25257extern "C" {
25258 pub fn SteamAPI_ISteamUGC_SubscribeItem(
25259 self_: *mut ISteamUGC,
25260 nPublishedFileID: PublishedFileId_t,
25261 ) -> SteamAPICall_t;
25262}
25263extern "C" {
25264 pub fn SteamAPI_ISteamUGC_UnsubscribeItem(
25265 self_: *mut ISteamUGC,
25266 nPublishedFileID: PublishedFileId_t,
25267 ) -> SteamAPICall_t;
25268}
25269extern "C" {
25270 pub fn SteamAPI_ISteamUGC_GetNumSubscribedItems(
25271 self_: *mut ISteamUGC,
25272 bIncludeLocallyDisabled: bool,
25273 ) -> uint32;
25274}
25275extern "C" {
25276 pub fn SteamAPI_ISteamUGC_GetSubscribedItems(
25277 self_: *mut ISteamUGC,
25278 pvecPublishedFileID: *mut PublishedFileId_t,
25279 cMaxEntries: uint32,
25280 bIncludeLocallyDisabled: bool,
25281 ) -> uint32;
25282}
25283extern "C" {
25284 pub fn SteamAPI_ISteamUGC_GetItemState(
25285 self_: *mut ISteamUGC,
25286 nPublishedFileID: PublishedFileId_t,
25287 ) -> uint32;
25288}
25289extern "C" {
25290 pub fn SteamAPI_ISteamUGC_GetItemInstallInfo(
25291 self_: *mut ISteamUGC,
25292 nPublishedFileID: PublishedFileId_t,
25293 punSizeOnDisk: *mut uint64,
25294 pchFolder: *mut ::std::os::raw::c_char,
25295 cchFolderSize: uint32,
25296 punTimeStamp: *mut uint32,
25297 ) -> bool;
25298}
25299extern "C" {
25300 pub fn SteamAPI_ISteamUGC_GetItemDownloadInfo(
25301 self_: *mut ISteamUGC,
25302 nPublishedFileID: PublishedFileId_t,
25303 punBytesDownloaded: *mut uint64,
25304 punBytesTotal: *mut uint64,
25305 ) -> bool;
25306}
25307extern "C" {
25308 pub fn SteamAPI_ISteamUGC_DownloadItem(
25309 self_: *mut ISteamUGC,
25310 nPublishedFileID: PublishedFileId_t,
25311 bHighPriority: bool,
25312 ) -> bool;
25313}
25314extern "C" {
25315 pub fn SteamAPI_ISteamUGC_BInitWorkshopForGameServer(
25316 self_: *mut ISteamUGC,
25317 unWorkshopDepotID: DepotId_t,
25318 pszFolder: *const ::std::os::raw::c_char,
25319 ) -> bool;
25320}
25321extern "C" {
25322 pub fn SteamAPI_ISteamUGC_SuspendDownloads(self_: *mut ISteamUGC, bSuspend: bool);
25323}
25324extern "C" {
25325 pub fn SteamAPI_ISteamUGC_StartPlaytimeTracking(
25326 self_: *mut ISteamUGC,
25327 pvecPublishedFileID: *mut PublishedFileId_t,
25328 unNumPublishedFileIDs: uint32,
25329 ) -> SteamAPICall_t;
25330}
25331extern "C" {
25332 pub fn SteamAPI_ISteamUGC_StopPlaytimeTracking(
25333 self_: *mut ISteamUGC,
25334 pvecPublishedFileID: *mut PublishedFileId_t,
25335 unNumPublishedFileIDs: uint32,
25336 ) -> SteamAPICall_t;
25337}
25338extern "C" {
25339 pub fn SteamAPI_ISteamUGC_StopPlaytimeTrackingForAllItems(
25340 self_: *mut ISteamUGC,
25341 ) -> SteamAPICall_t;
25342}
25343extern "C" {
25344 pub fn SteamAPI_ISteamUGC_AddDependency(
25345 self_: *mut ISteamUGC,
25346 nParentPublishedFileID: PublishedFileId_t,
25347 nChildPublishedFileID: PublishedFileId_t,
25348 ) -> SteamAPICall_t;
25349}
25350extern "C" {
25351 pub fn SteamAPI_ISteamUGC_RemoveDependency(
25352 self_: *mut ISteamUGC,
25353 nParentPublishedFileID: PublishedFileId_t,
25354 nChildPublishedFileID: PublishedFileId_t,
25355 ) -> SteamAPICall_t;
25356}
25357extern "C" {
25358 pub fn SteamAPI_ISteamUGC_AddAppDependency(
25359 self_: *mut ISteamUGC,
25360 nPublishedFileID: PublishedFileId_t,
25361 nAppID: AppId_t,
25362 ) -> SteamAPICall_t;
25363}
25364extern "C" {
25365 pub fn SteamAPI_ISteamUGC_RemoveAppDependency(
25366 self_: *mut ISteamUGC,
25367 nPublishedFileID: PublishedFileId_t,
25368 nAppID: AppId_t,
25369 ) -> SteamAPICall_t;
25370}
25371extern "C" {
25372 pub fn SteamAPI_ISteamUGC_GetAppDependencies(
25373 self_: *mut ISteamUGC,
25374 nPublishedFileID: PublishedFileId_t,
25375 ) -> SteamAPICall_t;
25376}
25377extern "C" {
25378 pub fn SteamAPI_ISteamUGC_DeleteItem(
25379 self_: *mut ISteamUGC,
25380 nPublishedFileID: PublishedFileId_t,
25381 ) -> SteamAPICall_t;
25382}
25383extern "C" {
25384 pub fn SteamAPI_ISteamUGC_ShowWorkshopEULA(self_: *mut ISteamUGC) -> bool;
25385}
25386extern "C" {
25387 pub fn SteamAPI_ISteamUGC_GetWorkshopEULAStatus(self_: *mut ISteamUGC) -> SteamAPICall_t;
25388}
25389extern "C" {
25390 pub fn SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences(
25391 self_: *mut ISteamUGC,
25392 pvecDescriptors: *mut EUGCContentDescriptorID,
25393 cMaxEntries: uint32,
25394 ) -> uint32;
25395}
25396extern "C" {
25397 pub fn SteamAPI_ISteamUGC_SetItemsDisabledLocally(
25398 self_: *mut ISteamUGC,
25399 pvecPublishedFileIDs: *mut PublishedFileId_t,
25400 unNumPublishedFileIDs: uint32,
25401 bDisabledLocally: bool,
25402 ) -> bool;
25403}
25404extern "C" {
25405 pub fn SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder(
25406 self_: *mut ISteamUGC,
25407 pvecPublishedFileIDs: *mut PublishedFileId_t,
25408 unNumPublishedFileIDs: uint32,
25409 ) -> bool;
25410}
25411extern "C" {
25412 pub fn SteamAPI_ISteamUGC_MarkDownloadedItemAsUnused(
25413 self_: *mut ISteamUGC,
25414 nPublishedFileID: PublishedFileId_t,
25415 ) -> bool;
25416}
25417extern "C" {
25418 pub fn SteamAPI_ISteamUGC_GetNumDownloadedItems(self_: *mut ISteamUGC) -> uint32;
25419}
25420extern "C" {
25421 pub fn SteamAPI_ISteamUGC_GetDownloadedItems(
25422 self_: *mut ISteamUGC,
25423 pvecPublishedFileIDs: *mut PublishedFileId_t,
25424 cMaxEntries: uint32,
25425 ) -> uint32;
25426}
25427extern "C" {
25428 pub fn SteamAPI_SteamHTMLSurface_v005() -> *mut ISteamHTMLSurface;
25429}
25430extern "C" {
25431 pub fn SteamAPI_ISteamHTMLSurface_Init(self_: *mut ISteamHTMLSurface) -> bool;
25432}
25433extern "C" {
25434 pub fn SteamAPI_ISteamHTMLSurface_Shutdown(self_: *mut ISteamHTMLSurface) -> bool;
25435}
25436extern "C" {
25437 pub fn SteamAPI_ISteamHTMLSurface_CreateBrowser(
25438 self_: *mut ISteamHTMLSurface,
25439 pchUserAgent: *const ::std::os::raw::c_char,
25440 pchUserCSS: *const ::std::os::raw::c_char,
25441 ) -> SteamAPICall_t;
25442}
25443extern "C" {
25444 pub fn SteamAPI_ISteamHTMLSurface_RemoveBrowser(
25445 self_: *mut ISteamHTMLSurface,
25446 unBrowserHandle: HHTMLBrowser,
25447 );
25448}
25449extern "C" {
25450 pub fn SteamAPI_ISteamHTMLSurface_LoadURL(
25451 self_: *mut ISteamHTMLSurface,
25452 unBrowserHandle: HHTMLBrowser,
25453 pchURL: *const ::std::os::raw::c_char,
25454 pchPostData: *const ::std::os::raw::c_char,
25455 );
25456}
25457extern "C" {
25458 pub fn SteamAPI_ISteamHTMLSurface_SetSize(
25459 self_: *mut ISteamHTMLSurface,
25460 unBrowserHandle: HHTMLBrowser,
25461 unWidth: uint32,
25462 unHeight: uint32,
25463 );
25464}
25465extern "C" {
25466 pub fn SteamAPI_ISteamHTMLSurface_StopLoad(
25467 self_: *mut ISteamHTMLSurface,
25468 unBrowserHandle: HHTMLBrowser,
25469 );
25470}
25471extern "C" {
25472 pub fn SteamAPI_ISteamHTMLSurface_Reload(
25473 self_: *mut ISteamHTMLSurface,
25474 unBrowserHandle: HHTMLBrowser,
25475 );
25476}
25477extern "C" {
25478 pub fn SteamAPI_ISteamHTMLSurface_GoBack(
25479 self_: *mut ISteamHTMLSurface,
25480 unBrowserHandle: HHTMLBrowser,
25481 );
25482}
25483extern "C" {
25484 pub fn SteamAPI_ISteamHTMLSurface_GoForward(
25485 self_: *mut ISteamHTMLSurface,
25486 unBrowserHandle: HHTMLBrowser,
25487 );
25488}
25489extern "C" {
25490 pub fn SteamAPI_ISteamHTMLSurface_AddHeader(
25491 self_: *mut ISteamHTMLSurface,
25492 unBrowserHandle: HHTMLBrowser,
25493 pchKey: *const ::std::os::raw::c_char,
25494 pchValue: *const ::std::os::raw::c_char,
25495 );
25496}
25497extern "C" {
25498 pub fn SteamAPI_ISteamHTMLSurface_ExecuteJavascript(
25499 self_: *mut ISteamHTMLSurface,
25500 unBrowserHandle: HHTMLBrowser,
25501 pchScript: *const ::std::os::raw::c_char,
25502 );
25503}
25504extern "C" {
25505 pub fn SteamAPI_ISteamHTMLSurface_MouseUp(
25506 self_: *mut ISteamHTMLSurface,
25507 unBrowserHandle: HHTMLBrowser,
25508 eMouseButton: ISteamHTMLSurface_EHTMLMouseButton,
25509 );
25510}
25511extern "C" {
25512 pub fn SteamAPI_ISteamHTMLSurface_MouseDown(
25513 self_: *mut ISteamHTMLSurface,
25514 unBrowserHandle: HHTMLBrowser,
25515 eMouseButton: ISteamHTMLSurface_EHTMLMouseButton,
25516 );
25517}
25518extern "C" {
25519 pub fn SteamAPI_ISteamHTMLSurface_MouseDoubleClick(
25520 self_: *mut ISteamHTMLSurface,
25521 unBrowserHandle: HHTMLBrowser,
25522 eMouseButton: ISteamHTMLSurface_EHTMLMouseButton,
25523 );
25524}
25525extern "C" {
25526 pub fn SteamAPI_ISteamHTMLSurface_MouseMove(
25527 self_: *mut ISteamHTMLSurface,
25528 unBrowserHandle: HHTMLBrowser,
25529 x: ::std::os::raw::c_int,
25530 y: ::std::os::raw::c_int,
25531 );
25532}
25533extern "C" {
25534 pub fn SteamAPI_ISteamHTMLSurface_MouseWheel(
25535 self_: *mut ISteamHTMLSurface,
25536 unBrowserHandle: HHTMLBrowser,
25537 nDelta: int32,
25538 );
25539}
25540extern "C" {
25541 pub fn SteamAPI_ISteamHTMLSurface_KeyDown(
25542 self_: *mut ISteamHTMLSurface,
25543 unBrowserHandle: HHTMLBrowser,
25544 nNativeKeyCode: uint32,
25545 eHTMLKeyModifiers: ISteamHTMLSurface_EHTMLKeyModifiers,
25546 bIsSystemKey: bool,
25547 );
25548}
25549extern "C" {
25550 pub fn SteamAPI_ISteamHTMLSurface_KeyUp(
25551 self_: *mut ISteamHTMLSurface,
25552 unBrowserHandle: HHTMLBrowser,
25553 nNativeKeyCode: uint32,
25554 eHTMLKeyModifiers: ISteamHTMLSurface_EHTMLKeyModifiers,
25555 );
25556}
25557extern "C" {
25558 pub fn SteamAPI_ISteamHTMLSurface_KeyChar(
25559 self_: *mut ISteamHTMLSurface,
25560 unBrowserHandle: HHTMLBrowser,
25561 cUnicodeChar: uint32,
25562 eHTMLKeyModifiers: ISteamHTMLSurface_EHTMLKeyModifiers,
25563 );
25564}
25565extern "C" {
25566 pub fn SteamAPI_ISteamHTMLSurface_SetHorizontalScroll(
25567 self_: *mut ISteamHTMLSurface,
25568 unBrowserHandle: HHTMLBrowser,
25569 nAbsolutePixelScroll: uint32,
25570 );
25571}
25572extern "C" {
25573 pub fn SteamAPI_ISteamHTMLSurface_SetVerticalScroll(
25574 self_: *mut ISteamHTMLSurface,
25575 unBrowserHandle: HHTMLBrowser,
25576 nAbsolutePixelScroll: uint32,
25577 );
25578}
25579extern "C" {
25580 pub fn SteamAPI_ISteamHTMLSurface_SetKeyFocus(
25581 self_: *mut ISteamHTMLSurface,
25582 unBrowserHandle: HHTMLBrowser,
25583 bHasKeyFocus: bool,
25584 );
25585}
25586extern "C" {
25587 pub fn SteamAPI_ISteamHTMLSurface_ViewSource(
25588 self_: *mut ISteamHTMLSurface,
25589 unBrowserHandle: HHTMLBrowser,
25590 );
25591}
25592extern "C" {
25593 pub fn SteamAPI_ISteamHTMLSurface_CopyToClipboard(
25594 self_: *mut ISteamHTMLSurface,
25595 unBrowserHandle: HHTMLBrowser,
25596 );
25597}
25598extern "C" {
25599 pub fn SteamAPI_ISteamHTMLSurface_PasteFromClipboard(
25600 self_: *mut ISteamHTMLSurface,
25601 unBrowserHandle: HHTMLBrowser,
25602 );
25603}
25604extern "C" {
25605 pub fn SteamAPI_ISteamHTMLSurface_Find(
25606 self_: *mut ISteamHTMLSurface,
25607 unBrowserHandle: HHTMLBrowser,
25608 pchSearchStr: *const ::std::os::raw::c_char,
25609 bCurrentlyInFind: bool,
25610 bReverse: bool,
25611 );
25612}
25613extern "C" {
25614 pub fn SteamAPI_ISteamHTMLSurface_StopFind(
25615 self_: *mut ISteamHTMLSurface,
25616 unBrowserHandle: HHTMLBrowser,
25617 );
25618}
25619extern "C" {
25620 pub fn SteamAPI_ISteamHTMLSurface_GetLinkAtPosition(
25621 self_: *mut ISteamHTMLSurface,
25622 unBrowserHandle: HHTMLBrowser,
25623 x: ::std::os::raw::c_int,
25624 y: ::std::os::raw::c_int,
25625 );
25626}
25627extern "C" {
25628 pub fn SteamAPI_ISteamHTMLSurface_SetCookie(
25629 self_: *mut ISteamHTMLSurface,
25630 pchHostname: *const ::std::os::raw::c_char,
25631 pchKey: *const ::std::os::raw::c_char,
25632 pchValue: *const ::std::os::raw::c_char,
25633 pchPath: *const ::std::os::raw::c_char,
25634 nExpires: RTime32,
25635 bSecure: bool,
25636 bHTTPOnly: bool,
25637 );
25638}
25639extern "C" {
25640 pub fn SteamAPI_ISteamHTMLSurface_SetPageScaleFactor(
25641 self_: *mut ISteamHTMLSurface,
25642 unBrowserHandle: HHTMLBrowser,
25643 flZoom: f32,
25644 nPointX: ::std::os::raw::c_int,
25645 nPointY: ::std::os::raw::c_int,
25646 );
25647}
25648extern "C" {
25649 pub fn SteamAPI_ISteamHTMLSurface_SetBackgroundMode(
25650 self_: *mut ISteamHTMLSurface,
25651 unBrowserHandle: HHTMLBrowser,
25652 bBackgroundMode: bool,
25653 );
25654}
25655extern "C" {
25656 pub fn SteamAPI_ISteamHTMLSurface_SetDPIScalingFactor(
25657 self_: *mut ISteamHTMLSurface,
25658 unBrowserHandle: HHTMLBrowser,
25659 flDPIScaling: f32,
25660 );
25661}
25662extern "C" {
25663 pub fn SteamAPI_ISteamHTMLSurface_OpenDeveloperTools(
25664 self_: *mut ISteamHTMLSurface,
25665 unBrowserHandle: HHTMLBrowser,
25666 );
25667}
25668extern "C" {
25669 pub fn SteamAPI_ISteamHTMLSurface_AllowStartRequest(
25670 self_: *mut ISteamHTMLSurface,
25671 unBrowserHandle: HHTMLBrowser,
25672 bAllowed: bool,
25673 );
25674}
25675extern "C" {
25676 pub fn SteamAPI_ISteamHTMLSurface_JSDialogResponse(
25677 self_: *mut ISteamHTMLSurface,
25678 unBrowserHandle: HHTMLBrowser,
25679 bResult: bool,
25680 );
25681}
25682extern "C" {
25683 pub fn SteamAPI_ISteamHTMLSurface_FileLoadDialogResponse(
25684 self_: *mut ISteamHTMLSurface,
25685 unBrowserHandle: HHTMLBrowser,
25686 pchSelectedFiles: *mut *const ::std::os::raw::c_char,
25687 );
25688}
25689extern "C" {
25690 pub fn SteamAPI_SteamInventory_v003() -> *mut ISteamInventory;
25691}
25692extern "C" {
25693 pub fn SteamAPI_SteamGameServerInventory_v003() -> *mut ISteamInventory;
25694}
25695extern "C" {
25696 pub fn SteamAPI_ISteamInventory_GetResultStatus(
25697 self_: *mut ISteamInventory,
25698 resultHandle: SteamInventoryResult_t,
25699 ) -> EResult;
25700}
25701extern "C" {
25702 pub fn SteamAPI_ISteamInventory_GetResultItems(
25703 self_: *mut ISteamInventory,
25704 resultHandle: SteamInventoryResult_t,
25705 pOutItemsArray: *mut SteamItemDetails_t,
25706 punOutItemsArraySize: *mut uint32,
25707 ) -> bool;
25708}
25709extern "C" {
25710 pub fn SteamAPI_ISteamInventory_GetResultItemProperty(
25711 self_: *mut ISteamInventory,
25712 resultHandle: SteamInventoryResult_t,
25713 unItemIndex: uint32,
25714 pchPropertyName: *const ::std::os::raw::c_char,
25715 pchValueBuffer: *mut ::std::os::raw::c_char,
25716 punValueBufferSizeOut: *mut uint32,
25717 ) -> bool;
25718}
25719extern "C" {
25720 pub fn SteamAPI_ISteamInventory_GetResultTimestamp(
25721 self_: *mut ISteamInventory,
25722 resultHandle: SteamInventoryResult_t,
25723 ) -> uint32;
25724}
25725extern "C" {
25726 pub fn SteamAPI_ISteamInventory_CheckResultSteamID(
25727 self_: *mut ISteamInventory,
25728 resultHandle: SteamInventoryResult_t,
25729 steamIDExpected: uint64_steamid,
25730 ) -> bool;
25731}
25732extern "C" {
25733 pub fn SteamAPI_ISteamInventory_DestroyResult(
25734 self_: *mut ISteamInventory,
25735 resultHandle: SteamInventoryResult_t,
25736 );
25737}
25738extern "C" {
25739 pub fn SteamAPI_ISteamInventory_GetAllItems(
25740 self_: *mut ISteamInventory,
25741 pResultHandle: *mut SteamInventoryResult_t,
25742 ) -> bool;
25743}
25744extern "C" {
25745 pub fn SteamAPI_ISteamInventory_GetItemsByID(
25746 self_: *mut ISteamInventory,
25747 pResultHandle: *mut SteamInventoryResult_t,
25748 pInstanceIDs: *const SteamItemInstanceID_t,
25749 unCountInstanceIDs: uint32,
25750 ) -> bool;
25751}
25752extern "C" {
25753 pub fn SteamAPI_ISteamInventory_SerializeResult(
25754 self_: *mut ISteamInventory,
25755 resultHandle: SteamInventoryResult_t,
25756 pOutBuffer: *mut ::std::os::raw::c_void,
25757 punOutBufferSize: *mut uint32,
25758 ) -> bool;
25759}
25760extern "C" {
25761 pub fn SteamAPI_ISteamInventory_DeserializeResult(
25762 self_: *mut ISteamInventory,
25763 pOutResultHandle: *mut SteamInventoryResult_t,
25764 pBuffer: *const ::std::os::raw::c_void,
25765 unBufferSize: uint32,
25766 bRESERVED_MUST_BE_FALSE: bool,
25767 ) -> bool;
25768}
25769extern "C" {
25770 pub fn SteamAPI_ISteamInventory_GenerateItems(
25771 self_: *mut ISteamInventory,
25772 pResultHandle: *mut SteamInventoryResult_t,
25773 pArrayItemDefs: *const SteamItemDef_t,
25774 punArrayQuantity: *const uint32,
25775 unArrayLength: uint32,
25776 ) -> bool;
25777}
25778extern "C" {
25779 pub fn SteamAPI_ISteamInventory_GrantPromoItems(
25780 self_: *mut ISteamInventory,
25781 pResultHandle: *mut SteamInventoryResult_t,
25782 ) -> bool;
25783}
25784extern "C" {
25785 pub fn SteamAPI_ISteamInventory_AddPromoItem(
25786 self_: *mut ISteamInventory,
25787 pResultHandle: *mut SteamInventoryResult_t,
25788 itemDef: SteamItemDef_t,
25789 ) -> bool;
25790}
25791extern "C" {
25792 pub fn SteamAPI_ISteamInventory_AddPromoItems(
25793 self_: *mut ISteamInventory,
25794 pResultHandle: *mut SteamInventoryResult_t,
25795 pArrayItemDefs: *const SteamItemDef_t,
25796 unArrayLength: uint32,
25797 ) -> bool;
25798}
25799extern "C" {
25800 pub fn SteamAPI_ISteamInventory_ConsumeItem(
25801 self_: *mut ISteamInventory,
25802 pResultHandle: *mut SteamInventoryResult_t,
25803 itemConsume: SteamItemInstanceID_t,
25804 unQuantity: uint32,
25805 ) -> bool;
25806}
25807extern "C" {
25808 pub fn SteamAPI_ISteamInventory_ExchangeItems(
25809 self_: *mut ISteamInventory,
25810 pResultHandle: *mut SteamInventoryResult_t,
25811 pArrayGenerate: *const SteamItemDef_t,
25812 punArrayGenerateQuantity: *const uint32,
25813 unArrayGenerateLength: uint32,
25814 pArrayDestroy: *const SteamItemInstanceID_t,
25815 punArrayDestroyQuantity: *const uint32,
25816 unArrayDestroyLength: uint32,
25817 ) -> bool;
25818}
25819extern "C" {
25820 pub fn SteamAPI_ISteamInventory_TransferItemQuantity(
25821 self_: *mut ISteamInventory,
25822 pResultHandle: *mut SteamInventoryResult_t,
25823 itemIdSource: SteamItemInstanceID_t,
25824 unQuantity: uint32,
25825 itemIdDest: SteamItemInstanceID_t,
25826 ) -> bool;
25827}
25828extern "C" {
25829 pub fn SteamAPI_ISteamInventory_SendItemDropHeartbeat(self_: *mut ISteamInventory);
25830}
25831extern "C" {
25832 pub fn SteamAPI_ISteamInventory_TriggerItemDrop(
25833 self_: *mut ISteamInventory,
25834 pResultHandle: *mut SteamInventoryResult_t,
25835 dropListDefinition: SteamItemDef_t,
25836 ) -> bool;
25837}
25838extern "C" {
25839 pub fn SteamAPI_ISteamInventory_TradeItems(
25840 self_: *mut ISteamInventory,
25841 pResultHandle: *mut SteamInventoryResult_t,
25842 steamIDTradePartner: uint64_steamid,
25843 pArrayGive: *const SteamItemInstanceID_t,
25844 pArrayGiveQuantity: *const uint32,
25845 nArrayGiveLength: uint32,
25846 pArrayGet: *const SteamItemInstanceID_t,
25847 pArrayGetQuantity: *const uint32,
25848 nArrayGetLength: uint32,
25849 ) -> bool;
25850}
25851extern "C" {
25852 pub fn SteamAPI_ISteamInventory_LoadItemDefinitions(self_: *mut ISteamInventory) -> bool;
25853}
25854extern "C" {
25855 pub fn SteamAPI_ISteamInventory_GetItemDefinitionIDs(
25856 self_: *mut ISteamInventory,
25857 pItemDefIDs: *mut SteamItemDef_t,
25858 punItemDefIDsArraySize: *mut uint32,
25859 ) -> bool;
25860}
25861extern "C" {
25862 pub fn SteamAPI_ISteamInventory_GetItemDefinitionProperty(
25863 self_: *mut ISteamInventory,
25864 iDefinition: SteamItemDef_t,
25865 pchPropertyName: *const ::std::os::raw::c_char,
25866 pchValueBuffer: *mut ::std::os::raw::c_char,
25867 punValueBufferSizeOut: *mut uint32,
25868 ) -> bool;
25869}
25870extern "C" {
25871 pub fn SteamAPI_ISteamInventory_RequestEligiblePromoItemDefinitionsIDs(
25872 self_: *mut ISteamInventory,
25873 steamID: uint64_steamid,
25874 ) -> SteamAPICall_t;
25875}
25876extern "C" {
25877 pub fn SteamAPI_ISteamInventory_GetEligiblePromoItemDefinitionIDs(
25878 self_: *mut ISteamInventory,
25879 steamID: uint64_steamid,
25880 pItemDefIDs: *mut SteamItemDef_t,
25881 punItemDefIDsArraySize: *mut uint32,
25882 ) -> bool;
25883}
25884extern "C" {
25885 pub fn SteamAPI_ISteamInventory_StartPurchase(
25886 self_: *mut ISteamInventory,
25887 pArrayItemDefs: *const SteamItemDef_t,
25888 punArrayQuantity: *const uint32,
25889 unArrayLength: uint32,
25890 ) -> SteamAPICall_t;
25891}
25892extern "C" {
25893 pub fn SteamAPI_ISteamInventory_RequestPrices(self_: *mut ISteamInventory) -> SteamAPICall_t;
25894}
25895extern "C" {
25896 pub fn SteamAPI_ISteamInventory_GetNumItemsWithPrices(self_: *mut ISteamInventory) -> uint32;
25897}
25898extern "C" {
25899 pub fn SteamAPI_ISteamInventory_GetItemsWithPrices(
25900 self_: *mut ISteamInventory,
25901 pArrayItemDefs: *mut SteamItemDef_t,
25902 pCurrentPrices: *mut uint64,
25903 pBasePrices: *mut uint64,
25904 unArrayLength: uint32,
25905 ) -> bool;
25906}
25907extern "C" {
25908 pub fn SteamAPI_ISteamInventory_GetItemPrice(
25909 self_: *mut ISteamInventory,
25910 iDefinition: SteamItemDef_t,
25911 pCurrentPrice: *mut uint64,
25912 pBasePrice: *mut uint64,
25913 ) -> bool;
25914}
25915extern "C" {
25916 pub fn SteamAPI_ISteamInventory_StartUpdateProperties(
25917 self_: *mut ISteamInventory,
25918 ) -> SteamInventoryUpdateHandle_t;
25919}
25920extern "C" {
25921 pub fn SteamAPI_ISteamInventory_RemoveProperty(
25922 self_: *mut ISteamInventory,
25923 handle: SteamInventoryUpdateHandle_t,
25924 nItemID: SteamItemInstanceID_t,
25925 pchPropertyName: *const ::std::os::raw::c_char,
25926 ) -> bool;
25927}
25928extern "C" {
25929 pub fn SteamAPI_ISteamInventory_SetPropertyString(
25930 self_: *mut ISteamInventory,
25931 handle: SteamInventoryUpdateHandle_t,
25932 nItemID: SteamItemInstanceID_t,
25933 pchPropertyName: *const ::std::os::raw::c_char,
25934 pchPropertyValue: *const ::std::os::raw::c_char,
25935 ) -> bool;
25936}
25937extern "C" {
25938 pub fn SteamAPI_ISteamInventory_SetPropertyBool(
25939 self_: *mut ISteamInventory,
25940 handle: SteamInventoryUpdateHandle_t,
25941 nItemID: SteamItemInstanceID_t,
25942 pchPropertyName: *const ::std::os::raw::c_char,
25943 bValue: bool,
25944 ) -> bool;
25945}
25946extern "C" {
25947 pub fn SteamAPI_ISteamInventory_SetPropertyInt64(
25948 self_: *mut ISteamInventory,
25949 handle: SteamInventoryUpdateHandle_t,
25950 nItemID: SteamItemInstanceID_t,
25951 pchPropertyName: *const ::std::os::raw::c_char,
25952 nValue: int64,
25953 ) -> bool;
25954}
25955extern "C" {
25956 pub fn SteamAPI_ISteamInventory_SetPropertyFloat(
25957 self_: *mut ISteamInventory,
25958 handle: SteamInventoryUpdateHandle_t,
25959 nItemID: SteamItemInstanceID_t,
25960 pchPropertyName: *const ::std::os::raw::c_char,
25961 flValue: f32,
25962 ) -> bool;
25963}
25964extern "C" {
25965 pub fn SteamAPI_ISteamInventory_SubmitUpdateProperties(
25966 self_: *mut ISteamInventory,
25967 handle: SteamInventoryUpdateHandle_t,
25968 pResultHandle: *mut SteamInventoryResult_t,
25969 ) -> bool;
25970}
25971extern "C" {
25972 pub fn SteamAPI_ISteamInventory_InspectItem(
25973 self_: *mut ISteamInventory,
25974 pResultHandle: *mut SteamInventoryResult_t,
25975 pchItemToken: *const ::std::os::raw::c_char,
25976 ) -> bool;
25977}
25978extern "C" {
25979 pub fn SteamAPI_SteamTimeline_v004() -> *mut ISteamTimeline;
25980}
25981extern "C" {
25982 pub fn SteamAPI_ISteamTimeline_SetTimelineTooltip(
25983 self_: *mut ISteamTimeline,
25984 pchDescription: *const ::std::os::raw::c_char,
25985 flTimeDelta: f32,
25986 );
25987}
25988extern "C" {
25989 pub fn SteamAPI_ISteamTimeline_ClearTimelineTooltip(
25990 self_: *mut ISteamTimeline,
25991 flTimeDelta: f32,
25992 );
25993}
25994extern "C" {
25995 pub fn SteamAPI_ISteamTimeline_SetTimelineGameMode(
25996 self_: *mut ISteamTimeline,
25997 eMode: ETimelineGameMode,
25998 );
25999}
26000extern "C" {
26001 pub fn SteamAPI_ISteamTimeline_AddInstantaneousTimelineEvent(
26002 self_: *mut ISteamTimeline,
26003 pchTitle: *const ::std::os::raw::c_char,
26004 pchDescription: *const ::std::os::raw::c_char,
26005 pchIcon: *const ::std::os::raw::c_char,
26006 unIconPriority: uint32,
26007 flStartOffsetSeconds: f32,
26008 ePossibleClip: ETimelineEventClipPriority,
26009 ) -> TimelineEventHandle_t;
26010}
26011extern "C" {
26012 pub fn SteamAPI_ISteamTimeline_AddRangeTimelineEvent(
26013 self_: *mut ISteamTimeline,
26014 pchTitle: *const ::std::os::raw::c_char,
26015 pchDescription: *const ::std::os::raw::c_char,
26016 pchIcon: *const ::std::os::raw::c_char,
26017 unIconPriority: uint32,
26018 flStartOffsetSeconds: f32,
26019 flDuration: f32,
26020 ePossibleClip: ETimelineEventClipPriority,
26021 ) -> TimelineEventHandle_t;
26022}
26023extern "C" {
26024 pub fn SteamAPI_ISteamTimeline_StartRangeTimelineEvent(
26025 self_: *mut ISteamTimeline,
26026 pchTitle: *const ::std::os::raw::c_char,
26027 pchDescription: *const ::std::os::raw::c_char,
26028 pchIcon: *const ::std::os::raw::c_char,
26029 unPriority: uint32,
26030 flStartOffsetSeconds: f32,
26031 ePossibleClip: ETimelineEventClipPriority,
26032 ) -> TimelineEventHandle_t;
26033}
26034extern "C" {
26035 pub fn SteamAPI_ISteamTimeline_UpdateRangeTimelineEvent(
26036 self_: *mut ISteamTimeline,
26037 ulEvent: TimelineEventHandle_t,
26038 pchTitle: *const ::std::os::raw::c_char,
26039 pchDescription: *const ::std::os::raw::c_char,
26040 pchIcon: *const ::std::os::raw::c_char,
26041 unPriority: uint32,
26042 ePossibleClip: ETimelineEventClipPriority,
26043 );
26044}
26045extern "C" {
26046 pub fn SteamAPI_ISteamTimeline_EndRangeTimelineEvent(
26047 self_: *mut ISteamTimeline,
26048 ulEvent: TimelineEventHandle_t,
26049 flEndOffsetSeconds: f32,
26050 );
26051}
26052extern "C" {
26053 pub fn SteamAPI_ISteamTimeline_RemoveTimelineEvent(
26054 self_: *mut ISteamTimeline,
26055 ulEvent: TimelineEventHandle_t,
26056 );
26057}
26058extern "C" {
26059 pub fn SteamAPI_ISteamTimeline_DoesEventRecordingExist(
26060 self_: *mut ISteamTimeline,
26061 ulEvent: TimelineEventHandle_t,
26062 ) -> SteamAPICall_t;
26063}
26064extern "C" {
26065 pub fn SteamAPI_ISteamTimeline_StartGamePhase(self_: *mut ISteamTimeline);
26066}
26067extern "C" {
26068 pub fn SteamAPI_ISteamTimeline_EndGamePhase(self_: *mut ISteamTimeline);
26069}
26070extern "C" {
26071 pub fn SteamAPI_ISteamTimeline_SetGamePhaseID(
26072 self_: *mut ISteamTimeline,
26073 pchPhaseID: *const ::std::os::raw::c_char,
26074 );
26075}
26076extern "C" {
26077 pub fn SteamAPI_ISteamTimeline_DoesGamePhaseRecordingExist(
26078 self_: *mut ISteamTimeline,
26079 pchPhaseID: *const ::std::os::raw::c_char,
26080 ) -> SteamAPICall_t;
26081}
26082extern "C" {
26083 pub fn SteamAPI_ISteamTimeline_AddGamePhaseTag(
26084 self_: *mut ISteamTimeline,
26085 pchTagName: *const ::std::os::raw::c_char,
26086 pchTagIcon: *const ::std::os::raw::c_char,
26087 pchTagGroup: *const ::std::os::raw::c_char,
26088 unPriority: uint32,
26089 );
26090}
26091extern "C" {
26092 pub fn SteamAPI_ISteamTimeline_SetGamePhaseAttribute(
26093 self_: *mut ISteamTimeline,
26094 pchAttributeGroup: *const ::std::os::raw::c_char,
26095 pchAttributeValue: *const ::std::os::raw::c_char,
26096 unPriority: uint32,
26097 );
26098}
26099extern "C" {
26100 pub fn SteamAPI_ISteamTimeline_OpenOverlayToGamePhase(
26101 self_: *mut ISteamTimeline,
26102 pchPhaseID: *const ::std::os::raw::c_char,
26103 );
26104}
26105extern "C" {
26106 pub fn SteamAPI_ISteamTimeline_OpenOverlayToTimelineEvent(
26107 self_: *mut ISteamTimeline,
26108 ulEvent: TimelineEventHandle_t,
26109 );
26110}
26111extern "C" {
26112 pub fn SteamAPI_SteamVideo_v007() -> *mut ISteamVideo;
26113}
26114extern "C" {
26115 pub fn SteamAPI_ISteamVideo_GetVideoURL(self_: *mut ISteamVideo, unVideoAppID: AppId_t);
26116}
26117extern "C" {
26118 pub fn SteamAPI_ISteamVideo_IsBroadcasting(
26119 self_: *mut ISteamVideo,
26120 pnNumViewers: *mut ::std::os::raw::c_int,
26121 ) -> bool;
26122}
26123extern "C" {
26124 pub fn SteamAPI_ISteamVideo_GetOPFSettings(self_: *mut ISteamVideo, unVideoAppID: AppId_t);
26125}
26126extern "C" {
26127 pub fn SteamAPI_ISteamVideo_GetOPFStringForApp(
26128 self_: *mut ISteamVideo,
26129 unVideoAppID: AppId_t,
26130 pchBuffer: *mut ::std::os::raw::c_char,
26131 pnBufferSize: *mut int32,
26132 ) -> bool;
26133}
26134extern "C" {
26135 pub fn SteamAPI_SteamParentalSettings_v001() -> *mut ISteamParentalSettings;
26136}
26137extern "C" {
26138 pub fn SteamAPI_ISteamParentalSettings_BIsParentalLockEnabled(
26139 self_: *mut ISteamParentalSettings,
26140 ) -> bool;
26141}
26142extern "C" {
26143 pub fn SteamAPI_ISteamParentalSettings_BIsParentalLockLocked(
26144 self_: *mut ISteamParentalSettings,
26145 ) -> bool;
26146}
26147extern "C" {
26148 pub fn SteamAPI_ISteamParentalSettings_BIsAppBlocked(
26149 self_: *mut ISteamParentalSettings,
26150 nAppID: AppId_t,
26151 ) -> bool;
26152}
26153extern "C" {
26154 pub fn SteamAPI_ISteamParentalSettings_BIsAppInBlockList(
26155 self_: *mut ISteamParentalSettings,
26156 nAppID: AppId_t,
26157 ) -> bool;
26158}
26159extern "C" {
26160 pub fn SteamAPI_ISteamParentalSettings_BIsFeatureBlocked(
26161 self_: *mut ISteamParentalSettings,
26162 eFeature: EParentalFeature,
26163 ) -> bool;
26164}
26165extern "C" {
26166 pub fn SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList(
26167 self_: *mut ISteamParentalSettings,
26168 eFeature: EParentalFeature,
26169 ) -> bool;
26170}
26171extern "C" {
26172 pub fn SteamAPI_SteamRemotePlay_v004() -> *mut ISteamRemotePlay;
26173}
26174extern "C" {
26175 pub fn SteamAPI_ISteamRemotePlay_GetSessionCount(self_: *mut ISteamRemotePlay) -> uint32;
26176}
26177extern "C" {
26178 pub fn SteamAPI_ISteamRemotePlay_GetSessionID(
26179 self_: *mut ISteamRemotePlay,
26180 iSessionIndex: ::std::os::raw::c_int,
26181 ) -> RemotePlaySessionID_t;
26182}
26183extern "C" {
26184 pub fn SteamAPI_ISteamRemotePlay_BSessionRemotePlayTogether(
26185 self_: *mut ISteamRemotePlay,
26186 unSessionID: RemotePlaySessionID_t,
26187 ) -> bool;
26188}
26189extern "C" {
26190 pub fn SteamAPI_ISteamRemotePlay_GetSessionSteamID(
26191 self_: *mut ISteamRemotePlay,
26192 unSessionID: RemotePlaySessionID_t,
26193 ) -> uint64_steamid;
26194}
26195extern "C" {
26196 pub fn SteamAPI_ISteamRemotePlay_GetSessionGuestID(
26197 self_: *mut ISteamRemotePlay,
26198 unSessionID: RemotePlaySessionID_t,
26199 ) -> uint32;
26200}
26201extern "C" {
26202 pub fn SteamAPI_ISteamRemotePlay_GetSmallSessionAvatar(
26203 self_: *mut ISteamRemotePlay,
26204 unSessionID: RemotePlaySessionID_t,
26205 ) -> ::std::os::raw::c_int;
26206}
26207extern "C" {
26208 pub fn SteamAPI_ISteamRemotePlay_GetMediumSessionAvatar(
26209 self_: *mut ISteamRemotePlay,
26210 unSessionID: RemotePlaySessionID_t,
26211 ) -> ::std::os::raw::c_int;
26212}
26213extern "C" {
26214 pub fn SteamAPI_ISteamRemotePlay_GetLargeSessionAvatar(
26215 self_: *mut ISteamRemotePlay,
26216 unSessionID: RemotePlaySessionID_t,
26217 ) -> ::std::os::raw::c_int;
26218}
26219extern "C" {
26220 pub fn SteamAPI_ISteamRemotePlay_GetSessionClientName(
26221 self_: *mut ISteamRemotePlay,
26222 unSessionID: RemotePlaySessionID_t,
26223 ) -> *const ::std::os::raw::c_char;
26224}
26225extern "C" {
26226 pub fn SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor(
26227 self_: *mut ISteamRemotePlay,
26228 unSessionID: RemotePlaySessionID_t,
26229 ) -> ESteamDeviceFormFactor;
26230}
26231extern "C" {
26232 pub fn SteamAPI_ISteamRemotePlay_BGetSessionClientResolution(
26233 self_: *mut ISteamRemotePlay,
26234 unSessionID: RemotePlaySessionID_t,
26235 pnResolutionX: *mut ::std::os::raw::c_int,
26236 pnResolutionY: *mut ::std::os::raw::c_int,
26237 ) -> bool;
26238}
26239extern "C" {
26240 pub fn SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI(self_: *mut ISteamRemotePlay)
26241 -> bool;
26242}
26243extern "C" {
26244 pub fn SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite(
26245 self_: *mut ISteamRemotePlay,
26246 steamIDFriend: uint64_steamid,
26247 ) -> bool;
26248}
26249extern "C" {
26250 pub fn SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput(
26251 self_: *mut ISteamRemotePlay,
26252 ) -> bool;
26253}
26254extern "C" {
26255 pub fn SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput(
26256 self_: *mut ISteamRemotePlay,
26257 );
26258}
26259extern "C" {
26260 pub fn SteamAPI_ISteamRemotePlay_GetInput(
26261 self_: *mut ISteamRemotePlay,
26262 pInput: *mut RemotePlayInput_t,
26263 unMaxEvents: uint32,
26264 ) -> uint32;
26265}
26266extern "C" {
26267 pub fn SteamAPI_ISteamRemotePlay_SetMouseVisibility(
26268 self_: *mut ISteamRemotePlay,
26269 unSessionID: RemotePlaySessionID_t,
26270 bVisible: bool,
26271 );
26272}
26273extern "C" {
26274 pub fn SteamAPI_ISteamRemotePlay_SetMousePosition(
26275 self_: *mut ISteamRemotePlay,
26276 unSessionID: RemotePlaySessionID_t,
26277 flNormalizedX: f32,
26278 flNormalizedY: f32,
26279 );
26280}
26281extern "C" {
26282 pub fn SteamAPI_ISteamRemotePlay_CreateMouseCursor(
26283 self_: *mut ISteamRemotePlay,
26284 nWidth: ::std::os::raw::c_int,
26285 nHeight: ::std::os::raw::c_int,
26286 nHotX: ::std::os::raw::c_int,
26287 nHotY: ::std::os::raw::c_int,
26288 pBGRA: *const ::std::os::raw::c_void,
26289 nPitch: ::std::os::raw::c_int,
26290 ) -> RemotePlayCursorID_t;
26291}
26292extern "C" {
26293 pub fn SteamAPI_ISteamRemotePlay_SetMouseCursor(
26294 self_: *mut ISteamRemotePlay,
26295 unSessionID: RemotePlaySessionID_t,
26296 unCursorID: RemotePlayCursorID_t,
26297 );
26298}
26299extern "C" {
26300 pub fn SteamAPI_SteamNetworkingMessages_SteamAPI_v002() -> *mut ISteamNetworkingMessages;
26301}
26302extern "C" {
26303 pub fn SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002(
26304 ) -> *mut ISteamNetworkingMessages;
26305}
26306extern "C" {
26307 pub fn SteamAPI_ISteamNetworkingMessages_SendMessageToUser(
26308 self_: *mut ISteamNetworkingMessages,
26309 identityRemote: *const SteamNetworkingIdentity,
26310 pubData: *const ::std::os::raw::c_void,
26311 cubData: uint32,
26312 nSendFlags: ::std::os::raw::c_int,
26313 nRemoteChannel: ::std::os::raw::c_int,
26314 ) -> EResult;
26315}
26316extern "C" {
26317 pub fn SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel(
26318 self_: *mut ISteamNetworkingMessages,
26319 nLocalChannel: ::std::os::raw::c_int,
26320 ppOutMessages: *mut *mut SteamNetworkingMessage_t,
26321 nMaxMessages: ::std::os::raw::c_int,
26322 ) -> ::std::os::raw::c_int;
26323}
26324extern "C" {
26325 pub fn SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser(
26326 self_: *mut ISteamNetworkingMessages,
26327 identityRemote: *const SteamNetworkingIdentity,
26328 ) -> bool;
26329}
26330extern "C" {
26331 pub fn SteamAPI_ISteamNetworkingMessages_CloseSessionWithUser(
26332 self_: *mut ISteamNetworkingMessages,
26333 identityRemote: *const SteamNetworkingIdentity,
26334 ) -> bool;
26335}
26336extern "C" {
26337 pub fn SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser(
26338 self_: *mut ISteamNetworkingMessages,
26339 identityRemote: *const SteamNetworkingIdentity,
26340 nLocalChannel: ::std::os::raw::c_int,
26341 ) -> bool;
26342}
26343extern "C" {
26344 pub fn SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo(
26345 self_: *mut ISteamNetworkingMessages,
26346 identityRemote: *const SteamNetworkingIdentity,
26347 pConnectionInfo: *mut SteamNetConnectionInfo_t,
26348 pQuickStatus: *mut SteamNetConnectionRealTimeStatus_t,
26349 ) -> ESteamNetworkingConnectionState;
26350}
26351extern "C" {
26352 pub fn SteamAPI_SteamNetworkingSockets_SteamAPI_v012() -> *mut ISteamNetworkingSockets;
26353}
26354extern "C" {
26355 pub fn SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012() -> *mut ISteamNetworkingSockets;
26356}
26357extern "C" {
26358 pub fn SteamAPI_ISteamNetworkingSockets_CreateListenSocketIP(
26359 self_: *mut ISteamNetworkingSockets,
26360 localAddress: *const SteamNetworkingIPAddr,
26361 nOptions: ::std::os::raw::c_int,
26362 pOptions: *const SteamNetworkingConfigValue_t,
26363 ) -> HSteamListenSocket;
26364}
26365extern "C" {
26366 pub fn SteamAPI_ISteamNetworkingSockets_ConnectByIPAddress(
26367 self_: *mut ISteamNetworkingSockets,
26368 address: *const SteamNetworkingIPAddr,
26369 nOptions: ::std::os::raw::c_int,
26370 pOptions: *const SteamNetworkingConfigValue_t,
26371 ) -> HSteamNetConnection;
26372}
26373extern "C" {
26374 pub fn SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2P(
26375 self_: *mut ISteamNetworkingSockets,
26376 nLocalVirtualPort: ::std::os::raw::c_int,
26377 nOptions: ::std::os::raw::c_int,
26378 pOptions: *const SteamNetworkingConfigValue_t,
26379 ) -> HSteamListenSocket;
26380}
26381extern "C" {
26382 pub fn SteamAPI_ISteamNetworkingSockets_ConnectP2P(
26383 self_: *mut ISteamNetworkingSockets,
26384 identityRemote: *const SteamNetworkingIdentity,
26385 nRemoteVirtualPort: ::std::os::raw::c_int,
26386 nOptions: ::std::os::raw::c_int,
26387 pOptions: *const SteamNetworkingConfigValue_t,
26388 ) -> HSteamNetConnection;
26389}
26390extern "C" {
26391 pub fn SteamAPI_ISteamNetworkingSockets_AcceptConnection(
26392 self_: *mut ISteamNetworkingSockets,
26393 hConn: HSteamNetConnection,
26394 ) -> EResult;
26395}
26396extern "C" {
26397 pub fn SteamAPI_ISteamNetworkingSockets_CloseConnection(
26398 self_: *mut ISteamNetworkingSockets,
26399 hPeer: HSteamNetConnection,
26400 nReason: ::std::os::raw::c_int,
26401 pszDebug: *const ::std::os::raw::c_char,
26402 bEnableLinger: bool,
26403 ) -> bool;
26404}
26405extern "C" {
26406 pub fn SteamAPI_ISteamNetworkingSockets_CloseListenSocket(
26407 self_: *mut ISteamNetworkingSockets,
26408 hSocket: HSteamListenSocket,
26409 ) -> bool;
26410}
26411extern "C" {
26412 pub fn SteamAPI_ISteamNetworkingSockets_SetConnectionUserData(
26413 self_: *mut ISteamNetworkingSockets,
26414 hPeer: HSteamNetConnection,
26415 nUserData: int64,
26416 ) -> bool;
26417}
26418extern "C" {
26419 pub fn SteamAPI_ISteamNetworkingSockets_GetConnectionUserData(
26420 self_: *mut ISteamNetworkingSockets,
26421 hPeer: HSteamNetConnection,
26422 ) -> int64;
26423}
26424extern "C" {
26425 pub fn SteamAPI_ISteamNetworkingSockets_SetConnectionName(
26426 self_: *mut ISteamNetworkingSockets,
26427 hPeer: HSteamNetConnection,
26428 pszName: *const ::std::os::raw::c_char,
26429 );
26430}
26431extern "C" {
26432 pub fn SteamAPI_ISteamNetworkingSockets_GetConnectionName(
26433 self_: *mut ISteamNetworkingSockets,
26434 hPeer: HSteamNetConnection,
26435 pszName: *mut ::std::os::raw::c_char,
26436 nMaxLen: ::std::os::raw::c_int,
26437 ) -> bool;
26438}
26439extern "C" {
26440 pub fn SteamAPI_ISteamNetworkingSockets_SendMessageToConnection(
26441 self_: *mut ISteamNetworkingSockets,
26442 hConn: HSteamNetConnection,
26443 pData: *const ::std::os::raw::c_void,
26444 cbData: uint32,
26445 nSendFlags: ::std::os::raw::c_int,
26446 pOutMessageNumber: *mut int64,
26447 ) -> EResult;
26448}
26449extern "C" {
26450 pub fn SteamAPI_ISteamNetworkingSockets_SendMessages(
26451 self_: *mut ISteamNetworkingSockets,
26452 nMessages: ::std::os::raw::c_int,
26453 pMessages: *const *mut SteamNetworkingMessage_t,
26454 pOutMessageNumberOrResult: *mut int64,
26455 );
26456}
26457extern "C" {
26458 pub fn SteamAPI_ISteamNetworkingSockets_FlushMessagesOnConnection(
26459 self_: *mut ISteamNetworkingSockets,
26460 hConn: HSteamNetConnection,
26461 ) -> EResult;
26462}
26463extern "C" {
26464 pub fn SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnConnection(
26465 self_: *mut ISteamNetworkingSockets,
26466 hConn: HSteamNetConnection,
26467 ppOutMessages: *mut *mut SteamNetworkingMessage_t,
26468 nMaxMessages: ::std::os::raw::c_int,
26469 ) -> ::std::os::raw::c_int;
26470}
26471extern "C" {
26472 pub fn SteamAPI_ISteamNetworkingSockets_GetConnectionInfo(
26473 self_: *mut ISteamNetworkingSockets,
26474 hConn: HSteamNetConnection,
26475 pInfo: *mut SteamNetConnectionInfo_t,
26476 ) -> bool;
26477}
26478extern "C" {
26479 pub fn SteamAPI_ISteamNetworkingSockets_GetConnectionRealTimeStatus(
26480 self_: *mut ISteamNetworkingSockets,
26481 hConn: HSteamNetConnection,
26482 pStatus: *mut SteamNetConnectionRealTimeStatus_t,
26483 nLanes: ::std::os::raw::c_int,
26484 pLanes: *mut SteamNetConnectionRealTimeLaneStatus_t,
26485 ) -> EResult;
26486}
26487extern "C" {
26488 pub fn SteamAPI_ISteamNetworkingSockets_GetDetailedConnectionStatus(
26489 self_: *mut ISteamNetworkingSockets,
26490 hConn: HSteamNetConnection,
26491 pszBuf: *mut ::std::os::raw::c_char,
26492 cbBuf: ::std::os::raw::c_int,
26493 ) -> ::std::os::raw::c_int;
26494}
26495extern "C" {
26496 pub fn SteamAPI_ISteamNetworkingSockets_GetListenSocketAddress(
26497 self_: *mut ISteamNetworkingSockets,
26498 hSocket: HSteamListenSocket,
26499 address: *mut SteamNetworkingIPAddr,
26500 ) -> bool;
26501}
26502extern "C" {
26503 pub fn SteamAPI_ISteamNetworkingSockets_CreateSocketPair(
26504 self_: *mut ISteamNetworkingSockets,
26505 pOutConnection1: *mut HSteamNetConnection,
26506 pOutConnection2: *mut HSteamNetConnection,
26507 bUseNetworkLoopback: bool,
26508 pIdentity1: *const SteamNetworkingIdentity,
26509 pIdentity2: *const SteamNetworkingIdentity,
26510 ) -> bool;
26511}
26512extern "C" {
26513 pub fn SteamAPI_ISteamNetworkingSockets_ConfigureConnectionLanes(
26514 self_: *mut ISteamNetworkingSockets,
26515 hConn: HSteamNetConnection,
26516 nNumLanes: ::std::os::raw::c_int,
26517 pLanePriorities: *const ::std::os::raw::c_int,
26518 pLaneWeights: *const uint16,
26519 ) -> EResult;
26520}
26521extern "C" {
26522 pub fn SteamAPI_ISteamNetworkingSockets_GetIdentity(
26523 self_: *mut ISteamNetworkingSockets,
26524 pIdentity: *mut SteamNetworkingIdentity,
26525 ) -> bool;
26526}
26527extern "C" {
26528 pub fn SteamAPI_ISteamNetworkingSockets_InitAuthentication(
26529 self_: *mut ISteamNetworkingSockets,
26530 ) -> ESteamNetworkingAvailability;
26531}
26532extern "C" {
26533 pub fn SteamAPI_ISteamNetworkingSockets_GetAuthenticationStatus(
26534 self_: *mut ISteamNetworkingSockets,
26535 pDetails: *mut SteamNetAuthenticationStatus_t,
26536 ) -> ESteamNetworkingAvailability;
26537}
26538extern "C" {
26539 pub fn SteamAPI_ISteamNetworkingSockets_CreatePollGroup(
26540 self_: *mut ISteamNetworkingSockets,
26541 ) -> HSteamNetPollGroup;
26542}
26543extern "C" {
26544 pub fn SteamAPI_ISteamNetworkingSockets_DestroyPollGroup(
26545 self_: *mut ISteamNetworkingSockets,
26546 hPollGroup: HSteamNetPollGroup,
26547 ) -> bool;
26548}
26549extern "C" {
26550 pub fn SteamAPI_ISteamNetworkingSockets_SetConnectionPollGroup(
26551 self_: *mut ISteamNetworkingSockets,
26552 hConn: HSteamNetConnection,
26553 hPollGroup: HSteamNetPollGroup,
26554 ) -> bool;
26555}
26556extern "C" {
26557 pub fn SteamAPI_ISteamNetworkingSockets_ReceiveMessagesOnPollGroup(
26558 self_: *mut ISteamNetworkingSockets,
26559 hPollGroup: HSteamNetPollGroup,
26560 ppOutMessages: *mut *mut SteamNetworkingMessage_t,
26561 nMaxMessages: ::std::os::raw::c_int,
26562 ) -> ::std::os::raw::c_int;
26563}
26564extern "C" {
26565 pub fn SteamAPI_ISteamNetworkingSockets_ReceivedRelayAuthTicket(
26566 self_: *mut ISteamNetworkingSockets,
26567 pvTicket: *const ::std::os::raw::c_void,
26568 cbTicket: ::std::os::raw::c_int,
26569 pOutParsedTicket: *mut SteamDatagramRelayAuthTicket,
26570 ) -> bool;
26571}
26572extern "C" {
26573 pub fn SteamAPI_ISteamNetworkingSockets_FindRelayAuthTicketForServer(
26574 self_: *mut ISteamNetworkingSockets,
26575 identityGameServer: *const SteamNetworkingIdentity,
26576 nRemoteVirtualPort: ::std::os::raw::c_int,
26577 pOutParsedTicket: *mut SteamDatagramRelayAuthTicket,
26578 ) -> ::std::os::raw::c_int;
26579}
26580extern "C" {
26581 pub fn SteamAPI_ISteamNetworkingSockets_ConnectToHostedDedicatedServer(
26582 self_: *mut ISteamNetworkingSockets,
26583 identityTarget: *const SteamNetworkingIdentity,
26584 nRemoteVirtualPort: ::std::os::raw::c_int,
26585 nOptions: ::std::os::raw::c_int,
26586 pOptions: *const SteamNetworkingConfigValue_t,
26587 ) -> HSteamNetConnection;
26588}
26589extern "C" {
26590 pub fn SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPort(
26591 self_: *mut ISteamNetworkingSockets,
26592 ) -> uint16;
26593}
26594extern "C" {
26595 pub fn SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerPOPID(
26596 self_: *mut ISteamNetworkingSockets,
26597 ) -> SteamNetworkingPOPID;
26598}
26599extern "C" {
26600 pub fn SteamAPI_ISteamNetworkingSockets_GetHostedDedicatedServerAddress(
26601 self_: *mut ISteamNetworkingSockets,
26602 pRouting: *mut SteamDatagramHostedAddress,
26603 ) -> EResult;
26604}
26605extern "C" {
26606 pub fn SteamAPI_ISteamNetworkingSockets_CreateHostedDedicatedServerListenSocket(
26607 self_: *mut ISteamNetworkingSockets,
26608 nLocalVirtualPort: ::std::os::raw::c_int,
26609 nOptions: ::std::os::raw::c_int,
26610 pOptions: *const SteamNetworkingConfigValue_t,
26611 ) -> HSteamListenSocket;
26612}
26613extern "C" {
26614 pub fn SteamAPI_ISteamNetworkingSockets_GetGameCoordinatorServerLogin(
26615 self_: *mut ISteamNetworkingSockets,
26616 pLoginInfo: *mut SteamDatagramGameCoordinatorServerLogin,
26617 pcbSignedBlob: *mut ::std::os::raw::c_int,
26618 pBlob: *mut ::std::os::raw::c_void,
26619 ) -> EResult;
26620}
26621extern "C" {
26622 pub fn SteamAPI_ISteamNetworkingSockets_ConnectP2PCustomSignaling(
26623 self_: *mut ISteamNetworkingSockets,
26624 pSignaling: *mut ISteamNetworkingConnectionSignaling,
26625 pPeerIdentity: *const SteamNetworkingIdentity,
26626 nRemoteVirtualPort: ::std::os::raw::c_int,
26627 nOptions: ::std::os::raw::c_int,
26628 pOptions: *const SteamNetworkingConfigValue_t,
26629 ) -> HSteamNetConnection;
26630}
26631extern "C" {
26632 pub fn SteamAPI_ISteamNetworkingSockets_ReceivedP2PCustomSignal(
26633 self_: *mut ISteamNetworkingSockets,
26634 pMsg: *const ::std::os::raw::c_void,
26635 cbMsg: ::std::os::raw::c_int,
26636 pContext: *mut ISteamNetworkingSignalingRecvContext,
26637 ) -> bool;
26638}
26639extern "C" {
26640 pub fn SteamAPI_ISteamNetworkingSockets_GetCertificateRequest(
26641 self_: *mut ISteamNetworkingSockets,
26642 pcbBlob: *mut ::std::os::raw::c_int,
26643 pBlob: *mut ::std::os::raw::c_void,
26644 errMsg: *mut SteamNetworkingErrMsg,
26645 ) -> bool;
26646}
26647extern "C" {
26648 pub fn SteamAPI_ISteamNetworkingSockets_SetCertificate(
26649 self_: *mut ISteamNetworkingSockets,
26650 pCertificate: *const ::std::os::raw::c_void,
26651 cbCertificate: ::std::os::raw::c_int,
26652 errMsg: *mut SteamNetworkingErrMsg,
26653 ) -> bool;
26654}
26655extern "C" {
26656 pub fn SteamAPI_ISteamNetworkingSockets_ResetIdentity(
26657 self_: *mut ISteamNetworkingSockets,
26658 pIdentity: *const SteamNetworkingIdentity,
26659 );
26660}
26661extern "C" {
26662 pub fn SteamAPI_ISteamNetworkingSockets_RunCallbacks(self_: *mut ISteamNetworkingSockets);
26663}
26664extern "C" {
26665 pub fn SteamAPI_ISteamNetworkingSockets_BeginAsyncRequestFakeIP(
26666 self_: *mut ISteamNetworkingSockets,
26667 nNumPorts: ::std::os::raw::c_int,
26668 ) -> bool;
26669}
26670extern "C" {
26671 pub fn SteamAPI_ISteamNetworkingSockets_GetFakeIP(
26672 self_: *mut ISteamNetworkingSockets,
26673 idxFirstPort: ::std::os::raw::c_int,
26674 pInfo: *mut SteamNetworkingFakeIPResult_t,
26675 );
26676}
26677extern "C" {
26678 pub fn SteamAPI_ISteamNetworkingSockets_CreateListenSocketP2PFakeIP(
26679 self_: *mut ISteamNetworkingSockets,
26680 idxFakePort: ::std::os::raw::c_int,
26681 nOptions: ::std::os::raw::c_int,
26682 pOptions: *const SteamNetworkingConfigValue_t,
26683 ) -> HSteamListenSocket;
26684}
26685extern "C" {
26686 pub fn SteamAPI_ISteamNetworkingSockets_GetRemoteFakeIPForConnection(
26687 self_: *mut ISteamNetworkingSockets,
26688 hConn: HSteamNetConnection,
26689 pOutAddr: *mut SteamNetworkingIPAddr,
26690 ) -> EResult;
26691}
26692extern "C" {
26693 pub fn SteamAPI_ISteamNetworkingSockets_CreateFakeUDPPort(
26694 self_: *mut ISteamNetworkingSockets,
26695 idxFakeServerPort: ::std::os::raw::c_int,
26696 ) -> *mut ISteamNetworkingFakeUDPPort;
26697}
26698extern "C" {
26699 pub fn SteamAPI_SteamNetworkingUtils_SteamAPI_v004() -> *mut ISteamNetworkingUtils;
26700}
26701extern "C" {
26702 pub fn SteamAPI_ISteamNetworkingUtils_AllocateMessage(
26703 self_: *mut ISteamNetworkingUtils,
26704 cbAllocateBuffer: ::std::os::raw::c_int,
26705 ) -> *mut SteamNetworkingMessage_t;
26706}
26707extern "C" {
26708 pub fn SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess(self_: *mut ISteamNetworkingUtils);
26709}
26710extern "C" {
26711 pub fn SteamAPI_ISteamNetworkingUtils_GetRelayNetworkStatus(
26712 self_: *mut ISteamNetworkingUtils,
26713 pDetails: *mut SteamRelayNetworkStatus_t,
26714 ) -> ESteamNetworkingAvailability;
26715}
26716extern "C" {
26717 pub fn SteamAPI_ISteamNetworkingUtils_GetLocalPingLocation(
26718 self_: *mut ISteamNetworkingUtils,
26719 result: *mut SteamNetworkPingLocation_t,
26720 ) -> f32;
26721}
26722extern "C" {
26723 pub fn SteamAPI_ISteamNetworkingUtils_EstimatePingTimeBetweenTwoLocations(
26724 self_: *mut ISteamNetworkingUtils,
26725 location1: *const SteamNetworkPingLocation_t,
26726 location2: *const SteamNetworkPingLocation_t,
26727 ) -> ::std::os::raw::c_int;
26728}
26729extern "C" {
26730 pub fn SteamAPI_ISteamNetworkingUtils_EstimatePingTimeFromLocalHost(
26731 self_: *mut ISteamNetworkingUtils,
26732 remoteLocation: *const SteamNetworkPingLocation_t,
26733 ) -> ::std::os::raw::c_int;
26734}
26735extern "C" {
26736 pub fn SteamAPI_ISteamNetworkingUtils_ConvertPingLocationToString(
26737 self_: *mut ISteamNetworkingUtils,
26738 location: *const SteamNetworkPingLocation_t,
26739 pszBuf: *mut ::std::os::raw::c_char,
26740 cchBufSize: ::std::os::raw::c_int,
26741 );
26742}
26743extern "C" {
26744 pub fn SteamAPI_ISteamNetworkingUtils_ParsePingLocationString(
26745 self_: *mut ISteamNetworkingUtils,
26746 pszString: *const ::std::os::raw::c_char,
26747 result: *mut SteamNetworkPingLocation_t,
26748 ) -> bool;
26749}
26750extern "C" {
26751 pub fn SteamAPI_ISteamNetworkingUtils_CheckPingDataUpToDate(
26752 self_: *mut ISteamNetworkingUtils,
26753 flMaxAgeSeconds: f32,
26754 ) -> bool;
26755}
26756extern "C" {
26757 pub fn SteamAPI_ISteamNetworkingUtils_GetPingToDataCenter(
26758 self_: *mut ISteamNetworkingUtils,
26759 popID: SteamNetworkingPOPID,
26760 pViaRelayPoP: *mut SteamNetworkingPOPID,
26761 ) -> ::std::os::raw::c_int;
26762}
26763extern "C" {
26764 pub fn SteamAPI_ISteamNetworkingUtils_GetDirectPingToPOP(
26765 self_: *mut ISteamNetworkingUtils,
26766 popID: SteamNetworkingPOPID,
26767 ) -> ::std::os::raw::c_int;
26768}
26769extern "C" {
26770 pub fn SteamAPI_ISteamNetworkingUtils_GetPOPCount(
26771 self_: *mut ISteamNetworkingUtils,
26772 ) -> ::std::os::raw::c_int;
26773}
26774extern "C" {
26775 pub fn SteamAPI_ISteamNetworkingUtils_GetPOPList(
26776 self_: *mut ISteamNetworkingUtils,
26777 list: *mut SteamNetworkingPOPID,
26778 nListSz: ::std::os::raw::c_int,
26779 ) -> ::std::os::raw::c_int;
26780}
26781extern "C" {
26782 pub fn SteamAPI_ISteamNetworkingUtils_GetLocalTimestamp(
26783 self_: *mut ISteamNetworkingUtils,
26784 ) -> SteamNetworkingMicroseconds;
26785}
26786extern "C" {
26787 pub fn SteamAPI_ISteamNetworkingUtils_SetDebugOutputFunction(
26788 self_: *mut ISteamNetworkingUtils,
26789 eDetailLevel: ESteamNetworkingSocketsDebugOutputType,
26790 pfnFunc: FSteamNetworkingSocketsDebugOutput,
26791 );
26792}
26793extern "C" {
26794 pub fn SteamAPI_ISteamNetworkingUtils_IsFakeIPv4(
26795 self_: *mut ISteamNetworkingUtils,
26796 nIPv4: uint32,
26797 ) -> bool;
26798}
26799extern "C" {
26800 pub fn SteamAPI_ISteamNetworkingUtils_GetIPv4FakeIPType(
26801 self_: *mut ISteamNetworkingUtils,
26802 nIPv4: uint32,
26803 ) -> ESteamNetworkingFakeIPType;
26804}
26805extern "C" {
26806 pub fn SteamAPI_ISteamNetworkingUtils_GetRealIdentityForFakeIP(
26807 self_: *mut ISteamNetworkingUtils,
26808 fakeIP: *const SteamNetworkingIPAddr,
26809 pOutRealIdentity: *mut SteamNetworkingIdentity,
26810 ) -> EResult;
26811}
26812extern "C" {
26813 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueInt32(
26814 self_: *mut ISteamNetworkingUtils,
26815 eValue: ESteamNetworkingConfigValue,
26816 val: int32,
26817 ) -> bool;
26818}
26819extern "C" {
26820 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueFloat(
26821 self_: *mut ISteamNetworkingUtils,
26822 eValue: ESteamNetworkingConfigValue,
26823 val: f32,
26824 ) -> bool;
26825}
26826extern "C" {
26827 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValueString(
26828 self_: *mut ISteamNetworkingUtils,
26829 eValue: ESteamNetworkingConfigValue,
26830 val: *const ::std::os::raw::c_char,
26831 ) -> bool;
26832}
26833extern "C" {
26834 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalConfigValuePtr(
26835 self_: *mut ISteamNetworkingUtils,
26836 eValue: ESteamNetworkingConfigValue,
26837 val: *mut ::std::os::raw::c_void,
26838 ) -> bool;
26839}
26840extern "C" {
26841 pub fn SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueInt32(
26842 self_: *mut ISteamNetworkingUtils,
26843 hConn: HSteamNetConnection,
26844 eValue: ESteamNetworkingConfigValue,
26845 val: int32,
26846 ) -> bool;
26847}
26848extern "C" {
26849 pub fn SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueFloat(
26850 self_: *mut ISteamNetworkingUtils,
26851 hConn: HSteamNetConnection,
26852 eValue: ESteamNetworkingConfigValue,
26853 val: f32,
26854 ) -> bool;
26855}
26856extern "C" {
26857 pub fn SteamAPI_ISteamNetworkingUtils_SetConnectionConfigValueString(
26858 self_: *mut ISteamNetworkingUtils,
26859 hConn: HSteamNetConnection,
26860 eValue: ESteamNetworkingConfigValue,
26861 val: *const ::std::os::raw::c_char,
26862 ) -> bool;
26863}
26864extern "C" {
26865 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetConnectionStatusChanged(
26866 self_: *mut ISteamNetworkingUtils,
26867 fnCallback: FnSteamNetConnectionStatusChanged,
26868 ) -> bool;
26869}
26870extern "C" {
26871 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamNetAuthenticationStatusChanged(
26872 self_: *mut ISteamNetworkingUtils,
26873 fnCallback: FnSteamNetAuthenticationStatusChanged,
26874 ) -> bool;
26875}
26876extern "C" {
26877 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_SteamRelayNetworkStatusChanged(
26878 self_: *mut ISteamNetworkingUtils,
26879 fnCallback: FnSteamRelayNetworkStatusChanged,
26880 ) -> bool;
26881}
26882extern "C" {
26883 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_FakeIPResult(
26884 self_: *mut ISteamNetworkingUtils,
26885 fnCallback: FnSteamNetworkingFakeIPResult,
26886 ) -> bool;
26887}
26888extern "C" {
26889 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionRequest(
26890 self_: *mut ISteamNetworkingUtils,
26891 fnCallback: FnSteamNetworkingMessagesSessionRequest,
26892 ) -> bool;
26893}
26894extern "C" {
26895 pub fn SteamAPI_ISteamNetworkingUtils_SetGlobalCallback_MessagesSessionFailed(
26896 self_: *mut ISteamNetworkingUtils,
26897 fnCallback: FnSteamNetworkingMessagesSessionFailed,
26898 ) -> bool;
26899}
26900extern "C" {
26901 pub fn SteamAPI_ISteamNetworkingUtils_SetConfigValue(
26902 self_: *mut ISteamNetworkingUtils,
26903 eValue: ESteamNetworkingConfigValue,
26904 eScopeType: ESteamNetworkingConfigScope,
26905 scopeObj: isize,
26906 eDataType: ESteamNetworkingConfigDataType,
26907 pArg: *const ::std::os::raw::c_void,
26908 ) -> bool;
26909}
26910extern "C" {
26911 pub fn SteamAPI_ISteamNetworkingUtils_SetConfigValueStruct(
26912 self_: *mut ISteamNetworkingUtils,
26913 opt: *const SteamNetworkingConfigValue_t,
26914 eScopeType: ESteamNetworkingConfigScope,
26915 scopeObj: isize,
26916 ) -> bool;
26917}
26918extern "C" {
26919 pub fn SteamAPI_ISteamNetworkingUtils_GetConfigValue(
26920 self_: *mut ISteamNetworkingUtils,
26921 eValue: ESteamNetworkingConfigValue,
26922 eScopeType: ESteamNetworkingConfigScope,
26923 scopeObj: isize,
26924 pOutDataType: *mut ESteamNetworkingConfigDataType,
26925 pResult: *mut ::std::os::raw::c_void,
26926 cbResult: *mut usize,
26927 ) -> ESteamNetworkingGetConfigValueResult;
26928}
26929extern "C" {
26930 pub fn SteamAPI_ISteamNetworkingUtils_GetConfigValueInfo(
26931 self_: *mut ISteamNetworkingUtils,
26932 eValue: ESteamNetworkingConfigValue,
26933 pOutDataType: *mut ESteamNetworkingConfigDataType,
26934 pOutScope: *mut ESteamNetworkingConfigScope,
26935 ) -> *const ::std::os::raw::c_char;
26936}
26937extern "C" {
26938 pub fn SteamAPI_ISteamNetworkingUtils_IterateGenericEditableConfigValues(
26939 self_: *mut ISteamNetworkingUtils,
26940 eCurrent: ESteamNetworkingConfigValue,
26941 bEnumerateDevVars: bool,
26942 ) -> ESteamNetworkingConfigValue;
26943}
26944extern "C" {
26945 pub fn SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ToString(
26946 self_: *mut ISteamNetworkingUtils,
26947 addr: *const SteamNetworkingIPAddr,
26948 buf: *mut ::std::os::raw::c_char,
26949 cbBuf: uint32,
26950 bWithPort: bool,
26951 );
26952}
26953extern "C" {
26954 pub fn SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_ParseString(
26955 self_: *mut ISteamNetworkingUtils,
26956 pAddr: *mut SteamNetworkingIPAddr,
26957 pszStr: *const ::std::os::raw::c_char,
26958 ) -> bool;
26959}
26960extern "C" {
26961 pub fn SteamAPI_ISteamNetworkingUtils_SteamNetworkingIPAddr_GetFakeIPType(
26962 self_: *mut ISteamNetworkingUtils,
26963 addr: *const SteamNetworkingIPAddr,
26964 ) -> ESteamNetworkingFakeIPType;
26965}
26966extern "C" {
26967 pub fn SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ToString(
26968 self_: *mut ISteamNetworkingUtils,
26969 identity: *const SteamNetworkingIdentity,
26970 buf: *mut ::std::os::raw::c_char,
26971 cbBuf: uint32,
26972 );
26973}
26974extern "C" {
26975 pub fn SteamAPI_ISteamNetworkingUtils_SteamNetworkingIdentity_ParseString(
26976 self_: *mut ISteamNetworkingUtils,
26977 pIdentity: *mut SteamNetworkingIdentity,
26978 pszStr: *const ::std::os::raw::c_char,
26979 ) -> bool;
26980}
26981extern "C" {
26982 pub fn SteamAPI_SteamGameServer_v015() -> *mut ISteamGameServer;
26983}
26984extern "C" {
26985 pub fn SteamAPI_ISteamGameServer_SetProduct(
26986 self_: *mut ISteamGameServer,
26987 pszProduct: *const ::std::os::raw::c_char,
26988 );
26989}
26990extern "C" {
26991 pub fn SteamAPI_ISteamGameServer_SetGameDescription(
26992 self_: *mut ISteamGameServer,
26993 pszGameDescription: *const ::std::os::raw::c_char,
26994 );
26995}
26996extern "C" {
26997 pub fn SteamAPI_ISteamGameServer_SetModDir(
26998 self_: *mut ISteamGameServer,
26999 pszModDir: *const ::std::os::raw::c_char,
27000 );
27001}
27002extern "C" {
27003 pub fn SteamAPI_ISteamGameServer_SetDedicatedServer(
27004 self_: *mut ISteamGameServer,
27005 bDedicated: bool,
27006 );
27007}
27008extern "C" {
27009 pub fn SteamAPI_ISteamGameServer_LogOn(
27010 self_: *mut ISteamGameServer,
27011 pszToken: *const ::std::os::raw::c_char,
27012 );
27013}
27014extern "C" {
27015 pub fn SteamAPI_ISteamGameServer_LogOnAnonymous(self_: *mut ISteamGameServer);
27016}
27017extern "C" {
27018 pub fn SteamAPI_ISteamGameServer_LogOff(self_: *mut ISteamGameServer);
27019}
27020extern "C" {
27021 pub fn SteamAPI_ISteamGameServer_BLoggedOn(self_: *mut ISteamGameServer) -> bool;
27022}
27023extern "C" {
27024 pub fn SteamAPI_ISteamGameServer_BSecure(self_: *mut ISteamGameServer) -> bool;
27025}
27026extern "C" {
27027 pub fn SteamAPI_ISteamGameServer_GetSteamID(self_: *mut ISteamGameServer) -> uint64_steamid;
27028}
27029extern "C" {
27030 pub fn SteamAPI_ISteamGameServer_WasRestartRequested(self_: *mut ISteamGameServer) -> bool;
27031}
27032extern "C" {
27033 pub fn SteamAPI_ISteamGameServer_SetMaxPlayerCount(
27034 self_: *mut ISteamGameServer,
27035 cPlayersMax: ::std::os::raw::c_int,
27036 );
27037}
27038extern "C" {
27039 pub fn SteamAPI_ISteamGameServer_SetBotPlayerCount(
27040 self_: *mut ISteamGameServer,
27041 cBotplayers: ::std::os::raw::c_int,
27042 );
27043}
27044extern "C" {
27045 pub fn SteamAPI_ISteamGameServer_SetServerName(
27046 self_: *mut ISteamGameServer,
27047 pszServerName: *const ::std::os::raw::c_char,
27048 );
27049}
27050extern "C" {
27051 pub fn SteamAPI_ISteamGameServer_SetMapName(
27052 self_: *mut ISteamGameServer,
27053 pszMapName: *const ::std::os::raw::c_char,
27054 );
27055}
27056extern "C" {
27057 pub fn SteamAPI_ISteamGameServer_SetPasswordProtected(
27058 self_: *mut ISteamGameServer,
27059 bPasswordProtected: bool,
27060 );
27061}
27062extern "C" {
27063 pub fn SteamAPI_ISteamGameServer_SetSpectatorPort(
27064 self_: *mut ISteamGameServer,
27065 unSpectatorPort: uint16,
27066 );
27067}
27068extern "C" {
27069 pub fn SteamAPI_ISteamGameServer_SetSpectatorServerName(
27070 self_: *mut ISteamGameServer,
27071 pszSpectatorServerName: *const ::std::os::raw::c_char,
27072 );
27073}
27074extern "C" {
27075 pub fn SteamAPI_ISteamGameServer_ClearAllKeyValues(self_: *mut ISteamGameServer);
27076}
27077extern "C" {
27078 pub fn SteamAPI_ISteamGameServer_SetKeyValue(
27079 self_: *mut ISteamGameServer,
27080 pKey: *const ::std::os::raw::c_char,
27081 pValue: *const ::std::os::raw::c_char,
27082 );
27083}
27084extern "C" {
27085 pub fn SteamAPI_ISteamGameServer_SetGameTags(
27086 self_: *mut ISteamGameServer,
27087 pchGameTags: *const ::std::os::raw::c_char,
27088 );
27089}
27090extern "C" {
27091 pub fn SteamAPI_ISteamGameServer_SetGameData(
27092 self_: *mut ISteamGameServer,
27093 pchGameData: *const ::std::os::raw::c_char,
27094 );
27095}
27096extern "C" {
27097 pub fn SteamAPI_ISteamGameServer_SetRegion(
27098 self_: *mut ISteamGameServer,
27099 pszRegion: *const ::std::os::raw::c_char,
27100 );
27101}
27102extern "C" {
27103 pub fn SteamAPI_ISteamGameServer_SetAdvertiseServerActive(
27104 self_: *mut ISteamGameServer,
27105 bActive: bool,
27106 );
27107}
27108extern "C" {
27109 pub fn SteamAPI_ISteamGameServer_GetAuthSessionTicket(
27110 self_: *mut ISteamGameServer,
27111 pTicket: *mut ::std::os::raw::c_void,
27112 cbMaxTicket: ::std::os::raw::c_int,
27113 pcbTicket: *mut uint32,
27114 pSnid: *const SteamNetworkingIdentity,
27115 ) -> HAuthTicket;
27116}
27117extern "C" {
27118 pub fn SteamAPI_ISteamGameServer_BeginAuthSession(
27119 self_: *mut ISteamGameServer,
27120 pAuthTicket: *const ::std::os::raw::c_void,
27121 cbAuthTicket: ::std::os::raw::c_int,
27122 steamID: uint64_steamid,
27123 ) -> EBeginAuthSessionResult;
27124}
27125extern "C" {
27126 pub fn SteamAPI_ISteamGameServer_EndAuthSession(
27127 self_: *mut ISteamGameServer,
27128 steamID: uint64_steamid,
27129 );
27130}
27131extern "C" {
27132 pub fn SteamAPI_ISteamGameServer_CancelAuthTicket(
27133 self_: *mut ISteamGameServer,
27134 hAuthTicket: HAuthTicket,
27135 );
27136}
27137extern "C" {
27138 pub fn SteamAPI_ISteamGameServer_UserHasLicenseForApp(
27139 self_: *mut ISteamGameServer,
27140 steamID: uint64_steamid,
27141 appID: AppId_t,
27142 ) -> EUserHasLicenseForAppResult;
27143}
27144extern "C" {
27145 pub fn SteamAPI_ISteamGameServer_RequestUserGroupStatus(
27146 self_: *mut ISteamGameServer,
27147 steamIDUser: uint64_steamid,
27148 steamIDGroup: uint64_steamid,
27149 ) -> bool;
27150}
27151extern "C" {
27152 pub fn SteamAPI_ISteamGameServer_GetGameplayStats(self_: *mut ISteamGameServer);
27153}
27154extern "C" {
27155 pub fn SteamAPI_ISteamGameServer_GetServerReputation(
27156 self_: *mut ISteamGameServer,
27157 ) -> SteamAPICall_t;
27158}
27159extern "C" {
27160 pub fn SteamAPI_ISteamGameServer_GetPublicIP(self_: *mut ISteamGameServer) -> SteamIPAddress_t;
27161}
27162extern "C" {
27163 pub fn SteamAPI_ISteamGameServer_HandleIncomingPacket(
27164 self_: *mut ISteamGameServer,
27165 pData: *const ::std::os::raw::c_void,
27166 cbData: ::std::os::raw::c_int,
27167 srcIP: uint32,
27168 srcPort: uint16,
27169 ) -> bool;
27170}
27171extern "C" {
27172 pub fn SteamAPI_ISteamGameServer_GetNextOutgoingPacket(
27173 self_: *mut ISteamGameServer,
27174 pOut: *mut ::std::os::raw::c_void,
27175 cbMaxOut: ::std::os::raw::c_int,
27176 pNetAdr: *mut uint32,
27177 pPort: *mut uint16,
27178 ) -> ::std::os::raw::c_int;
27179}
27180extern "C" {
27181 pub fn SteamAPI_ISteamGameServer_AssociateWithClan(
27182 self_: *mut ISteamGameServer,
27183 steamIDClan: uint64_steamid,
27184 ) -> SteamAPICall_t;
27185}
27186extern "C" {
27187 pub fn SteamAPI_ISteamGameServer_ComputeNewPlayerCompatibility(
27188 self_: *mut ISteamGameServer,
27189 steamIDNewPlayer: uint64_steamid,
27190 ) -> SteamAPICall_t;
27191}
27192extern "C" {
27193 pub fn SteamAPI_ISteamGameServer_SendUserConnectAndAuthenticate_DEPRECATED(
27194 self_: *mut ISteamGameServer,
27195 unIPClient: uint32,
27196 pvAuthBlob: *const ::std::os::raw::c_void,
27197 cubAuthBlobSize: uint32,
27198 pSteamIDUser: *mut CSteamID,
27199 ) -> bool;
27200}
27201extern "C" {
27202 pub fn SteamAPI_ISteamGameServer_CreateUnauthenticatedUserConnection(
27203 self_: *mut ISteamGameServer,
27204 ) -> uint64_steamid;
27205}
27206extern "C" {
27207 pub fn SteamAPI_ISteamGameServer_SendUserDisconnect_DEPRECATED(
27208 self_: *mut ISteamGameServer,
27209 steamIDUser: uint64_steamid,
27210 );
27211}
27212extern "C" {
27213 pub fn SteamAPI_ISteamGameServer_BUpdateUserData(
27214 self_: *mut ISteamGameServer,
27215 steamIDUser: uint64_steamid,
27216 pchPlayerName: *const ::std::os::raw::c_char,
27217 uScore: uint32,
27218 ) -> bool;
27219}
27220extern "C" {
27221 pub fn SteamAPI_SteamGameServerStats_v001() -> *mut ISteamGameServerStats;
27222}
27223extern "C" {
27224 pub fn SteamAPI_ISteamGameServerStats_RequestUserStats(
27225 self_: *mut ISteamGameServerStats,
27226 steamIDUser: uint64_steamid,
27227 ) -> SteamAPICall_t;
27228}
27229extern "C" {
27230 pub fn SteamAPI_ISteamGameServerStats_GetUserStatInt32(
27231 self_: *mut ISteamGameServerStats,
27232 steamIDUser: uint64_steamid,
27233 pchName: *const ::std::os::raw::c_char,
27234 pData: *mut int32,
27235 ) -> bool;
27236}
27237extern "C" {
27238 pub fn SteamAPI_ISteamGameServerStats_GetUserStatFloat(
27239 self_: *mut ISteamGameServerStats,
27240 steamIDUser: uint64_steamid,
27241 pchName: *const ::std::os::raw::c_char,
27242 pData: *mut f32,
27243 ) -> bool;
27244}
27245extern "C" {
27246 pub fn SteamAPI_ISteamGameServerStats_GetUserAchievement(
27247 self_: *mut ISteamGameServerStats,
27248 steamIDUser: uint64_steamid,
27249 pchName: *const ::std::os::raw::c_char,
27250 pbAchieved: *mut bool,
27251 ) -> bool;
27252}
27253extern "C" {
27254 pub fn SteamAPI_ISteamGameServerStats_SetUserStatInt32(
27255 self_: *mut ISteamGameServerStats,
27256 steamIDUser: uint64_steamid,
27257 pchName: *const ::std::os::raw::c_char,
27258 nData: int32,
27259 ) -> bool;
27260}
27261extern "C" {
27262 pub fn SteamAPI_ISteamGameServerStats_SetUserStatFloat(
27263 self_: *mut ISteamGameServerStats,
27264 steamIDUser: uint64_steamid,
27265 pchName: *const ::std::os::raw::c_char,
27266 fData: f32,
27267 ) -> bool;
27268}
27269extern "C" {
27270 pub fn SteamAPI_ISteamGameServerStats_UpdateUserAvgRateStat(
27271 self_: *mut ISteamGameServerStats,
27272 steamIDUser: uint64_steamid,
27273 pchName: *const ::std::os::raw::c_char,
27274 flCountThisSession: f32,
27275 dSessionLength: f64,
27276 ) -> bool;
27277}
27278extern "C" {
27279 pub fn SteamAPI_ISteamGameServerStats_SetUserAchievement(
27280 self_: *mut ISteamGameServerStats,
27281 steamIDUser: uint64_steamid,
27282 pchName: *const ::std::os::raw::c_char,
27283 ) -> bool;
27284}
27285extern "C" {
27286 pub fn SteamAPI_ISteamGameServerStats_ClearUserAchievement(
27287 self_: *mut ISteamGameServerStats,
27288 steamIDUser: uint64_steamid,
27289 pchName: *const ::std::os::raw::c_char,
27290 ) -> bool;
27291}
27292extern "C" {
27293 pub fn SteamAPI_ISteamGameServerStats_StoreUserStats(
27294 self_: *mut ISteamGameServerStats,
27295 steamIDUser: uint64_steamid,
27296 ) -> SteamAPICall_t;
27297}
27298extern "C" {
27299 pub fn SteamAPI_ISteamNetworkingFakeUDPPort_DestroyFakeUDPPort(
27300 self_: *mut ISteamNetworkingFakeUDPPort,
27301 );
27302}
27303extern "C" {
27304 pub fn SteamAPI_ISteamNetworkingFakeUDPPort_SendMessageToFakeIP(
27305 self_: *mut ISteamNetworkingFakeUDPPort,
27306 remoteAddress: *const SteamNetworkingIPAddr,
27307 pData: *const ::std::os::raw::c_void,
27308 cbData: uint32,
27309 nSendFlags: ::std::os::raw::c_int,
27310 ) -> EResult;
27311}
27312extern "C" {
27313 pub fn SteamAPI_ISteamNetworkingFakeUDPPort_ReceiveMessages(
27314 self_: *mut ISteamNetworkingFakeUDPPort,
27315 ppOutMessages: *mut *mut SteamNetworkingMessage_t,
27316 nMaxMessages: ::std::os::raw::c_int,
27317 ) -> ::std::os::raw::c_int;
27318}
27319extern "C" {
27320 pub fn SteamAPI_ISteamNetworkingFakeUDPPort_ScheduleCleanup(
27321 self_: *mut ISteamNetworkingFakeUDPPort,
27322 remoteAddress: *const SteamNetworkingIPAddr,
27323 );
27324}
27325extern "C" {
27326 pub fn SteamAPI_SteamIPAddress_t_IsSet(self_: *mut SteamIPAddress_t) -> bool;
27327}
27328extern "C" {
27329 pub fn SteamAPI_MatchMakingKeyValuePair_t_Construct(self_: *mut MatchMakingKeyValuePair_t);
27330}
27331extern "C" {
27332 pub fn SteamAPI_servernetadr_t_Construct(self_: *mut servernetadr_t);
27333}
27334extern "C" {
27335 pub fn SteamAPI_servernetadr_t_Init(
27336 self_: *mut servernetadr_t,
27337 ip: ::std::os::raw::c_uint,
27338 usQueryPort: uint16,
27339 usConnectionPort: uint16,
27340 );
27341}
27342extern "C" {
27343 pub fn SteamAPI_servernetadr_t_GetQueryPort(self_: *mut servernetadr_t) -> uint16;
27344}
27345extern "C" {
27346 pub fn SteamAPI_servernetadr_t_SetQueryPort(self_: *mut servernetadr_t, usPort: uint16);
27347}
27348extern "C" {
27349 pub fn SteamAPI_servernetadr_t_GetConnectionPort(self_: *mut servernetadr_t) -> uint16;
27350}
27351extern "C" {
27352 pub fn SteamAPI_servernetadr_t_SetConnectionPort(self_: *mut servernetadr_t, usPort: uint16);
27353}
27354extern "C" {
27355 pub fn SteamAPI_servernetadr_t_GetIP(self_: *mut servernetadr_t) -> uint32;
27356}
27357extern "C" {
27358 pub fn SteamAPI_servernetadr_t_SetIP(self_: *mut servernetadr_t, unIP: uint32);
27359}
27360extern "C" {
27361 pub fn SteamAPI_servernetadr_t_GetConnectionAddressString(
27362 self_: *mut servernetadr_t,
27363 ) -> *const ::std::os::raw::c_char;
27364}
27365extern "C" {
27366 pub fn SteamAPI_servernetadr_t_GetQueryAddressString(
27367 self_: *mut servernetadr_t,
27368 ) -> *const ::std::os::raw::c_char;
27369}
27370extern "C" {
27371 pub fn SteamAPI_servernetadr_t_IsLessThan(
27372 self_: *mut servernetadr_t,
27373 netadr: *const servernetadr_t,
27374 ) -> bool;
27375}
27376extern "C" {
27377 pub fn SteamAPI_servernetadr_t_Assign(self_: *mut servernetadr_t, that: *const servernetadr_t);
27378}
27379extern "C" {
27380 pub fn SteamAPI_gameserveritem_t_Construct(self_: *mut gameserveritem_t);
27381}
27382extern "C" {
27383 pub fn SteamAPI_gameserveritem_t_GetName(
27384 self_: *mut gameserveritem_t,
27385 ) -> *const ::std::os::raw::c_char;
27386}
27387extern "C" {
27388 pub fn SteamAPI_gameserveritem_t_SetName(
27389 self_: *mut gameserveritem_t,
27390 pName: *const ::std::os::raw::c_char,
27391 );
27392}
27393extern "C" {
27394 pub fn SteamAPI_SteamNetworkingIPAddr_Clear(self_: *mut SteamNetworkingIPAddr);
27395}
27396extern "C" {
27397 pub fn SteamAPI_SteamNetworkingIPAddr_IsIPv6AllZeros(self_: *mut SteamNetworkingIPAddr)
27398 -> bool;
27399}
27400extern "C" {
27401 pub fn SteamAPI_SteamNetworkingIPAddr_SetIPv6(
27402 self_: *mut SteamNetworkingIPAddr,
27403 ipv6: *const uint8,
27404 nPort: uint16,
27405 );
27406}
27407extern "C" {
27408 pub fn SteamAPI_SteamNetworkingIPAddr_SetIPv4(
27409 self_: *mut SteamNetworkingIPAddr,
27410 nIP: uint32,
27411 nPort: uint16,
27412 );
27413}
27414extern "C" {
27415 pub fn SteamAPI_SteamNetworkingIPAddr_IsIPv4(self_: *mut SteamNetworkingIPAddr) -> bool;
27416}
27417extern "C" {
27418 pub fn SteamAPI_SteamNetworkingIPAddr_GetIPv4(self_: *mut SteamNetworkingIPAddr) -> uint32;
27419}
27420extern "C" {
27421 pub fn SteamAPI_SteamNetworkingIPAddr_SetIPv6LocalHost(
27422 self_: *mut SteamNetworkingIPAddr,
27423 nPort: uint16,
27424 );
27425}
27426extern "C" {
27427 pub fn SteamAPI_SteamNetworkingIPAddr_IsLocalHost(self_: *mut SteamNetworkingIPAddr) -> bool;
27428}
27429extern "C" {
27430 pub fn SteamAPI_SteamNetworkingIPAddr_ToString(
27431 self_: *mut SteamNetworkingIPAddr,
27432 buf: *mut ::std::os::raw::c_char,
27433 cbBuf: uint32,
27434 bWithPort: bool,
27435 );
27436}
27437extern "C" {
27438 pub fn SteamAPI_SteamNetworkingIPAddr_ParseString(
27439 self_: *mut SteamNetworkingIPAddr,
27440 pszStr: *const ::std::os::raw::c_char,
27441 ) -> bool;
27442}
27443extern "C" {
27444 pub fn SteamAPI_SteamNetworkingIPAddr_IsEqualTo(
27445 self_: *mut SteamNetworkingIPAddr,
27446 x: *const SteamNetworkingIPAddr,
27447 ) -> bool;
27448}
27449extern "C" {
27450 pub fn SteamAPI_SteamNetworkingIPAddr_GetFakeIPType(
27451 self_: *mut SteamNetworkingIPAddr,
27452 ) -> ESteamNetworkingFakeIPType;
27453}
27454extern "C" {
27455 pub fn SteamAPI_SteamNetworkingIPAddr_IsFakeIP(self_: *mut SteamNetworkingIPAddr) -> bool;
27456}
27457extern "C" {
27458 pub fn SteamAPI_SteamNetworkingIdentity_Clear(self_: *mut SteamNetworkingIdentity);
27459}
27460extern "C" {
27461 pub fn SteamAPI_SteamNetworkingIdentity_IsInvalid(self_: *mut SteamNetworkingIdentity) -> bool;
27462}
27463extern "C" {
27464 pub fn SteamAPI_SteamNetworkingIdentity_SetSteamID(
27465 self_: *mut SteamNetworkingIdentity,
27466 steamID: uint64_steamid,
27467 );
27468}
27469extern "C" {
27470 pub fn SteamAPI_SteamNetworkingIdentity_GetSteamID(
27471 self_: *mut SteamNetworkingIdentity,
27472 ) -> uint64_steamid;
27473}
27474extern "C" {
27475 pub fn SteamAPI_SteamNetworkingIdentity_SetSteamID64(
27476 self_: *mut SteamNetworkingIdentity,
27477 steamID: uint64,
27478 );
27479}
27480extern "C" {
27481 pub fn SteamAPI_SteamNetworkingIdentity_GetSteamID64(
27482 self_: *mut SteamNetworkingIdentity,
27483 ) -> uint64;
27484}
27485extern "C" {
27486 pub fn SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID(
27487 self_: *mut SteamNetworkingIdentity,
27488 pszString: *const ::std::os::raw::c_char,
27489 ) -> bool;
27490}
27491extern "C" {
27492 pub fn SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID(
27493 self_: *mut SteamNetworkingIdentity,
27494 ) -> *const ::std::os::raw::c_char;
27495}
27496extern "C" {
27497 pub fn SteamAPI_SteamNetworkingIdentity_SetPSNID(
27498 self_: *mut SteamNetworkingIdentity,
27499 id: uint64,
27500 );
27501}
27502extern "C" {
27503 pub fn SteamAPI_SteamNetworkingIdentity_GetPSNID(self_: *mut SteamNetworkingIdentity)
27504 -> uint64;
27505}
27506extern "C" {
27507 pub fn SteamAPI_SteamNetworkingIdentity_SetIPAddr(
27508 self_: *mut SteamNetworkingIdentity,
27509 addr: *const SteamNetworkingIPAddr,
27510 );
27511}
27512extern "C" {
27513 pub fn SteamAPI_SteamNetworkingIdentity_GetIPAddr(
27514 self_: *mut SteamNetworkingIdentity,
27515 ) -> *const SteamNetworkingIPAddr;
27516}
27517extern "C" {
27518 pub fn SteamAPI_SteamNetworkingIdentity_SetIPv4Addr(
27519 self_: *mut SteamNetworkingIdentity,
27520 nIPv4: uint32,
27521 nPort: uint16,
27522 );
27523}
27524extern "C" {
27525 pub fn SteamAPI_SteamNetworkingIdentity_GetIPv4(self_: *mut SteamNetworkingIdentity) -> uint32;
27526}
27527extern "C" {
27528 pub fn SteamAPI_SteamNetworkingIdentity_GetFakeIPType(
27529 self_: *mut SteamNetworkingIdentity,
27530 ) -> ESteamNetworkingFakeIPType;
27531}
27532extern "C" {
27533 pub fn SteamAPI_SteamNetworkingIdentity_IsFakeIP(self_: *mut SteamNetworkingIdentity) -> bool;
27534}
27535extern "C" {
27536 pub fn SteamAPI_SteamNetworkingIdentity_SetLocalHost(self_: *mut SteamNetworkingIdentity);
27537}
27538extern "C" {
27539 pub fn SteamAPI_SteamNetworkingIdentity_IsLocalHost(
27540 self_: *mut SteamNetworkingIdentity,
27541 ) -> bool;
27542}
27543extern "C" {
27544 pub fn SteamAPI_SteamNetworkingIdentity_SetGenericString(
27545 self_: *mut SteamNetworkingIdentity,
27546 pszString: *const ::std::os::raw::c_char,
27547 ) -> bool;
27548}
27549extern "C" {
27550 pub fn SteamAPI_SteamNetworkingIdentity_GetGenericString(
27551 self_: *mut SteamNetworkingIdentity,
27552 ) -> *const ::std::os::raw::c_char;
27553}
27554extern "C" {
27555 pub fn SteamAPI_SteamNetworkingIdentity_SetGenericBytes(
27556 self_: *mut SteamNetworkingIdentity,
27557 data: *const ::std::os::raw::c_void,
27558 cbLen: uint32,
27559 ) -> bool;
27560}
27561extern "C" {
27562 pub fn SteamAPI_SteamNetworkingIdentity_GetGenericBytes(
27563 self_: *mut SteamNetworkingIdentity,
27564 cbLen: *mut ::std::os::raw::c_int,
27565 ) -> *const uint8;
27566}
27567extern "C" {
27568 pub fn SteamAPI_SteamNetworkingIdentity_IsEqualTo(
27569 self_: *mut SteamNetworkingIdentity,
27570 x: *const SteamNetworkingIdentity,
27571 ) -> bool;
27572}
27573extern "C" {
27574 pub fn SteamAPI_SteamNetworkingIdentity_ToString(
27575 self_: *mut SteamNetworkingIdentity,
27576 buf: *mut ::std::os::raw::c_char,
27577 cbBuf: uint32,
27578 );
27579}
27580extern "C" {
27581 pub fn SteamAPI_SteamNetworkingIdentity_ParseString(
27582 self_: *mut SteamNetworkingIdentity,
27583 pszStr: *const ::std::os::raw::c_char,
27584 ) -> bool;
27585}
27586extern "C" {
27587 pub fn SteamAPI_SteamNetworkingMessage_t_Release(self_: *mut SteamNetworkingMessage_t);
27588}
27589extern "C" {
27590 pub fn SteamAPI_SteamNetworkingConfigValue_t_SetInt32(
27591 self_: *mut SteamNetworkingConfigValue_t,
27592 eVal: ESteamNetworkingConfigValue,
27593 data: i32,
27594 );
27595}
27596extern "C" {
27597 pub fn SteamAPI_SteamNetworkingConfigValue_t_SetInt64(
27598 self_: *mut SteamNetworkingConfigValue_t,
27599 eVal: ESteamNetworkingConfigValue,
27600 data: i64,
27601 );
27602}
27603extern "C" {
27604 pub fn SteamAPI_SteamNetworkingConfigValue_t_SetFloat(
27605 self_: *mut SteamNetworkingConfigValue_t,
27606 eVal: ESteamNetworkingConfigValue,
27607 data: f32,
27608 );
27609}
27610extern "C" {
27611 pub fn SteamAPI_SteamNetworkingConfigValue_t_SetPtr(
27612 self_: *mut SteamNetworkingConfigValue_t,
27613 eVal: ESteamNetworkingConfigValue,
27614 data: *mut ::std::os::raw::c_void,
27615 );
27616}
27617extern "C" {
27618 pub fn SteamAPI_SteamNetworkingConfigValue_t_SetString(
27619 self_: *mut SteamNetworkingConfigValue_t,
27620 eVal: ESteamNetworkingConfigValue,
27621 data: *const ::std::os::raw::c_char,
27622 );
27623}
27624extern "C" {
27625 pub fn SteamAPI_SteamDatagramHostedAddress_Clear(self_: *mut SteamDatagramHostedAddress);
27626}
27627extern "C" {
27628 pub fn SteamAPI_SteamDatagramHostedAddress_GetPopID(
27629 self_: *mut SteamDatagramHostedAddress,
27630 ) -> SteamNetworkingPOPID;
27631}
27632extern "C" {
27633 pub fn SteamAPI_SteamDatagramHostedAddress_SetDevAddress(
27634 self_: *mut SteamDatagramHostedAddress,
27635 nIP: uint32,
27636 nPort: uint16,
27637 popid: SteamNetworkingPOPID,
27638 );
27639}
27640#[repr(u32)]
27641#[non_exhaustive]
27642#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
27643pub enum EServerMode {
27644 eServerModeInvalid = 0,
27645 eServerModeNoAuthentication = 1,
27646 eServerModeAuthentication = 2,
27647 eServerModeAuthenticationAndSecure = 3,
27648}
27649#[doc = " Pass to SteamGameServer_Init to indicate that the same UDP port will be used for game traffic\n UDP queries for server browser pings and LAN discovery. In this case, Steam will not open up a\n socket to handle server browser queries, and you must use ISteamGameServer::HandleIncomingPacket\n and ISteamGameServer::GetNextOutgoingPacket to handle packets related to server discovery on your socket."]
27650pub const STEAMGAMESERVER_QUERY_PORT_SHARED: uint16 = 65535;
27651pub const MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE: uint16 = 65535;
27652extern "C" {
27653 pub fn SteamGameServer_Shutdown();
27654}
27655extern "C" {
27656 pub fn SteamGameServer_BSecure() -> bool;
27657}
27658extern "C" {
27659 pub fn SteamGameServer_GetSteamID() -> uint64;
27660}
27661extern "C" {
27662 pub fn SteamInternal_GameServer_Init_V2(
27663 unIP: uint32,
27664 usGamePort: uint16,
27665 usQueryPort: uint16,
27666 eServerMode: EServerMode,
27667 pchVersionString: *const ::std::os::raw::c_char,
27668 pszInternalCheckInterfaceVersions: *const ::std::os::raw::c_char,
27669 pOutErrMsg: *mut SteamErrMsg,
27670 ) -> ESteamAPIInitResult;
27671}
27672#[repr(C)]
27673#[derive(Debug, Copy, Clone)]
27674pub struct __locale_data {
27675 pub _address: u8,
27676}
27677pub type __builtin_va_list = [__va_list_tag; 1usize];
27678#[repr(C)]
27679#[derive(Debug, Copy, Clone)]
27680pub struct __va_list_tag {
27681 pub gp_offset: ::std::os::raw::c_uint,
27682 pub fp_offset: ::std::os::raw::c_uint,
27683 pub overflow_arg_area: *mut ::std::os::raw::c_void,
27684 pub reg_save_area: *mut ::std::os::raw::c_void,
27685}
27686#[test]
27687fn bindgen_test_layout___va_list_tag() {
27688 const UNINIT: ::std::mem::MaybeUninit<__va_list_tag> = ::std::mem::MaybeUninit::uninit();
27689 let ptr = UNINIT.as_ptr();
27690 assert_eq!(
27691 ::std::mem::size_of::<__va_list_tag>(),
27692 24usize,
27693 concat!("Size of: ", stringify!(__va_list_tag))
27694 );
27695 assert_eq!(
27696 ::std::mem::align_of::<__va_list_tag>(),
27697 8usize,
27698 concat!("Alignment of ", stringify!(__va_list_tag))
27699 );
27700 assert_eq!(
27701 unsafe { ::std::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
27702 0usize,
27703 concat!(
27704 "Offset of field: ",
27705 stringify!(__va_list_tag),
27706 "::",
27707 stringify!(gp_offset)
27708 )
27709 );
27710 assert_eq!(
27711 unsafe { ::std::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
27712 4usize,
27713 concat!(
27714 "Offset of field: ",
27715 stringify!(__va_list_tag),
27716 "::",
27717 stringify!(fp_offset)
27718 )
27719 );
27720 assert_eq!(
27721 unsafe { ::std::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
27722 8usize,
27723 concat!(
27724 "Offset of field: ",
27725 stringify!(__va_list_tag),
27726 "::",
27727 stringify!(overflow_arg_area)
27728 )
27729 );
27730 assert_eq!(
27731 unsafe { ::std::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
27732 16usize,
27733 concat!(
27734 "Offset of field: ",
27735 stringify!(__va_list_tag),
27736 "::",
27737 stringify!(reg_save_area)
27738 )
27739 );
27740}