1 #![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
2 pub const ALL_SERVICES: u32 = 0u32;
3 pub const ALL_SERVICE_TYPES: u32 = 0u32;
4 pub const C1_ALPHA: u32 = 256u32;
5 pub const C1_BLANK: u32 = 64u32;
6 pub const C1_CNTRL: u32 = 32u32;
7 pub const C1_DEFINED: u32 = 512u32;
8 pub const C1_DIGIT: u32 = 4u32;
9 pub const C1_LOWER: u32 = 2u32;
10 pub const C1_PUNCT: u32 = 16u32;
11 pub const C1_SPACE: u32 = 8u32;
12 pub const C1_UPPER: u32 = 1u32;
13 pub const C1_XDIGIT: u32 = 128u32;
14 pub const C2_ARABICNUMBER: u32 = 6u32;
15 pub const C2_BLOCKSEPARATOR: u32 = 8u32;
16 pub const C2_COMMONSEPARATOR: u32 = 7u32;
17 pub const C2_EUROPENUMBER: u32 = 3u32;
18 pub const C2_EUROPESEPARATOR: u32 = 4u32;
19 pub const C2_EUROPETERMINATOR: u32 = 5u32;
20 pub const C2_LEFTTORIGHT: u32 = 1u32;
21 pub const C2_NOTAPPLICABLE: u32 = 0u32;
22 pub const C2_OTHERNEUTRAL: u32 = 11u32;
23 pub const C2_RIGHTTOLEFT: u32 = 2u32;
24 pub const C2_SEGMENTSEPARATOR: u32 = 9u32;
25 pub const C2_WHITESPACE: u32 = 10u32;
26 pub const C3_ALPHA: u32 = 32768u32;
27 pub const C3_DIACRITIC: u32 = 2u32;
28 pub const C3_FULLWIDTH: u32 = 128u32;
29 pub const C3_HALFWIDTH: u32 = 64u32;
30 pub const C3_HIGHSURROGATE: u32 = 2048u32;
31 pub const C3_HIRAGANA: u32 = 32u32;
32 pub const C3_IDEOGRAPH: u32 = 256u32;
33 pub const C3_KASHIDA: u32 = 512u32;
34 pub const C3_KATAKANA: u32 = 16u32;
35 pub const C3_LEXICAL: u32 = 1024u32;
36 pub const C3_LOWSURROGATE: u32 = 4096u32;
37 pub const C3_NONSPACING: u32 = 1u32;
38 pub const C3_NOTAPPLICABLE: u32 = 0u32;
39 pub const C3_SYMBOL: u32 = 8u32;
40 pub const C3_VOWELMARK: u32 = 4u32;
41 #[cfg(feature = "Win32_Foundation")]
42 pub type CALINFO_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR) -> super::Foundation::BOOL;
43 #[cfg(feature = "Win32_Foundation")]
44 pub type CALINFO_ENUMPROCEXA = unsafe extern "system" fn(param0: super::Foundation::PSTR, param1: u32) -> super::Foundation::BOOL;
45 #[cfg(feature = "Win32_Foundation")]
46 pub type CALINFO_ENUMPROCEXEX = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: u32, param2: super::Foundation::PWSTR, param3: super::Foundation::LPARAM) -> super::Foundation::BOOL;
47 #[cfg(feature = "Win32_Foundation")]
48 pub type CALINFO_ENUMPROCEXW = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: u32) -> super::Foundation::BOOL;
49 #[cfg(feature = "Win32_Foundation")]
50 pub type CALINFO_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR) -> super::Foundation::BOOL;
51 pub const CAL_GREGORIAN: u32 = 1u32;
52 pub const CAL_GREGORIAN_ARABIC: u32 = 10u32;
53 pub const CAL_GREGORIAN_ME_FRENCH: u32 = 9u32;
54 pub const CAL_GREGORIAN_US: u32 = 2u32;
55 pub const CAL_GREGORIAN_XLIT_ENGLISH: u32 = 11u32;
56 pub const CAL_GREGORIAN_XLIT_FRENCH: u32 = 12u32;
57 pub const CAL_HEBREW: u32 = 8u32;
58 pub const CAL_HIJRI: u32 = 6u32;
59 pub const CAL_ICALINTVALUE: u32 = 1u32;
60 pub const CAL_ITWODIGITYEARMAX: u32 = 48u32;
61 pub const CAL_IYEAROFFSETRANGE: u32 = 3u32;
62 pub const CAL_JAPAN: u32 = 3u32;
63 pub const CAL_KOREA: u32 = 5u32;
64 pub const CAL_NOUSEROVERRIDE: u32 = 2147483648u32;
65 pub const CAL_PERSIAN: u32 = 22u32;
66 pub const CAL_RETURN_GENITIVE_NAMES: u32 = 268435456u32;
67 pub const CAL_RETURN_NUMBER: u32 = 536870912u32;
68 pub const CAL_SABBREVDAYNAME1: u32 = 14u32;
69 pub const CAL_SABBREVDAYNAME2: u32 = 15u32;
70 pub const CAL_SABBREVDAYNAME3: u32 = 16u32;
71 pub const CAL_SABBREVDAYNAME4: u32 = 17u32;
72 pub const CAL_SABBREVDAYNAME5: u32 = 18u32;
73 pub const CAL_SABBREVDAYNAME6: u32 = 19u32;
74 pub const CAL_SABBREVDAYNAME7: u32 = 20u32;
75 pub const CAL_SABBREVERASTRING: u32 = 57u32;
76 pub const CAL_SABBREVMONTHNAME1: u32 = 34u32;
77 pub const CAL_SABBREVMONTHNAME10: u32 = 43u32;
78 pub const CAL_SABBREVMONTHNAME11: u32 = 44u32;
79 pub const CAL_SABBREVMONTHNAME12: u32 = 45u32;
80 pub const CAL_SABBREVMONTHNAME13: u32 = 46u32;
81 pub const CAL_SABBREVMONTHNAME2: u32 = 35u32;
82 pub const CAL_SABBREVMONTHNAME3: u32 = 36u32;
83 pub const CAL_SABBREVMONTHNAME4: u32 = 37u32;
84 pub const CAL_SABBREVMONTHNAME5: u32 = 38u32;
85 pub const CAL_SABBREVMONTHNAME6: u32 = 39u32;
86 pub const CAL_SABBREVMONTHNAME7: u32 = 40u32;
87 pub const CAL_SABBREVMONTHNAME8: u32 = 41u32;
88 pub const CAL_SABBREVMONTHNAME9: u32 = 42u32;
89 pub const CAL_SCALNAME: u32 = 2u32;
90 pub const CAL_SDAYNAME1: u32 = 7u32;
91 pub const CAL_SDAYNAME2: u32 = 8u32;
92 pub const CAL_SDAYNAME3: u32 = 9u32;
93 pub const CAL_SDAYNAME4: u32 = 10u32;
94 pub const CAL_SDAYNAME5: u32 = 11u32;
95 pub const CAL_SDAYNAME6: u32 = 12u32;
96 pub const CAL_SDAYNAME7: u32 = 13u32;
97 pub const CAL_SENGLISHABBREVERANAME: u32 = 60u32;
98 pub const CAL_SENGLISHERANAME: u32 = 59u32;
99 pub const CAL_SERASTRING: u32 = 4u32;
100 pub const CAL_SJAPANESEERAFIRSTYEAR: u32 = 61u32;
101 pub const CAL_SLONGDATE: u32 = 6u32;
102 pub const CAL_SMONTHDAY: u32 = 56u32;
103 pub const CAL_SMONTHNAME1: u32 = 21u32;
104 pub const CAL_SMONTHNAME10: u32 = 30u32;
105 pub const CAL_SMONTHNAME11: u32 = 31u32;
106 pub const CAL_SMONTHNAME12: u32 = 32u32;
107 pub const CAL_SMONTHNAME13: u32 = 33u32;
108 pub const CAL_SMONTHNAME2: u32 = 22u32;
109 pub const CAL_SMONTHNAME3: u32 = 23u32;
110 pub const CAL_SMONTHNAME4: u32 = 24u32;
111 pub const CAL_SMONTHNAME5: u32 = 25u32;
112 pub const CAL_SMONTHNAME6: u32 = 26u32;
113 pub const CAL_SMONTHNAME7: u32 = 27u32;
114 pub const CAL_SMONTHNAME8: u32 = 28u32;
115 pub const CAL_SMONTHNAME9: u32 = 29u32;
116 pub const CAL_SRELATIVELONGDATE: u32 = 58u32;
117 pub const CAL_SSHORTDATE: u32 = 5u32;
118 pub const CAL_SSHORTESTDAYNAME1: u32 = 49u32;
119 pub const CAL_SSHORTESTDAYNAME2: u32 = 50u32;
120 pub const CAL_SSHORTESTDAYNAME3: u32 = 51u32;
121 pub const CAL_SSHORTESTDAYNAME4: u32 = 52u32;
122 pub const CAL_SSHORTESTDAYNAME5: u32 = 53u32;
123 pub const CAL_SSHORTESTDAYNAME6: u32 = 54u32;
124 pub const CAL_SSHORTESTDAYNAME7: u32 = 55u32;
125 pub const CAL_SYEARMONTH: u32 = 47u32;
126 pub const CAL_TAIWAN: u32 = 4u32;
127 pub const CAL_THAI: u32 = 7u32;
128 pub const CAL_UMALQURA: u32 = 23u32;
129 pub const CAL_USE_CP_ACP: u32 = 1073741824u32;
130 pub const CANITER_SKIP_ZEROES: u32 = 1u32;
131 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
132 #[repr(C)]
133 pub struct CHARSETINFO {
134     pub ciCharset: u32,
135     pub ciACP: u32,
136     pub fs: FONTSIGNATURE,
137 }
138 impl CHARSETINFO {}
139 impl ::std::default::Default for CHARSETINFO {
default() -> Self140     fn default() -> Self {
141         unsafe { ::std::mem::zeroed() }
142     }
143 }
144 impl ::std::fmt::Debug for CHARSETINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result145     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
146         fmt.debug_struct("CHARSETINFO").field("ciCharset", &self.ciCharset).field("ciACP", &self.ciACP).field("fs", &self.fs).finish()
147     }
148 }
149 impl ::std::cmp::PartialEq for CHARSETINFO {
eq(&self, other: &Self) -> bool150     fn eq(&self, other: &Self) -> bool {
151         self.ciCharset == other.ciCharset && self.ciACP == other.ciACP && self.fs == other.fs
152     }
153 }
154 impl ::std::cmp::Eq for CHARSETINFO {}
155 unsafe impl ::windows::runtime::Abi for CHARSETINFO {
156     type Abi = Self;
157     type DefaultType = Self;
158 }
159 pub const CMLangConvertCharset: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3597496217, 52650, 4560, [184, 34, 0, 192, 79, 201, 179, 31]);
160 pub const CMLangString: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3226297807, 46861, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
161 pub const CMultiLanguage: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(660349922, 14151, 4560, [159, 234, 0, 170, 0, 63, 134, 70]);
162 #[cfg(feature = "Win32_Foundation")]
163 pub type CODEPAGE_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR) -> super::Foundation::BOOL;
164 #[cfg(feature = "Win32_Foundation")]
165 pub type CODEPAGE_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR) -> super::Foundation::BOOL;
166 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
167 #[repr(transparent)]
168 pub struct COMPARE_STRING_FLAGS(pub u32);
169 pub const LINGUISTIC_IGNORECASE: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(16u32);
170 pub const LINGUISTIC_IGNOREDIACRITIC: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(32u32);
171 pub const NORM_IGNORECASE: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(1u32);
172 pub const NORM_IGNOREKANATYPE: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(65536u32);
173 pub const NORM_IGNORENONSPACE: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(2u32);
174 pub const NORM_IGNORESYMBOLS: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(4u32);
175 pub const NORM_IGNOREWIDTH: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(131072u32);
176 pub const NORM_LINGUISTIC_CASING: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(134217728u32);
177 pub const SORT_DIGITSASNUMBERS: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(8u32);
178 pub const SORT_STRINGSORT: COMPARE_STRING_FLAGS = COMPARE_STRING_FLAGS(4096u32);
179 impl ::std::convert::From<u32> for COMPARE_STRING_FLAGS {
from(value: u32) -> Self180     fn from(value: u32) -> Self {
181         Self(value)
182     }
183 }
184 unsafe impl ::windows::runtime::Abi for COMPARE_STRING_FLAGS {
185     type Abi = Self;
186     type DefaultType = Self;
187 }
188 impl ::std::ops::BitOr for COMPARE_STRING_FLAGS {
189     type Output = Self;
bitor(self, rhs: Self) -> Self190     fn bitor(self, rhs: Self) -> Self {
191         Self(self.0 | rhs.0)
192     }
193 }
194 impl ::std::ops::BitAnd for COMPARE_STRING_FLAGS {
195     type Output = Self;
bitand(self, rhs: Self) -> Self196     fn bitand(self, rhs: Self) -> Self {
197         Self(self.0 & rhs.0)
198     }
199 }
200 impl ::std::ops::BitOrAssign for COMPARE_STRING_FLAGS {
bitor_assign(&mut self, rhs: Self)201     fn bitor_assign(&mut self, rhs: Self) {
202         self.0.bitor_assign(rhs.0)
203     }
204 }
205 impl ::std::ops::BitAndAssign for COMPARE_STRING_FLAGS {
bitand_assign(&mut self, rhs: Self)206     fn bitand_assign(&mut self, rhs: Self) {
207         self.0.bitand_assign(rhs.0)
208     }
209 }
210 impl ::std::ops::Not for COMPARE_STRING_FLAGS {
211     type Output = Self;
not(self) -> Self212     fn not(self) -> Self {
213         Self(self.0.not())
214     }
215 }
216 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
217 #[repr(transparent)]
218 pub struct CORRECTIVE_ACTION(pub i32);
219 pub const CORRECTIVE_ACTION_NONE: CORRECTIVE_ACTION = CORRECTIVE_ACTION(0i32);
220 pub const CORRECTIVE_ACTION_GET_SUGGESTIONS: CORRECTIVE_ACTION = CORRECTIVE_ACTION(1i32);
221 pub const CORRECTIVE_ACTION_REPLACE: CORRECTIVE_ACTION = CORRECTIVE_ACTION(2i32);
222 pub const CORRECTIVE_ACTION_DELETE: CORRECTIVE_ACTION = CORRECTIVE_ACTION(3i32);
223 impl ::std::convert::From<i32> for CORRECTIVE_ACTION {
from(value: i32) -> Self224     fn from(value: i32) -> Self {
225         Self(value)
226     }
227 }
228 unsafe impl ::windows::runtime::Abi for CORRECTIVE_ACTION {
229     type Abi = Self;
230     type DefaultType = Self;
231 }
232 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
233 #[repr(C)]
234 pub struct CPINFO {
235     pub MaxCharSize: u32,
236     pub DefaultChar: [u8; 2],
237     pub LeadByte: [u8; 12],
238 }
239 impl CPINFO {}
240 impl ::std::default::Default for CPINFO {
default() -> Self241     fn default() -> Self {
242         unsafe { ::std::mem::zeroed() }
243     }
244 }
245 impl ::std::fmt::Debug for CPINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result246     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
247         fmt.debug_struct("CPINFO").field("MaxCharSize", &self.MaxCharSize).field("DefaultChar", &self.DefaultChar).field("LeadByte", &self.LeadByte).finish()
248     }
249 }
250 impl ::std::cmp::PartialEq for CPINFO {
eq(&self, other: &Self) -> bool251     fn eq(&self, other: &Self) -> bool {
252         self.MaxCharSize == other.MaxCharSize && self.DefaultChar == other.DefaultChar && self.LeadByte == other.LeadByte
253     }
254 }
255 impl ::std::cmp::Eq for CPINFO {}
256 unsafe impl ::windows::runtime::Abi for CPINFO {
257     type Abi = Self;
258     type DefaultType = Self;
259 }
260 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
261 #[repr(C)]
262 #[cfg(feature = "Win32_Foundation")]
263 pub struct CPINFOEXA {
264     pub MaxCharSize: u32,
265     pub DefaultChar: [u8; 2],
266     pub LeadByte: [u8; 12],
267     pub UnicodeDefaultChar: u16,
268     pub CodePage: u32,
269     pub CodePageName: [super::Foundation::CHAR; 260],
270 }
271 #[cfg(feature = "Win32_Foundation")]
272 impl CPINFOEXA {}
273 #[cfg(feature = "Win32_Foundation")]
274 impl ::std::default::Default for CPINFOEXA {
default() -> Self275     fn default() -> Self {
276         unsafe { ::std::mem::zeroed() }
277     }
278 }
279 #[cfg(feature = "Win32_Foundation")]
280 impl ::std::fmt::Debug for CPINFOEXA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result281     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
282         fmt.debug_struct("CPINFOEXA").field("MaxCharSize", &self.MaxCharSize).field("DefaultChar", &self.DefaultChar).field("LeadByte", &self.LeadByte).field("UnicodeDefaultChar", &self.UnicodeDefaultChar).field("CodePage", &self.CodePage).field("CodePageName", &self.CodePageName).finish()
283     }
284 }
285 #[cfg(feature = "Win32_Foundation")]
286 impl ::std::cmp::PartialEq for CPINFOEXA {
eq(&self, other: &Self) -> bool287     fn eq(&self, other: &Self) -> bool {
288         self.MaxCharSize == other.MaxCharSize && self.DefaultChar == other.DefaultChar && self.LeadByte == other.LeadByte && self.UnicodeDefaultChar == other.UnicodeDefaultChar && self.CodePage == other.CodePage && self.CodePageName == other.CodePageName
289     }
290 }
291 #[cfg(feature = "Win32_Foundation")]
292 impl ::std::cmp::Eq for CPINFOEXA {}
293 #[cfg(feature = "Win32_Foundation")]
294 unsafe impl ::windows::runtime::Abi for CPINFOEXA {
295     type Abi = Self;
296     type DefaultType = Self;
297 }
298 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
299 #[repr(C)]
300 pub struct CPINFOEXW {
301     pub MaxCharSize: u32,
302     pub DefaultChar: [u8; 2],
303     pub LeadByte: [u8; 12],
304     pub UnicodeDefaultChar: u16,
305     pub CodePage: u32,
306     pub CodePageName: [u16; 260],
307 }
308 impl CPINFOEXW {}
309 impl ::std::default::Default for CPINFOEXW {
default() -> Self310     fn default() -> Self {
311         unsafe { ::std::mem::zeroed() }
312     }
313 }
314 impl ::std::fmt::Debug for CPINFOEXW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result315     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
316         fmt.debug_struct("CPINFOEXW").field("MaxCharSize", &self.MaxCharSize).field("DefaultChar", &self.DefaultChar).field("LeadByte", &self.LeadByte).field("UnicodeDefaultChar", &self.UnicodeDefaultChar).field("CodePage", &self.CodePage).field("CodePageName", &self.CodePageName).finish()
317     }
318 }
319 impl ::std::cmp::PartialEq for CPINFOEXW {
eq(&self, other: &Self) -> bool320     fn eq(&self, other: &Self) -> bool {
321         self.MaxCharSize == other.MaxCharSize && self.DefaultChar == other.DefaultChar && self.LeadByte == other.LeadByte && self.UnicodeDefaultChar == other.UnicodeDefaultChar && self.CodePage == other.CodePage && self.CodePageName == other.CodePageName
322     }
323 }
324 impl ::std::cmp::Eq for CPINFOEXW {}
325 unsafe impl ::windows::runtime::Abi for CPINFOEXW {
326     type Abi = Self;
327     type DefaultType = Self;
328 }
329 pub const CPIOD_FORCE_PROMPT: i32 = -2147483648i32;
330 pub const CPIOD_PEEK: i32 = 1073741824i32;
331 pub const CP_ACP: u32 = 0u32;
332 pub const CP_MACCP: u32 = 2u32;
333 pub const CP_OEMCP: u32 = 1u32;
334 pub const CP_SYMBOL: u32 = 42u32;
335 pub const CP_THREAD_ACP: u32 = 3u32;
336 pub const CP_UTF7: u32 = 65000u32;
337 pub const CP_UTF8: u32 = 65001u32;
338 pub const CSTR_EQUAL: u32 = 2u32;
339 pub const CSTR_GREATER_THAN: u32 = 3u32;
340 pub const CSTR_LESS_THAN: u32 = 1u32;
341 pub const CTRY_ALBANIA: u32 = 355u32;
342 pub const CTRY_ALGERIA: u32 = 213u32;
343 pub const CTRY_ARGENTINA: u32 = 54u32;
344 pub const CTRY_ARMENIA: u32 = 374u32;
345 pub const CTRY_AUSTRALIA: u32 = 61u32;
346 pub const CTRY_AUSTRIA: u32 = 43u32;
347 pub const CTRY_AZERBAIJAN: u32 = 994u32;
348 pub const CTRY_BAHRAIN: u32 = 973u32;
349 pub const CTRY_BELARUS: u32 = 375u32;
350 pub const CTRY_BELGIUM: u32 = 32u32;
351 pub const CTRY_BELIZE: u32 = 501u32;
352 pub const CTRY_BOLIVIA: u32 = 591u32;
353 pub const CTRY_BRAZIL: u32 = 55u32;
354 pub const CTRY_BRUNEI_DARUSSALAM: u32 = 673u32;
355 pub const CTRY_BULGARIA: u32 = 359u32;
356 pub const CTRY_CANADA: u32 = 2u32;
357 pub const CTRY_CARIBBEAN: u32 = 1u32;
358 pub const CTRY_CHILE: u32 = 56u32;
359 pub const CTRY_COLOMBIA: u32 = 57u32;
360 pub const CTRY_COSTA_RICA: u32 = 506u32;
361 pub const CTRY_CROATIA: u32 = 385u32;
362 pub const CTRY_CZECH: u32 = 420u32;
363 pub const CTRY_DEFAULT: u32 = 0u32;
364 pub const CTRY_DENMARK: u32 = 45u32;
365 pub const CTRY_DOMINICAN_REPUBLIC: u32 = 1u32;
366 pub const CTRY_ECUADOR: u32 = 593u32;
367 pub const CTRY_EGYPT: u32 = 20u32;
368 pub const CTRY_EL_SALVADOR: u32 = 503u32;
369 pub const CTRY_ESTONIA: u32 = 372u32;
370 pub const CTRY_FAEROE_ISLANDS: u32 = 298u32;
371 pub const CTRY_FINLAND: u32 = 358u32;
372 pub const CTRY_FRANCE: u32 = 33u32;
373 pub const CTRY_GEORGIA: u32 = 995u32;
374 pub const CTRY_GERMANY: u32 = 49u32;
375 pub const CTRY_GREECE: u32 = 30u32;
376 pub const CTRY_GUATEMALA: u32 = 502u32;
377 pub const CTRY_HONDURAS: u32 = 504u32;
378 pub const CTRY_HONG_KONG: u32 = 852u32;
379 pub const CTRY_HUNGARY: u32 = 36u32;
380 pub const CTRY_ICELAND: u32 = 354u32;
381 pub const CTRY_INDIA: u32 = 91u32;
382 pub const CTRY_INDONESIA: u32 = 62u32;
383 pub const CTRY_IRAN: u32 = 981u32;
384 pub const CTRY_IRAQ: u32 = 964u32;
385 pub const CTRY_IRELAND: u32 = 353u32;
386 pub const CTRY_ISRAEL: u32 = 972u32;
387 pub const CTRY_ITALY: u32 = 39u32;
388 pub const CTRY_JAMAICA: u32 = 1u32;
389 pub const CTRY_JAPAN: u32 = 81u32;
390 pub const CTRY_JORDAN: u32 = 962u32;
391 pub const CTRY_KAZAKSTAN: u32 = 7u32;
392 pub const CTRY_KENYA: u32 = 254u32;
393 pub const CTRY_KUWAIT: u32 = 965u32;
394 pub const CTRY_KYRGYZSTAN: u32 = 996u32;
395 pub const CTRY_LATVIA: u32 = 371u32;
396 pub const CTRY_LEBANON: u32 = 961u32;
397 pub const CTRY_LIBYA: u32 = 218u32;
398 pub const CTRY_LIECHTENSTEIN: u32 = 41u32;
399 pub const CTRY_LITHUANIA: u32 = 370u32;
400 pub const CTRY_LUXEMBOURG: u32 = 352u32;
401 pub const CTRY_MACAU: u32 = 853u32;
402 pub const CTRY_MACEDONIA: u32 = 389u32;
403 pub const CTRY_MALAYSIA: u32 = 60u32;
404 pub const CTRY_MALDIVES: u32 = 960u32;
405 pub const CTRY_MEXICO: u32 = 52u32;
406 pub const CTRY_MONACO: u32 = 33u32;
407 pub const CTRY_MONGOLIA: u32 = 976u32;
408 pub const CTRY_MOROCCO: u32 = 212u32;
409 pub const CTRY_NETHERLANDS: u32 = 31u32;
410 pub const CTRY_NEW_ZEALAND: u32 = 64u32;
411 pub const CTRY_NICARAGUA: u32 = 505u32;
412 pub const CTRY_NORWAY: u32 = 47u32;
413 pub const CTRY_OMAN: u32 = 968u32;
414 pub const CTRY_PAKISTAN: u32 = 92u32;
415 pub const CTRY_PANAMA: u32 = 507u32;
416 pub const CTRY_PARAGUAY: u32 = 595u32;
417 pub const CTRY_PERU: u32 = 51u32;
418 pub const CTRY_PHILIPPINES: u32 = 63u32;
419 pub const CTRY_POLAND: u32 = 48u32;
420 pub const CTRY_PORTUGAL: u32 = 351u32;
421 pub const CTRY_PRCHINA: u32 = 86u32;
422 pub const CTRY_PUERTO_RICO: u32 = 1u32;
423 pub const CTRY_QATAR: u32 = 974u32;
424 pub const CTRY_ROMANIA: u32 = 40u32;
425 pub const CTRY_RUSSIA: u32 = 7u32;
426 pub const CTRY_SAUDI_ARABIA: u32 = 966u32;
427 pub const CTRY_SERBIA: u32 = 381u32;
428 pub const CTRY_SINGAPORE: u32 = 65u32;
429 pub const CTRY_SLOVAK: u32 = 421u32;
430 pub const CTRY_SLOVENIA: u32 = 386u32;
431 pub const CTRY_SOUTH_AFRICA: u32 = 27u32;
432 pub const CTRY_SOUTH_KOREA: u32 = 82u32;
433 pub const CTRY_SPAIN: u32 = 34u32;
434 pub const CTRY_SWEDEN: u32 = 46u32;
435 pub const CTRY_SWITZERLAND: u32 = 41u32;
436 pub const CTRY_SYRIA: u32 = 963u32;
437 pub const CTRY_TAIWAN: u32 = 886u32;
438 pub const CTRY_TATARSTAN: u32 = 7u32;
439 pub const CTRY_THAILAND: u32 = 66u32;
440 pub const CTRY_TRINIDAD_Y_TOBAGO: u32 = 1u32;
441 pub const CTRY_TUNISIA: u32 = 216u32;
442 pub const CTRY_TURKEY: u32 = 90u32;
443 pub const CTRY_UAE: u32 = 971u32;
444 pub const CTRY_UKRAINE: u32 = 380u32;
445 pub const CTRY_UNITED_KINGDOM: u32 = 44u32;
446 pub const CTRY_UNITED_STATES: u32 = 1u32;
447 pub const CTRY_URUGUAY: u32 = 598u32;
448 pub const CTRY_UZBEKISTAN: u32 = 7u32;
449 pub const CTRY_VENEZUELA: u32 = 58u32;
450 pub const CTRY_VIET_NAM: u32 = 84u32;
451 pub const CTRY_YEMEN: u32 = 967u32;
452 pub const CTRY_ZIMBABWE: u32 = 263u32;
453 pub const CT_CTYPE1: u32 = 1u32;
454 pub const CT_CTYPE2: u32 = 2u32;
455 pub const CT_CTYPE3: u32 = 4u32;
456 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
457 #[repr(C)]
458 #[cfg(feature = "Win32_Foundation")]
459 pub struct CURRENCYFMTA {
460     pub NumDigits: u32,
461     pub LeadingZero: u32,
462     pub Grouping: u32,
463     pub lpDecimalSep: super::Foundation::PSTR,
464     pub lpThousandSep: super::Foundation::PSTR,
465     pub NegativeOrder: u32,
466     pub PositiveOrder: u32,
467     pub lpCurrencySymbol: super::Foundation::PSTR,
468 }
469 #[cfg(feature = "Win32_Foundation")]
470 impl CURRENCYFMTA {}
471 #[cfg(feature = "Win32_Foundation")]
472 impl ::std::default::Default for CURRENCYFMTA {
default() -> Self473     fn default() -> Self {
474         unsafe { ::std::mem::zeroed() }
475     }
476 }
477 #[cfg(feature = "Win32_Foundation")]
478 impl ::std::fmt::Debug for CURRENCYFMTA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result479     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
480         fmt.debug_struct("CURRENCYFMTA")
481             .field("NumDigits", &self.NumDigits)
482             .field("LeadingZero", &self.LeadingZero)
483             .field("Grouping", &self.Grouping)
484             .field("lpDecimalSep", &self.lpDecimalSep)
485             .field("lpThousandSep", &self.lpThousandSep)
486             .field("NegativeOrder", &self.NegativeOrder)
487             .field("PositiveOrder", &self.PositiveOrder)
488             .field("lpCurrencySymbol", &self.lpCurrencySymbol)
489             .finish()
490     }
491 }
492 #[cfg(feature = "Win32_Foundation")]
493 impl ::std::cmp::PartialEq for CURRENCYFMTA {
eq(&self, other: &Self) -> bool494     fn eq(&self, other: &Self) -> bool {
495         self.NumDigits == other.NumDigits && self.LeadingZero == other.LeadingZero && self.Grouping == other.Grouping && self.lpDecimalSep == other.lpDecimalSep && self.lpThousandSep == other.lpThousandSep && self.NegativeOrder == other.NegativeOrder && self.PositiveOrder == other.PositiveOrder && self.lpCurrencySymbol == other.lpCurrencySymbol
496     }
497 }
498 #[cfg(feature = "Win32_Foundation")]
499 impl ::std::cmp::Eq for CURRENCYFMTA {}
500 #[cfg(feature = "Win32_Foundation")]
501 unsafe impl ::windows::runtime::Abi for CURRENCYFMTA {
502     type Abi = Self;
503     type DefaultType = Self;
504 }
505 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
506 #[repr(C)]
507 #[cfg(feature = "Win32_Foundation")]
508 pub struct CURRENCYFMTW {
509     pub NumDigits: u32,
510     pub LeadingZero: u32,
511     pub Grouping: u32,
512     pub lpDecimalSep: super::Foundation::PWSTR,
513     pub lpThousandSep: super::Foundation::PWSTR,
514     pub NegativeOrder: u32,
515     pub PositiveOrder: u32,
516     pub lpCurrencySymbol: super::Foundation::PWSTR,
517 }
518 #[cfg(feature = "Win32_Foundation")]
519 impl CURRENCYFMTW {}
520 #[cfg(feature = "Win32_Foundation")]
521 impl ::std::default::Default for CURRENCYFMTW {
default() -> Self522     fn default() -> Self {
523         unsafe { ::std::mem::zeroed() }
524     }
525 }
526 #[cfg(feature = "Win32_Foundation")]
527 impl ::std::fmt::Debug for CURRENCYFMTW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result528     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
529         fmt.debug_struct("CURRENCYFMTW")
530             .field("NumDigits", &self.NumDigits)
531             .field("LeadingZero", &self.LeadingZero)
532             .field("Grouping", &self.Grouping)
533             .field("lpDecimalSep", &self.lpDecimalSep)
534             .field("lpThousandSep", &self.lpThousandSep)
535             .field("NegativeOrder", &self.NegativeOrder)
536             .field("PositiveOrder", &self.PositiveOrder)
537             .field("lpCurrencySymbol", &self.lpCurrencySymbol)
538             .finish()
539     }
540 }
541 #[cfg(feature = "Win32_Foundation")]
542 impl ::std::cmp::PartialEq for CURRENCYFMTW {
eq(&self, other: &Self) -> bool543     fn eq(&self, other: &Self) -> bool {
544         self.NumDigits == other.NumDigits && self.LeadingZero == other.LeadingZero && self.Grouping == other.Grouping && self.lpDecimalSep == other.lpDecimalSep && self.lpThousandSep == other.lpThousandSep && self.NegativeOrder == other.NegativeOrder && self.PositiveOrder == other.PositiveOrder && self.lpCurrencySymbol == other.lpCurrencySymbol
545     }
546 }
547 #[cfg(feature = "Win32_Foundation")]
548 impl ::std::cmp::Eq for CURRENCYFMTW {}
549 #[cfg(feature = "Win32_Foundation")]
550 unsafe impl ::windows::runtime::Abi for CURRENCYFMTW {
551     type Abi = Self;
552     type DefaultType = Self;
553 }
554 #[inline]
CompareStringA(locale: u32, dwcmpflags: u32, lpstring1: *const i8, cchcount1: i32, lpstring2: *const i8, cchcount2: i32) -> i32555 pub unsafe fn CompareStringA(locale: u32, dwcmpflags: u32, lpstring1: *const i8, cchcount1: i32, lpstring2: *const i8, cchcount2: i32) -> i32 {
556     #[cfg(windows)]
557     {
558         #[link(name = "windows")]
559         extern "system" {
560             fn CompareStringA(locale: u32, dwcmpflags: u32, lpstring1: *const i8, cchcount1: i32, lpstring2: *const i8, cchcount2: i32) -> i32;
561         }
562         ::std::mem::transmute(CompareStringA(::std::mem::transmute(locale), ::std::mem::transmute(dwcmpflags), ::std::mem::transmute(lpstring1), ::std::mem::transmute(cchcount1), ::std::mem::transmute(lpstring2), ::std::mem::transmute(cchcount2)))
563     }
564     #[cfg(not(windows))]
565     unimplemented!("Unsupported target OS");
566 }
567 #[cfg(feature = "Win32_Foundation")]
568 #[inline]
CompareStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>( lplocalename: Param0, dwcmpflags: COMPARE_STRING_FLAGS, lpstring1: Param2, cchcount1: i32, lpstring2: Param4, cchcount2: i32, lpversioninformation: *mut NLSVERSIONINFO, lpreserved: *mut ::std::ffi::c_void, lparam: Param8, ) -> i32569 pub unsafe fn CompareStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(
570     lplocalename: Param0,
571     dwcmpflags: COMPARE_STRING_FLAGS,
572     lpstring1: Param2,
573     cchcount1: i32,
574     lpstring2: Param4,
575     cchcount2: i32,
576     lpversioninformation: *mut NLSVERSIONINFO,
577     lpreserved: *mut ::std::ffi::c_void,
578     lparam: Param8,
579 ) -> i32 {
580     #[cfg(windows)]
581     {
582         #[link(name = "windows")]
583         extern "system" {
584             fn CompareStringEx(lplocalename: super::Foundation::PWSTR, dwcmpflags: COMPARE_STRING_FLAGS, lpstring1: super::Foundation::PWSTR, cchcount1: i32, lpstring2: super::Foundation::PWSTR, cchcount2: i32, lpversioninformation: *mut NLSVERSIONINFO, lpreserved: *mut ::std::ffi::c_void, lparam: super::Foundation::LPARAM) -> i32;
585         }
586         ::std::mem::transmute(CompareStringEx(
587             lplocalename.into_param().abi(),
588             ::std::mem::transmute(dwcmpflags),
589             lpstring1.into_param().abi(),
590             ::std::mem::transmute(cchcount1),
591             lpstring2.into_param().abi(),
592             ::std::mem::transmute(cchcount2),
593             ::std::mem::transmute(lpversioninformation),
594             ::std::mem::transmute(lpreserved),
595             lparam.into_param().abi(),
596         ))
597     }
598     #[cfg(not(windows))]
599     unimplemented!("Unsupported target OS");
600 }
601 #[cfg(feature = "Win32_Foundation")]
602 #[inline]
CompareStringOrdinal<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(lpstring1: Param0, cchcount1: i32, lpstring2: Param2, cchcount2: i32, bignorecase: Param4) -> i32603 pub unsafe fn CompareStringOrdinal<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(lpstring1: Param0, cchcount1: i32, lpstring2: Param2, cchcount2: i32, bignorecase: Param4) -> i32 {
604     #[cfg(windows)]
605     {
606         #[link(name = "windows")]
607         extern "system" {
608             fn CompareStringOrdinal(lpstring1: super::Foundation::PWSTR, cchcount1: i32, lpstring2: super::Foundation::PWSTR, cchcount2: i32, bignorecase: super::Foundation::BOOL) -> i32;
609         }
610         ::std::mem::transmute(CompareStringOrdinal(lpstring1.into_param().abi(), ::std::mem::transmute(cchcount1), lpstring2.into_param().abi(), ::std::mem::transmute(cchcount2), bignorecase.into_param().abi()))
611     }
612     #[cfg(not(windows))]
613     unimplemented!("Unsupported target OS");
614 }
615 #[cfg(feature = "Win32_Foundation")]
616 #[inline]
CompareStringW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwcmpflags: u32, lpstring1: Param2, cchcount1: i32, lpstring2: Param4, cchcount2: i32) -> i32617 pub unsafe fn CompareStringW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwcmpflags: u32, lpstring1: Param2, cchcount1: i32, lpstring2: Param4, cchcount2: i32) -> i32 {
618     #[cfg(windows)]
619     {
620         #[link(name = "windows")]
621         extern "system" {
622             fn CompareStringW(locale: u32, dwcmpflags: u32, lpstring1: super::Foundation::PWSTR, cchcount1: i32, lpstring2: super::Foundation::PWSTR, cchcount2: i32) -> i32;
623         }
624         ::std::mem::transmute(CompareStringW(::std::mem::transmute(locale), ::std::mem::transmute(dwcmpflags), lpstring1.into_param().abi(), ::std::mem::transmute(cchcount1), lpstring2.into_param().abi(), ::std::mem::transmute(cchcount2)))
625     }
626     #[cfg(not(windows))]
627     unimplemented!("Unsupported target OS");
628 }
629 #[inline]
ConvertDefaultLocale(locale: u32) -> u32630 pub unsafe fn ConvertDefaultLocale(locale: u32) -> u32 {
631     #[cfg(windows)]
632     {
633         #[link(name = "windows")]
634         extern "system" {
635             fn ConvertDefaultLocale(locale: u32) -> u32;
636         }
637         ::std::mem::transmute(ConvertDefaultLocale(::std::mem::transmute(locale)))
638     }
639     #[cfg(not(windows))]
640     unimplemented!("Unsupported target OS");
641 }
642 #[cfg(feature = "Win32_Foundation")]
643 pub type DATEFMT_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR) -> super::Foundation::BOOL;
644 #[cfg(feature = "Win32_Foundation")]
645 pub type DATEFMT_ENUMPROCEXA = unsafe extern "system" fn(param0: super::Foundation::PSTR, param1: u32) -> super::Foundation::BOOL;
646 #[cfg(feature = "Win32_Foundation")]
647 pub type DATEFMT_ENUMPROCEXEX = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: u32, param2: super::Foundation::LPARAM) -> super::Foundation::BOOL;
648 #[cfg(feature = "Win32_Foundation")]
649 pub type DATEFMT_ENUMPROCEXW = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: u32) -> super::Foundation::BOOL;
650 #[cfg(feature = "Win32_Foundation")]
651 pub type DATEFMT_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR) -> super::Foundation::BOOL;
652 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
653 #[repr(C)]
654 pub struct DetectEncodingInfo {
655     pub nLangID: u32,
656     pub nCodePage: u32,
657     pub nDocPercent: i32,
658     pub nConfidence: i32,
659 }
660 impl DetectEncodingInfo {}
661 impl ::std::default::Default for DetectEncodingInfo {
default() -> Self662     fn default() -> Self {
663         unsafe { ::std::mem::zeroed() }
664     }
665 }
666 impl ::std::fmt::Debug for DetectEncodingInfo {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result667     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
668         fmt.debug_struct("DetectEncodingInfo").field("nLangID", &self.nLangID).field("nCodePage", &self.nCodePage).field("nDocPercent", &self.nDocPercent).field("nConfidence", &self.nConfidence).finish()
669     }
670 }
671 impl ::std::cmp::PartialEq for DetectEncodingInfo {
eq(&self, other: &Self) -> bool672     fn eq(&self, other: &Self) -> bool {
673         self.nLangID == other.nLangID && self.nCodePage == other.nCodePage && self.nDocPercent == other.nDocPercent && self.nConfidence == other.nConfidence
674     }
675 }
676 impl ::std::cmp::Eq for DetectEncodingInfo {}
677 unsafe impl ::windows::runtime::Abi for DetectEncodingInfo {
678     type Abi = Self;
679     type DefaultType = Self;
680 }
681 pub const ELS_GUID_LANGUAGE_DETECTION: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3481141425, 37019, 19861, [168, 244, 97, 31, 124, 55, 119, 2]);
682 pub const ELS_GUID_SCRIPT_DETECTION: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(761574457, 27823, 20331, [182, 136, 229, 208, 244, 250, 167, 215]);
683 pub const ELS_GUID_TRANSLITERATION_BENGALI_TO_LATIN: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(4108310565, 37284, 18591, [133, 94, 154, 217, 190, 229, 87, 39]);
684 pub const ELS_GUID_TRANSLITERATION_CYRILLIC_TO_LATIN: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1037118104, 23293, 18691, [161, 63, 225, 126, 108, 11, 254, 1]);
685 pub const ELS_GUID_TRANSLITERATION_DEVANAGARI_TO_LATIN: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3299138814, 9825, 19714, [152, 53, 244, 129, 135, 16, 152, 3]);
686 pub const ELS_GUID_TRANSLITERATION_HANGUL_DECOMPOSITION: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1268950817, 58429, 16823, [179, 48, 83, 106, 225, 228, 136, 99]);
687 pub const ELS_GUID_TRANSLITERATION_HANS_TO_HANT: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1017957832, 21904, 17116, [154, 123, 181, 166, 181, 179, 182, 59]);
688 pub const ELS_GUID_TRANSLITERATION_HANT_TO_HANS: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2745709371, 62716, 17142, [160, 196, 4, 98, 254, 115, 23, 203]);
689 pub const ELS_GUID_TRANSLITERATION_MALAYALAM_TO_LATIN: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3636036529, 63679, 18987, [188, 213, 91, 94, 162, 6, 19, 225]);
690 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
691 #[repr(C)]
692 #[cfg(feature = "Win32_Graphics_Gdi")]
693 pub struct ENUMTEXTMETRICA {
694     pub etmNewTextMetricEx: NEWTEXTMETRICEXA,
695     pub etmAxesList: super::Graphics::Gdi::AXESLISTA,
696 }
697 #[cfg(feature = "Win32_Graphics_Gdi")]
698 impl ENUMTEXTMETRICA {}
699 #[cfg(feature = "Win32_Graphics_Gdi")]
700 impl ::std::default::Default for ENUMTEXTMETRICA {
default() -> Self701     fn default() -> Self {
702         unsafe { ::std::mem::zeroed() }
703     }
704 }
705 #[cfg(feature = "Win32_Graphics_Gdi")]
706 impl ::std::fmt::Debug for ENUMTEXTMETRICA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result707     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
708         fmt.debug_struct("ENUMTEXTMETRICA").field("etmNewTextMetricEx", &self.etmNewTextMetricEx).field("etmAxesList", &self.etmAxesList).finish()
709     }
710 }
711 #[cfg(feature = "Win32_Graphics_Gdi")]
712 impl ::std::cmp::PartialEq for ENUMTEXTMETRICA {
eq(&self, other: &Self) -> bool713     fn eq(&self, other: &Self) -> bool {
714         self.etmNewTextMetricEx == other.etmNewTextMetricEx && self.etmAxesList == other.etmAxesList
715     }
716 }
717 #[cfg(feature = "Win32_Graphics_Gdi")]
718 impl ::std::cmp::Eq for ENUMTEXTMETRICA {}
719 #[cfg(feature = "Win32_Graphics_Gdi")]
720 unsafe impl ::windows::runtime::Abi for ENUMTEXTMETRICA {
721     type Abi = Self;
722     type DefaultType = Self;
723 }
724 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
725 #[repr(C)]
726 #[cfg(feature = "Win32_Graphics_Gdi")]
727 pub struct ENUMTEXTMETRICW {
728     pub etmNewTextMetricEx: NEWTEXTMETRICEXW,
729     pub etmAxesList: super::Graphics::Gdi::AXESLISTW,
730 }
731 #[cfg(feature = "Win32_Graphics_Gdi")]
732 impl ENUMTEXTMETRICW {}
733 #[cfg(feature = "Win32_Graphics_Gdi")]
734 impl ::std::default::Default for ENUMTEXTMETRICW {
default() -> Self735     fn default() -> Self {
736         unsafe { ::std::mem::zeroed() }
737     }
738 }
739 #[cfg(feature = "Win32_Graphics_Gdi")]
740 impl ::std::fmt::Debug for ENUMTEXTMETRICW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result741     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
742         fmt.debug_struct("ENUMTEXTMETRICW").field("etmNewTextMetricEx", &self.etmNewTextMetricEx).field("etmAxesList", &self.etmAxesList).finish()
743     }
744 }
745 #[cfg(feature = "Win32_Graphics_Gdi")]
746 impl ::std::cmp::PartialEq for ENUMTEXTMETRICW {
eq(&self, other: &Self) -> bool747     fn eq(&self, other: &Self) -> bool {
748         self.etmNewTextMetricEx == other.etmNewTextMetricEx && self.etmAxesList == other.etmAxesList
749     }
750 }
751 #[cfg(feature = "Win32_Graphics_Gdi")]
752 impl ::std::cmp::Eq for ENUMTEXTMETRICW {}
753 #[cfg(feature = "Win32_Graphics_Gdi")]
754 unsafe impl ::windows::runtime::Abi for ENUMTEXTMETRICW {
755     type Abi = Self;
756     type DefaultType = Self;
757 }
758 pub const ENUM_ALL_CALENDARS: u32 = 4294967295u32;
759 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
760 #[repr(transparent)]
761 pub struct ENUM_DATE_FORMATS_FLAGS(pub u32);
762 pub const DATE_SHORTDATE: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(1u32);
763 pub const DATE_LONGDATE: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(2u32);
764 pub const DATE_YEARMONTH: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(8u32);
765 pub const DATE_MONTHDAY: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(128u32);
766 pub const DATE_AUTOLAYOUT: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(64u32);
767 pub const DATE_LTRREADING: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(16u32);
768 pub const DATE_RTLREADING: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(32u32);
769 pub const DATE_USE_ALT_CALENDAR: ENUM_DATE_FORMATS_FLAGS = ENUM_DATE_FORMATS_FLAGS(4u32);
770 impl ::std::convert::From<u32> for ENUM_DATE_FORMATS_FLAGS {
from(value: u32) -> Self771     fn from(value: u32) -> Self {
772         Self(value)
773     }
774 }
775 unsafe impl ::windows::runtime::Abi for ENUM_DATE_FORMATS_FLAGS {
776     type Abi = Self;
777     type DefaultType = Self;
778 }
779 impl ::std::ops::BitOr for ENUM_DATE_FORMATS_FLAGS {
780     type Output = Self;
bitor(self, rhs: Self) -> Self781     fn bitor(self, rhs: Self) -> Self {
782         Self(self.0 | rhs.0)
783     }
784 }
785 impl ::std::ops::BitAnd for ENUM_DATE_FORMATS_FLAGS {
786     type Output = Self;
bitand(self, rhs: Self) -> Self787     fn bitand(self, rhs: Self) -> Self {
788         Self(self.0 & rhs.0)
789     }
790 }
791 impl ::std::ops::BitOrAssign for ENUM_DATE_FORMATS_FLAGS {
bitor_assign(&mut self, rhs: Self)792     fn bitor_assign(&mut self, rhs: Self) {
793         self.0.bitor_assign(rhs.0)
794     }
795 }
796 impl ::std::ops::BitAndAssign for ENUM_DATE_FORMATS_FLAGS {
bitand_assign(&mut self, rhs: Self)797     fn bitand_assign(&mut self, rhs: Self) {
798         self.0.bitand_assign(rhs.0)
799     }
800 }
801 impl ::std::ops::Not for ENUM_DATE_FORMATS_FLAGS {
802     type Output = Self;
not(self) -> Self803     fn not(self) -> Self {
804         Self(self.0.not())
805     }
806 }
807 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
808 #[repr(transparent)]
809 pub struct ENUM_SYSTEM_CODE_PAGES_FLAGS(pub u32);
810 pub const CP_INSTALLED: ENUM_SYSTEM_CODE_PAGES_FLAGS = ENUM_SYSTEM_CODE_PAGES_FLAGS(1u32);
811 pub const CP_SUPPORTED: ENUM_SYSTEM_CODE_PAGES_FLAGS = ENUM_SYSTEM_CODE_PAGES_FLAGS(2u32);
812 impl ::std::convert::From<u32> for ENUM_SYSTEM_CODE_PAGES_FLAGS {
from(value: u32) -> Self813     fn from(value: u32) -> Self {
814         Self(value)
815     }
816 }
817 unsafe impl ::windows::runtime::Abi for ENUM_SYSTEM_CODE_PAGES_FLAGS {
818     type Abi = Self;
819     type DefaultType = Self;
820 }
821 impl ::std::ops::BitOr for ENUM_SYSTEM_CODE_PAGES_FLAGS {
822     type Output = Self;
bitor(self, rhs: Self) -> Self823     fn bitor(self, rhs: Self) -> Self {
824         Self(self.0 | rhs.0)
825     }
826 }
827 impl ::std::ops::BitAnd for ENUM_SYSTEM_CODE_PAGES_FLAGS {
828     type Output = Self;
bitand(self, rhs: Self) -> Self829     fn bitand(self, rhs: Self) -> Self {
830         Self(self.0 & rhs.0)
831     }
832 }
833 impl ::std::ops::BitOrAssign for ENUM_SYSTEM_CODE_PAGES_FLAGS {
bitor_assign(&mut self, rhs: Self)834     fn bitor_assign(&mut self, rhs: Self) {
835         self.0.bitor_assign(rhs.0)
836     }
837 }
838 impl ::std::ops::BitAndAssign for ENUM_SYSTEM_CODE_PAGES_FLAGS {
bitand_assign(&mut self, rhs: Self)839     fn bitand_assign(&mut self, rhs: Self) {
840         self.0.bitand_assign(rhs.0)
841     }
842 }
843 impl ::std::ops::Not for ENUM_SYSTEM_CODE_PAGES_FLAGS {
844     type Output = Self;
not(self) -> Self845     fn not(self) -> Self {
846         Self(self.0.not())
847     }
848 }
849 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
850 #[repr(transparent)]
851 pub struct ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS(pub u32);
852 pub const LGRPID_INSTALLED: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS = ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS(1u32);
853 pub const LGRPID_SUPPORTED: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS = ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS(2u32);
854 impl ::std::convert::From<u32> for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
from(value: u32) -> Self855     fn from(value: u32) -> Self {
856         Self(value)
857     }
858 }
859 unsafe impl ::windows::runtime::Abi for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
860     type Abi = Self;
861     type DefaultType = Self;
862 }
863 impl ::std::ops::BitOr for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
864     type Output = Self;
bitor(self, rhs: Self) -> Self865     fn bitor(self, rhs: Self) -> Self {
866         Self(self.0 | rhs.0)
867     }
868 }
869 impl ::std::ops::BitAnd for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
870     type Output = Self;
bitand(self, rhs: Self) -> Self871     fn bitand(self, rhs: Self) -> Self {
872         Self(self.0 & rhs.0)
873     }
874 }
875 impl ::std::ops::BitOrAssign for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
bitor_assign(&mut self, rhs: Self)876     fn bitor_assign(&mut self, rhs: Self) {
877         self.0.bitor_assign(rhs.0)
878     }
879 }
880 impl ::std::ops::BitAndAssign for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
bitand_assign(&mut self, rhs: Self)881     fn bitand_assign(&mut self, rhs: Self) {
882         self.0.bitand_assign(rhs.0)
883     }
884 }
885 impl ::std::ops::Not for ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS {
886     type Output = Self;
not(self) -> Self887     fn not(self) -> Self {
888         Self(self.0.not())
889     }
890 }
891 #[cfg(feature = "Win32_Foundation")]
892 #[inline]
EnumCalendarInfoA(lpcalinfoenumproc: ::std::option::Option<CALINFO_ENUMPROCA>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL893 pub unsafe fn EnumCalendarInfoA(lpcalinfoenumproc: ::std::option::Option<CALINFO_ENUMPROCA>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL {
894     #[cfg(windows)]
895     {
896         #[link(name = "windows")]
897         extern "system" {
898             fn EnumCalendarInfoA(lpcalinfoenumproc: ::windows::runtime::RawPtr, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL;
899         }
900         ::std::mem::transmute(EnumCalendarInfoA(::std::mem::transmute(lpcalinfoenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype)))
901     }
902     #[cfg(not(windows))]
903     unimplemented!("Unsupported target OS");
904 }
905 #[cfg(feature = "Win32_Foundation")]
906 #[inline]
EnumCalendarInfoExA(lpcalinfoenumprocex: ::std::option::Option<CALINFO_ENUMPROCEXA>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL907 pub unsafe fn EnumCalendarInfoExA(lpcalinfoenumprocex: ::std::option::Option<CALINFO_ENUMPROCEXA>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL {
908     #[cfg(windows)]
909     {
910         #[link(name = "windows")]
911         extern "system" {
912             fn EnumCalendarInfoExA(lpcalinfoenumprocex: ::windows::runtime::RawPtr, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL;
913         }
914         ::std::mem::transmute(EnumCalendarInfoExA(::std::mem::transmute(lpcalinfoenumprocex), ::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype)))
915     }
916     #[cfg(not(windows))]
917     unimplemented!("Unsupported target OS");
918 }
919 #[cfg(feature = "Win32_Foundation")]
920 #[inline]
EnumCalendarInfoExEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(pcalinfoenumprocexex: ::std::option::Option<CALINFO_ENUMPROCEXEX>, lplocalename: Param1, calendar: u32, lpreserved: Param3, caltype: u32, lparam: Param5) -> super::Foundation::BOOL921 pub unsafe fn EnumCalendarInfoExEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(pcalinfoenumprocexex: ::std::option::Option<CALINFO_ENUMPROCEXEX>, lplocalename: Param1, calendar: u32, lpreserved: Param3, caltype: u32, lparam: Param5) -> super::Foundation::BOOL {
922     #[cfg(windows)]
923     {
924         #[link(name = "windows")]
925         extern "system" {
926             fn EnumCalendarInfoExEx(pcalinfoenumprocexex: ::windows::runtime::RawPtr, lplocalename: super::Foundation::PWSTR, calendar: u32, lpreserved: super::Foundation::PWSTR, caltype: u32, lparam: super::Foundation::LPARAM) -> super::Foundation::BOOL;
927         }
928         ::std::mem::transmute(EnumCalendarInfoExEx(::std::mem::transmute(pcalinfoenumprocexex), lplocalename.into_param().abi(), ::std::mem::transmute(calendar), lpreserved.into_param().abi(), ::std::mem::transmute(caltype), lparam.into_param().abi()))
929     }
930     #[cfg(not(windows))]
931     unimplemented!("Unsupported target OS");
932 }
933 #[cfg(feature = "Win32_Foundation")]
934 #[inline]
EnumCalendarInfoExW(lpcalinfoenumprocex: ::std::option::Option<CALINFO_ENUMPROCEXW>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL935 pub unsafe fn EnumCalendarInfoExW(lpcalinfoenumprocex: ::std::option::Option<CALINFO_ENUMPROCEXW>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL {
936     #[cfg(windows)]
937     {
938         #[link(name = "windows")]
939         extern "system" {
940             fn EnumCalendarInfoExW(lpcalinfoenumprocex: ::windows::runtime::RawPtr, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL;
941         }
942         ::std::mem::transmute(EnumCalendarInfoExW(::std::mem::transmute(lpcalinfoenumprocex), ::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype)))
943     }
944     #[cfg(not(windows))]
945     unimplemented!("Unsupported target OS");
946 }
947 #[cfg(feature = "Win32_Foundation")]
948 #[inline]
EnumCalendarInfoW(lpcalinfoenumproc: ::std::option::Option<CALINFO_ENUMPROCW>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL949 pub unsafe fn EnumCalendarInfoW(lpcalinfoenumproc: ::std::option::Option<CALINFO_ENUMPROCW>, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL {
950     #[cfg(windows)]
951     {
952         #[link(name = "windows")]
953         extern "system" {
954             fn EnumCalendarInfoW(lpcalinfoenumproc: ::windows::runtime::RawPtr, locale: u32, calendar: u32, caltype: u32) -> super::Foundation::BOOL;
955         }
956         ::std::mem::transmute(EnumCalendarInfoW(::std::mem::transmute(lpcalinfoenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype)))
957     }
958     #[cfg(not(windows))]
959     unimplemented!("Unsupported target OS");
960 }
961 #[cfg(feature = "Win32_Foundation")]
962 #[inline]
EnumDateFormatsA(lpdatefmtenumproc: ::std::option::Option<DATEFMT_ENUMPROCA>, locale: u32, dwflags: u32) -> super::Foundation::BOOL963 pub unsafe fn EnumDateFormatsA(lpdatefmtenumproc: ::std::option::Option<DATEFMT_ENUMPROCA>, locale: u32, dwflags: u32) -> super::Foundation::BOOL {
964     #[cfg(windows)]
965     {
966         #[link(name = "windows")]
967         extern "system" {
968             fn EnumDateFormatsA(lpdatefmtenumproc: ::windows::runtime::RawPtr, locale: u32, dwflags: u32) -> super::Foundation::BOOL;
969         }
970         ::std::mem::transmute(EnumDateFormatsA(::std::mem::transmute(lpdatefmtenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
971     }
972     #[cfg(not(windows))]
973     unimplemented!("Unsupported target OS");
974 }
975 #[cfg(feature = "Win32_Foundation")]
976 #[inline]
EnumDateFormatsExA(lpdatefmtenumprocex: ::std::option::Option<DATEFMT_ENUMPROCEXA>, locale: u32, dwflags: u32) -> super::Foundation::BOOL977 pub unsafe fn EnumDateFormatsExA(lpdatefmtenumprocex: ::std::option::Option<DATEFMT_ENUMPROCEXA>, locale: u32, dwflags: u32) -> super::Foundation::BOOL {
978     #[cfg(windows)]
979     {
980         #[link(name = "windows")]
981         extern "system" {
982             fn EnumDateFormatsExA(lpdatefmtenumprocex: ::windows::runtime::RawPtr, locale: u32, dwflags: u32) -> super::Foundation::BOOL;
983         }
984         ::std::mem::transmute(EnumDateFormatsExA(::std::mem::transmute(lpdatefmtenumprocex), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
985     }
986     #[cfg(not(windows))]
987     unimplemented!("Unsupported target OS");
988 }
989 #[cfg(feature = "Win32_Foundation")]
990 #[inline]
EnumDateFormatsExEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lpdatefmtenumprocexex: ::std::option::Option<DATEFMT_ENUMPROCEXEX>, lplocalename: Param1, dwflags: ENUM_DATE_FORMATS_FLAGS, lparam: Param3) -> super::Foundation::BOOL991 pub unsafe fn EnumDateFormatsExEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lpdatefmtenumprocexex: ::std::option::Option<DATEFMT_ENUMPROCEXEX>, lplocalename: Param1, dwflags: ENUM_DATE_FORMATS_FLAGS, lparam: Param3) -> super::Foundation::BOOL {
992     #[cfg(windows)]
993     {
994         #[link(name = "windows")]
995         extern "system" {
996             fn EnumDateFormatsExEx(lpdatefmtenumprocexex: ::windows::runtime::RawPtr, lplocalename: super::Foundation::PWSTR, dwflags: ENUM_DATE_FORMATS_FLAGS, lparam: super::Foundation::LPARAM) -> super::Foundation::BOOL;
997         }
998         ::std::mem::transmute(EnumDateFormatsExEx(::std::mem::transmute(lpdatefmtenumprocexex), lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), lparam.into_param().abi()))
999     }
1000     #[cfg(not(windows))]
1001     unimplemented!("Unsupported target OS");
1002 }
1003 #[cfg(feature = "Win32_Foundation")]
1004 #[inline]
EnumDateFormatsExW(lpdatefmtenumprocex: ::std::option::Option<DATEFMT_ENUMPROCEXW>, locale: u32, dwflags: u32) -> super::Foundation::BOOL1005 pub unsafe fn EnumDateFormatsExW(lpdatefmtenumprocex: ::std::option::Option<DATEFMT_ENUMPROCEXW>, locale: u32, dwflags: u32) -> super::Foundation::BOOL {
1006     #[cfg(windows)]
1007     {
1008         #[link(name = "windows")]
1009         extern "system" {
1010             fn EnumDateFormatsExW(lpdatefmtenumprocex: ::windows::runtime::RawPtr, locale: u32, dwflags: u32) -> super::Foundation::BOOL;
1011         }
1012         ::std::mem::transmute(EnumDateFormatsExW(::std::mem::transmute(lpdatefmtenumprocex), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
1013     }
1014     #[cfg(not(windows))]
1015     unimplemented!("Unsupported target OS");
1016 }
1017 #[cfg(feature = "Win32_Foundation")]
1018 #[inline]
EnumDateFormatsW(lpdatefmtenumproc: ::std::option::Option<DATEFMT_ENUMPROCW>, locale: u32, dwflags: u32) -> super::Foundation::BOOL1019 pub unsafe fn EnumDateFormatsW(lpdatefmtenumproc: ::std::option::Option<DATEFMT_ENUMPROCW>, locale: u32, dwflags: u32) -> super::Foundation::BOOL {
1020     #[cfg(windows)]
1021     {
1022         #[link(name = "windows")]
1023         extern "system" {
1024             fn EnumDateFormatsW(lpdatefmtenumproc: ::windows::runtime::RawPtr, locale: u32, dwflags: u32) -> super::Foundation::BOOL;
1025         }
1026         ::std::mem::transmute(EnumDateFormatsW(::std::mem::transmute(lpdatefmtenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
1027     }
1028     #[cfg(not(windows))]
1029     unimplemented!("Unsupported target OS");
1030 }
1031 #[cfg(feature = "Win32_Foundation")]
1032 #[inline]
EnumLanguageGroupLocalesA(lplanggrouplocaleenumproc: ::std::option::Option<LANGGROUPLOCALE_ENUMPROCA>, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL1033 pub unsafe fn EnumLanguageGroupLocalesA(lplanggrouplocaleenumproc: ::std::option::Option<LANGGROUPLOCALE_ENUMPROCA>, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL {
1034     #[cfg(windows)]
1035     {
1036         #[link(name = "windows")]
1037         extern "system" {
1038             fn EnumLanguageGroupLocalesA(lplanggrouplocaleenumproc: ::windows::runtime::RawPtr, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL;
1039         }
1040         ::std::mem::transmute(EnumLanguageGroupLocalesA(::std::mem::transmute(lplanggrouplocaleenumproc), ::std::mem::transmute(languagegroup), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1041     }
1042     #[cfg(not(windows))]
1043     unimplemented!("Unsupported target OS");
1044 }
1045 #[cfg(feature = "Win32_Foundation")]
1046 #[inline]
EnumLanguageGroupLocalesW(lplanggrouplocaleenumproc: ::std::option::Option<LANGGROUPLOCALE_ENUMPROCW>, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL1047 pub unsafe fn EnumLanguageGroupLocalesW(lplanggrouplocaleenumproc: ::std::option::Option<LANGGROUPLOCALE_ENUMPROCW>, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL {
1048     #[cfg(windows)]
1049     {
1050         #[link(name = "windows")]
1051         extern "system" {
1052             fn EnumLanguageGroupLocalesW(lplanggrouplocaleenumproc: ::windows::runtime::RawPtr, languagegroup: u32, dwflags: u32, lparam: isize) -> super::Foundation::BOOL;
1053         }
1054         ::std::mem::transmute(EnumLanguageGroupLocalesW(::std::mem::transmute(lplanggrouplocaleenumproc), ::std::mem::transmute(languagegroup), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1055     }
1056     #[cfg(not(windows))]
1057     unimplemented!("Unsupported target OS");
1058 }
1059 #[cfg(feature = "Win32_Foundation")]
1060 #[inline]
EnumSystemCodePagesA(lpcodepageenumproc: ::std::option::Option<CODEPAGE_ENUMPROCA>, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL1061 pub unsafe fn EnumSystemCodePagesA(lpcodepageenumproc: ::std::option::Option<CODEPAGE_ENUMPROCA>, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL {
1062     #[cfg(windows)]
1063     {
1064         #[link(name = "windows")]
1065         extern "system" {
1066             fn EnumSystemCodePagesA(lpcodepageenumproc: ::windows::runtime::RawPtr, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL;
1067         }
1068         ::std::mem::transmute(EnumSystemCodePagesA(::std::mem::transmute(lpcodepageenumproc), ::std::mem::transmute(dwflags)))
1069     }
1070     #[cfg(not(windows))]
1071     unimplemented!("Unsupported target OS");
1072 }
1073 #[cfg(feature = "Win32_Foundation")]
1074 #[inline]
EnumSystemCodePagesW(lpcodepageenumproc: ::std::option::Option<CODEPAGE_ENUMPROCW>, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL1075 pub unsafe fn EnumSystemCodePagesW(lpcodepageenumproc: ::std::option::Option<CODEPAGE_ENUMPROCW>, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL {
1076     #[cfg(windows)]
1077     {
1078         #[link(name = "windows")]
1079         extern "system" {
1080             fn EnumSystemCodePagesW(lpcodepageenumproc: ::windows::runtime::RawPtr, dwflags: ENUM_SYSTEM_CODE_PAGES_FLAGS) -> super::Foundation::BOOL;
1081         }
1082         ::std::mem::transmute(EnumSystemCodePagesW(::std::mem::transmute(lpcodepageenumproc), ::std::mem::transmute(dwflags)))
1083     }
1084     #[cfg(not(windows))]
1085     unimplemented!("Unsupported target OS");
1086 }
1087 #[cfg(feature = "Win32_Foundation")]
1088 #[inline]
EnumSystemGeoID(geoclass: u32, parentgeoid: i32, lpgeoenumproc: ::std::option::Option<GEO_ENUMPROC>) -> super::Foundation::BOOL1089 pub unsafe fn EnumSystemGeoID(geoclass: u32, parentgeoid: i32, lpgeoenumproc: ::std::option::Option<GEO_ENUMPROC>) -> super::Foundation::BOOL {
1090     #[cfg(windows)]
1091     {
1092         #[link(name = "windows")]
1093         extern "system" {
1094             fn EnumSystemGeoID(geoclass: u32, parentgeoid: i32, lpgeoenumproc: ::windows::runtime::RawPtr) -> super::Foundation::BOOL;
1095         }
1096         ::std::mem::transmute(EnumSystemGeoID(::std::mem::transmute(geoclass), ::std::mem::transmute(parentgeoid), ::std::mem::transmute(lpgeoenumproc)))
1097     }
1098     #[cfg(not(windows))]
1099     unimplemented!("Unsupported target OS");
1100 }
1101 #[cfg(feature = "Win32_Foundation")]
1102 #[inline]
EnumSystemGeoNames<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(geoclass: u32, geoenumproc: ::std::option::Option<GEO_ENUMNAMEPROC>, data: Param2) -> super::Foundation::BOOL1103 pub unsafe fn EnumSystemGeoNames<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(geoclass: u32, geoenumproc: ::std::option::Option<GEO_ENUMNAMEPROC>, data: Param2) -> super::Foundation::BOOL {
1104     #[cfg(windows)]
1105     {
1106         #[link(name = "windows")]
1107         extern "system" {
1108             fn EnumSystemGeoNames(geoclass: u32, geoenumproc: ::windows::runtime::RawPtr, data: super::Foundation::LPARAM) -> super::Foundation::BOOL;
1109         }
1110         ::std::mem::transmute(EnumSystemGeoNames(::std::mem::transmute(geoclass), ::std::mem::transmute(geoenumproc), data.into_param().abi()))
1111     }
1112     #[cfg(not(windows))]
1113     unimplemented!("Unsupported target OS");
1114 }
1115 #[cfg(feature = "Win32_Foundation")]
1116 #[inline]
EnumSystemLanguageGroupsA(lplanguagegroupenumproc: ::std::option::Option<LANGUAGEGROUP_ENUMPROCA>, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL1117 pub unsafe fn EnumSystemLanguageGroupsA(lplanguagegroupenumproc: ::std::option::Option<LANGUAGEGROUP_ENUMPROCA>, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL {
1118     #[cfg(windows)]
1119     {
1120         #[link(name = "windows")]
1121         extern "system" {
1122             fn EnumSystemLanguageGroupsA(lplanguagegroupenumproc: ::windows::runtime::RawPtr, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL;
1123         }
1124         ::std::mem::transmute(EnumSystemLanguageGroupsA(::std::mem::transmute(lplanguagegroupenumproc), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1125     }
1126     #[cfg(not(windows))]
1127     unimplemented!("Unsupported target OS");
1128 }
1129 #[cfg(feature = "Win32_Foundation")]
1130 #[inline]
EnumSystemLanguageGroupsW(lplanguagegroupenumproc: ::std::option::Option<LANGUAGEGROUP_ENUMPROCW>, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL1131 pub unsafe fn EnumSystemLanguageGroupsW(lplanguagegroupenumproc: ::std::option::Option<LANGUAGEGROUP_ENUMPROCW>, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL {
1132     #[cfg(windows)]
1133     {
1134         #[link(name = "windows")]
1135         extern "system" {
1136             fn EnumSystemLanguageGroupsW(lplanguagegroupenumproc: ::windows::runtime::RawPtr, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS, lparam: isize) -> super::Foundation::BOOL;
1137         }
1138         ::std::mem::transmute(EnumSystemLanguageGroupsW(::std::mem::transmute(lplanguagegroupenumproc), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1139     }
1140     #[cfg(not(windows))]
1141     unimplemented!("Unsupported target OS");
1142 }
1143 #[cfg(feature = "Win32_Foundation")]
1144 #[inline]
EnumSystemLocalesA(lplocaleenumproc: ::std::option::Option<LOCALE_ENUMPROCA>, dwflags: u32) -> super::Foundation::BOOL1145 pub unsafe fn EnumSystemLocalesA(lplocaleenumproc: ::std::option::Option<LOCALE_ENUMPROCA>, dwflags: u32) -> super::Foundation::BOOL {
1146     #[cfg(windows)]
1147     {
1148         #[link(name = "windows")]
1149         extern "system" {
1150             fn EnumSystemLocalesA(lplocaleenumproc: ::windows::runtime::RawPtr, dwflags: u32) -> super::Foundation::BOOL;
1151         }
1152         ::std::mem::transmute(EnumSystemLocalesA(::std::mem::transmute(lplocaleenumproc), ::std::mem::transmute(dwflags)))
1153     }
1154     #[cfg(not(windows))]
1155     unimplemented!("Unsupported target OS");
1156 }
1157 #[cfg(feature = "Win32_Foundation")]
1158 #[inline]
EnumSystemLocalesEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lplocaleenumprocex: ::std::option::Option<LOCALE_ENUMPROCEX>, dwflags: u32, lparam: Param2, lpreserved: *const ::std::ffi::c_void) -> super::Foundation::BOOL1159 pub unsafe fn EnumSystemLocalesEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lplocaleenumprocex: ::std::option::Option<LOCALE_ENUMPROCEX>, dwflags: u32, lparam: Param2, lpreserved: *const ::std::ffi::c_void) -> super::Foundation::BOOL {
1160     #[cfg(windows)]
1161     {
1162         #[link(name = "windows")]
1163         extern "system" {
1164             fn EnumSystemLocalesEx(lplocaleenumprocex: ::windows::runtime::RawPtr, dwflags: u32, lparam: super::Foundation::LPARAM, lpreserved: *const ::std::ffi::c_void) -> super::Foundation::BOOL;
1165         }
1166         ::std::mem::transmute(EnumSystemLocalesEx(::std::mem::transmute(lplocaleenumprocex), ::std::mem::transmute(dwflags), lparam.into_param().abi(), ::std::mem::transmute(lpreserved)))
1167     }
1168     #[cfg(not(windows))]
1169     unimplemented!("Unsupported target OS");
1170 }
1171 #[cfg(feature = "Win32_Foundation")]
1172 #[inline]
EnumSystemLocalesW(lplocaleenumproc: ::std::option::Option<LOCALE_ENUMPROCW>, dwflags: u32) -> super::Foundation::BOOL1173 pub unsafe fn EnumSystemLocalesW(lplocaleenumproc: ::std::option::Option<LOCALE_ENUMPROCW>, dwflags: u32) -> super::Foundation::BOOL {
1174     #[cfg(windows)]
1175     {
1176         #[link(name = "windows")]
1177         extern "system" {
1178             fn EnumSystemLocalesW(lplocaleenumproc: ::windows::runtime::RawPtr, dwflags: u32) -> super::Foundation::BOOL;
1179         }
1180         ::std::mem::transmute(EnumSystemLocalesW(::std::mem::transmute(lplocaleenumproc), ::std::mem::transmute(dwflags)))
1181     }
1182     #[cfg(not(windows))]
1183     unimplemented!("Unsupported target OS");
1184 }
1185 #[cfg(feature = "Win32_Foundation")]
1186 #[inline]
EnumTimeFormatsA(lptimefmtenumproc: ::std::option::Option<TIMEFMT_ENUMPROCA>, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL1187 pub unsafe fn EnumTimeFormatsA(lptimefmtenumproc: ::std::option::Option<TIMEFMT_ENUMPROCA>, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL {
1188     #[cfg(windows)]
1189     {
1190         #[link(name = "windows")]
1191         extern "system" {
1192             fn EnumTimeFormatsA(lptimefmtenumproc: ::windows::runtime::RawPtr, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL;
1193         }
1194         ::std::mem::transmute(EnumTimeFormatsA(::std::mem::transmute(lptimefmtenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
1195     }
1196     #[cfg(not(windows))]
1197     unimplemented!("Unsupported target OS");
1198 }
1199 #[cfg(feature = "Win32_Foundation")]
1200 #[inline]
EnumTimeFormatsEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lptimefmtenumprocex: ::std::option::Option<TIMEFMT_ENUMPROCEX>, lplocalename: Param1, dwflags: u32, lparam: Param3) -> super::Foundation::BOOL1201 pub unsafe fn EnumTimeFormatsEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lptimefmtenumprocex: ::std::option::Option<TIMEFMT_ENUMPROCEX>, lplocalename: Param1, dwflags: u32, lparam: Param3) -> super::Foundation::BOOL {
1202     #[cfg(windows)]
1203     {
1204         #[link(name = "windows")]
1205         extern "system" {
1206             fn EnumTimeFormatsEx(lptimefmtenumprocex: ::windows::runtime::RawPtr, lplocalename: super::Foundation::PWSTR, dwflags: u32, lparam: super::Foundation::LPARAM) -> super::Foundation::BOOL;
1207         }
1208         ::std::mem::transmute(EnumTimeFormatsEx(::std::mem::transmute(lptimefmtenumprocex), lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), lparam.into_param().abi()))
1209     }
1210     #[cfg(not(windows))]
1211     unimplemented!("Unsupported target OS");
1212 }
1213 #[cfg(feature = "Win32_Foundation")]
1214 #[inline]
EnumTimeFormatsW(lptimefmtenumproc: ::std::option::Option<TIMEFMT_ENUMPROCW>, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL1215 pub unsafe fn EnumTimeFormatsW(lptimefmtenumproc: ::std::option::Option<TIMEFMT_ENUMPROCW>, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL {
1216     #[cfg(windows)]
1217     {
1218         #[link(name = "windows")]
1219         extern "system" {
1220             fn EnumTimeFormatsW(lptimefmtenumproc: ::windows::runtime::RawPtr, locale: u32, dwflags: TIME_FORMAT_FLAGS) -> super::Foundation::BOOL;
1221         }
1222         ::std::mem::transmute(EnumTimeFormatsW(::std::mem::transmute(lptimefmtenumproc), ::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
1223     }
1224     #[cfg(not(windows))]
1225     unimplemented!("Unsupported target OS");
1226 }
1227 #[cfg(feature = "Win32_Foundation")]
1228 #[inline]
EnumUILanguagesA(lpuilanguageenumproc: ::std::option::Option<UILANGUAGE_ENUMPROCA>, dwflags: u32, lparam: isize) -> super::Foundation::BOOL1229 pub unsafe fn EnumUILanguagesA(lpuilanguageenumproc: ::std::option::Option<UILANGUAGE_ENUMPROCA>, dwflags: u32, lparam: isize) -> super::Foundation::BOOL {
1230     #[cfg(windows)]
1231     {
1232         #[link(name = "windows")]
1233         extern "system" {
1234             fn EnumUILanguagesA(lpuilanguageenumproc: ::windows::runtime::RawPtr, dwflags: u32, lparam: isize) -> super::Foundation::BOOL;
1235         }
1236         ::std::mem::transmute(EnumUILanguagesA(::std::mem::transmute(lpuilanguageenumproc), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1237     }
1238     #[cfg(not(windows))]
1239     unimplemented!("Unsupported target OS");
1240 }
1241 #[cfg(feature = "Win32_Foundation")]
1242 #[inline]
EnumUILanguagesW(lpuilanguageenumproc: ::std::option::Option<UILANGUAGE_ENUMPROCW>, dwflags: u32, lparam: isize) -> super::Foundation::BOOL1243 pub unsafe fn EnumUILanguagesW(lpuilanguageenumproc: ::std::option::Option<UILANGUAGE_ENUMPROCW>, dwflags: u32, lparam: isize) -> super::Foundation::BOOL {
1244     #[cfg(windows)]
1245     {
1246         #[link(name = "windows")]
1247         extern "system" {
1248             fn EnumUILanguagesW(lpuilanguageenumproc: ::windows::runtime::RawPtr, dwflags: u32, lparam: isize) -> super::Foundation::BOOL;
1249         }
1250         ::std::mem::transmute(EnumUILanguagesW(::std::mem::transmute(lpuilanguageenumproc), ::std::mem::transmute(dwflags), ::std::mem::transmute(lparam)))
1251     }
1252     #[cfg(not(windows))]
1253     unimplemented!("Unsupported target OS");
1254 }
1255 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1256 #[repr(C)]
1257 pub struct FILEMUIINFO {
1258     pub dwSize: u32,
1259     pub dwVersion: u32,
1260     pub dwFileType: u32,
1261     pub pChecksum: [u8; 16],
1262     pub pServiceChecksum: [u8; 16],
1263     pub dwLanguageNameOffset: u32,
1264     pub dwTypeIDMainSize: u32,
1265     pub dwTypeIDMainOffset: u32,
1266     pub dwTypeNameMainOffset: u32,
1267     pub dwTypeIDMUISize: u32,
1268     pub dwTypeIDMUIOffset: u32,
1269     pub dwTypeNameMUIOffset: u32,
1270     pub abBuffer: [u8; 8],
1271 }
1272 impl FILEMUIINFO {}
1273 impl ::std::default::Default for FILEMUIINFO {
default() -> Self1274     fn default() -> Self {
1275         unsafe { ::std::mem::zeroed() }
1276     }
1277 }
1278 impl ::std::fmt::Debug for FILEMUIINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1279     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1280         fmt.debug_struct("FILEMUIINFO")
1281             .field("dwSize", &self.dwSize)
1282             .field("dwVersion", &self.dwVersion)
1283             .field("dwFileType", &self.dwFileType)
1284             .field("pChecksum", &self.pChecksum)
1285             .field("pServiceChecksum", &self.pServiceChecksum)
1286             .field("dwLanguageNameOffset", &self.dwLanguageNameOffset)
1287             .field("dwTypeIDMainSize", &self.dwTypeIDMainSize)
1288             .field("dwTypeIDMainOffset", &self.dwTypeIDMainOffset)
1289             .field("dwTypeNameMainOffset", &self.dwTypeNameMainOffset)
1290             .field("dwTypeIDMUISize", &self.dwTypeIDMUISize)
1291             .field("dwTypeIDMUIOffset", &self.dwTypeIDMUIOffset)
1292             .field("dwTypeNameMUIOffset", &self.dwTypeNameMUIOffset)
1293             .field("abBuffer", &self.abBuffer)
1294             .finish()
1295     }
1296 }
1297 impl ::std::cmp::PartialEq for FILEMUIINFO {
eq(&self, other: &Self) -> bool1298     fn eq(&self, other: &Self) -> bool {
1299         self.dwSize == other.dwSize
1300             && self.dwVersion == other.dwVersion
1301             && self.dwFileType == other.dwFileType
1302             && self.pChecksum == other.pChecksum
1303             && self.pServiceChecksum == other.pServiceChecksum
1304             && self.dwLanguageNameOffset == other.dwLanguageNameOffset
1305             && self.dwTypeIDMainSize == other.dwTypeIDMainSize
1306             && self.dwTypeIDMainOffset == other.dwTypeIDMainOffset
1307             && self.dwTypeNameMainOffset == other.dwTypeNameMainOffset
1308             && self.dwTypeIDMUISize == other.dwTypeIDMUISize
1309             && self.dwTypeIDMUIOffset == other.dwTypeIDMUIOffset
1310             && self.dwTypeNameMUIOffset == other.dwTypeNameMUIOffset
1311             && self.abBuffer == other.abBuffer
1312     }
1313 }
1314 impl ::std::cmp::Eq for FILEMUIINFO {}
1315 unsafe impl ::windows::runtime::Abi for FILEMUIINFO {
1316     type Abi = Self;
1317     type DefaultType = Self;
1318 }
1319 pub const FIND_ENDSWITH: u32 = 2097152u32;
1320 pub const FIND_FROMEND: u32 = 8388608u32;
1321 pub const FIND_FROMSTART: u32 = 4194304u32;
1322 pub const FIND_STARTSWITH: u32 = 1048576u32;
1323 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
1324 #[repr(transparent)]
1325 pub struct FOLD_STRING_MAP_FLAGS(pub u32);
1326 pub const MAP_COMPOSITE: FOLD_STRING_MAP_FLAGS = FOLD_STRING_MAP_FLAGS(64u32);
1327 pub const MAP_EXPAND_LIGATURES: FOLD_STRING_MAP_FLAGS = FOLD_STRING_MAP_FLAGS(8192u32);
1328 pub const MAP_FOLDCZONE: FOLD_STRING_MAP_FLAGS = FOLD_STRING_MAP_FLAGS(16u32);
1329 pub const MAP_FOLDDIGITS: FOLD_STRING_MAP_FLAGS = FOLD_STRING_MAP_FLAGS(128u32);
1330 pub const MAP_PRECOMPOSED: FOLD_STRING_MAP_FLAGS = FOLD_STRING_MAP_FLAGS(32u32);
1331 impl ::std::convert::From<u32> for FOLD_STRING_MAP_FLAGS {
from(value: u32) -> Self1332     fn from(value: u32) -> Self {
1333         Self(value)
1334     }
1335 }
1336 unsafe impl ::windows::runtime::Abi for FOLD_STRING_MAP_FLAGS {
1337     type Abi = Self;
1338     type DefaultType = Self;
1339 }
1340 impl ::std::ops::BitOr for FOLD_STRING_MAP_FLAGS {
1341     type Output = Self;
bitor(self, rhs: Self) -> Self1342     fn bitor(self, rhs: Self) -> Self {
1343         Self(self.0 | rhs.0)
1344     }
1345 }
1346 impl ::std::ops::BitAnd for FOLD_STRING_MAP_FLAGS {
1347     type Output = Self;
bitand(self, rhs: Self) -> Self1348     fn bitand(self, rhs: Self) -> Self {
1349         Self(self.0 & rhs.0)
1350     }
1351 }
1352 impl ::std::ops::BitOrAssign for FOLD_STRING_MAP_FLAGS {
bitor_assign(&mut self, rhs: Self)1353     fn bitor_assign(&mut self, rhs: Self) {
1354         self.0.bitor_assign(rhs.0)
1355     }
1356 }
1357 impl ::std::ops::BitAndAssign for FOLD_STRING_MAP_FLAGS {
bitand_assign(&mut self, rhs: Self)1358     fn bitand_assign(&mut self, rhs: Self) {
1359         self.0.bitand_assign(rhs.0)
1360     }
1361 }
1362 impl ::std::ops::Not for FOLD_STRING_MAP_FLAGS {
1363     type Output = Self;
not(self) -> Self1364     fn not(self) -> Self {
1365         Self(self.0.not())
1366     }
1367 }
1368 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1369 #[repr(C)]
1370 pub struct FONTSIGNATURE {
1371     pub fsUsb: [u32; 4],
1372     pub fsCsb: [u32; 2],
1373 }
1374 impl FONTSIGNATURE {}
1375 impl ::std::default::Default for FONTSIGNATURE {
default() -> Self1376     fn default() -> Self {
1377         unsafe { ::std::mem::zeroed() }
1378     }
1379 }
1380 impl ::std::fmt::Debug for FONTSIGNATURE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1381     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1382         fmt.debug_struct("FONTSIGNATURE").field("fsUsb", &self.fsUsb).field("fsCsb", &self.fsCsb).finish()
1383     }
1384 }
1385 impl ::std::cmp::PartialEq for FONTSIGNATURE {
eq(&self, other: &Self) -> bool1386     fn eq(&self, other: &Self) -> bool {
1387         self.fsUsb == other.fsUsb && self.fsCsb == other.fsCsb
1388     }
1389 }
1390 impl ::std::cmp::Eq for FONTSIGNATURE {}
1391 unsafe impl ::windows::runtime::Abi for FONTSIGNATURE {
1392     type Abi = Self;
1393     type DefaultType = Self;
1394 }
1395 #[cfg(feature = "Win32_Foundation")]
1396 #[inline]
FindNLSString<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwfindnlsstringflags: u32, lpstringsource: Param2, cchsource: i32, lpstringvalue: Param4, cchvalue: i32, pcchfound: *mut i32) -> i321397 pub unsafe fn FindNLSString<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwfindnlsstringflags: u32, lpstringsource: Param2, cchsource: i32, lpstringvalue: Param4, cchvalue: i32, pcchfound: *mut i32) -> i32 {
1398     #[cfg(windows)]
1399     {
1400         #[link(name = "windows")]
1401         extern "system" {
1402             fn FindNLSString(locale: u32, dwfindnlsstringflags: u32, lpstringsource: super::Foundation::PWSTR, cchsource: i32, lpstringvalue: super::Foundation::PWSTR, cchvalue: i32, pcchfound: *mut i32) -> i32;
1403         }
1404         ::std::mem::transmute(FindNLSString(::std::mem::transmute(locale), ::std::mem::transmute(dwfindnlsstringflags), lpstringsource.into_param().abi(), ::std::mem::transmute(cchsource), lpstringvalue.into_param().abi(), ::std::mem::transmute(cchvalue), ::std::mem::transmute(pcchfound)))
1405     }
1406     #[cfg(not(windows))]
1407     unimplemented!("Unsupported target OS");
1408 }
1409 #[cfg(feature = "Win32_Foundation")]
1410 #[inline]
FindNLSStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>( lplocalename: Param0, dwfindnlsstringflags: u32, lpstringsource: Param2, cchsource: i32, lpstringvalue: Param4, cchvalue: i32, pcchfound: *mut i32, lpversioninformation: *const NLSVERSIONINFO, lpreserved: *const ::std::ffi::c_void, sorthandle: Param9, ) -> i321411 pub unsafe fn FindNLSStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param9: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(
1412     lplocalename: Param0,
1413     dwfindnlsstringflags: u32,
1414     lpstringsource: Param2,
1415     cchsource: i32,
1416     lpstringvalue: Param4,
1417     cchvalue: i32,
1418     pcchfound: *mut i32,
1419     lpversioninformation: *const NLSVERSIONINFO,
1420     lpreserved: *const ::std::ffi::c_void,
1421     sorthandle: Param9,
1422 ) -> i32 {
1423     #[cfg(windows)]
1424     {
1425         #[link(name = "windows")]
1426         extern "system" {
1427             fn FindNLSStringEx(lplocalename: super::Foundation::PWSTR, dwfindnlsstringflags: u32, lpstringsource: super::Foundation::PWSTR, cchsource: i32, lpstringvalue: super::Foundation::PWSTR, cchvalue: i32, pcchfound: *mut i32, lpversioninformation: *const NLSVERSIONINFO, lpreserved: *const ::std::ffi::c_void, sorthandle: super::Foundation::LPARAM) -> i32;
1428         }
1429         ::std::mem::transmute(FindNLSStringEx(
1430             lplocalename.into_param().abi(),
1431             ::std::mem::transmute(dwfindnlsstringflags),
1432             lpstringsource.into_param().abi(),
1433             ::std::mem::transmute(cchsource),
1434             lpstringvalue.into_param().abi(),
1435             ::std::mem::transmute(cchvalue),
1436             ::std::mem::transmute(pcchfound),
1437             ::std::mem::transmute(lpversioninformation),
1438             ::std::mem::transmute(lpreserved),
1439             sorthandle.into_param().abi(),
1440         ))
1441     }
1442     #[cfg(not(windows))]
1443     unimplemented!("Unsupported target OS");
1444 }
1445 #[cfg(feature = "Win32_Foundation")]
1446 #[inline]
FindStringOrdinal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(dwfindstringordinalflags: u32, lpstringsource: Param1, cchsource: i32, lpstringvalue: Param3, cchvalue: i32, bignorecase: Param5) -> i321447 pub unsafe fn FindStringOrdinal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(dwfindstringordinalflags: u32, lpstringsource: Param1, cchsource: i32, lpstringvalue: Param3, cchvalue: i32, bignorecase: Param5) -> i32 {
1448     #[cfg(windows)]
1449     {
1450         #[link(name = "windows")]
1451         extern "system" {
1452             fn FindStringOrdinal(dwfindstringordinalflags: u32, lpstringsource: super::Foundation::PWSTR, cchsource: i32, lpstringvalue: super::Foundation::PWSTR, cchvalue: i32, bignorecase: super::Foundation::BOOL) -> i32;
1453         }
1454         ::std::mem::transmute(FindStringOrdinal(::std::mem::transmute(dwfindstringordinalflags), lpstringsource.into_param().abi(), ::std::mem::transmute(cchsource), lpstringvalue.into_param().abi(), ::std::mem::transmute(cchvalue), bignorecase.into_param().abi()))
1455     }
1456     #[cfg(not(windows))]
1457     unimplemented!("Unsupported target OS");
1458 }
1459 #[cfg(feature = "Win32_Foundation")]
1460 #[inline]
FoldStringA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: Param1, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i321461 pub unsafe fn FoldStringA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: Param1, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i32 {
1462     #[cfg(windows)]
1463     {
1464         #[link(name = "windows")]
1465         extern "system" {
1466             fn FoldStringA(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: super::Foundation::PSTR, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i32;
1467         }
1468         ::std::mem::transmute(FoldStringA(::std::mem::transmute(dwmapflags), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpdeststr), ::std::mem::transmute(cchdest)))
1469     }
1470     #[cfg(not(windows))]
1471     unimplemented!("Unsupported target OS");
1472 }
1473 #[cfg(feature = "Win32_Foundation")]
1474 #[inline]
FoldStringW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: Param1, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i321475 pub unsafe fn FoldStringW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: Param1, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i32 {
1476     #[cfg(windows)]
1477     {
1478         #[link(name = "windows")]
1479         extern "system" {
1480             fn FoldStringW(dwmapflags: FOLD_STRING_MAP_FLAGS, lpsrcstr: super::Foundation::PWSTR, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i32;
1481         }
1482         ::std::mem::transmute(FoldStringW(::std::mem::transmute(dwmapflags), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpdeststr), ::std::mem::transmute(cchdest)))
1483     }
1484     #[cfg(not(windows))]
1485     unimplemented!("Unsupported target OS");
1486 }
1487 pub const GEOID_NOT_AVAILABLE: i32 = -1i32;
1488 #[cfg(feature = "Win32_Foundation")]
1489 pub type GEO_ENUMNAMEPROC = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: super::Foundation::LPARAM) -> super::Foundation::BOOL;
1490 #[cfg(feature = "Win32_Foundation")]
1491 pub type GEO_ENUMPROC = unsafe extern "system" fn(param0: i32) -> super::Foundation::BOOL;
1492 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
1493 #[repr(C)]
1494 pub struct GOFFSET {
1495     pub du: i32,
1496     pub dv: i32,
1497 }
1498 impl GOFFSET {}
1499 impl ::std::default::Default for GOFFSET {
default() -> Self1500     fn default() -> Self {
1501         unsafe { ::std::mem::zeroed() }
1502     }
1503 }
1504 impl ::std::fmt::Debug for GOFFSET {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result1505     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1506         fmt.debug_struct("GOFFSET").field("du", &self.du).field("dv", &self.dv).finish()
1507     }
1508 }
1509 impl ::std::cmp::PartialEq for GOFFSET {
eq(&self, other: &Self) -> bool1510     fn eq(&self, other: &Self) -> bool {
1511         self.du == other.du && self.dv == other.dv
1512     }
1513 }
1514 impl ::std::cmp::Eq for GOFFSET {}
1515 unsafe impl ::windows::runtime::Abi for GOFFSET {
1516     type Abi = Self;
1517     type DefaultType = Self;
1518 }
1519 pub const GSS_ALLOW_INHERITED_COMMON: u32 = 1u32;
1520 #[inline]
GetACP() -> u321521 pub unsafe fn GetACP() -> u32 {
1522     #[cfg(windows)]
1523     {
1524         #[link(name = "windows")]
1525         extern "system" {
1526             fn GetACP() -> u32;
1527         }
1528         ::std::mem::transmute(GetACP())
1529     }
1530     #[cfg(not(windows))]
1531     unimplemented!("Unsupported target OS");
1532 }
1533 #[cfg(feature = "Win32_Foundation")]
1534 #[inline]
GetCPInfo(codepage: u32, lpcpinfo: *mut CPINFO) -> super::Foundation::BOOL1535 pub unsafe fn GetCPInfo(codepage: u32, lpcpinfo: *mut CPINFO) -> super::Foundation::BOOL {
1536     #[cfg(windows)]
1537     {
1538         #[link(name = "windows")]
1539         extern "system" {
1540             fn GetCPInfo(codepage: u32, lpcpinfo: *mut CPINFO) -> super::Foundation::BOOL;
1541         }
1542         ::std::mem::transmute(GetCPInfo(::std::mem::transmute(codepage), ::std::mem::transmute(lpcpinfo)))
1543     }
1544     #[cfg(not(windows))]
1545     unimplemented!("Unsupported target OS");
1546 }
1547 #[cfg(feature = "Win32_Foundation")]
1548 #[inline]
GetCPInfoExA(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXA) -> super::Foundation::BOOL1549 pub unsafe fn GetCPInfoExA(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXA) -> super::Foundation::BOOL {
1550     #[cfg(windows)]
1551     {
1552         #[link(name = "windows")]
1553         extern "system" {
1554             fn GetCPInfoExA(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXA) -> super::Foundation::BOOL;
1555         }
1556         ::std::mem::transmute(GetCPInfoExA(::std::mem::transmute(codepage), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpcpinfoex)))
1557     }
1558     #[cfg(not(windows))]
1559     unimplemented!("Unsupported target OS");
1560 }
1561 #[cfg(feature = "Win32_Foundation")]
1562 #[inline]
GetCPInfoExW(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXW) -> super::Foundation::BOOL1563 pub unsafe fn GetCPInfoExW(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXW) -> super::Foundation::BOOL {
1564     #[cfg(windows)]
1565     {
1566         #[link(name = "windows")]
1567         extern "system" {
1568             fn GetCPInfoExW(codepage: u32, dwflags: u32, lpcpinfoex: *mut CPINFOEXW) -> super::Foundation::BOOL;
1569         }
1570         ::std::mem::transmute(GetCPInfoExW(::std::mem::transmute(codepage), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpcpinfoex)))
1571     }
1572     #[cfg(not(windows))]
1573     unimplemented!("Unsupported target OS");
1574 }
1575 #[cfg(feature = "Win32_Foundation")]
1576 #[inline]
GetCalendarInfoA(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PSTR, cchdata: i32, lpvalue: *mut u32) -> i321577 pub unsafe fn GetCalendarInfoA(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PSTR, cchdata: i32, lpvalue: *mut u32) -> i32 {
1578     #[cfg(windows)]
1579     {
1580         #[link(name = "windows")]
1581         extern "system" {
1582             fn GetCalendarInfoA(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PSTR, cchdata: i32, lpvalue: *mut u32) -> i32;
1583         }
1584         ::std::mem::transmute(GetCalendarInfoA(::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype), ::std::mem::transmute(lpcaldata), ::std::mem::transmute(cchdata), ::std::mem::transmute(lpvalue)))
1585     }
1586     #[cfg(not(windows))]
1587     unimplemented!("Unsupported target OS");
1588 }
1589 #[cfg(feature = "Win32_Foundation")]
1590 #[inline]
GetCalendarInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, calendar: u32, lpreserved: Param2, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i321591 pub unsafe fn GetCalendarInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, calendar: u32, lpreserved: Param2, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i32 {
1592     #[cfg(windows)]
1593     {
1594         #[link(name = "windows")]
1595         extern "system" {
1596             fn GetCalendarInfoEx(lplocalename: super::Foundation::PWSTR, calendar: u32, lpreserved: super::Foundation::PWSTR, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i32;
1597         }
1598         ::std::mem::transmute(GetCalendarInfoEx(lplocalename.into_param().abi(), ::std::mem::transmute(calendar), lpreserved.into_param().abi(), ::std::mem::transmute(caltype), ::std::mem::transmute(lpcaldata), ::std::mem::transmute(cchdata), ::std::mem::transmute(lpvalue)))
1599     }
1600     #[cfg(not(windows))]
1601     unimplemented!("Unsupported target OS");
1602 }
1603 #[cfg(feature = "Win32_Foundation")]
1604 #[inline]
GetCalendarInfoW(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i321605 pub unsafe fn GetCalendarInfoW(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i32 {
1606     #[cfg(windows)]
1607     {
1608         #[link(name = "windows")]
1609         extern "system" {
1610             fn GetCalendarInfoW(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PWSTR, cchdata: i32, lpvalue: *mut u32) -> i32;
1611         }
1612         ::std::mem::transmute(GetCalendarInfoW(::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype), ::std::mem::transmute(lpcaldata), ::std::mem::transmute(cchdata), ::std::mem::transmute(lpvalue)))
1613     }
1614     #[cfg(not(windows))]
1615     unimplemented!("Unsupported target OS");
1616 }
1617 #[cfg(feature = "Win32_Foundation")]
1618 #[inline]
GetCurrencyFormatA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTA, lpcurrencystr: super::Foundation::PSTR, cchcurrency: i32) -> i321619 pub unsafe fn GetCurrencyFormatA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTA, lpcurrencystr: super::Foundation::PSTR, cchcurrency: i32) -> i32 {
1620     #[cfg(windows)]
1621     {
1622         #[link(name = "windows")]
1623         extern "system" {
1624             fn GetCurrencyFormatA(locale: u32, dwflags: u32, lpvalue: super::Foundation::PSTR, lpformat: *const CURRENCYFMTA, lpcurrencystr: super::Foundation::PSTR, cchcurrency: i32) -> i32;
1625         }
1626         ::std::mem::transmute(GetCurrencyFormatA(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpcurrencystr), ::std::mem::transmute(cchcurrency)))
1627     }
1628     #[cfg(not(windows))]
1629     unimplemented!("Unsupported target OS");
1630 }
1631 #[cfg(feature = "Win32_Foundation")]
1632 #[inline]
GetCurrencyFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i321633 pub unsafe fn GetCurrencyFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i32 {
1634     #[cfg(windows)]
1635     {
1636         #[link(name = "windows")]
1637         extern "system" {
1638             fn GetCurrencyFormatEx(lplocalename: super::Foundation::PWSTR, dwflags: u32, lpvalue: super::Foundation::PWSTR, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i32;
1639         }
1640         ::std::mem::transmute(GetCurrencyFormatEx(lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpcurrencystr), ::std::mem::transmute(cchcurrency)))
1641     }
1642     #[cfg(not(windows))]
1643     unimplemented!("Unsupported target OS");
1644 }
1645 #[cfg(feature = "Win32_Foundation")]
1646 #[inline]
GetCurrencyFormatW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i321647 pub unsafe fn GetCurrencyFormatW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i32 {
1648     #[cfg(windows)]
1649     {
1650         #[link(name = "windows")]
1651         extern "system" {
1652             fn GetCurrencyFormatW(locale: u32, dwflags: u32, lpvalue: super::Foundation::PWSTR, lpformat: *const CURRENCYFMTW, lpcurrencystr: super::Foundation::PWSTR, cchcurrency: i32) -> i32;
1653         }
1654         ::std::mem::transmute(GetCurrencyFormatW(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpcurrencystr), ::std::mem::transmute(cchcurrency)))
1655     }
1656     #[cfg(not(windows))]
1657     unimplemented!("Unsupported target OS");
1658 }
1659 #[cfg(feature = "Win32_Foundation")]
1660 #[inline]
GetDateFormatA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PSTR, cchdate: i32) -> i321661 pub unsafe fn GetDateFormatA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PSTR, cchdate: i32) -> i32 {
1662     #[cfg(windows)]
1663     {
1664         #[link(name = "windows")]
1665         extern "system" {
1666             fn GetDateFormatA(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PSTR, lpdatestr: super::Foundation::PSTR, cchdate: i32) -> i32;
1667         }
1668         ::std::mem::transmute(GetDateFormatA(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpdate), lpformat.into_param().abi(), ::std::mem::transmute(lpdatestr), ::std::mem::transmute(cchdate)))
1669     }
1670     #[cfg(not(windows))]
1671     unimplemented!("Unsupported target OS");
1672 }
1673 #[cfg(feature = "Win32_Foundation")]
1674 #[inline]
GetDateFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: ENUM_DATE_FORMATS_FLAGS, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PWSTR, cchdate: i32, lpcalendar: Param6) -> i321675 pub unsafe fn GetDateFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: ENUM_DATE_FORMATS_FLAGS, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PWSTR, cchdate: i32, lpcalendar: Param6) -> i32 {
1676     #[cfg(windows)]
1677     {
1678         #[link(name = "windows")]
1679         extern "system" {
1680             fn GetDateFormatEx(lplocalename: super::Foundation::PWSTR, dwflags: ENUM_DATE_FORMATS_FLAGS, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PWSTR, lpdatestr: super::Foundation::PWSTR, cchdate: i32, lpcalendar: super::Foundation::PWSTR) -> i32;
1681         }
1682         ::std::mem::transmute(GetDateFormatEx(lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpdate), lpformat.into_param().abi(), ::std::mem::transmute(lpdatestr), ::std::mem::transmute(cchdate), lpcalendar.into_param().abi()))
1683     }
1684     #[cfg(not(windows))]
1685     unimplemented!("Unsupported target OS");
1686 }
1687 #[cfg(feature = "Win32_Foundation")]
1688 #[inline]
GetDateFormatW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PWSTR, cchdate: i32) -> i321689 pub unsafe fn GetDateFormatW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lpdatestr: super::Foundation::PWSTR, cchdate: i32) -> i32 {
1690     #[cfg(windows)]
1691     {
1692         #[link(name = "windows")]
1693         extern "system" {
1694             fn GetDateFormatW(locale: u32, dwflags: u32, lpdate: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PWSTR, lpdatestr: super::Foundation::PWSTR, cchdate: i32) -> i32;
1695         }
1696         ::std::mem::transmute(GetDateFormatW(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpdate), lpformat.into_param().abi(), ::std::mem::transmute(lpdatestr), ::std::mem::transmute(cchdate)))
1697     }
1698     #[cfg(not(windows))]
1699     unimplemented!("Unsupported target OS");
1700 }
1701 #[cfg(feature = "Win32_Foundation")]
1702 #[inline]
GetDistanceOfClosestLanguageInList<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pszlanguage: Param0, pszlanguageslist: Param1, wchlistdelimiter: u16) -> ::windows::runtime::Result<f64>1703 pub unsafe fn GetDistanceOfClosestLanguageInList<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pszlanguage: Param0, pszlanguageslist: Param1, wchlistdelimiter: u16) -> ::windows::runtime::Result<f64> {
1704     #[cfg(windows)]
1705     {
1706         #[link(name = "windows")]
1707         extern "system" {
1708             fn GetDistanceOfClosestLanguageInList(pszlanguage: super::Foundation::PWSTR, pszlanguageslist: super::Foundation::PWSTR, wchlistdelimiter: u16, pclosestdistance: *mut f64) -> ::windows::runtime::HRESULT;
1709         }
1710         let mut result__: <f64 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
1711         GetDistanceOfClosestLanguageInList(pszlanguage.into_param().abi(), pszlanguageslist.into_param().abi(), ::std::mem::transmute(wchlistdelimiter), &mut result__).from_abi::<f64>(result__)
1712     }
1713     #[cfg(not(windows))]
1714     unimplemented!("Unsupported target OS");
1715 }
1716 #[cfg(feature = "Win32_Foundation")]
1717 #[inline]
GetDurationFormat<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: Param4, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i321718 pub unsafe fn GetDurationFormat<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: Param4, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i32 {
1719     #[cfg(windows)]
1720     {
1721         #[link(name = "windows")]
1722         extern "system" {
1723             fn GetDurationFormat(locale: u32, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: super::Foundation::PWSTR, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i32;
1724         }
1725         ::std::mem::transmute(GetDurationFormat(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpduration), ::std::mem::transmute(ullduration), lpformat.into_param().abi(), ::std::mem::transmute(lpdurationstr), ::std::mem::transmute(cchduration)))
1726     }
1727     #[cfg(not(windows))]
1728     unimplemented!("Unsupported target OS");
1729 }
1730 #[cfg(feature = "Win32_Foundation")]
1731 #[inline]
GetDurationFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: Param4, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i321732 pub unsafe fn GetDurationFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: Param4, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i32 {
1733     #[cfg(windows)]
1734     {
1735         #[link(name = "windows")]
1736         extern "system" {
1737             fn GetDurationFormatEx(lplocalename: super::Foundation::PWSTR, dwflags: u32, lpduration: *const super::Foundation::SYSTEMTIME, ullduration: u64, lpformat: super::Foundation::PWSTR, lpdurationstr: super::Foundation::PWSTR, cchduration: i32) -> i32;
1738         }
1739         ::std::mem::transmute(GetDurationFormatEx(lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpduration), ::std::mem::transmute(ullduration), lpformat.into_param().abi(), ::std::mem::transmute(lpdurationstr), ::std::mem::transmute(cchduration)))
1740     }
1741     #[cfg(not(windows))]
1742     unimplemented!("Unsupported target OS");
1743 }
1744 #[cfg(feature = "Win32_Foundation")]
1745 #[inline]
GetFileMUIInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwszfilepath: Param1, pfilemuiinfo: *mut FILEMUIINFO, pcbfilemuiinfo: *mut u32) -> super::Foundation::BOOL1746 pub unsafe fn GetFileMUIInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwszfilepath: Param1, pfilemuiinfo: *mut FILEMUIINFO, pcbfilemuiinfo: *mut u32) -> super::Foundation::BOOL {
1747     #[cfg(windows)]
1748     {
1749         #[link(name = "windows")]
1750         extern "system" {
1751             fn GetFileMUIInfo(dwflags: u32, pcwszfilepath: super::Foundation::PWSTR, pfilemuiinfo: *mut FILEMUIINFO, pcbfilemuiinfo: *mut u32) -> super::Foundation::BOOL;
1752         }
1753         ::std::mem::transmute(GetFileMUIInfo(::std::mem::transmute(dwflags), pcwszfilepath.into_param().abi(), ::std::mem::transmute(pfilemuiinfo), ::std::mem::transmute(pcbfilemuiinfo)))
1754     }
1755     #[cfg(not(windows))]
1756     unimplemented!("Unsupported target OS");
1757 }
1758 #[cfg(feature = "Win32_Foundation")]
1759 #[inline]
GetFileMUIPath<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwszfilepath: Param1, pwszlanguage: Param2, pcchlanguage: *mut u32, pwszfilemuipath: super::Foundation::PWSTR, pcchfilemuipath: *mut u32, pululenumerator: *mut u64) -> super::Foundation::BOOL1760 pub unsafe fn GetFileMUIPath<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwszfilepath: Param1, pwszlanguage: Param2, pcchlanguage: *mut u32, pwszfilemuipath: super::Foundation::PWSTR, pcchfilemuipath: *mut u32, pululenumerator: *mut u64) -> super::Foundation::BOOL {
1761     #[cfg(windows)]
1762     {
1763         #[link(name = "windows")]
1764         extern "system" {
1765             fn GetFileMUIPath(dwflags: u32, pcwszfilepath: super::Foundation::PWSTR, pwszlanguage: super::Foundation::PWSTR, pcchlanguage: *mut u32, pwszfilemuipath: super::Foundation::PWSTR, pcchfilemuipath: *mut u32, pululenumerator: *mut u64) -> super::Foundation::BOOL;
1766         }
1767         ::std::mem::transmute(GetFileMUIPath(::std::mem::transmute(dwflags), pcwszfilepath.into_param().abi(), pwszlanguage.into_param().abi(), ::std::mem::transmute(pcchlanguage), ::std::mem::transmute(pwszfilemuipath), ::std::mem::transmute(pcchfilemuipath), ::std::mem::transmute(pululenumerator)))
1768     }
1769     #[cfg(not(windows))]
1770     unimplemented!("Unsupported target OS");
1771 }
1772 #[cfg(feature = "Win32_Foundation")]
1773 #[inline]
GetGeoInfoA(location: i32, geotype: u32, lpgeodata: super::Foundation::PSTR, cchdata: i32, langid: u16) -> i321774 pub unsafe fn GetGeoInfoA(location: i32, geotype: u32, lpgeodata: super::Foundation::PSTR, cchdata: i32, langid: u16) -> i32 {
1775     #[cfg(windows)]
1776     {
1777         #[link(name = "windows")]
1778         extern "system" {
1779             fn GetGeoInfoA(location: i32, geotype: u32, lpgeodata: super::Foundation::PSTR, cchdata: i32, langid: u16) -> i32;
1780         }
1781         ::std::mem::transmute(GetGeoInfoA(::std::mem::transmute(location), ::std::mem::transmute(geotype), ::std::mem::transmute(lpgeodata), ::std::mem::transmute(cchdata), ::std::mem::transmute(langid)))
1782     }
1783     #[cfg(not(windows))]
1784     unimplemented!("Unsupported target OS");
1785 }
1786 #[cfg(feature = "Win32_Foundation")]
1787 #[inline]
GetGeoInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(location: Param0, geotype: u32, geodata: super::Foundation::PWSTR, geodatacount: i32) -> i321788 pub unsafe fn GetGeoInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(location: Param0, geotype: u32, geodata: super::Foundation::PWSTR, geodatacount: i32) -> i32 {
1789     #[cfg(windows)]
1790     {
1791         #[link(name = "windows")]
1792         extern "system" {
1793             fn GetGeoInfoEx(location: super::Foundation::PWSTR, geotype: u32, geodata: super::Foundation::PWSTR, geodatacount: i32) -> i32;
1794         }
1795         ::std::mem::transmute(GetGeoInfoEx(location.into_param().abi(), ::std::mem::transmute(geotype), ::std::mem::transmute(geodata), ::std::mem::transmute(geodatacount)))
1796     }
1797     #[cfg(not(windows))]
1798     unimplemented!("Unsupported target OS");
1799 }
1800 #[cfg(feature = "Win32_Foundation")]
1801 #[inline]
GetGeoInfoW(location: i32, geotype: u32, lpgeodata: super::Foundation::PWSTR, cchdata: i32, langid: u16) -> i321802 pub unsafe fn GetGeoInfoW(location: i32, geotype: u32, lpgeodata: super::Foundation::PWSTR, cchdata: i32, langid: u16) -> i32 {
1803     #[cfg(windows)]
1804     {
1805         #[link(name = "windows")]
1806         extern "system" {
1807             fn GetGeoInfoW(location: i32, geotype: u32, lpgeodata: super::Foundation::PWSTR, cchdata: i32, langid: u16) -> i32;
1808         }
1809         ::std::mem::transmute(GetGeoInfoW(::std::mem::transmute(location), ::std::mem::transmute(geotype), ::std::mem::transmute(lpgeodata), ::std::mem::transmute(cchdata), ::std::mem::transmute(langid)))
1810     }
1811     #[cfg(not(windows))]
1812     unimplemented!("Unsupported target OS");
1813 }
1814 #[cfg(feature = "Win32_Foundation")]
1815 #[inline]
GetLocaleInfoA(locale: u32, lctype: u32, lplcdata: super::Foundation::PSTR, cchdata: i32) -> i321816 pub unsafe fn GetLocaleInfoA(locale: u32, lctype: u32, lplcdata: super::Foundation::PSTR, cchdata: i32) -> i32 {
1817     #[cfg(windows)]
1818     {
1819         #[link(name = "windows")]
1820         extern "system" {
1821             fn GetLocaleInfoA(locale: u32, lctype: u32, lplcdata: super::Foundation::PSTR, cchdata: i32) -> i32;
1822         }
1823         ::std::mem::transmute(GetLocaleInfoA(::std::mem::transmute(locale), ::std::mem::transmute(lctype), ::std::mem::transmute(lplcdata), ::std::mem::transmute(cchdata)))
1824     }
1825     #[cfg(not(windows))]
1826     unimplemented!("Unsupported target OS");
1827 }
1828 #[cfg(feature = "Win32_Foundation")]
1829 #[inline]
GetLocaleInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i321830 pub unsafe fn GetLocaleInfoEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i32 {
1831     #[cfg(windows)]
1832     {
1833         #[link(name = "windows")]
1834         extern "system" {
1835             fn GetLocaleInfoEx(lplocalename: super::Foundation::PWSTR, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i32;
1836         }
1837         ::std::mem::transmute(GetLocaleInfoEx(lplocalename.into_param().abi(), ::std::mem::transmute(lctype), ::std::mem::transmute(lplcdata), ::std::mem::transmute(cchdata)))
1838     }
1839     #[cfg(not(windows))]
1840     unimplemented!("Unsupported target OS");
1841 }
1842 #[cfg(feature = "Win32_Foundation")]
1843 #[inline]
GetLocaleInfoW(locale: u32, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i321844 pub unsafe fn GetLocaleInfoW(locale: u32, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i32 {
1845     #[cfg(windows)]
1846     {
1847         #[link(name = "windows")]
1848         extern "system" {
1849             fn GetLocaleInfoW(locale: u32, lctype: u32, lplcdata: super::Foundation::PWSTR, cchdata: i32) -> i32;
1850         }
1851         ::std::mem::transmute(GetLocaleInfoW(::std::mem::transmute(locale), ::std::mem::transmute(lctype), ::std::mem::transmute(lplcdata), ::std::mem::transmute(cchdata)))
1852     }
1853     #[cfg(not(windows))]
1854     unimplemented!("Unsupported target OS");
1855 }
1856 #[cfg(feature = "Win32_Foundation")]
1857 #[inline]
GetNLSVersion(function: u32, locale: u32, lpversioninformation: *mut NLSVERSIONINFO) -> super::Foundation::BOOL1858 pub unsafe fn GetNLSVersion(function: u32, locale: u32, lpversioninformation: *mut NLSVERSIONINFO) -> super::Foundation::BOOL {
1859     #[cfg(windows)]
1860     {
1861         #[link(name = "windows")]
1862         extern "system" {
1863             fn GetNLSVersion(function: u32, locale: u32, lpversioninformation: *mut NLSVERSIONINFO) -> super::Foundation::BOOL;
1864         }
1865         ::std::mem::transmute(GetNLSVersion(::std::mem::transmute(function), ::std::mem::transmute(locale), ::std::mem::transmute(lpversioninformation)))
1866     }
1867     #[cfg(not(windows))]
1868     unimplemented!("Unsupported target OS");
1869 }
1870 #[cfg(feature = "Win32_Foundation")]
1871 #[inline]
GetNLSVersionEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, lplocalename: Param1, lpversioninformation: *mut NLSVERSIONINFOEX) -> super::Foundation::BOOL1872 pub unsafe fn GetNLSVersionEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, lplocalename: Param1, lpversioninformation: *mut NLSVERSIONINFOEX) -> super::Foundation::BOOL {
1873     #[cfg(windows)]
1874     {
1875         #[link(name = "windows")]
1876         extern "system" {
1877             fn GetNLSVersionEx(function: u32, lplocalename: super::Foundation::PWSTR, lpversioninformation: *mut NLSVERSIONINFOEX) -> super::Foundation::BOOL;
1878         }
1879         ::std::mem::transmute(GetNLSVersionEx(::std::mem::transmute(function), lplocalename.into_param().abi(), ::std::mem::transmute(lpversioninformation)))
1880     }
1881     #[cfg(not(windows))]
1882     unimplemented!("Unsupported target OS");
1883 }
1884 #[cfg(feature = "Win32_Foundation")]
1885 #[inline]
GetNumberFormatA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTA, lpnumberstr: super::Foundation::PSTR, cchnumber: i32) -> i321886 pub unsafe fn GetNumberFormatA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTA, lpnumberstr: super::Foundation::PSTR, cchnumber: i32) -> i32 {
1887     #[cfg(windows)]
1888     {
1889         #[link(name = "windows")]
1890         extern "system" {
1891             fn GetNumberFormatA(locale: u32, dwflags: u32, lpvalue: super::Foundation::PSTR, lpformat: *const NUMBERFMTA, lpnumberstr: super::Foundation::PSTR, cchnumber: i32) -> i32;
1892         }
1893         ::std::mem::transmute(GetNumberFormatA(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpnumberstr), ::std::mem::transmute(cchnumber)))
1894     }
1895     #[cfg(not(windows))]
1896     unimplemented!("Unsupported target OS");
1897 }
1898 #[cfg(feature = "Win32_Foundation")]
1899 #[inline]
GetNumberFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i321900 pub unsafe fn GetNumberFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i32 {
1901     #[cfg(windows)]
1902     {
1903         #[link(name = "windows")]
1904         extern "system" {
1905             fn GetNumberFormatEx(lplocalename: super::Foundation::PWSTR, dwflags: u32, lpvalue: super::Foundation::PWSTR, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i32;
1906         }
1907         ::std::mem::transmute(GetNumberFormatEx(lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpnumberstr), ::std::mem::transmute(cchnumber)))
1908     }
1909     #[cfg(not(windows))]
1910     unimplemented!("Unsupported target OS");
1911 }
1912 #[cfg(feature = "Win32_Foundation")]
1913 #[inline]
GetNumberFormatW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i321914 pub unsafe fn GetNumberFormatW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lpvalue: Param2, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i32 {
1915     #[cfg(windows)]
1916     {
1917         #[link(name = "windows")]
1918         extern "system" {
1919             fn GetNumberFormatW(locale: u32, dwflags: u32, lpvalue: super::Foundation::PWSTR, lpformat: *const NUMBERFMTW, lpnumberstr: super::Foundation::PWSTR, cchnumber: i32) -> i32;
1920         }
1921         ::std::mem::transmute(GetNumberFormatW(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), lpvalue.into_param().abi(), ::std::mem::transmute(lpformat), ::std::mem::transmute(lpnumberstr), ::std::mem::transmute(cchnumber)))
1922     }
1923     #[cfg(not(windows))]
1924     unimplemented!("Unsupported target OS");
1925 }
1926 #[inline]
GetOEMCP() -> u321927 pub unsafe fn GetOEMCP() -> u32 {
1928     #[cfg(windows)]
1929     {
1930         #[link(name = "windows")]
1931         extern "system" {
1932             fn GetOEMCP() -> u32;
1933         }
1934         ::std::mem::transmute(GetOEMCP())
1935     }
1936     #[cfg(not(windows))]
1937     unimplemented!("Unsupported target OS");
1938 }
1939 #[cfg(feature = "Win32_Foundation")]
1940 #[inline]
GetProcessPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL1941 pub unsafe fn GetProcessPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL {
1942     #[cfg(windows)]
1943     {
1944         #[link(name = "windows")]
1945         extern "system" {
1946             fn GetProcessPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL;
1947         }
1948         ::std::mem::transmute(GetProcessPreferredUILanguages(::std::mem::transmute(dwflags), ::std::mem::transmute(pulnumlanguages), ::std::mem::transmute(pwszlanguagesbuffer), ::std::mem::transmute(pcchlanguagesbuffer)))
1949     }
1950     #[cfg(not(windows))]
1951     unimplemented!("Unsupported target OS");
1952 }
1953 #[cfg(feature = "Win32_Foundation")]
1954 #[inline]
GetStringScripts<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpstring: Param1, cchstring: i32, lpscripts: super::Foundation::PWSTR, cchscripts: i32) -> i321955 pub unsafe fn GetStringScripts<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpstring: Param1, cchstring: i32, lpscripts: super::Foundation::PWSTR, cchscripts: i32) -> i32 {
1956     #[cfg(windows)]
1957     {
1958         #[link(name = "windows")]
1959         extern "system" {
1960             fn GetStringScripts(dwflags: u32, lpstring: super::Foundation::PWSTR, cchstring: i32, lpscripts: super::Foundation::PWSTR, cchscripts: i32) -> i32;
1961         }
1962         ::std::mem::transmute(GetStringScripts(::std::mem::transmute(dwflags), lpstring.into_param().abi(), ::std::mem::transmute(cchstring), ::std::mem::transmute(lpscripts), ::std::mem::transmute(cchscripts)))
1963     }
1964     #[cfg(not(windows))]
1965     unimplemented!("Unsupported target OS");
1966 }
1967 #[cfg(feature = "Win32_Foundation")]
1968 #[inline]
GetStringTypeA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL1969 pub unsafe fn GetStringTypeA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL {
1970     #[cfg(windows)]
1971     {
1972         #[link(name = "windows")]
1973         extern "system" {
1974             fn GetStringTypeA(locale: u32, dwinfotype: u32, lpsrcstr: super::Foundation::PSTR, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL;
1975         }
1976         ::std::mem::transmute(GetStringTypeA(::std::mem::transmute(locale), ::std::mem::transmute(dwinfotype), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpchartype)))
1977     }
1978     #[cfg(not(windows))]
1979     unimplemented!("Unsupported target OS");
1980 }
1981 #[cfg(feature = "Win32_Foundation")]
1982 #[inline]
GetStringTypeExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL1983 pub unsafe fn GetStringTypeExA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL {
1984     #[cfg(windows)]
1985     {
1986         #[link(name = "windows")]
1987         extern "system" {
1988             fn GetStringTypeExA(locale: u32, dwinfotype: u32, lpsrcstr: super::Foundation::PSTR, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL;
1989         }
1990         ::std::mem::transmute(GetStringTypeExA(::std::mem::transmute(locale), ::std::mem::transmute(dwinfotype), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpchartype)))
1991     }
1992     #[cfg(not(windows))]
1993     unimplemented!("Unsupported target OS");
1994 }
1995 #[cfg(feature = "Win32_Foundation")]
1996 #[inline]
GetStringTypeExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL1997 pub unsafe fn GetStringTypeExW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwinfotype: u32, lpsrcstr: Param2, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL {
1998     #[cfg(windows)]
1999     {
2000         #[link(name = "windows")]
2001         extern "system" {
2002             fn GetStringTypeExW(locale: u32, dwinfotype: u32, lpsrcstr: super::Foundation::PWSTR, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL;
2003         }
2004         ::std::mem::transmute(GetStringTypeExW(::std::mem::transmute(locale), ::std::mem::transmute(dwinfotype), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpchartype)))
2005     }
2006     #[cfg(not(windows))]
2007     unimplemented!("Unsupported target OS");
2008 }
2009 #[cfg(feature = "Win32_Foundation")]
2010 #[inline]
GetStringTypeW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwinfotype: u32, lpsrcstr: Param1, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL2011 pub unsafe fn GetStringTypeW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwinfotype: u32, lpsrcstr: Param1, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL {
2012     #[cfg(windows)]
2013     {
2014         #[link(name = "windows")]
2015         extern "system" {
2016             fn GetStringTypeW(dwinfotype: u32, lpsrcstr: super::Foundation::PWSTR, cchsrc: i32, lpchartype: *mut u16) -> super::Foundation::BOOL;
2017         }
2018         ::std::mem::transmute(GetStringTypeW(::std::mem::transmute(dwinfotype), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpchartype)))
2019     }
2020     #[cfg(not(windows))]
2021     unimplemented!("Unsupported target OS");
2022 }
2023 #[inline]
GetSystemDefaultLCID() -> u322024 pub unsafe fn GetSystemDefaultLCID() -> u32 {
2025     #[cfg(windows)]
2026     {
2027         #[link(name = "windows")]
2028         extern "system" {
2029             fn GetSystemDefaultLCID() -> u32;
2030         }
2031         ::std::mem::transmute(GetSystemDefaultLCID())
2032     }
2033     #[cfg(not(windows))]
2034     unimplemented!("Unsupported target OS");
2035 }
2036 #[inline]
GetSystemDefaultLangID() -> u162037 pub unsafe fn GetSystemDefaultLangID() -> u16 {
2038     #[cfg(windows)]
2039     {
2040         #[link(name = "windows")]
2041         extern "system" {
2042             fn GetSystemDefaultLangID() -> u16;
2043         }
2044         ::std::mem::transmute(GetSystemDefaultLangID())
2045     }
2046     #[cfg(not(windows))]
2047     unimplemented!("Unsupported target OS");
2048 }
2049 #[cfg(feature = "Win32_Foundation")]
2050 #[inline]
GetSystemDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i322051 pub unsafe fn GetSystemDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32 {
2052     #[cfg(windows)]
2053     {
2054         #[link(name = "windows")]
2055         extern "system" {
2056             fn GetSystemDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32;
2057         }
2058         ::std::mem::transmute(GetSystemDefaultLocaleName(::std::mem::transmute(lplocalename), ::std::mem::transmute(cchlocalename)))
2059     }
2060     #[cfg(not(windows))]
2061     unimplemented!("Unsupported target OS");
2062 }
2063 #[inline]
GetSystemDefaultUILanguage() -> u162064 pub unsafe fn GetSystemDefaultUILanguage() -> u16 {
2065     #[cfg(windows)]
2066     {
2067         #[link(name = "windows")]
2068         extern "system" {
2069             fn GetSystemDefaultUILanguage() -> u16;
2070         }
2071         ::std::mem::transmute(GetSystemDefaultUILanguage())
2072     }
2073     #[cfg(not(windows))]
2074     unimplemented!("Unsupported target OS");
2075 }
2076 #[cfg(feature = "Win32_Foundation")]
2077 #[inline]
GetSystemPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL2078 pub unsafe fn GetSystemPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL {
2079     #[cfg(windows)]
2080     {
2081         #[link(name = "windows")]
2082         extern "system" {
2083             fn GetSystemPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL;
2084         }
2085         ::std::mem::transmute(GetSystemPreferredUILanguages(::std::mem::transmute(dwflags), ::std::mem::transmute(pulnumlanguages), ::std::mem::transmute(pwszlanguagesbuffer), ::std::mem::transmute(pcchlanguagesbuffer)))
2086     }
2087     #[cfg(not(windows))]
2088     unimplemented!("Unsupported target OS");
2089 }
2090 #[cfg(feature = "Win32_Graphics_Gdi")]
2091 #[inline]
GetTextCharset<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0) -> i322092 pub unsafe fn GetTextCharset<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0) -> i32 {
2093     #[cfg(windows)]
2094     {
2095         #[link(name = "windows")]
2096         extern "system" {
2097             fn GetTextCharset(hdc: super::Graphics::Gdi::HDC) -> i32;
2098         }
2099         ::std::mem::transmute(GetTextCharset(hdc.into_param().abi()))
2100     }
2101     #[cfg(not(windows))]
2102     unimplemented!("Unsupported target OS");
2103 }
2104 #[cfg(feature = "Win32_Graphics_Gdi")]
2105 #[inline]
GetTextCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, lpsig: *mut FONTSIGNATURE, dwflags: u32) -> i322106 pub unsafe fn GetTextCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, lpsig: *mut FONTSIGNATURE, dwflags: u32) -> i32 {
2107     #[cfg(windows)]
2108     {
2109         #[link(name = "windows")]
2110         extern "system" {
2111             fn GetTextCharsetInfo(hdc: super::Graphics::Gdi::HDC, lpsig: *mut FONTSIGNATURE, dwflags: u32) -> i32;
2112         }
2113         ::std::mem::transmute(GetTextCharsetInfo(hdc.into_param().abi(), ::std::mem::transmute(lpsig), ::std::mem::transmute(dwflags)))
2114     }
2115     #[cfg(not(windows))]
2116     unimplemented!("Unsupported target OS");
2117 }
2118 #[inline]
GetThreadLocale() -> u322119 pub unsafe fn GetThreadLocale() -> u32 {
2120     #[cfg(windows)]
2121     {
2122         #[link(name = "windows")]
2123         extern "system" {
2124             fn GetThreadLocale() -> u32;
2125         }
2126         ::std::mem::transmute(GetThreadLocale())
2127     }
2128     #[cfg(not(windows))]
2129     unimplemented!("Unsupported target OS");
2130 }
2131 #[cfg(feature = "Win32_Foundation")]
2132 #[inline]
GetThreadPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL2133 pub unsafe fn GetThreadPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL {
2134     #[cfg(windows)]
2135     {
2136         #[link(name = "windows")]
2137         extern "system" {
2138             fn GetThreadPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL;
2139         }
2140         ::std::mem::transmute(GetThreadPreferredUILanguages(::std::mem::transmute(dwflags), ::std::mem::transmute(pulnumlanguages), ::std::mem::transmute(pwszlanguagesbuffer), ::std::mem::transmute(pcchlanguagesbuffer)))
2141     }
2142     #[cfg(not(windows))]
2143     unimplemented!("Unsupported target OS");
2144 }
2145 #[inline]
GetThreadUILanguage() -> u162146 pub unsafe fn GetThreadUILanguage() -> u16 {
2147     #[cfg(windows)]
2148     {
2149         #[link(name = "windows")]
2150         extern "system" {
2151             fn GetThreadUILanguage() -> u16;
2152         }
2153         ::std::mem::transmute(GetThreadUILanguage())
2154     }
2155     #[cfg(not(windows))]
2156     unimplemented!("Unsupported target OS");
2157 }
2158 #[cfg(feature = "Win32_Foundation")]
2159 #[inline]
GetTimeFormatA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PSTR, cchtime: i32) -> i322160 pub unsafe fn GetTimeFormatA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PSTR, cchtime: i32) -> i32 {
2161     #[cfg(windows)]
2162     {
2163         #[link(name = "windows")]
2164         extern "system" {
2165             fn GetTimeFormatA(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PSTR, lptimestr: super::Foundation::PSTR, cchtime: i32) -> i32;
2166         }
2167         ::std::mem::transmute(GetTimeFormatA(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), ::std::mem::transmute(lptime), lpformat.into_param().abi(), ::std::mem::transmute(lptimestr), ::std::mem::transmute(cchtime)))
2168     }
2169     #[cfg(not(windows))]
2170     unimplemented!("Unsupported target OS");
2171 }
2172 #[cfg(feature = "Win32_Foundation")]
2173 #[inline]
GetTimeFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: TIME_FORMAT_FLAGS, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i322174 pub unsafe fn GetTimeFormatEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0, dwflags: TIME_FORMAT_FLAGS, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i32 {
2175     #[cfg(windows)]
2176     {
2177         #[link(name = "windows")]
2178         extern "system" {
2179             fn GetTimeFormatEx(lplocalename: super::Foundation::PWSTR, dwflags: TIME_FORMAT_FLAGS, lptime: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PWSTR, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i32;
2180         }
2181         ::std::mem::transmute(GetTimeFormatEx(lplocalename.into_param().abi(), ::std::mem::transmute(dwflags), ::std::mem::transmute(lptime), lpformat.into_param().abi(), ::std::mem::transmute(lptimestr), ::std::mem::transmute(cchtime)))
2182     }
2183     #[cfg(not(windows))]
2184     unimplemented!("Unsupported target OS");
2185 }
2186 #[cfg(feature = "Win32_Foundation")]
2187 #[inline]
GetTimeFormatW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i322188 pub unsafe fn GetTimeFormatW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: Param3, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i32 {
2189     #[cfg(windows)]
2190     {
2191         #[link(name = "windows")]
2192         extern "system" {
2193             fn GetTimeFormatW(locale: u32, dwflags: u32, lptime: *const super::Foundation::SYSTEMTIME, lpformat: super::Foundation::PWSTR, lptimestr: super::Foundation::PWSTR, cchtime: i32) -> i32;
2194         }
2195         ::std::mem::transmute(GetTimeFormatW(::std::mem::transmute(locale), ::std::mem::transmute(dwflags), ::std::mem::transmute(lptime), lpformat.into_param().abi(), ::std::mem::transmute(lptimestr), ::std::mem::transmute(cchtime)))
2196     }
2197     #[cfg(not(windows))]
2198     unimplemented!("Unsupported target OS");
2199 }
2200 #[cfg(feature = "Win32_Foundation")]
2201 #[inline]
GetUILanguageInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwmszlanguage: Param1, pwszfallbacklanguages: super::Foundation::PWSTR, pcchfallbacklanguages: *mut u32, pattributes: *mut u32) -> super::Foundation::BOOL2202 pub unsafe fn GetUILanguageInfo<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwmszlanguage: Param1, pwszfallbacklanguages: super::Foundation::PWSTR, pcchfallbacklanguages: *mut u32, pattributes: *mut u32) -> super::Foundation::BOOL {
2203     #[cfg(windows)]
2204     {
2205         #[link(name = "windows")]
2206         extern "system" {
2207             fn GetUILanguageInfo(dwflags: u32, pwmszlanguage: super::Foundation::PWSTR, pwszfallbacklanguages: super::Foundation::PWSTR, pcchfallbacklanguages: *mut u32, pattributes: *mut u32) -> super::Foundation::BOOL;
2208         }
2209         ::std::mem::transmute(GetUILanguageInfo(::std::mem::transmute(dwflags), pwmszlanguage.into_param().abi(), ::std::mem::transmute(pwszfallbacklanguages), ::std::mem::transmute(pcchfallbacklanguages), ::std::mem::transmute(pattributes)))
2210     }
2211     #[cfg(not(windows))]
2212     unimplemented!("Unsupported target OS");
2213 }
2214 #[cfg(feature = "Win32_Foundation")]
2215 #[inline]
GetUserDefaultGeoName(geoname: super::Foundation::PWSTR, geonamecount: i32) -> i322216 pub unsafe fn GetUserDefaultGeoName(geoname: super::Foundation::PWSTR, geonamecount: i32) -> i32 {
2217     #[cfg(windows)]
2218     {
2219         #[link(name = "windows")]
2220         extern "system" {
2221             fn GetUserDefaultGeoName(geoname: super::Foundation::PWSTR, geonamecount: i32) -> i32;
2222         }
2223         ::std::mem::transmute(GetUserDefaultGeoName(::std::mem::transmute(geoname), ::std::mem::transmute(geonamecount)))
2224     }
2225     #[cfg(not(windows))]
2226     unimplemented!("Unsupported target OS");
2227 }
2228 #[inline]
GetUserDefaultLCID() -> u322229 pub unsafe fn GetUserDefaultLCID() -> u32 {
2230     #[cfg(windows)]
2231     {
2232         #[link(name = "windows")]
2233         extern "system" {
2234             fn GetUserDefaultLCID() -> u32;
2235         }
2236         ::std::mem::transmute(GetUserDefaultLCID())
2237     }
2238     #[cfg(not(windows))]
2239     unimplemented!("Unsupported target OS");
2240 }
2241 #[inline]
GetUserDefaultLangID() -> u162242 pub unsafe fn GetUserDefaultLangID() -> u16 {
2243     #[cfg(windows)]
2244     {
2245         #[link(name = "windows")]
2246         extern "system" {
2247             fn GetUserDefaultLangID() -> u16;
2248         }
2249         ::std::mem::transmute(GetUserDefaultLangID())
2250     }
2251     #[cfg(not(windows))]
2252     unimplemented!("Unsupported target OS");
2253 }
2254 #[cfg(feature = "Win32_Foundation")]
2255 #[inline]
GetUserDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i322256 pub unsafe fn GetUserDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32 {
2257     #[cfg(windows)]
2258     {
2259         #[link(name = "windows")]
2260         extern "system" {
2261             fn GetUserDefaultLocaleName(lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32;
2262         }
2263         ::std::mem::transmute(GetUserDefaultLocaleName(::std::mem::transmute(lplocalename), ::std::mem::transmute(cchlocalename)))
2264     }
2265     #[cfg(not(windows))]
2266     unimplemented!("Unsupported target OS");
2267 }
2268 #[inline]
GetUserDefaultUILanguage() -> u162269 pub unsafe fn GetUserDefaultUILanguage() -> u16 {
2270     #[cfg(windows)]
2271     {
2272         #[link(name = "windows")]
2273         extern "system" {
2274             fn GetUserDefaultUILanguage() -> u16;
2275         }
2276         ::std::mem::transmute(GetUserDefaultUILanguage())
2277     }
2278     #[cfg(not(windows))]
2279     unimplemented!("Unsupported target OS");
2280 }
2281 #[inline]
GetUserGeoID(geoclass: u32) -> i322282 pub unsafe fn GetUserGeoID(geoclass: u32) -> i32 {
2283     #[cfg(windows)]
2284     {
2285         #[link(name = "windows")]
2286         extern "system" {
2287             fn GetUserGeoID(geoclass: u32) -> i32;
2288         }
2289         ::std::mem::transmute(GetUserGeoID(::std::mem::transmute(geoclass)))
2290     }
2291     #[cfg(not(windows))]
2292     unimplemented!("Unsupported target OS");
2293 }
2294 #[cfg(feature = "Win32_Foundation")]
2295 #[inline]
GetUserPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL2296 pub unsafe fn GetUserPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL {
2297     #[cfg(windows)]
2298     {
2299         #[link(name = "windows")]
2300         extern "system" {
2301             fn GetUserPreferredUILanguages(dwflags: u32, pulnumlanguages: *mut u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pcchlanguagesbuffer: *mut u32) -> super::Foundation::BOOL;
2302         }
2303         ::std::mem::transmute(GetUserPreferredUILanguages(::std::mem::transmute(dwflags), ::std::mem::transmute(pulnumlanguages), ::std::mem::transmute(pwszlanguagesbuffer), ::std::mem::transmute(pcchlanguagesbuffer)))
2304     }
2305     #[cfg(not(windows))]
2306     unimplemented!("Unsupported target OS");
2307 }
2308 pub const HIGHLEVEL_SERVICE_TYPES: u32 = 1u32;
2309 pub const HIGH_SURROGATE_END: u32 = 56319u32;
2310 pub const HIGH_SURROGATE_START: u32 = 55296u32;
2311 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2312 #[repr(transparent)]
2313 pub struct HIMC(pub isize);
2314 impl ::std::default::Default for HIMC {
default() -> Self2315     fn default() -> Self {
2316         unsafe { ::std::mem::zeroed() }
2317     }
2318 }
2319 unsafe impl ::windows::runtime::Handle for HIMC {}
2320 unsafe impl ::windows::runtime::Abi for HIMC {
2321     type Abi = Self;
2322     type DefaultType = Self;
2323 }
2324 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2325 #[repr(transparent)]
2326 pub struct HIMCC(pub isize);
2327 impl ::std::default::Default for HIMCC {
default() -> Self2328     fn default() -> Self {
2329         unsafe { ::std::mem::zeroed() }
2330     }
2331 }
2332 unsafe impl ::windows::runtime::Handle for HIMCC {}
2333 unsafe impl ::windows::runtime::Abi for HIMCC {
2334     type Abi = Self;
2335     type DefaultType = Self;
2336 }
2337 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq)]
2338 #[repr(transparent)]
2339 pub struct HSAVEDUILANGUAGES(pub isize);
2340 impl ::std::default::Default for HSAVEDUILANGUAGES {
default() -> Self2341     fn default() -> Self {
2342         unsafe { ::std::mem::zeroed() }
2343     }
2344 }
2345 unsafe impl ::windows::runtime::Handle for HSAVEDUILANGUAGES {}
2346 unsafe impl ::windows::runtime::Abi for HSAVEDUILANGUAGES {
2347     type Abi = Self;
2348     type DefaultType = Self;
2349 }
2350 #[repr(transparent)]
2351 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2352 pub struct IComprehensiveSpellCheckProvider(::windows::runtime::IUnknown);
2353 impl IComprehensiveSpellCheckProvider {
2354     #[cfg(feature = "Win32_Foundation")]
ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>2355     pub unsafe fn ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
2356         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2357         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
2358     }
2359 }
2360 unsafe impl ::windows::runtime::Interface for IComprehensiveSpellCheckProvider {
2361     type Vtable = IComprehensiveSpellCheckProvider_abi;
2362     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(207157470, 36500, 18334, [151, 23, 112, 196, 44, 74, 210, 195]);
2363 }
2364 impl ::std::convert::From<IComprehensiveSpellCheckProvider> for ::windows::runtime::IUnknown {
from(value: IComprehensiveSpellCheckProvider) -> Self2365     fn from(value: IComprehensiveSpellCheckProvider) -> Self {
2366         unsafe { ::std::mem::transmute(value) }
2367     }
2368 }
2369 impl ::std::convert::From<&IComprehensiveSpellCheckProvider> for ::windows::runtime::IUnknown {
from(value: &IComprehensiveSpellCheckProvider) -> Self2370     fn from(value: &IComprehensiveSpellCheckProvider) -> Self {
2371         ::std::convert::From::from(::std::clone::Clone::clone(value))
2372     }
2373 }
2374 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IComprehensiveSpellCheckProvider {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2375     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2376         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2377     }
2378 }
2379 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IComprehensiveSpellCheckProvider {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2380     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2381         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2382     }
2383 }
2384 #[repr(C)]
2385 #[doc(hidden)]
2386 pub struct IComprehensiveSpellCheckProvider_abi(
2387     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2388     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2389     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2390     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2391     #[cfg(not(feature = "Win32_Foundation"))] usize,
2392 );
2393 pub const IDN_ALLOW_UNASSIGNED: u32 = 1u32;
2394 pub const IDN_EMAIL_ADDRESS: u32 = 4u32;
2395 pub const IDN_RAW_PUNYCODE: u32 = 8u32;
2396 pub const IDN_USE_STD3_ASCII_RULES: u32 = 2u32;
2397 #[repr(transparent)]
2398 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2399 pub struct IEnumCodePage(::windows::runtime::IUnknown);
2400 impl IEnumCodePage {
Clone(&self) -> ::windows::runtime::Result<IEnumCodePage>2401     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumCodePage> {
2402         let mut result__: <IEnumCodePage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2403         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumCodePage>(result__)
2404     }
Next(&self, celt: u32, rgelt: *mut MIMECPINFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>2405     pub unsafe fn Next(&self, celt: u32, rgelt: *mut MIMECPINFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
2406         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
2407     }
Reset(&self) -> ::windows::runtime::Result<()>2408     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2409         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2410     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>2411     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
2412         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
2413     }
2414 }
2415 unsafe impl ::windows::runtime::Interface for IEnumCodePage {
2416     type Vtable = IEnumCodePage_abi;
2417     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(660349923, 14151, 4560, [159, 234, 0, 170, 0, 63, 134, 70]);
2418 }
2419 impl ::std::convert::From<IEnumCodePage> for ::windows::runtime::IUnknown {
from(value: IEnumCodePage) -> Self2420     fn from(value: IEnumCodePage) -> Self {
2421         unsafe { ::std::mem::transmute(value) }
2422     }
2423 }
2424 impl ::std::convert::From<&IEnumCodePage> for ::windows::runtime::IUnknown {
from(value: &IEnumCodePage) -> Self2425     fn from(value: &IEnumCodePage) -> Self {
2426         ::std::convert::From::from(::std::clone::Clone::clone(value))
2427     }
2428 }
2429 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumCodePage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2430     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2431         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2432     }
2433 }
2434 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumCodePage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2435     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2436         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2437     }
2438 }
2439 #[repr(C)]
2440 #[doc(hidden)]
2441 pub struct IEnumCodePage_abi(
2442     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2443     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2444     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2445     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2446     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut MIMECPINFO, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
2447     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2448     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
2449 );
2450 #[repr(transparent)]
2451 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2452 pub struct IEnumRfc1766(::windows::runtime::IUnknown);
2453 impl IEnumRfc1766 {
Clone(&self) -> ::windows::runtime::Result<IEnumRfc1766>2454     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumRfc1766> {
2455         let mut result__: <IEnumRfc1766 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2456         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRfc1766>(result__)
2457     }
Next(&self, celt: u32, rgelt: *mut RFC1766INFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>2458     pub unsafe fn Next(&self, celt: u32, rgelt: *mut RFC1766INFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
2459         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
2460     }
Reset(&self) -> ::windows::runtime::Result<()>2461     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2462         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2463     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>2464     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
2465         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
2466     }
2467 }
2468 unsafe impl ::windows::runtime::Interface for IEnumRfc1766 {
2469     type Vtable = IEnumRfc1766_abi;
2470     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1036229917, 49200, 4560, [184, 27, 0, 192, 79, 201, 179, 31]);
2471 }
2472 impl ::std::convert::From<IEnumRfc1766> for ::windows::runtime::IUnknown {
from(value: IEnumRfc1766) -> Self2473     fn from(value: IEnumRfc1766) -> Self {
2474         unsafe { ::std::mem::transmute(value) }
2475     }
2476 }
2477 impl ::std::convert::From<&IEnumRfc1766> for ::windows::runtime::IUnknown {
from(value: &IEnumRfc1766) -> Self2478     fn from(value: &IEnumRfc1766) -> Self {
2479         ::std::convert::From::from(::std::clone::Clone::clone(value))
2480     }
2481 }
2482 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumRfc1766 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2483     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2484         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2485     }
2486 }
2487 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumRfc1766 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2488     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2489         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2490     }
2491 }
2492 #[repr(C)]
2493 #[doc(hidden)]
2494 pub struct IEnumRfc1766_abi(
2495     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2496     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2497     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2498     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2499     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut RFC1766INFO, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
2500     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2501     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
2502 );
2503 #[repr(transparent)]
2504 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2505 pub struct IEnumScript(::windows::runtime::IUnknown);
2506 impl IEnumScript {
Clone(&self) -> ::windows::runtime::Result<IEnumScript>2507     pub unsafe fn Clone(&self) -> ::windows::runtime::Result<IEnumScript> {
2508         let mut result__: <IEnumScript as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2509         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumScript>(result__)
2510     }
Next(&self, celt: u32, rgelt: *mut SCRIPTINFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()>2511     pub unsafe fn Next(&self, celt: u32, rgelt: *mut SCRIPTINFO, pceltfetched: *mut u32) -> ::windows::runtime::Result<()> {
2512         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt), ::std::mem::transmute(rgelt), ::std::mem::transmute(pceltfetched)).ok()
2513     }
Reset(&self) -> ::windows::runtime::Result<()>2514     pub unsafe fn Reset(&self) -> ::windows::runtime::Result<()> {
2515         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self)).ok()
2516     }
Skip(&self, celt: u32) -> ::windows::runtime::Result<()>2517     pub unsafe fn Skip(&self, celt: u32) -> ::windows::runtime::Result<()> {
2518         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(celt)).ok()
2519     }
2520 }
2521 unsafe impl ::windows::runtime::Interface for IEnumScript {
2522     type Vtable = IEnumScript_abi;
2523     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2925466672, 14475, 4562, [131, 128, 0, 192, 79, 143, 93, 161]);
2524 }
2525 impl ::std::convert::From<IEnumScript> for ::windows::runtime::IUnknown {
from(value: IEnumScript) -> Self2526     fn from(value: IEnumScript) -> Self {
2527         unsafe { ::std::mem::transmute(value) }
2528     }
2529 }
2530 impl ::std::convert::From<&IEnumScript> for ::windows::runtime::IUnknown {
from(value: &IEnumScript) -> Self2531     fn from(value: &IEnumScript) -> Self {
2532         ::std::convert::From::from(::std::clone::Clone::clone(value))
2533     }
2534 }
2535 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumScript {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2536     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2537         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2538     }
2539 }
2540 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumScript {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2541     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2542         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2543     }
2544 }
2545 #[repr(C)]
2546 #[doc(hidden)]
2547 pub struct IEnumScript_abi(
2548     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2549     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2550     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2551     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenum: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2552     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32, rgelt: *mut SCRIPTINFO, pceltfetched: *mut u32) -> ::windows::runtime::HRESULT,
2553     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2554     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, celt: u32) -> ::windows::runtime::HRESULT,
2555 );
2556 #[repr(transparent)]
2557 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2558 pub struct IEnumSpellingError(::windows::runtime::IUnknown);
2559 impl IEnumSpellingError {
Next(&self) -> ::windows::runtime::Result<ISpellingError>2560     pub unsafe fn Next(&self) -> ::windows::runtime::Result<ISpellingError> {
2561         let mut result__: <ISpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2562         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<ISpellingError>(result__)
2563     }
2564 }
2565 unsafe impl ::windows::runtime::Interface for IEnumSpellingError {
2566     type Vtable = IEnumSpellingError_abi;
2567     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2151562196, 10280, 17424, [130, 144, 65, 141, 29, 115, 199, 98]);
2568 }
2569 impl ::std::convert::From<IEnumSpellingError> for ::windows::runtime::IUnknown {
from(value: IEnumSpellingError) -> Self2570     fn from(value: IEnumSpellingError) -> Self {
2571         unsafe { ::std::mem::transmute(value) }
2572     }
2573 }
2574 impl ::std::convert::From<&IEnumSpellingError> for ::windows::runtime::IUnknown {
from(value: &IEnumSpellingError) -> Self2575     fn from(value: &IEnumSpellingError) -> Self {
2576         ::std::convert::From::from(::std::clone::Clone::clone(value))
2577     }
2578 }
2579 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IEnumSpellingError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2580     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2581         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2582     }
2583 }
2584 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IEnumSpellingError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2585     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2586         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2587     }
2588 }
2589 #[repr(C)]
2590 #[doc(hidden)]
2591 pub struct IEnumSpellingError_abi(
2592     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2593     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2594     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2595     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2596 );
2597 pub const IME_CMODE_ALPHANUMERIC: u32 = 0u32;
2598 pub const IME_CMODE_CHARCODE: u32 = 32u32;
2599 pub const IME_CMODE_CHINESE: u32 = 1u32;
2600 pub const IME_CMODE_FULLSHAPE: u32 = 8u32;
2601 pub const IME_CMODE_HANGUL: u32 = 1u32;
2602 pub const IME_CMODE_HANJACONVERT: u32 = 64u32;
2603 pub const IME_CMODE_JAPANESE: u32 = 1u32;
2604 pub const IME_CMODE_KATAKANA: u32 = 2u32;
2605 pub const IME_CMODE_LANGUAGE: u32 = 3u32;
2606 pub const IME_CMODE_NATIVE: u32 = 1u32;
2607 pub const IME_CMODE_NATIVESYMBOL: u32 = 128u32;
2608 pub const IME_CMODE_ROMAN: u32 = 16u32;
2609 #[repr(transparent)]
2610 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2611 pub struct IMLangCodePages(::windows::runtime::IUnknown);
2612 impl IMLangCodePages {
GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32>2613     pub unsafe fn GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32> {
2614         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2615         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(chsrc), &mut result__).from_abi::<u32>(result__)
2616     }
2617     #[cfg(feature = "Win32_Foundation")]
GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()>2618     pub unsafe fn GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()> {
2619         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(dwprioritycodepages), ::std::mem::transmute(pdwcodepages), ::std::mem::transmute(pcchcodepages)).ok()
2620     }
CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32>2621     pub unsafe fn CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32> {
2622         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2623         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ucodepage), &mut result__).from_abi::<u32>(result__)
2624     }
CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32>2625     pub unsafe fn CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32> {
2626         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2627         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwcodepages), ::std::mem::transmute(udefaultcodepage), &mut result__).from_abi::<u32>(result__)
2628     }
2629 }
2630 unsafe impl ::windows::runtime::Interface for IMLangCodePages {
2631     type Vtable = IMLangCodePages_abi;
2632     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(899626051, 48458, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
2633 }
2634 impl ::std::convert::From<IMLangCodePages> for ::windows::runtime::IUnknown {
from(value: IMLangCodePages) -> Self2635     fn from(value: IMLangCodePages) -> Self {
2636         unsafe { ::std::mem::transmute(value) }
2637     }
2638 }
2639 impl ::std::convert::From<&IMLangCodePages> for ::windows::runtime::IUnknown {
from(value: &IMLangCodePages) -> Self2640     fn from(value: &IMLangCodePages) -> Self {
2641         ::std::convert::From::from(::std::clone::Clone::clone(value))
2642     }
2643 }
2644 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangCodePages {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2645     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2646         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2647     }
2648 }
2649 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangCodePages {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2650     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2651         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2652     }
2653 }
2654 #[repr(C)]
2655 #[doc(hidden)]
2656 pub struct IMLangCodePages_abi(
2657     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2658     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2659     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2660     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, chsrc: u16, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2661     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszsrc: super::Foundation::PWSTR, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::HRESULT,
2662     #[cfg(not(feature = "Win32_Foundation"))] usize,
2663     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ucodepage: u32, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2664     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwcodepages: u32, udefaultcodepage: u32, pucodepage: *mut u32) -> ::windows::runtime::HRESULT,
2665 );
2666 #[repr(transparent)]
2667 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2668 pub struct IMLangConvertCharset(::windows::runtime::IUnknown);
2669 impl IMLangConvertCharset {
Initialize(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<()>2670     pub unsafe fn Initialize(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<()> {
2671         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(uisrccodepage), ::std::mem::transmute(uidstcodepage), ::std::mem::transmute(dwproperty)).ok()
2672     }
GetSourceCodePage(&self) -> ::windows::runtime::Result<u32>2673     pub unsafe fn GetSourceCodePage(&self) -> ::windows::runtime::Result<u32> {
2674         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2675         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
2676     }
GetDestinationCodePage(&self) -> ::windows::runtime::Result<u32>2677     pub unsafe fn GetDestinationCodePage(&self) -> ::windows::runtime::Result<u32> {
2678         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2679         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
2680     }
GetProperty(&self) -> ::windows::runtime::Result<u32>2681     pub unsafe fn GetProperty(&self) -> ::windows::runtime::Result<u32> {
2682         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2683         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
2684     }
DoConversion(&self, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>2685     pub unsafe fn DoConversion(&self, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
2686         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(psrcstr), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
2687     }
2688     #[cfg(feature = "Win32_Foundation")]
DoConversionToUnicode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, psrcstr: Param0, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>2689     pub unsafe fn DoConversionToUnicode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, psrcstr: Param0, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
2690         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
2691     }
2692     #[cfg(feature = "Win32_Foundation")]
DoConversionFromUnicode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, psrcstr: Param0, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>2693     pub unsafe fn DoConversionFromUnicode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, psrcstr: Param0, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
2694         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
2695     }
2696 }
2697 unsafe impl ::windows::runtime::Interface for IMLangConvertCharset {
2698     type Vtable = IMLangConvertCharset_abi;
2699     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3597496216, 52650, 4560, [184, 34, 0, 192, 79, 201, 179, 31]);
2700 }
2701 impl ::std::convert::From<IMLangConvertCharset> for ::windows::runtime::IUnknown {
from(value: IMLangConvertCharset) -> Self2702     fn from(value: IMLangConvertCharset) -> Self {
2703         unsafe { ::std::mem::transmute(value) }
2704     }
2705 }
2706 impl ::std::convert::From<&IMLangConvertCharset> for ::windows::runtime::IUnknown {
from(value: &IMLangConvertCharset) -> Self2707     fn from(value: &IMLangConvertCharset) -> Self {
2708         ::std::convert::From::from(::std::clone::Clone::clone(value))
2709     }
2710 }
2711 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangConvertCharset {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2712     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2713         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2714     }
2715 }
2716 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangConvertCharset {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2717     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2718         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2719     }
2720 }
2721 #[repr(C)]
2722 #[doc(hidden)]
2723 pub struct IMLangConvertCharset_abi(
2724     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2725     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2726     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2727     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::HRESULT,
2728     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, puisrccodepage: *mut u32) -> ::windows::runtime::HRESULT,
2729     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, puidstcodepage: *mut u32) -> ::windows::runtime::HRESULT,
2730     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwproperty: *mut u32) -> ::windows::runtime::HRESULT,
2731     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
2732     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
2733     #[cfg(not(feature = "Win32_Foundation"))] usize,
2734     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
2735     #[cfg(not(feature = "Win32_Foundation"))] usize,
2736 );
2737 #[repr(transparent)]
2738 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2739 pub struct IMLangFontLink(::windows::runtime::IUnknown);
2740 impl IMLangFontLink {
GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32>2741     pub unsafe fn GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32> {
2742         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2743         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(chsrc), &mut result__).from_abi::<u32>(result__)
2744     }
2745     #[cfg(feature = "Win32_Foundation")]
GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()>2746     pub unsafe fn GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()> {
2747         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(dwprioritycodepages), ::std::mem::transmute(pdwcodepages), ::std::mem::transmute(pcchcodepages)).ok()
2748     }
CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32>2749     pub unsafe fn CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32> {
2750         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2751         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ucodepage), &mut result__).from_abi::<u32>(result__)
2752     }
CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32>2753     pub unsafe fn CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32> {
2754         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2755         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwcodepages), ::std::mem::transmute(udefaultcodepage), &mut result__).from_abi::<u32>(result__)
2756     }
2757     #[cfg(feature = "Win32_Graphics_Gdi")]
GetFontCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, hfont: Param1) -> ::windows::runtime::Result<u32>2758     pub unsafe fn GetFontCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, hfont: Param1) -> ::windows::runtime::Result<u32> {
2759         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2760         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), hdc.into_param().abi(), hfont.into_param().abi(), &mut result__).from_abi::<u32>(result__)
2761     }
2762     #[cfg(feature = "Win32_Graphics_Gdi")]
MapFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, dwcodepages: u32, hsrcfont: Param2) -> ::windows::runtime::Result<super::Graphics::Gdi::HFONT>2763     pub unsafe fn MapFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, dwcodepages: u32, hsrcfont: Param2) -> ::windows::runtime::Result<super::Graphics::Gdi::HFONT> {
2764         let mut result__: <super::Graphics::Gdi::HFONT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2765         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), hdc.into_param().abi(), ::std::mem::transmute(dwcodepages), hsrcfont.into_param().abi(), &mut result__).from_abi::<super::Graphics::Gdi::HFONT>(result__)
2766     }
2767     #[cfg(feature = "Win32_Graphics_Gdi")]
ReleaseFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hfont: Param0) -> ::windows::runtime::Result<()>2768     pub unsafe fn ReleaseFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hfont: Param0) -> ::windows::runtime::Result<()> {
2769         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), hfont.into_param().abi()).ok()
2770     }
ResetFontMapping(&self) -> ::windows::runtime::Result<()>2771     pub unsafe fn ResetFontMapping(&self) -> ::windows::runtime::Result<()> {
2772         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self)).ok()
2773     }
2774 }
2775 unsafe impl ::windows::runtime::Interface for IMLangFontLink {
2776     type Vtable = IMLangFontLink_abi;
2777     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(899626049, 48458, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
2778 }
2779 impl ::std::convert::From<IMLangFontLink> for ::windows::runtime::IUnknown {
from(value: IMLangFontLink) -> Self2780     fn from(value: IMLangFontLink) -> Self {
2781         unsafe { ::std::mem::transmute(value) }
2782     }
2783 }
2784 impl ::std::convert::From<&IMLangFontLink> for ::windows::runtime::IUnknown {
from(value: &IMLangFontLink) -> Self2785     fn from(value: &IMLangFontLink) -> Self {
2786         ::std::convert::From::from(::std::clone::Clone::clone(value))
2787     }
2788 }
2789 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangFontLink {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2790     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2791         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2792     }
2793 }
2794 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangFontLink {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2795     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2796         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2797     }
2798 }
2799 impl ::std::convert::From<IMLangFontLink> for IMLangCodePages {
from(value: IMLangFontLink) -> Self2800     fn from(value: IMLangFontLink) -> Self {
2801         unsafe { ::std::mem::transmute(value) }
2802     }
2803 }
2804 impl ::std::convert::From<&IMLangFontLink> for IMLangCodePages {
from(value: &IMLangFontLink) -> Self2805     fn from(value: &IMLangFontLink) -> Self {
2806         ::std::convert::From::from(::std::clone::Clone::clone(value))
2807     }
2808 }
2809 impl<'a> ::windows::runtime::IntoParam<'a, IMLangCodePages> for IMLangFontLink {
into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages>2810     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages> {
2811         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangCodePages>::into(self))
2812     }
2813 }
2814 impl<'a> ::windows::runtime::IntoParam<'a, IMLangCodePages> for &IMLangFontLink {
into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages>2815     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages> {
2816         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangCodePages>::into(::std::clone::Clone::clone(self)))
2817     }
2818 }
2819 #[repr(C)]
2820 #[doc(hidden)]
2821 pub struct IMLangFontLink_abi(
2822     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2823     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2824     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2825     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, chsrc: u16, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2826     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszsrc: super::Foundation::PWSTR, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::HRESULT,
2827     #[cfg(not(feature = "Win32_Foundation"))] usize,
2828     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ucodepage: u32, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2829     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwcodepages: u32, udefaultcodepage: u32, pucodepage: *mut u32) -> ::windows::runtime::HRESULT,
2830     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hdc: super::Graphics::Gdi::HDC, hfont: super::Graphics::Gdi::HFONT, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2831     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2832     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hdc: super::Graphics::Gdi::HDC, dwcodepages: u32, hsrcfont: super::Graphics::Gdi::HFONT, phdestfont: *mut super::Graphics::Gdi::HFONT) -> ::windows::runtime::HRESULT,
2833     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2834     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hfont: super::Graphics::Gdi::HFONT) -> ::windows::runtime::HRESULT,
2835     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2836     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2837 );
2838 #[repr(transparent)]
2839 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2840 pub struct IMLangFontLink2(::windows::runtime::IUnknown);
2841 impl IMLangFontLink2 {
GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32>2842     pub unsafe fn GetCharCodePages(&self, chsrc: u16) -> ::windows::runtime::Result<u32> {
2843         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2844         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(chsrc), &mut result__).from_abi::<u32>(result__)
2845     }
2846     #[cfg(feature = "Win32_Foundation")]
GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()>2847     pub unsafe fn GetStrCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::Result<()> {
2848         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(dwprioritycodepages), ::std::mem::transmute(pdwcodepages), ::std::mem::transmute(pcchcodepages)).ok()
2849     }
CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32>2850     pub unsafe fn CodePageToCodePages(&self, ucodepage: u32) -> ::windows::runtime::Result<u32> {
2851         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2852         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ucodepage), &mut result__).from_abi::<u32>(result__)
2853     }
CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32>2854     pub unsafe fn CodePagesToCodePage(&self, dwcodepages: u32, udefaultcodepage: u32) -> ::windows::runtime::Result<u32> {
2855         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2856         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwcodepages), ::std::mem::transmute(udefaultcodepage), &mut result__).from_abi::<u32>(result__)
2857     }
2858     #[cfg(feature = "Win32_Graphics_Gdi")]
GetFontCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, hfont: Param1) -> ::windows::runtime::Result<u32>2859     pub unsafe fn GetFontCodePages<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param1: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hdc: Param0, hfont: Param1) -> ::windows::runtime::Result<u32> {
2860         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2861         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), hdc.into_param().abi(), hfont.into_param().abi(), &mut result__).from_abi::<u32>(result__)
2862     }
2863     #[cfg(feature = "Win32_Graphics_Gdi")]
ReleaseFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hfont: Param0) -> ::windows::runtime::Result<()>2864     pub unsafe fn ReleaseFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HFONT>>(&self, hfont: Param0) -> ::windows::runtime::Result<()> {
2865         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), hfont.into_param().abi()).ok()
2866     }
ResetFontMapping(&self) -> ::windows::runtime::Result<()>2867     pub unsafe fn ResetFontMapping(&self) -> ::windows::runtime::Result<()> {
2868         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self)).ok()
2869     }
2870     #[cfg(feature = "Win32_Graphics_Gdi")]
MapFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(&self, hdc: Param0, dwcodepages: u32, chsrc: u16) -> ::windows::runtime::Result<super::Graphics::Gdi::HFONT>2871     pub unsafe fn MapFont<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(&self, hdc: Param0, dwcodepages: u32, chsrc: u16) -> ::windows::runtime::Result<super::Graphics::Gdi::HFONT> {
2872         let mut result__: <super::Graphics::Gdi::HFONT as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2873         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), hdc.into_param().abi(), ::std::mem::transmute(dwcodepages), ::std::mem::transmute(chsrc), &mut result__).from_abi::<super::Graphics::Gdi::HFONT>(result__)
2874     }
2875     #[cfg(feature = "Win32_Graphics_Gdi")]
GetFontUnicodeRanges<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(&self, hdc: Param0, puiranges: *const u32) -> ::windows::runtime::Result<UNICODERANGE>2876     pub unsafe fn GetFontUnicodeRanges<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(&self, hdc: Param0, puiranges: *const u32) -> ::windows::runtime::Result<UNICODERANGE> {
2877         let mut result__: <UNICODERANGE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2878         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), hdc.into_param().abi(), ::std::mem::transmute(puiranges), &mut result__).from_abi::<UNICODERANGE>(result__)
2879     }
GetScriptFontInfo(&self, sid: u8, dwflags: u32, puifonts: *mut u32, pscriptfont: *mut tagSCRIPFONTINFO) -> ::windows::runtime::Result<()>2880     pub unsafe fn GetScriptFontInfo(&self, sid: u8, dwflags: u32, puifonts: *mut u32, pscriptfont: *mut tagSCRIPFONTINFO) -> ::windows::runtime::Result<()> {
2881         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(sid), ::std::mem::transmute(dwflags), ::std::mem::transmute(puifonts), ::std::mem::transmute(pscriptfont)).ok()
2882     }
CodePageToScriptID(&self, uicodepage: u32) -> ::windows::runtime::Result<u8>2883     pub unsafe fn CodePageToScriptID(&self, uicodepage: u32) -> ::windows::runtime::Result<u8> {
2884         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
2885         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), &mut result__).from_abi::<u8>(result__)
2886     }
2887 }
2888 unsafe impl ::windows::runtime::Interface for IMLangFontLink2 {
2889     type Vtable = IMLangFontLink2_abi;
2890     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3704602978, 11064, 4562, [183, 236, 0, 192, 79, 143, 93, 154]);
2891 }
2892 impl ::std::convert::From<IMLangFontLink2> for ::windows::runtime::IUnknown {
from(value: IMLangFontLink2) -> Self2893     fn from(value: IMLangFontLink2) -> Self {
2894         unsafe { ::std::mem::transmute(value) }
2895     }
2896 }
2897 impl ::std::convert::From<&IMLangFontLink2> for ::windows::runtime::IUnknown {
from(value: &IMLangFontLink2) -> Self2898     fn from(value: &IMLangFontLink2) -> Self {
2899         ::std::convert::From::from(::std::clone::Clone::clone(value))
2900     }
2901 }
2902 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangFontLink2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2903     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2904         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2905     }
2906 }
2907 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangFontLink2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2908     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2909         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2910     }
2911 }
2912 impl ::std::convert::From<IMLangFontLink2> for IMLangCodePages {
from(value: IMLangFontLink2) -> Self2913     fn from(value: IMLangFontLink2) -> Self {
2914         unsafe { ::std::mem::transmute(value) }
2915     }
2916 }
2917 impl ::std::convert::From<&IMLangFontLink2> for IMLangCodePages {
from(value: &IMLangFontLink2) -> Self2918     fn from(value: &IMLangFontLink2) -> Self {
2919         ::std::convert::From::from(::std::clone::Clone::clone(value))
2920     }
2921 }
2922 impl<'a> ::windows::runtime::IntoParam<'a, IMLangCodePages> for IMLangFontLink2 {
into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages>2923     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages> {
2924         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangCodePages>::into(self))
2925     }
2926 }
2927 impl<'a> ::windows::runtime::IntoParam<'a, IMLangCodePages> for &IMLangFontLink2 {
into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages>2928     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangCodePages> {
2929         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangCodePages>::into(::std::clone::Clone::clone(self)))
2930     }
2931 }
2932 #[repr(C)]
2933 #[doc(hidden)]
2934 pub struct IMLangFontLink2_abi(
2935     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2936     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2937     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
2938     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, chsrc: u16, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2939     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszsrc: super::Foundation::PWSTR, cchsrc: i32, dwprioritycodepages: u32, pdwcodepages: *mut u32, pcchcodepages: *mut i32) -> ::windows::runtime::HRESULT,
2940     #[cfg(not(feature = "Win32_Foundation"))] usize,
2941     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ucodepage: u32, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2942     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwcodepages: u32, udefaultcodepage: u32, pucodepage: *mut u32) -> ::windows::runtime::HRESULT,
2943     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hdc: super::Graphics::Gdi::HDC, hfont: super::Graphics::Gdi::HFONT, pdwcodepages: *mut u32) -> ::windows::runtime::HRESULT,
2944     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2945     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hfont: super::Graphics::Gdi::HFONT) -> ::windows::runtime::HRESULT,
2946     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2947     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2948     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hdc: super::Graphics::Gdi::HDC, dwcodepages: u32, chsrc: u16, pfont: *mut super::Graphics::Gdi::HFONT) -> ::windows::runtime::HRESULT,
2949     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2950     #[cfg(feature = "Win32_Graphics_Gdi")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, hdc: super::Graphics::Gdi::HDC, puiranges: *const u32, puranges: *mut UNICODERANGE) -> ::windows::runtime::HRESULT,
2951     #[cfg(not(feature = "Win32_Graphics_Gdi"))] usize,
2952     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, sid: u8, dwflags: u32, puifonts: *mut u32, pscriptfont: *mut tagSCRIPFONTINFO) -> ::windows::runtime::HRESULT,
2953     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, psid: *mut u8) -> ::windows::runtime::HRESULT,
2954 );
2955 #[repr(transparent)]
2956 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
2957 pub struct IMLangLineBreakConsole(::windows::runtime::IUnknown);
2958 impl IMLangLineBreakConsole {
BreakLineML<'a, Param0: ::windows::runtime::IntoParam<'a, IMLangString>>(&self, psrcmlstr: Param0, lsrcpos: i32, lsrclen: i32, cmincolumns: i32, cmaxcolumns: i32, pllinelen: *mut i32, plskiplen: *mut i32) -> ::windows::runtime::Result<()>2959     pub unsafe fn BreakLineML<'a, Param0: ::windows::runtime::IntoParam<'a, IMLangString>>(&self, psrcmlstr: Param0, lsrcpos: i32, lsrclen: i32, cmincolumns: i32, cmaxcolumns: i32, pllinelen: *mut i32, plskiplen: *mut i32) -> ::windows::runtime::Result<()> {
2960         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), psrcmlstr.into_param().abi(), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), ::std::mem::transmute(cmincolumns), ::std::mem::transmute(cmaxcolumns), ::std::mem::transmute(pllinelen), ::std::mem::transmute(plskiplen)).ok()
2961     }
2962     #[cfg(feature = "Win32_Foundation")]
BreakLineW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, locale: u32, pszsrc: Param1, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::Result<()>2963     pub unsafe fn BreakLineW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, locale: u32, pszsrc: Param1, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::Result<()> {
2964         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(cmaxcolumns), ::std::mem::transmute(pcchline), ::std::mem::transmute(pcchskip)).ok()
2965     }
2966     #[cfg(feature = "Win32_Foundation")]
BreakLineA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, locale: u32, ucodepage: u32, pszsrc: Param2, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::Result<()>2967     pub unsafe fn BreakLineA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, locale: u32, ucodepage: u32, pszsrc: Param2, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::Result<()> {
2968         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), ::std::mem::transmute(ucodepage), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(cmaxcolumns), ::std::mem::transmute(pcchline), ::std::mem::transmute(pcchskip)).ok()
2969     }
2970 }
2971 unsafe impl ::windows::runtime::Interface for IMLangLineBreakConsole {
2972     type Vtable = IMLangLineBreakConsole_abi;
2973     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(4122881761, 49111, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
2974 }
2975 impl ::std::convert::From<IMLangLineBreakConsole> for ::windows::runtime::IUnknown {
from(value: IMLangLineBreakConsole) -> Self2976     fn from(value: IMLangLineBreakConsole) -> Self {
2977         unsafe { ::std::mem::transmute(value) }
2978     }
2979 }
2980 impl ::std::convert::From<&IMLangLineBreakConsole> for ::windows::runtime::IUnknown {
from(value: &IMLangLineBreakConsole) -> Self2981     fn from(value: &IMLangLineBreakConsole) -> Self {
2982         ::std::convert::From::from(::std::clone::Clone::clone(value))
2983     }
2984 }
2985 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangLineBreakConsole {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2986     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2987         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
2988     }
2989 }
2990 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangLineBreakConsole {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>2991     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
2992         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
2993     }
2994 }
2995 #[repr(C)]
2996 #[doc(hidden)]
2997 pub struct IMLangLineBreakConsole_abi(
2998     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
2999     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3000     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3001     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, psrcmlstr: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, cmincolumns: i32, cmaxcolumns: i32, pllinelen: *mut i32, plskiplen: *mut i32) -> ::windows::runtime::HRESULT,
3002     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, pszsrc: super::Foundation::PWSTR, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::HRESULT,
3003     #[cfg(not(feature = "Win32_Foundation"))] usize,
3004     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, ucodepage: u32, pszsrc: super::Foundation::PSTR, cchsrc: i32, cmaxcolumns: i32, pcchline: *mut i32, pcchskip: *mut i32) -> ::windows::runtime::HRESULT,
3005     #[cfg(not(feature = "Win32_Foundation"))] usize,
3006 );
3007 #[repr(transparent)]
3008 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3009 pub struct IMLangString(::windows::runtime::IUnknown);
3010 impl IMLangString {
3011     #[cfg(feature = "Win32_Foundation")]
Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()>3012     pub unsafe fn Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()> {
3013         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), fnoaccess.into_param().abi()).ok()
3014     }
GetLength(&self) -> ::windows::runtime::Result<i32>3015     pub unsafe fn GetLength(&self) -> ::windows::runtime::Result<i32> {
3016         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3017         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
3018     }
SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()>3019     pub unsafe fn SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()> {
3020         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), psrcmlstr.into_param().abi(), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen)).ok()
3021     }
GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3022     pub unsafe fn GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3023         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), punkouter.into_param().abi(), ::std::mem::transmute(dwclscontext), ::std::mem::transmute(piid), ::std::mem::transmute(ppdestmlstr), ::std::mem::transmute(pldestpos), ::std::mem::transmute(pldestlen)).ok()
3024     }
3025 }
3026 unsafe impl ::windows::runtime::Interface for IMLangString {
3027     type Vtable = IMLangString_abi;
3028     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3226297806, 46861, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
3029 }
3030 impl ::std::convert::From<IMLangString> for ::windows::runtime::IUnknown {
from(value: IMLangString) -> Self3031     fn from(value: IMLangString) -> Self {
3032         unsafe { ::std::mem::transmute(value) }
3033     }
3034 }
3035 impl ::std::convert::From<&IMLangString> for ::windows::runtime::IUnknown {
from(value: &IMLangString) -> Self3036     fn from(value: &IMLangString) -> Self {
3037         ::std::convert::From::from(::std::clone::Clone::clone(value))
3038     }
3039 }
3040 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangString {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3041     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3042         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3043     }
3044 }
3045 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangString {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3046     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3047         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3048     }
3049 }
3050 #[repr(C)]
3051 #[doc(hidden)]
3052 pub struct IMLangString_abi(
3053     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3054     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3055     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3056     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, fnoaccess: super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3057     #[cfg(not(feature = "Win32_Foundation"))] usize,
3058     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pllen: *mut i32) -> ::windows::runtime::HRESULT,
3059     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, psrcmlstr: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::HRESULT,
3060     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, punkouter: ::windows::runtime::RawPtr, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::windows::runtime::RawPtr, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3061 );
3062 #[repr(transparent)]
3063 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3064 pub struct IMLangStringAStr(::windows::runtime::IUnknown);
3065 impl IMLangStringAStr {
3066     #[cfg(feature = "Win32_Foundation")]
Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()>3067     pub unsafe fn Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()> {
3068         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), fnoaccess.into_param().abi()).ok()
3069     }
GetLength(&self) -> ::windows::runtime::Result<i32>3070     pub unsafe fn GetLength(&self) -> ::windows::runtime::Result<i32> {
3071         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3072         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
3073     }
SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()>3074     pub unsafe fn SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()> {
3075         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), psrcmlstr.into_param().abi(), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen)).ok()
3076     }
GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3077     pub unsafe fn GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3078         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), punkouter.into_param().abi(), ::std::mem::transmute(dwclscontext), ::std::mem::transmute(piid), ::std::mem::transmute(ppdestmlstr), ::std::mem::transmute(pldestpos), ::std::mem::transmute(pldestlen)).ok()
3079     }
3080     #[cfg(feature = "Win32_Foundation")]
SetAStr<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, ldestpos: i32, ldestlen: i32, ucodepage: u32, pszsrc: Param3, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3081     pub unsafe fn SetAStr<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, ldestpos: i32, ldestlen: i32, ucodepage: u32, pszsrc: Param3, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3082         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), ::std::mem::transmute(ucodepage), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3083     }
SetStrBufA<'a, Param3: ::windows::runtime::IntoParam<'a, IMLangStringBufA>>(&self, ldestpos: i32, ldestlen: i32, ucodepage: u32, psrcbuf: Param3, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3084     pub unsafe fn SetStrBufA<'a, Param3: ::windows::runtime::IntoParam<'a, IMLangStringBufA>>(&self, ldestpos: i32, ldestlen: i32, ucodepage: u32, psrcbuf: Param3, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3085         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), ::std::mem::transmute(ucodepage), psrcbuf.into_param().abi(), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3086     }
3087     #[cfg(feature = "Win32_Foundation")]
GetAStr(&self, lsrcpos: i32, lsrclen: i32, ucodepagein: u32, pucodepageout: *mut u32, pszdest: super::Foundation::PSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3088     pub unsafe fn GetAStr(&self, lsrcpos: i32, lsrclen: i32, ucodepagein: u32, pucodepageout: *mut u32, pszdest: super::Foundation::PSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3089         (::windows::runtime::Interface::vtable(self).9)(
3090             ::std::mem::transmute_copy(self),
3091             ::std::mem::transmute(lsrcpos),
3092             ::std::mem::transmute(lsrclen),
3093             ::std::mem::transmute(ucodepagein),
3094             ::std::mem::transmute(pucodepageout),
3095             ::std::mem::transmute(pszdest),
3096             ::std::mem::transmute(cchdest),
3097             ::std::mem::transmute(pcchactual),
3098             ::std::mem::transmute(plactuallen),
3099         )
3100         .ok()
3101     }
GetStrBufA(&self, lsrcpos: i32, lsrcmaxlen: i32, pudestcodepage: *mut u32, ppdestbuf: *mut ::std::option::Option<IMLangStringBufA>, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3102     pub unsafe fn GetStrBufA(&self, lsrcpos: i32, lsrcmaxlen: i32, pudestcodepage: *mut u32, ppdestbuf: *mut ::std::option::Option<IMLangStringBufA>, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3103         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrcmaxlen), ::std::mem::transmute(pudestcodepage), ::std::mem::transmute(ppdestbuf), ::std::mem::transmute(pldestlen)).ok()
3104     }
3105     #[cfg(feature = "Win32_Foundation")]
LockAStr(&self, lsrcpos: i32, lsrclen: i32, lflags: i32, ucodepagein: u32, cchrequest: i32, pucodepageout: *mut u32, ppszdest: *mut super::Foundation::PSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3106     pub unsafe fn LockAStr(&self, lsrcpos: i32, lsrclen: i32, lflags: i32, ucodepagein: u32, cchrequest: i32, pucodepageout: *mut u32, ppszdest: *mut super::Foundation::PSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3107         (::windows::runtime::Interface::vtable(self).11)(
3108             ::std::mem::transmute_copy(self),
3109             ::std::mem::transmute(lsrcpos),
3110             ::std::mem::transmute(lsrclen),
3111             ::std::mem::transmute(lflags),
3112             ::std::mem::transmute(ucodepagein),
3113             ::std::mem::transmute(cchrequest),
3114             ::std::mem::transmute(pucodepageout),
3115             ::std::mem::transmute(ppszdest),
3116             ::std::mem::transmute(pcchdest),
3117             ::std::mem::transmute(pldestlen),
3118         )
3119         .ok()
3120     }
3121     #[cfg(feature = "Win32_Foundation")]
UnlockAStr<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pszsrc: Param0, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3122     pub unsafe fn UnlockAStr<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pszsrc: Param0, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3123         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3124     }
SetLocale(&self, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::Result<()>3125     pub unsafe fn SetLocale(&self, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::Result<()> {
3126         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), ::std::mem::transmute(locale)).ok()
3127     }
GetLocale(&self, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::Result<()>3128     pub unsafe fn GetLocale(&self, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::Result<()> {
3129         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrcmaxlen), ::std::mem::transmute(plocale), ::std::mem::transmute(pllocalepos), ::std::mem::transmute(pllocalelen)).ok()
3130     }
3131 }
3132 unsafe impl ::windows::runtime::Interface for IMLangStringAStr {
3133     type Vtable = IMLangStringAStr_abi;
3134     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3226297810, 46861, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
3135 }
3136 impl ::std::convert::From<IMLangStringAStr> for ::windows::runtime::IUnknown {
from(value: IMLangStringAStr) -> Self3137     fn from(value: IMLangStringAStr) -> Self {
3138         unsafe { ::std::mem::transmute(value) }
3139     }
3140 }
3141 impl ::std::convert::From<&IMLangStringAStr> for ::windows::runtime::IUnknown {
from(value: &IMLangStringAStr) -> Self3142     fn from(value: &IMLangStringAStr) -> Self {
3143         ::std::convert::From::from(::std::clone::Clone::clone(value))
3144     }
3145 }
3146 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangStringAStr {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3147     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3148         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3149     }
3150 }
3151 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangStringAStr {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3152     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3153         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3154     }
3155 }
3156 impl ::std::convert::From<IMLangStringAStr> for IMLangString {
from(value: IMLangStringAStr) -> Self3157     fn from(value: IMLangStringAStr) -> Self {
3158         unsafe { ::std::mem::transmute(value) }
3159     }
3160 }
3161 impl ::std::convert::From<&IMLangStringAStr> for IMLangString {
from(value: &IMLangStringAStr) -> Self3162     fn from(value: &IMLangStringAStr) -> Self {
3163         ::std::convert::From::from(::std::clone::Clone::clone(value))
3164     }
3165 }
3166 impl<'a> ::windows::runtime::IntoParam<'a, IMLangString> for IMLangStringAStr {
into_param(self) -> ::windows::runtime::Param<'a, IMLangString>3167     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangString> {
3168         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangString>::into(self))
3169     }
3170 }
3171 impl<'a> ::windows::runtime::IntoParam<'a, IMLangString> for &IMLangStringAStr {
into_param(self) -> ::windows::runtime::Param<'a, IMLangString>3172     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangString> {
3173         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangString>::into(::std::clone::Clone::clone(self)))
3174     }
3175 }
3176 #[repr(C)]
3177 #[doc(hidden)]
3178 pub struct IMLangStringAStr_abi(
3179     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3180     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3181     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3182     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, fnoaccess: super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3183     #[cfg(not(feature = "Win32_Foundation"))] usize,
3184     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pllen: *mut i32) -> ::windows::runtime::HRESULT,
3185     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, psrcmlstr: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::HRESULT,
3186     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, punkouter: ::windows::runtime::RawPtr, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::windows::runtime::RawPtr, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3187     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, ucodepage: u32, pszsrc: super::Foundation::PSTR, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3188     #[cfg(not(feature = "Win32_Foundation"))] usize,
3189     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, ucodepage: u32, psrcbuf: ::windows::runtime::RawPtr, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3190     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, ucodepagein: u32, pucodepageout: *mut u32, pszdest: super::Foundation::PSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3191     #[cfg(not(feature = "Win32_Foundation"))] usize,
3192     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrcmaxlen: i32, pudestcodepage: *mut u32, ppdestbuf: *mut ::windows::runtime::RawPtr, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3193     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, lflags: i32, ucodepagein: u32, cchrequest: i32, pucodepageout: *mut u32, ppszdest: *mut super::Foundation::PSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3194     #[cfg(not(feature = "Win32_Foundation"))] usize,
3195     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszsrc: super::Foundation::PSTR, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3196     #[cfg(not(feature = "Win32_Foundation"))] usize,
3197     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::HRESULT,
3198     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::HRESULT,
3199 );
3200 #[repr(transparent)]
3201 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3202 pub struct IMLangStringBufA(::windows::runtime::IUnknown);
3203 impl IMLangStringBufA {
GetStatus(&self, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::Result<()>3204     pub unsafe fn GetStatus(&self, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::Result<()> {
3205         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(plflags), ::std::mem::transmute(pcchbuf)).ok()
3206     }
3207     #[cfg(feature = "Win32_Foundation")]
LockBuf(&self, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut super::Foundation::CHAR, pcchbuf: *mut i32) -> ::windows::runtime::Result<()>3208     pub unsafe fn LockBuf(&self, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut super::Foundation::CHAR, pcchbuf: *mut i32) -> ::windows::runtime::Result<()> {
3209         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchmaxlock), ::std::mem::transmute(ppszbuf), ::std::mem::transmute(pcchbuf)).ok()
3210     }
3211     #[cfg(feature = "Win32_Foundation")]
UnlockBuf<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pszbuf: Param0, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::Result<()>3212     pub unsafe fn UnlockBuf<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pszbuf: Param0, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::Result<()> {
3213         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), pszbuf.into_param().abi(), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchwrite)).ok()
3214     }
Insert(&self, cchoffset: i32, cchmaxinsert: i32) -> ::windows::runtime::Result<i32>3215     pub unsafe fn Insert(&self, cchoffset: i32, cchmaxinsert: i32) -> ::windows::runtime::Result<i32> {
3216         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3217         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchmaxinsert), &mut result__).from_abi::<i32>(result__)
3218     }
Delete(&self, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::Result<()>3219     pub unsafe fn Delete(&self, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::Result<()> {
3220         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchdelete)).ok()
3221     }
3222 }
3223 unsafe impl ::windows::runtime::Interface for IMLangStringBufA {
3224     type Vtable = IMLangStringBufA_abi;
3225     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3528117539, 47730, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
3226 }
3227 impl ::std::convert::From<IMLangStringBufA> for ::windows::runtime::IUnknown {
from(value: IMLangStringBufA) -> Self3228     fn from(value: IMLangStringBufA) -> Self {
3229         unsafe { ::std::mem::transmute(value) }
3230     }
3231 }
3232 impl ::std::convert::From<&IMLangStringBufA> for ::windows::runtime::IUnknown {
from(value: &IMLangStringBufA) -> Self3233     fn from(value: &IMLangStringBufA) -> Self {
3234         ::std::convert::From::from(::std::clone::Clone::clone(value))
3235     }
3236 }
3237 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangStringBufA {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3238     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3239         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3240     }
3241 }
3242 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangStringBufA {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3243     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3244         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3245     }
3246 }
3247 #[repr(C)]
3248 #[doc(hidden)]
3249 pub struct IMLangStringBufA_abi(
3250     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3251     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3252     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3253     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::HRESULT,
3254     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut super::Foundation::CHAR, pcchbuf: *mut i32) -> ::windows::runtime::HRESULT,
3255     #[cfg(not(feature = "Win32_Foundation"))] usize,
3256     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszbuf: super::Foundation::PSTR, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::HRESULT,
3257     #[cfg(not(feature = "Win32_Foundation"))] usize,
3258     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchmaxinsert: i32, pcchactual: *mut i32) -> ::windows::runtime::HRESULT,
3259     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::HRESULT,
3260 );
3261 #[repr(transparent)]
3262 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3263 pub struct IMLangStringBufW(::windows::runtime::IUnknown);
3264 impl IMLangStringBufW {
GetStatus(&self, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::Result<()>3265     pub unsafe fn GetStatus(&self, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::Result<()> {
3266         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), ::std::mem::transmute(plflags), ::std::mem::transmute(pcchbuf)).ok()
3267     }
LockBuf(&self, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut u16, pcchbuf: *mut i32) -> ::windows::runtime::Result<()>3268     pub unsafe fn LockBuf(&self, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut u16, pcchbuf: *mut i32) -> ::windows::runtime::Result<()> {
3269         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchmaxlock), ::std::mem::transmute(ppszbuf), ::std::mem::transmute(pcchbuf)).ok()
3270     }
3271     #[cfg(feature = "Win32_Foundation")]
UnlockBuf<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszbuf: Param0, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::Result<()>3272     pub unsafe fn UnlockBuf<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszbuf: Param0, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::Result<()> {
3273         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), pszbuf.into_param().abi(), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchwrite)).ok()
3274     }
Insert(&self, cchoffset: i32, cchmaxinsert: i32) -> ::windows::runtime::Result<i32>3275     pub unsafe fn Insert(&self, cchoffset: i32, cchmaxinsert: i32) -> ::windows::runtime::Result<i32> {
3276         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3277         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchmaxinsert), &mut result__).from_abi::<i32>(result__)
3278     }
Delete(&self, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::Result<()>3279     pub unsafe fn Delete(&self, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::Result<()> {
3280         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(cchoffset), ::std::mem::transmute(cchdelete)).ok()
3281     }
3282 }
3283 unsafe impl ::windows::runtime::Interface for IMLangStringBufW {
3284     type Vtable = IMLangStringBufW_abi;
3285     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3528117537, 47730, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
3286 }
3287 impl ::std::convert::From<IMLangStringBufW> for ::windows::runtime::IUnknown {
from(value: IMLangStringBufW) -> Self3288     fn from(value: IMLangStringBufW) -> Self {
3289         unsafe { ::std::mem::transmute(value) }
3290     }
3291 }
3292 impl ::std::convert::From<&IMLangStringBufW> for ::windows::runtime::IUnknown {
from(value: &IMLangStringBufW) -> Self3293     fn from(value: &IMLangStringBufW) -> Self {
3294         ::std::convert::From::from(::std::clone::Clone::clone(value))
3295     }
3296 }
3297 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangStringBufW {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3298     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3299         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3300     }
3301 }
3302 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangStringBufW {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3303     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3304         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3305     }
3306 }
3307 #[repr(C)]
3308 #[doc(hidden)]
3309 pub struct IMLangStringBufW_abi(
3310     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3311     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3312     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3313     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plflags: *mut i32, pcchbuf: *mut i32) -> ::windows::runtime::HRESULT,
3314     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchmaxlock: i32, ppszbuf: *mut *mut u16, pcchbuf: *mut i32) -> ::windows::runtime::HRESULT,
3315     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszbuf: super::Foundation::PWSTR, cchoffset: i32, cchwrite: i32) -> ::windows::runtime::HRESULT,
3316     #[cfg(not(feature = "Win32_Foundation"))] usize,
3317     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchmaxinsert: i32, pcchactual: *mut i32) -> ::windows::runtime::HRESULT,
3318     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, cchoffset: i32, cchdelete: i32) -> ::windows::runtime::HRESULT,
3319 );
3320 #[repr(transparent)]
3321 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3322 pub struct IMLangStringWStr(::windows::runtime::IUnknown);
3323 impl IMLangStringWStr {
3324     #[cfg(feature = "Win32_Foundation")]
Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()>3325     pub unsafe fn Sync<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(&self, fnoaccess: Param0) -> ::windows::runtime::Result<()> {
3326         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), fnoaccess.into_param().abi()).ok()
3327     }
GetLength(&self) -> ::windows::runtime::Result<i32>3328     pub unsafe fn GetLength(&self) -> ::windows::runtime::Result<i32> {
3329         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3330         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
3331     }
SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()>3332     pub unsafe fn SetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, ldestpos: i32, ldestlen: i32, psrcmlstr: Param2, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::Result<()> {
3333         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), psrcmlstr.into_param().abi(), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen)).ok()
3334     }
GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3335     pub unsafe fn GetMLStr<'a, Param2: ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown>>(&self, lsrcpos: i32, lsrclen: i32, punkouter: Param2, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::std::option::Option<::windows::runtime::IUnknown>, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3336         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), punkouter.into_param().abi(), ::std::mem::transmute(dwclscontext), ::std::mem::transmute(piid), ::std::mem::transmute(ppdestmlstr), ::std::mem::transmute(pldestpos), ::std::mem::transmute(pldestlen)).ok()
3337     }
3338     #[cfg(feature = "Win32_Foundation")]
SetWStr<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, ldestpos: i32, ldestlen: i32, pszsrc: Param2, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3339     pub unsafe fn SetWStr<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, ldestpos: i32, ldestlen: i32, pszsrc: Param2, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3340         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3341     }
SetStrBufW<'a, Param2: ::windows::runtime::IntoParam<'a, IMLangStringBufW>>(&self, ldestpos: i32, ldestlen: i32, psrcbuf: Param2, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3342     pub unsafe fn SetStrBufW<'a, Param2: ::windows::runtime::IntoParam<'a, IMLangStringBufW>>(&self, ldestpos: i32, ldestlen: i32, psrcbuf: Param2, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3343         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), psrcbuf.into_param().abi(), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3344     }
3345     #[cfg(feature = "Win32_Foundation")]
GetWStr(&self, lsrcpos: i32, lsrclen: i32, pszdest: super::Foundation::PWSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3346     pub unsafe fn GetWStr(&self, lsrcpos: i32, lsrclen: i32, pszdest: super::Foundation::PWSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3347         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), ::std::mem::transmute(pszdest), ::std::mem::transmute(cchdest), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3348     }
GetStrBufW(&self, lsrcpos: i32, lsrcmaxlen: i32, ppdestbuf: *mut ::std::option::Option<IMLangStringBufW>, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3349     pub unsafe fn GetStrBufW(&self, lsrcpos: i32, lsrcmaxlen: i32, ppdestbuf: *mut ::std::option::Option<IMLangStringBufW>, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3350         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrcmaxlen), ::std::mem::transmute(ppdestbuf), ::std::mem::transmute(pldestlen)).ok()
3351     }
3352     #[cfg(feature = "Win32_Foundation")]
LockWStr(&self, lsrcpos: i32, lsrclen: i32, lflags: i32, cchrequest: i32, ppszdest: *mut super::Foundation::PWSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()>3353     pub unsafe fn LockWStr(&self, lsrcpos: i32, lsrclen: i32, lflags: i32, cchrequest: i32, ppszdest: *mut super::Foundation::PWSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::Result<()> {
3354         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrclen), ::std::mem::transmute(lflags), ::std::mem::transmute(cchrequest), ::std::mem::transmute(ppszdest), ::std::mem::transmute(pcchdest), ::std::mem::transmute(pldestlen)).ok()
3355     }
3356     #[cfg(feature = "Win32_Foundation")]
UnlockWStr<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()>3357     pub unsafe fn UnlockWStr<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pszsrc: Param0, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::Result<()> {
3358         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), pszsrc.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(pcchactual), ::std::mem::transmute(plactuallen)).ok()
3359     }
SetLocale(&self, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::Result<()>3360     pub unsafe fn SetLocale(&self, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::Result<()> {
3361         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(ldestpos), ::std::mem::transmute(ldestlen), ::std::mem::transmute(locale)).ok()
3362     }
GetLocale(&self, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::Result<()>3363     pub unsafe fn GetLocale(&self, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::Result<()> {
3364         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(lsrcpos), ::std::mem::transmute(lsrcmaxlen), ::std::mem::transmute(plocale), ::std::mem::transmute(pllocalepos), ::std::mem::transmute(pllocalelen)).ok()
3365     }
3366 }
3367 unsafe impl ::windows::runtime::Interface for IMLangStringWStr {
3368     type Vtable = IMLangStringWStr_abi;
3369     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3226297808, 46861, 4560, [177, 136, 0, 170, 0, 56, 201, 105]);
3370 }
3371 impl ::std::convert::From<IMLangStringWStr> for ::windows::runtime::IUnknown {
from(value: IMLangStringWStr) -> Self3372     fn from(value: IMLangStringWStr) -> Self {
3373         unsafe { ::std::mem::transmute(value) }
3374     }
3375 }
3376 impl ::std::convert::From<&IMLangStringWStr> for ::windows::runtime::IUnknown {
from(value: &IMLangStringWStr) -> Self3377     fn from(value: &IMLangStringWStr) -> Self {
3378         ::std::convert::From::from(::std::clone::Clone::clone(value))
3379     }
3380 }
3381 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMLangStringWStr {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3382     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3383         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3384     }
3385 }
3386 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMLangStringWStr {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3387     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3388         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3389     }
3390 }
3391 impl ::std::convert::From<IMLangStringWStr> for IMLangString {
from(value: IMLangStringWStr) -> Self3392     fn from(value: IMLangStringWStr) -> Self {
3393         unsafe { ::std::mem::transmute(value) }
3394     }
3395 }
3396 impl ::std::convert::From<&IMLangStringWStr> for IMLangString {
from(value: &IMLangStringWStr) -> Self3397     fn from(value: &IMLangStringWStr) -> Self {
3398         ::std::convert::From::from(::std::clone::Clone::clone(value))
3399     }
3400 }
3401 impl<'a> ::windows::runtime::IntoParam<'a, IMLangString> for IMLangStringWStr {
into_param(self) -> ::windows::runtime::Param<'a, IMLangString>3402     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangString> {
3403         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangString>::into(self))
3404     }
3405 }
3406 impl<'a> ::windows::runtime::IntoParam<'a, IMLangString> for &IMLangStringWStr {
into_param(self) -> ::windows::runtime::Param<'a, IMLangString>3407     fn into_param(self) -> ::windows::runtime::Param<'a, IMLangString> {
3408         ::windows::runtime::Param::Owned(::std::convert::Into::<IMLangString>::into(::std::clone::Clone::clone(self)))
3409     }
3410 }
3411 #[repr(C)]
3412 #[doc(hidden)]
3413 pub struct IMLangStringWStr_abi(
3414     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3415     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3416     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3417     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, fnoaccess: super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
3418     #[cfg(not(feature = "Win32_Foundation"))] usize,
3419     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pllen: *mut i32) -> ::windows::runtime::HRESULT,
3420     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, psrcmlstr: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32) -> ::windows::runtime::HRESULT,
3421     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, punkouter: ::windows::runtime::RawPtr, dwclscontext: u32, piid: *const ::windows::runtime::GUID, ppdestmlstr: *mut ::windows::runtime::RawPtr, pldestpos: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3422     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, pszsrc: super::Foundation::PWSTR, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3423     #[cfg(not(feature = "Win32_Foundation"))] usize,
3424     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, psrcbuf: ::windows::runtime::RawPtr, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3425     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, pszdest: super::Foundation::PWSTR, cchdest: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3426     #[cfg(not(feature = "Win32_Foundation"))] usize,
3427     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrcmaxlen: i32, ppdestbuf: *mut ::windows::runtime::RawPtr, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3428     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrclen: i32, lflags: i32, cchrequest: i32, ppszdest: *mut super::Foundation::PWSTR, pcchdest: *mut i32, pldestlen: *mut i32) -> ::windows::runtime::HRESULT,
3429     #[cfg(not(feature = "Win32_Foundation"))] usize,
3430     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pszsrc: super::Foundation::PWSTR, cchsrc: i32, pcchactual: *mut i32, plactuallen: *mut i32) -> ::windows::runtime::HRESULT,
3431     #[cfg(not(feature = "Win32_Foundation"))] usize,
3432     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ldestpos: i32, ldestlen: i32, locale: u32) -> ::windows::runtime::HRESULT,
3433     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, lsrcpos: i32, lsrcmaxlen: i32, plocale: *mut u32, pllocalepos: *mut i32, pllocalelen: *mut i32) -> ::windows::runtime::HRESULT,
3434 );
3435 #[repr(transparent)]
3436 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3437 pub struct IMultiLanguage(::windows::runtime::IUnknown);
3438 impl IMultiLanguage {
GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32>3439     pub unsafe fn GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32> {
3440         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3441         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3442     }
GetCodePageInfo(&self, uicodepage: u32) -> ::windows::runtime::Result<MIMECPINFO>3443     pub unsafe fn GetCodePageInfo(&self, uicodepage: u32) -> ::windows::runtime::Result<MIMECPINFO> {
3444         let mut result__: <MIMECPINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3445         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), &mut result__).from_abi::<MIMECPINFO>(result__)
3446     }
GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32>3447     pub unsafe fn GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32> {
3448         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3449         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), &mut result__).from_abi::<u32>(result__)
3450     }
EnumCodePages(&self, grfflags: u32) -> ::windows::runtime::Result<IEnumCodePage>3451     pub unsafe fn EnumCodePages(&self, grfflags: u32) -> ::windows::runtime::Result<IEnumCodePage> {
3452         let mut result__: <IEnumCodePage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3453         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfflags), &mut result__).from_abi::<IEnumCodePage>(result__)
3454     }
3455     #[cfg(feature = "Win32_Foundation")]
GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO>3456     pub unsafe fn GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO> {
3457         let mut result__: <MIMECSETINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3458         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), charset.into_param().abi(), &mut result__).from_abi::<MIMECSETINFO>(result__)
3459     }
IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()>3460     pub unsafe fn IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()> {
3461         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding)).ok()
3462     }
ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3463     pub unsafe fn ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3464         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding), ::std::mem::transmute(psrcstr), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3465     }
3466     #[cfg(feature = "Win32_Foundation")]
ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3467     pub unsafe fn ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3468         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3469     }
3470     #[cfg(feature = "Win32_Foundation")]
ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3471     pub unsafe fn ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3472         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3473     }
ConvertStringReset(&self) -> ::windows::runtime::Result<()>3474     pub unsafe fn ConvertStringReset(&self) -> ::windows::runtime::Result<()> {
3475         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self)).ok()
3476     }
3477     #[cfg(feature = "Win32_Foundation")]
GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR>3478     pub unsafe fn GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR> {
3479         let mut result__: <super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3480         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), &mut result__).from_abi::<super::Foundation::BSTR>(result__)
3481     }
3482     #[cfg(feature = "Win32_Foundation")]
GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()>3483     pub unsafe fn GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()> {
3484         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(plocale), bstrrfc1766.into_param().abi()).ok()
3485     }
EnumRfc1766(&self) -> ::windows::runtime::Result<IEnumRfc1766>3486     pub unsafe fn EnumRfc1766(&self) -> ::windows::runtime::Result<IEnumRfc1766> {
3487         let mut result__: <IEnumRfc1766 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3488         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRfc1766>(result__)
3489     }
GetRfc1766Info(&self, locale: u32) -> ::windows::runtime::Result<RFC1766INFO>3490     pub unsafe fn GetRfc1766Info(&self, locale: u32) -> ::windows::runtime::Result<RFC1766INFO> {
3491         let mut result__: <RFC1766INFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3492         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), &mut result__).from_abi::<RFC1766INFO>(result__)
3493     }
CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset>3494     pub unsafe fn CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset> {
3495         let mut result__: <IMLangConvertCharset as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3496         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(uisrccodepage), ::std::mem::transmute(uidstcodepage), ::std::mem::transmute(dwproperty), &mut result__).from_abi::<IMLangConvertCharset>(result__)
3497     }
3498 }
3499 unsafe impl ::windows::runtime::Interface for IMultiLanguage {
3500     type Vtable = IMultiLanguage_abi;
3501     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(660349921, 14151, 4560, [159, 234, 0, 170, 0, 63, 134, 70]);
3502 }
3503 impl ::std::convert::From<IMultiLanguage> for ::windows::runtime::IUnknown {
from(value: IMultiLanguage) -> Self3504     fn from(value: IMultiLanguage) -> Self {
3505         unsafe { ::std::mem::transmute(value) }
3506     }
3507 }
3508 impl ::std::convert::From<&IMultiLanguage> for ::windows::runtime::IUnknown {
from(value: &IMultiLanguage) -> Self3509     fn from(value: &IMultiLanguage) -> Self {
3510         ::std::convert::From::from(::std::clone::Clone::clone(value))
3511     }
3512 }
3513 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMultiLanguage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3514     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3515         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3516     }
3517 }
3518 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMultiLanguage {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3519     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3520         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3521     }
3522 }
3523 #[repr(C)]
3524 #[doc(hidden)]
3525 pub struct IMultiLanguage_abi(
3526     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3527     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3528     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3529     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pccodepage: *mut u32) -> ::windows::runtime::HRESULT,
3530     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, pcodepageinfo: *mut MIMECPINFO) -> ::windows::runtime::HRESULT,
3531     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, puifamilycodepage: *mut u32) -> ::windows::runtime::HRESULT,
3532     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfflags: u32, ppenumcodepage: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3533     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, charset: ::std::mem::ManuallyDrop<super::Foundation::BSTR>, pcharsetinfo: *mut MIMECSETINFO) -> ::windows::runtime::HRESULT,
3534     #[cfg(not(feature = "Win32_Foundation"))] usize,
3535     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::HRESULT,
3536     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3537     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3538     #[cfg(not(feature = "Win32_Foundation"))] usize,
3539     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3540     #[cfg(not(feature = "Win32_Foundation"))] usize,
3541     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3542     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, pbstrrfc1766: *mut ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3543     #[cfg(not(feature = "Win32_Foundation"))] usize,
3544     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plocale: *mut u32, bstrrfc1766: ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3545     #[cfg(not(feature = "Win32_Foundation"))] usize,
3546     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, ppenumrfc1766: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3547     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, prfc1766info: *mut RFC1766INFO) -> ::windows::runtime::HRESULT,
3548     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32, ppmlangconvertcharset: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3549 );
3550 #[repr(transparent)]
3551 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3552 pub struct IMultiLanguage2(::windows::runtime::IUnknown);
3553 impl IMultiLanguage2 {
GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32>3554     pub unsafe fn GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32> {
3555         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3556         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3557     }
GetCodePageInfo(&self, uicodepage: u32, langid: u16) -> ::windows::runtime::Result<MIMECPINFO>3558     pub unsafe fn GetCodePageInfo(&self, uicodepage: u32, langid: u16) -> ::windows::runtime::Result<MIMECPINFO> {
3559         let mut result__: <MIMECPINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3560         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), ::std::mem::transmute(langid), &mut result__).from_abi::<MIMECPINFO>(result__)
3561     }
GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32>3562     pub unsafe fn GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32> {
3563         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3564         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), &mut result__).from_abi::<u32>(result__)
3565     }
EnumCodePages(&self, grfflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumCodePage>3566     pub unsafe fn EnumCodePages(&self, grfflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumCodePage> {
3567         let mut result__: <IEnumCodePage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3568         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfflags), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumCodePage>(result__)
3569     }
3570     #[cfg(feature = "Win32_Foundation")]
GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO>3571     pub unsafe fn GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO> {
3572         let mut result__: <MIMECSETINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3573         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), charset.into_param().abi(), &mut result__).from_abi::<MIMECSETINFO>(result__)
3574     }
IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()>3575     pub unsafe fn IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()> {
3576         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding)).ok()
3577     }
ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3578     pub unsafe fn ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3579         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding), ::std::mem::transmute(psrcstr), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3580     }
3581     #[cfg(feature = "Win32_Foundation")]
ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3582     pub unsafe fn ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3583         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3584     }
3585     #[cfg(feature = "Win32_Foundation")]
ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3586     pub unsafe fn ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3587         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3588     }
ConvertStringReset(&self) -> ::windows::runtime::Result<()>3589     pub unsafe fn ConvertStringReset(&self) -> ::windows::runtime::Result<()> {
3590         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self)).ok()
3591     }
3592     #[cfg(feature = "Win32_Foundation")]
GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR>3593     pub unsafe fn GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR> {
3594         let mut result__: <super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3595         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), &mut result__).from_abi::<super::Foundation::BSTR>(result__)
3596     }
3597     #[cfg(feature = "Win32_Foundation")]
GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()>3598     pub unsafe fn GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()> {
3599         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(plocale), bstrrfc1766.into_param().abi()).ok()
3600     }
EnumRfc1766(&self, langid: u16) -> ::windows::runtime::Result<IEnumRfc1766>3601     pub unsafe fn EnumRfc1766(&self, langid: u16) -> ::windows::runtime::Result<IEnumRfc1766> {
3602         let mut result__: <IEnumRfc1766 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3603         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumRfc1766>(result__)
3604     }
GetRfc1766Info(&self, locale: u32, langid: u16) -> ::windows::runtime::Result<RFC1766INFO>3605     pub unsafe fn GetRfc1766Info(&self, locale: u32, langid: u16) -> ::windows::runtime::Result<RFC1766INFO> {
3606         let mut result__: <RFC1766INFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3607         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), ::std::mem::transmute(langid), &mut result__).from_abi::<RFC1766INFO>(result__)
3608     }
CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset>3609     pub unsafe fn CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset> {
3610         let mut result__: <IMLangConvertCharset as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3611         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(uisrccodepage), ::std::mem::transmute(uidstcodepage), ::std::mem::transmute(dwproperty), &mut result__).from_abi::<IMLangConvertCharset>(result__)
3612     }
3613     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
ConvertStringInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, pdwmode: *mut u32, dwflag: u32, lpfallback: Param2, dwsrcencoding: u32, dwdstencoding: u32, pstmin: Param5, pstmout: Param6) -> ::windows::runtime::Result<()>3614     pub unsafe fn ConvertStringInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, pdwmode: *mut u32, dwflag: u32, lpfallback: Param2, dwsrcencoding: u32, dwdstencoding: u32, pstmin: Param5, pstmout: Param6) -> ::windows::runtime::Result<()> {
3615         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwflag), lpfallback.into_param().abi(), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding), pstmin.into_param().abi(), pstmout.into_param().abi()).ok()
3616     }
3617     #[cfg(feature = "Win32_Foundation")]
ConvertStringToUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()>3618     pub unsafe fn ConvertStringToUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()> {
3619         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize), ::std::mem::transmute(dwflag), lpfallback.into_param().abi()).ok()
3620     }
3621     #[cfg(feature = "Win32_Foundation")]
ConvertStringFromUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()>3622     pub unsafe fn ConvertStringFromUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()> {
3623         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize), ::std::mem::transmute(dwflag), lpfallback.into_param().abi()).ok()
3624     }
3625     #[cfg(feature = "Win32_System_Com")]
DetectCodepageInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, dwflag: u32, dwprefwincodepage: u32, pstmin: Param2, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()>3626     pub unsafe fn DetectCodepageInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, dwflag: u32, dwprefwincodepage: u32, pstmin: Param2, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()> {
3627         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflag), ::std::mem::transmute(dwprefwincodepage), pstmin.into_param().abi(), ::std::mem::transmute(lpencoding), ::std::mem::transmute(pnscores)).ok()
3628     }
3629     #[cfg(feature = "Win32_Foundation")]
DetectInputCodepage<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, dwflag: u32, dwprefwincodepage: u32, psrcstr: Param2, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()>3630     pub unsafe fn DetectInputCodepage<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, dwflag: u32, dwprefwincodepage: u32, psrcstr: Param2, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()> {
3631         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflag), ::std::mem::transmute(dwprefwincodepage), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(lpencoding), ::std::mem::transmute(pnscores)).ok()
3632     }
3633     #[cfg(feature = "Win32_Foundation")]
ValidateCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1) -> ::windows::runtime::Result<()>3634     pub unsafe fn ValidateCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1) -> ::windows::runtime::Result<()> {
3635         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), hwnd.into_param().abi()).ok()
3636     }
3637     #[cfg(feature = "Win32_Foundation")]
GetCodePageDescription(&self, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::Result<()>3638     pub unsafe fn GetCodePageDescription(&self, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::Result<()> {
3639         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), ::std::mem::transmute(lcid), ::std::mem::transmute(lpwidecharstr), ::std::mem::transmute(cchwidechar)).ok()
3640     }
IsCodePageInstallable(&self, uicodepage: u32) -> ::windows::runtime::Result<()>3641     pub unsafe fn IsCodePageInstallable(&self, uicodepage: u32) -> ::windows::runtime::Result<()> {
3642         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage)).ok()
3643     }
SetMimeDBSource(&self, dwsource: MIMECONTF) -> ::windows::runtime::Result<()>3644     pub unsafe fn SetMimeDBSource(&self, dwsource: MIMECONTF) -> ::windows::runtime::Result<()> {
3645         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwsource)).ok()
3646     }
GetNumberOfScripts(&self) -> ::windows::runtime::Result<u32>3647     pub unsafe fn GetNumberOfScripts(&self) -> ::windows::runtime::Result<u32> {
3648         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3649         (::windows::runtime::Interface::vtable(self).27)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3650     }
EnumScripts(&self, dwflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumScript>3651     pub unsafe fn EnumScripts(&self, dwflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumScript> {
3652         let mut result__: <IEnumScript as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3653         (::windows::runtime::Interface::vtable(self).28)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumScript>(result__)
3654     }
3655     #[cfg(feature = "Win32_Foundation")]
ValidateCodePageEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1, dwfiodcontrol: u32) -> ::windows::runtime::Result<()>3656     pub unsafe fn ValidateCodePageEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1, dwfiodcontrol: u32) -> ::windows::runtime::Result<()> {
3657         (::windows::runtime::Interface::vtable(self).29)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), hwnd.into_param().abi(), ::std::mem::transmute(dwfiodcontrol)).ok()
3658     }
3659 }
3660 unsafe impl ::windows::runtime::Interface for IMultiLanguage2 {
3661     type Vtable = IMultiLanguage2_abi;
3662     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3704602980, 11064, 4562, [183, 236, 0, 192, 79, 143, 93, 154]);
3663 }
3664 impl ::std::convert::From<IMultiLanguage2> for ::windows::runtime::IUnknown {
from(value: IMultiLanguage2) -> Self3665     fn from(value: IMultiLanguage2) -> Self {
3666         unsafe { ::std::mem::transmute(value) }
3667     }
3668 }
3669 impl ::std::convert::From<&IMultiLanguage2> for ::windows::runtime::IUnknown {
from(value: &IMultiLanguage2) -> Self3670     fn from(value: &IMultiLanguage2) -> Self {
3671         ::std::convert::From::from(::std::clone::Clone::clone(value))
3672     }
3673 }
3674 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMultiLanguage2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3675     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3676         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3677     }
3678 }
3679 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMultiLanguage2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3680     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3681         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3682     }
3683 }
3684 #[repr(C)]
3685 #[doc(hidden)]
3686 pub struct IMultiLanguage2_abi(
3687     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3688     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3689     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3690     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pccodepage: *mut u32) -> ::windows::runtime::HRESULT,
3691     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, langid: u16, pcodepageinfo: *mut MIMECPINFO) -> ::windows::runtime::HRESULT,
3692     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, puifamilycodepage: *mut u32) -> ::windows::runtime::HRESULT,
3693     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfflags: u32, langid: u16, ppenumcodepage: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3694     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, charset: ::std::mem::ManuallyDrop<super::Foundation::BSTR>, pcharsetinfo: *mut MIMECSETINFO) -> ::windows::runtime::HRESULT,
3695     #[cfg(not(feature = "Win32_Foundation"))] usize,
3696     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::HRESULT,
3697     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3698     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3699     #[cfg(not(feature = "Win32_Foundation"))] usize,
3700     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3701     #[cfg(not(feature = "Win32_Foundation"))] usize,
3702     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3703     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, pbstrrfc1766: *mut ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3704     #[cfg(not(feature = "Win32_Foundation"))] usize,
3705     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plocale: *mut u32, bstrrfc1766: ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3706     #[cfg(not(feature = "Win32_Foundation"))] usize,
3707     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, langid: u16, ppenumrfc1766: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3708     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, langid: u16, prfc1766info: *mut RFC1766INFO) -> ::windows::runtime::HRESULT,
3709     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32, ppmlangconvertcharset: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3710     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR, dwsrcencoding: u32, dwdstencoding: u32, pstmin: ::windows::runtime::RawPtr, pstmout: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3711     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
3712     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3713     #[cfg(not(feature = "Win32_Foundation"))] usize,
3714     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3715     #[cfg(not(feature = "Win32_Foundation"))] usize,
3716     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflag: u32, dwprefwincodepage: u32, pstmin: ::windows::runtime::RawPtr, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::HRESULT,
3717     #[cfg(not(feature = "Win32_System_Com"))] usize,
3718     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflag: u32, dwprefwincodepage: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::HRESULT,
3719     #[cfg(not(feature = "Win32_Foundation"))] usize,
3720     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, hwnd: super::Foundation::HWND) -> ::windows::runtime::HRESULT,
3721     #[cfg(not(feature = "Win32_Foundation"))] usize,
3722     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::HRESULT,
3723     #[cfg(not(feature = "Win32_Foundation"))] usize,
3724     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32) -> ::windows::runtime::HRESULT,
3725     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwsource: MIMECONTF) -> ::windows::runtime::HRESULT,
3726     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnscripts: *mut u32) -> ::windows::runtime::HRESULT,
3727     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, langid: u16, ppenumscript: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3728     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, hwnd: super::Foundation::HWND, dwfiodcontrol: u32) -> ::windows::runtime::HRESULT,
3729     #[cfg(not(feature = "Win32_Foundation"))] usize,
3730 );
3731 #[repr(transparent)]
3732 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3733 pub struct IMultiLanguage3(::windows::runtime::IUnknown);
3734 impl IMultiLanguage3 {
GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32>3735     pub unsafe fn GetNumberOfCodePageInfo(&self) -> ::windows::runtime::Result<u32> {
3736         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3737         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3738     }
GetCodePageInfo(&self, uicodepage: u32, langid: u16) -> ::windows::runtime::Result<MIMECPINFO>3739     pub unsafe fn GetCodePageInfo(&self, uicodepage: u32, langid: u16) -> ::windows::runtime::Result<MIMECPINFO> {
3740         let mut result__: <MIMECPINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3741         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), ::std::mem::transmute(langid), &mut result__).from_abi::<MIMECPINFO>(result__)
3742     }
GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32>3743     pub unsafe fn GetFamilyCodePage(&self, uicodepage: u32) -> ::windows::runtime::Result<u32> {
3744         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3745         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), &mut result__).from_abi::<u32>(result__)
3746     }
EnumCodePages(&self, grfflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumCodePage>3747     pub unsafe fn EnumCodePages(&self, grfflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumCodePage> {
3748         let mut result__: <IEnumCodePage as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3749         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), ::std::mem::transmute(grfflags), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumCodePage>(result__)
3750     }
3751     #[cfg(feature = "Win32_Foundation")]
GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO>3752     pub unsafe fn GetCharsetInfo<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, charset: Param0) -> ::windows::runtime::Result<MIMECSETINFO> {
3753         let mut result__: <MIMECSETINFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3754         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), charset.into_param().abi(), &mut result__).from_abi::<MIMECSETINFO>(result__)
3755     }
IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()>3756     pub unsafe fn IsConvertible(&self, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::Result<()> {
3757         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding)).ok()
3758     }
ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3759     pub unsafe fn ConvertString(&self, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3760         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding), ::std::mem::transmute(psrcstr), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3761     }
3762     #[cfg(feature = "Win32_Foundation")]
ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3763     pub unsafe fn ConvertStringToUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3764         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3765     }
3766     #[cfg(feature = "Win32_Foundation")]
ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()>3767     pub unsafe fn ConvertStringFromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::Result<()> {
3768         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize)).ok()
3769     }
ConvertStringReset(&self) -> ::windows::runtime::Result<()>3770     pub unsafe fn ConvertStringReset(&self) -> ::windows::runtime::Result<()> {
3771         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self)).ok()
3772     }
3773     #[cfg(feature = "Win32_Foundation")]
GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR>3774     pub unsafe fn GetRfc1766FromLcid(&self, locale: u32) -> ::windows::runtime::Result<super::Foundation::BSTR> {
3775         let mut result__: <super::Foundation::BSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3776         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), &mut result__).from_abi::<super::Foundation::BSTR>(result__)
3777     }
3778     #[cfg(feature = "Win32_Foundation")]
GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()>3779     pub unsafe fn GetLcidFromRfc1766<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BSTR>>(&self, plocale: *mut u32, bstrrfc1766: Param1) -> ::windows::runtime::Result<()> {
3780         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(plocale), bstrrfc1766.into_param().abi()).ok()
3781     }
EnumRfc1766(&self, langid: u16) -> ::windows::runtime::Result<IEnumRfc1766>3782     pub unsafe fn EnumRfc1766(&self, langid: u16) -> ::windows::runtime::Result<IEnumRfc1766> {
3783         let mut result__: <IEnumRfc1766 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3784         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumRfc1766>(result__)
3785     }
GetRfc1766Info(&self, locale: u32, langid: u16) -> ::windows::runtime::Result<RFC1766INFO>3786     pub unsafe fn GetRfc1766Info(&self, locale: u32, langid: u16) -> ::windows::runtime::Result<RFC1766INFO> {
3787         let mut result__: <RFC1766INFO as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3788         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), ::std::mem::transmute(locale), ::std::mem::transmute(langid), &mut result__).from_abi::<RFC1766INFO>(result__)
3789     }
CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset>3790     pub unsafe fn CreateConvertCharset(&self, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32) -> ::windows::runtime::Result<IMLangConvertCharset> {
3791         let mut result__: <IMLangConvertCharset as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3792         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), ::std::mem::transmute(uisrccodepage), ::std::mem::transmute(uidstcodepage), ::std::mem::transmute(dwproperty), &mut result__).from_abi::<IMLangConvertCharset>(result__)
3793     }
3794     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
ConvertStringInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, pdwmode: *mut u32, dwflag: u32, lpfallback: Param2, dwsrcencoding: u32, dwdstencoding: u32, pstmin: Param5, pstmout: Param6) -> ::windows::runtime::Result<()>3795     pub unsafe fn ConvertStringInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param5: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, pdwmode: *mut u32, dwflag: u32, lpfallback: Param2, dwsrcencoding: u32, dwdstencoding: u32, pstmin: Param5, pstmout: Param6) -> ::windows::runtime::Result<()> {
3796         (::windows::runtime::Interface::vtable(self).18)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwflag), lpfallback.into_param().abi(), ::std::mem::transmute(dwsrcencoding), ::std::mem::transmute(dwdstencoding), pstmin.into_param().abi(), pstmout.into_param().abi()).ok()
3797     }
3798     #[cfg(feature = "Win32_Foundation")]
ConvertStringToUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()>3799     pub unsafe fn ConvertStringToUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()> {
3800         (::windows::runtime::Interface::vtable(self).19)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize), ::std::mem::transmute(dwflag), lpfallback.into_param().abi()).ok()
3801     }
3802     #[cfg(feature = "Win32_Foundation")]
ConvertStringFromUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()>3803     pub unsafe fn ConvertStringFromUnicodeEx<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, pdwmode: *mut u32, dwencoding: u32, psrcstr: Param2, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: Param7) -> ::windows::runtime::Result<()> {
3804         (::windows::runtime::Interface::vtable(self).20)(::std::mem::transmute_copy(self), ::std::mem::transmute(pdwmode), ::std::mem::transmute(dwencoding), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(pdststr), ::std::mem::transmute(pcdstsize), ::std::mem::transmute(dwflag), lpfallback.into_param().abi()).ok()
3805     }
3806     #[cfg(feature = "Win32_System_Com")]
DetectCodepageInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, dwflag: u32, dwprefwincodepage: u32, pstmin: Param2, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()>3807     pub unsafe fn DetectCodepageInIStream<'a, Param2: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>>(&self, dwflag: u32, dwprefwincodepage: u32, pstmin: Param2, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()> {
3808         (::windows::runtime::Interface::vtable(self).21)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflag), ::std::mem::transmute(dwprefwincodepage), pstmin.into_param().abi(), ::std::mem::transmute(lpencoding), ::std::mem::transmute(pnscores)).ok()
3809     }
3810     #[cfg(feature = "Win32_Foundation")]
DetectInputCodepage<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, dwflag: u32, dwprefwincodepage: u32, psrcstr: Param2, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()>3811     pub unsafe fn DetectInputCodepage<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(&self, dwflag: u32, dwprefwincodepage: u32, psrcstr: Param2, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::Result<()> {
3812         (::windows::runtime::Interface::vtable(self).22)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflag), ::std::mem::transmute(dwprefwincodepage), psrcstr.into_param().abi(), ::std::mem::transmute(pcsrcsize), ::std::mem::transmute(lpencoding), ::std::mem::transmute(pnscores)).ok()
3813     }
3814     #[cfg(feature = "Win32_Foundation")]
ValidateCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1) -> ::windows::runtime::Result<()>3815     pub unsafe fn ValidateCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1) -> ::windows::runtime::Result<()> {
3816         (::windows::runtime::Interface::vtable(self).23)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), hwnd.into_param().abi()).ok()
3817     }
3818     #[cfg(feature = "Win32_Foundation")]
GetCodePageDescription(&self, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::Result<()>3819     pub unsafe fn GetCodePageDescription(&self, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::Result<()> {
3820         (::windows::runtime::Interface::vtable(self).24)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), ::std::mem::transmute(lcid), ::std::mem::transmute(lpwidecharstr), ::std::mem::transmute(cchwidechar)).ok()
3821     }
IsCodePageInstallable(&self, uicodepage: u32) -> ::windows::runtime::Result<()>3822     pub unsafe fn IsCodePageInstallable(&self, uicodepage: u32) -> ::windows::runtime::Result<()> {
3823         (::windows::runtime::Interface::vtable(self).25)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage)).ok()
3824     }
SetMimeDBSource(&self, dwsource: MIMECONTF) -> ::windows::runtime::Result<()>3825     pub unsafe fn SetMimeDBSource(&self, dwsource: MIMECONTF) -> ::windows::runtime::Result<()> {
3826         (::windows::runtime::Interface::vtable(self).26)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwsource)).ok()
3827     }
GetNumberOfScripts(&self) -> ::windows::runtime::Result<u32>3828     pub unsafe fn GetNumberOfScripts(&self) -> ::windows::runtime::Result<u32> {
3829         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3830         (::windows::runtime::Interface::vtable(self).27)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
3831     }
EnumScripts(&self, dwflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumScript>3832     pub unsafe fn EnumScripts(&self, dwflags: u32, langid: u16) -> ::windows::runtime::Result<IEnumScript> {
3833         let mut result__: <IEnumScript as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3834         (::windows::runtime::Interface::vtable(self).28)(::std::mem::transmute_copy(self), ::std::mem::transmute(dwflags), ::std::mem::transmute(langid), &mut result__).from_abi::<IEnumScript>(result__)
3835     }
3836     #[cfg(feature = "Win32_Foundation")]
ValidateCodePageEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1, dwfiodcontrol: u32) -> ::windows::runtime::Result<()>3837     pub unsafe fn ValidateCodePageEx<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::HWND>>(&self, uicodepage: u32, hwnd: Param1, dwfiodcontrol: u32) -> ::windows::runtime::Result<()> {
3838         (::windows::runtime::Interface::vtable(self).29)(::std::mem::transmute_copy(self), ::std::mem::transmute(uicodepage), hwnd.into_param().abi(), ::std::mem::transmute(dwfiodcontrol)).ok()
3839     }
3840     #[cfg(feature = "Win32_Foundation")]
DetectOutboundCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dwflags: u32, lpwidecharstr: Param1, cchwidechar: u32, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: Param7) -> ::windows::runtime::Result<()>3841     pub unsafe fn DetectOutboundCodePage<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dwflags: u32, lpwidecharstr: Param1, cchwidechar: u32, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: Param7) -> ::windows::runtime::Result<()> {
3842         (::windows::runtime::Interface::vtable(self).30)(
3843             ::std::mem::transmute_copy(self),
3844             ::std::mem::transmute(dwflags),
3845             lpwidecharstr.into_param().abi(),
3846             ::std::mem::transmute(cchwidechar),
3847             ::std::mem::transmute(puipreferredcodepages),
3848             ::std::mem::transmute(npreferredcodepages),
3849             ::std::mem::transmute(puidetectedcodepages),
3850             ::std::mem::transmute(pndetectedcodepages),
3851             lpspecialchar.into_param().abi(),
3852         )
3853         .ok()
3854     }
3855     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
DetectOutboundCodePageInIStream<'a, Param1: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dwflags: u32, pstrin: Param1, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: Param6) -> ::windows::runtime::Result<()>3856     pub unsafe fn DetectOutboundCodePageInIStream<'a, Param1: ::windows::runtime::IntoParam<'a, super::System::Com::IStream>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dwflags: u32, pstrin: Param1, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: Param6) -> ::windows::runtime::Result<()> {
3857         (::windows::runtime::Interface::vtable(self).31)(
3858             ::std::mem::transmute_copy(self),
3859             ::std::mem::transmute(dwflags),
3860             pstrin.into_param().abi(),
3861             ::std::mem::transmute(puipreferredcodepages),
3862             ::std::mem::transmute(npreferredcodepages),
3863             ::std::mem::transmute(puidetectedcodepages),
3864             ::std::mem::transmute(pndetectedcodepages),
3865             lpspecialchar.into_param().abi(),
3866         )
3867         .ok()
3868     }
3869 }
3870 unsafe impl ::windows::runtime::Interface for IMultiLanguage3 {
3871     type Vtable = IMultiLanguage3_abi;
3872     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1314416811, 45399, 17955, [154, 204, 106, 29, 156, 174, 190, 4]);
3873 }
3874 impl ::std::convert::From<IMultiLanguage3> for ::windows::runtime::IUnknown {
from(value: IMultiLanguage3) -> Self3875     fn from(value: IMultiLanguage3) -> Self {
3876         unsafe { ::std::mem::transmute(value) }
3877     }
3878 }
3879 impl ::std::convert::From<&IMultiLanguage3> for ::windows::runtime::IUnknown {
from(value: &IMultiLanguage3) -> Self3880     fn from(value: &IMultiLanguage3) -> Self {
3881         ::std::convert::From::from(::std::clone::Clone::clone(value))
3882     }
3883 }
3884 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IMultiLanguage3 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3885     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3886         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
3887     }
3888 }
3889 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IMultiLanguage3 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>3890     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
3891         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
3892     }
3893 }
3894 impl ::std::convert::From<IMultiLanguage3> for IMultiLanguage2 {
from(value: IMultiLanguage3) -> Self3895     fn from(value: IMultiLanguage3) -> Self {
3896         unsafe { ::std::mem::transmute(value) }
3897     }
3898 }
3899 impl ::std::convert::From<&IMultiLanguage3> for IMultiLanguage2 {
from(value: &IMultiLanguage3) -> Self3900     fn from(value: &IMultiLanguage3) -> Self {
3901         ::std::convert::From::from(::std::clone::Clone::clone(value))
3902     }
3903 }
3904 impl<'a> ::windows::runtime::IntoParam<'a, IMultiLanguage2> for IMultiLanguage3 {
into_param(self) -> ::windows::runtime::Param<'a, IMultiLanguage2>3905     fn into_param(self) -> ::windows::runtime::Param<'a, IMultiLanguage2> {
3906         ::windows::runtime::Param::Owned(::std::convert::Into::<IMultiLanguage2>::into(self))
3907     }
3908 }
3909 impl<'a> ::windows::runtime::IntoParam<'a, IMultiLanguage2> for &IMultiLanguage3 {
into_param(self) -> ::windows::runtime::Param<'a, IMultiLanguage2>3910     fn into_param(self) -> ::windows::runtime::Param<'a, IMultiLanguage2> {
3911         ::windows::runtime::Param::Owned(::std::convert::Into::<IMultiLanguage2>::into(::std::clone::Clone::clone(self)))
3912     }
3913 }
3914 #[repr(C)]
3915 #[doc(hidden)]
3916 pub struct IMultiLanguage3_abi(
3917     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3918     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3919     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
3920     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pccodepage: *mut u32) -> ::windows::runtime::HRESULT,
3921     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, langid: u16, pcodepageinfo: *mut MIMECPINFO) -> ::windows::runtime::HRESULT,
3922     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, puifamilycodepage: *mut u32) -> ::windows::runtime::HRESULT,
3923     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, grfflags: u32, langid: u16, ppenumcodepage: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3924     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, charset: ::std::mem::ManuallyDrop<super::Foundation::BSTR>, pcharsetinfo: *mut MIMECSETINFO) -> ::windows::runtime::HRESULT,
3925     #[cfg(not(feature = "Win32_Foundation"))] usize,
3926     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwsrcencoding: u32, dwdstencoding: u32) -> ::windows::runtime::HRESULT,
3927     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwsrcencoding: u32, dwdstencoding: u32, psrcstr: *const u8, pcsrcsize: *mut u32, pdststr: *mut u8, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3928     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3929     #[cfg(not(feature = "Win32_Foundation"))] usize,
3930     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32) -> ::windows::runtime::HRESULT,
3931     #[cfg(not(feature = "Win32_Foundation"))] usize,
3932     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3933     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, pbstrrfc1766: *mut ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3934     #[cfg(not(feature = "Win32_Foundation"))] usize,
3935     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, plocale: *mut u32, bstrrfc1766: ::std::mem::ManuallyDrop<super::Foundation::BSTR>) -> ::windows::runtime::HRESULT,
3936     #[cfg(not(feature = "Win32_Foundation"))] usize,
3937     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, langid: u16, ppenumrfc1766: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3938     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, locale: u32, langid: u16, prfc1766info: *mut RFC1766INFO) -> ::windows::runtime::HRESULT,
3939     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uisrccodepage: u32, uidstcodepage: u32, dwproperty: u32, ppmlangconvertcharset: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3940     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR, dwsrcencoding: u32, dwdstencoding: u32, pstmin: ::windows::runtime::RawPtr, pstmout: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3941     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
3942     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PWSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3943     #[cfg(not(feature = "Win32_Foundation"))] usize,
3944     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pdwmode: *mut u32, dwencoding: u32, psrcstr: super::Foundation::PWSTR, pcsrcsize: *mut u32, pdststr: super::Foundation::PSTR, pcdstsize: *mut u32, dwflag: u32, lpfallback: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3945     #[cfg(not(feature = "Win32_Foundation"))] usize,
3946     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflag: u32, dwprefwincodepage: u32, pstmin: ::windows::runtime::RawPtr, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::HRESULT,
3947     #[cfg(not(feature = "Win32_System_Com"))] usize,
3948     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflag: u32, dwprefwincodepage: u32, psrcstr: super::Foundation::PSTR, pcsrcsize: *mut i32, lpencoding: *mut DetectEncodingInfo, pnscores: *mut i32) -> ::windows::runtime::HRESULT,
3949     #[cfg(not(feature = "Win32_Foundation"))] usize,
3950     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, hwnd: super::Foundation::HWND) -> ::windows::runtime::HRESULT,
3951     #[cfg(not(feature = "Win32_Foundation"))] usize,
3952     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, lcid: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> ::windows::runtime::HRESULT,
3953     #[cfg(not(feature = "Win32_Foundation"))] usize,
3954     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32) -> ::windows::runtime::HRESULT,
3955     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwsource: MIMECONTF) -> ::windows::runtime::HRESULT,
3956     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, pnscripts: *mut u32) -> ::windows::runtime::HRESULT,
3957     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, langid: u16, ppenumscript: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
3958     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, uicodepage: u32, hwnd: super::Foundation::HWND, dwfiodcontrol: u32) -> ::windows::runtime::HRESULT,
3959     #[cfg(not(feature = "Win32_Foundation"))] usize,
3960     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: u32, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3961     #[cfg(not(feature = "Win32_Foundation"))] usize,
3962     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dwflags: u32, pstrin: ::windows::runtime::RawPtr, puipreferredcodepages: *const u32, npreferredcodepages: u32, puidetectedcodepages: *mut u32, pndetectedcodepages: *mut u32, lpspecialchar: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
3963     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
3964 );
3965 #[repr(transparent)]
3966 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
3967 pub struct IOptionDescription(::windows::runtime::IUnknown);
3968 impl IOptionDescription {
3969     #[cfg(feature = "Win32_Foundation")]
Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>3970     pub unsafe fn Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
3971         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3972         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
3973     }
3974     #[cfg(feature = "Win32_Foundation")]
Heading(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>3975     pub unsafe fn Heading(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
3976         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3977         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
3978     }
3979     #[cfg(feature = "Win32_Foundation")]
Description(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>3980     pub unsafe fn Description(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
3981         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3982         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
3983     }
3984     #[cfg(feature = "Win32_System_Com")]
Labels(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>3985     pub unsafe fn Labels(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
3986         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
3987         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
3988     }
3989 }
3990 unsafe impl ::windows::runtime::Interface for IOptionDescription {
3991     type Vtable = IOptionDescription_abi;
3992     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1127112581, 13775, 17926, [168, 1, 111, 112, 39, 126, 29, 122]);
3993 }
3994 impl ::std::convert::From<IOptionDescription> for ::windows::runtime::IUnknown {
from(value: IOptionDescription) -> Self3995     fn from(value: IOptionDescription) -> Self {
3996         unsafe { ::std::mem::transmute(value) }
3997     }
3998 }
3999 impl ::std::convert::From<&IOptionDescription> for ::windows::runtime::IUnknown {
from(value: &IOptionDescription) -> Self4000     fn from(value: &IOptionDescription) -> Self {
4001         ::std::convert::From::from(::std::clone::Clone::clone(value))
4002     }
4003 }
4004 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IOptionDescription {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4005     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4006         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4007     }
4008 }
4009 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IOptionDescription {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4010     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4011         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4012     }
4013 }
4014 #[repr(C)]
4015 #[doc(hidden)]
4016 pub struct IOptionDescription_abi(
4017     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4018     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4019     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4020     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4021     #[cfg(not(feature = "Win32_Foundation"))] usize,
4022     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4023     #[cfg(not(feature = "Win32_Foundation"))] usize,
4024     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4025     #[cfg(not(feature = "Win32_Foundation"))] usize,
4026     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4027     #[cfg(not(feature = "Win32_System_Com"))] usize,
4028 );
4029 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4030 #[repr(transparent)]
4031 pub struct IS_TEXT_UNICODE_RESULT(pub u32);
4032 pub const IS_TEXT_UNICODE_ASCII16: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(1u32);
4033 pub const IS_TEXT_UNICODE_REVERSE_ASCII16: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(16u32);
4034 pub const IS_TEXT_UNICODE_STATISTICS: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(2u32);
4035 pub const IS_TEXT_UNICODE_REVERSE_STATISTICS: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(32u32);
4036 pub const IS_TEXT_UNICODE_CONTROLS: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(4u32);
4037 pub const IS_TEXT_UNICODE_REVERSE_CONTROLS: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(64u32);
4038 pub const IS_TEXT_UNICODE_SIGNATURE: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(8u32);
4039 pub const IS_TEXT_UNICODE_REVERSE_SIGNATURE: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(128u32);
4040 pub const IS_TEXT_UNICODE_ILLEGAL_CHARS: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(256u32);
4041 pub const IS_TEXT_UNICODE_ODD_LENGTH: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(512u32);
4042 pub const IS_TEXT_UNICODE_NULL_BYTES: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(4096u32);
4043 pub const IS_TEXT_UNICODE_UNICODE_MASK: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(15u32);
4044 pub const IS_TEXT_UNICODE_REVERSE_MASK: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(240u32);
4045 pub const IS_TEXT_UNICODE_NOT_UNICODE_MASK: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(3840u32);
4046 pub const IS_TEXT_UNICODE_NOT_ASCII_MASK: IS_TEXT_UNICODE_RESULT = IS_TEXT_UNICODE_RESULT(61440u32);
4047 impl ::std::convert::From<u32> for IS_TEXT_UNICODE_RESULT {
from(value: u32) -> Self4048     fn from(value: u32) -> Self {
4049         Self(value)
4050     }
4051 }
4052 unsafe impl ::windows::runtime::Abi for IS_TEXT_UNICODE_RESULT {
4053     type Abi = Self;
4054     type DefaultType = Self;
4055 }
4056 impl ::std::ops::BitOr for IS_TEXT_UNICODE_RESULT {
4057     type Output = Self;
bitor(self, rhs: Self) -> Self4058     fn bitor(self, rhs: Self) -> Self {
4059         Self(self.0 | rhs.0)
4060     }
4061 }
4062 impl ::std::ops::BitAnd for IS_TEXT_UNICODE_RESULT {
4063     type Output = Self;
bitand(self, rhs: Self) -> Self4064     fn bitand(self, rhs: Self) -> Self {
4065         Self(self.0 & rhs.0)
4066     }
4067 }
4068 impl ::std::ops::BitOrAssign for IS_TEXT_UNICODE_RESULT {
bitor_assign(&mut self, rhs: Self)4069     fn bitor_assign(&mut self, rhs: Self) {
4070         self.0.bitor_assign(rhs.0)
4071     }
4072 }
4073 impl ::std::ops::BitAndAssign for IS_TEXT_UNICODE_RESULT {
bitand_assign(&mut self, rhs: Self)4074     fn bitand_assign(&mut self, rhs: Self) {
4075         self.0.bitand_assign(rhs.0)
4076     }
4077 }
4078 impl ::std::ops::Not for IS_TEXT_UNICODE_RESULT {
4079     type Output = Self;
not(self) -> Self4080     fn not(self) -> Self {
4081         Self(self.0.not())
4082     }
4083 }
4084 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
4085 #[repr(transparent)]
4086 pub struct IS_VALID_LOCALE_FLAGS(pub u32);
4087 pub const LCID_INSTALLED: IS_VALID_LOCALE_FLAGS = IS_VALID_LOCALE_FLAGS(1u32);
4088 pub const LCID_SUPPORTED: IS_VALID_LOCALE_FLAGS = IS_VALID_LOCALE_FLAGS(2u32);
4089 impl ::std::convert::From<u32> for IS_VALID_LOCALE_FLAGS {
from(value: u32) -> Self4090     fn from(value: u32) -> Self {
4091         Self(value)
4092     }
4093 }
4094 unsafe impl ::windows::runtime::Abi for IS_VALID_LOCALE_FLAGS {
4095     type Abi = Self;
4096     type DefaultType = Self;
4097 }
4098 impl ::std::ops::BitOr for IS_VALID_LOCALE_FLAGS {
4099     type Output = Self;
bitor(self, rhs: Self) -> Self4100     fn bitor(self, rhs: Self) -> Self {
4101         Self(self.0 | rhs.0)
4102     }
4103 }
4104 impl ::std::ops::BitAnd for IS_VALID_LOCALE_FLAGS {
4105     type Output = Self;
bitand(self, rhs: Self) -> Self4106     fn bitand(self, rhs: Self) -> Self {
4107         Self(self.0 & rhs.0)
4108     }
4109 }
4110 impl ::std::ops::BitOrAssign for IS_VALID_LOCALE_FLAGS {
bitor_assign(&mut self, rhs: Self)4111     fn bitor_assign(&mut self, rhs: Self) {
4112         self.0.bitor_assign(rhs.0)
4113     }
4114 }
4115 impl ::std::ops::BitAndAssign for IS_VALID_LOCALE_FLAGS {
bitand_assign(&mut self, rhs: Self)4116     fn bitand_assign(&mut self, rhs: Self) {
4117         self.0.bitand_assign(rhs.0)
4118     }
4119 }
4120 impl ::std::ops::Not for IS_VALID_LOCALE_FLAGS {
4121     type Output = Self;
not(self) -> Self4122     fn not(self) -> Self {
4123         Self(self.0.not())
4124     }
4125 }
4126 #[repr(transparent)]
4127 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4128 pub struct ISpellCheckProvider(::windows::runtime::IUnknown);
4129 impl ISpellCheckProvider {
4130     #[cfg(feature = "Win32_Foundation")]
LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4131     pub unsafe fn LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4132         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4133         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4134     }
4135     #[cfg(feature = "Win32_Foundation")]
Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>4136     pub unsafe fn Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
4137         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4138         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
4139     }
4140     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString>4141     pub unsafe fn Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4142         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4143         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), word.into_param().abi(), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4144     }
4145     #[cfg(feature = "Win32_Foundation")]
GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8>4146     pub unsafe fn GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8> {
4147         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4148         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<u8>(result__)
4149     }
4150     #[cfg(feature = "Win32_Foundation")]
SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0, value: u8) -> ::windows::runtime::Result<()>4151     pub unsafe fn SetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0, value: u8) -> ::windows::runtime::Result<()> {
4152         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), optionid.into_param().abi(), ::std::mem::transmute(value)).ok()
4153     }
4154     #[cfg(feature = "Win32_System_Com")]
OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>4155     pub unsafe fn OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4156         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4157         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4158     }
4159     #[cfg(feature = "Win32_Foundation")]
Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4160     pub unsafe fn Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4161         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4162         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4163     }
4164     #[cfg(feature = "Win32_Foundation")]
LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4165     pub unsafe fn LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4166         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4167         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4168     }
4169     #[cfg(feature = "Win32_Foundation")]
GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription>4170     pub unsafe fn GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription> {
4171         let mut result__: <IOptionDescription as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4172         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<IOptionDescription>(result__)
4173     }
4174     #[cfg(feature = "Win32_System_Com")]
InitializeWordlist<'a, Param1: ::windows::runtime::IntoParam<'a, super::System::Com::IEnumString>>(&self, wordlisttype: WORDLIST_TYPE, words: Param1) -> ::windows::runtime::Result<()>4175     pub unsafe fn InitializeWordlist<'a, Param1: ::windows::runtime::IntoParam<'a, super::System::Com::IEnumString>>(&self, wordlisttype: WORDLIST_TYPE, words: Param1) -> ::windows::runtime::Result<()> {
4176         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), ::std::mem::transmute(wordlisttype), words.into_param().abi()).ok()
4177     }
4178 }
4179 unsafe impl ::windows::runtime::Interface for ISpellCheckProvider {
4180     type Vtable = ISpellCheckProvider_abi;
4181     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(1944680160, 36564, 20145, [128, 215, 27, 224, 161, 107, 12, 56]);
4182 }
4183 impl ::std::convert::From<ISpellCheckProvider> for ::windows::runtime::IUnknown {
from(value: ISpellCheckProvider) -> Self4184     fn from(value: ISpellCheckProvider) -> Self {
4185         unsafe { ::std::mem::transmute(value) }
4186     }
4187 }
4188 impl ::std::convert::From<&ISpellCheckProvider> for ::windows::runtime::IUnknown {
from(value: &ISpellCheckProvider) -> Self4189     fn from(value: &ISpellCheckProvider) -> Self {
4190         ::std::convert::From::from(::std::clone::Clone::clone(value))
4191     }
4192 }
4193 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellCheckProvider {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4194     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4195         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4196     }
4197 }
4198 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellCheckProvider {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4199     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4200         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4201     }
4202 }
4203 #[repr(C)]
4204 #[doc(hidden)]
4205 pub struct ISpellCheckProvider_abi(
4206     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4207     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4208     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4209     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4210     #[cfg(not(feature = "Win32_Foundation"))] usize,
4211     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4212     #[cfg(not(feature = "Win32_Foundation"))] usize,
4213     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4214     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
4215     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut u8) -> ::windows::runtime::HRESULT,
4216     #[cfg(not(feature = "Win32_Foundation"))] usize,
4217     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: u8) -> ::windows::runtime::HRESULT,
4218     #[cfg(not(feature = "Win32_Foundation"))] usize,
4219     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4220     #[cfg(not(feature = "Win32_System_Com"))] usize,
4221     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4222     #[cfg(not(feature = "Win32_Foundation"))] usize,
4223     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4224     #[cfg(not(feature = "Win32_Foundation"))] usize,
4225     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4226     #[cfg(not(feature = "Win32_Foundation"))] usize,
4227     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, wordlisttype: WORDLIST_TYPE, words: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4228     #[cfg(not(feature = "Win32_System_Com"))] usize,
4229 );
4230 #[repr(transparent)]
4231 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4232 pub struct ISpellCheckProviderFactory(::windows::runtime::IUnknown);
4233 impl ISpellCheckProviderFactory {
4234     #[cfg(feature = "Win32_System_Com")]
SupportedLanguages(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>4235     pub unsafe fn SupportedLanguages(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4236         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4237         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4238     }
4239     #[cfg(feature = "Win32_Foundation")]
IsSupported<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<super::Foundation::BOOL>4240     pub unsafe fn IsSupported<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<super::Foundation::BOOL> {
4241         let mut result__: <super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4242         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), languagetag.into_param().abi(), &mut result__).from_abi::<super::Foundation::BOOL>(result__)
4243     }
4244     #[cfg(feature = "Win32_Foundation")]
CreateSpellCheckProvider<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<ISpellCheckProvider>4245     pub unsafe fn CreateSpellCheckProvider<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<ISpellCheckProvider> {
4246         let mut result__: <ISpellCheckProvider as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4247         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), languagetag.into_param().abi(), &mut result__).from_abi::<ISpellCheckProvider>(result__)
4248     }
4249 }
4250 unsafe impl ::windows::runtime::Interface for ISpellCheckProviderFactory {
4251     type Vtable = ISpellCheckProviderFactory_abi;
4252     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2674335249, 30678, 19602, [174, 251, 97, 82, 21, 227, 164, 190]);
4253 }
4254 impl ::std::convert::From<ISpellCheckProviderFactory> for ::windows::runtime::IUnknown {
from(value: ISpellCheckProviderFactory) -> Self4255     fn from(value: ISpellCheckProviderFactory) -> Self {
4256         unsafe { ::std::mem::transmute(value) }
4257     }
4258 }
4259 impl ::std::convert::From<&ISpellCheckProviderFactory> for ::windows::runtime::IUnknown {
from(value: &ISpellCheckProviderFactory) -> Self4260     fn from(value: &ISpellCheckProviderFactory) -> Self {
4261         ::std::convert::From::from(::std::clone::Clone::clone(value))
4262     }
4263 }
4264 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellCheckProviderFactory {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4265     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4266         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4267     }
4268 }
4269 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellCheckProviderFactory {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4270     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4271         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4272     }
4273 }
4274 #[repr(C)]
4275 #[doc(hidden)]
4276 pub struct ISpellCheckProviderFactory_abi(
4277     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4278     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4279     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4280     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4281     #[cfg(not(feature = "Win32_System_Com"))] usize,
4282     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, languagetag: super::Foundation::PWSTR, value: *mut super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4283     #[cfg(not(feature = "Win32_Foundation"))] usize,
4284     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, languagetag: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4285     #[cfg(not(feature = "Win32_Foundation"))] usize,
4286 );
4287 #[repr(transparent)]
4288 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4289 pub struct ISpellChecker(::windows::runtime::IUnknown);
4290 impl ISpellChecker {
4291     #[cfg(feature = "Win32_Foundation")]
LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4292     pub unsafe fn LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4293         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4294         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4295     }
4296     #[cfg(feature = "Win32_Foundation")]
Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>4297     pub unsafe fn Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
4298         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4299         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
4300     }
4301     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString>4302     pub unsafe fn Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4303         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4304         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), word.into_param().abi(), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4305     }
4306     #[cfg(feature = "Win32_Foundation")]
Add<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()>4307     pub unsafe fn Add<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()> {
4308         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), word.into_param().abi()).ok()
4309     }
4310     #[cfg(feature = "Win32_Foundation")]
Ignore<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()>4311     pub unsafe fn Ignore<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()> {
4312         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), word.into_param().abi()).ok()
4313     }
4314     #[cfg(feature = "Win32_Foundation")]
AutoCorrect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, from: Param0, to: Param1) -> ::windows::runtime::Result<()>4315     pub unsafe fn AutoCorrect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, from: Param0, to: Param1) -> ::windows::runtime::Result<()> {
4316         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), from.into_param().abi(), to.into_param().abi()).ok()
4317     }
4318     #[cfg(feature = "Win32_Foundation")]
GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8>4319     pub unsafe fn GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8> {
4320         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4321         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<u8>(result__)
4322     }
4323     #[cfg(feature = "Win32_System_Com")]
OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>4324     pub unsafe fn OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4325         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4326         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4327     }
4328     #[cfg(feature = "Win32_Foundation")]
Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4329     pub unsafe fn Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4330         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4331         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4332     }
4333     #[cfg(feature = "Win32_Foundation")]
LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4334     pub unsafe fn LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4335         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4336         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4337     }
SpellCheckerChanged<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellCheckerChangedEventHandler>>(&self, handler: Param0) -> ::windows::runtime::Result<u32>4338     pub unsafe fn SpellCheckerChanged<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellCheckerChangedEventHandler>>(&self, handler: Param0) -> ::windows::runtime::Result<u32> {
4339         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4340         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), handler.into_param().abi(), &mut result__).from_abi::<u32>(result__)
4341     }
RemoveSpellCheckerChanged(&self, eventcookie: u32) -> ::windows::runtime::Result<()>4342     pub unsafe fn RemoveSpellCheckerChanged(&self, eventcookie: u32) -> ::windows::runtime::Result<()> {
4343         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(eventcookie)).ok()
4344     }
4345     #[cfg(feature = "Win32_Foundation")]
GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription>4346     pub unsafe fn GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription> {
4347         let mut result__: <IOptionDescription as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4348         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<IOptionDescription>(result__)
4349     }
4350     #[cfg(feature = "Win32_Foundation")]
ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>4351     pub unsafe fn ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
4352         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4353         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
4354     }
4355 }
4356 unsafe impl ::windows::runtime::Interface for ISpellChecker {
4357     type Vtable = ISpellChecker_abi;
4358     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3070036849, 58044, 18003, [141, 5, 241, 151, 228, 18, 119, 11]);
4359 }
4360 impl ::std::convert::From<ISpellChecker> for ::windows::runtime::IUnknown {
from(value: ISpellChecker) -> Self4361     fn from(value: ISpellChecker) -> Self {
4362         unsafe { ::std::mem::transmute(value) }
4363     }
4364 }
4365 impl ::std::convert::From<&ISpellChecker> for ::windows::runtime::IUnknown {
from(value: &ISpellChecker) -> Self4366     fn from(value: &ISpellChecker) -> Self {
4367         ::std::convert::From::from(::std::clone::Clone::clone(value))
4368     }
4369 }
4370 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellChecker {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4371     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4372         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4373     }
4374 }
4375 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellChecker {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4376     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4377         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4378     }
4379 }
4380 #[repr(C)]
4381 #[doc(hidden)]
4382 pub struct ISpellChecker_abi(
4383     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4384     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4385     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4386     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4387     #[cfg(not(feature = "Win32_Foundation"))] usize,
4388     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4389     #[cfg(not(feature = "Win32_Foundation"))] usize,
4390     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4391     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
4392     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4393     #[cfg(not(feature = "Win32_Foundation"))] usize,
4394     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4395     #[cfg(not(feature = "Win32_Foundation"))] usize,
4396     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, from: super::Foundation::PWSTR, to: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4397     #[cfg(not(feature = "Win32_Foundation"))] usize,
4398     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut u8) -> ::windows::runtime::HRESULT,
4399     #[cfg(not(feature = "Win32_Foundation"))] usize,
4400     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4401     #[cfg(not(feature = "Win32_System_Com"))] usize,
4402     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4403     #[cfg(not(feature = "Win32_Foundation"))] usize,
4404     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4405     #[cfg(not(feature = "Win32_Foundation"))] usize,
4406     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, handler: ::windows::runtime::RawPtr, eventcookie: *mut u32) -> ::windows::runtime::HRESULT,
4407     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, eventcookie: u32) -> ::windows::runtime::HRESULT,
4408     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4409     #[cfg(not(feature = "Win32_Foundation"))] usize,
4410     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4411     #[cfg(not(feature = "Win32_Foundation"))] usize,
4412 );
4413 #[repr(transparent)]
4414 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4415 pub struct ISpellChecker2(::windows::runtime::IUnknown);
4416 impl ISpellChecker2 {
4417     #[cfg(feature = "Win32_Foundation")]
LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4418     pub unsafe fn LanguageTag(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4419         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4420         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4421     }
4422     #[cfg(feature = "Win32_Foundation")]
Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>4423     pub unsafe fn Check<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
4424         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4425         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
4426     }
4427     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString>4428     pub unsafe fn Suggest<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4429         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4430         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), word.into_param().abi(), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4431     }
4432     #[cfg(feature = "Win32_Foundation")]
Add<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()>4433     pub unsafe fn Add<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()> {
4434         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), word.into_param().abi()).ok()
4435     }
4436     #[cfg(feature = "Win32_Foundation")]
Ignore<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()>4437     pub unsafe fn Ignore<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()> {
4438         (::windows::runtime::Interface::vtable(self).7)(::std::mem::transmute_copy(self), word.into_param().abi()).ok()
4439     }
4440     #[cfg(feature = "Win32_Foundation")]
AutoCorrect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, from: Param0, to: Param1) -> ::windows::runtime::Result<()>4441     pub unsafe fn AutoCorrect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, from: Param0, to: Param1) -> ::windows::runtime::Result<()> {
4442         (::windows::runtime::Interface::vtable(self).8)(::std::mem::transmute_copy(self), from.into_param().abi(), to.into_param().abi()).ok()
4443     }
4444     #[cfg(feature = "Win32_Foundation")]
GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8>4445     pub unsafe fn GetOptionValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<u8> {
4446         let mut result__: <u8 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4447         (::windows::runtime::Interface::vtable(self).9)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<u8>(result__)
4448     }
4449     #[cfg(feature = "Win32_System_Com")]
OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>4450     pub unsafe fn OptionIds(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4451         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4452         (::windows::runtime::Interface::vtable(self).10)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4453     }
4454     #[cfg(feature = "Win32_Foundation")]
Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4455     pub unsafe fn Id(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4456         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4457         (::windows::runtime::Interface::vtable(self).11)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4458     }
4459     #[cfg(feature = "Win32_Foundation")]
LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4460     pub unsafe fn LocalizedName(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4461         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4462         (::windows::runtime::Interface::vtable(self).12)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4463     }
SpellCheckerChanged<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellCheckerChangedEventHandler>>(&self, handler: Param0) -> ::windows::runtime::Result<u32>4464     pub unsafe fn SpellCheckerChanged<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellCheckerChangedEventHandler>>(&self, handler: Param0) -> ::windows::runtime::Result<u32> {
4465         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4466         (::windows::runtime::Interface::vtable(self).13)(::std::mem::transmute_copy(self), handler.into_param().abi(), &mut result__).from_abi::<u32>(result__)
4467     }
RemoveSpellCheckerChanged(&self, eventcookie: u32) -> ::windows::runtime::Result<()>4468     pub unsafe fn RemoveSpellCheckerChanged(&self, eventcookie: u32) -> ::windows::runtime::Result<()> {
4469         (::windows::runtime::Interface::vtable(self).14)(::std::mem::transmute_copy(self), ::std::mem::transmute(eventcookie)).ok()
4470     }
4471     #[cfg(feature = "Win32_Foundation")]
GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription>4472     pub unsafe fn GetOptionDescription<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, optionid: Param0) -> ::windows::runtime::Result<IOptionDescription> {
4473         let mut result__: <IOptionDescription as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4474         (::windows::runtime::Interface::vtable(self).15)(::std::mem::transmute_copy(self), optionid.into_param().abi(), &mut result__).from_abi::<IOptionDescription>(result__)
4475     }
4476     #[cfg(feature = "Win32_Foundation")]
ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError>4477     pub unsafe fn ComprehensiveCheck<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, text: Param0) -> ::windows::runtime::Result<IEnumSpellingError> {
4478         let mut result__: <IEnumSpellingError as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4479         (::windows::runtime::Interface::vtable(self).16)(::std::mem::transmute_copy(self), text.into_param().abi(), &mut result__).from_abi::<IEnumSpellingError>(result__)
4480     }
4481     #[cfg(feature = "Win32_Foundation")]
Remove<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()>4482     pub unsafe fn Remove<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, word: Param0) -> ::windows::runtime::Result<()> {
4483         (::windows::runtime::Interface::vtable(self).17)(::std::mem::transmute_copy(self), word.into_param().abi()).ok()
4484     }
4485 }
4486 unsafe impl ::windows::runtime::Interface for ISpellChecker2 {
4487     type Vtable = ISpellChecker2_abi;
4488     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3891076209, 34807, 17272, [168, 64, 201, 32, 13, 172, 238, 71]);
4489 }
4490 impl ::std::convert::From<ISpellChecker2> for ::windows::runtime::IUnknown {
from(value: ISpellChecker2) -> Self4491     fn from(value: ISpellChecker2) -> Self {
4492         unsafe { ::std::mem::transmute(value) }
4493     }
4494 }
4495 impl ::std::convert::From<&ISpellChecker2> for ::windows::runtime::IUnknown {
from(value: &ISpellChecker2) -> Self4496     fn from(value: &ISpellChecker2) -> Self {
4497         ::std::convert::From::from(::std::clone::Clone::clone(value))
4498     }
4499 }
4500 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellChecker2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4501     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4502         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4503     }
4504 }
4505 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellChecker2 {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4506     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4507         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4508     }
4509 }
4510 impl ::std::convert::From<ISpellChecker2> for ISpellChecker {
from(value: ISpellChecker2) -> Self4511     fn from(value: ISpellChecker2) -> Self {
4512         unsafe { ::std::mem::transmute(value) }
4513     }
4514 }
4515 impl ::std::convert::From<&ISpellChecker2> for ISpellChecker {
from(value: &ISpellChecker2) -> Self4516     fn from(value: &ISpellChecker2) -> Self {
4517         ::std::convert::From::from(::std::clone::Clone::clone(value))
4518     }
4519 }
4520 impl<'a> ::windows::runtime::IntoParam<'a, ISpellChecker> for ISpellChecker2 {
into_param(self) -> ::windows::runtime::Param<'a, ISpellChecker>4521     fn into_param(self) -> ::windows::runtime::Param<'a, ISpellChecker> {
4522         ::windows::runtime::Param::Owned(::std::convert::Into::<ISpellChecker>::into(self))
4523     }
4524 }
4525 impl<'a> ::windows::runtime::IntoParam<'a, ISpellChecker> for &ISpellChecker2 {
into_param(self) -> ::windows::runtime::Param<'a, ISpellChecker>4526     fn into_param(self) -> ::windows::runtime::Param<'a, ISpellChecker> {
4527         ::windows::runtime::Param::Owned(::std::convert::Into::<ISpellChecker>::into(::std::clone::Clone::clone(self)))
4528     }
4529 }
4530 #[repr(C)]
4531 #[doc(hidden)]
4532 pub struct ISpellChecker2_abi(
4533     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4534     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4535     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4536     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4537     #[cfg(not(feature = "Win32_Foundation"))] usize,
4538     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4539     #[cfg(not(feature = "Win32_Foundation"))] usize,
4540     #[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4541     #[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
4542     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4543     #[cfg(not(feature = "Win32_Foundation"))] usize,
4544     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4545     #[cfg(not(feature = "Win32_Foundation"))] usize,
4546     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, from: super::Foundation::PWSTR, to: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4547     #[cfg(not(feature = "Win32_Foundation"))] usize,
4548     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut u8) -> ::windows::runtime::HRESULT,
4549     #[cfg(not(feature = "Win32_Foundation"))] usize,
4550     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4551     #[cfg(not(feature = "Win32_System_Com"))] usize,
4552     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4553     #[cfg(not(feature = "Win32_Foundation"))] usize,
4554     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4555     #[cfg(not(feature = "Win32_Foundation"))] usize,
4556     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, handler: ::windows::runtime::RawPtr, eventcookie: *mut u32) -> ::windows::runtime::HRESULT,
4557     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, eventcookie: u32) -> ::windows::runtime::HRESULT,
4558     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, optionid: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4559     #[cfg(not(feature = "Win32_Foundation"))] usize,
4560     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, text: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4561     #[cfg(not(feature = "Win32_Foundation"))] usize,
4562     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, word: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4563     #[cfg(not(feature = "Win32_Foundation"))] usize,
4564 );
4565 #[repr(transparent)]
4566 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4567 pub struct ISpellCheckerChangedEventHandler(::windows::runtime::IUnknown);
4568 impl ISpellCheckerChangedEventHandler {
Invoke<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellChecker>>(&self, sender: Param0) -> ::windows::runtime::Result<()>4569     pub unsafe fn Invoke<'a, Param0: ::windows::runtime::IntoParam<'a, ISpellChecker>>(&self, sender: Param0) -> ::windows::runtime::Result<()> {
4570         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), sender.into_param().abi()).ok()
4571     }
4572 }
4573 unsafe impl ::windows::runtime::Interface for ISpellCheckerChangedEventHandler {
4574     type Vtable = ISpellCheckerChangedEventHandler_abi;
4575     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(193177008, 31023, 20139, [151, 153, 172, 245, 44, 94, 208, 138]);
4576 }
4577 impl ::std::convert::From<ISpellCheckerChangedEventHandler> for ::windows::runtime::IUnknown {
from(value: ISpellCheckerChangedEventHandler) -> Self4578     fn from(value: ISpellCheckerChangedEventHandler) -> Self {
4579         unsafe { ::std::mem::transmute(value) }
4580     }
4581 }
4582 impl ::std::convert::From<&ISpellCheckerChangedEventHandler> for ::windows::runtime::IUnknown {
from(value: &ISpellCheckerChangedEventHandler) -> Self4583     fn from(value: &ISpellCheckerChangedEventHandler) -> Self {
4584         ::std::convert::From::from(::std::clone::Clone::clone(value))
4585     }
4586 }
4587 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellCheckerChangedEventHandler {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4588     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4589         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4590     }
4591 }
4592 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellCheckerChangedEventHandler {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4593     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4594         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4595     }
4596 }
4597 #[repr(C)]
4598 #[doc(hidden)]
4599 pub struct ISpellCheckerChangedEventHandler_abi(
4600     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4601     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4602     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4603     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, sender: ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4604 );
4605 #[repr(transparent)]
4606 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4607 pub struct ISpellCheckerFactory(::windows::runtime::IUnknown);
4608 impl ISpellCheckerFactory {
4609     #[cfg(feature = "Win32_System_Com")]
SupportedLanguages(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString>4610     pub unsafe fn SupportedLanguages(&self) -> ::windows::runtime::Result<super::System::Com::IEnumString> {
4611         let mut result__: <super::System::Com::IEnumString as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4612         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::System::Com::IEnumString>(result__)
4613     }
4614     #[cfg(feature = "Win32_Foundation")]
IsSupported<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<super::Foundation::BOOL>4615     pub unsafe fn IsSupported<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<super::Foundation::BOOL> {
4616         let mut result__: <super::Foundation::BOOL as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4617         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), languagetag.into_param().abi(), &mut result__).from_abi::<super::Foundation::BOOL>(result__)
4618     }
4619     #[cfg(feature = "Win32_Foundation")]
CreateSpellChecker<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<ISpellChecker>4620     pub unsafe fn CreateSpellChecker<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, languagetag: Param0) -> ::windows::runtime::Result<ISpellChecker> {
4621         let mut result__: <ISpellChecker as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4622         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), languagetag.into_param().abi(), &mut result__).from_abi::<ISpellChecker>(result__)
4623     }
4624 }
4625 unsafe impl ::windows::runtime::Interface for ISpellCheckerFactory {
4626     type Vtable = ISpellCheckerFactory_abi;
4627     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2382465693, 9237, 18039, [191, 8, 121, 78, 166, 31, 148, 187]);
4628 }
4629 impl ::std::convert::From<ISpellCheckerFactory> for ::windows::runtime::IUnknown {
from(value: ISpellCheckerFactory) -> Self4630     fn from(value: ISpellCheckerFactory) -> Self {
4631         unsafe { ::std::mem::transmute(value) }
4632     }
4633 }
4634 impl ::std::convert::From<&ISpellCheckerFactory> for ::windows::runtime::IUnknown {
from(value: &ISpellCheckerFactory) -> Self4635     fn from(value: &ISpellCheckerFactory) -> Self {
4636         ::std::convert::From::from(::std::clone::Clone::clone(value))
4637     }
4638 }
4639 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellCheckerFactory {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4640     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4641         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4642     }
4643 }
4644 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellCheckerFactory {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4645     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4646         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4647     }
4648 }
4649 #[repr(C)]
4650 #[doc(hidden)]
4651 pub struct ISpellCheckerFactory_abi(
4652     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4653     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4654     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4655     #[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4656     #[cfg(not(feature = "Win32_System_Com"))] usize,
4657     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, languagetag: super::Foundation::PWSTR, value: *mut super::Foundation::BOOL) -> ::windows::runtime::HRESULT,
4658     #[cfg(not(feature = "Win32_Foundation"))] usize,
4659     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, languagetag: super::Foundation::PWSTR, value: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4660     #[cfg(not(feature = "Win32_Foundation"))] usize,
4661 );
4662 #[repr(transparent)]
4663 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4664 pub struct ISpellingError(::windows::runtime::IUnknown);
4665 impl ISpellingError {
StartIndex(&self) -> ::windows::runtime::Result<u32>4666     pub unsafe fn StartIndex(&self) -> ::windows::runtime::Result<u32> {
4667         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4668         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4669     }
Length(&self) -> ::windows::runtime::Result<u32>4670     pub unsafe fn Length(&self) -> ::windows::runtime::Result<u32> {
4671         let mut result__: <u32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4672         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
4673     }
CorrectiveAction(&self) -> ::windows::runtime::Result<CORRECTIVE_ACTION>4674     pub unsafe fn CorrectiveAction(&self) -> ::windows::runtime::Result<CORRECTIVE_ACTION> {
4675         let mut result__: <CORRECTIVE_ACTION as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4676         (::windows::runtime::Interface::vtable(self).5)(::std::mem::transmute_copy(self), &mut result__).from_abi::<CORRECTIVE_ACTION>(result__)
4677     }
4678     #[cfg(feature = "Win32_Foundation")]
Replacement(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR>4679     pub unsafe fn Replacement(&self) -> ::windows::runtime::Result<super::Foundation::PWSTR> {
4680         let mut result__: <super::Foundation::PWSTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
4681         (::windows::runtime::Interface::vtable(self).6)(::std::mem::transmute_copy(self), &mut result__).from_abi::<super::Foundation::PWSTR>(result__)
4682     }
4683 }
4684 unsafe impl ::windows::runtime::Interface for ISpellingError {
4685     type Vtable = ISpellingError_abi;
4686     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(3083349345, 64488, 19271, [155, 39, 108, 13, 46, 13, 224, 163]);
4687 }
4688 impl ::std::convert::From<ISpellingError> for ::windows::runtime::IUnknown {
from(value: ISpellingError) -> Self4689     fn from(value: ISpellingError) -> Self {
4690         unsafe { ::std::mem::transmute(value) }
4691     }
4692 }
4693 impl ::std::convert::From<&ISpellingError> for ::windows::runtime::IUnknown {
from(value: &ISpellingError) -> Self4694     fn from(value: &ISpellingError) -> Self {
4695         ::std::convert::From::from(::std::clone::Clone::clone(value))
4696     }
4697 }
4698 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for ISpellingError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4699     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4700         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4701     }
4702 }
4703 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &ISpellingError {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4704     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4705         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4706     }
4707 }
4708 #[repr(C)]
4709 #[doc(hidden)]
4710 pub struct ISpellingError_abi(
4711     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4712     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4713     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4714     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut u32) -> ::windows::runtime::HRESULT,
4715     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut u32) -> ::windows::runtime::HRESULT,
4716     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut CORRECTIVE_ACTION) -> ::windows::runtime::HRESULT,
4717     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, value: *mut super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4718     #[cfg(not(feature = "Win32_Foundation"))] usize,
4719 );
4720 #[repr(transparent)]
4721 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: clone :: Clone, :: std :: fmt :: Debug)]
4722 pub struct IUserDictionariesRegistrar(::windows::runtime::IUnknown);
4723 impl IUserDictionariesRegistrar {
4724     #[cfg(feature = "Win32_Foundation")]
RegisterUserDictionary<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dictionarypath: Param0, languagetag: Param1) -> ::windows::runtime::Result<()>4725     pub unsafe fn RegisterUserDictionary<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dictionarypath: Param0, languagetag: Param1) -> ::windows::runtime::Result<()> {
4726         (::windows::runtime::Interface::vtable(self).3)(::std::mem::transmute_copy(self), dictionarypath.into_param().abi(), languagetag.into_param().abi()).ok()
4727     }
4728     #[cfg(feature = "Win32_Foundation")]
UnregisterUserDictionary<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dictionarypath: Param0, languagetag: Param1) -> ::windows::runtime::Result<()>4729     pub unsafe fn UnregisterUserDictionary<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(&self, dictionarypath: Param0, languagetag: Param1) -> ::windows::runtime::Result<()> {
4730         (::windows::runtime::Interface::vtable(self).4)(::std::mem::transmute_copy(self), dictionarypath.into_param().abi(), languagetag.into_param().abi()).ok()
4731     }
4732 }
4733 unsafe impl ::windows::runtime::Interface for IUserDictionariesRegistrar {
4734     type Vtable = IUserDictionariesRegistrar_abi;
4735     const IID: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2853661573, 3602, 18500, [142, 26, 238, 241, 218, 119, 245, 134]);
4736 }
4737 impl ::std::convert::From<IUserDictionariesRegistrar> for ::windows::runtime::IUnknown {
from(value: IUserDictionariesRegistrar) -> Self4738     fn from(value: IUserDictionariesRegistrar) -> Self {
4739         unsafe { ::std::mem::transmute(value) }
4740     }
4741 }
4742 impl ::std::convert::From<&IUserDictionariesRegistrar> for ::windows::runtime::IUnknown {
from(value: &IUserDictionariesRegistrar) -> Self4743     fn from(value: &IUserDictionariesRegistrar) -> Self {
4744         ::std::convert::From::from(::std::clone::Clone::clone(value))
4745     }
4746 }
4747 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for IUserDictionariesRegistrar {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4748     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4749         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(self))
4750     }
4751 }
4752 impl<'a> ::windows::runtime::IntoParam<'a, ::windows::runtime::IUnknown> for &IUserDictionariesRegistrar {
into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown>4753     fn into_param(self) -> ::windows::runtime::Param<'a, ::windows::runtime::IUnknown> {
4754         ::windows::runtime::Param::Owned(::std::convert::Into::<::windows::runtime::IUnknown>::into(::std::clone::Clone::clone(self)))
4755     }
4756 }
4757 #[repr(C)]
4758 #[doc(hidden)]
4759 pub struct IUserDictionariesRegistrar_abi(
4760     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, iid: &::windows::runtime::GUID, interface: *mut ::windows::runtime::RawPtr) -> ::windows::runtime::HRESULT,
4761     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4762     pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr) -> u32,
4763     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dictionarypath: super::Foundation::PWSTR, languagetag: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4764     #[cfg(not(feature = "Win32_Foundation"))] usize,
4765     #[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::runtime::RawPtr, dictionarypath: super::Foundation::PWSTR, languagetag: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT,
4766     #[cfg(not(feature = "Win32_Foundation"))] usize,
4767 );
4768 #[cfg(feature = "Win32_Foundation")]
4769 #[inline]
IdnToAscii<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpunicodecharstr: Param1, cchunicodechar: i32, lpasciicharstr: super::Foundation::PWSTR, cchasciichar: i32) -> i324770 pub unsafe fn IdnToAscii<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpunicodecharstr: Param1, cchunicodechar: i32, lpasciicharstr: super::Foundation::PWSTR, cchasciichar: i32) -> i32 {
4771     #[cfg(windows)]
4772     {
4773         #[link(name = "windows")]
4774         extern "system" {
4775             fn IdnToAscii(dwflags: u32, lpunicodecharstr: super::Foundation::PWSTR, cchunicodechar: i32, lpasciicharstr: super::Foundation::PWSTR, cchasciichar: i32) -> i32;
4776         }
4777         ::std::mem::transmute(IdnToAscii(::std::mem::transmute(dwflags), lpunicodecharstr.into_param().abi(), ::std::mem::transmute(cchunicodechar), ::std::mem::transmute(lpasciicharstr), ::std::mem::transmute(cchasciichar)))
4778     }
4779     #[cfg(not(windows))]
4780     unimplemented!("Unsupported target OS");
4781 }
4782 #[cfg(feature = "Win32_Foundation")]
4783 #[inline]
IdnToNameprepUnicode<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpunicodecharstr: Param1, cchunicodechar: i32, lpnameprepcharstr: super::Foundation::PWSTR, cchnameprepchar: i32) -> i324784 pub unsafe fn IdnToNameprepUnicode<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpunicodecharstr: Param1, cchunicodechar: i32, lpnameprepcharstr: super::Foundation::PWSTR, cchnameprepchar: i32) -> i32 {
4785     #[cfg(windows)]
4786     {
4787         #[link(name = "windows")]
4788         extern "system" {
4789             fn IdnToNameprepUnicode(dwflags: u32, lpunicodecharstr: super::Foundation::PWSTR, cchunicodechar: i32, lpnameprepcharstr: super::Foundation::PWSTR, cchnameprepchar: i32) -> i32;
4790         }
4791         ::std::mem::transmute(IdnToNameprepUnicode(::std::mem::transmute(dwflags), lpunicodecharstr.into_param().abi(), ::std::mem::transmute(cchunicodechar), ::std::mem::transmute(lpnameprepcharstr), ::std::mem::transmute(cchnameprepchar)))
4792     }
4793     #[cfg(not(windows))]
4794     unimplemented!("Unsupported target OS");
4795 }
4796 #[cfg(feature = "Win32_Foundation")]
4797 #[inline]
IdnToUnicode<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpasciicharstr: Param1, cchasciichar: i32, lpunicodecharstr: super::Foundation::PWSTR, cchunicodechar: i32) -> i324798 pub unsafe fn IdnToUnicode<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lpasciicharstr: Param1, cchasciichar: i32, lpunicodecharstr: super::Foundation::PWSTR, cchunicodechar: i32) -> i32 {
4799     #[cfg(windows)]
4800     {
4801         #[link(name = "windows")]
4802         extern "system" {
4803             fn IdnToUnicode(dwflags: u32, lpasciicharstr: super::Foundation::PWSTR, cchasciichar: i32, lpunicodecharstr: super::Foundation::PWSTR, cchunicodechar: i32) -> i32;
4804         }
4805         ::std::mem::transmute(IdnToUnicode(::std::mem::transmute(dwflags), lpasciicharstr.into_param().abi(), ::std::mem::transmute(cchasciichar), ::std::mem::transmute(lpunicodecharstr), ::std::mem::transmute(cchunicodechar)))
4806     }
4807     #[cfg(not(windows))]
4808     unimplemented!("Unsupported target OS");
4809 }
4810 #[cfg(feature = "Win32_Foundation")]
4811 #[inline]
IsDBCSLeadByte(testchar: u8) -> super::Foundation::BOOL4812 pub unsafe fn IsDBCSLeadByte(testchar: u8) -> super::Foundation::BOOL {
4813     #[cfg(windows)]
4814     {
4815         #[link(name = "windows")]
4816         extern "system" {
4817             fn IsDBCSLeadByte(testchar: u8) -> super::Foundation::BOOL;
4818         }
4819         ::std::mem::transmute(IsDBCSLeadByte(::std::mem::transmute(testchar)))
4820     }
4821     #[cfg(not(windows))]
4822     unimplemented!("Unsupported target OS");
4823 }
4824 #[cfg(feature = "Win32_Foundation")]
4825 #[inline]
IsDBCSLeadByteEx(codepage: u32, testchar: u8) -> super::Foundation::BOOL4826 pub unsafe fn IsDBCSLeadByteEx(codepage: u32, testchar: u8) -> super::Foundation::BOOL {
4827     #[cfg(windows)]
4828     {
4829         #[link(name = "windows")]
4830         extern "system" {
4831             fn IsDBCSLeadByteEx(codepage: u32, testchar: u8) -> super::Foundation::BOOL;
4832         }
4833         ::std::mem::transmute(IsDBCSLeadByteEx(::std::mem::transmute(codepage), ::std::mem::transmute(testchar)))
4834     }
4835     #[cfg(not(windows))]
4836     unimplemented!("Unsupported target OS");
4837 }
4838 #[cfg(feature = "Win32_Foundation")]
4839 #[inline]
IsNLSDefinedString<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, dwflags: u32, lpversioninformation: *const NLSVERSIONINFO, lpstring: Param3, cchstr: i32) -> super::Foundation::BOOL4840 pub unsafe fn IsNLSDefinedString<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, dwflags: u32, lpversioninformation: *const NLSVERSIONINFO, lpstring: Param3, cchstr: i32) -> super::Foundation::BOOL {
4841     #[cfg(windows)]
4842     {
4843         #[link(name = "windows")]
4844         extern "system" {
4845             fn IsNLSDefinedString(function: u32, dwflags: u32, lpversioninformation: *const NLSVERSIONINFO, lpstring: super::Foundation::PWSTR, cchstr: i32) -> super::Foundation::BOOL;
4846         }
4847         ::std::mem::transmute(IsNLSDefinedString(::std::mem::transmute(function), ::std::mem::transmute(dwflags), ::std::mem::transmute(lpversioninformation), lpstring.into_param().abi(), ::std::mem::transmute(cchstr)))
4848     }
4849     #[cfg(not(windows))]
4850     unimplemented!("Unsupported target OS");
4851 }
4852 #[cfg(feature = "Win32_Foundation")]
4853 #[inline]
IsNormalizedString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(normform: NORM_FORM, lpstring: Param1, cwlength: i32) -> super::Foundation::BOOL4854 pub unsafe fn IsNormalizedString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(normform: NORM_FORM, lpstring: Param1, cwlength: i32) -> super::Foundation::BOOL {
4855     #[cfg(windows)]
4856     {
4857         #[link(name = "windows")]
4858         extern "system" {
4859             fn IsNormalizedString(normform: NORM_FORM, lpstring: super::Foundation::PWSTR, cwlength: i32) -> super::Foundation::BOOL;
4860         }
4861         ::std::mem::transmute(IsNormalizedString(::std::mem::transmute(normform), lpstring.into_param().abi(), ::std::mem::transmute(cwlength)))
4862     }
4863     #[cfg(not(windows))]
4864     unimplemented!("Unsupported target OS");
4865 }
4866 #[cfg(feature = "Win32_Foundation")]
4867 #[inline]
IsTextUnicode(lpv: *const ::std::ffi::c_void, isize: i32, lpiresult: *mut IS_TEXT_UNICODE_RESULT) -> super::Foundation::BOOL4868 pub unsafe fn IsTextUnicode(lpv: *const ::std::ffi::c_void, isize: i32, lpiresult: *mut IS_TEXT_UNICODE_RESULT) -> super::Foundation::BOOL {
4869     #[cfg(windows)]
4870     {
4871         #[link(name = "windows")]
4872         extern "system" {
4873             fn IsTextUnicode(lpv: *const ::std::ffi::c_void, isize: i32, lpiresult: *mut IS_TEXT_UNICODE_RESULT) -> super::Foundation::BOOL;
4874         }
4875         ::std::mem::transmute(IsTextUnicode(::std::mem::transmute(lpv), ::std::mem::transmute(isize), ::std::mem::transmute(lpiresult)))
4876     }
4877     #[cfg(not(windows))]
4878     unimplemented!("Unsupported target OS");
4879 }
4880 #[cfg(feature = "Win32_Foundation")]
4881 #[inline]
IsValidCodePage(codepage: u32) -> super::Foundation::BOOL4882 pub unsafe fn IsValidCodePage(codepage: u32) -> super::Foundation::BOOL {
4883     #[cfg(windows)]
4884     {
4885         #[link(name = "windows")]
4886         extern "system" {
4887             fn IsValidCodePage(codepage: u32) -> super::Foundation::BOOL;
4888         }
4889         ::std::mem::transmute(IsValidCodePage(::std::mem::transmute(codepage)))
4890     }
4891     #[cfg(not(windows))]
4892     unimplemented!("Unsupported target OS");
4893 }
4894 #[cfg(feature = "Win32_Foundation")]
4895 #[inline]
IsValidLanguageGroup(languagegroup: u32, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS) -> super::Foundation::BOOL4896 pub unsafe fn IsValidLanguageGroup(languagegroup: u32, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS) -> super::Foundation::BOOL {
4897     #[cfg(windows)]
4898     {
4899         #[link(name = "windows")]
4900         extern "system" {
4901             fn IsValidLanguageGroup(languagegroup: u32, dwflags: ENUM_SYSTEM_LANGUAGE_GROUPS_FLAGS) -> super::Foundation::BOOL;
4902         }
4903         ::std::mem::transmute(IsValidLanguageGroup(::std::mem::transmute(languagegroup), ::std::mem::transmute(dwflags)))
4904     }
4905     #[cfg(not(windows))]
4906     unimplemented!("Unsupported target OS");
4907 }
4908 #[cfg(feature = "Win32_Foundation")]
4909 #[inline]
IsValidLocale(locale: u32, dwflags: IS_VALID_LOCALE_FLAGS) -> super::Foundation::BOOL4910 pub unsafe fn IsValidLocale(locale: u32, dwflags: IS_VALID_LOCALE_FLAGS) -> super::Foundation::BOOL {
4911     #[cfg(windows)]
4912     {
4913         #[link(name = "windows")]
4914         extern "system" {
4915             fn IsValidLocale(locale: u32, dwflags: IS_VALID_LOCALE_FLAGS) -> super::Foundation::BOOL;
4916         }
4917         ::std::mem::transmute(IsValidLocale(::std::mem::transmute(locale), ::std::mem::transmute(dwflags)))
4918     }
4919     #[cfg(not(windows))]
4920     unimplemented!("Unsupported target OS");
4921 }
4922 #[cfg(feature = "Win32_Foundation")]
4923 #[inline]
IsValidLocaleName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0) -> super::Foundation::BOOL4924 pub unsafe fn IsValidLocaleName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lplocalename: Param0) -> super::Foundation::BOOL {
4925     #[cfg(windows)]
4926     {
4927         #[link(name = "windows")]
4928         extern "system" {
4929             fn IsValidLocaleName(lplocalename: super::Foundation::PWSTR) -> super::Foundation::BOOL;
4930         }
4931         ::std::mem::transmute(IsValidLocaleName(lplocalename.into_param().abi()))
4932     }
4933     #[cfg(not(windows))]
4934     unimplemented!("Unsupported target OS");
4935 }
4936 #[cfg(feature = "Win32_Foundation")]
4937 #[inline]
IsValidNLSVersion<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, lplocalename: Param1, lpversioninformation: *const NLSVERSIONINFOEX) -> u324938 pub unsafe fn IsValidNLSVersion<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(function: u32, lplocalename: Param1, lpversioninformation: *const NLSVERSIONINFOEX) -> u32 {
4939     #[cfg(windows)]
4940     {
4941         #[link(name = "windows")]
4942         extern "system" {
4943             fn IsValidNLSVersion(function: u32, lplocalename: super::Foundation::PWSTR, lpversioninformation: *const NLSVERSIONINFOEX) -> u32;
4944         }
4945         ::std::mem::transmute(IsValidNLSVersion(::std::mem::transmute(function), lplocalename.into_param().abi(), ::std::mem::transmute(lpversioninformation)))
4946     }
4947     #[cfg(not(windows))]
4948     unimplemented!("Unsupported target OS");
4949 }
4950 #[cfg(feature = "Win32_Foundation")]
4951 #[inline]
IsWellFormedTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(psztag: Param0) -> u84952 pub unsafe fn IsWellFormedTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(psztag: Param0) -> u8 {
4953     #[cfg(windows)]
4954     {
4955         #[link(name = "windows")]
4956         extern "system" {
4957             fn IsWellFormedTag(psztag: super::Foundation::PWSTR) -> u8;
4958         }
4959         ::std::mem::transmute(IsWellFormedTag(psztag.into_param().abi()))
4960     }
4961     #[cfg(not(windows))]
4962     unimplemented!("Unsupported target OS");
4963 }
4964 #[cfg(feature = "Win32_Foundation")]
4965 pub type LANGGROUPLOCALE_ENUMPROCA = unsafe extern "system" fn(param0: u32, param1: u32, param2: super::Foundation::PSTR, param3: isize) -> super::Foundation::BOOL;
4966 #[cfg(feature = "Win32_Foundation")]
4967 pub type LANGGROUPLOCALE_ENUMPROCW = unsafe extern "system" fn(param0: u32, param1: u32, param2: super::Foundation::PWSTR, param3: isize) -> super::Foundation::BOOL;
4968 #[cfg(feature = "Win32_Foundation")]
4969 pub type LANGUAGEGROUP_ENUMPROCA = unsafe extern "system" fn(param0: u32, param1: super::Foundation::PSTR, param2: super::Foundation::PSTR, param3: u32, param4: isize) -> super::Foundation::BOOL;
4970 #[cfg(feature = "Win32_Foundation")]
4971 pub type LANGUAGEGROUP_ENUMPROCW = unsafe extern "system" fn(param0: u32, param1: super::Foundation::PWSTR, param2: super::Foundation::PWSTR, param3: u32, param4: isize) -> super::Foundation::BOOL;
4972 #[cfg(feature = "Win32_Foundation")]
4973 #[inline]
LCIDToLocaleName(locale: u32, lpname: super::Foundation::PWSTR, cchname: i32, dwflags: u32) -> i324974 pub unsafe fn LCIDToLocaleName(locale: u32, lpname: super::Foundation::PWSTR, cchname: i32, dwflags: u32) -> i32 {
4975     #[cfg(windows)]
4976     {
4977         #[link(name = "windows")]
4978         extern "system" {
4979             fn LCIDToLocaleName(locale: u32, lpname: super::Foundation::PWSTR, cchname: i32, dwflags: u32) -> i32;
4980         }
4981         ::std::mem::transmute(LCIDToLocaleName(::std::mem::transmute(locale), ::std::mem::transmute(lpname), ::std::mem::transmute(cchname), ::std::mem::transmute(dwflags)))
4982     }
4983     #[cfg(not(windows))]
4984     unimplemented!("Unsupported target OS");
4985 }
4986 pub const LCID_ALTERNATE_SORTS: u32 = 4u32;
4987 pub const LCMAP_BYTEREV: u32 = 2048u32;
4988 pub const LCMAP_FULLWIDTH: u32 = 8388608u32;
4989 pub const LCMAP_HALFWIDTH: u32 = 4194304u32;
4990 pub const LCMAP_HASH: u32 = 262144u32;
4991 pub const LCMAP_HIRAGANA: u32 = 1048576u32;
4992 pub const LCMAP_KATAKANA: u32 = 2097152u32;
4993 pub const LCMAP_LINGUISTIC_CASING: u32 = 16777216u32;
4994 pub const LCMAP_LOWERCASE: u32 = 256u32;
4995 pub const LCMAP_SIMPLIFIED_CHINESE: u32 = 33554432u32;
4996 pub const LCMAP_SORTHANDLE: u32 = 536870912u32;
4997 pub const LCMAP_SORTKEY: u32 = 1024u32;
4998 pub const LCMAP_TITLECASE: u32 = 768u32;
4999 pub const LCMAP_TRADITIONAL_CHINESE: u32 = 67108864u32;
5000 pub const LCMAP_UPPERCASE: u32 = 512u32;
5001 #[cfg(feature = "Win32_Foundation")]
5002 #[inline]
LCMapStringA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i325003 pub unsafe fn LCMapStringA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i32 {
5004     #[cfg(windows)]
5005     {
5006         #[link(name = "windows")]
5007         extern "system" {
5008             fn LCMapStringA(locale: u32, dwmapflags: u32, lpsrcstr: super::Foundation::PSTR, cchsrc: i32, lpdeststr: super::Foundation::PSTR, cchdest: i32) -> i32;
5009         }
5010         ::std::mem::transmute(LCMapStringA(::std::mem::transmute(locale), ::std::mem::transmute(dwmapflags), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpdeststr), ::std::mem::transmute(cchdest)))
5011     }
5012     #[cfg(not(windows))]
5013     unimplemented!("Unsupported target OS");
5014 }
5015 #[cfg(feature = "Win32_Foundation")]
5016 #[inline]
LCMapStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lplocalename: Param0, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32, lpversioninformation: *const NLSVERSIONINFO, lpreserved: *const ::std::ffi::c_void, sorthandle: Param8) -> i325017 pub unsafe fn LCMapStringEx<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::LPARAM>>(lplocalename: Param0, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32, lpversioninformation: *const NLSVERSIONINFO, lpreserved: *const ::std::ffi::c_void, sorthandle: Param8) -> i32 {
5018     #[cfg(windows)]
5019     {
5020         #[link(name = "windows")]
5021         extern "system" {
5022             fn LCMapStringEx(lplocalename: super::Foundation::PWSTR, dwmapflags: u32, lpsrcstr: super::Foundation::PWSTR, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32, lpversioninformation: *const NLSVERSIONINFO, lpreserved: *const ::std::ffi::c_void, sorthandle: super::Foundation::LPARAM) -> i32;
5023         }
5024         ::std::mem::transmute(LCMapStringEx(
5025             lplocalename.into_param().abi(),
5026             ::std::mem::transmute(dwmapflags),
5027             lpsrcstr.into_param().abi(),
5028             ::std::mem::transmute(cchsrc),
5029             ::std::mem::transmute(lpdeststr),
5030             ::std::mem::transmute(cchdest),
5031             ::std::mem::transmute(lpversioninformation),
5032             ::std::mem::transmute(lpreserved),
5033             sorthandle.into_param().abi(),
5034         ))
5035     }
5036     #[cfg(not(windows))]
5037     unimplemented!("Unsupported target OS");
5038 }
5039 #[cfg(feature = "Win32_Foundation")]
5040 #[inline]
LCMapStringW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i325041 pub unsafe fn LCMapStringW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, dwmapflags: u32, lpsrcstr: Param2, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i32 {
5042     #[cfg(windows)]
5043     {
5044         #[link(name = "windows")]
5045         extern "system" {
5046             fn LCMapStringW(locale: u32, dwmapflags: u32, lpsrcstr: super::Foundation::PWSTR, cchsrc: i32, lpdeststr: super::Foundation::PWSTR, cchdest: i32) -> i32;
5047         }
5048         ::std::mem::transmute(LCMapStringW(::std::mem::transmute(locale), ::std::mem::transmute(dwmapflags), lpsrcstr.into_param().abi(), ::std::mem::transmute(cchsrc), ::std::mem::transmute(lpdeststr), ::std::mem::transmute(cchdest)))
5049     }
5050     #[cfg(not(windows))]
5051     unimplemented!("Unsupported target OS");
5052 }
5053 pub const LGRPID_ARABIC: u32 = 13u32;
5054 pub const LGRPID_ARMENIAN: u32 = 17u32;
5055 pub const LGRPID_BALTIC: u32 = 3u32;
5056 pub const LGRPID_CENTRAL_EUROPE: u32 = 2u32;
5057 pub const LGRPID_CYRILLIC: u32 = 5u32;
5058 pub const LGRPID_GEORGIAN: u32 = 16u32;
5059 pub const LGRPID_GREEK: u32 = 4u32;
5060 pub const LGRPID_HEBREW: u32 = 12u32;
5061 pub const LGRPID_INDIC: u32 = 15u32;
5062 pub const LGRPID_JAPANESE: u32 = 7u32;
5063 pub const LGRPID_KOREAN: u32 = 8u32;
5064 pub const LGRPID_SIMPLIFIED_CHINESE: u32 = 10u32;
5065 pub const LGRPID_THAI: u32 = 11u32;
5066 pub const LGRPID_TRADITIONAL_CHINESE: u32 = 9u32;
5067 pub const LGRPID_TURKIC: u32 = 6u32;
5068 pub const LGRPID_TURKISH: u32 = 6u32;
5069 pub const LGRPID_VIETNAMESE: u32 = 14u32;
5070 pub const LGRPID_WESTERN_EUROPE: u32 = 1u32;
5071 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5072 #[repr(C)]
5073 pub struct LOCALESIGNATURE {
5074     pub lsUsb: [u32; 4],
5075     pub lsCsbDefault: [u32; 2],
5076     pub lsCsbSupported: [u32; 2],
5077 }
5078 impl LOCALESIGNATURE {}
5079 impl ::std::default::Default for LOCALESIGNATURE {
default() -> Self5080     fn default() -> Self {
5081         unsafe { ::std::mem::zeroed() }
5082     }
5083 }
5084 impl ::std::fmt::Debug for LOCALESIGNATURE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5085     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5086         fmt.debug_struct("LOCALESIGNATURE").field("lsUsb", &self.lsUsb).field("lsCsbDefault", &self.lsCsbDefault).field("lsCsbSupported", &self.lsCsbSupported).finish()
5087     }
5088 }
5089 impl ::std::cmp::PartialEq for LOCALESIGNATURE {
eq(&self, other: &Self) -> bool5090     fn eq(&self, other: &Self) -> bool {
5091         self.lsUsb == other.lsUsb && self.lsCsbDefault == other.lsCsbDefault && self.lsCsbSupported == other.lsCsbSupported
5092     }
5093 }
5094 impl ::std::cmp::Eq for LOCALESIGNATURE {}
5095 unsafe impl ::windows::runtime::Abi for LOCALESIGNATURE {
5096     type Abi = Self;
5097     type DefaultType = Self;
5098 }
5099 pub const LOCALE_ALL: u32 = 0u32;
5100 pub const LOCALE_ALLOW_NEUTRAL_NAMES: u32 = 134217728u32;
5101 pub const LOCALE_ALTERNATE_SORTS: u32 = 4u32;
5102 #[cfg(feature = "Win32_Foundation")]
5103 pub type LOCALE_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR) -> super::Foundation::BOOL;
5104 #[cfg(feature = "Win32_Foundation")]
5105 pub type LOCALE_ENUMPROCEX = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: u32, param2: super::Foundation::LPARAM) -> super::Foundation::BOOL;
5106 #[cfg(feature = "Win32_Foundation")]
5107 pub type LOCALE_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR) -> super::Foundation::BOOL;
5108 pub const LOCALE_FONTSIGNATURE: u32 = 88u32;
5109 pub const LOCALE_ICALENDARTYPE: u32 = 4105u32;
5110 pub const LOCALE_ICENTURY: u32 = 36u32;
5111 pub const LOCALE_ICONSTRUCTEDLOCALE: u32 = 125u32;
5112 pub const LOCALE_ICOUNTRY: u32 = 5u32;
5113 pub const LOCALE_ICURRDIGITS: u32 = 25u32;
5114 pub const LOCALE_ICURRENCY: u32 = 27u32;
5115 pub const LOCALE_IDATE: u32 = 33u32;
5116 pub const LOCALE_IDAYLZERO: u32 = 38u32;
5117 pub const LOCALE_IDEFAULTANSICODEPAGE: u32 = 4100u32;
5118 pub const LOCALE_IDEFAULTCODEPAGE: u32 = 11u32;
5119 pub const LOCALE_IDEFAULTCOUNTRY: u32 = 10u32;
5120 pub const LOCALE_IDEFAULTEBCDICCODEPAGE: u32 = 4114u32;
5121 pub const LOCALE_IDEFAULTLANGUAGE: u32 = 9u32;
5122 pub const LOCALE_IDEFAULTMACCODEPAGE: u32 = 4113u32;
5123 pub const LOCALE_IDIALINGCODE: u32 = 5u32;
5124 pub const LOCALE_IDIGITS: u32 = 17u32;
5125 pub const LOCALE_IDIGITSUBSTITUTION: u32 = 4116u32;
5126 pub const LOCALE_IFIRSTDAYOFWEEK: u32 = 4108u32;
5127 pub const LOCALE_IFIRSTWEEKOFYEAR: u32 = 4109u32;
5128 pub const LOCALE_IGEOID: u32 = 91u32;
5129 pub const LOCALE_IINTLCURRDIGITS: u32 = 26u32;
5130 pub const LOCALE_ILANGUAGE: u32 = 1u32;
5131 pub const LOCALE_ILDATE: u32 = 34u32;
5132 pub const LOCALE_ILZERO: u32 = 18u32;
5133 pub const LOCALE_IMEASURE: u32 = 13u32;
5134 pub const LOCALE_IMONLZERO: u32 = 39u32;
5135 pub const LOCALE_INEGATIVEPERCENT: u32 = 116u32;
5136 pub const LOCALE_INEGCURR: u32 = 28u32;
5137 pub const LOCALE_INEGNUMBER: u32 = 4112u32;
5138 pub const LOCALE_INEGSEPBYSPACE: u32 = 87u32;
5139 pub const LOCALE_INEGSIGNPOSN: u32 = 83u32;
5140 pub const LOCALE_INEGSYMPRECEDES: u32 = 86u32;
5141 pub const LOCALE_INEUTRAL: u32 = 113u32;
5142 pub const LOCALE_IOPTIONALCALENDAR: u32 = 4107u32;
5143 pub const LOCALE_IPAPERSIZE: u32 = 4106u32;
5144 pub const LOCALE_IPOSITIVEPERCENT: u32 = 117u32;
5145 pub const LOCALE_IPOSSEPBYSPACE: u32 = 85u32;
5146 pub const LOCALE_IPOSSIGNPOSN: u32 = 82u32;
5147 pub const LOCALE_IPOSSYMPRECEDES: u32 = 84u32;
5148 pub const LOCALE_IREADINGLAYOUT: u32 = 112u32;
5149 pub const LOCALE_ITIME: u32 = 35u32;
5150 pub const LOCALE_ITIMEMARKPOSN: u32 = 4101u32;
5151 pub const LOCALE_ITLZERO: u32 = 37u32;
5152 pub const LOCALE_IUSEUTF8LEGACYACP: u32 = 1638u32;
5153 pub const LOCALE_IUSEUTF8LEGACYOEMCP: u32 = 2457u32;
5154 pub const LOCALE_NEUTRALDATA: u32 = 16u32;
5155 pub const LOCALE_NOUSEROVERRIDE: u32 = 2147483648u32;
5156 pub const LOCALE_REPLACEMENT: u32 = 8u32;
5157 pub const LOCALE_RETURN_GENITIVE_NAMES: u32 = 268435456u32;
5158 pub const LOCALE_RETURN_NUMBER: u32 = 536870912u32;
5159 pub const LOCALE_S1159: u32 = 40u32;
5160 pub const LOCALE_S2359: u32 = 41u32;
5161 pub const LOCALE_SABBREVCTRYNAME: u32 = 7u32;
5162 pub const LOCALE_SABBREVDAYNAME1: u32 = 49u32;
5163 pub const LOCALE_SABBREVDAYNAME2: u32 = 50u32;
5164 pub const LOCALE_SABBREVDAYNAME3: u32 = 51u32;
5165 pub const LOCALE_SABBREVDAYNAME4: u32 = 52u32;
5166 pub const LOCALE_SABBREVDAYNAME5: u32 = 53u32;
5167 pub const LOCALE_SABBREVDAYNAME6: u32 = 54u32;
5168 pub const LOCALE_SABBREVDAYNAME7: u32 = 55u32;
5169 pub const LOCALE_SABBREVLANGNAME: u32 = 3u32;
5170 pub const LOCALE_SABBREVMONTHNAME1: u32 = 68u32;
5171 pub const LOCALE_SABBREVMONTHNAME10: u32 = 77u32;
5172 pub const LOCALE_SABBREVMONTHNAME11: u32 = 78u32;
5173 pub const LOCALE_SABBREVMONTHNAME12: u32 = 79u32;
5174 pub const LOCALE_SABBREVMONTHNAME13: u32 = 4111u32;
5175 pub const LOCALE_SABBREVMONTHNAME2: u32 = 69u32;
5176 pub const LOCALE_SABBREVMONTHNAME3: u32 = 70u32;
5177 pub const LOCALE_SABBREVMONTHNAME4: u32 = 71u32;
5178 pub const LOCALE_SABBREVMONTHNAME5: u32 = 72u32;
5179 pub const LOCALE_SABBREVMONTHNAME6: u32 = 73u32;
5180 pub const LOCALE_SABBREVMONTHNAME7: u32 = 74u32;
5181 pub const LOCALE_SABBREVMONTHNAME8: u32 = 75u32;
5182 pub const LOCALE_SABBREVMONTHNAME9: u32 = 76u32;
5183 pub const LOCALE_SAM: u32 = 40u32;
5184 pub const LOCALE_SCONSOLEFALLBACKNAME: u32 = 110u32;
5185 pub const LOCALE_SCOUNTRY: u32 = 6u32;
5186 pub const LOCALE_SCURRENCY: u32 = 20u32;
5187 pub const LOCALE_SDATE: u32 = 29u32;
5188 pub const LOCALE_SDAYNAME1: u32 = 42u32;
5189 pub const LOCALE_SDAYNAME2: u32 = 43u32;
5190 pub const LOCALE_SDAYNAME3: u32 = 44u32;
5191 pub const LOCALE_SDAYNAME4: u32 = 45u32;
5192 pub const LOCALE_SDAYNAME5: u32 = 46u32;
5193 pub const LOCALE_SDAYNAME6: u32 = 47u32;
5194 pub const LOCALE_SDAYNAME7: u32 = 48u32;
5195 pub const LOCALE_SDECIMAL: u32 = 14u32;
5196 pub const LOCALE_SDURATION: u32 = 93u32;
5197 pub const LOCALE_SENGCOUNTRY: u32 = 4098u32;
5198 pub const LOCALE_SENGCURRNAME: u32 = 4103u32;
5199 pub const LOCALE_SENGLANGUAGE: u32 = 4097u32;
5200 pub const LOCALE_SENGLISHCOUNTRYNAME: u32 = 4098u32;
5201 pub const LOCALE_SENGLISHDISPLAYNAME: u32 = 114u32;
5202 pub const LOCALE_SENGLISHLANGUAGENAME: u32 = 4097u32;
5203 pub const LOCALE_SGROUPING: u32 = 16u32;
5204 pub const LOCALE_SINTLSYMBOL: u32 = 21u32;
5205 pub const LOCALE_SISO3166CTRYNAME: u32 = 90u32;
5206 pub const LOCALE_SISO3166CTRYNAME2: u32 = 104u32;
5207 pub const LOCALE_SISO639LANGNAME: u32 = 89u32;
5208 pub const LOCALE_SISO639LANGNAME2: u32 = 103u32;
5209 pub const LOCALE_SKEYBOARDSTOINSTALL: u32 = 94u32;
5210 pub const LOCALE_SLANGDISPLAYNAME: u32 = 111u32;
5211 pub const LOCALE_SLANGUAGE: u32 = 2u32;
5212 pub const LOCALE_SLIST: u32 = 12u32;
5213 pub const LOCALE_SLOCALIZEDCOUNTRYNAME: u32 = 6u32;
5214 pub const LOCALE_SLOCALIZEDDISPLAYNAME: u32 = 2u32;
5215 pub const LOCALE_SLOCALIZEDLANGUAGENAME: u32 = 111u32;
5216 pub const LOCALE_SLONGDATE: u32 = 32u32;
5217 pub const LOCALE_SMONDECIMALSEP: u32 = 22u32;
5218 pub const LOCALE_SMONGROUPING: u32 = 24u32;
5219 pub const LOCALE_SMONTHDAY: u32 = 120u32;
5220 pub const LOCALE_SMONTHNAME1: u32 = 56u32;
5221 pub const LOCALE_SMONTHNAME10: u32 = 65u32;
5222 pub const LOCALE_SMONTHNAME11: u32 = 66u32;
5223 pub const LOCALE_SMONTHNAME12: u32 = 67u32;
5224 pub const LOCALE_SMONTHNAME13: u32 = 4110u32;
5225 pub const LOCALE_SMONTHNAME2: u32 = 57u32;
5226 pub const LOCALE_SMONTHNAME3: u32 = 58u32;
5227 pub const LOCALE_SMONTHNAME4: u32 = 59u32;
5228 pub const LOCALE_SMONTHNAME5: u32 = 60u32;
5229 pub const LOCALE_SMONTHNAME6: u32 = 61u32;
5230 pub const LOCALE_SMONTHNAME7: u32 = 62u32;
5231 pub const LOCALE_SMONTHNAME8: u32 = 63u32;
5232 pub const LOCALE_SMONTHNAME9: u32 = 64u32;
5233 pub const LOCALE_SMONTHOUSANDSEP: u32 = 23u32;
5234 pub const LOCALE_SNAME: u32 = 92u32;
5235 pub const LOCALE_SNAN: u32 = 105u32;
5236 pub const LOCALE_SNATIVECOUNTRYNAME: u32 = 8u32;
5237 pub const LOCALE_SNATIVECTRYNAME: u32 = 8u32;
5238 pub const LOCALE_SNATIVECURRNAME: u32 = 4104u32;
5239 pub const LOCALE_SNATIVEDIGITS: u32 = 19u32;
5240 pub const LOCALE_SNATIVEDISPLAYNAME: u32 = 115u32;
5241 pub const LOCALE_SNATIVELANGNAME: u32 = 4u32;
5242 pub const LOCALE_SNATIVELANGUAGENAME: u32 = 4u32;
5243 pub const LOCALE_SNEGATIVESIGN: u32 = 81u32;
5244 pub const LOCALE_SNEGINFINITY: u32 = 107u32;
5245 pub const LOCALE_SOPENTYPELANGUAGETAG: u32 = 122u32;
5246 pub const LOCALE_SPARENT: u32 = 109u32;
5247 pub const LOCALE_SPECIFICDATA: u32 = 32u32;
5248 pub const LOCALE_SPERCENT: u32 = 118u32;
5249 pub const LOCALE_SPERMILLE: u32 = 119u32;
5250 pub const LOCALE_SPM: u32 = 41u32;
5251 pub const LOCALE_SPOSINFINITY: u32 = 106u32;
5252 pub const LOCALE_SPOSITIVESIGN: u32 = 80u32;
5253 pub const LOCALE_SRELATIVELONGDATE: u32 = 124u32;
5254 pub const LOCALE_SSCRIPTS: u32 = 108u32;
5255 pub const LOCALE_SSHORTDATE: u32 = 31u32;
5256 pub const LOCALE_SSHORTESTAM: u32 = 126u32;
5257 pub const LOCALE_SSHORTESTDAYNAME1: u32 = 96u32;
5258 pub const LOCALE_SSHORTESTDAYNAME2: u32 = 97u32;
5259 pub const LOCALE_SSHORTESTDAYNAME3: u32 = 98u32;
5260 pub const LOCALE_SSHORTESTDAYNAME4: u32 = 99u32;
5261 pub const LOCALE_SSHORTESTDAYNAME5: u32 = 100u32;
5262 pub const LOCALE_SSHORTESTDAYNAME6: u32 = 101u32;
5263 pub const LOCALE_SSHORTESTDAYNAME7: u32 = 102u32;
5264 pub const LOCALE_SSHORTESTPM: u32 = 127u32;
5265 pub const LOCALE_SSHORTTIME: u32 = 121u32;
5266 pub const LOCALE_SSORTLOCALE: u32 = 123u32;
5267 pub const LOCALE_SSORTNAME: u32 = 4115u32;
5268 pub const LOCALE_STHOUSAND: u32 = 15u32;
5269 pub const LOCALE_STIME: u32 = 30u32;
5270 pub const LOCALE_STIMEFORMAT: u32 = 4099u32;
5271 pub const LOCALE_SUPPLEMENTAL: u32 = 2u32;
5272 pub const LOCALE_SYEARMONTH: u32 = 4102u32;
5273 pub const LOCALE_USE_CP_ACP: u32 = 1073741824u32;
5274 pub const LOCALE_WINDOWS: u32 = 1u32;
5275 pub const LOWLEVEL_SERVICE_TYPES: u32 = 2u32;
5276 pub const LOW_SURROGATE_END: u32 = 57343u32;
5277 pub const LOW_SURROGATE_START: u32 = 56320u32;
5278 #[cfg(feature = "Win32_Foundation")]
5279 #[inline]
LocaleNameToLCID<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpname: Param0, dwflags: u32) -> u325280 pub unsafe fn LocaleNameToLCID<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpname: Param0, dwflags: u32) -> u32 {
5281     #[cfg(windows)]
5282     {
5283         #[link(name = "windows")]
5284         extern "system" {
5285             fn LocaleNameToLCID(lpname: super::Foundation::PWSTR, dwflags: u32) -> u32;
5286         }
5287         ::std::mem::transmute(LocaleNameToLCID(lpname.into_param().abi(), ::std::mem::transmute(dwflags)))
5288     }
5289     #[cfg(not(windows))]
5290     unimplemented!("Unsupported target OS");
5291 }
5292 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5293 #[repr(C)]
5294 #[cfg(feature = "Win32_Foundation")]
5295 pub struct MAPPING_DATA_RANGE {
5296     pub dwStartIndex: u32,
5297     pub dwEndIndex: u32,
5298     pub pszDescription: super::Foundation::PWSTR,
5299     pub dwDescriptionLength: u32,
5300     pub pData: *mut ::std::ffi::c_void,
5301     pub dwDataSize: u32,
5302     pub pszContentType: super::Foundation::PWSTR,
5303     pub prgActionIds: *mut super::Foundation::PWSTR,
5304     pub dwActionsCount: u32,
5305     pub prgActionDisplayNames: *mut super::Foundation::PWSTR,
5306 }
5307 #[cfg(feature = "Win32_Foundation")]
5308 impl MAPPING_DATA_RANGE {}
5309 #[cfg(feature = "Win32_Foundation")]
5310 impl ::std::default::Default for MAPPING_DATA_RANGE {
default() -> Self5311     fn default() -> Self {
5312         unsafe { ::std::mem::zeroed() }
5313     }
5314 }
5315 #[cfg(feature = "Win32_Foundation")]
5316 impl ::std::fmt::Debug for MAPPING_DATA_RANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5317     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5318         fmt.debug_struct("MAPPING_DATA_RANGE")
5319             .field("dwStartIndex", &self.dwStartIndex)
5320             .field("dwEndIndex", &self.dwEndIndex)
5321             .field("pszDescription", &self.pszDescription)
5322             .field("dwDescriptionLength", &self.dwDescriptionLength)
5323             .field("pData", &self.pData)
5324             .field("dwDataSize", &self.dwDataSize)
5325             .field("pszContentType", &self.pszContentType)
5326             .field("prgActionIds", &self.prgActionIds)
5327             .field("dwActionsCount", &self.dwActionsCount)
5328             .field("prgActionDisplayNames", &self.prgActionDisplayNames)
5329             .finish()
5330     }
5331 }
5332 #[cfg(feature = "Win32_Foundation")]
5333 impl ::std::cmp::PartialEq for MAPPING_DATA_RANGE {
eq(&self, other: &Self) -> bool5334     fn eq(&self, other: &Self) -> bool {
5335         self.dwStartIndex == other.dwStartIndex && self.dwEndIndex == other.dwEndIndex && self.pszDescription == other.pszDescription && self.dwDescriptionLength == other.dwDescriptionLength && self.pData == other.pData && self.dwDataSize == other.dwDataSize && self.pszContentType == other.pszContentType && self.prgActionIds == other.prgActionIds && self.dwActionsCount == other.dwActionsCount && self.prgActionDisplayNames == other.prgActionDisplayNames
5336     }
5337 }
5338 #[cfg(feature = "Win32_Foundation")]
5339 impl ::std::cmp::Eq for MAPPING_DATA_RANGE {}
5340 #[cfg(feature = "Win32_Foundation")]
5341 unsafe impl ::windows::runtime::Abi for MAPPING_DATA_RANGE {
5342     type Abi = Self;
5343     type DefaultType = Self;
5344 }
5345 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5346 #[repr(C)]
5347 #[cfg(feature = "Win32_Foundation")]
5348 pub struct MAPPING_ENUM_OPTIONS {
5349     pub Size: usize,
5350     pub pszCategory: super::Foundation::PWSTR,
5351     pub pszInputLanguage: super::Foundation::PWSTR,
5352     pub pszOutputLanguage: super::Foundation::PWSTR,
5353     pub pszInputScript: super::Foundation::PWSTR,
5354     pub pszOutputScript: super::Foundation::PWSTR,
5355     pub pszInputContentType: super::Foundation::PWSTR,
5356     pub pszOutputContentType: super::Foundation::PWSTR,
5357     pub pGuid: *mut ::windows::runtime::GUID,
5358     pub _bitfield: u32,
5359 }
5360 #[cfg(feature = "Win32_Foundation")]
5361 impl MAPPING_ENUM_OPTIONS {}
5362 #[cfg(feature = "Win32_Foundation")]
5363 impl ::std::default::Default for MAPPING_ENUM_OPTIONS {
default() -> Self5364     fn default() -> Self {
5365         unsafe { ::std::mem::zeroed() }
5366     }
5367 }
5368 #[cfg(feature = "Win32_Foundation")]
5369 impl ::std::fmt::Debug for MAPPING_ENUM_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5370     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5371         fmt.debug_struct("MAPPING_ENUM_OPTIONS")
5372             .field("Size", &self.Size)
5373             .field("pszCategory", &self.pszCategory)
5374             .field("pszInputLanguage", &self.pszInputLanguage)
5375             .field("pszOutputLanguage", &self.pszOutputLanguage)
5376             .field("pszInputScript", &self.pszInputScript)
5377             .field("pszOutputScript", &self.pszOutputScript)
5378             .field("pszInputContentType", &self.pszInputContentType)
5379             .field("pszOutputContentType", &self.pszOutputContentType)
5380             .field("pGuid", &self.pGuid)
5381             .field("_bitfield", &self._bitfield)
5382             .finish()
5383     }
5384 }
5385 #[cfg(feature = "Win32_Foundation")]
5386 impl ::std::cmp::PartialEq for MAPPING_ENUM_OPTIONS {
eq(&self, other: &Self) -> bool5387     fn eq(&self, other: &Self) -> bool {
5388         self.Size == other.Size && self.pszCategory == other.pszCategory && self.pszInputLanguage == other.pszInputLanguage && self.pszOutputLanguage == other.pszOutputLanguage && self.pszInputScript == other.pszInputScript && self.pszOutputScript == other.pszOutputScript && self.pszInputContentType == other.pszInputContentType && self.pszOutputContentType == other.pszOutputContentType && self.pGuid == other.pGuid && self._bitfield == other._bitfield
5389     }
5390 }
5391 #[cfg(feature = "Win32_Foundation")]
5392 impl ::std::cmp::Eq for MAPPING_ENUM_OPTIONS {}
5393 #[cfg(feature = "Win32_Foundation")]
5394 unsafe impl ::windows::runtime::Abi for MAPPING_ENUM_OPTIONS {
5395     type Abi = Self;
5396     type DefaultType = Self;
5397 }
5398 #[derive(:: std :: clone :: Clone)]
5399 #[repr(C)]
5400 #[cfg(feature = "Win32_Foundation")]
5401 pub struct MAPPING_OPTIONS {
5402     pub Size: usize,
5403     pub pszInputLanguage: super::Foundation::PWSTR,
5404     pub pszOutputLanguage: super::Foundation::PWSTR,
5405     pub pszInputScript: super::Foundation::PWSTR,
5406     pub pszOutputScript: super::Foundation::PWSTR,
5407     pub pszInputContentType: super::Foundation::PWSTR,
5408     pub pszOutputContentType: super::Foundation::PWSTR,
5409     pub pszUILanguage: super::Foundation::PWSTR,
5410     pub pfnRecognizeCallback: ::std::option::Option<PFN_MAPPINGCALLBACKPROC>,
5411     pub pRecognizeCallerData: *mut ::std::ffi::c_void,
5412     pub dwRecognizeCallerDataSize: u32,
5413     pub pfnActionCallback: ::std::option::Option<PFN_MAPPINGCALLBACKPROC>,
5414     pub pActionCallerData: *mut ::std::ffi::c_void,
5415     pub dwActionCallerDataSize: u32,
5416     pub dwServiceFlag: u32,
5417     pub _bitfield: u32,
5418 }
5419 #[cfg(feature = "Win32_Foundation")]
5420 impl MAPPING_OPTIONS {}
5421 #[cfg(feature = "Win32_Foundation")]
5422 impl ::std::default::Default for MAPPING_OPTIONS {
default() -> Self5423     fn default() -> Self {
5424         unsafe { ::std::mem::zeroed() }
5425     }
5426 }
5427 #[cfg(feature = "Win32_Foundation")]
5428 impl ::std::fmt::Debug for MAPPING_OPTIONS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5429     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5430         fmt.debug_struct("MAPPING_OPTIONS")
5431             .field("Size", &self.Size)
5432             .field("pszInputLanguage", &self.pszInputLanguage)
5433             .field("pszOutputLanguage", &self.pszOutputLanguage)
5434             .field("pszInputScript", &self.pszInputScript)
5435             .field("pszOutputScript", &self.pszOutputScript)
5436             .field("pszInputContentType", &self.pszInputContentType)
5437             .field("pszOutputContentType", &self.pszOutputContentType)
5438             .field("pszUILanguage", &self.pszUILanguage)
5439             .field("pRecognizeCallerData", &self.pRecognizeCallerData)
5440             .field("dwRecognizeCallerDataSize", &self.dwRecognizeCallerDataSize)
5441             .field("pActionCallerData", &self.pActionCallerData)
5442             .field("dwActionCallerDataSize", &self.dwActionCallerDataSize)
5443             .field("dwServiceFlag", &self.dwServiceFlag)
5444             .field("_bitfield", &self._bitfield)
5445             .finish()
5446     }
5447 }
5448 #[cfg(feature = "Win32_Foundation")]
5449 impl ::std::cmp::PartialEq for MAPPING_OPTIONS {
eq(&self, other: &Self) -> bool5450     fn eq(&self, other: &Self) -> bool {
5451         self.Size == other.Size
5452             && self.pszInputLanguage == other.pszInputLanguage
5453             && self.pszOutputLanguage == other.pszOutputLanguage
5454             && self.pszInputScript == other.pszInputScript
5455             && self.pszOutputScript == other.pszOutputScript
5456             && self.pszInputContentType == other.pszInputContentType
5457             && self.pszOutputContentType == other.pszOutputContentType
5458             && self.pszUILanguage == other.pszUILanguage
5459             && self.pfnRecognizeCallback.map(|f| f as usize) == other.pfnRecognizeCallback.map(|f| f as usize)
5460             && self.pRecognizeCallerData == other.pRecognizeCallerData
5461             && self.dwRecognizeCallerDataSize == other.dwRecognizeCallerDataSize
5462             && self.pfnActionCallback.map(|f| f as usize) == other.pfnActionCallback.map(|f| f as usize)
5463             && self.pActionCallerData == other.pActionCallerData
5464             && self.dwActionCallerDataSize == other.dwActionCallerDataSize
5465             && self.dwServiceFlag == other.dwServiceFlag
5466             && self._bitfield == other._bitfield
5467     }
5468 }
5469 #[cfg(feature = "Win32_Foundation")]
5470 impl ::std::cmp::Eq for MAPPING_OPTIONS {}
5471 #[cfg(feature = "Win32_Foundation")]
5472 unsafe impl ::windows::runtime::Abi for MAPPING_OPTIONS {
5473     type Abi = ::std::mem::ManuallyDrop<Self>;
5474     type DefaultType = Self;
5475 }
5476 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5477 #[repr(C)]
5478 #[cfg(feature = "Win32_Foundation")]
5479 pub struct MAPPING_PROPERTY_BAG {
5480     pub Size: usize,
5481     pub prgResultRanges: *mut MAPPING_DATA_RANGE,
5482     pub dwRangesCount: u32,
5483     pub pServiceData: *mut ::std::ffi::c_void,
5484     pub dwServiceDataSize: u32,
5485     pub pCallerData: *mut ::std::ffi::c_void,
5486     pub dwCallerDataSize: u32,
5487     pub pContext: *mut ::std::ffi::c_void,
5488 }
5489 #[cfg(feature = "Win32_Foundation")]
5490 impl MAPPING_PROPERTY_BAG {}
5491 #[cfg(feature = "Win32_Foundation")]
5492 impl ::std::default::Default for MAPPING_PROPERTY_BAG {
default() -> Self5493     fn default() -> Self {
5494         unsafe { ::std::mem::zeroed() }
5495     }
5496 }
5497 #[cfg(feature = "Win32_Foundation")]
5498 impl ::std::fmt::Debug for MAPPING_PROPERTY_BAG {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5499     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5500         fmt.debug_struct("MAPPING_PROPERTY_BAG")
5501             .field("Size", &self.Size)
5502             .field("prgResultRanges", &self.prgResultRanges)
5503             .field("dwRangesCount", &self.dwRangesCount)
5504             .field("pServiceData", &self.pServiceData)
5505             .field("dwServiceDataSize", &self.dwServiceDataSize)
5506             .field("pCallerData", &self.pCallerData)
5507             .field("dwCallerDataSize", &self.dwCallerDataSize)
5508             .field("pContext", &self.pContext)
5509             .finish()
5510     }
5511 }
5512 #[cfg(feature = "Win32_Foundation")]
5513 impl ::std::cmp::PartialEq for MAPPING_PROPERTY_BAG {
eq(&self, other: &Self) -> bool5514     fn eq(&self, other: &Self) -> bool {
5515         self.Size == other.Size && self.prgResultRanges == other.prgResultRanges && self.dwRangesCount == other.dwRangesCount && self.pServiceData == other.pServiceData && self.dwServiceDataSize == other.dwServiceDataSize && self.pCallerData == other.pCallerData && self.dwCallerDataSize == other.dwCallerDataSize && self.pContext == other.pContext
5516     }
5517 }
5518 #[cfg(feature = "Win32_Foundation")]
5519 impl ::std::cmp::Eq for MAPPING_PROPERTY_BAG {}
5520 #[cfg(feature = "Win32_Foundation")]
5521 unsafe impl ::windows::runtime::Abi for MAPPING_PROPERTY_BAG {
5522     type Abi = Self;
5523     type DefaultType = Self;
5524 }
5525 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5526 #[repr(C)]
5527 #[cfg(feature = "Win32_Foundation")]
5528 pub struct MAPPING_SERVICE_INFO {
5529     pub Size: usize,
5530     pub pszCopyright: super::Foundation::PWSTR,
5531     pub wMajorVersion: u16,
5532     pub wMinorVersion: u16,
5533     pub wBuildVersion: u16,
5534     pub wStepVersion: u16,
5535     pub dwInputContentTypesCount: u32,
5536     pub prgInputContentTypes: *mut super::Foundation::PWSTR,
5537     pub dwOutputContentTypesCount: u32,
5538     pub prgOutputContentTypes: *mut super::Foundation::PWSTR,
5539     pub dwInputLanguagesCount: u32,
5540     pub prgInputLanguages: *mut super::Foundation::PWSTR,
5541     pub dwOutputLanguagesCount: u32,
5542     pub prgOutputLanguages: *mut super::Foundation::PWSTR,
5543     pub dwInputScriptsCount: u32,
5544     pub prgInputScripts: *mut super::Foundation::PWSTR,
5545     pub dwOutputScriptsCount: u32,
5546     pub prgOutputScripts: *mut super::Foundation::PWSTR,
5547     pub guid: ::windows::runtime::GUID,
5548     pub pszCategory: super::Foundation::PWSTR,
5549     pub pszDescription: super::Foundation::PWSTR,
5550     pub dwPrivateDataSize: u32,
5551     pub pPrivateData: *mut ::std::ffi::c_void,
5552     pub pContext: *mut ::std::ffi::c_void,
5553     pub _bitfield: u32,
5554 }
5555 #[cfg(feature = "Win32_Foundation")]
5556 impl MAPPING_SERVICE_INFO {}
5557 #[cfg(feature = "Win32_Foundation")]
5558 impl ::std::default::Default for MAPPING_SERVICE_INFO {
default() -> Self5559     fn default() -> Self {
5560         unsafe { ::std::mem::zeroed() }
5561     }
5562 }
5563 #[cfg(feature = "Win32_Foundation")]
5564 impl ::std::fmt::Debug for MAPPING_SERVICE_INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5565     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5566         fmt.debug_struct("MAPPING_SERVICE_INFO")
5567             .field("Size", &self.Size)
5568             .field("pszCopyright", &self.pszCopyright)
5569             .field("wMajorVersion", &self.wMajorVersion)
5570             .field("wMinorVersion", &self.wMinorVersion)
5571             .field("wBuildVersion", &self.wBuildVersion)
5572             .field("wStepVersion", &self.wStepVersion)
5573             .field("dwInputContentTypesCount", &self.dwInputContentTypesCount)
5574             .field("prgInputContentTypes", &self.prgInputContentTypes)
5575             .field("dwOutputContentTypesCount", &self.dwOutputContentTypesCount)
5576             .field("prgOutputContentTypes", &self.prgOutputContentTypes)
5577             .field("dwInputLanguagesCount", &self.dwInputLanguagesCount)
5578             .field("prgInputLanguages", &self.prgInputLanguages)
5579             .field("dwOutputLanguagesCount", &self.dwOutputLanguagesCount)
5580             .field("prgOutputLanguages", &self.prgOutputLanguages)
5581             .field("dwInputScriptsCount", &self.dwInputScriptsCount)
5582             .field("prgInputScripts", &self.prgInputScripts)
5583             .field("dwOutputScriptsCount", &self.dwOutputScriptsCount)
5584             .field("prgOutputScripts", &self.prgOutputScripts)
5585             .field("guid", &self.guid)
5586             .field("pszCategory", &self.pszCategory)
5587             .field("pszDescription", &self.pszDescription)
5588             .field("dwPrivateDataSize", &self.dwPrivateDataSize)
5589             .field("pPrivateData", &self.pPrivateData)
5590             .field("pContext", &self.pContext)
5591             .field("_bitfield", &self._bitfield)
5592             .finish()
5593     }
5594 }
5595 #[cfg(feature = "Win32_Foundation")]
5596 impl ::std::cmp::PartialEq for MAPPING_SERVICE_INFO {
eq(&self, other: &Self) -> bool5597     fn eq(&self, other: &Self) -> bool {
5598         self.Size == other.Size
5599             && self.pszCopyright == other.pszCopyright
5600             && self.wMajorVersion == other.wMajorVersion
5601             && self.wMinorVersion == other.wMinorVersion
5602             && self.wBuildVersion == other.wBuildVersion
5603             && self.wStepVersion == other.wStepVersion
5604             && self.dwInputContentTypesCount == other.dwInputContentTypesCount
5605             && self.prgInputContentTypes == other.prgInputContentTypes
5606             && self.dwOutputContentTypesCount == other.dwOutputContentTypesCount
5607             && self.prgOutputContentTypes == other.prgOutputContentTypes
5608             && self.dwInputLanguagesCount == other.dwInputLanguagesCount
5609             && self.prgInputLanguages == other.prgInputLanguages
5610             && self.dwOutputLanguagesCount == other.dwOutputLanguagesCount
5611             && self.prgOutputLanguages == other.prgOutputLanguages
5612             && self.dwInputScriptsCount == other.dwInputScriptsCount
5613             && self.prgInputScripts == other.prgInputScripts
5614             && self.dwOutputScriptsCount == other.dwOutputScriptsCount
5615             && self.prgOutputScripts == other.prgOutputScripts
5616             && self.guid == other.guid
5617             && self.pszCategory == other.pszCategory
5618             && self.pszDescription == other.pszDescription
5619             && self.dwPrivateDataSize == other.dwPrivateDataSize
5620             && self.pPrivateData == other.pPrivateData
5621             && self.pContext == other.pContext
5622             && self._bitfield == other._bitfield
5623     }
5624 }
5625 #[cfg(feature = "Win32_Foundation")]
5626 impl ::std::cmp::Eq for MAPPING_SERVICE_INFO {}
5627 #[cfg(feature = "Win32_Foundation")]
5628 unsafe impl ::windows::runtime::Abi for MAPPING_SERVICE_INFO {
5629     type Abi = Self;
5630     type DefaultType = Self;
5631 }
5632 pub const MAX_DEFAULTCHAR: u32 = 2u32;
5633 pub const MAX_LEADBYTES: u32 = 12u32;
5634 pub const MAX_LOCALE_NAME: u32 = 32u32;
5635 pub const MAX_MIMECP_NAME: u32 = 64u32;
5636 pub const MAX_MIMECSET_NAME: u32 = 50u32;
5637 pub const MAX_MIMEFACE_NAME: u32 = 32u32;
5638 pub const MAX_RFC1766_NAME: u32 = 6u32;
5639 pub const MAX_SCRIPT_NAME: u32 = 48u32;
5640 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5641 #[repr(transparent)]
5642 pub struct MIMECONTF(pub i32);
5643 pub const MIMECONTF_MAILNEWS: MIMECONTF = MIMECONTF(1i32);
5644 pub const MIMECONTF_BROWSER: MIMECONTF = MIMECONTF(2i32);
5645 pub const MIMECONTF_MINIMAL: MIMECONTF = MIMECONTF(4i32);
5646 pub const MIMECONTF_IMPORT: MIMECONTF = MIMECONTF(8i32);
5647 pub const MIMECONTF_SAVABLE_MAILNEWS: MIMECONTF = MIMECONTF(256i32);
5648 pub const MIMECONTF_SAVABLE_BROWSER: MIMECONTF = MIMECONTF(512i32);
5649 pub const MIMECONTF_EXPORT: MIMECONTF = MIMECONTF(1024i32);
5650 pub const MIMECONTF_PRIVCONVERTER: MIMECONTF = MIMECONTF(65536i32);
5651 pub const MIMECONTF_VALID: MIMECONTF = MIMECONTF(131072i32);
5652 pub const MIMECONTF_VALID_NLS: MIMECONTF = MIMECONTF(262144i32);
5653 pub const MIMECONTF_MIME_IE4: MIMECONTF = MIMECONTF(268435456i32);
5654 pub const MIMECONTF_MIME_LATEST: MIMECONTF = MIMECONTF(536870912i32);
5655 pub const MIMECONTF_MIME_REGISTRY: MIMECONTF = MIMECONTF(1073741824i32);
5656 impl ::std::convert::From<i32> for MIMECONTF {
from(value: i32) -> Self5657     fn from(value: i32) -> Self {
5658         Self(value)
5659     }
5660 }
5661 unsafe impl ::windows::runtime::Abi for MIMECONTF {
5662     type Abi = Self;
5663     type DefaultType = Self;
5664 }
5665 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5666 #[repr(C)]
5667 pub struct MIMECPINFO {
5668     pub dwFlags: u32,
5669     pub uiCodePage: u32,
5670     pub uiFamilyCodePage: u32,
5671     pub wszDescription: [u16; 64],
5672     pub wszWebCharset: [u16; 50],
5673     pub wszHeaderCharset: [u16; 50],
5674     pub wszBodyCharset: [u16; 50],
5675     pub wszFixedWidthFont: [u16; 32],
5676     pub wszProportionalFont: [u16; 32],
5677     pub bGDICharset: u8,
5678 }
5679 impl MIMECPINFO {}
5680 impl ::std::default::Default for MIMECPINFO {
default() -> Self5681     fn default() -> Self {
5682         unsafe { ::std::mem::zeroed() }
5683     }
5684 }
5685 impl ::std::fmt::Debug for MIMECPINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5686     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5687         fmt.debug_struct("MIMECPINFO")
5688             .field("dwFlags", &self.dwFlags)
5689             .field("uiCodePage", &self.uiCodePage)
5690             .field("uiFamilyCodePage", &self.uiFamilyCodePage)
5691             .field("wszDescription", &self.wszDescription)
5692             .field("wszWebCharset", &self.wszWebCharset)
5693             .field("wszHeaderCharset", &self.wszHeaderCharset)
5694             .field("wszBodyCharset", &self.wszBodyCharset)
5695             .field("wszFixedWidthFont", &self.wszFixedWidthFont)
5696             .field("wszProportionalFont", &self.wszProportionalFont)
5697             .field("bGDICharset", &self.bGDICharset)
5698             .finish()
5699     }
5700 }
5701 impl ::std::cmp::PartialEq for MIMECPINFO {
eq(&self, other: &Self) -> bool5702     fn eq(&self, other: &Self) -> bool {
5703         self.dwFlags == other.dwFlags && self.uiCodePage == other.uiCodePage && self.uiFamilyCodePage == other.uiFamilyCodePage && self.wszDescription == other.wszDescription && self.wszWebCharset == other.wszWebCharset && self.wszHeaderCharset == other.wszHeaderCharset && self.wszBodyCharset == other.wszBodyCharset && self.wszFixedWidthFont == other.wszFixedWidthFont && self.wszProportionalFont == other.wszProportionalFont && self.bGDICharset == other.bGDICharset
5704     }
5705 }
5706 impl ::std::cmp::Eq for MIMECPINFO {}
5707 unsafe impl ::windows::runtime::Abi for MIMECPINFO {
5708     type Abi = Self;
5709     type DefaultType = Self;
5710 }
5711 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5712 #[repr(C)]
5713 pub struct MIMECSETINFO {
5714     pub uiCodePage: u32,
5715     pub uiInternetEncoding: u32,
5716     pub wszCharset: [u16; 50],
5717 }
5718 impl MIMECSETINFO {}
5719 impl ::std::default::Default for MIMECSETINFO {
default() -> Self5720     fn default() -> Self {
5721         unsafe { ::std::mem::zeroed() }
5722     }
5723 }
5724 impl ::std::fmt::Debug for MIMECSETINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5725     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5726         fmt.debug_struct("MIMECSETINFO").field("uiCodePage", &self.uiCodePage).field("uiInternetEncoding", &self.uiInternetEncoding).field("wszCharset", &self.wszCharset).finish()
5727     }
5728 }
5729 impl ::std::cmp::PartialEq for MIMECSETINFO {
eq(&self, other: &Self) -> bool5730     fn eq(&self, other: &Self) -> bool {
5731         self.uiCodePage == other.uiCodePage && self.uiInternetEncoding == other.uiInternetEncoding && self.wszCharset == other.wszCharset
5732     }
5733 }
5734 impl ::std::cmp::Eq for MIMECSETINFO {}
5735 unsafe impl ::windows::runtime::Abi for MIMECSETINFO {
5736     type Abi = Self;
5737     type DefaultType = Self;
5738 }
5739 pub const MIN_SPELLING_NTDDI: u32 = 100794368u32;
5740 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5741 #[repr(transparent)]
5742 pub struct MLDETECTCP(pub i32);
5743 pub const MLDETECTCP_NONE: MLDETECTCP = MLDETECTCP(0i32);
5744 pub const MLDETECTCP_7BIT: MLDETECTCP = MLDETECTCP(1i32);
5745 pub const MLDETECTCP_8BIT: MLDETECTCP = MLDETECTCP(2i32);
5746 pub const MLDETECTCP_DBCS: MLDETECTCP = MLDETECTCP(4i32);
5747 pub const MLDETECTCP_HTML: MLDETECTCP = MLDETECTCP(8i32);
5748 pub const MLDETECTCP_NUMBER: MLDETECTCP = MLDETECTCP(16i32);
5749 impl ::std::convert::From<i32> for MLDETECTCP {
from(value: i32) -> Self5750     fn from(value: i32) -> Self {
5751         Self(value)
5752     }
5753 }
5754 unsafe impl ::windows::runtime::Abi for MLDETECTCP {
5755     type Abi = Self;
5756     type DefaultType = Self;
5757 }
5758 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5759 #[repr(transparent)]
5760 pub struct MLSTR_FLAGS(pub i32);
5761 pub const MLSTR_READ: MLSTR_FLAGS = MLSTR_FLAGS(1i32);
5762 pub const MLSTR_WRITE: MLSTR_FLAGS = MLSTR_FLAGS(2i32);
5763 impl ::std::convert::From<i32> for MLSTR_FLAGS {
from(value: i32) -> Self5764     fn from(value: i32) -> Self {
5765         Self(value)
5766     }
5767 }
5768 unsafe impl ::windows::runtime::Abi for MLSTR_FLAGS {
5769     type Abi = Self;
5770     type DefaultType = Self;
5771 }
5772 pub const MUI_COMPLEX_SCRIPT_FILTER: u32 = 512u32;
5773 pub const MUI_CONSOLE_FILTER: u32 = 256u32;
5774 pub const MUI_FILEINFO_VERSION: u32 = 1u32;
5775 pub const MUI_FILETYPE_LANGUAGE_NEUTRAL_MAIN: u32 = 2u32;
5776 pub const MUI_FILETYPE_LANGUAGE_NEUTRAL_MUI: u32 = 4u32;
5777 pub const MUI_FILETYPE_NOT_LANGUAGE_NEUTRAL: u32 = 1u32;
5778 pub const MUI_FORMAT_INF_COMPAT: u32 = 2u32;
5779 pub const MUI_FORMAT_REG_COMPAT: u32 = 1u32;
5780 pub const MUI_FULL_LANGUAGE: u32 = 1u32;
5781 pub const MUI_IMMUTABLE_LOOKUP: u32 = 16u32;
5782 pub const MUI_LANGUAGE_EXACT: u32 = 16u32;
5783 pub const MUI_LANGUAGE_ID: u32 = 4u32;
5784 pub const MUI_LANGUAGE_INSTALLED: u32 = 32u32;
5785 pub const MUI_LANGUAGE_LICENSED: u32 = 64u32;
5786 pub const MUI_LANGUAGE_NAME: u32 = 8u32;
5787 pub const MUI_LANG_NEUTRAL_PE_FILE: u32 = 256u32;
5788 pub const MUI_LIP_LANGUAGE: u32 = 4u32;
5789 pub const MUI_MACHINE_LANGUAGE_SETTINGS: u32 = 1024u32;
5790 pub const MUI_MERGE_SYSTEM_FALLBACK: u32 = 16u32;
5791 pub const MUI_MERGE_USER_FALLBACK: u32 = 32u32;
5792 pub const MUI_NON_LANG_NEUTRAL_FILE: u32 = 512u32;
5793 pub const MUI_PARTIAL_LANGUAGE: u32 = 2u32;
5794 pub const MUI_QUERY_CHECKSUM: u32 = 2u32;
5795 pub const MUI_QUERY_LANGUAGE_NAME: u32 = 4u32;
5796 pub const MUI_QUERY_RESOURCE_TYPES: u32 = 8u32;
5797 pub const MUI_QUERY_TYPE: u32 = 1u32;
5798 pub const MUI_RESET_FILTERS: u32 = 1u32;
5799 pub const MUI_SKIP_STRING_CACHE: u32 = 8u32;
5800 pub const MUI_THREAD_LANGUAGES: u32 = 64u32;
5801 pub const MUI_USER_PREFERRED_UI_LANGUAGES: u32 = 16u32;
5802 pub const MUI_USE_INSTALLED_LANGUAGES: u32 = 32u32;
5803 pub const MUI_USE_SEARCH_ALL_LANGUAGES: u32 = 64u32;
5804 pub const MUI_VERIFY_FILE_EXISTS: u32 = 4u32;
5805 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
5806 #[repr(transparent)]
5807 pub struct MULTI_BYTE_TO_WIDE_CHAR_FLAGS(pub u32);
5808 pub const MB_COMPOSITE: MULTI_BYTE_TO_WIDE_CHAR_FLAGS = MULTI_BYTE_TO_WIDE_CHAR_FLAGS(2u32);
5809 pub const MB_ERR_INVALID_CHARS: MULTI_BYTE_TO_WIDE_CHAR_FLAGS = MULTI_BYTE_TO_WIDE_CHAR_FLAGS(8u32);
5810 pub const MB_PRECOMPOSED: MULTI_BYTE_TO_WIDE_CHAR_FLAGS = MULTI_BYTE_TO_WIDE_CHAR_FLAGS(1u32);
5811 pub const MB_USEGLYPHCHARS: MULTI_BYTE_TO_WIDE_CHAR_FLAGS = MULTI_BYTE_TO_WIDE_CHAR_FLAGS(4u32);
5812 impl ::std::convert::From<u32> for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
from(value: u32) -> Self5813     fn from(value: u32) -> Self {
5814         Self(value)
5815     }
5816 }
5817 unsafe impl ::windows::runtime::Abi for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
5818     type Abi = Self;
5819     type DefaultType = Self;
5820 }
5821 impl ::std::ops::BitOr for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
5822     type Output = Self;
bitor(self, rhs: Self) -> Self5823     fn bitor(self, rhs: Self) -> Self {
5824         Self(self.0 | rhs.0)
5825     }
5826 }
5827 impl ::std::ops::BitAnd for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
5828     type Output = Self;
bitand(self, rhs: Self) -> Self5829     fn bitand(self, rhs: Self) -> Self {
5830         Self(self.0 & rhs.0)
5831     }
5832 }
5833 impl ::std::ops::BitOrAssign for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
bitor_assign(&mut self, rhs: Self)5834     fn bitor_assign(&mut self, rhs: Self) {
5835         self.0.bitor_assign(rhs.0)
5836     }
5837 }
5838 impl ::std::ops::BitAndAssign for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
bitand_assign(&mut self, rhs: Self)5839     fn bitand_assign(&mut self, rhs: Self) {
5840         self.0.bitand_assign(rhs.0)
5841     }
5842 }
5843 impl ::std::ops::Not for MULTI_BYTE_TO_WIDE_CHAR_FLAGS {
5844     type Output = Self;
not(self) -> Self5845     fn not(self) -> Self {
5846         Self(self.0.not())
5847     }
5848 }
5849 #[cfg(feature = "Win32_Foundation")]
5850 #[inline]
MappingDoAction<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pbag: *mut MAPPING_PROPERTY_BAG, dwrangeindex: u32, pszactionid: Param2) -> ::windows::runtime::Result<()>5851 pub unsafe fn MappingDoAction<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pbag: *mut MAPPING_PROPERTY_BAG, dwrangeindex: u32, pszactionid: Param2) -> ::windows::runtime::Result<()> {
5852     #[cfg(windows)]
5853     {
5854         #[link(name = "windows")]
5855         extern "system" {
5856             fn MappingDoAction(pbag: *mut MAPPING_PROPERTY_BAG, dwrangeindex: u32, pszactionid: super::Foundation::PWSTR) -> ::windows::runtime::HRESULT;
5857         }
5858         MappingDoAction(::std::mem::transmute(pbag), ::std::mem::transmute(dwrangeindex), pszactionid.into_param().abi()).ok()
5859     }
5860     #[cfg(not(windows))]
5861     unimplemented!("Unsupported target OS");
5862 }
5863 #[cfg(feature = "Win32_Foundation")]
5864 #[inline]
MappingFreePropertyBag(pbag: *const MAPPING_PROPERTY_BAG) -> ::windows::runtime::Result<()>5865 pub unsafe fn MappingFreePropertyBag(pbag: *const MAPPING_PROPERTY_BAG) -> ::windows::runtime::Result<()> {
5866     #[cfg(windows)]
5867     {
5868         #[link(name = "windows")]
5869         extern "system" {
5870             fn MappingFreePropertyBag(pbag: *const MAPPING_PROPERTY_BAG) -> ::windows::runtime::HRESULT;
5871         }
5872         MappingFreePropertyBag(::std::mem::transmute(pbag)).ok()
5873     }
5874     #[cfg(not(windows))]
5875     unimplemented!("Unsupported target OS");
5876 }
5877 #[cfg(feature = "Win32_Foundation")]
5878 #[inline]
MappingFreeServices(pserviceinfo: *const MAPPING_SERVICE_INFO) -> ::windows::runtime::Result<()>5879 pub unsafe fn MappingFreeServices(pserviceinfo: *const MAPPING_SERVICE_INFO) -> ::windows::runtime::Result<()> {
5880     #[cfg(windows)]
5881     {
5882         #[link(name = "windows")]
5883         extern "system" {
5884             fn MappingFreeServices(pserviceinfo: *const MAPPING_SERVICE_INFO) -> ::windows::runtime::HRESULT;
5885         }
5886         MappingFreeServices(::std::mem::transmute(pserviceinfo)).ok()
5887     }
5888     #[cfg(not(windows))]
5889     unimplemented!("Unsupported target OS");
5890 }
5891 #[cfg(feature = "Win32_Foundation")]
5892 #[inline]
MappingGetServices(poptions: *const MAPPING_ENUM_OPTIONS, prgservices: *mut *mut MAPPING_SERVICE_INFO, pdwservicescount: *mut u32) -> ::windows::runtime::Result<()>5893 pub unsafe fn MappingGetServices(poptions: *const MAPPING_ENUM_OPTIONS, prgservices: *mut *mut MAPPING_SERVICE_INFO, pdwservicescount: *mut u32) -> ::windows::runtime::Result<()> {
5894     #[cfg(windows)]
5895     {
5896         #[link(name = "windows")]
5897         extern "system" {
5898             fn MappingGetServices(poptions: *const MAPPING_ENUM_OPTIONS, prgservices: *mut *mut MAPPING_SERVICE_INFO, pdwservicescount: *mut u32) -> ::windows::runtime::HRESULT;
5899         }
5900         MappingGetServices(::std::mem::transmute(poptions), ::std::mem::transmute(prgservices), ::std::mem::transmute(pdwservicescount)).ok()
5901     }
5902     #[cfg(not(windows))]
5903     unimplemented!("Unsupported target OS");
5904 }
5905 #[cfg(feature = "Win32_Foundation")]
5906 #[inline]
MappingRecognizeText<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pserviceinfo: *const MAPPING_SERVICE_INFO, psztext: Param1, dwlength: u32, dwindex: u32, poptions: *const MAPPING_OPTIONS, pbag: *mut MAPPING_PROPERTY_BAG) -> ::windows::runtime::Result<()>5907 pub unsafe fn MappingRecognizeText<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pserviceinfo: *const MAPPING_SERVICE_INFO, psztext: Param1, dwlength: u32, dwindex: u32, poptions: *const MAPPING_OPTIONS, pbag: *mut MAPPING_PROPERTY_BAG) -> ::windows::runtime::Result<()> {
5908     #[cfg(windows)]
5909     {
5910         #[link(name = "windows")]
5911         extern "system" {
5912             fn MappingRecognizeText(pserviceinfo: *const MAPPING_SERVICE_INFO, psztext: super::Foundation::PWSTR, dwlength: u32, dwindex: u32, poptions: *const ::std::mem::ManuallyDrop<MAPPING_OPTIONS>, pbag: *mut MAPPING_PROPERTY_BAG) -> ::windows::runtime::HRESULT;
5913         }
5914         MappingRecognizeText(::std::mem::transmute(pserviceinfo), psztext.into_param().abi(), ::std::mem::transmute(dwlength), ::std::mem::transmute(dwindex), ::std::mem::transmute(poptions), ::std::mem::transmute(pbag)).ok()
5915     }
5916     #[cfg(not(windows))]
5917     unimplemented!("Unsupported target OS");
5918 }
5919 #[cfg(feature = "Win32_Foundation")]
5920 #[inline]
MultiByteToWideChar<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(codepage: u32, dwflags: MULTI_BYTE_TO_WIDE_CHAR_FLAGS, lpmultibytestr: Param2, cbmultibyte: i32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> i325921 pub unsafe fn MultiByteToWideChar<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(codepage: u32, dwflags: MULTI_BYTE_TO_WIDE_CHAR_FLAGS, lpmultibytestr: Param2, cbmultibyte: i32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> i32 {
5922     #[cfg(windows)]
5923     {
5924         #[link(name = "windows")]
5925         extern "system" {
5926             fn MultiByteToWideChar(codepage: u32, dwflags: MULTI_BYTE_TO_WIDE_CHAR_FLAGS, lpmultibytestr: super::Foundation::PSTR, cbmultibyte: i32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32) -> i32;
5927         }
5928         ::std::mem::transmute(MultiByteToWideChar(::std::mem::transmute(codepage), ::std::mem::transmute(dwflags), lpmultibytestr.into_param().abi(), ::std::mem::transmute(cbmultibyte), ::std::mem::transmute(lpwidecharstr), ::std::mem::transmute(cchwidechar)))
5929     }
5930     #[cfg(not(windows))]
5931     unimplemented!("Unsupported target OS");
5932 }
5933 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5934 #[repr(C)]
5935 #[cfg(feature = "Win32_Graphics_Gdi")]
5936 pub struct NEWTEXTMETRICEXA {
5937     pub ntmTm: super::Graphics::Gdi::NEWTEXTMETRICA,
5938     pub ntmFontSig: FONTSIGNATURE,
5939 }
5940 #[cfg(feature = "Win32_Graphics_Gdi")]
5941 impl NEWTEXTMETRICEXA {}
5942 #[cfg(feature = "Win32_Graphics_Gdi")]
5943 impl ::std::default::Default for NEWTEXTMETRICEXA {
default() -> Self5944     fn default() -> Self {
5945         unsafe { ::std::mem::zeroed() }
5946     }
5947 }
5948 #[cfg(feature = "Win32_Graphics_Gdi")]
5949 impl ::std::fmt::Debug for NEWTEXTMETRICEXA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5950     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5951         fmt.debug_struct("NEWTEXTMETRICEXA").field("ntmTm", &self.ntmTm).field("ntmFontSig", &self.ntmFontSig).finish()
5952     }
5953 }
5954 #[cfg(feature = "Win32_Graphics_Gdi")]
5955 impl ::std::cmp::PartialEq for NEWTEXTMETRICEXA {
eq(&self, other: &Self) -> bool5956     fn eq(&self, other: &Self) -> bool {
5957         self.ntmTm == other.ntmTm && self.ntmFontSig == other.ntmFontSig
5958     }
5959 }
5960 #[cfg(feature = "Win32_Graphics_Gdi")]
5961 impl ::std::cmp::Eq for NEWTEXTMETRICEXA {}
5962 #[cfg(feature = "Win32_Graphics_Gdi")]
5963 unsafe impl ::windows::runtime::Abi for NEWTEXTMETRICEXA {
5964     type Abi = Self;
5965     type DefaultType = Self;
5966 }
5967 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
5968 #[repr(C)]
5969 #[cfg(feature = "Win32_Graphics_Gdi")]
5970 pub struct NEWTEXTMETRICEXW {
5971     pub ntmTm: super::Graphics::Gdi::NEWTEXTMETRICW,
5972     pub ntmFontSig: FONTSIGNATURE,
5973 }
5974 #[cfg(feature = "Win32_Graphics_Gdi")]
5975 impl NEWTEXTMETRICEXW {}
5976 #[cfg(feature = "Win32_Graphics_Gdi")]
5977 impl ::std::default::Default for NEWTEXTMETRICEXW {
default() -> Self5978     fn default() -> Self {
5979         unsafe { ::std::mem::zeroed() }
5980     }
5981 }
5982 #[cfg(feature = "Win32_Graphics_Gdi")]
5983 impl ::std::fmt::Debug for NEWTEXTMETRICEXW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result5984     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5985         fmt.debug_struct("NEWTEXTMETRICEXW").field("ntmTm", &self.ntmTm).field("ntmFontSig", &self.ntmFontSig).finish()
5986     }
5987 }
5988 #[cfg(feature = "Win32_Graphics_Gdi")]
5989 impl ::std::cmp::PartialEq for NEWTEXTMETRICEXW {
eq(&self, other: &Self) -> bool5990     fn eq(&self, other: &Self) -> bool {
5991         self.ntmTm == other.ntmTm && self.ntmFontSig == other.ntmFontSig
5992     }
5993 }
5994 #[cfg(feature = "Win32_Graphics_Gdi")]
5995 impl ::std::cmp::Eq for NEWTEXTMETRICEXW {}
5996 #[cfg(feature = "Win32_Graphics_Gdi")]
5997 unsafe impl ::windows::runtime::Abi for NEWTEXTMETRICEXW {
5998     type Abi = Self;
5999     type DefaultType = Self;
6000 }
6001 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6002 #[repr(C)]
6003 pub struct NLSVERSIONINFO {
6004     pub dwNLSVersionInfoSize: u32,
6005     pub dwNLSVersion: u32,
6006     pub dwDefinedVersion: u32,
6007     pub dwEffectiveId: u32,
6008     pub guidCustomVersion: ::windows::runtime::GUID,
6009 }
6010 impl NLSVERSIONINFO {}
6011 impl ::std::default::Default for NLSVERSIONINFO {
default() -> Self6012     fn default() -> Self {
6013         unsafe { ::std::mem::zeroed() }
6014     }
6015 }
6016 impl ::std::fmt::Debug for NLSVERSIONINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6017     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6018         fmt.debug_struct("NLSVERSIONINFO").field("dwNLSVersionInfoSize", &self.dwNLSVersionInfoSize).field("dwNLSVersion", &self.dwNLSVersion).field("dwDefinedVersion", &self.dwDefinedVersion).field("dwEffectiveId", &self.dwEffectiveId).field("guidCustomVersion", &self.guidCustomVersion).finish()
6019     }
6020 }
6021 impl ::std::cmp::PartialEq for NLSVERSIONINFO {
eq(&self, other: &Self) -> bool6022     fn eq(&self, other: &Self) -> bool {
6023         self.dwNLSVersionInfoSize == other.dwNLSVersionInfoSize && self.dwNLSVersion == other.dwNLSVersion && self.dwDefinedVersion == other.dwDefinedVersion && self.dwEffectiveId == other.dwEffectiveId && self.guidCustomVersion == other.guidCustomVersion
6024     }
6025 }
6026 impl ::std::cmp::Eq for NLSVERSIONINFO {}
6027 unsafe impl ::windows::runtime::Abi for NLSVERSIONINFO {
6028     type Abi = Self;
6029     type DefaultType = Self;
6030 }
6031 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6032 #[repr(C)]
6033 pub struct NLSVERSIONINFOEX {
6034     pub dwNLSVersionInfoSize: u32,
6035     pub dwNLSVersion: u32,
6036     pub dwDefinedVersion: u32,
6037     pub dwEffectiveId: u32,
6038     pub guidCustomVersion: ::windows::runtime::GUID,
6039 }
6040 impl NLSVERSIONINFOEX {}
6041 impl ::std::default::Default for NLSVERSIONINFOEX {
default() -> Self6042     fn default() -> Self {
6043         unsafe { ::std::mem::zeroed() }
6044     }
6045 }
6046 impl ::std::fmt::Debug for NLSVERSIONINFOEX {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6047     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6048         fmt.debug_struct("NLSVERSIONINFOEX").field("dwNLSVersionInfoSize", &self.dwNLSVersionInfoSize).field("dwNLSVersion", &self.dwNLSVersion).field("dwDefinedVersion", &self.dwDefinedVersion).field("dwEffectiveId", &self.dwEffectiveId).field("guidCustomVersion", &self.guidCustomVersion).finish()
6049     }
6050 }
6051 impl ::std::cmp::PartialEq for NLSVERSIONINFOEX {
eq(&self, other: &Self) -> bool6052     fn eq(&self, other: &Self) -> bool {
6053         self.dwNLSVersionInfoSize == other.dwNLSVersionInfoSize && self.dwNLSVersion == other.dwNLSVersion && self.dwDefinedVersion == other.dwDefinedVersion && self.dwEffectiveId == other.dwEffectiveId && self.guidCustomVersion == other.guidCustomVersion
6054     }
6055 }
6056 impl ::std::cmp::Eq for NLSVERSIONINFOEX {}
6057 unsafe impl ::windows::runtime::Abi for NLSVERSIONINFOEX {
6058     type Abi = Self;
6059     type DefaultType = Self;
6060 }
6061 pub const NLS_CP_CPINFO: u32 = 268435456u32;
6062 pub const NLS_CP_MBTOWC: u32 = 1073741824u32;
6063 pub const NLS_CP_WCTOMB: u32 = 2147483648u32;
6064 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6065 #[repr(transparent)]
6066 pub struct NORM_FORM(pub i32);
6067 pub const NormalizationOther: NORM_FORM = NORM_FORM(0i32);
6068 pub const NormalizationC: NORM_FORM = NORM_FORM(1i32);
6069 pub const NormalizationD: NORM_FORM = NORM_FORM(2i32);
6070 pub const NormalizationKC: NORM_FORM = NORM_FORM(5i32);
6071 pub const NormalizationKD: NORM_FORM = NORM_FORM(6i32);
6072 impl ::std::convert::From<i32> for NORM_FORM {
from(value: i32) -> Self6073     fn from(value: i32) -> Self {
6074         Self(value)
6075     }
6076 }
6077 unsafe impl ::windows::runtime::Abi for NORM_FORM {
6078     type Abi = Self;
6079     type DefaultType = Self;
6080 }
6081 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6082 #[repr(C)]
6083 #[cfg(feature = "Win32_Foundation")]
6084 pub struct NUMBERFMTA {
6085     pub NumDigits: u32,
6086     pub LeadingZero: u32,
6087     pub Grouping: u32,
6088     pub lpDecimalSep: super::Foundation::PSTR,
6089     pub lpThousandSep: super::Foundation::PSTR,
6090     pub NegativeOrder: u32,
6091 }
6092 #[cfg(feature = "Win32_Foundation")]
6093 impl NUMBERFMTA {}
6094 #[cfg(feature = "Win32_Foundation")]
6095 impl ::std::default::Default for NUMBERFMTA {
default() -> Self6096     fn default() -> Self {
6097         unsafe { ::std::mem::zeroed() }
6098     }
6099 }
6100 #[cfg(feature = "Win32_Foundation")]
6101 impl ::std::fmt::Debug for NUMBERFMTA {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6102     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6103         fmt.debug_struct("NUMBERFMTA").field("NumDigits", &self.NumDigits).field("LeadingZero", &self.LeadingZero).field("Grouping", &self.Grouping).field("lpDecimalSep", &self.lpDecimalSep).field("lpThousandSep", &self.lpThousandSep).field("NegativeOrder", &self.NegativeOrder).finish()
6104     }
6105 }
6106 #[cfg(feature = "Win32_Foundation")]
6107 impl ::std::cmp::PartialEq for NUMBERFMTA {
eq(&self, other: &Self) -> bool6108     fn eq(&self, other: &Self) -> bool {
6109         self.NumDigits == other.NumDigits && self.LeadingZero == other.LeadingZero && self.Grouping == other.Grouping && self.lpDecimalSep == other.lpDecimalSep && self.lpThousandSep == other.lpThousandSep && self.NegativeOrder == other.NegativeOrder
6110     }
6111 }
6112 #[cfg(feature = "Win32_Foundation")]
6113 impl ::std::cmp::Eq for NUMBERFMTA {}
6114 #[cfg(feature = "Win32_Foundation")]
6115 unsafe impl ::windows::runtime::Abi for NUMBERFMTA {
6116     type Abi = Self;
6117     type DefaultType = Self;
6118 }
6119 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6120 #[repr(C)]
6121 #[cfg(feature = "Win32_Foundation")]
6122 pub struct NUMBERFMTW {
6123     pub NumDigits: u32,
6124     pub LeadingZero: u32,
6125     pub Grouping: u32,
6126     pub lpDecimalSep: super::Foundation::PWSTR,
6127     pub lpThousandSep: super::Foundation::PWSTR,
6128     pub NegativeOrder: u32,
6129 }
6130 #[cfg(feature = "Win32_Foundation")]
6131 impl NUMBERFMTW {}
6132 #[cfg(feature = "Win32_Foundation")]
6133 impl ::std::default::Default for NUMBERFMTW {
default() -> Self6134     fn default() -> Self {
6135         unsafe { ::std::mem::zeroed() }
6136     }
6137 }
6138 #[cfg(feature = "Win32_Foundation")]
6139 impl ::std::fmt::Debug for NUMBERFMTW {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6140     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6141         fmt.debug_struct("NUMBERFMTW").field("NumDigits", &self.NumDigits).field("LeadingZero", &self.LeadingZero).field("Grouping", &self.Grouping).field("lpDecimalSep", &self.lpDecimalSep).field("lpThousandSep", &self.lpThousandSep).field("NegativeOrder", &self.NegativeOrder).finish()
6142     }
6143 }
6144 #[cfg(feature = "Win32_Foundation")]
6145 impl ::std::cmp::PartialEq for NUMBERFMTW {
eq(&self, other: &Self) -> bool6146     fn eq(&self, other: &Self) -> bool {
6147         self.NumDigits == other.NumDigits && self.LeadingZero == other.LeadingZero && self.Grouping == other.Grouping && self.lpDecimalSep == other.lpDecimalSep && self.lpThousandSep == other.lpThousandSep && self.NegativeOrder == other.NegativeOrder
6148     }
6149 }
6150 #[cfg(feature = "Win32_Foundation")]
6151 impl ::std::cmp::Eq for NUMBERFMTW {}
6152 #[cfg(feature = "Win32_Foundation")]
6153 unsafe impl ::windows::runtime::Abi for NUMBERFMTW {
6154     type Abi = Self;
6155     type DefaultType = Self;
6156 }
6157 pub const NUMSYS_NAME_CAPACITY: u32 = 8u32;
6158 #[cfg(feature = "Win32_Foundation")]
6159 #[inline]
NormalizeString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(normform: NORM_FORM, lpsrcstring: Param1, cwsrclength: i32, lpdststring: super::Foundation::PWSTR, cwdstlength: i32) -> i326160 pub unsafe fn NormalizeString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(normform: NORM_FORM, lpsrcstring: Param1, cwsrclength: i32, lpdststring: super::Foundation::PWSTR, cwdstlength: i32) -> i32 {
6161     #[cfg(windows)]
6162     {
6163         #[link(name = "windows")]
6164         extern "system" {
6165             fn NormalizeString(normform: NORM_FORM, lpsrcstring: super::Foundation::PWSTR, cwsrclength: i32, lpdststring: super::Foundation::PWSTR, cwdstlength: i32) -> i32;
6166         }
6167         ::std::mem::transmute(NormalizeString(::std::mem::transmute(normform), lpsrcstring.into_param().abi(), ::std::mem::transmute(cwsrclength), ::std::mem::transmute(lpdststring), ::std::mem::transmute(cwdstlength)))
6168     }
6169     #[cfg(not(windows))]
6170     unimplemented!("Unsupported target OS");
6171 }
6172 #[cfg(feature = "Win32_Foundation")]
6173 #[inline]
NotifyUILanguageChange<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwstrnewlanguage: Param1, pcwstrpreviouslanguage: Param2, dwreserved: u32, pdwstatusrtrn: *mut u32) -> super::Foundation::BOOL6174 pub unsafe fn NotifyUILanguageChange<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pcwstrnewlanguage: Param1, pcwstrpreviouslanguage: Param2, dwreserved: u32, pdwstatusrtrn: *mut u32) -> super::Foundation::BOOL {
6175     #[cfg(windows)]
6176     {
6177         #[link(name = "windows")]
6178         extern "system" {
6179             fn NotifyUILanguageChange(dwflags: u32, pcwstrnewlanguage: super::Foundation::PWSTR, pcwstrpreviouslanguage: super::Foundation::PWSTR, dwreserved: u32, pdwstatusrtrn: *mut u32) -> super::Foundation::BOOL;
6180         }
6181         ::std::mem::transmute(NotifyUILanguageChange(::std::mem::transmute(dwflags), pcwstrnewlanguage.into_param().abi(), pcwstrpreviouslanguage.into_param().abi(), ::std::mem::transmute(dwreserved), ::std::mem::transmute(pdwstatusrtrn)))
6182     }
6183     #[cfg(not(windows))]
6184     unimplemented!("Unsupported target OS");
6185 }
6186 pub const OFFLINE_SERVICES: u32 = 2u32;
6187 pub const ONLINE_SERVICES: u32 = 1u32;
6188 #[cfg(feature = "Win32_Foundation")]
6189 pub type PFN_MAPPINGCALLBACKPROC = unsafe extern "system" fn(pbag: *mut MAPPING_PROPERTY_BAG, data: *mut ::std::ffi::c_void, dwdatasize: u32, result: ::windows::runtime::HRESULT);
6190 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6191 #[repr(C)]
6192 pub struct RFC1766INFO {
6193     pub lcid: u32,
6194     pub wszRfc1766: [u16; 6],
6195     pub wszLocaleName: [u16; 32],
6196 }
6197 impl RFC1766INFO {}
6198 impl ::std::default::Default for RFC1766INFO {
default() -> Self6199     fn default() -> Self {
6200         unsafe { ::std::mem::zeroed() }
6201     }
6202 }
6203 impl ::std::fmt::Debug for RFC1766INFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6204     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6205         fmt.debug_struct("RFC1766INFO").field("lcid", &self.lcid).field("wszRfc1766", &self.wszRfc1766).field("wszLocaleName", &self.wszLocaleName).finish()
6206     }
6207 }
6208 impl ::std::cmp::PartialEq for RFC1766INFO {
eq(&self, other: &Self) -> bool6209     fn eq(&self, other: &Self) -> bool {
6210         self.lcid == other.lcid && self.wszRfc1766 == other.wszRfc1766 && self.wszLocaleName == other.wszLocaleName
6211     }
6212 }
6213 impl ::std::cmp::Eq for RFC1766INFO {}
6214 unsafe impl ::windows::runtime::Abi for RFC1766INFO {
6215     type Abi = Self;
6216     type DefaultType = Self;
6217 }
6218 #[cfg(feature = "Win32_Foundation")]
6219 #[inline]
ResolveLocaleName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpnametoresolve: Param0, lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i326220 pub unsafe fn ResolveLocaleName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpnametoresolve: Param0, lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32 {
6221     #[cfg(windows)]
6222     {
6223         #[link(name = "windows")]
6224         extern "system" {
6225             fn ResolveLocaleName(lpnametoresolve: super::Foundation::PWSTR, lplocalename: super::Foundation::PWSTR, cchlocalename: i32) -> i32;
6226         }
6227         ::std::mem::transmute(ResolveLocaleName(lpnametoresolve.into_param().abi(), ::std::mem::transmute(lplocalename), ::std::mem::transmute(cchlocalename)))
6228     }
6229     #[cfg(not(windows))]
6230     unimplemented!("Unsupported target OS");
6231 }
6232 #[inline]
RestoreThreadPreferredUILanguages<'a, Param0: ::windows::runtime::IntoParam<'a, HSAVEDUILANGUAGES>>(snapshot: Param0)6233 pub unsafe fn RestoreThreadPreferredUILanguages<'a, Param0: ::windows::runtime::IntoParam<'a, HSAVEDUILANGUAGES>>(snapshot: Param0) {
6234     #[cfg(windows)]
6235     {
6236         #[link(name = "windows")]
6237         extern "system" {
6238             fn RestoreThreadPreferredUILanguages(snapshot: HSAVEDUILANGUAGES);
6239         }
6240         ::std::mem::transmute(RestoreThreadPreferredUILanguages(snapshot.into_param().abi()))
6241     }
6242     #[cfg(not(windows))]
6243     unimplemented!("Unsupported target OS");
6244 }
6245 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6246 #[repr(transparent)]
6247 pub struct SCRIPTCONTF(pub i32);
6248 pub const sidDefault: SCRIPTCONTF = SCRIPTCONTF(0i32);
6249 pub const sidMerge: SCRIPTCONTF = SCRIPTCONTF(1i32);
6250 pub const sidAsciiSym: SCRIPTCONTF = SCRIPTCONTF(2i32);
6251 pub const sidAsciiLatin: SCRIPTCONTF = SCRIPTCONTF(3i32);
6252 pub const sidLatin: SCRIPTCONTF = SCRIPTCONTF(4i32);
6253 pub const sidGreek: SCRIPTCONTF = SCRIPTCONTF(5i32);
6254 pub const sidCyrillic: SCRIPTCONTF = SCRIPTCONTF(6i32);
6255 pub const sidArmenian: SCRIPTCONTF = SCRIPTCONTF(7i32);
6256 pub const sidHebrew: SCRIPTCONTF = SCRIPTCONTF(8i32);
6257 pub const sidArabic: SCRIPTCONTF = SCRIPTCONTF(9i32);
6258 pub const sidDevanagari: SCRIPTCONTF = SCRIPTCONTF(10i32);
6259 pub const sidBengali: SCRIPTCONTF = SCRIPTCONTF(11i32);
6260 pub const sidGurmukhi: SCRIPTCONTF = SCRIPTCONTF(12i32);
6261 pub const sidGujarati: SCRIPTCONTF = SCRIPTCONTF(13i32);
6262 pub const sidOriya: SCRIPTCONTF = SCRIPTCONTF(14i32);
6263 pub const sidTamil: SCRIPTCONTF = SCRIPTCONTF(15i32);
6264 pub const sidTelugu: SCRIPTCONTF = SCRIPTCONTF(16i32);
6265 pub const sidKannada: SCRIPTCONTF = SCRIPTCONTF(17i32);
6266 pub const sidMalayalam: SCRIPTCONTF = SCRIPTCONTF(18i32);
6267 pub const sidThai: SCRIPTCONTF = SCRIPTCONTF(19i32);
6268 pub const sidLao: SCRIPTCONTF = SCRIPTCONTF(20i32);
6269 pub const sidTibetan: SCRIPTCONTF = SCRIPTCONTF(21i32);
6270 pub const sidGeorgian: SCRIPTCONTF = SCRIPTCONTF(22i32);
6271 pub const sidHangul: SCRIPTCONTF = SCRIPTCONTF(23i32);
6272 pub const sidKana: SCRIPTCONTF = SCRIPTCONTF(24i32);
6273 pub const sidBopomofo: SCRIPTCONTF = SCRIPTCONTF(25i32);
6274 pub const sidHan: SCRIPTCONTF = SCRIPTCONTF(26i32);
6275 pub const sidEthiopic: SCRIPTCONTF = SCRIPTCONTF(27i32);
6276 pub const sidCanSyllabic: SCRIPTCONTF = SCRIPTCONTF(28i32);
6277 pub const sidCherokee: SCRIPTCONTF = SCRIPTCONTF(29i32);
6278 pub const sidYi: SCRIPTCONTF = SCRIPTCONTF(30i32);
6279 pub const sidBraille: SCRIPTCONTF = SCRIPTCONTF(31i32);
6280 pub const sidRunic: SCRIPTCONTF = SCRIPTCONTF(32i32);
6281 pub const sidOgham: SCRIPTCONTF = SCRIPTCONTF(33i32);
6282 pub const sidSinhala: SCRIPTCONTF = SCRIPTCONTF(34i32);
6283 pub const sidSyriac: SCRIPTCONTF = SCRIPTCONTF(35i32);
6284 pub const sidBurmese: SCRIPTCONTF = SCRIPTCONTF(36i32);
6285 pub const sidKhmer: SCRIPTCONTF = SCRIPTCONTF(37i32);
6286 pub const sidThaana: SCRIPTCONTF = SCRIPTCONTF(38i32);
6287 pub const sidMongolian: SCRIPTCONTF = SCRIPTCONTF(39i32);
6288 pub const sidUserDefined: SCRIPTCONTF = SCRIPTCONTF(40i32);
6289 pub const sidLim: SCRIPTCONTF = SCRIPTCONTF(41i32);
6290 pub const sidFEFirst: SCRIPTCONTF = SCRIPTCONTF(23i32);
6291 pub const sidFELast: SCRIPTCONTF = SCRIPTCONTF(26i32);
6292 impl ::std::convert::From<i32> for SCRIPTCONTF {
from(value: i32) -> Self6293     fn from(value: i32) -> Self {
6294         Self(value)
6295     }
6296 }
6297 unsafe impl ::windows::runtime::Abi for SCRIPTCONTF {
6298     type Abi = Self;
6299     type DefaultType = Self;
6300 }
6301 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6302 #[repr(transparent)]
6303 pub struct SCRIPTFONTCONTF(pub i32);
6304 pub const SCRIPTCONTF_FIXED_FONT: SCRIPTFONTCONTF = SCRIPTFONTCONTF(1i32);
6305 pub const SCRIPTCONTF_PROPORTIONAL_FONT: SCRIPTFONTCONTF = SCRIPTFONTCONTF(2i32);
6306 pub const SCRIPTCONTF_SCRIPT_USER: SCRIPTFONTCONTF = SCRIPTFONTCONTF(65536i32);
6307 pub const SCRIPTCONTF_SCRIPT_HIDE: SCRIPTFONTCONTF = SCRIPTFONTCONTF(131072i32);
6308 pub const SCRIPTCONTF_SCRIPT_SYSTEM: SCRIPTFONTCONTF = SCRIPTFONTCONTF(262144i32);
6309 impl ::std::convert::From<i32> for SCRIPTFONTCONTF {
from(value: i32) -> Self6310     fn from(value: i32) -> Self {
6311         Self(value)
6312     }
6313 }
6314 unsafe impl ::windows::runtime::Abi for SCRIPTFONTCONTF {
6315     type Abi = Self;
6316     type DefaultType = Self;
6317 }
6318 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6319 #[repr(C)]
6320 pub struct SCRIPTINFO {
6321     pub ScriptId: u8,
6322     pub uiCodePage: u32,
6323     pub wszDescription: [u16; 48],
6324     pub wszFixedWidthFont: [u16; 32],
6325     pub wszProportionalFont: [u16; 32],
6326 }
6327 impl SCRIPTINFO {}
6328 impl ::std::default::Default for SCRIPTINFO {
default() -> Self6329     fn default() -> Self {
6330         unsafe { ::std::mem::zeroed() }
6331     }
6332 }
6333 impl ::std::fmt::Debug for SCRIPTINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6334     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6335         fmt.debug_struct("SCRIPTINFO").field("ScriptId", &self.ScriptId).field("uiCodePage", &self.uiCodePage).field("wszDescription", &self.wszDescription).field("wszFixedWidthFont", &self.wszFixedWidthFont).field("wszProportionalFont", &self.wszProportionalFont).finish()
6336     }
6337 }
6338 impl ::std::cmp::PartialEq for SCRIPTINFO {
eq(&self, other: &Self) -> bool6339     fn eq(&self, other: &Self) -> bool {
6340         self.ScriptId == other.ScriptId && self.uiCodePage == other.uiCodePage && self.wszDescription == other.wszDescription && self.wszFixedWidthFont == other.wszFixedWidthFont && self.wszProportionalFont == other.wszProportionalFont
6341     }
6342 }
6343 impl ::std::cmp::Eq for SCRIPTINFO {}
6344 unsafe impl ::windows::runtime::Abi for SCRIPTINFO {
6345     type Abi = Self;
6346     type DefaultType = Self;
6347 }
6348 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6349 #[repr(C)]
6350 pub struct SCRIPT_ANALYSIS {
6351     pub _bitfield: u16,
6352     pub s: SCRIPT_STATE,
6353 }
6354 impl SCRIPT_ANALYSIS {}
6355 impl ::std::default::Default for SCRIPT_ANALYSIS {
default() -> Self6356     fn default() -> Self {
6357         unsafe { ::std::mem::zeroed() }
6358     }
6359 }
6360 impl ::std::fmt::Debug for SCRIPT_ANALYSIS {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6361     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6362         fmt.debug_struct("SCRIPT_ANALYSIS").field("_bitfield", &self._bitfield).field("s", &self.s).finish()
6363     }
6364 }
6365 impl ::std::cmp::PartialEq for SCRIPT_ANALYSIS {
eq(&self, other: &Self) -> bool6366     fn eq(&self, other: &Self) -> bool {
6367         self._bitfield == other._bitfield && self.s == other.s
6368     }
6369 }
6370 impl ::std::cmp::Eq for SCRIPT_ANALYSIS {}
6371 unsafe impl ::windows::runtime::Abi for SCRIPT_ANALYSIS {
6372     type Abi = Self;
6373     type DefaultType = Self;
6374 }
6375 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6376 #[repr(C)]
6377 pub struct SCRIPT_CONTROL {
6378     pub _bitfield: u32,
6379 }
6380 impl SCRIPT_CONTROL {}
6381 impl ::std::default::Default for SCRIPT_CONTROL {
default() -> Self6382     fn default() -> Self {
6383         unsafe { ::std::mem::zeroed() }
6384     }
6385 }
6386 impl ::std::fmt::Debug for SCRIPT_CONTROL {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6387     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6388         fmt.debug_struct("SCRIPT_CONTROL").field("_bitfield", &self._bitfield).finish()
6389     }
6390 }
6391 impl ::std::cmp::PartialEq for SCRIPT_CONTROL {
eq(&self, other: &Self) -> bool6392     fn eq(&self, other: &Self) -> bool {
6393         self._bitfield == other._bitfield
6394     }
6395 }
6396 impl ::std::cmp::Eq for SCRIPT_CONTROL {}
6397 unsafe impl ::windows::runtime::Abi for SCRIPT_CONTROL {
6398     type Abi = Self;
6399     type DefaultType = Self;
6400 }
6401 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6402 #[repr(C)]
6403 pub struct SCRIPT_DIGITSUBSTITUTE {
6404     pub _bitfield1: u32,
6405     pub _bitfield2: u32,
6406     pub dwReserved: u32,
6407 }
6408 impl SCRIPT_DIGITSUBSTITUTE {}
6409 impl ::std::default::Default for SCRIPT_DIGITSUBSTITUTE {
default() -> Self6410     fn default() -> Self {
6411         unsafe { ::std::mem::zeroed() }
6412     }
6413 }
6414 impl ::std::fmt::Debug for SCRIPT_DIGITSUBSTITUTE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6415     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6416         fmt.debug_struct("SCRIPT_DIGITSUBSTITUTE").field("_bitfield1", &self._bitfield1).field("_bitfield2", &self._bitfield2).field("dwReserved", &self.dwReserved).finish()
6417     }
6418 }
6419 impl ::std::cmp::PartialEq for SCRIPT_DIGITSUBSTITUTE {
eq(&self, other: &Self) -> bool6420     fn eq(&self, other: &Self) -> bool {
6421         self._bitfield1 == other._bitfield1 && self._bitfield2 == other._bitfield2 && self.dwReserved == other.dwReserved
6422     }
6423 }
6424 impl ::std::cmp::Eq for SCRIPT_DIGITSUBSTITUTE {}
6425 unsafe impl ::windows::runtime::Abi for SCRIPT_DIGITSUBSTITUTE {
6426     type Abi = Self;
6427     type DefaultType = Self;
6428 }
6429 pub const SCRIPT_DIGITSUBSTITUTE_CONTEXT: u32 = 0u32;
6430 pub const SCRIPT_DIGITSUBSTITUTE_NATIONAL: u32 = 2u32;
6431 pub const SCRIPT_DIGITSUBSTITUTE_NONE: u32 = 1u32;
6432 pub const SCRIPT_DIGITSUBSTITUTE_TRADITIONAL: u32 = 3u32;
6433 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6434 #[repr(C)]
6435 pub struct SCRIPT_FONTPROPERTIES {
6436     pub cBytes: i32,
6437     pub wgBlank: u16,
6438     pub wgDefault: u16,
6439     pub wgInvalid: u16,
6440     pub wgKashida: u16,
6441     pub iKashidaWidth: i32,
6442 }
6443 impl SCRIPT_FONTPROPERTIES {}
6444 impl ::std::default::Default for SCRIPT_FONTPROPERTIES {
default() -> Self6445     fn default() -> Self {
6446         unsafe { ::std::mem::zeroed() }
6447     }
6448 }
6449 impl ::std::fmt::Debug for SCRIPT_FONTPROPERTIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6450     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6451         fmt.debug_struct("SCRIPT_FONTPROPERTIES").field("cBytes", &self.cBytes).field("wgBlank", &self.wgBlank).field("wgDefault", &self.wgDefault).field("wgInvalid", &self.wgInvalid).field("wgKashida", &self.wgKashida).field("iKashidaWidth", &self.iKashidaWidth).finish()
6452     }
6453 }
6454 impl ::std::cmp::PartialEq for SCRIPT_FONTPROPERTIES {
eq(&self, other: &Self) -> bool6455     fn eq(&self, other: &Self) -> bool {
6456         self.cBytes == other.cBytes && self.wgBlank == other.wgBlank && self.wgDefault == other.wgDefault && self.wgInvalid == other.wgInvalid && self.wgKashida == other.wgKashida && self.iKashidaWidth == other.iKashidaWidth
6457     }
6458 }
6459 impl ::std::cmp::Eq for SCRIPT_FONTPROPERTIES {}
6460 unsafe impl ::windows::runtime::Abi for SCRIPT_FONTPROPERTIES {
6461     type Abi = Self;
6462     type DefaultType = Self;
6463 }
6464 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6465 #[repr(transparent)]
6466 pub struct SCRIPT_IS_COMPLEX_FLAGS(pub u32);
6467 pub const SIC_ASCIIDIGIT: SCRIPT_IS_COMPLEX_FLAGS = SCRIPT_IS_COMPLEX_FLAGS(2u32);
6468 pub const SIC_COMPLEX: SCRIPT_IS_COMPLEX_FLAGS = SCRIPT_IS_COMPLEX_FLAGS(1u32);
6469 pub const SIC_NEUTRAL: SCRIPT_IS_COMPLEX_FLAGS = SCRIPT_IS_COMPLEX_FLAGS(4u32);
6470 impl ::std::convert::From<u32> for SCRIPT_IS_COMPLEX_FLAGS {
from(value: u32) -> Self6471     fn from(value: u32) -> Self {
6472         Self(value)
6473     }
6474 }
6475 unsafe impl ::windows::runtime::Abi for SCRIPT_IS_COMPLEX_FLAGS {
6476     type Abi = Self;
6477     type DefaultType = Self;
6478 }
6479 impl ::std::ops::BitOr for SCRIPT_IS_COMPLEX_FLAGS {
6480     type Output = Self;
bitor(self, rhs: Self) -> Self6481     fn bitor(self, rhs: Self) -> Self {
6482         Self(self.0 | rhs.0)
6483     }
6484 }
6485 impl ::std::ops::BitAnd for SCRIPT_IS_COMPLEX_FLAGS {
6486     type Output = Self;
bitand(self, rhs: Self) -> Self6487     fn bitand(self, rhs: Self) -> Self {
6488         Self(self.0 & rhs.0)
6489     }
6490 }
6491 impl ::std::ops::BitOrAssign for SCRIPT_IS_COMPLEX_FLAGS {
bitor_assign(&mut self, rhs: Self)6492     fn bitor_assign(&mut self, rhs: Self) {
6493         self.0.bitor_assign(rhs.0)
6494     }
6495 }
6496 impl ::std::ops::BitAndAssign for SCRIPT_IS_COMPLEX_FLAGS {
bitand_assign(&mut self, rhs: Self)6497     fn bitand_assign(&mut self, rhs: Self) {
6498         self.0.bitand_assign(rhs.0)
6499     }
6500 }
6501 impl ::std::ops::Not for SCRIPT_IS_COMPLEX_FLAGS {
6502     type Output = Self;
not(self) -> Self6503     fn not(self) -> Self {
6504         Self(self.0.not())
6505     }
6506 }
6507 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6508 #[repr(C)]
6509 pub struct SCRIPT_ITEM {
6510     pub iCharPos: i32,
6511     pub a: SCRIPT_ANALYSIS,
6512 }
6513 impl SCRIPT_ITEM {}
6514 impl ::std::default::Default for SCRIPT_ITEM {
default() -> Self6515     fn default() -> Self {
6516         unsafe { ::std::mem::zeroed() }
6517     }
6518 }
6519 impl ::std::fmt::Debug for SCRIPT_ITEM {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6520     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6521         fmt.debug_struct("SCRIPT_ITEM").field("iCharPos", &self.iCharPos).field("a", &self.a).finish()
6522     }
6523 }
6524 impl ::std::cmp::PartialEq for SCRIPT_ITEM {
eq(&self, other: &Self) -> bool6525     fn eq(&self, other: &Self) -> bool {
6526         self.iCharPos == other.iCharPos && self.a == other.a
6527     }
6528 }
6529 impl ::std::cmp::Eq for SCRIPT_ITEM {}
6530 unsafe impl ::windows::runtime::Abi for SCRIPT_ITEM {
6531     type Abi = Self;
6532     type DefaultType = Self;
6533 }
6534 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6535 #[repr(transparent)]
6536 pub struct SCRIPT_JUSTIFY(pub i32);
6537 pub const SCRIPT_JUSTIFY_NONE: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(0i32);
6538 pub const SCRIPT_JUSTIFY_ARABIC_BLANK: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(1i32);
6539 pub const SCRIPT_JUSTIFY_CHARACTER: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(2i32);
6540 pub const SCRIPT_JUSTIFY_RESERVED1: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(3i32);
6541 pub const SCRIPT_JUSTIFY_BLANK: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(4i32);
6542 pub const SCRIPT_JUSTIFY_RESERVED2: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(5i32);
6543 pub const SCRIPT_JUSTIFY_RESERVED3: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(6i32);
6544 pub const SCRIPT_JUSTIFY_ARABIC_NORMAL: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(7i32);
6545 pub const SCRIPT_JUSTIFY_ARABIC_KASHIDA: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(8i32);
6546 pub const SCRIPT_JUSTIFY_ARABIC_ALEF: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(9i32);
6547 pub const SCRIPT_JUSTIFY_ARABIC_HA: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(10i32);
6548 pub const SCRIPT_JUSTIFY_ARABIC_RA: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(11i32);
6549 pub const SCRIPT_JUSTIFY_ARABIC_BA: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(12i32);
6550 pub const SCRIPT_JUSTIFY_ARABIC_BARA: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(13i32);
6551 pub const SCRIPT_JUSTIFY_ARABIC_SEEN: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(14i32);
6552 pub const SCRIPT_JUSTIFY_ARABIC_SEEN_M: SCRIPT_JUSTIFY = SCRIPT_JUSTIFY(15i32);
6553 impl ::std::convert::From<i32> for SCRIPT_JUSTIFY {
from(value: i32) -> Self6554     fn from(value: i32) -> Self {
6555         Self(value)
6556     }
6557 }
6558 unsafe impl ::windows::runtime::Abi for SCRIPT_JUSTIFY {
6559     type Abi = Self;
6560     type DefaultType = Self;
6561 }
6562 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6563 #[repr(C)]
6564 pub struct SCRIPT_LOGATTR {
6565     pub _bitfield: u8,
6566 }
6567 impl SCRIPT_LOGATTR {}
6568 impl ::std::default::Default for SCRIPT_LOGATTR {
default() -> Self6569     fn default() -> Self {
6570         unsafe { ::std::mem::zeroed() }
6571     }
6572 }
6573 impl ::std::fmt::Debug for SCRIPT_LOGATTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6574     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6575         fmt.debug_struct("SCRIPT_LOGATTR").field("_bitfield", &self._bitfield).finish()
6576     }
6577 }
6578 impl ::std::cmp::PartialEq for SCRIPT_LOGATTR {
eq(&self, other: &Self) -> bool6579     fn eq(&self, other: &Self) -> bool {
6580         self._bitfield == other._bitfield
6581     }
6582 }
6583 impl ::std::cmp::Eq for SCRIPT_LOGATTR {}
6584 unsafe impl ::windows::runtime::Abi for SCRIPT_LOGATTR {
6585     type Abi = Self;
6586     type DefaultType = Self;
6587 }
6588 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6589 #[repr(C)]
6590 pub struct SCRIPT_PROPERTIES {
6591     pub _bitfield1: u32,
6592     pub _bitfield2: u32,
6593 }
6594 impl SCRIPT_PROPERTIES {}
6595 impl ::std::default::Default for SCRIPT_PROPERTIES {
default() -> Self6596     fn default() -> Self {
6597         unsafe { ::std::mem::zeroed() }
6598     }
6599 }
6600 impl ::std::fmt::Debug for SCRIPT_PROPERTIES {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6601     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6602         fmt.debug_struct("SCRIPT_PROPERTIES").field("_bitfield1", &self._bitfield1).field("_bitfield2", &self._bitfield2).finish()
6603     }
6604 }
6605 impl ::std::cmp::PartialEq for SCRIPT_PROPERTIES {
eq(&self, other: &Self) -> bool6606     fn eq(&self, other: &Self) -> bool {
6607         self._bitfield1 == other._bitfield1 && self._bitfield2 == other._bitfield2
6608     }
6609 }
6610 impl ::std::cmp::Eq for SCRIPT_PROPERTIES {}
6611 unsafe impl ::windows::runtime::Abi for SCRIPT_PROPERTIES {
6612     type Abi = Self;
6613     type DefaultType = Self;
6614 }
6615 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6616 #[repr(C)]
6617 pub struct SCRIPT_STATE {
6618     pub _bitfield: u16,
6619 }
6620 impl SCRIPT_STATE {}
6621 impl ::std::default::Default for SCRIPT_STATE {
default() -> Self6622     fn default() -> Self {
6623         unsafe { ::std::mem::zeroed() }
6624     }
6625 }
6626 impl ::std::fmt::Debug for SCRIPT_STATE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6627     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6628         fmt.debug_struct("SCRIPT_STATE").field("_bitfield", &self._bitfield).finish()
6629     }
6630 }
6631 impl ::std::cmp::PartialEq for SCRIPT_STATE {
eq(&self, other: &Self) -> bool6632     fn eq(&self, other: &Self) -> bool {
6633         self._bitfield == other._bitfield
6634     }
6635 }
6636 impl ::std::cmp::Eq for SCRIPT_STATE {}
6637 unsafe impl ::windows::runtime::Abi for SCRIPT_STATE {
6638     type Abi = Self;
6639     type DefaultType = Self;
6640 }
6641 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6642 #[repr(C)]
6643 pub struct SCRIPT_TABDEF {
6644     pub cTabStops: i32,
6645     pub iScale: i32,
6646     pub pTabStops: *mut i32,
6647     pub iTabOrigin: i32,
6648 }
6649 impl SCRIPT_TABDEF {}
6650 impl ::std::default::Default for SCRIPT_TABDEF {
default() -> Self6651     fn default() -> Self {
6652         unsafe { ::std::mem::zeroed() }
6653     }
6654 }
6655 impl ::std::fmt::Debug for SCRIPT_TABDEF {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6656     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6657         fmt.debug_struct("SCRIPT_TABDEF").field("cTabStops", &self.cTabStops).field("iScale", &self.iScale).field("pTabStops", &self.pTabStops).field("iTabOrigin", &self.iTabOrigin).finish()
6658     }
6659 }
6660 impl ::std::cmp::PartialEq for SCRIPT_TABDEF {
eq(&self, other: &Self) -> bool6661     fn eq(&self, other: &Self) -> bool {
6662         self.cTabStops == other.cTabStops && self.iScale == other.iScale && self.pTabStops == other.pTabStops && self.iTabOrigin == other.iTabOrigin
6663     }
6664 }
6665 impl ::std::cmp::Eq for SCRIPT_TABDEF {}
6666 unsafe impl ::windows::runtime::Abi for SCRIPT_TABDEF {
6667     type Abi = Self;
6668     type DefaultType = Self;
6669 }
6670 pub const SCRIPT_TAG_UNKNOWN: u32 = 0u32;
6671 pub const SCRIPT_UNDEFINED: u32 = 0u32;
6672 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
6673 #[repr(C)]
6674 pub struct SCRIPT_VISATTR {
6675     pub _bitfield: u16,
6676 }
6677 impl SCRIPT_VISATTR {}
6678 impl ::std::default::Default for SCRIPT_VISATTR {
default() -> Self6679     fn default() -> Self {
6680         unsafe { ::std::mem::zeroed() }
6681     }
6682 }
6683 impl ::std::fmt::Debug for SCRIPT_VISATTR {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result6684     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6685         fmt.debug_struct("SCRIPT_VISATTR").field("_bitfield", &self._bitfield).finish()
6686     }
6687 }
6688 impl ::std::cmp::PartialEq for SCRIPT_VISATTR {
eq(&self, other: &Self) -> bool6689     fn eq(&self, other: &Self) -> bool {
6690         self._bitfield == other._bitfield
6691     }
6692 }
6693 impl ::std::cmp::Eq for SCRIPT_VISATTR {}
6694 unsafe impl ::windows::runtime::Abi for SCRIPT_VISATTR {
6695     type Abi = Self;
6696     type DefaultType = Self;
6697 }
6698 pub const SGCM_RTL: u32 = 1u32;
6699 pub const SORTING_PARADIGM_ICU: u32 = 16777216u32;
6700 pub const SORTING_PARADIGM_NLS: u32 = 0u32;
6701 pub const SSA_BREAK: u32 = 64u32;
6702 pub const SSA_CLIP: u32 = 4u32;
6703 pub const SSA_DONTGLYPH: u32 = 1073741824u32;
6704 pub const SSA_DZWG: u32 = 16u32;
6705 pub const SSA_FALLBACK: u32 = 32u32;
6706 pub const SSA_FIT: u32 = 8u32;
6707 pub const SSA_FULLMEASURE: u32 = 67108864u32;
6708 pub const SSA_GCP: u32 = 512u32;
6709 pub const SSA_GLYPHS: u32 = 128u32;
6710 pub const SSA_HIDEHOTKEY: u32 = 8192u32;
6711 pub const SSA_HOTKEY: u32 = 1024u32;
6712 pub const SSA_HOTKEYONLY: u32 = 9216u32;
6713 pub const SSA_LAYOUTRTL: u32 = 536870912u32;
6714 pub const SSA_LINK: u32 = 4096u32;
6715 pub const SSA_LPKANSIFALLBACK: u32 = 134217728u32;
6716 pub const SSA_METAFILE: u32 = 2048u32;
6717 pub const SSA_NOKASHIDA: u32 = 2147483648u32;
6718 pub const SSA_PASSWORD: u32 = 1u32;
6719 pub const SSA_PIDX: u32 = 268435456u32;
6720 pub const SSA_RTL: u32 = 256u32;
6721 pub const SSA_TAB: u32 = 2u32;
6722 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6723 #[repr(transparent)]
6724 pub struct SYSGEOCLASS(pub i32);
6725 pub const GEOCLASS_NATION: SYSGEOCLASS = SYSGEOCLASS(16i32);
6726 pub const GEOCLASS_REGION: SYSGEOCLASS = SYSGEOCLASS(14i32);
6727 pub const GEOCLASS_ALL: SYSGEOCLASS = SYSGEOCLASS(0i32);
6728 impl ::std::convert::From<i32> for SYSGEOCLASS {
from(value: i32) -> Self6729     fn from(value: i32) -> Self {
6730         Self(value)
6731     }
6732 }
6733 unsafe impl ::windows::runtime::Abi for SYSGEOCLASS {
6734     type Abi = Self;
6735     type DefaultType = Self;
6736 }
6737 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6738 #[repr(transparent)]
6739 pub struct SYSGEOTYPE(pub i32);
6740 pub const GEO_NATION: SYSGEOTYPE = SYSGEOTYPE(1i32);
6741 pub const GEO_LATITUDE: SYSGEOTYPE = SYSGEOTYPE(2i32);
6742 pub const GEO_LONGITUDE: SYSGEOTYPE = SYSGEOTYPE(3i32);
6743 pub const GEO_ISO2: SYSGEOTYPE = SYSGEOTYPE(4i32);
6744 pub const GEO_ISO3: SYSGEOTYPE = SYSGEOTYPE(5i32);
6745 pub const GEO_RFC1766: SYSGEOTYPE = SYSGEOTYPE(6i32);
6746 pub const GEO_LCID: SYSGEOTYPE = SYSGEOTYPE(7i32);
6747 pub const GEO_FRIENDLYNAME: SYSGEOTYPE = SYSGEOTYPE(8i32);
6748 pub const GEO_OFFICIALNAME: SYSGEOTYPE = SYSGEOTYPE(9i32);
6749 pub const GEO_TIMEZONES: SYSGEOTYPE = SYSGEOTYPE(10i32);
6750 pub const GEO_OFFICIALLANGUAGES: SYSGEOTYPE = SYSGEOTYPE(11i32);
6751 pub const GEO_ISO_UN_NUMBER: SYSGEOTYPE = SYSGEOTYPE(12i32);
6752 pub const GEO_PARENT: SYSGEOTYPE = SYSGEOTYPE(13i32);
6753 pub const GEO_DIALINGCODE: SYSGEOTYPE = SYSGEOTYPE(14i32);
6754 pub const GEO_CURRENCYCODE: SYSGEOTYPE = SYSGEOTYPE(15i32);
6755 pub const GEO_CURRENCYSYMBOL: SYSGEOTYPE = SYSGEOTYPE(16i32);
6756 pub const GEO_NAME: SYSGEOTYPE = SYSGEOTYPE(17i32);
6757 pub const GEO_ID: SYSGEOTYPE = SYSGEOTYPE(18i32);
6758 impl ::std::convert::From<i32> for SYSGEOTYPE {
from(value: i32) -> Self6759     fn from(value: i32) -> Self {
6760         Self(value)
6761     }
6762 }
6763 unsafe impl ::windows::runtime::Abi for SYSGEOTYPE {
6764     type Abi = Self;
6765     type DefaultType = Self;
6766 }
6767 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
6768 #[repr(transparent)]
6769 pub struct SYSNLS_FUNCTION(pub i32);
6770 pub const COMPARE_STRING: SYSNLS_FUNCTION = SYSNLS_FUNCTION(1i32);
6771 impl ::std::convert::From<i32> for SYSNLS_FUNCTION {
from(value: i32) -> Self6772     fn from(value: i32) -> Self {
6773         Self(value)
6774     }
6775 }
6776 unsafe impl ::windows::runtime::Abi for SYSNLS_FUNCTION {
6777     type Abi = Self;
6778     type DefaultType = Self;
6779 }
6780 #[inline]
ScriptApplyDigitSubstitution(psds: *const SCRIPT_DIGITSUBSTITUTE, psc: *mut SCRIPT_CONTROL, pss: *mut SCRIPT_STATE) -> ::windows::runtime::Result<()>6781 pub unsafe fn ScriptApplyDigitSubstitution(psds: *const SCRIPT_DIGITSUBSTITUTE, psc: *mut SCRIPT_CONTROL, pss: *mut SCRIPT_STATE) -> ::windows::runtime::Result<()> {
6782     #[cfg(windows)]
6783     {
6784         #[link(name = "windows")]
6785         extern "system" {
6786             fn ScriptApplyDigitSubstitution(psds: *const SCRIPT_DIGITSUBSTITUTE, psc: *mut SCRIPT_CONTROL, pss: *mut SCRIPT_STATE) -> ::windows::runtime::HRESULT;
6787         }
6788         ScriptApplyDigitSubstitution(::std::mem::transmute(psds), ::std::mem::transmute(psc), ::std::mem::transmute(pss)).ok()
6789     }
6790     #[cfg(not(windows))]
6791     unimplemented!("Unsupported target OS");
6792 }
6793 #[cfg(feature = "Win32_Graphics_Gdi")]
6794 #[inline]
ScriptApplyLogicalWidth(pidx: *const i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pabc: *mut super::Graphics::Gdi::ABC, pijustify: *mut i32) -> ::windows::runtime::Result<()>6795 pub unsafe fn ScriptApplyLogicalWidth(pidx: *const i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pabc: *mut super::Graphics::Gdi::ABC, pijustify: *mut i32) -> ::windows::runtime::Result<()> {
6796     #[cfg(windows)]
6797     {
6798         #[link(name = "windows")]
6799         extern "system" {
6800             fn ScriptApplyLogicalWidth(pidx: *const i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pabc: *mut super::Graphics::Gdi::ABC, pijustify: *mut i32) -> ::windows::runtime::HRESULT;
6801         }
6802         ScriptApplyLogicalWidth(::std::mem::transmute(pidx), ::std::mem::transmute(cchars), ::std::mem::transmute(cglyphs), ::std::mem::transmute(pwlogclust), ::std::mem::transmute(psva), ::std::mem::transmute(piadvance), ::std::mem::transmute(psa), ::std::mem::transmute(pabc), ::std::mem::transmute(pijustify)).ok()
6803     }
6804     #[cfg(not(windows))]
6805     unimplemented!("Unsupported target OS");
6806 }
6807 #[cfg(feature = "Win32_Foundation")]
6808 #[inline]
ScriptBreak<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcchars: Param0, cchars: i32, psa: *const SCRIPT_ANALYSIS) -> ::windows::runtime::Result<SCRIPT_LOGATTR>6809 pub unsafe fn ScriptBreak<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcchars: Param0, cchars: i32, psa: *const SCRIPT_ANALYSIS) -> ::windows::runtime::Result<SCRIPT_LOGATTR> {
6810     #[cfg(windows)]
6811     {
6812         #[link(name = "windows")]
6813         extern "system" {
6814             fn ScriptBreak(pwcchars: super::Foundation::PWSTR, cchars: i32, psa: *const SCRIPT_ANALYSIS, psla: *mut SCRIPT_LOGATTR) -> ::windows::runtime::HRESULT;
6815         }
6816         let mut result__: <SCRIPT_LOGATTR as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
6817         ScriptBreak(pwcchars.into_param().abi(), ::std::mem::transmute(cchars), ::std::mem::transmute(psa), &mut result__).from_abi::<SCRIPT_LOGATTR>(result__)
6818     }
6819     #[cfg(not(windows))]
6820     unimplemented!("Unsupported target OS");
6821 }
6822 #[cfg(feature = "Win32_Foundation")]
6823 #[inline]
ScriptCPtoX<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(icp: i32, ftrailing: Param1, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pix: *mut i32) -> ::windows::runtime::Result<()>6824 pub unsafe fn ScriptCPtoX<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(icp: i32, ftrailing: Param1, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pix: *mut i32) -> ::windows::runtime::Result<()> {
6825     #[cfg(windows)]
6826     {
6827         #[link(name = "windows")]
6828         extern "system" {
6829             fn ScriptCPtoX(icp: i32, ftrailing: super::Foundation::BOOL, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, pix: *mut i32) -> ::windows::runtime::HRESULT;
6830         }
6831         ScriptCPtoX(::std::mem::transmute(icp), ftrailing.into_param().abi(), ::std::mem::transmute(cchars), ::std::mem::transmute(cglyphs), ::std::mem::transmute(pwlogclust), ::std::mem::transmute(psva), ::std::mem::transmute(piadvance), ::std::mem::transmute(psa), ::std::mem::transmute(pix)).ok()
6832     }
6833     #[cfg(not(windows))]
6834     unimplemented!("Unsupported target OS");
6835 }
6836 #[cfg(feature = "Win32_Graphics_Gdi")]
6837 #[inline]
ScriptCacheGetHeight<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, tmheight: *mut i32) -> ::windows::runtime::Result<()>6838 pub unsafe fn ScriptCacheGetHeight<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, tmheight: *mut i32) -> ::windows::runtime::Result<()> {
6839     #[cfg(windows)]
6840     {
6841         #[link(name = "windows")]
6842         extern "system" {
6843             fn ScriptCacheGetHeight(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, tmheight: *mut i32) -> ::windows::runtime::HRESULT;
6844         }
6845         ScriptCacheGetHeight(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(tmheight)).ok()
6846     }
6847     #[cfg(not(windows))]
6848     unimplemented!("Unsupported target OS");
6849 }
6850 #[inline]
ScriptFreeCache(psc: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>6851 pub unsafe fn ScriptFreeCache(psc: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
6852     #[cfg(windows)]
6853     {
6854         #[link(name = "windows")]
6855         extern "system" {
6856             fn ScriptFreeCache(psc: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
6857         }
6858         ScriptFreeCache(::std::mem::transmute(psc)).ok()
6859     }
6860     #[cfg(not(windows))]
6861     unimplemented!("Unsupported target OS");
6862 }
6863 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
6864 #[inline]
ScriptGetCMap<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwcinchars: Param2, cchars: i32, dwflags: u32, pwoutglyphs: *mut u16) -> ::windows::runtime::Result<()>6865 pub unsafe fn ScriptGetCMap<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwcinchars: Param2, cchars: i32, dwflags: u32, pwoutglyphs: *mut u16) -> ::windows::runtime::Result<()> {
6866     #[cfg(windows)]
6867     {
6868         #[link(name = "windows")]
6869         extern "system" {
6870             fn ScriptGetCMap(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, pwcinchars: super::Foundation::PWSTR, cchars: i32, dwflags: u32, pwoutglyphs: *mut u16) -> ::windows::runtime::HRESULT;
6871         }
6872         ScriptGetCMap(hdc.into_param().abi(), ::std::mem::transmute(psc), pwcinchars.into_param().abi(), ::std::mem::transmute(cchars), ::std::mem::transmute(dwflags), ::std::mem::transmute(pwoutglyphs)).ok()
6873     }
6874     #[cfg(not(windows))]
6875     unimplemented!("Unsupported target OS");
6876 }
6877 #[cfg(feature = "Win32_Graphics_Gdi")]
6878 #[inline]
ScriptGetFontAlternateGlyphs<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, wglyphid: u16, cmaxalternates: i32, palternateglyphs: *mut u16, pcalternates: *mut i32) -> ::windows::runtime::Result<()>6879 pub unsafe fn ScriptGetFontAlternateGlyphs<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, wglyphid: u16, cmaxalternates: i32, palternateglyphs: *mut u16, pcalternates: *mut i32) -> ::windows::runtime::Result<()> {
6880     #[cfg(windows)]
6881     {
6882         #[link(name = "windows")]
6883         extern "system" {
6884             fn ScriptGetFontAlternateGlyphs(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, wglyphid: u16, cmaxalternates: i32, palternateglyphs: *mut u16, pcalternates: *mut i32) -> ::windows::runtime::HRESULT;
6885         }
6886         ScriptGetFontAlternateGlyphs(
6887             hdc.into_param().abi(),
6888             ::std::mem::transmute(psc),
6889             ::std::mem::transmute(psa),
6890             ::std::mem::transmute(tagscript),
6891             ::std::mem::transmute(taglangsys),
6892             ::std::mem::transmute(tagfeature),
6893             ::std::mem::transmute(wglyphid),
6894             ::std::mem::transmute(cmaxalternates),
6895             ::std::mem::transmute(palternateglyphs),
6896             ::std::mem::transmute(pcalternates),
6897         )
6898         .ok()
6899     }
6900     #[cfg(not(windows))]
6901     unimplemented!("Unsupported target OS");
6902 }
6903 #[cfg(feature = "Win32_Graphics_Gdi")]
6904 #[inline]
ScriptGetFontFeatureTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, cmaxtags: i32, pfeaturetags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()>6905 pub unsafe fn ScriptGetFontFeatureTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, cmaxtags: i32, pfeaturetags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()> {
6906     #[cfg(windows)]
6907     {
6908         #[link(name = "windows")]
6909         extern "system" {
6910             fn ScriptGetFontFeatureTags(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, cmaxtags: i32, pfeaturetags: *mut u32, pctags: *mut i32) -> ::windows::runtime::HRESULT;
6911         }
6912         ScriptGetFontFeatureTags(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(psa), ::std::mem::transmute(tagscript), ::std::mem::transmute(taglangsys), ::std::mem::transmute(cmaxtags), ::std::mem::transmute(pfeaturetags), ::std::mem::transmute(pctags)).ok()
6913     }
6914     #[cfg(not(windows))]
6915     unimplemented!("Unsupported target OS");
6916 }
6917 #[cfg(feature = "Win32_Graphics_Gdi")]
6918 #[inline]
ScriptGetFontLanguageTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, cmaxtags: i32, plangsystags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()>6919 pub unsafe fn ScriptGetFontLanguageTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, cmaxtags: i32, plangsystags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()> {
6920     #[cfg(windows)]
6921     {
6922         #[link(name = "windows")]
6923         extern "system" {
6924             fn ScriptGetFontLanguageTags(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, cmaxtags: i32, plangsystags: *mut u32, pctags: *mut i32) -> ::windows::runtime::HRESULT;
6925         }
6926         ScriptGetFontLanguageTags(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(psa), ::std::mem::transmute(tagscript), ::std::mem::transmute(cmaxtags), ::std::mem::transmute(plangsystags), ::std::mem::transmute(pctags)).ok()
6927     }
6928     #[cfg(not(windows))]
6929     unimplemented!("Unsupported target OS");
6930 }
6931 #[cfg(feature = "Win32_Graphics_Gdi")]
6932 #[inline]
ScriptGetFontProperties<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, sfp: *mut SCRIPT_FONTPROPERTIES) -> ::windows::runtime::Result<()>6933 pub unsafe fn ScriptGetFontProperties<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, sfp: *mut SCRIPT_FONTPROPERTIES) -> ::windows::runtime::Result<()> {
6934     #[cfg(windows)]
6935     {
6936         #[link(name = "windows")]
6937         extern "system" {
6938             fn ScriptGetFontProperties(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, sfp: *mut SCRIPT_FONTPROPERTIES) -> ::windows::runtime::HRESULT;
6939         }
6940         ScriptGetFontProperties(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(sfp)).ok()
6941     }
6942     #[cfg(not(windows))]
6943     unimplemented!("Unsupported target OS");
6944 }
6945 #[cfg(feature = "Win32_Graphics_Gdi")]
6946 #[inline]
ScriptGetFontScriptTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, cmaxtags: i32, pscripttags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()>6947 pub unsafe fn ScriptGetFontScriptTags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, cmaxtags: i32, pscripttags: *mut u32, pctags: *mut i32) -> ::windows::runtime::Result<()> {
6948     #[cfg(windows)]
6949     {
6950         #[link(name = "windows")]
6951         extern "system" {
6952             fn ScriptGetFontScriptTags(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, cmaxtags: i32, pscripttags: *mut u32, pctags: *mut i32) -> ::windows::runtime::HRESULT;
6953         }
6954         ScriptGetFontScriptTags(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(psa), ::std::mem::transmute(cmaxtags), ::std::mem::transmute(pscripttags), ::std::mem::transmute(pctags)).ok()
6955     }
6956     #[cfg(not(windows))]
6957     unimplemented!("Unsupported target OS");
6958 }
6959 #[cfg(feature = "Win32_Graphics_Gdi")]
6960 #[inline]
ScriptGetGlyphABCWidth<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, wglyph: u16, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::Result<()>6961 pub unsafe fn ScriptGetGlyphABCWidth<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, wglyph: u16, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::Result<()> {
6962     #[cfg(windows)]
6963     {
6964         #[link(name = "windows")]
6965         extern "system" {
6966             fn ScriptGetGlyphABCWidth(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, wglyph: u16, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::HRESULT;
6967         }
6968         ScriptGetGlyphABCWidth(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(wglyph), ::std::mem::transmute(pabc)).ok()
6969     }
6970     #[cfg(not(windows))]
6971     unimplemented!("Unsupported target OS");
6972 }
6973 #[inline]
ScriptGetLogicalWidths(psa: *const SCRIPT_ANALYSIS, cchars: i32, cglyphs: i32, piglyphwidth: *const i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, pidx: *const i32) -> ::windows::runtime::Result<()>6974 pub unsafe fn ScriptGetLogicalWidths(psa: *const SCRIPT_ANALYSIS, cchars: i32, cglyphs: i32, piglyphwidth: *const i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, pidx: *const i32) -> ::windows::runtime::Result<()> {
6975     #[cfg(windows)]
6976     {
6977         #[link(name = "windows")]
6978         extern "system" {
6979             fn ScriptGetLogicalWidths(psa: *const SCRIPT_ANALYSIS, cchars: i32, cglyphs: i32, piglyphwidth: *const i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, pidx: *const i32) -> ::windows::runtime::HRESULT;
6980         }
6981         ScriptGetLogicalWidths(::std::mem::transmute(psa), ::std::mem::transmute(cchars), ::std::mem::transmute(cglyphs), ::std::mem::transmute(piglyphwidth), ::std::mem::transmute(pwlogclust), ::std::mem::transmute(psva), ::std::mem::transmute(pidx)).ok()
6982     }
6983     #[cfg(not(windows))]
6984     unimplemented!("Unsupported target OS");
6985 }
6986 #[inline]
ScriptGetProperties(ppsp: *mut *mut *mut SCRIPT_PROPERTIES, pinumscripts: *mut i32) -> ::windows::runtime::Result<()>6987 pub unsafe fn ScriptGetProperties(ppsp: *mut *mut *mut SCRIPT_PROPERTIES, pinumscripts: *mut i32) -> ::windows::runtime::Result<()> {
6988     #[cfg(windows)]
6989     {
6990         #[link(name = "windows")]
6991         extern "system" {
6992             fn ScriptGetProperties(ppsp: *mut *mut *mut SCRIPT_PROPERTIES, pinumscripts: *mut i32) -> ::windows::runtime::HRESULT;
6993         }
6994         ScriptGetProperties(::std::mem::transmute(ppsp), ::std::mem::transmute(pinumscripts)).ok()
6995     }
6996     #[cfg(not(windows))]
6997     unimplemented!("Unsupported target OS");
6998 }
6999 #[cfg(feature = "Win32_Foundation")]
7000 #[inline]
ScriptIsComplex<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, dwflags: SCRIPT_IS_COMPLEX_FLAGS) -> ::windows::runtime::Result<()>7001 pub unsafe fn ScriptIsComplex<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, dwflags: SCRIPT_IS_COMPLEX_FLAGS) -> ::windows::runtime::Result<()> {
7002     #[cfg(windows)]
7003     {
7004         #[link(name = "windows")]
7005         extern "system" {
7006             fn ScriptIsComplex(pwcinchars: super::Foundation::PWSTR, cinchars: i32, dwflags: SCRIPT_IS_COMPLEX_FLAGS) -> ::windows::runtime::HRESULT;
7007         }
7008         ScriptIsComplex(pwcinchars.into_param().abi(), ::std::mem::transmute(cinchars), ::std::mem::transmute(dwflags)).ok()
7009     }
7010     #[cfg(not(windows))]
7011     unimplemented!("Unsupported target OS");
7012 }
7013 #[cfg(feature = "Win32_Foundation")]
7014 #[inline]
ScriptItemize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pcitems: *mut i32) -> ::windows::runtime::Result<()>7015 pub unsafe fn ScriptItemize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pcitems: *mut i32) -> ::windows::runtime::Result<()> {
7016     #[cfg(windows)]
7017     {
7018         #[link(name = "windows")]
7019         extern "system" {
7020             fn ScriptItemize(pwcinchars: super::Foundation::PWSTR, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pcitems: *mut i32) -> ::windows::runtime::HRESULT;
7021         }
7022         ScriptItemize(pwcinchars.into_param().abi(), ::std::mem::transmute(cinchars), ::std::mem::transmute(cmaxitems), ::std::mem::transmute(pscontrol), ::std::mem::transmute(psstate), ::std::mem::transmute(pitems), ::std::mem::transmute(pcitems)).ok()
7023     }
7024     #[cfg(not(windows))]
7025     unimplemented!("Unsupported target OS");
7026 }
7027 #[cfg(feature = "Win32_Foundation")]
7028 #[inline]
ScriptItemizeOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pscripttags: *mut u32, pcitems: *mut i32) -> ::windows::runtime::Result<()>7029 pub unsafe fn ScriptItemizeOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(pwcinchars: Param0, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pscripttags: *mut u32, pcitems: *mut i32) -> ::windows::runtime::Result<()> {
7030     #[cfg(windows)]
7031     {
7032         #[link(name = "windows")]
7033         extern "system" {
7034             fn ScriptItemizeOpenType(pwcinchars: super::Foundation::PWSTR, cinchars: i32, cmaxitems: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pitems: *mut SCRIPT_ITEM, pscripttags: *mut u32, pcitems: *mut i32) -> ::windows::runtime::HRESULT;
7035         }
7036         ScriptItemizeOpenType(pwcinchars.into_param().abi(), ::std::mem::transmute(cinchars), ::std::mem::transmute(cmaxitems), ::std::mem::transmute(pscontrol), ::std::mem::transmute(psstate), ::std::mem::transmute(pitems), ::std::mem::transmute(pscripttags), ::std::mem::transmute(pcitems)).ok()
7037     }
7038     #[cfg(not(windows))]
7039     unimplemented!("Unsupported target OS");
7040 }
7041 #[inline]
ScriptJustify(psva: *const SCRIPT_VISATTR, piadvance: *const i32, cglyphs: i32, idx: i32, iminkashida: i32) -> ::windows::runtime::Result<i32>7042 pub unsafe fn ScriptJustify(psva: *const SCRIPT_VISATTR, piadvance: *const i32, cglyphs: i32, idx: i32, iminkashida: i32) -> ::windows::runtime::Result<i32> {
7043     #[cfg(windows)]
7044     {
7045         #[link(name = "windows")]
7046         extern "system" {
7047             fn ScriptJustify(psva: *const SCRIPT_VISATTR, piadvance: *const i32, cglyphs: i32, idx: i32, iminkashida: i32, pijustify: *mut i32) -> ::windows::runtime::HRESULT;
7048         }
7049         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
7050         ScriptJustify(::std::mem::transmute(psva), ::std::mem::transmute(piadvance), ::std::mem::transmute(cglyphs), ::std::mem::transmute(idx), ::std::mem::transmute(iminkashida), &mut result__).from_abi::<i32>(result__)
7051     }
7052     #[cfg(not(windows))]
7053     unimplemented!("Unsupported target OS");
7054 }
7055 #[inline]
ScriptLayout(cruns: i32, pblevel: *const u8, pivisualtological: *mut i32, pilogicaltovisual: *mut i32) -> ::windows::runtime::Result<()>7056 pub unsafe fn ScriptLayout(cruns: i32, pblevel: *const u8, pivisualtological: *mut i32, pilogicaltovisual: *mut i32) -> ::windows::runtime::Result<()> {
7057     #[cfg(windows)]
7058     {
7059         #[link(name = "windows")]
7060         extern "system" {
7061             fn ScriptLayout(cruns: i32, pblevel: *const u8, pivisualtological: *mut i32, pilogicaltovisual: *mut i32) -> ::windows::runtime::HRESULT;
7062         }
7063         ScriptLayout(::std::mem::transmute(cruns), ::std::mem::transmute(pblevel), ::std::mem::transmute(pivisualtological), ::std::mem::transmute(pilogicaltovisual)).ok()
7064     }
7065     #[cfg(not(windows))]
7066     unimplemented!("Unsupported target OS");
7067 }
7068 #[cfg(feature = "Win32_Graphics_Gdi")]
7069 #[inline]
ScriptPlace<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwglyphs: *const u16, cglyphs: i32, psva: *const SCRIPT_VISATTR, psa: *mut SCRIPT_ANALYSIS, piadvance: *mut i32, pgoffset: *mut GOFFSET, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::Result<()>7070 pub unsafe fn ScriptPlace<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwglyphs: *const u16, cglyphs: i32, psva: *const SCRIPT_VISATTR, psa: *mut SCRIPT_ANALYSIS, piadvance: *mut i32, pgoffset: *mut GOFFSET, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::Result<()> {
7071     #[cfg(windows)]
7072     {
7073         #[link(name = "windows")]
7074         extern "system" {
7075             fn ScriptPlace(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, pwglyphs: *const u16, cglyphs: i32, psva: *const SCRIPT_VISATTR, psa: *mut SCRIPT_ANALYSIS, piadvance: *mut i32, pgoffset: *mut GOFFSET, pabc: *mut super::Graphics::Gdi::ABC) -> ::windows::runtime::HRESULT;
7076         }
7077         ScriptPlace(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(pwglyphs), ::std::mem::transmute(cglyphs), ::std::mem::transmute(psva), ::std::mem::transmute(psa), ::std::mem::transmute(piadvance), ::std::mem::transmute(pgoffset), ::std::mem::transmute(pabc)).ok()
7078     }
7079     #[cfg(not(windows))]
7080     unimplemented!("Unsupported target OS");
7081 }
7082 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
7083 #[inline]
ScriptPlaceOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>( hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *mut SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, rcrangechars: *const i32, rprangeproperties: *const *const textrange_properties, cranges: i32, pwcchars: Param8, pwlogclust: *const u16, pcharprops: *const script_charprop, cchars: i32, pwglyphs: *const u16, pglyphprops: *const script_glyphprop, cglyphs: i32, piadvance: *mut i32, pgoffset: *mut GOFFSET, pabc: *mut super::Graphics::Gdi::ABC, ) -> ::windows::runtime::Result<()>7084 pub unsafe fn ScriptPlaceOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(
7085     hdc: Param0,
7086     psc: *mut *mut ::std::ffi::c_void,
7087     psa: *mut SCRIPT_ANALYSIS,
7088     tagscript: u32,
7089     taglangsys: u32,
7090     rcrangechars: *const i32,
7091     rprangeproperties: *const *const textrange_properties,
7092     cranges: i32,
7093     pwcchars: Param8,
7094     pwlogclust: *const u16,
7095     pcharprops: *const script_charprop,
7096     cchars: i32,
7097     pwglyphs: *const u16,
7098     pglyphprops: *const script_glyphprop,
7099     cglyphs: i32,
7100     piadvance: *mut i32,
7101     pgoffset: *mut GOFFSET,
7102     pabc: *mut super::Graphics::Gdi::ABC,
7103 ) -> ::windows::runtime::Result<()> {
7104     #[cfg(windows)]
7105     {
7106         #[link(name = "windows")]
7107         extern "system" {
7108             fn ScriptPlaceOpenType(
7109                 hdc: super::Graphics::Gdi::HDC,
7110                 psc: *mut *mut ::std::ffi::c_void,
7111                 psa: *mut SCRIPT_ANALYSIS,
7112                 tagscript: u32,
7113                 taglangsys: u32,
7114                 rcrangechars: *const i32,
7115                 rprangeproperties: *const *const textrange_properties,
7116                 cranges: i32,
7117                 pwcchars: super::Foundation::PWSTR,
7118                 pwlogclust: *const u16,
7119                 pcharprops: *const script_charprop,
7120                 cchars: i32,
7121                 pwglyphs: *const u16,
7122                 pglyphprops: *const script_glyphprop,
7123                 cglyphs: i32,
7124                 piadvance: *mut i32,
7125                 pgoffset: *mut GOFFSET,
7126                 pabc: *mut super::Graphics::Gdi::ABC,
7127             ) -> ::windows::runtime::HRESULT;
7128         }
7129         ScriptPlaceOpenType(
7130             hdc.into_param().abi(),
7131             ::std::mem::transmute(psc),
7132             ::std::mem::transmute(psa),
7133             ::std::mem::transmute(tagscript),
7134             ::std::mem::transmute(taglangsys),
7135             ::std::mem::transmute(rcrangechars),
7136             ::std::mem::transmute(rprangeproperties),
7137             ::std::mem::transmute(cranges),
7138             pwcchars.into_param().abi(),
7139             ::std::mem::transmute(pwlogclust),
7140             ::std::mem::transmute(pcharprops),
7141             ::std::mem::transmute(cchars),
7142             ::std::mem::transmute(pwglyphs),
7143             ::std::mem::transmute(pglyphprops),
7144             ::std::mem::transmute(cglyphs),
7145             ::std::mem::transmute(piadvance),
7146             ::std::mem::transmute(pgoffset),
7147             ::std::mem::transmute(pabc),
7148         )
7149         .ok()
7150     }
7151     #[cfg(not(windows))]
7152     unimplemented!("Unsupported target OS");
7153 }
7154 #[cfg(feature = "Win32_Graphics_Gdi")]
7155 #[inline]
ScriptPositionSingleGlyph<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param9: ::windows::runtime::IntoParam<'a, GOFFSET>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, iadvance: i32, goffset: Param9, pioutadvance: *mut i32, poutgoffset: *mut GOFFSET) -> ::windows::runtime::Result<()>7156 pub unsafe fn ScriptPositionSingleGlyph<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param9: ::windows::runtime::IntoParam<'a, GOFFSET>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, iadvance: i32, goffset: Param9, pioutadvance: *mut i32, poutgoffset: *mut GOFFSET) -> ::windows::runtime::Result<()> {
7157     #[cfg(windows)]
7158     {
7159         #[link(name = "windows")]
7160         extern "system" {
7161             fn ScriptPositionSingleGlyph(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, iadvance: i32, goffset: GOFFSET, pioutadvance: *mut i32, poutgoffset: *mut GOFFSET) -> ::windows::runtime::HRESULT;
7162         }
7163         ScriptPositionSingleGlyph(
7164             hdc.into_param().abi(),
7165             ::std::mem::transmute(psc),
7166             ::std::mem::transmute(psa),
7167             ::std::mem::transmute(tagscript),
7168             ::std::mem::transmute(taglangsys),
7169             ::std::mem::transmute(tagfeature),
7170             ::std::mem::transmute(lparameter),
7171             ::std::mem::transmute(wglyphid),
7172             ::std::mem::transmute(iadvance),
7173             goffset.into_param().abi(),
7174             ::std::mem::transmute(pioutadvance),
7175             ::std::mem::transmute(poutgoffset),
7176         )
7177         .ok()
7178     }
7179     #[cfg(not(windows))]
7180     unimplemented!("Unsupported target OS");
7181 }
7182 #[inline]
ScriptRecordDigitSubstitution(locale: u32) -> ::windows::runtime::Result<SCRIPT_DIGITSUBSTITUTE>7183 pub unsafe fn ScriptRecordDigitSubstitution(locale: u32) -> ::windows::runtime::Result<SCRIPT_DIGITSUBSTITUTE> {
7184     #[cfg(windows)]
7185     {
7186         #[link(name = "windows")]
7187         extern "system" {
7188             fn ScriptRecordDigitSubstitution(locale: u32, psds: *mut SCRIPT_DIGITSUBSTITUTE) -> ::windows::runtime::HRESULT;
7189         }
7190         let mut result__: <SCRIPT_DIGITSUBSTITUTE as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
7191         ScriptRecordDigitSubstitution(::std::mem::transmute(locale), &mut result__).from_abi::<SCRIPT_DIGITSUBSTITUTE>(result__)
7192     }
7193     #[cfg(not(windows))]
7194     unimplemented!("Unsupported target OS");
7195 }
7196 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
7197 #[inline]
ScriptShape<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwcchars: Param2, cchars: i32, cmaxglyphs: i32, psa: *mut SCRIPT_ANALYSIS, pwoutglyphs: *mut u16, pwlogclust: *mut u16, psva: *mut SCRIPT_VISATTR, pcglyphs: *mut i32) -> ::windows::runtime::Result<()>7198 pub unsafe fn ScriptShape<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, pwcchars: Param2, cchars: i32, cmaxglyphs: i32, psa: *mut SCRIPT_ANALYSIS, pwoutglyphs: *mut u16, pwlogclust: *mut u16, psva: *mut SCRIPT_VISATTR, pcglyphs: *mut i32) -> ::windows::runtime::Result<()> {
7199     #[cfg(windows)]
7200     {
7201         #[link(name = "windows")]
7202         extern "system" {
7203             fn ScriptShape(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, pwcchars: super::Foundation::PWSTR, cchars: i32, cmaxglyphs: i32, psa: *mut SCRIPT_ANALYSIS, pwoutglyphs: *mut u16, pwlogclust: *mut u16, psva: *mut SCRIPT_VISATTR, pcglyphs: *mut i32) -> ::windows::runtime::HRESULT;
7204         }
7205         ScriptShape(
7206             hdc.into_param().abi(),
7207             ::std::mem::transmute(psc),
7208             pwcchars.into_param().abi(),
7209             ::std::mem::transmute(cchars),
7210             ::std::mem::transmute(cmaxglyphs),
7211             ::std::mem::transmute(psa),
7212             ::std::mem::transmute(pwoutglyphs),
7213             ::std::mem::transmute(pwlogclust),
7214             ::std::mem::transmute(psva),
7215             ::std::mem::transmute(pcglyphs),
7216         )
7217         .ok()
7218     }
7219     #[cfg(not(windows))]
7220     unimplemented!("Unsupported target OS");
7221 }
7222 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
7223 #[inline]
ScriptShapeOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>( hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *mut SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, rcrangechars: *const i32, rprangeproperties: *const *const textrange_properties, cranges: i32, pwcchars: Param8, cchars: i32, cmaxglyphs: i32, pwlogclust: *mut u16, pcharprops: *mut script_charprop, pwoutglyphs: *mut u16, poutglyphprops: *mut script_glyphprop, pcglyphs: *mut i32, ) -> ::windows::runtime::Result<()>7224 pub unsafe fn ScriptShapeOpenType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param8: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(
7225     hdc: Param0,
7226     psc: *mut *mut ::std::ffi::c_void,
7227     psa: *mut SCRIPT_ANALYSIS,
7228     tagscript: u32,
7229     taglangsys: u32,
7230     rcrangechars: *const i32,
7231     rprangeproperties: *const *const textrange_properties,
7232     cranges: i32,
7233     pwcchars: Param8,
7234     cchars: i32,
7235     cmaxglyphs: i32,
7236     pwlogclust: *mut u16,
7237     pcharprops: *mut script_charprop,
7238     pwoutglyphs: *mut u16,
7239     poutglyphprops: *mut script_glyphprop,
7240     pcglyphs: *mut i32,
7241 ) -> ::windows::runtime::Result<()> {
7242     #[cfg(windows)]
7243     {
7244         #[link(name = "windows")]
7245         extern "system" {
7246             fn ScriptShapeOpenType(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *mut SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, rcrangechars: *const i32, rprangeproperties: *const *const textrange_properties, cranges: i32, pwcchars: super::Foundation::PWSTR, cchars: i32, cmaxglyphs: i32, pwlogclust: *mut u16, pcharprops: *mut script_charprop, pwoutglyphs: *mut u16, poutglyphprops: *mut script_glyphprop, pcglyphs: *mut i32) -> ::windows::runtime::HRESULT;
7247         }
7248         ScriptShapeOpenType(
7249             hdc.into_param().abi(),
7250             ::std::mem::transmute(psc),
7251             ::std::mem::transmute(psa),
7252             ::std::mem::transmute(tagscript),
7253             ::std::mem::transmute(taglangsys),
7254             ::std::mem::transmute(rcrangechars),
7255             ::std::mem::transmute(rprangeproperties),
7256             ::std::mem::transmute(cranges),
7257             pwcchars.into_param().abi(),
7258             ::std::mem::transmute(cchars),
7259             ::std::mem::transmute(cmaxglyphs),
7260             ::std::mem::transmute(pwlogclust),
7261             ::std::mem::transmute(pcharprops),
7262             ::std::mem::transmute(pwoutglyphs),
7263             ::std::mem::transmute(poutglyphprops),
7264             ::std::mem::transmute(pcglyphs),
7265         )
7266         .ok()
7267     }
7268     #[cfg(not(windows))]
7269     unimplemented!("Unsupported target OS");
7270 }
7271 #[cfg(feature = "Win32_Graphics_Gdi")]
7272 #[inline]
ScriptStringAnalyse<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, pstring: *const ::std::ffi::c_void, cstring: i32, cglyphs: i32, icharset: i32, dwflags: u32, ireqwidth: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pidx: *const i32, ptabdef: *const SCRIPT_TABDEF, pbinclass: *const u8, pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7273 pub unsafe fn ScriptStringAnalyse<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, pstring: *const ::std::ffi::c_void, cstring: i32, cglyphs: i32, icharset: i32, dwflags: u32, ireqwidth: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pidx: *const i32, ptabdef: *const SCRIPT_TABDEF, pbinclass: *const u8, pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7274     #[cfg(windows)]
7275     {
7276         #[link(name = "windows")]
7277         extern "system" {
7278             fn ScriptStringAnalyse(hdc: super::Graphics::Gdi::HDC, pstring: *const ::std::ffi::c_void, cstring: i32, cglyphs: i32, icharset: i32, dwflags: u32, ireqwidth: i32, pscontrol: *const SCRIPT_CONTROL, psstate: *const SCRIPT_STATE, pidx: *const i32, ptabdef: *const SCRIPT_TABDEF, pbinclass: *const u8, pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
7279         }
7280         ScriptStringAnalyse(
7281             hdc.into_param().abi(),
7282             ::std::mem::transmute(pstring),
7283             ::std::mem::transmute(cstring),
7284             ::std::mem::transmute(cglyphs),
7285             ::std::mem::transmute(icharset),
7286             ::std::mem::transmute(dwflags),
7287             ::std::mem::transmute(ireqwidth),
7288             ::std::mem::transmute(pscontrol),
7289             ::std::mem::transmute(psstate),
7290             ::std::mem::transmute(pidx),
7291             ::std::mem::transmute(ptabdef),
7292             ::std::mem::transmute(pbinclass),
7293             ::std::mem::transmute(pssa),
7294         )
7295         .ok()
7296     }
7297     #[cfg(not(windows))]
7298     unimplemented!("Unsupported target OS");
7299 }
7300 #[cfg(feature = "Win32_Foundation")]
7301 #[inline]
ScriptStringCPtoX<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(ssa: *const ::std::ffi::c_void, icp: i32, ftrailing: Param2) -> ::windows::runtime::Result<i32>7302 pub unsafe fn ScriptStringCPtoX<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(ssa: *const ::std::ffi::c_void, icp: i32, ftrailing: Param2) -> ::windows::runtime::Result<i32> {
7303     #[cfg(windows)]
7304     {
7305         #[link(name = "windows")]
7306         extern "system" {
7307             fn ScriptStringCPtoX(ssa: *const ::std::ffi::c_void, icp: i32, ftrailing: super::Foundation::BOOL, px: *mut i32) -> ::windows::runtime::HRESULT;
7308         }
7309         let mut result__: <i32 as ::windows::runtime::Abi>::Abi = ::std::mem::zeroed();
7310         ScriptStringCPtoX(::std::mem::transmute(ssa), ::std::mem::transmute(icp), ftrailing.into_param().abi(), &mut result__).from_abi::<i32>(result__)
7311     }
7312     #[cfg(not(windows))]
7313     unimplemented!("Unsupported target OS");
7314 }
7315 #[inline]
ScriptStringFree(pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()>7316 pub unsafe fn ScriptStringFree(pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7317     #[cfg(windows)]
7318     {
7319         #[link(name = "windows")]
7320         extern "system" {
7321             fn ScriptStringFree(pssa: *mut *mut ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
7322         }
7323         ScriptStringFree(::std::mem::transmute(pssa)).ok()
7324     }
7325     #[cfg(not(windows))]
7326     unimplemented!("Unsupported target OS");
7327 }
7328 #[inline]
ScriptStringGetLogicalWidths(ssa: *const ::std::ffi::c_void, pidx: *mut i32) -> ::windows::runtime::Result<()>7329 pub unsafe fn ScriptStringGetLogicalWidths(ssa: *const ::std::ffi::c_void, pidx: *mut i32) -> ::windows::runtime::Result<()> {
7330     #[cfg(windows)]
7331     {
7332         #[link(name = "windows")]
7333         extern "system" {
7334             fn ScriptStringGetLogicalWidths(ssa: *const ::std::ffi::c_void, pidx: *mut i32) -> ::windows::runtime::HRESULT;
7335         }
7336         ScriptStringGetLogicalWidths(::std::mem::transmute(ssa), ::std::mem::transmute(pidx)).ok()
7337     }
7338     #[cfg(not(windows))]
7339     unimplemented!("Unsupported target OS");
7340 }
7341 #[inline]
ScriptStringGetOrder(ssa: *const ::std::ffi::c_void, puorder: *mut u32) -> ::windows::runtime::Result<()>7342 pub unsafe fn ScriptStringGetOrder(ssa: *const ::std::ffi::c_void, puorder: *mut u32) -> ::windows::runtime::Result<()> {
7343     #[cfg(windows)]
7344     {
7345         #[link(name = "windows")]
7346         extern "system" {
7347             fn ScriptStringGetOrder(ssa: *const ::std::ffi::c_void, puorder: *mut u32) -> ::windows::runtime::HRESULT;
7348         }
7349         ScriptStringGetOrder(::std::mem::transmute(ssa), ::std::mem::transmute(puorder)).ok()
7350     }
7351     #[cfg(not(windows))]
7352     unimplemented!("Unsupported target OS");
7353 }
7354 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
7355 #[inline]
ScriptStringOut<'a, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(ssa: *const ::std::ffi::c_void, ix: i32, iy: i32, uoptions: super::Graphics::Gdi::ETO_OPTIONS, prc: *const super::Foundation::RECT, iminsel: i32, imaxsel: i32, fdisabled: Param7) -> ::windows::runtime::Result<()>7356 pub unsafe fn ScriptStringOut<'a, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::BOOL>>(ssa: *const ::std::ffi::c_void, ix: i32, iy: i32, uoptions: super::Graphics::Gdi::ETO_OPTIONS, prc: *const super::Foundation::RECT, iminsel: i32, imaxsel: i32, fdisabled: Param7) -> ::windows::runtime::Result<()> {
7357     #[cfg(windows)]
7358     {
7359         #[link(name = "windows")]
7360         extern "system" {
7361             fn ScriptStringOut(ssa: *const ::std::ffi::c_void, ix: i32, iy: i32, uoptions: super::Graphics::Gdi::ETO_OPTIONS, prc: *const super::Foundation::RECT, iminsel: i32, imaxsel: i32, fdisabled: super::Foundation::BOOL) -> ::windows::runtime::HRESULT;
7362         }
7363         ScriptStringOut(::std::mem::transmute(ssa), ::std::mem::transmute(ix), ::std::mem::transmute(iy), ::std::mem::transmute(uoptions), ::std::mem::transmute(prc), ::std::mem::transmute(iminsel), ::std::mem::transmute(imaxsel), fdisabled.into_param().abi()).ok()
7364     }
7365     #[cfg(not(windows))]
7366     unimplemented!("Unsupported target OS");
7367 }
7368 #[inline]
ScriptStringValidate(ssa: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()>7369 pub unsafe fn ScriptStringValidate(ssa: *const ::std::ffi::c_void) -> ::windows::runtime::Result<()> {
7370     #[cfg(windows)]
7371     {
7372         #[link(name = "windows")]
7373         extern "system" {
7374             fn ScriptStringValidate(ssa: *const ::std::ffi::c_void) -> ::windows::runtime::HRESULT;
7375         }
7376         ScriptStringValidate(::std::mem::transmute(ssa)).ok()
7377     }
7378     #[cfg(not(windows))]
7379     unimplemented!("Unsupported target OS");
7380 }
7381 #[inline]
ScriptStringXtoCP(ssa: *const ::std::ffi::c_void, ix: i32, pich: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::Result<()>7382 pub unsafe fn ScriptStringXtoCP(ssa: *const ::std::ffi::c_void, ix: i32, pich: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::Result<()> {
7383     #[cfg(windows)]
7384     {
7385         #[link(name = "windows")]
7386         extern "system" {
7387             fn ScriptStringXtoCP(ssa: *const ::std::ffi::c_void, ix: i32, pich: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::HRESULT;
7388         }
7389         ScriptStringXtoCP(::std::mem::transmute(ssa), ::std::mem::transmute(ix), ::std::mem::transmute(pich), ::std::mem::transmute(pitrailing)).ok()
7390     }
7391     #[cfg(not(windows))]
7392     unimplemented!("Unsupported target OS");
7393 }
7394 #[inline]
ScriptString_pLogAttr(ssa: *const ::std::ffi::c_void) -> *mut SCRIPT_LOGATTR7395 pub unsafe fn ScriptString_pLogAttr(ssa: *const ::std::ffi::c_void) -> *mut SCRIPT_LOGATTR {
7396     #[cfg(windows)]
7397     {
7398         #[link(name = "windows")]
7399         extern "system" {
7400             fn ScriptString_pLogAttr(ssa: *const ::std::ffi::c_void) -> *mut SCRIPT_LOGATTR;
7401         }
7402         ::std::mem::transmute(ScriptString_pLogAttr(::std::mem::transmute(ssa)))
7403     }
7404     #[cfg(not(windows))]
7405     unimplemented!("Unsupported target OS");
7406 }
7407 #[cfg(feature = "Win32_Foundation")]
7408 #[inline]
ScriptString_pSize(ssa: *const ::std::ffi::c_void) -> *mut super::Foundation::SIZE7409 pub unsafe fn ScriptString_pSize(ssa: *const ::std::ffi::c_void) -> *mut super::Foundation::SIZE {
7410     #[cfg(windows)]
7411     {
7412         #[link(name = "windows")]
7413         extern "system" {
7414             fn ScriptString_pSize(ssa: *const ::std::ffi::c_void) -> *mut super::Foundation::SIZE;
7415         }
7416         ::std::mem::transmute(ScriptString_pSize(::std::mem::transmute(ssa)))
7417     }
7418     #[cfg(not(windows))]
7419     unimplemented!("Unsupported target OS");
7420 }
7421 #[inline]
ScriptString_pcOutChars(ssa: *const ::std::ffi::c_void) -> *mut i327422 pub unsafe fn ScriptString_pcOutChars(ssa: *const ::std::ffi::c_void) -> *mut i32 {
7423     #[cfg(windows)]
7424     {
7425         #[link(name = "windows")]
7426         extern "system" {
7427             fn ScriptString_pcOutChars(ssa: *const ::std::ffi::c_void) -> *mut i32;
7428         }
7429         ::std::mem::transmute(ScriptString_pcOutChars(::std::mem::transmute(ssa)))
7430     }
7431     #[cfg(not(windows))]
7432     unimplemented!("Unsupported target OS");
7433 }
7434 #[cfg(feature = "Win32_Graphics_Gdi")]
7435 #[inline]
ScriptSubstituteSingleGlyph<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, pwoutglyphid: *mut u16) -> ::windows::runtime::Result<()>7436 pub unsafe fn ScriptSubstituteSingleGlyph<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, pwoutglyphid: *mut u16) -> ::windows::runtime::Result<()> {
7437     #[cfg(windows)]
7438     {
7439         #[link(name = "windows")]
7440         extern "system" {
7441             fn ScriptSubstituteSingleGlyph(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, psa: *const SCRIPT_ANALYSIS, tagscript: u32, taglangsys: u32, tagfeature: u32, lparameter: i32, wglyphid: u16, pwoutglyphid: *mut u16) -> ::windows::runtime::HRESULT;
7442         }
7443         ScriptSubstituteSingleGlyph(hdc.into_param().abi(), ::std::mem::transmute(psc), ::std::mem::transmute(psa), ::std::mem::transmute(tagscript), ::std::mem::transmute(taglangsys), ::std::mem::transmute(tagfeature), ::std::mem::transmute(lparameter), ::std::mem::transmute(wglyphid), ::std::mem::transmute(pwoutglyphid)).ok()
7444     }
7445     #[cfg(not(windows))]
7446     unimplemented!("Unsupported target OS");
7447 }
7448 #[cfg(all(feature = "Win32_Foundation", feature = "Win32_Graphics_Gdi"))]
7449 #[inline]
ScriptTextOut<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, x: i32, y: i32, fuoptions: u32, lprc: *const super::Foundation::RECT, psa: *const SCRIPT_ANALYSIS, pwcreserved: Param7, ireserved: i32, pwglyphs: *const u16, cglyphs: i32, piadvance: *const i32, pijustify: *const i32, pgoffset: *const GOFFSET) -> ::windows::runtime::Result<()>7450 pub unsafe fn ScriptTextOut<'a, Param0: ::windows::runtime::IntoParam<'a, super::Graphics::Gdi::HDC>, Param7: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(hdc: Param0, psc: *mut *mut ::std::ffi::c_void, x: i32, y: i32, fuoptions: u32, lprc: *const super::Foundation::RECT, psa: *const SCRIPT_ANALYSIS, pwcreserved: Param7, ireserved: i32, pwglyphs: *const u16, cglyphs: i32, piadvance: *const i32, pijustify: *const i32, pgoffset: *const GOFFSET) -> ::windows::runtime::Result<()> {
7451     #[cfg(windows)]
7452     {
7453         #[link(name = "windows")]
7454         extern "system" {
7455             fn ScriptTextOut(hdc: super::Graphics::Gdi::HDC, psc: *mut *mut ::std::ffi::c_void, x: i32, y: i32, fuoptions: u32, lprc: *const super::Foundation::RECT, psa: *const SCRIPT_ANALYSIS, pwcreserved: super::Foundation::PWSTR, ireserved: i32, pwglyphs: *const u16, cglyphs: i32, piadvance: *const i32, pijustify: *const i32, pgoffset: *const GOFFSET) -> ::windows::runtime::HRESULT;
7456         }
7457         ScriptTextOut(
7458             hdc.into_param().abi(),
7459             ::std::mem::transmute(psc),
7460             ::std::mem::transmute(x),
7461             ::std::mem::transmute(y),
7462             ::std::mem::transmute(fuoptions),
7463             ::std::mem::transmute(lprc),
7464             ::std::mem::transmute(psa),
7465             pwcreserved.into_param().abi(),
7466             ::std::mem::transmute(ireserved),
7467             ::std::mem::transmute(pwglyphs),
7468             ::std::mem::transmute(cglyphs),
7469             ::std::mem::transmute(piadvance),
7470             ::std::mem::transmute(pijustify),
7471             ::std::mem::transmute(pgoffset),
7472         )
7473         .ok()
7474     }
7475     #[cfg(not(windows))]
7476     unimplemented!("Unsupported target OS");
7477 }
7478 #[inline]
ScriptXtoCP(ix: i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, picp: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::Result<()>7479 pub unsafe fn ScriptXtoCP(ix: i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, picp: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::Result<()> {
7480     #[cfg(windows)]
7481     {
7482         #[link(name = "windows")]
7483         extern "system" {
7484             fn ScriptXtoCP(ix: i32, cchars: i32, cglyphs: i32, pwlogclust: *const u16, psva: *const SCRIPT_VISATTR, piadvance: *const i32, psa: *const SCRIPT_ANALYSIS, picp: *mut i32, pitrailing: *mut i32) -> ::windows::runtime::HRESULT;
7485         }
7486         ScriptXtoCP(::std::mem::transmute(ix), ::std::mem::transmute(cchars), ::std::mem::transmute(cglyphs), ::std::mem::transmute(pwlogclust), ::std::mem::transmute(psva), ::std::mem::transmute(piadvance), ::std::mem::transmute(psa), ::std::mem::transmute(picp), ::std::mem::transmute(pitrailing)).ok()
7487     }
7488     #[cfg(not(windows))]
7489     unimplemented!("Unsupported target OS");
7490 }
7491 #[cfg(feature = "Win32_Foundation")]
7492 #[inline]
SetCalendarInfoA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, calendar: u32, caltype: u32, lpcaldata: Param3) -> super::Foundation::BOOL7493 pub unsafe fn SetCalendarInfoA<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, calendar: u32, caltype: u32, lpcaldata: Param3) -> super::Foundation::BOOL {
7494     #[cfg(windows)]
7495     {
7496         #[link(name = "windows")]
7497         extern "system" {
7498             fn SetCalendarInfoA(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PSTR) -> super::Foundation::BOOL;
7499         }
7500         ::std::mem::transmute(SetCalendarInfoA(::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype), lpcaldata.into_param().abi()))
7501     }
7502     #[cfg(not(windows))]
7503     unimplemented!("Unsupported target OS");
7504 }
7505 #[cfg(feature = "Win32_Foundation")]
7506 #[inline]
SetCalendarInfoW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, calendar: u32, caltype: u32, lpcaldata: Param3) -> super::Foundation::BOOL7507 pub unsafe fn SetCalendarInfoW<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, calendar: u32, caltype: u32, lpcaldata: Param3) -> super::Foundation::BOOL {
7508     #[cfg(windows)]
7509     {
7510         #[link(name = "windows")]
7511         extern "system" {
7512             fn SetCalendarInfoW(locale: u32, calendar: u32, caltype: u32, lpcaldata: super::Foundation::PWSTR) -> super::Foundation::BOOL;
7513         }
7514         ::std::mem::transmute(SetCalendarInfoW(::std::mem::transmute(locale), ::std::mem::transmute(calendar), ::std::mem::transmute(caltype), lpcaldata.into_param().abi()))
7515     }
7516     #[cfg(not(windows))]
7517     unimplemented!("Unsupported target OS");
7518 }
7519 #[cfg(feature = "Win32_Foundation")]
7520 #[inline]
SetLocaleInfoA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, lctype: u32, lplcdata: Param2) -> super::Foundation::BOOL7521 pub unsafe fn SetLocaleInfoA<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: u32, lctype: u32, lplcdata: Param2) -> super::Foundation::BOOL {
7522     #[cfg(windows)]
7523     {
7524         #[link(name = "windows")]
7525         extern "system" {
7526             fn SetLocaleInfoA(locale: u32, lctype: u32, lplcdata: super::Foundation::PSTR) -> super::Foundation::BOOL;
7527         }
7528         ::std::mem::transmute(SetLocaleInfoA(::std::mem::transmute(locale), ::std::mem::transmute(lctype), lplcdata.into_param().abi()))
7529     }
7530     #[cfg(not(windows))]
7531     unimplemented!("Unsupported target OS");
7532 }
7533 #[cfg(feature = "Win32_Foundation")]
7534 #[inline]
SetLocaleInfoW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, lctype: u32, lplcdata: Param2) -> super::Foundation::BOOL7535 pub unsafe fn SetLocaleInfoW<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(locale: u32, lctype: u32, lplcdata: Param2) -> super::Foundation::BOOL {
7536     #[cfg(windows)]
7537     {
7538         #[link(name = "windows")]
7539         extern "system" {
7540             fn SetLocaleInfoW(locale: u32, lctype: u32, lplcdata: super::Foundation::PWSTR) -> super::Foundation::BOOL;
7541         }
7542         ::std::mem::transmute(SetLocaleInfoW(::std::mem::transmute(locale), ::std::mem::transmute(lctype), lplcdata.into_param().abi()))
7543     }
7544     #[cfg(not(windows))]
7545     unimplemented!("Unsupported target OS");
7546 }
7547 #[cfg(feature = "Win32_Foundation")]
7548 #[inline]
SetProcessPreferredUILanguages<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwszlanguagesbuffer: Param1, pulnumlanguages: *mut u32) -> super::Foundation::BOOL7549 pub unsafe fn SetProcessPreferredUILanguages<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwszlanguagesbuffer: Param1, pulnumlanguages: *mut u32) -> super::Foundation::BOOL {
7550     #[cfg(windows)]
7551     {
7552         #[link(name = "windows")]
7553         extern "system" {
7554             fn SetProcessPreferredUILanguages(dwflags: u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pulnumlanguages: *mut u32) -> super::Foundation::BOOL;
7555         }
7556         ::std::mem::transmute(SetProcessPreferredUILanguages(::std::mem::transmute(dwflags), pwszlanguagesbuffer.into_param().abi(), ::std::mem::transmute(pulnumlanguages)))
7557     }
7558     #[cfg(not(windows))]
7559     unimplemented!("Unsupported target OS");
7560 }
7561 #[cfg(feature = "Win32_Foundation")]
7562 #[inline]
SetThreadLocale(locale: u32) -> super::Foundation::BOOL7563 pub unsafe fn SetThreadLocale(locale: u32) -> super::Foundation::BOOL {
7564     #[cfg(windows)]
7565     {
7566         #[link(name = "windows")]
7567         extern "system" {
7568             fn SetThreadLocale(locale: u32) -> super::Foundation::BOOL;
7569         }
7570         ::std::mem::transmute(SetThreadLocale(::std::mem::transmute(locale)))
7571     }
7572     #[cfg(not(windows))]
7573     unimplemented!("Unsupported target OS");
7574 }
7575 #[cfg(feature = "Win32_Foundation")]
7576 #[inline]
SetThreadPreferredUILanguages<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwszlanguagesbuffer: Param1, pulnumlanguages: *mut u32) -> super::Foundation::BOOL7577 pub unsafe fn SetThreadPreferredUILanguages<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, pwszlanguagesbuffer: Param1, pulnumlanguages: *mut u32) -> super::Foundation::BOOL {
7578     #[cfg(windows)]
7579     {
7580         #[link(name = "windows")]
7581         extern "system" {
7582             fn SetThreadPreferredUILanguages(dwflags: u32, pwszlanguagesbuffer: super::Foundation::PWSTR, pulnumlanguages: *mut u32) -> super::Foundation::BOOL;
7583         }
7584         ::std::mem::transmute(SetThreadPreferredUILanguages(::std::mem::transmute(dwflags), pwszlanguagesbuffer.into_param().abi(), ::std::mem::transmute(pulnumlanguages)))
7585     }
7586     #[cfg(not(windows))]
7587     unimplemented!("Unsupported target OS");
7588 }
7589 #[cfg(feature = "Win32_Foundation")]
7590 #[inline]
SetThreadPreferredUILanguages2<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(flags: u32, languages: Param1, numlanguagesset: *mut u32, snapshot: *mut HSAVEDUILANGUAGES) -> super::Foundation::BOOL7591 pub unsafe fn SetThreadPreferredUILanguages2<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(flags: u32, languages: Param1, numlanguagesset: *mut u32, snapshot: *mut HSAVEDUILANGUAGES) -> super::Foundation::BOOL {
7592     #[cfg(windows)]
7593     {
7594         #[link(name = "windows")]
7595         extern "system" {
7596             fn SetThreadPreferredUILanguages2(flags: u32, languages: super::Foundation::PWSTR, numlanguagesset: *mut u32, snapshot: *mut HSAVEDUILANGUAGES) -> super::Foundation::BOOL;
7597         }
7598         ::std::mem::transmute(SetThreadPreferredUILanguages2(::std::mem::transmute(flags), languages.into_param().abi(), ::std::mem::transmute(numlanguagesset), ::std::mem::transmute(snapshot)))
7599     }
7600     #[cfg(not(windows))]
7601     unimplemented!("Unsupported target OS");
7602 }
7603 #[inline]
SetThreadUILanguage(langid: u16) -> u167604 pub unsafe fn SetThreadUILanguage(langid: u16) -> u16 {
7605     #[cfg(windows)]
7606     {
7607         #[link(name = "windows")]
7608         extern "system" {
7609             fn SetThreadUILanguage(langid: u16) -> u16;
7610         }
7611         ::std::mem::transmute(SetThreadUILanguage(::std::mem::transmute(langid)))
7612     }
7613     #[cfg(not(windows))]
7614     unimplemented!("Unsupported target OS");
7615 }
7616 #[cfg(feature = "Win32_Foundation")]
7617 #[inline]
SetUserGeoID(geoid: i32) -> super::Foundation::BOOL7618 pub unsafe fn SetUserGeoID(geoid: i32) -> super::Foundation::BOOL {
7619     #[cfg(windows)]
7620     {
7621         #[link(name = "windows")]
7622         extern "system" {
7623             fn SetUserGeoID(geoid: i32) -> super::Foundation::BOOL;
7624         }
7625         ::std::mem::transmute(SetUserGeoID(::std::mem::transmute(geoid)))
7626     }
7627     #[cfg(not(windows))]
7628     unimplemented!("Unsupported target OS");
7629 }
7630 #[cfg(feature = "Win32_Foundation")]
7631 #[inline]
SetUserGeoName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(geoname: Param0) -> super::Foundation::BOOL7632 pub unsafe fn SetUserGeoName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(geoname: Param0) -> super::Foundation::BOOL {
7633     #[cfg(windows)]
7634     {
7635         #[link(name = "windows")]
7636         extern "system" {
7637             fn SetUserGeoName(geoname: super::Foundation::PWSTR) -> super::Foundation::BOOL;
7638         }
7639         ::std::mem::transmute(SetUserGeoName(geoname.into_param().abi()))
7640     }
7641     #[cfg(not(windows))]
7642     unimplemented!("Unsupported target OS");
7643 }
7644 pub const SpellCheckerFactory: ::windows::runtime::GUID = ::windows::runtime::GUID::from_values(2058577491, 6038, 18507, [189, 250, 231, 79, 29, 183, 193, 220]);
7645 #[cfg(feature = "Win32_Foundation")]
7646 pub type TIMEFMT_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR) -> super::Foundation::BOOL;
7647 #[cfg(feature = "Win32_Foundation")]
7648 pub type TIMEFMT_ENUMPROCEX = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: super::Foundation::LPARAM) -> super::Foundation::BOOL;
7649 #[cfg(feature = "Win32_Foundation")]
7650 pub type TIMEFMT_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR) -> super::Foundation::BOOL;
7651 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7652 #[repr(transparent)]
7653 pub struct TIME_FORMAT_FLAGS(pub u32);
7654 pub const TIME_NOMINUTESORSECONDS: TIME_FORMAT_FLAGS = TIME_FORMAT_FLAGS(1u32);
7655 pub const TIME_NOSECONDS: TIME_FORMAT_FLAGS = TIME_FORMAT_FLAGS(2u32);
7656 pub const TIME_NOTIMEMARKER: TIME_FORMAT_FLAGS = TIME_FORMAT_FLAGS(4u32);
7657 pub const TIME_FORCE24HOURFORMAT: TIME_FORMAT_FLAGS = TIME_FORMAT_FLAGS(8u32);
7658 impl ::std::convert::From<u32> for TIME_FORMAT_FLAGS {
from(value: u32) -> Self7659     fn from(value: u32) -> Self {
7660         Self(value)
7661     }
7662 }
7663 unsafe impl ::windows::runtime::Abi for TIME_FORMAT_FLAGS {
7664     type Abi = Self;
7665     type DefaultType = Self;
7666 }
7667 impl ::std::ops::BitOr for TIME_FORMAT_FLAGS {
7668     type Output = Self;
bitor(self, rhs: Self) -> Self7669     fn bitor(self, rhs: Self) -> Self {
7670         Self(self.0 | rhs.0)
7671     }
7672 }
7673 impl ::std::ops::BitAnd for TIME_FORMAT_FLAGS {
7674     type Output = Self;
bitand(self, rhs: Self) -> Self7675     fn bitand(self, rhs: Self) -> Self {
7676         Self(self.0 & rhs.0)
7677     }
7678 }
7679 impl ::std::ops::BitOrAssign for TIME_FORMAT_FLAGS {
bitor_assign(&mut self, rhs: Self)7680     fn bitor_assign(&mut self, rhs: Self) {
7681         self.0.bitor_assign(rhs.0)
7682     }
7683 }
7684 impl ::std::ops::BitAndAssign for TIME_FORMAT_FLAGS {
bitand_assign(&mut self, rhs: Self)7685     fn bitand_assign(&mut self, rhs: Self) {
7686         self.0.bitand_assign(rhs.0)
7687     }
7688 }
7689 impl ::std::ops::Not for TIME_FORMAT_FLAGS {
7690     type Output = Self;
not(self) -> Self7691     fn not(self) -> Self {
7692         Self(self.0.not())
7693     }
7694 }
7695 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7696 #[repr(transparent)]
7697 pub struct TRANSLATE_CHARSET_INFO_FLAGS(pub u32);
7698 pub const TCI_SRCCHARSET: TRANSLATE_CHARSET_INFO_FLAGS = TRANSLATE_CHARSET_INFO_FLAGS(1u32);
7699 pub const TCI_SRCCODEPAGE: TRANSLATE_CHARSET_INFO_FLAGS = TRANSLATE_CHARSET_INFO_FLAGS(2u32);
7700 pub const TCI_SRCFONTSIG: TRANSLATE_CHARSET_INFO_FLAGS = TRANSLATE_CHARSET_INFO_FLAGS(3u32);
7701 pub const TCI_SRCLOCALE: TRANSLATE_CHARSET_INFO_FLAGS = TRANSLATE_CHARSET_INFO_FLAGS(4096u32);
7702 impl ::std::convert::From<u32> for TRANSLATE_CHARSET_INFO_FLAGS {
from(value: u32) -> Self7703     fn from(value: u32) -> Self {
7704         Self(value)
7705     }
7706 }
7707 unsafe impl ::windows::runtime::Abi for TRANSLATE_CHARSET_INFO_FLAGS {
7708     type Abi = Self;
7709     type DefaultType = Self;
7710 }
7711 impl ::std::ops::BitOr for TRANSLATE_CHARSET_INFO_FLAGS {
7712     type Output = Self;
bitor(self, rhs: Self) -> Self7713     fn bitor(self, rhs: Self) -> Self {
7714         Self(self.0 | rhs.0)
7715     }
7716 }
7717 impl ::std::ops::BitAnd for TRANSLATE_CHARSET_INFO_FLAGS {
7718     type Output = Self;
bitand(self, rhs: Self) -> Self7719     fn bitand(self, rhs: Self) -> Self {
7720         Self(self.0 & rhs.0)
7721     }
7722 }
7723 impl ::std::ops::BitOrAssign for TRANSLATE_CHARSET_INFO_FLAGS {
bitor_assign(&mut self, rhs: Self)7724     fn bitor_assign(&mut self, rhs: Self) {
7725         self.0.bitor_assign(rhs.0)
7726     }
7727 }
7728 impl ::std::ops::BitAndAssign for TRANSLATE_CHARSET_INFO_FLAGS {
bitand_assign(&mut self, rhs: Self)7729     fn bitand_assign(&mut self, rhs: Self) {
7730         self.0.bitand_assign(rhs.0)
7731     }
7732 }
7733 impl ::std::ops::Not for TRANSLATE_CHARSET_INFO_FLAGS {
7734     type Output = Self;
not(self) -> Self7735     fn not(self) -> Self {
7736         Self(self.0.not())
7737     }
7738 }
7739 #[cfg(feature = "Win32_Foundation")]
7740 #[inline]
TranslateCharsetInfo(lpsrc: *mut u32, lpcs: *mut CHARSETINFO, dwflags: TRANSLATE_CHARSET_INFO_FLAGS) -> super::Foundation::BOOL7741 pub unsafe fn TranslateCharsetInfo(lpsrc: *mut u32, lpcs: *mut CHARSETINFO, dwflags: TRANSLATE_CHARSET_INFO_FLAGS) -> super::Foundation::BOOL {
7742     #[cfg(windows)]
7743     {
7744         #[link(name = "windows")]
7745         extern "system" {
7746             fn TranslateCharsetInfo(lpsrc: *mut u32, lpcs: *mut CHARSETINFO, dwflags: TRANSLATE_CHARSET_INFO_FLAGS) -> super::Foundation::BOOL;
7747         }
7748         ::std::mem::transmute(TranslateCharsetInfo(::std::mem::transmute(lpsrc), ::std::mem::transmute(lpcs), ::std::mem::transmute(dwflags)))
7749     }
7750     #[cfg(not(windows))]
7751     unimplemented!("Unsupported target OS");
7752 }
7753 pub const U16_MAX_LENGTH: u32 = 2u32;
7754 pub const U8_MAX_LENGTH: u32 = 4u32;
7755 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7756 #[repr(transparent)]
7757 pub struct UAcceptResult(pub i32);
7758 pub const ULOC_ACCEPT_FAILED: UAcceptResult = UAcceptResult(0i32);
7759 pub const ULOC_ACCEPT_VALID: UAcceptResult = UAcceptResult(1i32);
7760 pub const ULOC_ACCEPT_FALLBACK: UAcceptResult = UAcceptResult(2i32);
7761 impl ::std::convert::From<i32> for UAcceptResult {
from(value: i32) -> Self7762     fn from(value: i32) -> Self {
7763         Self(value)
7764     }
7765 }
7766 unsafe impl ::windows::runtime::Abi for UAcceptResult {
7767     type Abi = Self;
7768     type DefaultType = Self;
7769 }
7770 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7771 #[repr(transparent)]
7772 pub struct UAlphabeticIndexLabelType(pub i32);
7773 pub const U_ALPHAINDEX_NORMAL: UAlphabeticIndexLabelType = UAlphabeticIndexLabelType(0i32);
7774 pub const U_ALPHAINDEX_UNDERFLOW: UAlphabeticIndexLabelType = UAlphabeticIndexLabelType(1i32);
7775 pub const U_ALPHAINDEX_INFLOW: UAlphabeticIndexLabelType = UAlphabeticIndexLabelType(2i32);
7776 pub const U_ALPHAINDEX_OVERFLOW: UAlphabeticIndexLabelType = UAlphabeticIndexLabelType(3i32);
7777 impl ::std::convert::From<i32> for UAlphabeticIndexLabelType {
from(value: i32) -> Self7778     fn from(value: i32) -> Self {
7779         Self(value)
7780     }
7781 }
7782 unsafe impl ::windows::runtime::Abi for UAlphabeticIndexLabelType {
7783     type Abi = Self;
7784     type DefaultType = Self;
7785 }
7786 pub const UBIDI_DEFAULT_LTR: u32 = 254u32;
7787 pub const UBIDI_DEFAULT_RTL: u32 = 255u32;
7788 pub const UBIDI_DO_MIRRORING: u32 = 2u32;
7789 pub const UBIDI_INSERT_LRM_FOR_NUMERIC: u32 = 4u32;
7790 pub const UBIDI_KEEP_BASE_COMBINING: u32 = 1u32;
7791 pub const UBIDI_LEVEL_OVERRIDE: u32 = 128u32;
7792 pub const UBIDI_MAP_NOWHERE: i32 = -1i32;
7793 pub const UBIDI_MAX_EXPLICIT_LEVEL: u32 = 125u32;
7794 pub const UBIDI_OUTPUT_REVERSE: u32 = 16u32;
7795 pub const UBIDI_REMOVE_BIDI_CONTROLS: u32 = 8u32;
7796 #[repr(C)]
7797 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
7798 pub struct UBiDi(pub u8);
7799 pub type UBiDiClassCallback = unsafe extern "system" fn(context: *const ::std::ffi::c_void, c: i32) -> UCharDirection;
7800 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7801 #[repr(transparent)]
7802 pub struct UBiDiDirection(pub i32);
7803 pub const UBIDI_LTR: UBiDiDirection = UBiDiDirection(0i32);
7804 pub const UBIDI_RTL: UBiDiDirection = UBiDiDirection(1i32);
7805 pub const UBIDI_MIXED: UBiDiDirection = UBiDiDirection(2i32);
7806 pub const UBIDI_NEUTRAL: UBiDiDirection = UBiDiDirection(3i32);
7807 impl ::std::convert::From<i32> for UBiDiDirection {
from(value: i32) -> Self7808     fn from(value: i32) -> Self {
7809         Self(value)
7810     }
7811 }
7812 unsafe impl ::windows::runtime::Abi for UBiDiDirection {
7813     type Abi = Self;
7814     type DefaultType = Self;
7815 }
7816 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7817 #[repr(transparent)]
7818 pub struct UBiDiMirroring(pub i32);
7819 pub const UBIDI_MIRRORING_OFF: UBiDiMirroring = UBiDiMirroring(0i32);
7820 pub const UBIDI_MIRRORING_ON: UBiDiMirroring = UBiDiMirroring(1i32);
7821 impl ::std::convert::From<i32> for UBiDiMirroring {
from(value: i32) -> Self7822     fn from(value: i32) -> Self {
7823         Self(value)
7824     }
7825 }
7826 unsafe impl ::windows::runtime::Abi for UBiDiMirroring {
7827     type Abi = Self;
7828     type DefaultType = Self;
7829 }
7830 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7831 #[repr(transparent)]
7832 pub struct UBiDiOrder(pub i32);
7833 pub const UBIDI_LOGICAL: UBiDiOrder = UBiDiOrder(0i32);
7834 pub const UBIDI_VISUAL: UBiDiOrder = UBiDiOrder(1i32);
7835 impl ::std::convert::From<i32> for UBiDiOrder {
from(value: i32) -> Self7836     fn from(value: i32) -> Self {
7837         Self(value)
7838     }
7839 }
7840 unsafe impl ::windows::runtime::Abi for UBiDiOrder {
7841     type Abi = Self;
7842     type DefaultType = Self;
7843 }
7844 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7845 #[repr(transparent)]
7846 pub struct UBiDiReorderingMode(pub i32);
7847 pub const UBIDI_REORDER_DEFAULT: UBiDiReorderingMode = UBiDiReorderingMode(0i32);
7848 pub const UBIDI_REORDER_NUMBERS_SPECIAL: UBiDiReorderingMode = UBiDiReorderingMode(1i32);
7849 pub const UBIDI_REORDER_GROUP_NUMBERS_WITH_R: UBiDiReorderingMode = UBiDiReorderingMode(2i32);
7850 pub const UBIDI_REORDER_RUNS_ONLY: UBiDiReorderingMode = UBiDiReorderingMode(3i32);
7851 pub const UBIDI_REORDER_INVERSE_NUMBERS_AS_L: UBiDiReorderingMode = UBiDiReorderingMode(4i32);
7852 pub const UBIDI_REORDER_INVERSE_LIKE_DIRECT: UBiDiReorderingMode = UBiDiReorderingMode(5i32);
7853 pub const UBIDI_REORDER_INVERSE_FOR_NUMBERS_SPECIAL: UBiDiReorderingMode = UBiDiReorderingMode(6i32);
7854 impl ::std::convert::From<i32> for UBiDiReorderingMode {
from(value: i32) -> Self7855     fn from(value: i32) -> Self {
7856         Self(value)
7857     }
7858 }
7859 unsafe impl ::windows::runtime::Abi for UBiDiReorderingMode {
7860     type Abi = Self;
7861     type DefaultType = Self;
7862 }
7863 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7864 #[repr(transparent)]
7865 pub struct UBiDiReorderingOption(pub i32);
7866 pub const UBIDI_OPTION_DEFAULT: UBiDiReorderingOption = UBiDiReorderingOption(0i32);
7867 pub const UBIDI_OPTION_INSERT_MARKS: UBiDiReorderingOption = UBiDiReorderingOption(1i32);
7868 pub const UBIDI_OPTION_REMOVE_CONTROLS: UBiDiReorderingOption = UBiDiReorderingOption(2i32);
7869 pub const UBIDI_OPTION_STREAMING: UBiDiReorderingOption = UBiDiReorderingOption(4i32);
7870 impl ::std::convert::From<i32> for UBiDiReorderingOption {
from(value: i32) -> Self7871     fn from(value: i32) -> Self {
7872         Self(value)
7873     }
7874 }
7875 unsafe impl ::windows::runtime::Abi for UBiDiReorderingOption {
7876     type Abi = Self;
7877     type DefaultType = Self;
7878 }
7879 #[repr(C)]
7880 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
7881 pub struct UBiDiTransform(pub u8);
7882 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7883 #[repr(transparent)]
7884 pub struct UBidiPairedBracketType(pub i32);
7885 pub const U_BPT_NONE: UBidiPairedBracketType = UBidiPairedBracketType(0i32);
7886 pub const U_BPT_OPEN: UBidiPairedBracketType = UBidiPairedBracketType(1i32);
7887 pub const U_BPT_CLOSE: UBidiPairedBracketType = UBidiPairedBracketType(2i32);
7888 impl ::std::convert::From<i32> for UBidiPairedBracketType {
from(value: i32) -> Self7889     fn from(value: i32) -> Self {
7890         Self(value)
7891     }
7892 }
7893 unsafe impl ::windows::runtime::Abi for UBidiPairedBracketType {
7894     type Abi = Self;
7895     type DefaultType = Self;
7896 }
7897 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
7898 #[repr(transparent)]
7899 pub struct UBlockCode(pub i32);
7900 pub const UBLOCK_NO_BLOCK: UBlockCode = UBlockCode(0i32);
7901 pub const UBLOCK_BASIC_LATIN: UBlockCode = UBlockCode(1i32);
7902 pub const UBLOCK_LATIN_1_SUPPLEMENT: UBlockCode = UBlockCode(2i32);
7903 pub const UBLOCK_LATIN_EXTENDED_A: UBlockCode = UBlockCode(3i32);
7904 pub const UBLOCK_LATIN_EXTENDED_B: UBlockCode = UBlockCode(4i32);
7905 pub const UBLOCK_IPA_EXTENSIONS: UBlockCode = UBlockCode(5i32);
7906 pub const UBLOCK_SPACING_MODIFIER_LETTERS: UBlockCode = UBlockCode(6i32);
7907 pub const UBLOCK_COMBINING_DIACRITICAL_MARKS: UBlockCode = UBlockCode(7i32);
7908 pub const UBLOCK_GREEK: UBlockCode = UBlockCode(8i32);
7909 pub const UBLOCK_CYRILLIC: UBlockCode = UBlockCode(9i32);
7910 pub const UBLOCK_ARMENIAN: UBlockCode = UBlockCode(10i32);
7911 pub const UBLOCK_HEBREW: UBlockCode = UBlockCode(11i32);
7912 pub const UBLOCK_ARABIC: UBlockCode = UBlockCode(12i32);
7913 pub const UBLOCK_SYRIAC: UBlockCode = UBlockCode(13i32);
7914 pub const UBLOCK_THAANA: UBlockCode = UBlockCode(14i32);
7915 pub const UBLOCK_DEVANAGARI: UBlockCode = UBlockCode(15i32);
7916 pub const UBLOCK_BENGALI: UBlockCode = UBlockCode(16i32);
7917 pub const UBLOCK_GURMUKHI: UBlockCode = UBlockCode(17i32);
7918 pub const UBLOCK_GUJARATI: UBlockCode = UBlockCode(18i32);
7919 pub const UBLOCK_ORIYA: UBlockCode = UBlockCode(19i32);
7920 pub const UBLOCK_TAMIL: UBlockCode = UBlockCode(20i32);
7921 pub const UBLOCK_TELUGU: UBlockCode = UBlockCode(21i32);
7922 pub const UBLOCK_KANNADA: UBlockCode = UBlockCode(22i32);
7923 pub const UBLOCK_MALAYALAM: UBlockCode = UBlockCode(23i32);
7924 pub const UBLOCK_SINHALA: UBlockCode = UBlockCode(24i32);
7925 pub const UBLOCK_THAI: UBlockCode = UBlockCode(25i32);
7926 pub const UBLOCK_LAO: UBlockCode = UBlockCode(26i32);
7927 pub const UBLOCK_TIBETAN: UBlockCode = UBlockCode(27i32);
7928 pub const UBLOCK_MYANMAR: UBlockCode = UBlockCode(28i32);
7929 pub const UBLOCK_GEORGIAN: UBlockCode = UBlockCode(29i32);
7930 pub const UBLOCK_HANGUL_JAMO: UBlockCode = UBlockCode(30i32);
7931 pub const UBLOCK_ETHIOPIC: UBlockCode = UBlockCode(31i32);
7932 pub const UBLOCK_CHEROKEE: UBlockCode = UBlockCode(32i32);
7933 pub const UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: UBlockCode = UBlockCode(33i32);
7934 pub const UBLOCK_OGHAM: UBlockCode = UBlockCode(34i32);
7935 pub const UBLOCK_RUNIC: UBlockCode = UBlockCode(35i32);
7936 pub const UBLOCK_KHMER: UBlockCode = UBlockCode(36i32);
7937 pub const UBLOCK_MONGOLIAN: UBlockCode = UBlockCode(37i32);
7938 pub const UBLOCK_LATIN_EXTENDED_ADDITIONAL: UBlockCode = UBlockCode(38i32);
7939 pub const UBLOCK_GREEK_EXTENDED: UBlockCode = UBlockCode(39i32);
7940 pub const UBLOCK_GENERAL_PUNCTUATION: UBlockCode = UBlockCode(40i32);
7941 pub const UBLOCK_SUPERSCRIPTS_AND_SUBSCRIPTS: UBlockCode = UBlockCode(41i32);
7942 pub const UBLOCK_CURRENCY_SYMBOLS: UBlockCode = UBlockCode(42i32);
7943 pub const UBLOCK_COMBINING_MARKS_FOR_SYMBOLS: UBlockCode = UBlockCode(43i32);
7944 pub const UBLOCK_LETTERLIKE_SYMBOLS: UBlockCode = UBlockCode(44i32);
7945 pub const UBLOCK_NUMBER_FORMS: UBlockCode = UBlockCode(45i32);
7946 pub const UBLOCK_ARROWS: UBlockCode = UBlockCode(46i32);
7947 pub const UBLOCK_MATHEMATICAL_OPERATORS: UBlockCode = UBlockCode(47i32);
7948 pub const UBLOCK_MISCELLANEOUS_TECHNICAL: UBlockCode = UBlockCode(48i32);
7949 pub const UBLOCK_CONTROL_PICTURES: UBlockCode = UBlockCode(49i32);
7950 pub const UBLOCK_OPTICAL_CHARACTER_RECOGNITION: UBlockCode = UBlockCode(50i32);
7951 pub const UBLOCK_ENCLOSED_ALPHANUMERICS: UBlockCode = UBlockCode(51i32);
7952 pub const UBLOCK_BOX_DRAWING: UBlockCode = UBlockCode(52i32);
7953 pub const UBLOCK_BLOCK_ELEMENTS: UBlockCode = UBlockCode(53i32);
7954 pub const UBLOCK_GEOMETRIC_SHAPES: UBlockCode = UBlockCode(54i32);
7955 pub const UBLOCK_MISCELLANEOUS_SYMBOLS: UBlockCode = UBlockCode(55i32);
7956 pub const UBLOCK_DINGBATS: UBlockCode = UBlockCode(56i32);
7957 pub const UBLOCK_BRAILLE_PATTERNS: UBlockCode = UBlockCode(57i32);
7958 pub const UBLOCK_CJK_RADICALS_SUPPLEMENT: UBlockCode = UBlockCode(58i32);
7959 pub const UBLOCK_KANGXI_RADICALS: UBlockCode = UBlockCode(59i32);
7960 pub const UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS: UBlockCode = UBlockCode(60i32);
7961 pub const UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION: UBlockCode = UBlockCode(61i32);
7962 pub const UBLOCK_HIRAGANA: UBlockCode = UBlockCode(62i32);
7963 pub const UBLOCK_KATAKANA: UBlockCode = UBlockCode(63i32);
7964 pub const UBLOCK_BOPOMOFO: UBlockCode = UBlockCode(64i32);
7965 pub const UBLOCK_HANGUL_COMPATIBILITY_JAMO: UBlockCode = UBlockCode(65i32);
7966 pub const UBLOCK_KANBUN: UBlockCode = UBlockCode(66i32);
7967 pub const UBLOCK_BOPOMOFO_EXTENDED: UBlockCode = UBlockCode(67i32);
7968 pub const UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS: UBlockCode = UBlockCode(68i32);
7969 pub const UBLOCK_CJK_COMPATIBILITY: UBlockCode = UBlockCode(69i32);
7970 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: UBlockCode = UBlockCode(70i32);
7971 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS: UBlockCode = UBlockCode(71i32);
7972 pub const UBLOCK_YI_SYLLABLES: UBlockCode = UBlockCode(72i32);
7973 pub const UBLOCK_YI_RADICALS: UBlockCode = UBlockCode(73i32);
7974 pub const UBLOCK_HANGUL_SYLLABLES: UBlockCode = UBlockCode(74i32);
7975 pub const UBLOCK_HIGH_SURROGATES: UBlockCode = UBlockCode(75i32);
7976 pub const UBLOCK_HIGH_PRIVATE_USE_SURROGATES: UBlockCode = UBlockCode(76i32);
7977 pub const UBLOCK_LOW_SURROGATES: UBlockCode = UBlockCode(77i32);
7978 pub const UBLOCK_PRIVATE_USE_AREA: UBlockCode = UBlockCode(78i32);
7979 pub const UBLOCK_PRIVATE_USE: UBlockCode = UBlockCode(78i32);
7980 pub const UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS: UBlockCode = UBlockCode(79i32);
7981 pub const UBLOCK_ALPHABETIC_PRESENTATION_FORMS: UBlockCode = UBlockCode(80i32);
7982 pub const UBLOCK_ARABIC_PRESENTATION_FORMS_A: UBlockCode = UBlockCode(81i32);
7983 pub const UBLOCK_COMBINING_HALF_MARKS: UBlockCode = UBlockCode(82i32);
7984 pub const UBLOCK_CJK_COMPATIBILITY_FORMS: UBlockCode = UBlockCode(83i32);
7985 pub const UBLOCK_SMALL_FORM_VARIANTS: UBlockCode = UBlockCode(84i32);
7986 pub const UBLOCK_ARABIC_PRESENTATION_FORMS_B: UBlockCode = UBlockCode(85i32);
7987 pub const UBLOCK_SPECIALS: UBlockCode = UBlockCode(86i32);
7988 pub const UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS: UBlockCode = UBlockCode(87i32);
7989 pub const UBLOCK_OLD_ITALIC: UBlockCode = UBlockCode(88i32);
7990 pub const UBLOCK_GOTHIC: UBlockCode = UBlockCode(89i32);
7991 pub const UBLOCK_DESERET: UBlockCode = UBlockCode(90i32);
7992 pub const UBLOCK_BYZANTINE_MUSICAL_SYMBOLS: UBlockCode = UBlockCode(91i32);
7993 pub const UBLOCK_MUSICAL_SYMBOLS: UBlockCode = UBlockCode(92i32);
7994 pub const UBLOCK_MATHEMATICAL_ALPHANUMERIC_SYMBOLS: UBlockCode = UBlockCode(93i32);
7995 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: UBlockCode = UBlockCode(94i32);
7996 pub const UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: UBlockCode = UBlockCode(95i32);
7997 pub const UBLOCK_TAGS: UBlockCode = UBlockCode(96i32);
7998 pub const UBLOCK_CYRILLIC_SUPPLEMENT: UBlockCode = UBlockCode(97i32);
7999 pub const UBLOCK_CYRILLIC_SUPPLEMENTARY: UBlockCode = UBlockCode(97i32);
8000 pub const UBLOCK_TAGALOG: UBlockCode = UBlockCode(98i32);
8001 pub const UBLOCK_HANUNOO: UBlockCode = UBlockCode(99i32);
8002 pub const UBLOCK_BUHID: UBlockCode = UBlockCode(100i32);
8003 pub const UBLOCK_TAGBANWA: UBlockCode = UBlockCode(101i32);
8004 pub const UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: UBlockCode = UBlockCode(102i32);
8005 pub const UBLOCK_SUPPLEMENTAL_ARROWS_A: UBlockCode = UBlockCode(103i32);
8006 pub const UBLOCK_SUPPLEMENTAL_ARROWS_B: UBlockCode = UBlockCode(104i32);
8007 pub const UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: UBlockCode = UBlockCode(105i32);
8008 pub const UBLOCK_SUPPLEMENTAL_MATHEMATICAL_OPERATORS: UBlockCode = UBlockCode(106i32);
8009 pub const UBLOCK_KATAKANA_PHONETIC_EXTENSIONS: UBlockCode = UBlockCode(107i32);
8010 pub const UBLOCK_VARIATION_SELECTORS: UBlockCode = UBlockCode(108i32);
8011 pub const UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_A: UBlockCode = UBlockCode(109i32);
8012 pub const UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B: UBlockCode = UBlockCode(110i32);
8013 pub const UBLOCK_LIMBU: UBlockCode = UBlockCode(111i32);
8014 pub const UBLOCK_TAI_LE: UBlockCode = UBlockCode(112i32);
8015 pub const UBLOCK_KHMER_SYMBOLS: UBlockCode = UBlockCode(113i32);
8016 pub const UBLOCK_PHONETIC_EXTENSIONS: UBlockCode = UBlockCode(114i32);
8017 pub const UBLOCK_MISCELLANEOUS_SYMBOLS_AND_ARROWS: UBlockCode = UBlockCode(115i32);
8018 pub const UBLOCK_YIJING_HEXAGRAM_SYMBOLS: UBlockCode = UBlockCode(116i32);
8019 pub const UBLOCK_LINEAR_B_SYLLABARY: UBlockCode = UBlockCode(117i32);
8020 pub const UBLOCK_LINEAR_B_IDEOGRAMS: UBlockCode = UBlockCode(118i32);
8021 pub const UBLOCK_AEGEAN_NUMBERS: UBlockCode = UBlockCode(119i32);
8022 pub const UBLOCK_UGARITIC: UBlockCode = UBlockCode(120i32);
8023 pub const UBLOCK_SHAVIAN: UBlockCode = UBlockCode(121i32);
8024 pub const UBLOCK_OSMANYA: UBlockCode = UBlockCode(122i32);
8025 pub const UBLOCK_CYPRIOT_SYLLABARY: UBlockCode = UBlockCode(123i32);
8026 pub const UBLOCK_TAI_XUAN_JING_SYMBOLS: UBlockCode = UBlockCode(124i32);
8027 pub const UBLOCK_VARIATION_SELECTORS_SUPPLEMENT: UBlockCode = UBlockCode(125i32);
8028 pub const UBLOCK_ANCIENT_GREEK_MUSICAL_NOTATION: UBlockCode = UBlockCode(126i32);
8029 pub const UBLOCK_ANCIENT_GREEK_NUMBERS: UBlockCode = UBlockCode(127i32);
8030 pub const UBLOCK_ARABIC_SUPPLEMENT: UBlockCode = UBlockCode(128i32);
8031 pub const UBLOCK_BUGINESE: UBlockCode = UBlockCode(129i32);
8032 pub const UBLOCK_CJK_STROKES: UBlockCode = UBlockCode(130i32);
8033 pub const UBLOCK_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: UBlockCode = UBlockCode(131i32);
8034 pub const UBLOCK_COPTIC: UBlockCode = UBlockCode(132i32);
8035 pub const UBLOCK_ETHIOPIC_EXTENDED: UBlockCode = UBlockCode(133i32);
8036 pub const UBLOCK_ETHIOPIC_SUPPLEMENT: UBlockCode = UBlockCode(134i32);
8037 pub const UBLOCK_GEORGIAN_SUPPLEMENT: UBlockCode = UBlockCode(135i32);
8038 pub const UBLOCK_GLAGOLITIC: UBlockCode = UBlockCode(136i32);
8039 pub const UBLOCK_KHAROSHTHI: UBlockCode = UBlockCode(137i32);
8040 pub const UBLOCK_MODIFIER_TONE_LETTERS: UBlockCode = UBlockCode(138i32);
8041 pub const UBLOCK_NEW_TAI_LUE: UBlockCode = UBlockCode(139i32);
8042 pub const UBLOCK_OLD_PERSIAN: UBlockCode = UBlockCode(140i32);
8043 pub const UBLOCK_PHONETIC_EXTENSIONS_SUPPLEMENT: UBlockCode = UBlockCode(141i32);
8044 pub const UBLOCK_SUPPLEMENTAL_PUNCTUATION: UBlockCode = UBlockCode(142i32);
8045 pub const UBLOCK_SYLOTI_NAGRI: UBlockCode = UBlockCode(143i32);
8046 pub const UBLOCK_TIFINAGH: UBlockCode = UBlockCode(144i32);
8047 pub const UBLOCK_VERTICAL_FORMS: UBlockCode = UBlockCode(145i32);
8048 pub const UBLOCK_NKO: UBlockCode = UBlockCode(146i32);
8049 pub const UBLOCK_BALINESE: UBlockCode = UBlockCode(147i32);
8050 pub const UBLOCK_LATIN_EXTENDED_C: UBlockCode = UBlockCode(148i32);
8051 pub const UBLOCK_LATIN_EXTENDED_D: UBlockCode = UBlockCode(149i32);
8052 pub const UBLOCK_PHAGS_PA: UBlockCode = UBlockCode(150i32);
8053 pub const UBLOCK_PHOENICIAN: UBlockCode = UBlockCode(151i32);
8054 pub const UBLOCK_CUNEIFORM: UBlockCode = UBlockCode(152i32);
8055 pub const UBLOCK_CUNEIFORM_NUMBERS_AND_PUNCTUATION: UBlockCode = UBlockCode(153i32);
8056 pub const UBLOCK_COUNTING_ROD_NUMERALS: UBlockCode = UBlockCode(154i32);
8057 pub const UBLOCK_SUNDANESE: UBlockCode = UBlockCode(155i32);
8058 pub const UBLOCK_LEPCHA: UBlockCode = UBlockCode(156i32);
8059 pub const UBLOCK_OL_CHIKI: UBlockCode = UBlockCode(157i32);
8060 pub const UBLOCK_CYRILLIC_EXTENDED_A: UBlockCode = UBlockCode(158i32);
8061 pub const UBLOCK_VAI: UBlockCode = UBlockCode(159i32);
8062 pub const UBLOCK_CYRILLIC_EXTENDED_B: UBlockCode = UBlockCode(160i32);
8063 pub const UBLOCK_SAURASHTRA: UBlockCode = UBlockCode(161i32);
8064 pub const UBLOCK_KAYAH_LI: UBlockCode = UBlockCode(162i32);
8065 pub const UBLOCK_REJANG: UBlockCode = UBlockCode(163i32);
8066 pub const UBLOCK_CHAM: UBlockCode = UBlockCode(164i32);
8067 pub const UBLOCK_ANCIENT_SYMBOLS: UBlockCode = UBlockCode(165i32);
8068 pub const UBLOCK_PHAISTOS_DISC: UBlockCode = UBlockCode(166i32);
8069 pub const UBLOCK_LYCIAN: UBlockCode = UBlockCode(167i32);
8070 pub const UBLOCK_CARIAN: UBlockCode = UBlockCode(168i32);
8071 pub const UBLOCK_LYDIAN: UBlockCode = UBlockCode(169i32);
8072 pub const UBLOCK_MAHJONG_TILES: UBlockCode = UBlockCode(170i32);
8073 pub const UBLOCK_DOMINO_TILES: UBlockCode = UBlockCode(171i32);
8074 pub const UBLOCK_SAMARITAN: UBlockCode = UBlockCode(172i32);
8075 pub const UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: UBlockCode = UBlockCode(173i32);
8076 pub const UBLOCK_TAI_THAM: UBlockCode = UBlockCode(174i32);
8077 pub const UBLOCK_VEDIC_EXTENSIONS: UBlockCode = UBlockCode(175i32);
8078 pub const UBLOCK_LISU: UBlockCode = UBlockCode(176i32);
8079 pub const UBLOCK_BAMUM: UBlockCode = UBlockCode(177i32);
8080 pub const UBLOCK_COMMON_INDIC_NUMBER_FORMS: UBlockCode = UBlockCode(178i32);
8081 pub const UBLOCK_DEVANAGARI_EXTENDED: UBlockCode = UBlockCode(179i32);
8082 pub const UBLOCK_HANGUL_JAMO_EXTENDED_A: UBlockCode = UBlockCode(180i32);
8083 pub const UBLOCK_JAVANESE: UBlockCode = UBlockCode(181i32);
8084 pub const UBLOCK_MYANMAR_EXTENDED_A: UBlockCode = UBlockCode(182i32);
8085 pub const UBLOCK_TAI_VIET: UBlockCode = UBlockCode(183i32);
8086 pub const UBLOCK_MEETEI_MAYEK: UBlockCode = UBlockCode(184i32);
8087 pub const UBLOCK_HANGUL_JAMO_EXTENDED_B: UBlockCode = UBlockCode(185i32);
8088 pub const UBLOCK_IMPERIAL_ARAMAIC: UBlockCode = UBlockCode(186i32);
8089 pub const UBLOCK_OLD_SOUTH_ARABIAN: UBlockCode = UBlockCode(187i32);
8090 pub const UBLOCK_AVESTAN: UBlockCode = UBlockCode(188i32);
8091 pub const UBLOCK_INSCRIPTIONAL_PARTHIAN: UBlockCode = UBlockCode(189i32);
8092 pub const UBLOCK_INSCRIPTIONAL_PAHLAVI: UBlockCode = UBlockCode(190i32);
8093 pub const UBLOCK_OLD_TURKIC: UBlockCode = UBlockCode(191i32);
8094 pub const UBLOCK_RUMI_NUMERAL_SYMBOLS: UBlockCode = UBlockCode(192i32);
8095 pub const UBLOCK_KAITHI: UBlockCode = UBlockCode(193i32);
8096 pub const UBLOCK_EGYPTIAN_HIEROGLYPHS: UBlockCode = UBlockCode(194i32);
8097 pub const UBLOCK_ENCLOSED_ALPHANUMERIC_SUPPLEMENT: UBlockCode = UBlockCode(195i32);
8098 pub const UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: UBlockCode = UBlockCode(196i32);
8099 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: UBlockCode = UBlockCode(197i32);
8100 pub const UBLOCK_MANDAIC: UBlockCode = UBlockCode(198i32);
8101 pub const UBLOCK_BATAK: UBlockCode = UBlockCode(199i32);
8102 pub const UBLOCK_ETHIOPIC_EXTENDED_A: UBlockCode = UBlockCode(200i32);
8103 pub const UBLOCK_BRAHMI: UBlockCode = UBlockCode(201i32);
8104 pub const UBLOCK_BAMUM_SUPPLEMENT: UBlockCode = UBlockCode(202i32);
8105 pub const UBLOCK_KANA_SUPPLEMENT: UBlockCode = UBlockCode(203i32);
8106 pub const UBLOCK_PLAYING_CARDS: UBlockCode = UBlockCode(204i32);
8107 pub const UBLOCK_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: UBlockCode = UBlockCode(205i32);
8108 pub const UBLOCK_EMOTICONS: UBlockCode = UBlockCode(206i32);
8109 pub const UBLOCK_TRANSPORT_AND_MAP_SYMBOLS: UBlockCode = UBlockCode(207i32);
8110 pub const UBLOCK_ALCHEMICAL_SYMBOLS: UBlockCode = UBlockCode(208i32);
8111 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: UBlockCode = UBlockCode(209i32);
8112 pub const UBLOCK_ARABIC_EXTENDED_A: UBlockCode = UBlockCode(210i32);
8113 pub const UBLOCK_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: UBlockCode = UBlockCode(211i32);
8114 pub const UBLOCK_CHAKMA: UBlockCode = UBlockCode(212i32);
8115 pub const UBLOCK_MEETEI_MAYEK_EXTENSIONS: UBlockCode = UBlockCode(213i32);
8116 pub const UBLOCK_MEROITIC_CURSIVE: UBlockCode = UBlockCode(214i32);
8117 pub const UBLOCK_MEROITIC_HIEROGLYPHS: UBlockCode = UBlockCode(215i32);
8118 pub const UBLOCK_MIAO: UBlockCode = UBlockCode(216i32);
8119 pub const UBLOCK_SHARADA: UBlockCode = UBlockCode(217i32);
8120 pub const UBLOCK_SORA_SOMPENG: UBlockCode = UBlockCode(218i32);
8121 pub const UBLOCK_SUNDANESE_SUPPLEMENT: UBlockCode = UBlockCode(219i32);
8122 pub const UBLOCK_TAKRI: UBlockCode = UBlockCode(220i32);
8123 pub const UBLOCK_BASSA_VAH: UBlockCode = UBlockCode(221i32);
8124 pub const UBLOCK_CAUCASIAN_ALBANIAN: UBlockCode = UBlockCode(222i32);
8125 pub const UBLOCK_COPTIC_EPACT_NUMBERS: UBlockCode = UBlockCode(223i32);
8126 pub const UBLOCK_COMBINING_DIACRITICAL_MARKS_EXTENDED: UBlockCode = UBlockCode(224i32);
8127 pub const UBLOCK_DUPLOYAN: UBlockCode = UBlockCode(225i32);
8128 pub const UBLOCK_ELBASAN: UBlockCode = UBlockCode(226i32);
8129 pub const UBLOCK_GEOMETRIC_SHAPES_EXTENDED: UBlockCode = UBlockCode(227i32);
8130 pub const UBLOCK_GRANTHA: UBlockCode = UBlockCode(228i32);
8131 pub const UBLOCK_KHOJKI: UBlockCode = UBlockCode(229i32);
8132 pub const UBLOCK_KHUDAWADI: UBlockCode = UBlockCode(230i32);
8133 pub const UBLOCK_LATIN_EXTENDED_E: UBlockCode = UBlockCode(231i32);
8134 pub const UBLOCK_LINEAR_A: UBlockCode = UBlockCode(232i32);
8135 pub const UBLOCK_MAHAJANI: UBlockCode = UBlockCode(233i32);
8136 pub const UBLOCK_MANICHAEAN: UBlockCode = UBlockCode(234i32);
8137 pub const UBLOCK_MENDE_KIKAKUI: UBlockCode = UBlockCode(235i32);
8138 pub const UBLOCK_MODI: UBlockCode = UBlockCode(236i32);
8139 pub const UBLOCK_MRO: UBlockCode = UBlockCode(237i32);
8140 pub const UBLOCK_MYANMAR_EXTENDED_B: UBlockCode = UBlockCode(238i32);
8141 pub const UBLOCK_NABATAEAN: UBlockCode = UBlockCode(239i32);
8142 pub const UBLOCK_OLD_NORTH_ARABIAN: UBlockCode = UBlockCode(240i32);
8143 pub const UBLOCK_OLD_PERMIC: UBlockCode = UBlockCode(241i32);
8144 pub const UBLOCK_ORNAMENTAL_DINGBATS: UBlockCode = UBlockCode(242i32);
8145 pub const UBLOCK_PAHAWH_HMONG: UBlockCode = UBlockCode(243i32);
8146 pub const UBLOCK_PALMYRENE: UBlockCode = UBlockCode(244i32);
8147 pub const UBLOCK_PAU_CIN_HAU: UBlockCode = UBlockCode(245i32);
8148 pub const UBLOCK_PSALTER_PAHLAVI: UBlockCode = UBlockCode(246i32);
8149 pub const UBLOCK_SHORTHAND_FORMAT_CONTROLS: UBlockCode = UBlockCode(247i32);
8150 pub const UBLOCK_SIDDHAM: UBlockCode = UBlockCode(248i32);
8151 pub const UBLOCK_SINHALA_ARCHAIC_NUMBERS: UBlockCode = UBlockCode(249i32);
8152 pub const UBLOCK_SUPPLEMENTAL_ARROWS_C: UBlockCode = UBlockCode(250i32);
8153 pub const UBLOCK_TIRHUTA: UBlockCode = UBlockCode(251i32);
8154 pub const UBLOCK_WARANG_CITI: UBlockCode = UBlockCode(252i32);
8155 pub const UBLOCK_AHOM: UBlockCode = UBlockCode(253i32);
8156 pub const UBLOCK_ANATOLIAN_HIEROGLYPHS: UBlockCode = UBlockCode(254i32);
8157 pub const UBLOCK_CHEROKEE_SUPPLEMENT: UBlockCode = UBlockCode(255i32);
8158 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E: UBlockCode = UBlockCode(256i32);
8159 pub const UBLOCK_EARLY_DYNASTIC_CUNEIFORM: UBlockCode = UBlockCode(257i32);
8160 pub const UBLOCK_HATRAN: UBlockCode = UBlockCode(258i32);
8161 pub const UBLOCK_MULTANI: UBlockCode = UBlockCode(259i32);
8162 pub const UBLOCK_OLD_HUNGARIAN: UBlockCode = UBlockCode(260i32);
8163 pub const UBLOCK_SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS: UBlockCode = UBlockCode(261i32);
8164 pub const UBLOCK_SUTTON_SIGNWRITING: UBlockCode = UBlockCode(262i32);
8165 pub const UBLOCK_ADLAM: UBlockCode = UBlockCode(263i32);
8166 pub const UBLOCK_BHAIKSUKI: UBlockCode = UBlockCode(264i32);
8167 pub const UBLOCK_CYRILLIC_EXTENDED_C: UBlockCode = UBlockCode(265i32);
8168 pub const UBLOCK_GLAGOLITIC_SUPPLEMENT: UBlockCode = UBlockCode(266i32);
8169 pub const UBLOCK_IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION: UBlockCode = UBlockCode(267i32);
8170 pub const UBLOCK_MARCHEN: UBlockCode = UBlockCode(268i32);
8171 pub const UBLOCK_MONGOLIAN_SUPPLEMENT: UBlockCode = UBlockCode(269i32);
8172 pub const UBLOCK_NEWA: UBlockCode = UBlockCode(270i32);
8173 pub const UBLOCK_OSAGE: UBlockCode = UBlockCode(271i32);
8174 pub const UBLOCK_TANGUT: UBlockCode = UBlockCode(272i32);
8175 pub const UBLOCK_TANGUT_COMPONENTS: UBlockCode = UBlockCode(273i32);
8176 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F: UBlockCode = UBlockCode(274i32);
8177 pub const UBLOCK_KANA_EXTENDED_A: UBlockCode = UBlockCode(275i32);
8178 pub const UBLOCK_MASARAM_GONDI: UBlockCode = UBlockCode(276i32);
8179 pub const UBLOCK_NUSHU: UBlockCode = UBlockCode(277i32);
8180 pub const UBLOCK_SOYOMBO: UBlockCode = UBlockCode(278i32);
8181 pub const UBLOCK_SYRIAC_SUPPLEMENT: UBlockCode = UBlockCode(279i32);
8182 pub const UBLOCK_ZANABAZAR_SQUARE: UBlockCode = UBlockCode(280i32);
8183 pub const UBLOCK_CHESS_SYMBOLS: UBlockCode = UBlockCode(281i32);
8184 pub const UBLOCK_DOGRA: UBlockCode = UBlockCode(282i32);
8185 pub const UBLOCK_GEORGIAN_EXTENDED: UBlockCode = UBlockCode(283i32);
8186 pub const UBLOCK_GUNJALA_GONDI: UBlockCode = UBlockCode(284i32);
8187 pub const UBLOCK_HANIFI_ROHINGYA: UBlockCode = UBlockCode(285i32);
8188 pub const UBLOCK_INDIC_SIYAQ_NUMBERS: UBlockCode = UBlockCode(286i32);
8189 pub const UBLOCK_MAKASAR: UBlockCode = UBlockCode(287i32);
8190 pub const UBLOCK_MAYAN_NUMERALS: UBlockCode = UBlockCode(288i32);
8191 pub const UBLOCK_MEDEFAIDRIN: UBlockCode = UBlockCode(289i32);
8192 pub const UBLOCK_OLD_SOGDIAN: UBlockCode = UBlockCode(290i32);
8193 pub const UBLOCK_SOGDIAN: UBlockCode = UBlockCode(291i32);
8194 pub const UBLOCK_EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS: UBlockCode = UBlockCode(292i32);
8195 pub const UBLOCK_ELYMAIC: UBlockCode = UBlockCode(293i32);
8196 pub const UBLOCK_NANDINAGARI: UBlockCode = UBlockCode(294i32);
8197 pub const UBLOCK_NYIAKENG_PUACHUE_HMONG: UBlockCode = UBlockCode(295i32);
8198 pub const UBLOCK_OTTOMAN_SIYAQ_NUMBERS: UBlockCode = UBlockCode(296i32);
8199 pub const UBLOCK_SMALL_KANA_EXTENSION: UBlockCode = UBlockCode(297i32);
8200 pub const UBLOCK_SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A: UBlockCode = UBlockCode(298i32);
8201 pub const UBLOCK_TAMIL_SUPPLEMENT: UBlockCode = UBlockCode(299i32);
8202 pub const UBLOCK_WANCHO: UBlockCode = UBlockCode(300i32);
8203 pub const UBLOCK_CHORASMIAN: UBlockCode = UBlockCode(301i32);
8204 pub const UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_G: UBlockCode = UBlockCode(302i32);
8205 pub const UBLOCK_DIVES_AKURU: UBlockCode = UBlockCode(303i32);
8206 pub const UBLOCK_KHITAN_SMALL_SCRIPT: UBlockCode = UBlockCode(304i32);
8207 pub const UBLOCK_LISU_SUPPLEMENT: UBlockCode = UBlockCode(305i32);
8208 pub const UBLOCK_SYMBOLS_FOR_LEGACY_COMPUTING: UBlockCode = UBlockCode(306i32);
8209 pub const UBLOCK_TANGUT_SUPPLEMENT: UBlockCode = UBlockCode(307i32);
8210 pub const UBLOCK_YEZIDI: UBlockCode = UBlockCode(308i32);
8211 pub const UBLOCK_INVALID_CODE: UBlockCode = UBlockCode(-1i32);
8212 impl ::std::convert::From<i32> for UBlockCode {
from(value: i32) -> Self8213     fn from(value: i32) -> Self {
8214         Self(value)
8215     }
8216 }
8217 unsafe impl ::windows::runtime::Abi for UBlockCode {
8218     type Abi = Self;
8219     type DefaultType = Self;
8220 }
8221 #[repr(C)]
8222 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8223 pub struct UBreakIterator(pub u8);
8224 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8225 #[repr(transparent)]
8226 pub struct UBreakIteratorType(pub i32);
8227 pub const UBRK_CHARACTER: UBreakIteratorType = UBreakIteratorType(0i32);
8228 pub const UBRK_WORD: UBreakIteratorType = UBreakIteratorType(1i32);
8229 pub const UBRK_LINE: UBreakIteratorType = UBreakIteratorType(2i32);
8230 pub const UBRK_SENTENCE: UBreakIteratorType = UBreakIteratorType(3i32);
8231 impl ::std::convert::From<i32> for UBreakIteratorType {
from(value: i32) -> Self8232     fn from(value: i32) -> Self {
8233         Self(value)
8234     }
8235 }
8236 unsafe impl ::windows::runtime::Abi for UBreakIteratorType {
8237     type Abi = Self;
8238     type DefaultType = Self;
8239 }
8240 pub const UCHAR_MAX_VALUE: u32 = 1114111u32;
8241 pub const UCHAR_MIN_VALUE: u32 = 0u32;
8242 pub const UCLN_NO_AUTO_CLEANUP: u32 = 1u32;
8243 #[cfg(feature = "Win32_Foundation")]
8244 #[inline]
UCNV_FROM_U_CALLBACK_ESCAPE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8245 pub unsafe fn UCNV_FROM_U_CALLBACK_ESCAPE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8246     #[cfg(windows)]
8247     {
8248         #[link(name = "windows")]
8249         extern "system" {
8250             fn UCNV_FROM_U_CALLBACK_ESCAPE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8251         }
8252         ::std::mem::transmute(UCNV_FROM_U_CALLBACK_ESCAPE(::std::mem::transmute(context), ::std::mem::transmute(fromuargs), ::std::mem::transmute(codeunits), ::std::mem::transmute(length), ::std::mem::transmute(codepoint), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8253     }
8254     #[cfg(not(windows))]
8255     unimplemented!("Unsupported target OS");
8256 }
8257 #[cfg(feature = "Win32_Foundation")]
8258 #[inline]
UCNV_FROM_U_CALLBACK_SKIP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8259 pub unsafe fn UCNV_FROM_U_CALLBACK_SKIP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8260     #[cfg(windows)]
8261     {
8262         #[link(name = "windows")]
8263         extern "system" {
8264             fn UCNV_FROM_U_CALLBACK_SKIP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8265         }
8266         ::std::mem::transmute(UCNV_FROM_U_CALLBACK_SKIP(::std::mem::transmute(context), ::std::mem::transmute(fromuargs), ::std::mem::transmute(codeunits), ::std::mem::transmute(length), ::std::mem::transmute(codepoint), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8267     }
8268     #[cfg(not(windows))]
8269     unimplemented!("Unsupported target OS");
8270 }
8271 #[cfg(feature = "Win32_Foundation")]
8272 #[inline]
UCNV_FROM_U_CALLBACK_STOP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8273 pub unsafe fn UCNV_FROM_U_CALLBACK_STOP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8274     #[cfg(windows)]
8275     {
8276         #[link(name = "windows")]
8277         extern "system" {
8278             fn UCNV_FROM_U_CALLBACK_STOP(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8279         }
8280         ::std::mem::transmute(UCNV_FROM_U_CALLBACK_STOP(::std::mem::transmute(context), ::std::mem::transmute(fromuargs), ::std::mem::transmute(codeunits), ::std::mem::transmute(length), ::std::mem::transmute(codepoint), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8281     }
8282     #[cfg(not(windows))]
8283     unimplemented!("Unsupported target OS");
8284 }
8285 #[cfg(feature = "Win32_Foundation")]
8286 #[inline]
UCNV_FROM_U_CALLBACK_SUBSTITUTE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8287 pub unsafe fn UCNV_FROM_U_CALLBACK_SUBSTITUTE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8288     #[cfg(windows)]
8289     {
8290         #[link(name = "windows")]
8291         extern "system" {
8292             fn UCNV_FROM_U_CALLBACK_SUBSTITUTE(context: *const ::std::ffi::c_void, fromuargs: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8293         }
8294         ::std::mem::transmute(UCNV_FROM_U_CALLBACK_SUBSTITUTE(::std::mem::transmute(context), ::std::mem::transmute(fromuargs), ::std::mem::transmute(codeunits), ::std::mem::transmute(length), ::std::mem::transmute(codepoint), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8295     }
8296     #[cfg(not(windows))]
8297     unimplemented!("Unsupported target OS");
8298 }
8299 pub const UCNV_MAX_CONVERTER_NAME_LENGTH: u32 = 60u32;
8300 pub const UCNV_SI: u32 = 15u32;
8301 pub const UCNV_SO: u32 = 14u32;
8302 #[cfg(feature = "Win32_Foundation")]
8303 #[inline]
UCNV_TO_U_CALLBACK_ESCAPE<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8304 pub unsafe fn UCNV_TO_U_CALLBACK_ESCAPE<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8305     #[cfg(windows)]
8306     {
8307         #[link(name = "windows")]
8308         extern "system" {
8309             fn UCNV_TO_U_CALLBACK_ESCAPE(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: super::Foundation::PSTR, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8310         }
8311         ::std::mem::transmute(UCNV_TO_U_CALLBACK_ESCAPE(::std::mem::transmute(context), ::std::mem::transmute(touargs), codeunits.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8312     }
8313     #[cfg(not(windows))]
8314     unimplemented!("Unsupported target OS");
8315 }
8316 #[cfg(feature = "Win32_Foundation")]
8317 #[inline]
UCNV_TO_U_CALLBACK_SKIP<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8318 pub unsafe fn UCNV_TO_U_CALLBACK_SKIP<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8319     #[cfg(windows)]
8320     {
8321         #[link(name = "windows")]
8322         extern "system" {
8323             fn UCNV_TO_U_CALLBACK_SKIP(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: super::Foundation::PSTR, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8324         }
8325         ::std::mem::transmute(UCNV_TO_U_CALLBACK_SKIP(::std::mem::transmute(context), ::std::mem::transmute(touargs), codeunits.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8326     }
8327     #[cfg(not(windows))]
8328     unimplemented!("Unsupported target OS");
8329 }
8330 #[cfg(feature = "Win32_Foundation")]
8331 #[inline]
UCNV_TO_U_CALLBACK_STOP<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8332 pub unsafe fn UCNV_TO_U_CALLBACK_STOP<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8333     #[cfg(windows)]
8334     {
8335         #[link(name = "windows")]
8336         extern "system" {
8337             fn UCNV_TO_U_CALLBACK_STOP(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: super::Foundation::PSTR, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8338         }
8339         ::std::mem::transmute(UCNV_TO_U_CALLBACK_STOP(::std::mem::transmute(context), ::std::mem::transmute(touargs), codeunits.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8340     }
8341     #[cfg(not(windows))]
8342     unimplemented!("Unsupported target OS");
8343 }
8344 #[cfg(feature = "Win32_Foundation")]
8345 #[inline]
UCNV_TO_U_CALLBACK_SUBSTITUTE<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode)8346 pub unsafe fn UCNV_TO_U_CALLBACK_SUBSTITUTE<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: Param2, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode) {
8347     #[cfg(windows)]
8348     {
8349         #[link(name = "windows")]
8350         extern "system" {
8351             fn UCNV_TO_U_CALLBACK_SUBSTITUTE(context: *const ::std::ffi::c_void, touargs: *mut UConverterToUnicodeArgs, codeunits: super::Foundation::PSTR, length: i32, reason: UConverterCallbackReason, err: *mut UErrorCode);
8352         }
8353         ::std::mem::transmute(UCNV_TO_U_CALLBACK_SUBSTITUTE(::std::mem::transmute(context), ::std::mem::transmute(touargs), codeunits.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(reason), ::std::mem::transmute(err)))
8354     }
8355     #[cfg(not(windows))]
8356     unimplemented!("Unsupported target OS");
8357 }
8358 pub const UCONFIG_ENABLE_PLUGINS: u32 = 0u32;
8359 #[repr(C)]
8360 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8361 pub struct UCPMap(pub u8);
8362 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8363 #[repr(transparent)]
8364 pub struct UCPMapRangeOption(pub i32);
8365 pub const UCPMAP_RANGE_NORMAL: UCPMapRangeOption = UCPMapRangeOption(0i32);
8366 pub const UCPMAP_RANGE_FIXED_LEAD_SURROGATES: UCPMapRangeOption = UCPMapRangeOption(1i32);
8367 pub const UCPMAP_RANGE_FIXED_ALL_SURROGATES: UCPMapRangeOption = UCPMapRangeOption(2i32);
8368 impl ::std::convert::From<i32> for UCPMapRangeOption {
from(value: i32) -> Self8369     fn from(value: i32) -> Self {
8370         Self(value)
8371     }
8372 }
8373 unsafe impl ::windows::runtime::Abi for UCPMapRangeOption {
8374     type Abi = Self;
8375     type DefaultType = Self;
8376 }
8377 pub type UCPMapValueFilter = unsafe extern "system" fn(context: *const ::std::ffi::c_void, value: u32) -> u32;
8378 pub const UCPTRIE_ERROR_VALUE_NEG_DATA_OFFSET: i32 = 1i32;
8379 pub const UCPTRIE_FAST_DATA_BLOCK_LENGTH: i32 = 64i32;
8380 pub const UCPTRIE_FAST_DATA_MASK: i32 = 63i32;
8381 pub const UCPTRIE_FAST_SHIFT: i32 = 6i32;
8382 pub const UCPTRIE_HIGH_VALUE_NEG_DATA_OFFSET: i32 = 2i32;
8383 pub const UCPTRIE_SMALL_MAX: i32 = 4095i32;
8384 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8385 #[repr(C)]
8386 pub struct UCPTrie {
8387     pub index: *mut u16,
8388     pub data: UCPTrieData,
8389     pub indexLength: i32,
8390     pub dataLength: i32,
8391     pub highStart: i32,
8392     pub shifted12HighStart: u16,
8393     pub r#type: i8,
8394     pub valueWidth: i8,
8395     pub reserved32: u32,
8396     pub reserved16: u16,
8397     pub index3NullOffset: u16,
8398     pub dataNullOffset: i32,
8399     pub nullValue: u32,
8400 }
8401 impl UCPTrie {}
8402 impl ::std::default::Default for UCPTrie {
default() -> Self8403     fn default() -> Self {
8404         unsafe { ::std::mem::zeroed() }
8405     }
8406 }
8407 impl ::std::cmp::PartialEq for UCPTrie {
eq(&self, _other: &Self) -> bool8408     fn eq(&self, _other: &Self) -> bool {
8409         unimplemented!()
8410     }
8411 }
8412 impl ::std::cmp::Eq for UCPTrie {}
8413 unsafe impl ::windows::runtime::Abi for UCPTrie {
8414     type Abi = Self;
8415     type DefaultType = Self;
8416 }
8417 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8418 #[repr(C)]
8419 pub union UCPTrieData {
8420     pub ptr0: *mut ::std::ffi::c_void,
8421     pub ptr16: *mut u16,
8422     pub ptr32: *mut u32,
8423     pub ptr8: *mut u8,
8424 }
8425 impl UCPTrieData {}
8426 impl ::std::default::Default for UCPTrieData {
default() -> Self8427     fn default() -> Self {
8428         unsafe { ::std::mem::zeroed() }
8429     }
8430 }
8431 impl ::std::cmp::PartialEq for UCPTrieData {
eq(&self, _other: &Self) -> bool8432     fn eq(&self, _other: &Self) -> bool {
8433         unimplemented!()
8434     }
8435 }
8436 impl ::std::cmp::Eq for UCPTrieData {}
8437 unsafe impl ::windows::runtime::Abi for UCPTrieData {
8438     type Abi = Self;
8439     type DefaultType = Self;
8440 }
8441 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8442 #[repr(transparent)]
8443 pub struct UCPTrieType(pub i32);
8444 pub const UCPTRIE_TYPE_ANY: UCPTrieType = UCPTrieType(-1i32);
8445 pub const UCPTRIE_TYPE_FAST: UCPTrieType = UCPTrieType(0i32);
8446 pub const UCPTRIE_TYPE_SMALL: UCPTrieType = UCPTrieType(1i32);
8447 impl ::std::convert::From<i32> for UCPTrieType {
from(value: i32) -> Self8448     fn from(value: i32) -> Self {
8449         Self(value)
8450     }
8451 }
8452 unsafe impl ::windows::runtime::Abi for UCPTrieType {
8453     type Abi = Self;
8454     type DefaultType = Self;
8455 }
8456 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8457 #[repr(transparent)]
8458 pub struct UCPTrieValueWidth(pub i32);
8459 pub const UCPTRIE_VALUE_BITS_ANY: UCPTrieValueWidth = UCPTrieValueWidth(-1i32);
8460 pub const UCPTRIE_VALUE_BITS_16: UCPTrieValueWidth = UCPTrieValueWidth(0i32);
8461 pub const UCPTRIE_VALUE_BITS_32: UCPTrieValueWidth = UCPTrieValueWidth(1i32);
8462 pub const UCPTRIE_VALUE_BITS_8: UCPTrieValueWidth = UCPTrieValueWidth(2i32);
8463 impl ::std::convert::From<i32> for UCPTrieValueWidth {
from(value: i32) -> Self8464     fn from(value: i32) -> Self {
8465         Self(value)
8466     }
8467 }
8468 unsafe impl ::windows::runtime::Abi for UCPTrieValueWidth {
8469     type Abi = Self;
8470     type DefaultType = Self;
8471 }
8472 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8473 #[repr(transparent)]
8474 pub struct UCalendarAMPMs(pub i32);
8475 pub const UCAL_AM: UCalendarAMPMs = UCalendarAMPMs(0i32);
8476 pub const UCAL_PM: UCalendarAMPMs = UCalendarAMPMs(1i32);
8477 impl ::std::convert::From<i32> for UCalendarAMPMs {
from(value: i32) -> Self8478     fn from(value: i32) -> Self {
8479         Self(value)
8480     }
8481 }
8482 unsafe impl ::windows::runtime::Abi for UCalendarAMPMs {
8483     type Abi = Self;
8484     type DefaultType = Self;
8485 }
8486 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8487 #[repr(transparent)]
8488 pub struct UCalendarAttribute(pub i32);
8489 pub const UCAL_LENIENT: UCalendarAttribute = UCalendarAttribute(0i32);
8490 pub const UCAL_FIRST_DAY_OF_WEEK: UCalendarAttribute = UCalendarAttribute(1i32);
8491 pub const UCAL_MINIMAL_DAYS_IN_FIRST_WEEK: UCalendarAttribute = UCalendarAttribute(2i32);
8492 pub const UCAL_REPEATED_WALL_TIME: UCalendarAttribute = UCalendarAttribute(3i32);
8493 pub const UCAL_SKIPPED_WALL_TIME: UCalendarAttribute = UCalendarAttribute(4i32);
8494 impl ::std::convert::From<i32> for UCalendarAttribute {
from(value: i32) -> Self8495     fn from(value: i32) -> Self {
8496         Self(value)
8497     }
8498 }
8499 unsafe impl ::windows::runtime::Abi for UCalendarAttribute {
8500     type Abi = Self;
8501     type DefaultType = Self;
8502 }
8503 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8504 #[repr(transparent)]
8505 pub struct UCalendarDateFields(pub i32);
8506 pub const UCAL_ERA: UCalendarDateFields = UCalendarDateFields(0i32);
8507 pub const UCAL_YEAR: UCalendarDateFields = UCalendarDateFields(1i32);
8508 pub const UCAL_MONTH: UCalendarDateFields = UCalendarDateFields(2i32);
8509 pub const UCAL_WEEK_OF_YEAR: UCalendarDateFields = UCalendarDateFields(3i32);
8510 pub const UCAL_WEEK_OF_MONTH: UCalendarDateFields = UCalendarDateFields(4i32);
8511 pub const UCAL_DATE: UCalendarDateFields = UCalendarDateFields(5i32);
8512 pub const UCAL_DAY_OF_YEAR: UCalendarDateFields = UCalendarDateFields(6i32);
8513 pub const UCAL_DAY_OF_WEEK: UCalendarDateFields = UCalendarDateFields(7i32);
8514 pub const UCAL_DAY_OF_WEEK_IN_MONTH: UCalendarDateFields = UCalendarDateFields(8i32);
8515 pub const UCAL_AM_PM: UCalendarDateFields = UCalendarDateFields(9i32);
8516 pub const UCAL_HOUR: UCalendarDateFields = UCalendarDateFields(10i32);
8517 pub const UCAL_HOUR_OF_DAY: UCalendarDateFields = UCalendarDateFields(11i32);
8518 pub const UCAL_MINUTE: UCalendarDateFields = UCalendarDateFields(12i32);
8519 pub const UCAL_SECOND: UCalendarDateFields = UCalendarDateFields(13i32);
8520 pub const UCAL_MILLISECOND: UCalendarDateFields = UCalendarDateFields(14i32);
8521 pub const UCAL_ZONE_OFFSET: UCalendarDateFields = UCalendarDateFields(15i32);
8522 pub const UCAL_DST_OFFSET: UCalendarDateFields = UCalendarDateFields(16i32);
8523 pub const UCAL_YEAR_WOY: UCalendarDateFields = UCalendarDateFields(17i32);
8524 pub const UCAL_DOW_LOCAL: UCalendarDateFields = UCalendarDateFields(18i32);
8525 pub const UCAL_EXTENDED_YEAR: UCalendarDateFields = UCalendarDateFields(19i32);
8526 pub const UCAL_JULIAN_DAY: UCalendarDateFields = UCalendarDateFields(20i32);
8527 pub const UCAL_MILLISECONDS_IN_DAY: UCalendarDateFields = UCalendarDateFields(21i32);
8528 pub const UCAL_IS_LEAP_MONTH: UCalendarDateFields = UCalendarDateFields(22i32);
8529 pub const UCAL_FIELD_COUNT: UCalendarDateFields = UCalendarDateFields(23i32);
8530 pub const UCAL_DAY_OF_MONTH: UCalendarDateFields = UCalendarDateFields(5i32);
8531 impl ::std::convert::From<i32> for UCalendarDateFields {
from(value: i32) -> Self8532     fn from(value: i32) -> Self {
8533         Self(value)
8534     }
8535 }
8536 unsafe impl ::windows::runtime::Abi for UCalendarDateFields {
8537     type Abi = Self;
8538     type DefaultType = Self;
8539 }
8540 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8541 #[repr(transparent)]
8542 pub struct UCalendarDaysOfWeek(pub i32);
8543 pub const UCAL_SUNDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(1i32);
8544 pub const UCAL_MONDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(2i32);
8545 pub const UCAL_TUESDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(3i32);
8546 pub const UCAL_WEDNESDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(4i32);
8547 pub const UCAL_THURSDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(5i32);
8548 pub const UCAL_FRIDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(6i32);
8549 pub const UCAL_SATURDAY: UCalendarDaysOfWeek = UCalendarDaysOfWeek(7i32);
8550 impl ::std::convert::From<i32> for UCalendarDaysOfWeek {
from(value: i32) -> Self8551     fn from(value: i32) -> Self {
8552         Self(value)
8553     }
8554 }
8555 unsafe impl ::windows::runtime::Abi for UCalendarDaysOfWeek {
8556     type Abi = Self;
8557     type DefaultType = Self;
8558 }
8559 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8560 #[repr(transparent)]
8561 pub struct UCalendarDisplayNameType(pub i32);
8562 pub const UCAL_STANDARD: UCalendarDisplayNameType = UCalendarDisplayNameType(0i32);
8563 pub const UCAL_SHORT_STANDARD: UCalendarDisplayNameType = UCalendarDisplayNameType(1i32);
8564 pub const UCAL_DST: UCalendarDisplayNameType = UCalendarDisplayNameType(2i32);
8565 pub const UCAL_SHORT_DST: UCalendarDisplayNameType = UCalendarDisplayNameType(3i32);
8566 impl ::std::convert::From<i32> for UCalendarDisplayNameType {
from(value: i32) -> Self8567     fn from(value: i32) -> Self {
8568         Self(value)
8569     }
8570 }
8571 unsafe impl ::windows::runtime::Abi for UCalendarDisplayNameType {
8572     type Abi = Self;
8573     type DefaultType = Self;
8574 }
8575 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8576 #[repr(transparent)]
8577 pub struct UCalendarLimitType(pub i32);
8578 pub const UCAL_MINIMUM: UCalendarLimitType = UCalendarLimitType(0i32);
8579 pub const UCAL_MAXIMUM: UCalendarLimitType = UCalendarLimitType(1i32);
8580 pub const UCAL_GREATEST_MINIMUM: UCalendarLimitType = UCalendarLimitType(2i32);
8581 pub const UCAL_LEAST_MAXIMUM: UCalendarLimitType = UCalendarLimitType(3i32);
8582 pub const UCAL_ACTUAL_MINIMUM: UCalendarLimitType = UCalendarLimitType(4i32);
8583 pub const UCAL_ACTUAL_MAXIMUM: UCalendarLimitType = UCalendarLimitType(5i32);
8584 impl ::std::convert::From<i32> for UCalendarLimitType {
from(value: i32) -> Self8585     fn from(value: i32) -> Self {
8586         Self(value)
8587     }
8588 }
8589 unsafe impl ::windows::runtime::Abi for UCalendarLimitType {
8590     type Abi = Self;
8591     type DefaultType = Self;
8592 }
8593 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8594 #[repr(transparent)]
8595 pub struct UCalendarMonths(pub i32);
8596 pub const UCAL_JANUARY: UCalendarMonths = UCalendarMonths(0i32);
8597 pub const UCAL_FEBRUARY: UCalendarMonths = UCalendarMonths(1i32);
8598 pub const UCAL_MARCH: UCalendarMonths = UCalendarMonths(2i32);
8599 pub const UCAL_APRIL: UCalendarMonths = UCalendarMonths(3i32);
8600 pub const UCAL_MAY: UCalendarMonths = UCalendarMonths(4i32);
8601 pub const UCAL_JUNE: UCalendarMonths = UCalendarMonths(5i32);
8602 pub const UCAL_JULY: UCalendarMonths = UCalendarMonths(6i32);
8603 pub const UCAL_AUGUST: UCalendarMonths = UCalendarMonths(7i32);
8604 pub const UCAL_SEPTEMBER: UCalendarMonths = UCalendarMonths(8i32);
8605 pub const UCAL_OCTOBER: UCalendarMonths = UCalendarMonths(9i32);
8606 pub const UCAL_NOVEMBER: UCalendarMonths = UCalendarMonths(10i32);
8607 pub const UCAL_DECEMBER: UCalendarMonths = UCalendarMonths(11i32);
8608 pub const UCAL_UNDECIMBER: UCalendarMonths = UCalendarMonths(12i32);
8609 impl ::std::convert::From<i32> for UCalendarMonths {
from(value: i32) -> Self8610     fn from(value: i32) -> Self {
8611         Self(value)
8612     }
8613 }
8614 unsafe impl ::windows::runtime::Abi for UCalendarMonths {
8615     type Abi = Self;
8616     type DefaultType = Self;
8617 }
8618 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8619 #[repr(transparent)]
8620 pub struct UCalendarType(pub i32);
8621 pub const UCAL_TRADITIONAL: UCalendarType = UCalendarType(0i32);
8622 pub const UCAL_DEFAULT: UCalendarType = UCalendarType(0i32);
8623 pub const UCAL_GREGORIAN: UCalendarType = UCalendarType(1i32);
8624 impl ::std::convert::From<i32> for UCalendarType {
from(value: i32) -> Self8625     fn from(value: i32) -> Self {
8626         Self(value)
8627     }
8628 }
8629 unsafe impl ::windows::runtime::Abi for UCalendarType {
8630     type Abi = Self;
8631     type DefaultType = Self;
8632 }
8633 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8634 #[repr(transparent)]
8635 pub struct UCalendarWallTimeOption(pub i32);
8636 pub const UCAL_WALLTIME_LAST: UCalendarWallTimeOption = UCalendarWallTimeOption(0i32);
8637 pub const UCAL_WALLTIME_FIRST: UCalendarWallTimeOption = UCalendarWallTimeOption(1i32);
8638 pub const UCAL_WALLTIME_NEXT_VALID: UCalendarWallTimeOption = UCalendarWallTimeOption(2i32);
8639 impl ::std::convert::From<i32> for UCalendarWallTimeOption {
from(value: i32) -> Self8640     fn from(value: i32) -> Self {
8641         Self(value)
8642     }
8643 }
8644 unsafe impl ::windows::runtime::Abi for UCalendarWallTimeOption {
8645     type Abi = Self;
8646     type DefaultType = Self;
8647 }
8648 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8649 #[repr(transparent)]
8650 pub struct UCalendarWeekdayType(pub i32);
8651 pub const UCAL_WEEKDAY: UCalendarWeekdayType = UCalendarWeekdayType(0i32);
8652 pub const UCAL_WEEKEND: UCalendarWeekdayType = UCalendarWeekdayType(1i32);
8653 pub const UCAL_WEEKEND_ONSET: UCalendarWeekdayType = UCalendarWeekdayType(2i32);
8654 pub const UCAL_WEEKEND_CEASE: UCalendarWeekdayType = UCalendarWeekdayType(3i32);
8655 impl ::std::convert::From<i32> for UCalendarWeekdayType {
from(value: i32) -> Self8656     fn from(value: i32) -> Self {
8657         Self(value)
8658     }
8659 }
8660 unsafe impl ::windows::runtime::Abi for UCalendarWeekdayType {
8661     type Abi = Self;
8662     type DefaultType = Self;
8663 }
8664 #[repr(C)]
8665 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8666 pub struct UCaseMap(pub u8);
8667 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8668 #[repr(transparent)]
8669 pub struct UCharCategory(pub i32);
8670 pub const U_UNASSIGNED: UCharCategory = UCharCategory(0i32);
8671 pub const U_GENERAL_OTHER_TYPES: UCharCategory = UCharCategory(0i32);
8672 pub const U_UPPERCASE_LETTER: UCharCategory = UCharCategory(1i32);
8673 pub const U_LOWERCASE_LETTER: UCharCategory = UCharCategory(2i32);
8674 pub const U_TITLECASE_LETTER: UCharCategory = UCharCategory(3i32);
8675 pub const U_MODIFIER_LETTER: UCharCategory = UCharCategory(4i32);
8676 pub const U_OTHER_LETTER: UCharCategory = UCharCategory(5i32);
8677 pub const U_NON_SPACING_MARK: UCharCategory = UCharCategory(6i32);
8678 pub const U_ENCLOSING_MARK: UCharCategory = UCharCategory(7i32);
8679 pub const U_COMBINING_SPACING_MARK: UCharCategory = UCharCategory(8i32);
8680 pub const U_DECIMAL_DIGIT_NUMBER: UCharCategory = UCharCategory(9i32);
8681 pub const U_LETTER_NUMBER: UCharCategory = UCharCategory(10i32);
8682 pub const U_OTHER_NUMBER: UCharCategory = UCharCategory(11i32);
8683 pub const U_SPACE_SEPARATOR: UCharCategory = UCharCategory(12i32);
8684 pub const U_LINE_SEPARATOR: UCharCategory = UCharCategory(13i32);
8685 pub const U_PARAGRAPH_SEPARATOR: UCharCategory = UCharCategory(14i32);
8686 pub const U_CONTROL_CHAR: UCharCategory = UCharCategory(15i32);
8687 pub const U_FORMAT_CHAR: UCharCategory = UCharCategory(16i32);
8688 pub const U_PRIVATE_USE_CHAR: UCharCategory = UCharCategory(17i32);
8689 pub const U_SURROGATE: UCharCategory = UCharCategory(18i32);
8690 pub const U_DASH_PUNCTUATION: UCharCategory = UCharCategory(19i32);
8691 pub const U_START_PUNCTUATION: UCharCategory = UCharCategory(20i32);
8692 pub const U_END_PUNCTUATION: UCharCategory = UCharCategory(21i32);
8693 pub const U_CONNECTOR_PUNCTUATION: UCharCategory = UCharCategory(22i32);
8694 pub const U_OTHER_PUNCTUATION: UCharCategory = UCharCategory(23i32);
8695 pub const U_MATH_SYMBOL: UCharCategory = UCharCategory(24i32);
8696 pub const U_CURRENCY_SYMBOL: UCharCategory = UCharCategory(25i32);
8697 pub const U_MODIFIER_SYMBOL: UCharCategory = UCharCategory(26i32);
8698 pub const U_OTHER_SYMBOL: UCharCategory = UCharCategory(27i32);
8699 pub const U_INITIAL_PUNCTUATION: UCharCategory = UCharCategory(28i32);
8700 pub const U_FINAL_PUNCTUATION: UCharCategory = UCharCategory(29i32);
8701 pub const U_CHAR_CATEGORY_COUNT: UCharCategory = UCharCategory(30i32);
8702 impl ::std::convert::From<i32> for UCharCategory {
from(value: i32) -> Self8703     fn from(value: i32) -> Self {
8704         Self(value)
8705     }
8706 }
8707 unsafe impl ::windows::runtime::Abi for UCharCategory {
8708     type Abi = Self;
8709     type DefaultType = Self;
8710 }
8711 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8712 #[repr(transparent)]
8713 pub struct UCharDirection(pub i32);
8714 pub const U_LEFT_TO_RIGHT: UCharDirection = UCharDirection(0i32);
8715 pub const U_RIGHT_TO_LEFT: UCharDirection = UCharDirection(1i32);
8716 pub const U_EUROPEAN_NUMBER: UCharDirection = UCharDirection(2i32);
8717 pub const U_EUROPEAN_NUMBER_SEPARATOR: UCharDirection = UCharDirection(3i32);
8718 pub const U_EUROPEAN_NUMBER_TERMINATOR: UCharDirection = UCharDirection(4i32);
8719 pub const U_ARABIC_NUMBER: UCharDirection = UCharDirection(5i32);
8720 pub const U_COMMON_NUMBER_SEPARATOR: UCharDirection = UCharDirection(6i32);
8721 pub const U_BLOCK_SEPARATOR: UCharDirection = UCharDirection(7i32);
8722 pub const U_SEGMENT_SEPARATOR: UCharDirection = UCharDirection(8i32);
8723 pub const U_WHITE_SPACE_NEUTRAL: UCharDirection = UCharDirection(9i32);
8724 pub const U_OTHER_NEUTRAL: UCharDirection = UCharDirection(10i32);
8725 pub const U_LEFT_TO_RIGHT_EMBEDDING: UCharDirection = UCharDirection(11i32);
8726 pub const U_LEFT_TO_RIGHT_OVERRIDE: UCharDirection = UCharDirection(12i32);
8727 pub const U_RIGHT_TO_LEFT_ARABIC: UCharDirection = UCharDirection(13i32);
8728 pub const U_RIGHT_TO_LEFT_EMBEDDING: UCharDirection = UCharDirection(14i32);
8729 pub const U_RIGHT_TO_LEFT_OVERRIDE: UCharDirection = UCharDirection(15i32);
8730 pub const U_POP_DIRECTIONAL_FORMAT: UCharDirection = UCharDirection(16i32);
8731 pub const U_DIR_NON_SPACING_MARK: UCharDirection = UCharDirection(17i32);
8732 pub const U_BOUNDARY_NEUTRAL: UCharDirection = UCharDirection(18i32);
8733 pub const U_FIRST_STRONG_ISOLATE: UCharDirection = UCharDirection(19i32);
8734 pub const U_LEFT_TO_RIGHT_ISOLATE: UCharDirection = UCharDirection(20i32);
8735 pub const U_RIGHT_TO_LEFT_ISOLATE: UCharDirection = UCharDirection(21i32);
8736 pub const U_POP_DIRECTIONAL_ISOLATE: UCharDirection = UCharDirection(22i32);
8737 impl ::std::convert::From<i32> for UCharDirection {
from(value: i32) -> Self8738     fn from(value: i32) -> Self {
8739         Self(value)
8740     }
8741 }
8742 unsafe impl ::windows::runtime::Abi for UCharDirection {
8743     type Abi = Self;
8744     type DefaultType = Self;
8745 }
8746 pub type UCharEnumTypeRange = unsafe extern "system" fn(context: *const ::std::ffi::c_void, start: i32, limit: i32, r#type: UCharCategory) -> i8;
8747 #[derive(:: std :: clone :: Clone)]
8748 #[repr(C)]
8749 pub struct UCharIterator {
8750     pub context: *mut ::std::ffi::c_void,
8751     pub length: i32,
8752     pub start: i32,
8753     pub index: i32,
8754     pub limit: i32,
8755     pub reservedField: i32,
8756     pub getIndex: ::std::option::Option<UCharIteratorGetIndex>,
8757     pub r#move: ::std::option::Option<UCharIteratorMove>,
8758     pub hasNext: ::std::option::Option<UCharIteratorHasNext>,
8759     pub hasPrevious: ::std::option::Option<UCharIteratorHasPrevious>,
8760     pub current: ::std::option::Option<UCharIteratorCurrent>,
8761     pub next: ::std::option::Option<UCharIteratorNext>,
8762     pub previous: ::std::option::Option<UCharIteratorPrevious>,
8763     pub reservedFn: ::std::option::Option<UCharIteratorReserved>,
8764     pub getState: ::std::option::Option<UCharIteratorGetState>,
8765     pub setState: ::std::option::Option<UCharIteratorSetState>,
8766 }
8767 impl UCharIterator {}
8768 impl ::std::default::Default for UCharIterator {
default() -> Self8769     fn default() -> Self {
8770         unsafe { ::std::mem::zeroed() }
8771     }
8772 }
8773 impl ::std::fmt::Debug for UCharIterator {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result8774     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8775         fmt.debug_struct("UCharIterator").field("context", &self.context).field("length", &self.length).field("start", &self.start).field("index", &self.index).field("limit", &self.limit).field("reservedField", &self.reservedField).finish()
8776     }
8777 }
8778 impl ::std::cmp::PartialEq for UCharIterator {
eq(&self, other: &Self) -> bool8779     fn eq(&self, other: &Self) -> bool {
8780         self.context == other.context
8781             && self.length == other.length
8782             && self.start == other.start
8783             && self.index == other.index
8784             && self.limit == other.limit
8785             && self.reservedField == other.reservedField
8786             && self.getIndex.map(|f| f as usize) == other.getIndex.map(|f| f as usize)
8787             && self.r#move.map(|f| f as usize) == other.r#move.map(|f| f as usize)
8788             && self.hasNext.map(|f| f as usize) == other.hasNext.map(|f| f as usize)
8789             && self.hasPrevious.map(|f| f as usize) == other.hasPrevious.map(|f| f as usize)
8790             && self.current.map(|f| f as usize) == other.current.map(|f| f as usize)
8791             && self.next.map(|f| f as usize) == other.next.map(|f| f as usize)
8792             && self.previous.map(|f| f as usize) == other.previous.map(|f| f as usize)
8793             && self.reservedFn.map(|f| f as usize) == other.reservedFn.map(|f| f as usize)
8794             && self.getState.map(|f| f as usize) == other.getState.map(|f| f as usize)
8795             && self.setState.map(|f| f as usize) == other.setState.map(|f| f as usize)
8796     }
8797 }
8798 impl ::std::cmp::Eq for UCharIterator {}
8799 unsafe impl ::windows::runtime::Abi for UCharIterator {
8800     type Abi = ::std::mem::ManuallyDrop<Self>;
8801     type DefaultType = Self;
8802 }
8803 pub type UCharIteratorCurrent = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
8804 pub type UCharIteratorGetIndex = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, origin: UCharIteratorOrigin) -> i32;
8805 pub type UCharIteratorGetState = unsafe extern "system" fn(iter: *const ::std::mem::ManuallyDrop<UCharIterator>) -> u32;
8806 pub type UCharIteratorHasNext = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i8;
8807 pub type UCharIteratorHasPrevious = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i8;
8808 pub type UCharIteratorMove = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, delta: i32, origin: UCharIteratorOrigin) -> i32;
8809 pub type UCharIteratorNext = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
8810 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8811 #[repr(transparent)]
8812 pub struct UCharIteratorOrigin(pub i32);
8813 pub const UITER_START: UCharIteratorOrigin = UCharIteratorOrigin(0i32);
8814 pub const UITER_CURRENT: UCharIteratorOrigin = UCharIteratorOrigin(1i32);
8815 pub const UITER_LIMIT: UCharIteratorOrigin = UCharIteratorOrigin(2i32);
8816 pub const UITER_ZERO: UCharIteratorOrigin = UCharIteratorOrigin(3i32);
8817 pub const UITER_LENGTH: UCharIteratorOrigin = UCharIteratorOrigin(4i32);
8818 impl ::std::convert::From<i32> for UCharIteratorOrigin {
from(value: i32) -> Self8819     fn from(value: i32) -> Self {
8820         Self(value)
8821     }
8822 }
8823 unsafe impl ::windows::runtime::Abi for UCharIteratorOrigin {
8824     type Abi = Self;
8825     type DefaultType = Self;
8826 }
8827 pub type UCharIteratorPrevious = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
8828 pub type UCharIteratorReserved = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, something: i32) -> i32;
8829 pub type UCharIteratorSetState = unsafe extern "system" fn(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, state: u32, perrorcode: *mut UErrorCode);
8830 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8831 #[repr(transparent)]
8832 pub struct UCharNameChoice(pub i32);
8833 pub const U_UNICODE_CHAR_NAME: UCharNameChoice = UCharNameChoice(0i32);
8834 pub const U_EXTENDED_CHAR_NAME: UCharNameChoice = UCharNameChoice(2i32);
8835 pub const U_CHAR_NAME_ALIAS: UCharNameChoice = UCharNameChoice(3i32);
8836 impl ::std::convert::From<i32> for UCharNameChoice {
from(value: i32) -> Self8837     fn from(value: i32) -> Self {
8838         Self(value)
8839     }
8840 }
8841 unsafe impl ::windows::runtime::Abi for UCharNameChoice {
8842     type Abi = Self;
8843     type DefaultType = Self;
8844 }
8845 #[repr(C)]
8846 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8847 pub struct UCharsetDetector(pub u8);
8848 #[repr(C)]
8849 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8850 pub struct UCharsetMatch(pub u8);
8851 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8852 #[repr(transparent)]
8853 pub struct UColAttribute(pub i32);
8854 pub const UCOL_FRENCH_COLLATION: UColAttribute = UColAttribute(0i32);
8855 pub const UCOL_ALTERNATE_HANDLING: UColAttribute = UColAttribute(1i32);
8856 pub const UCOL_CASE_FIRST: UColAttribute = UColAttribute(2i32);
8857 pub const UCOL_CASE_LEVEL: UColAttribute = UColAttribute(3i32);
8858 pub const UCOL_NORMALIZATION_MODE: UColAttribute = UColAttribute(4i32);
8859 pub const UCOL_DECOMPOSITION_MODE: UColAttribute = UColAttribute(4i32);
8860 pub const UCOL_STRENGTH: UColAttribute = UColAttribute(5i32);
8861 pub const UCOL_NUMERIC_COLLATION: UColAttribute = UColAttribute(7i32);
8862 pub const UCOL_ATTRIBUTE_COUNT: UColAttribute = UColAttribute(8i32);
8863 impl ::std::convert::From<i32> for UColAttribute {
from(value: i32) -> Self8864     fn from(value: i32) -> Self {
8865         Self(value)
8866     }
8867 }
8868 unsafe impl ::windows::runtime::Abi for UColAttribute {
8869     type Abi = Self;
8870     type DefaultType = Self;
8871 }
8872 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8873 #[repr(transparent)]
8874 pub struct UColAttributeValue(pub i32);
8875 pub const UCOL_DEFAULT: UColAttributeValue = UColAttributeValue(-1i32);
8876 pub const UCOL_PRIMARY: UColAttributeValue = UColAttributeValue(0i32);
8877 pub const UCOL_SECONDARY: UColAttributeValue = UColAttributeValue(1i32);
8878 pub const UCOL_TERTIARY: UColAttributeValue = UColAttributeValue(2i32);
8879 pub const UCOL_DEFAULT_STRENGTH: UColAttributeValue = UColAttributeValue(2i32);
8880 pub const UCOL_CE_STRENGTH_LIMIT: UColAttributeValue = UColAttributeValue(3i32);
8881 pub const UCOL_QUATERNARY: UColAttributeValue = UColAttributeValue(3i32);
8882 pub const UCOL_IDENTICAL: UColAttributeValue = UColAttributeValue(15i32);
8883 pub const UCOL_STRENGTH_LIMIT: UColAttributeValue = UColAttributeValue(16i32);
8884 pub const UCOL_OFF: UColAttributeValue = UColAttributeValue(16i32);
8885 pub const UCOL_ON: UColAttributeValue = UColAttributeValue(17i32);
8886 pub const UCOL_SHIFTED: UColAttributeValue = UColAttributeValue(20i32);
8887 pub const UCOL_NON_IGNORABLE: UColAttributeValue = UColAttributeValue(21i32);
8888 pub const UCOL_LOWER_FIRST: UColAttributeValue = UColAttributeValue(24i32);
8889 pub const UCOL_UPPER_FIRST: UColAttributeValue = UColAttributeValue(25i32);
8890 impl ::std::convert::From<i32> for UColAttributeValue {
from(value: i32) -> Self8891     fn from(value: i32) -> Self {
8892         Self(value)
8893     }
8894 }
8895 unsafe impl ::windows::runtime::Abi for UColAttributeValue {
8896     type Abi = Self;
8897     type DefaultType = Self;
8898 }
8899 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8900 #[repr(transparent)]
8901 pub struct UColBoundMode(pub i32);
8902 pub const UCOL_BOUND_LOWER: UColBoundMode = UColBoundMode(0i32);
8903 pub const UCOL_BOUND_UPPER: UColBoundMode = UColBoundMode(1i32);
8904 pub const UCOL_BOUND_UPPER_LONG: UColBoundMode = UColBoundMode(2i32);
8905 impl ::std::convert::From<i32> for UColBoundMode {
from(value: i32) -> Self8906     fn from(value: i32) -> Self {
8907         Self(value)
8908     }
8909 }
8910 unsafe impl ::windows::runtime::Abi for UColBoundMode {
8911     type Abi = Self;
8912     type DefaultType = Self;
8913 }
8914 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8915 #[repr(transparent)]
8916 pub struct UColReorderCode(pub i32);
8917 pub const UCOL_REORDER_CODE_DEFAULT: UColReorderCode = UColReorderCode(-1i32);
8918 pub const UCOL_REORDER_CODE_NONE: UColReorderCode = UColReorderCode(103i32);
8919 pub const UCOL_REORDER_CODE_OTHERS: UColReorderCode = UColReorderCode(103i32);
8920 pub const UCOL_REORDER_CODE_SPACE: UColReorderCode = UColReorderCode(4096i32);
8921 pub const UCOL_REORDER_CODE_FIRST: UColReorderCode = UColReorderCode(4096i32);
8922 pub const UCOL_REORDER_CODE_PUNCTUATION: UColReorderCode = UColReorderCode(4097i32);
8923 pub const UCOL_REORDER_CODE_SYMBOL: UColReorderCode = UColReorderCode(4098i32);
8924 pub const UCOL_REORDER_CODE_CURRENCY: UColReorderCode = UColReorderCode(4099i32);
8925 pub const UCOL_REORDER_CODE_DIGIT: UColReorderCode = UColReorderCode(4100i32);
8926 impl ::std::convert::From<i32> for UColReorderCode {
from(value: i32) -> Self8927     fn from(value: i32) -> Self {
8928         Self(value)
8929     }
8930 }
8931 unsafe impl ::windows::runtime::Abi for UColReorderCode {
8932     type Abi = Self;
8933     type DefaultType = Self;
8934 }
8935 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8936 #[repr(transparent)]
8937 pub struct UColRuleOption(pub i32);
8938 pub const UCOL_TAILORING_ONLY: UColRuleOption = UColRuleOption(0i32);
8939 pub const UCOL_FULL_RULES: UColRuleOption = UColRuleOption(1i32);
8940 impl ::std::convert::From<i32> for UColRuleOption {
from(value: i32) -> Self8941     fn from(value: i32) -> Self {
8942         Self(value)
8943     }
8944 }
8945 unsafe impl ::windows::runtime::Abi for UColRuleOption {
8946     type Abi = Self;
8947     type DefaultType = Self;
8948 }
8949 #[repr(C)]
8950 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8951 pub struct UCollationElements(pub u8);
8952 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8953 #[repr(transparent)]
8954 pub struct UCollationResult(pub i32);
8955 pub const UCOL_EQUAL: UCollationResult = UCollationResult(0i32);
8956 pub const UCOL_GREATER: UCollationResult = UCollationResult(1i32);
8957 pub const UCOL_LESS: UCollationResult = UCollationResult(-1i32);
8958 impl ::std::convert::From<i32> for UCollationResult {
from(value: i32) -> Self8959     fn from(value: i32) -> Self {
8960         Self(value)
8961     }
8962 }
8963 unsafe impl ::windows::runtime::Abi for UCollationResult {
8964     type Abi = Self;
8965     type DefaultType = Self;
8966 }
8967 #[repr(C)]
8968 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8969 pub struct UCollator(pub u8);
8970 #[repr(C)]
8971 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8972 pub struct UConstrainedFieldPosition(pub u8);
8973 #[repr(C)]
8974 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
8975 pub struct UConverter(pub u8);
8976 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
8977 #[repr(transparent)]
8978 pub struct UConverterCallbackReason(pub i32);
8979 pub const UCNV_UNASSIGNED: UConverterCallbackReason = UConverterCallbackReason(0i32);
8980 pub const UCNV_ILLEGAL: UConverterCallbackReason = UConverterCallbackReason(1i32);
8981 pub const UCNV_IRREGULAR: UConverterCallbackReason = UConverterCallbackReason(2i32);
8982 pub const UCNV_RESET: UConverterCallbackReason = UConverterCallbackReason(3i32);
8983 pub const UCNV_CLOSE: UConverterCallbackReason = UConverterCallbackReason(4i32);
8984 pub const UCNV_CLONE: UConverterCallbackReason = UConverterCallbackReason(5i32);
8985 impl ::std::convert::From<i32> for UConverterCallbackReason {
from(value: i32) -> Self8986     fn from(value: i32) -> Self {
8987         Self(value)
8988     }
8989 }
8990 unsafe impl ::windows::runtime::Abi for UConverterCallbackReason {
8991     type Abi = Self;
8992     type DefaultType = Self;
8993 }
8994 #[cfg(feature = "Win32_Foundation")]
8995 pub type UConverterFromUCallback = unsafe extern "system" fn(context: *const ::std::ffi::c_void, args: *mut UConverterFromUnicodeArgs, codeunits: *const u16, length: i32, codepoint: i32, reason: UConverterCallbackReason, perrorcode: *mut UErrorCode);
8996 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
8997 #[repr(C)]
8998 #[cfg(feature = "Win32_Foundation")]
8999 pub struct UConverterFromUnicodeArgs {
9000     pub size: u16,
9001     pub flush: i8,
9002     pub converter: *mut UConverter,
9003     pub source: *mut u16,
9004     pub sourceLimit: *mut u16,
9005     pub target: super::Foundation::PSTR,
9006     pub targetLimit: super::Foundation::PSTR,
9007     pub offsets: *mut i32,
9008 }
9009 #[cfg(feature = "Win32_Foundation")]
9010 impl UConverterFromUnicodeArgs {}
9011 #[cfg(feature = "Win32_Foundation")]
9012 impl ::std::default::Default for UConverterFromUnicodeArgs {
default() -> Self9013     fn default() -> Self {
9014         unsafe { ::std::mem::zeroed() }
9015     }
9016 }
9017 #[cfg(feature = "Win32_Foundation")]
9018 impl ::std::fmt::Debug for UConverterFromUnicodeArgs {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9019     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9020         fmt.debug_struct("UConverterFromUnicodeArgs")
9021             .field("size", &self.size)
9022             .field("flush", &self.flush)
9023             .field("converter", &self.converter)
9024             .field("source", &self.source)
9025             .field("sourceLimit", &self.sourceLimit)
9026             .field("target", &self.target)
9027             .field("targetLimit", &self.targetLimit)
9028             .field("offsets", &self.offsets)
9029             .finish()
9030     }
9031 }
9032 #[cfg(feature = "Win32_Foundation")]
9033 impl ::std::cmp::PartialEq for UConverterFromUnicodeArgs {
eq(&self, other: &Self) -> bool9034     fn eq(&self, other: &Self) -> bool {
9035         self.size == other.size && self.flush == other.flush && self.converter == other.converter && self.source == other.source && self.sourceLimit == other.sourceLimit && self.target == other.target && self.targetLimit == other.targetLimit && self.offsets == other.offsets
9036     }
9037 }
9038 #[cfg(feature = "Win32_Foundation")]
9039 impl ::std::cmp::Eq for UConverterFromUnicodeArgs {}
9040 #[cfg(feature = "Win32_Foundation")]
9041 unsafe impl ::windows::runtime::Abi for UConverterFromUnicodeArgs {
9042     type Abi = Self;
9043     type DefaultType = Self;
9044 }
9045 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9046 #[repr(transparent)]
9047 pub struct UConverterPlatform(pub i32);
9048 pub const UCNV_UNKNOWN: UConverterPlatform = UConverterPlatform(-1i32);
9049 pub const UCNV_IBM: UConverterPlatform = UConverterPlatform(0i32);
9050 impl ::std::convert::From<i32> for UConverterPlatform {
from(value: i32) -> Self9051     fn from(value: i32) -> Self {
9052         Self(value)
9053     }
9054 }
9055 unsafe impl ::windows::runtime::Abi for UConverterPlatform {
9056     type Abi = Self;
9057     type DefaultType = Self;
9058 }
9059 #[repr(C)]
9060 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9061 pub struct UConverterSelector(pub u8);
9062 #[cfg(feature = "Win32_Foundation")]
9063 pub type UConverterToUCallback = unsafe extern "system" fn(context: *const ::std::ffi::c_void, args: *mut UConverterToUnicodeArgs, codeunits: super::Foundation::PSTR, length: i32, reason: UConverterCallbackReason, perrorcode: *mut UErrorCode);
9064 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9065 #[repr(C)]
9066 #[cfg(feature = "Win32_Foundation")]
9067 pub struct UConverterToUnicodeArgs {
9068     pub size: u16,
9069     pub flush: i8,
9070     pub converter: *mut UConverter,
9071     pub source: super::Foundation::PSTR,
9072     pub sourceLimit: super::Foundation::PSTR,
9073     pub target: *mut u16,
9074     pub targetLimit: *mut u16,
9075     pub offsets: *mut i32,
9076 }
9077 #[cfg(feature = "Win32_Foundation")]
9078 impl UConverterToUnicodeArgs {}
9079 #[cfg(feature = "Win32_Foundation")]
9080 impl ::std::default::Default for UConverterToUnicodeArgs {
default() -> Self9081     fn default() -> Self {
9082         unsafe { ::std::mem::zeroed() }
9083     }
9084 }
9085 #[cfg(feature = "Win32_Foundation")]
9086 impl ::std::fmt::Debug for UConverterToUnicodeArgs {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9087     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9088         fmt.debug_struct("UConverterToUnicodeArgs")
9089             .field("size", &self.size)
9090             .field("flush", &self.flush)
9091             .field("converter", &self.converter)
9092             .field("source", &self.source)
9093             .field("sourceLimit", &self.sourceLimit)
9094             .field("target", &self.target)
9095             .field("targetLimit", &self.targetLimit)
9096             .field("offsets", &self.offsets)
9097             .finish()
9098     }
9099 }
9100 #[cfg(feature = "Win32_Foundation")]
9101 impl ::std::cmp::PartialEq for UConverterToUnicodeArgs {
eq(&self, other: &Self) -> bool9102     fn eq(&self, other: &Self) -> bool {
9103         self.size == other.size && self.flush == other.flush && self.converter == other.converter && self.source == other.source && self.sourceLimit == other.sourceLimit && self.target == other.target && self.targetLimit == other.targetLimit && self.offsets == other.offsets
9104     }
9105 }
9106 #[cfg(feature = "Win32_Foundation")]
9107 impl ::std::cmp::Eq for UConverterToUnicodeArgs {}
9108 #[cfg(feature = "Win32_Foundation")]
9109 unsafe impl ::windows::runtime::Abi for UConverterToUnicodeArgs {
9110     type Abi = Self;
9111     type DefaultType = Self;
9112 }
9113 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9114 #[repr(transparent)]
9115 pub struct UConverterType(pub i32);
9116 pub const UCNV_UNSUPPORTED_CONVERTER: UConverterType = UConverterType(-1i32);
9117 pub const UCNV_SBCS: UConverterType = UConverterType(0i32);
9118 pub const UCNV_DBCS: UConverterType = UConverterType(1i32);
9119 pub const UCNV_MBCS: UConverterType = UConverterType(2i32);
9120 pub const UCNV_LATIN_1: UConverterType = UConverterType(3i32);
9121 pub const UCNV_UTF8: UConverterType = UConverterType(4i32);
9122 pub const UCNV_UTF16_BigEndian: UConverterType = UConverterType(5i32);
9123 pub const UCNV_UTF16_LittleEndian: UConverterType = UConverterType(6i32);
9124 pub const UCNV_UTF32_BigEndian: UConverterType = UConverterType(7i32);
9125 pub const UCNV_UTF32_LittleEndian: UConverterType = UConverterType(8i32);
9126 pub const UCNV_EBCDIC_STATEFUL: UConverterType = UConverterType(9i32);
9127 pub const UCNV_ISO_2022: UConverterType = UConverterType(10i32);
9128 pub const UCNV_LMBCS_1: UConverterType = UConverterType(11i32);
9129 pub const UCNV_LMBCS_2: UConverterType = UConverterType(12i32);
9130 pub const UCNV_LMBCS_3: UConverterType = UConverterType(13i32);
9131 pub const UCNV_LMBCS_4: UConverterType = UConverterType(14i32);
9132 pub const UCNV_LMBCS_5: UConverterType = UConverterType(15i32);
9133 pub const UCNV_LMBCS_6: UConverterType = UConverterType(16i32);
9134 pub const UCNV_LMBCS_8: UConverterType = UConverterType(17i32);
9135 pub const UCNV_LMBCS_11: UConverterType = UConverterType(18i32);
9136 pub const UCNV_LMBCS_16: UConverterType = UConverterType(19i32);
9137 pub const UCNV_LMBCS_17: UConverterType = UConverterType(20i32);
9138 pub const UCNV_LMBCS_18: UConverterType = UConverterType(21i32);
9139 pub const UCNV_LMBCS_19: UConverterType = UConverterType(22i32);
9140 pub const UCNV_LMBCS_LAST: UConverterType = UConverterType(22i32);
9141 pub const UCNV_HZ: UConverterType = UConverterType(23i32);
9142 pub const UCNV_SCSU: UConverterType = UConverterType(24i32);
9143 pub const UCNV_ISCII: UConverterType = UConverterType(25i32);
9144 pub const UCNV_US_ASCII: UConverterType = UConverterType(26i32);
9145 pub const UCNV_UTF7: UConverterType = UConverterType(27i32);
9146 pub const UCNV_BOCU1: UConverterType = UConverterType(28i32);
9147 pub const UCNV_UTF16: UConverterType = UConverterType(29i32);
9148 pub const UCNV_UTF32: UConverterType = UConverterType(30i32);
9149 pub const UCNV_CESU8: UConverterType = UConverterType(31i32);
9150 pub const UCNV_IMAP_MAILBOX: UConverterType = UConverterType(32i32);
9151 pub const UCNV_COMPOUND_TEXT: UConverterType = UConverterType(33i32);
9152 pub const UCNV_NUMBER_OF_SUPPORTED_CONVERTER_TYPES: UConverterType = UConverterType(34i32);
9153 impl ::std::convert::From<i32> for UConverterType {
from(value: i32) -> Self9154     fn from(value: i32) -> Self {
9155         Self(value)
9156     }
9157 }
9158 unsafe impl ::windows::runtime::Abi for UConverterType {
9159     type Abi = Self;
9160     type DefaultType = Self;
9161 }
9162 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9163 #[repr(transparent)]
9164 pub struct UConverterUnicodeSet(pub i32);
9165 pub const UCNV_ROUNDTRIP_SET: UConverterUnicodeSet = UConverterUnicodeSet(0i32);
9166 pub const UCNV_ROUNDTRIP_AND_FALLBACK_SET: UConverterUnicodeSet = UConverterUnicodeSet(1i32);
9167 impl ::std::convert::From<i32> for UConverterUnicodeSet {
from(value: i32) -> Self9168     fn from(value: i32) -> Self {
9169         Self(value)
9170     }
9171 }
9172 unsafe impl ::windows::runtime::Abi for UConverterUnicodeSet {
9173     type Abi = Self;
9174     type DefaultType = Self;
9175 }
9176 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9177 #[repr(transparent)]
9178 pub struct UCurrCurrencyType(pub i32);
9179 pub const UCURR_ALL: UCurrCurrencyType = UCurrCurrencyType(2147483647i32);
9180 pub const UCURR_COMMON: UCurrCurrencyType = UCurrCurrencyType(1i32);
9181 pub const UCURR_UNCOMMON: UCurrCurrencyType = UCurrCurrencyType(2i32);
9182 pub const UCURR_DEPRECATED: UCurrCurrencyType = UCurrCurrencyType(4i32);
9183 pub const UCURR_NON_DEPRECATED: UCurrCurrencyType = UCurrCurrencyType(8i32);
9184 impl ::std::convert::From<i32> for UCurrCurrencyType {
from(value: i32) -> Self9185     fn from(value: i32) -> Self {
9186         Self(value)
9187     }
9188 }
9189 unsafe impl ::windows::runtime::Abi for UCurrCurrencyType {
9190     type Abi = Self;
9191     type DefaultType = Self;
9192 }
9193 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9194 #[repr(transparent)]
9195 pub struct UCurrNameStyle(pub i32);
9196 pub const UCURR_SYMBOL_NAME: UCurrNameStyle = UCurrNameStyle(0i32);
9197 pub const UCURR_LONG_NAME: UCurrNameStyle = UCurrNameStyle(1i32);
9198 pub const UCURR_NARROW_SYMBOL_NAME: UCurrNameStyle = UCurrNameStyle(2i32);
9199 impl ::std::convert::From<i32> for UCurrNameStyle {
from(value: i32) -> Self9200     fn from(value: i32) -> Self {
9201         Self(value)
9202     }
9203 }
9204 unsafe impl ::windows::runtime::Abi for UCurrNameStyle {
9205     type Abi = Self;
9206     type DefaultType = Self;
9207 }
9208 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9209 #[repr(transparent)]
9210 pub struct UCurrencySpacing(pub i32);
9211 pub const UNUM_CURRENCY_MATCH: UCurrencySpacing = UCurrencySpacing(0i32);
9212 pub const UNUM_CURRENCY_SURROUNDING_MATCH: UCurrencySpacing = UCurrencySpacing(1i32);
9213 pub const UNUM_CURRENCY_INSERT: UCurrencySpacing = UCurrencySpacing(2i32);
9214 pub const UNUM_CURRENCY_SPACING_COUNT: UCurrencySpacing = UCurrencySpacing(3i32);
9215 impl ::std::convert::From<i32> for UCurrencySpacing {
from(value: i32) -> Self9216     fn from(value: i32) -> Self {
9217         Self(value)
9218     }
9219 }
9220 unsafe impl ::windows::runtime::Abi for UCurrencySpacing {
9221     type Abi = Self;
9222     type DefaultType = Self;
9223 }
9224 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9225 #[repr(transparent)]
9226 pub struct UCurrencyUsage(pub i32);
9227 pub const UCURR_USAGE_STANDARD: UCurrencyUsage = UCurrencyUsage(0i32);
9228 pub const UCURR_USAGE_CASH: UCurrencyUsage = UCurrencyUsage(1i32);
9229 impl ::std::convert::From<i32> for UCurrencyUsage {
from(value: i32) -> Self9230     fn from(value: i32) -> Self {
9231         Self(value)
9232     }
9233 }
9234 unsafe impl ::windows::runtime::Abi for UCurrencyUsage {
9235     type Abi = Self;
9236     type DefaultType = Self;
9237 }
9238 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9239 #[repr(transparent)]
9240 pub struct UDateAbsoluteUnit(pub i32);
9241 pub const UDAT_ABSOLUTE_SUNDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(0i32);
9242 pub const UDAT_ABSOLUTE_MONDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(1i32);
9243 pub const UDAT_ABSOLUTE_TUESDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(2i32);
9244 pub const UDAT_ABSOLUTE_WEDNESDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(3i32);
9245 pub const UDAT_ABSOLUTE_THURSDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(4i32);
9246 pub const UDAT_ABSOLUTE_FRIDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(5i32);
9247 pub const UDAT_ABSOLUTE_SATURDAY: UDateAbsoluteUnit = UDateAbsoluteUnit(6i32);
9248 pub const UDAT_ABSOLUTE_DAY: UDateAbsoluteUnit = UDateAbsoluteUnit(7i32);
9249 pub const UDAT_ABSOLUTE_WEEK: UDateAbsoluteUnit = UDateAbsoluteUnit(8i32);
9250 pub const UDAT_ABSOLUTE_MONTH: UDateAbsoluteUnit = UDateAbsoluteUnit(9i32);
9251 pub const UDAT_ABSOLUTE_YEAR: UDateAbsoluteUnit = UDateAbsoluteUnit(10i32);
9252 pub const UDAT_ABSOLUTE_NOW: UDateAbsoluteUnit = UDateAbsoluteUnit(11i32);
9253 pub const UDAT_ABSOLUTE_UNIT_COUNT: UDateAbsoluteUnit = UDateAbsoluteUnit(12i32);
9254 impl ::std::convert::From<i32> for UDateAbsoluteUnit {
from(value: i32) -> Self9255     fn from(value: i32) -> Self {
9256         Self(value)
9257     }
9258 }
9259 unsafe impl ::windows::runtime::Abi for UDateAbsoluteUnit {
9260     type Abi = Self;
9261     type DefaultType = Self;
9262 }
9263 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9264 #[repr(transparent)]
9265 pub struct UDateDirection(pub i32);
9266 pub const UDAT_DIRECTION_LAST_2: UDateDirection = UDateDirection(0i32);
9267 pub const UDAT_DIRECTION_LAST: UDateDirection = UDateDirection(1i32);
9268 pub const UDAT_DIRECTION_THIS: UDateDirection = UDateDirection(2i32);
9269 pub const UDAT_DIRECTION_NEXT: UDateDirection = UDateDirection(3i32);
9270 pub const UDAT_DIRECTION_NEXT_2: UDateDirection = UDateDirection(4i32);
9271 pub const UDAT_DIRECTION_PLAIN: UDateDirection = UDateDirection(5i32);
9272 pub const UDAT_DIRECTION_COUNT: UDateDirection = UDateDirection(6i32);
9273 impl ::std::convert::From<i32> for UDateDirection {
from(value: i32) -> Self9274     fn from(value: i32) -> Self {
9275         Self(value)
9276     }
9277 }
9278 unsafe impl ::windows::runtime::Abi for UDateDirection {
9279     type Abi = Self;
9280     type DefaultType = Self;
9281 }
9282 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9283 #[repr(transparent)]
9284 pub struct UDateFormatBooleanAttribute(pub i32);
9285 pub const UDAT_PARSE_ALLOW_WHITESPACE: UDateFormatBooleanAttribute = UDateFormatBooleanAttribute(0i32);
9286 pub const UDAT_PARSE_ALLOW_NUMERIC: UDateFormatBooleanAttribute = UDateFormatBooleanAttribute(1i32);
9287 pub const UDAT_PARSE_PARTIAL_LITERAL_MATCH: UDateFormatBooleanAttribute = UDateFormatBooleanAttribute(2i32);
9288 pub const UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH: UDateFormatBooleanAttribute = UDateFormatBooleanAttribute(3i32);
9289 pub const UDAT_BOOLEAN_ATTRIBUTE_COUNT: UDateFormatBooleanAttribute = UDateFormatBooleanAttribute(4i32);
9290 impl ::std::convert::From<i32> for UDateFormatBooleanAttribute {
from(value: i32) -> Self9291     fn from(value: i32) -> Self {
9292         Self(value)
9293     }
9294 }
9295 unsafe impl ::windows::runtime::Abi for UDateFormatBooleanAttribute {
9296     type Abi = Self;
9297     type DefaultType = Self;
9298 }
9299 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9300 #[repr(transparent)]
9301 pub struct UDateFormatField(pub i32);
9302 pub const UDAT_ERA_FIELD: UDateFormatField = UDateFormatField(0i32);
9303 pub const UDAT_YEAR_FIELD: UDateFormatField = UDateFormatField(1i32);
9304 pub const UDAT_MONTH_FIELD: UDateFormatField = UDateFormatField(2i32);
9305 pub const UDAT_DATE_FIELD: UDateFormatField = UDateFormatField(3i32);
9306 pub const UDAT_HOUR_OF_DAY1_FIELD: UDateFormatField = UDateFormatField(4i32);
9307 pub const UDAT_HOUR_OF_DAY0_FIELD: UDateFormatField = UDateFormatField(5i32);
9308 pub const UDAT_MINUTE_FIELD: UDateFormatField = UDateFormatField(6i32);
9309 pub const UDAT_SECOND_FIELD: UDateFormatField = UDateFormatField(7i32);
9310 pub const UDAT_FRACTIONAL_SECOND_FIELD: UDateFormatField = UDateFormatField(8i32);
9311 pub const UDAT_DAY_OF_WEEK_FIELD: UDateFormatField = UDateFormatField(9i32);
9312 pub const UDAT_DAY_OF_YEAR_FIELD: UDateFormatField = UDateFormatField(10i32);
9313 pub const UDAT_DAY_OF_WEEK_IN_MONTH_FIELD: UDateFormatField = UDateFormatField(11i32);
9314 pub const UDAT_WEEK_OF_YEAR_FIELD: UDateFormatField = UDateFormatField(12i32);
9315 pub const UDAT_WEEK_OF_MONTH_FIELD: UDateFormatField = UDateFormatField(13i32);
9316 pub const UDAT_AM_PM_FIELD: UDateFormatField = UDateFormatField(14i32);
9317 pub const UDAT_HOUR1_FIELD: UDateFormatField = UDateFormatField(15i32);
9318 pub const UDAT_HOUR0_FIELD: UDateFormatField = UDateFormatField(16i32);
9319 pub const UDAT_TIMEZONE_FIELD: UDateFormatField = UDateFormatField(17i32);
9320 pub const UDAT_YEAR_WOY_FIELD: UDateFormatField = UDateFormatField(18i32);
9321 pub const UDAT_DOW_LOCAL_FIELD: UDateFormatField = UDateFormatField(19i32);
9322 pub const UDAT_EXTENDED_YEAR_FIELD: UDateFormatField = UDateFormatField(20i32);
9323 pub const UDAT_JULIAN_DAY_FIELD: UDateFormatField = UDateFormatField(21i32);
9324 pub const UDAT_MILLISECONDS_IN_DAY_FIELD: UDateFormatField = UDateFormatField(22i32);
9325 pub const UDAT_TIMEZONE_RFC_FIELD: UDateFormatField = UDateFormatField(23i32);
9326 pub const UDAT_TIMEZONE_GENERIC_FIELD: UDateFormatField = UDateFormatField(24i32);
9327 pub const UDAT_STANDALONE_DAY_FIELD: UDateFormatField = UDateFormatField(25i32);
9328 pub const UDAT_STANDALONE_MONTH_FIELD: UDateFormatField = UDateFormatField(26i32);
9329 pub const UDAT_QUARTER_FIELD: UDateFormatField = UDateFormatField(27i32);
9330 pub const UDAT_STANDALONE_QUARTER_FIELD: UDateFormatField = UDateFormatField(28i32);
9331 pub const UDAT_TIMEZONE_SPECIAL_FIELD: UDateFormatField = UDateFormatField(29i32);
9332 pub const UDAT_YEAR_NAME_FIELD: UDateFormatField = UDateFormatField(30i32);
9333 pub const UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD: UDateFormatField = UDateFormatField(31i32);
9334 pub const UDAT_TIMEZONE_ISO_FIELD: UDateFormatField = UDateFormatField(32i32);
9335 pub const UDAT_TIMEZONE_ISO_LOCAL_FIELD: UDateFormatField = UDateFormatField(33i32);
9336 pub const UDAT_AM_PM_MIDNIGHT_NOON_FIELD: UDateFormatField = UDateFormatField(35i32);
9337 pub const UDAT_FLEXIBLE_DAY_PERIOD_FIELD: UDateFormatField = UDateFormatField(36i32);
9338 impl ::std::convert::From<i32> for UDateFormatField {
from(value: i32) -> Self9339     fn from(value: i32) -> Self {
9340         Self(value)
9341     }
9342 }
9343 unsafe impl ::windows::runtime::Abi for UDateFormatField {
9344     type Abi = Self;
9345     type DefaultType = Self;
9346 }
9347 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9348 #[repr(transparent)]
9349 pub struct UDateFormatStyle(pub i32);
9350 pub const UDAT_FULL: UDateFormatStyle = UDateFormatStyle(0i32);
9351 pub const UDAT_LONG: UDateFormatStyle = UDateFormatStyle(1i32);
9352 pub const UDAT_MEDIUM: UDateFormatStyle = UDateFormatStyle(2i32);
9353 pub const UDAT_SHORT: UDateFormatStyle = UDateFormatStyle(3i32);
9354 pub const UDAT_DEFAULT: UDateFormatStyle = UDateFormatStyle(2i32);
9355 pub const UDAT_RELATIVE: UDateFormatStyle = UDateFormatStyle(128i32);
9356 pub const UDAT_FULL_RELATIVE: UDateFormatStyle = UDateFormatStyle(128i32);
9357 pub const UDAT_LONG_RELATIVE: UDateFormatStyle = UDateFormatStyle(129i32);
9358 pub const UDAT_MEDIUM_RELATIVE: UDateFormatStyle = UDateFormatStyle(130i32);
9359 pub const UDAT_SHORT_RELATIVE: UDateFormatStyle = UDateFormatStyle(131i32);
9360 pub const UDAT_NONE: UDateFormatStyle = UDateFormatStyle(-1i32);
9361 pub const UDAT_PATTERN: UDateFormatStyle = UDateFormatStyle(-2i32);
9362 impl ::std::convert::From<i32> for UDateFormatStyle {
from(value: i32) -> Self9363     fn from(value: i32) -> Self {
9364         Self(value)
9365     }
9366 }
9367 unsafe impl ::windows::runtime::Abi for UDateFormatStyle {
9368     type Abi = Self;
9369     type DefaultType = Self;
9370 }
9371 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9372 #[repr(transparent)]
9373 pub struct UDateFormatSymbolType(pub i32);
9374 pub const UDAT_ERAS: UDateFormatSymbolType = UDateFormatSymbolType(0i32);
9375 pub const UDAT_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(1i32);
9376 pub const UDAT_SHORT_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(2i32);
9377 pub const UDAT_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(3i32);
9378 pub const UDAT_SHORT_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(4i32);
9379 pub const UDAT_AM_PMS: UDateFormatSymbolType = UDateFormatSymbolType(5i32);
9380 pub const UDAT_LOCALIZED_CHARS: UDateFormatSymbolType = UDateFormatSymbolType(6i32);
9381 pub const UDAT_ERA_NAMES: UDateFormatSymbolType = UDateFormatSymbolType(7i32);
9382 pub const UDAT_NARROW_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(8i32);
9383 pub const UDAT_NARROW_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(9i32);
9384 pub const UDAT_STANDALONE_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(10i32);
9385 pub const UDAT_STANDALONE_SHORT_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(11i32);
9386 pub const UDAT_STANDALONE_NARROW_MONTHS: UDateFormatSymbolType = UDateFormatSymbolType(12i32);
9387 pub const UDAT_STANDALONE_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(13i32);
9388 pub const UDAT_STANDALONE_SHORT_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(14i32);
9389 pub const UDAT_STANDALONE_NARROW_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(15i32);
9390 pub const UDAT_QUARTERS: UDateFormatSymbolType = UDateFormatSymbolType(16i32);
9391 pub const UDAT_SHORT_QUARTERS: UDateFormatSymbolType = UDateFormatSymbolType(17i32);
9392 pub const UDAT_STANDALONE_QUARTERS: UDateFormatSymbolType = UDateFormatSymbolType(18i32);
9393 pub const UDAT_STANDALONE_SHORT_QUARTERS: UDateFormatSymbolType = UDateFormatSymbolType(19i32);
9394 pub const UDAT_SHORTER_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(20i32);
9395 pub const UDAT_STANDALONE_SHORTER_WEEKDAYS: UDateFormatSymbolType = UDateFormatSymbolType(21i32);
9396 pub const UDAT_CYCLIC_YEARS_WIDE: UDateFormatSymbolType = UDateFormatSymbolType(22i32);
9397 pub const UDAT_CYCLIC_YEARS_ABBREVIATED: UDateFormatSymbolType = UDateFormatSymbolType(23i32);
9398 pub const UDAT_CYCLIC_YEARS_NARROW: UDateFormatSymbolType = UDateFormatSymbolType(24i32);
9399 pub const UDAT_ZODIAC_NAMES_WIDE: UDateFormatSymbolType = UDateFormatSymbolType(25i32);
9400 pub const UDAT_ZODIAC_NAMES_ABBREVIATED: UDateFormatSymbolType = UDateFormatSymbolType(26i32);
9401 pub const UDAT_ZODIAC_NAMES_NARROW: UDateFormatSymbolType = UDateFormatSymbolType(27i32);
9402 impl ::std::convert::From<i32> for UDateFormatSymbolType {
from(value: i32) -> Self9403     fn from(value: i32) -> Self {
9404         Self(value)
9405     }
9406 }
9407 unsafe impl ::windows::runtime::Abi for UDateFormatSymbolType {
9408     type Abi = Self;
9409     type DefaultType = Self;
9410 }
9411 #[repr(C)]
9412 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9413 pub struct UDateFormatSymbols(pub u8);
9414 #[repr(C)]
9415 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9416 pub struct UDateIntervalFormat(pub u8);
9417 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9418 #[repr(transparent)]
9419 pub struct UDateRelativeDateTimeFormatterStyle(pub i32);
9420 pub const UDAT_STYLE_LONG: UDateRelativeDateTimeFormatterStyle = UDateRelativeDateTimeFormatterStyle(0i32);
9421 pub const UDAT_STYLE_SHORT: UDateRelativeDateTimeFormatterStyle = UDateRelativeDateTimeFormatterStyle(1i32);
9422 pub const UDAT_STYLE_NARROW: UDateRelativeDateTimeFormatterStyle = UDateRelativeDateTimeFormatterStyle(2i32);
9423 impl ::std::convert::From<i32> for UDateRelativeDateTimeFormatterStyle {
from(value: i32) -> Self9424     fn from(value: i32) -> Self {
9425         Self(value)
9426     }
9427 }
9428 unsafe impl ::windows::runtime::Abi for UDateRelativeDateTimeFormatterStyle {
9429     type Abi = Self;
9430     type DefaultType = Self;
9431 }
9432 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9433 #[repr(transparent)]
9434 pub struct UDateRelativeUnit(pub i32);
9435 pub const UDAT_RELATIVE_SECONDS: UDateRelativeUnit = UDateRelativeUnit(0i32);
9436 pub const UDAT_RELATIVE_MINUTES: UDateRelativeUnit = UDateRelativeUnit(1i32);
9437 pub const UDAT_RELATIVE_HOURS: UDateRelativeUnit = UDateRelativeUnit(2i32);
9438 pub const UDAT_RELATIVE_DAYS: UDateRelativeUnit = UDateRelativeUnit(3i32);
9439 pub const UDAT_RELATIVE_WEEKS: UDateRelativeUnit = UDateRelativeUnit(4i32);
9440 pub const UDAT_RELATIVE_MONTHS: UDateRelativeUnit = UDateRelativeUnit(5i32);
9441 pub const UDAT_RELATIVE_YEARS: UDateRelativeUnit = UDateRelativeUnit(6i32);
9442 pub const UDAT_RELATIVE_UNIT_COUNT: UDateRelativeUnit = UDateRelativeUnit(7i32);
9443 impl ::std::convert::From<i32> for UDateRelativeUnit {
from(value: i32) -> Self9444     fn from(value: i32) -> Self {
9445         Self(value)
9446     }
9447 }
9448 unsafe impl ::windows::runtime::Abi for UDateRelativeUnit {
9449     type Abi = Self;
9450     type DefaultType = Self;
9451 }
9452 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9453 #[repr(transparent)]
9454 pub struct UDateTimePGDisplayWidth(pub i32);
9455 pub const UDATPG_WIDE: UDateTimePGDisplayWidth = UDateTimePGDisplayWidth(0i32);
9456 pub const UDATPG_ABBREVIATED: UDateTimePGDisplayWidth = UDateTimePGDisplayWidth(1i32);
9457 pub const UDATPG_NARROW: UDateTimePGDisplayWidth = UDateTimePGDisplayWidth(2i32);
9458 impl ::std::convert::From<i32> for UDateTimePGDisplayWidth {
from(value: i32) -> Self9459     fn from(value: i32) -> Self {
9460         Self(value)
9461     }
9462 }
9463 unsafe impl ::windows::runtime::Abi for UDateTimePGDisplayWidth {
9464     type Abi = Self;
9465     type DefaultType = Self;
9466 }
9467 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9468 #[repr(transparent)]
9469 pub struct UDateTimePatternConflict(pub i32);
9470 pub const UDATPG_NO_CONFLICT: UDateTimePatternConflict = UDateTimePatternConflict(0i32);
9471 pub const UDATPG_BASE_CONFLICT: UDateTimePatternConflict = UDateTimePatternConflict(1i32);
9472 pub const UDATPG_CONFLICT: UDateTimePatternConflict = UDateTimePatternConflict(2i32);
9473 impl ::std::convert::From<i32> for UDateTimePatternConflict {
from(value: i32) -> Self9474     fn from(value: i32) -> Self {
9475         Self(value)
9476     }
9477 }
9478 unsafe impl ::windows::runtime::Abi for UDateTimePatternConflict {
9479     type Abi = Self;
9480     type DefaultType = Self;
9481 }
9482 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9483 #[repr(transparent)]
9484 pub struct UDateTimePatternField(pub i32);
9485 pub const UDATPG_ERA_FIELD: UDateTimePatternField = UDateTimePatternField(0i32);
9486 pub const UDATPG_YEAR_FIELD: UDateTimePatternField = UDateTimePatternField(1i32);
9487 pub const UDATPG_QUARTER_FIELD: UDateTimePatternField = UDateTimePatternField(2i32);
9488 pub const UDATPG_MONTH_FIELD: UDateTimePatternField = UDateTimePatternField(3i32);
9489 pub const UDATPG_WEEK_OF_YEAR_FIELD: UDateTimePatternField = UDateTimePatternField(4i32);
9490 pub const UDATPG_WEEK_OF_MONTH_FIELD: UDateTimePatternField = UDateTimePatternField(5i32);
9491 pub const UDATPG_WEEKDAY_FIELD: UDateTimePatternField = UDateTimePatternField(6i32);
9492 pub const UDATPG_DAY_OF_YEAR_FIELD: UDateTimePatternField = UDateTimePatternField(7i32);
9493 pub const UDATPG_DAY_OF_WEEK_IN_MONTH_FIELD: UDateTimePatternField = UDateTimePatternField(8i32);
9494 pub const UDATPG_DAY_FIELD: UDateTimePatternField = UDateTimePatternField(9i32);
9495 pub const UDATPG_DAYPERIOD_FIELD: UDateTimePatternField = UDateTimePatternField(10i32);
9496 pub const UDATPG_HOUR_FIELD: UDateTimePatternField = UDateTimePatternField(11i32);
9497 pub const UDATPG_MINUTE_FIELD: UDateTimePatternField = UDateTimePatternField(12i32);
9498 pub const UDATPG_SECOND_FIELD: UDateTimePatternField = UDateTimePatternField(13i32);
9499 pub const UDATPG_FRACTIONAL_SECOND_FIELD: UDateTimePatternField = UDateTimePatternField(14i32);
9500 pub const UDATPG_ZONE_FIELD: UDateTimePatternField = UDateTimePatternField(15i32);
9501 pub const UDATPG_FIELD_COUNT: UDateTimePatternField = UDateTimePatternField(16i32);
9502 impl ::std::convert::From<i32> for UDateTimePatternField {
from(value: i32) -> Self9503     fn from(value: i32) -> Self {
9504         Self(value)
9505     }
9506 }
9507 unsafe impl ::windows::runtime::Abi for UDateTimePatternField {
9508     type Abi = Self;
9509     type DefaultType = Self;
9510 }
9511 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9512 #[repr(transparent)]
9513 pub struct UDateTimePatternMatchOptions(pub i32);
9514 pub const UDATPG_MATCH_NO_OPTIONS: UDateTimePatternMatchOptions = UDateTimePatternMatchOptions(0i32);
9515 pub const UDATPG_MATCH_HOUR_FIELD_LENGTH: UDateTimePatternMatchOptions = UDateTimePatternMatchOptions(2048i32);
9516 pub const UDATPG_MATCH_ALL_FIELDS_LENGTH: UDateTimePatternMatchOptions = UDateTimePatternMatchOptions(65535i32);
9517 impl ::std::convert::From<i32> for UDateTimePatternMatchOptions {
from(value: i32) -> Self9518     fn from(value: i32) -> Self {
9519         Self(value)
9520     }
9521 }
9522 unsafe impl ::windows::runtime::Abi for UDateTimePatternMatchOptions {
9523     type Abi = Self;
9524     type DefaultType = Self;
9525 }
9526 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9527 #[repr(transparent)]
9528 pub struct UDateTimeScale(pub i32);
9529 pub const UDTS_JAVA_TIME: UDateTimeScale = UDateTimeScale(0i32);
9530 pub const UDTS_UNIX_TIME: UDateTimeScale = UDateTimeScale(1i32);
9531 pub const UDTS_ICU4C_TIME: UDateTimeScale = UDateTimeScale(2i32);
9532 pub const UDTS_WINDOWS_FILE_TIME: UDateTimeScale = UDateTimeScale(3i32);
9533 pub const UDTS_DOTNET_DATE_TIME: UDateTimeScale = UDateTimeScale(4i32);
9534 pub const UDTS_MAC_OLD_TIME: UDateTimeScale = UDateTimeScale(5i32);
9535 pub const UDTS_MAC_TIME: UDateTimeScale = UDateTimeScale(6i32);
9536 pub const UDTS_EXCEL_TIME: UDateTimeScale = UDateTimeScale(7i32);
9537 pub const UDTS_DB2_TIME: UDateTimeScale = UDateTimeScale(8i32);
9538 pub const UDTS_UNIX_MICROSECONDS_TIME: UDateTimeScale = UDateTimeScale(9i32);
9539 impl ::std::convert::From<i32> for UDateTimeScale {
from(value: i32) -> Self9540     fn from(value: i32) -> Self {
9541         Self(value)
9542     }
9543 }
9544 unsafe impl ::windows::runtime::Abi for UDateTimeScale {
9545     type Abi = Self;
9546     type DefaultType = Self;
9547 }
9548 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9549 #[repr(transparent)]
9550 pub struct UDecompositionType(pub i32);
9551 pub const U_DT_NONE: UDecompositionType = UDecompositionType(0i32);
9552 pub const U_DT_CANONICAL: UDecompositionType = UDecompositionType(1i32);
9553 pub const U_DT_COMPAT: UDecompositionType = UDecompositionType(2i32);
9554 pub const U_DT_CIRCLE: UDecompositionType = UDecompositionType(3i32);
9555 pub const U_DT_FINAL: UDecompositionType = UDecompositionType(4i32);
9556 pub const U_DT_FONT: UDecompositionType = UDecompositionType(5i32);
9557 pub const U_DT_FRACTION: UDecompositionType = UDecompositionType(6i32);
9558 pub const U_DT_INITIAL: UDecompositionType = UDecompositionType(7i32);
9559 pub const U_DT_ISOLATED: UDecompositionType = UDecompositionType(8i32);
9560 pub const U_DT_MEDIAL: UDecompositionType = UDecompositionType(9i32);
9561 pub const U_DT_NARROW: UDecompositionType = UDecompositionType(10i32);
9562 pub const U_DT_NOBREAK: UDecompositionType = UDecompositionType(11i32);
9563 pub const U_DT_SMALL: UDecompositionType = UDecompositionType(12i32);
9564 pub const U_DT_SQUARE: UDecompositionType = UDecompositionType(13i32);
9565 pub const U_DT_SUB: UDecompositionType = UDecompositionType(14i32);
9566 pub const U_DT_SUPER: UDecompositionType = UDecompositionType(15i32);
9567 pub const U_DT_VERTICAL: UDecompositionType = UDecompositionType(16i32);
9568 pub const U_DT_WIDE: UDecompositionType = UDecompositionType(17i32);
9569 impl ::std::convert::From<i32> for UDecompositionType {
from(value: i32) -> Self9570     fn from(value: i32) -> Self {
9571         Self(value)
9572     }
9573 }
9574 unsafe impl ::windows::runtime::Abi for UDecompositionType {
9575     type Abi = Self;
9576     type DefaultType = Self;
9577 }
9578 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9579 #[repr(transparent)]
9580 pub struct UDialectHandling(pub i32);
9581 pub const ULDN_STANDARD_NAMES: UDialectHandling = UDialectHandling(0i32);
9582 pub const ULDN_DIALECT_NAMES: UDialectHandling = UDialectHandling(1i32);
9583 impl ::std::convert::From<i32> for UDialectHandling {
from(value: i32) -> Self9584     fn from(value: i32) -> Self {
9585         Self(value)
9586     }
9587 }
9588 unsafe impl ::windows::runtime::Abi for UDialectHandling {
9589     type Abi = Self;
9590     type DefaultType = Self;
9591 }
9592 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9593 #[repr(transparent)]
9594 pub struct UDisplayContext(pub i32);
9595 pub const UDISPCTX_STANDARD_NAMES: UDisplayContext = UDisplayContext(0i32);
9596 pub const UDISPCTX_DIALECT_NAMES: UDisplayContext = UDisplayContext(1i32);
9597 pub const UDISPCTX_CAPITALIZATION_NONE: UDisplayContext = UDisplayContext(256i32);
9598 pub const UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE: UDisplayContext = UDisplayContext(257i32);
9599 pub const UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE: UDisplayContext = UDisplayContext(258i32);
9600 pub const UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU: UDisplayContext = UDisplayContext(259i32);
9601 pub const UDISPCTX_CAPITALIZATION_FOR_STANDALONE: UDisplayContext = UDisplayContext(260i32);
9602 pub const UDISPCTX_LENGTH_FULL: UDisplayContext = UDisplayContext(512i32);
9603 pub const UDISPCTX_LENGTH_SHORT: UDisplayContext = UDisplayContext(513i32);
9604 pub const UDISPCTX_SUBSTITUTE: UDisplayContext = UDisplayContext(768i32);
9605 pub const UDISPCTX_NO_SUBSTITUTE: UDisplayContext = UDisplayContext(769i32);
9606 impl ::std::convert::From<i32> for UDisplayContext {
from(value: i32) -> Self9607     fn from(value: i32) -> Self {
9608         Self(value)
9609     }
9610 }
9611 unsafe impl ::windows::runtime::Abi for UDisplayContext {
9612     type Abi = Self;
9613     type DefaultType = Self;
9614 }
9615 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9616 #[repr(transparent)]
9617 pub struct UDisplayContextType(pub i32);
9618 pub const UDISPCTX_TYPE_DIALECT_HANDLING: UDisplayContextType = UDisplayContextType(0i32);
9619 pub const UDISPCTX_TYPE_CAPITALIZATION: UDisplayContextType = UDisplayContextType(1i32);
9620 pub const UDISPCTX_TYPE_DISPLAY_LENGTH: UDisplayContextType = UDisplayContextType(2i32);
9621 pub const UDISPCTX_TYPE_SUBSTITUTE_HANDLING: UDisplayContextType = UDisplayContextType(3i32);
9622 impl ::std::convert::From<i32> for UDisplayContextType {
from(value: i32) -> Self9623     fn from(value: i32) -> Self {
9624         Self(value)
9625     }
9626 }
9627 unsafe impl ::windows::runtime::Abi for UDisplayContextType {
9628     type Abi = Self;
9629     type DefaultType = Self;
9630 }
9631 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9632 #[repr(transparent)]
9633 pub struct UEastAsianWidth(pub i32);
9634 pub const U_EA_NEUTRAL: UEastAsianWidth = UEastAsianWidth(0i32);
9635 pub const U_EA_AMBIGUOUS: UEastAsianWidth = UEastAsianWidth(1i32);
9636 pub const U_EA_HALFWIDTH: UEastAsianWidth = UEastAsianWidth(2i32);
9637 pub const U_EA_FULLWIDTH: UEastAsianWidth = UEastAsianWidth(3i32);
9638 pub const U_EA_NARROW: UEastAsianWidth = UEastAsianWidth(4i32);
9639 pub const U_EA_WIDE: UEastAsianWidth = UEastAsianWidth(5i32);
9640 impl ::std::convert::From<i32> for UEastAsianWidth {
from(value: i32) -> Self9641     fn from(value: i32) -> Self {
9642         Self(value)
9643     }
9644 }
9645 unsafe impl ::windows::runtime::Abi for UEastAsianWidth {
9646     type Abi = Self;
9647     type DefaultType = Self;
9648 }
9649 #[cfg(feature = "Win32_Foundation")]
9650 pub type UEnumCharNamesFn = unsafe extern "system" fn(context: *mut ::std::ffi::c_void, code: i32, namechoice: UCharNameChoice, name: super::Foundation::PSTR, length: i32) -> i8;
9651 #[repr(C)]
9652 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9653 pub struct UEnumeration(pub u8);
9654 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9655 #[repr(transparent)]
9656 pub struct UErrorCode(pub i32);
9657 pub const U_USING_FALLBACK_WARNING: UErrorCode = UErrorCode(-128i32);
9658 pub const U_ERROR_WARNING_START: UErrorCode = UErrorCode(-128i32);
9659 pub const U_USING_DEFAULT_WARNING: UErrorCode = UErrorCode(-127i32);
9660 pub const U_SAFECLONE_ALLOCATED_WARNING: UErrorCode = UErrorCode(-126i32);
9661 pub const U_STATE_OLD_WARNING: UErrorCode = UErrorCode(-125i32);
9662 pub const U_STRING_NOT_TERMINATED_WARNING: UErrorCode = UErrorCode(-124i32);
9663 pub const U_SORT_KEY_TOO_SHORT_WARNING: UErrorCode = UErrorCode(-123i32);
9664 pub const U_AMBIGUOUS_ALIAS_WARNING: UErrorCode = UErrorCode(-122i32);
9665 pub const U_DIFFERENT_UCA_VERSION: UErrorCode = UErrorCode(-121i32);
9666 pub const U_PLUGIN_CHANGED_LEVEL_WARNING: UErrorCode = UErrorCode(-120i32);
9667 pub const U_ZERO_ERROR: UErrorCode = UErrorCode(0i32);
9668 pub const U_ILLEGAL_ARGUMENT_ERROR: UErrorCode = UErrorCode(1i32);
9669 pub const U_MISSING_RESOURCE_ERROR: UErrorCode = UErrorCode(2i32);
9670 pub const U_INVALID_FORMAT_ERROR: UErrorCode = UErrorCode(3i32);
9671 pub const U_FILE_ACCESS_ERROR: UErrorCode = UErrorCode(4i32);
9672 pub const U_INTERNAL_PROGRAM_ERROR: UErrorCode = UErrorCode(5i32);
9673 pub const U_MESSAGE_PARSE_ERROR: UErrorCode = UErrorCode(6i32);
9674 pub const U_MEMORY_ALLOCATION_ERROR: UErrorCode = UErrorCode(7i32);
9675 pub const U_INDEX_OUTOFBOUNDS_ERROR: UErrorCode = UErrorCode(8i32);
9676 pub const U_PARSE_ERROR: UErrorCode = UErrorCode(9i32);
9677 pub const U_INVALID_CHAR_FOUND: UErrorCode = UErrorCode(10i32);
9678 pub const U_TRUNCATED_CHAR_FOUND: UErrorCode = UErrorCode(11i32);
9679 pub const U_ILLEGAL_CHAR_FOUND: UErrorCode = UErrorCode(12i32);
9680 pub const U_INVALID_TABLE_FORMAT: UErrorCode = UErrorCode(13i32);
9681 pub const U_INVALID_TABLE_FILE: UErrorCode = UErrorCode(14i32);
9682 pub const U_BUFFER_OVERFLOW_ERROR: UErrorCode = UErrorCode(15i32);
9683 pub const U_UNSUPPORTED_ERROR: UErrorCode = UErrorCode(16i32);
9684 pub const U_RESOURCE_TYPE_MISMATCH: UErrorCode = UErrorCode(17i32);
9685 pub const U_ILLEGAL_ESCAPE_SEQUENCE: UErrorCode = UErrorCode(18i32);
9686 pub const U_UNSUPPORTED_ESCAPE_SEQUENCE: UErrorCode = UErrorCode(19i32);
9687 pub const U_NO_SPACE_AVAILABLE: UErrorCode = UErrorCode(20i32);
9688 pub const U_CE_NOT_FOUND_ERROR: UErrorCode = UErrorCode(21i32);
9689 pub const U_PRIMARY_TOO_LONG_ERROR: UErrorCode = UErrorCode(22i32);
9690 pub const U_STATE_TOO_OLD_ERROR: UErrorCode = UErrorCode(23i32);
9691 pub const U_TOO_MANY_ALIASES_ERROR: UErrorCode = UErrorCode(24i32);
9692 pub const U_ENUM_OUT_OF_SYNC_ERROR: UErrorCode = UErrorCode(25i32);
9693 pub const U_INVARIANT_CONVERSION_ERROR: UErrorCode = UErrorCode(26i32);
9694 pub const U_INVALID_STATE_ERROR: UErrorCode = UErrorCode(27i32);
9695 pub const U_COLLATOR_VERSION_MISMATCH: UErrorCode = UErrorCode(28i32);
9696 pub const U_USELESS_COLLATOR_ERROR: UErrorCode = UErrorCode(29i32);
9697 pub const U_NO_WRITE_PERMISSION: UErrorCode = UErrorCode(30i32);
9698 pub const U_BAD_VARIABLE_DEFINITION: UErrorCode = UErrorCode(65536i32);
9699 pub const U_PARSE_ERROR_START: UErrorCode = UErrorCode(65536i32);
9700 pub const U_MALFORMED_RULE: UErrorCode = UErrorCode(65537i32);
9701 pub const U_MALFORMED_SET: UErrorCode = UErrorCode(65538i32);
9702 pub const U_MALFORMED_SYMBOL_REFERENCE: UErrorCode = UErrorCode(65539i32);
9703 pub const U_MALFORMED_UNICODE_ESCAPE: UErrorCode = UErrorCode(65540i32);
9704 pub const U_MALFORMED_VARIABLE_DEFINITION: UErrorCode = UErrorCode(65541i32);
9705 pub const U_MALFORMED_VARIABLE_REFERENCE: UErrorCode = UErrorCode(65542i32);
9706 pub const U_MISMATCHED_SEGMENT_DELIMITERS: UErrorCode = UErrorCode(65543i32);
9707 pub const U_MISPLACED_ANCHOR_START: UErrorCode = UErrorCode(65544i32);
9708 pub const U_MISPLACED_CURSOR_OFFSET: UErrorCode = UErrorCode(65545i32);
9709 pub const U_MISPLACED_QUANTIFIER: UErrorCode = UErrorCode(65546i32);
9710 pub const U_MISSING_OPERATOR: UErrorCode = UErrorCode(65547i32);
9711 pub const U_MISSING_SEGMENT_CLOSE: UErrorCode = UErrorCode(65548i32);
9712 pub const U_MULTIPLE_ANTE_CONTEXTS: UErrorCode = UErrorCode(65549i32);
9713 pub const U_MULTIPLE_CURSORS: UErrorCode = UErrorCode(65550i32);
9714 pub const U_MULTIPLE_POST_CONTEXTS: UErrorCode = UErrorCode(65551i32);
9715 pub const U_TRAILING_BACKSLASH: UErrorCode = UErrorCode(65552i32);
9716 pub const U_UNDEFINED_SEGMENT_REFERENCE: UErrorCode = UErrorCode(65553i32);
9717 pub const U_UNDEFINED_VARIABLE: UErrorCode = UErrorCode(65554i32);
9718 pub const U_UNQUOTED_SPECIAL: UErrorCode = UErrorCode(65555i32);
9719 pub const U_UNTERMINATED_QUOTE: UErrorCode = UErrorCode(65556i32);
9720 pub const U_RULE_MASK_ERROR: UErrorCode = UErrorCode(65557i32);
9721 pub const U_MISPLACED_COMPOUND_FILTER: UErrorCode = UErrorCode(65558i32);
9722 pub const U_MULTIPLE_COMPOUND_FILTERS: UErrorCode = UErrorCode(65559i32);
9723 pub const U_INVALID_RBT_SYNTAX: UErrorCode = UErrorCode(65560i32);
9724 pub const U_INVALID_PROPERTY_PATTERN: UErrorCode = UErrorCode(65561i32);
9725 pub const U_MALFORMED_PRAGMA: UErrorCode = UErrorCode(65562i32);
9726 pub const U_UNCLOSED_SEGMENT: UErrorCode = UErrorCode(65563i32);
9727 pub const U_ILLEGAL_CHAR_IN_SEGMENT: UErrorCode = UErrorCode(65564i32);
9728 pub const U_VARIABLE_RANGE_EXHAUSTED: UErrorCode = UErrorCode(65565i32);
9729 pub const U_VARIABLE_RANGE_OVERLAP: UErrorCode = UErrorCode(65566i32);
9730 pub const U_ILLEGAL_CHARACTER: UErrorCode = UErrorCode(65567i32);
9731 pub const U_INTERNAL_TRANSLITERATOR_ERROR: UErrorCode = UErrorCode(65568i32);
9732 pub const U_INVALID_ID: UErrorCode = UErrorCode(65569i32);
9733 pub const U_INVALID_FUNCTION: UErrorCode = UErrorCode(65570i32);
9734 pub const U_UNEXPECTED_TOKEN: UErrorCode = UErrorCode(65792i32);
9735 pub const U_FMT_PARSE_ERROR_START: UErrorCode = UErrorCode(65792i32);
9736 pub const U_MULTIPLE_DECIMAL_SEPARATORS: UErrorCode = UErrorCode(65793i32);
9737 pub const U_MULTIPLE_DECIMAL_SEPERATORS: UErrorCode = UErrorCode(65793i32);
9738 pub const U_MULTIPLE_EXPONENTIAL_SYMBOLS: UErrorCode = UErrorCode(65794i32);
9739 pub const U_MALFORMED_EXPONENTIAL_PATTERN: UErrorCode = UErrorCode(65795i32);
9740 pub const U_MULTIPLE_PERCENT_SYMBOLS: UErrorCode = UErrorCode(65796i32);
9741 pub const U_MULTIPLE_PERMILL_SYMBOLS: UErrorCode = UErrorCode(65797i32);
9742 pub const U_MULTIPLE_PAD_SPECIFIERS: UErrorCode = UErrorCode(65798i32);
9743 pub const U_PATTERN_SYNTAX_ERROR: UErrorCode = UErrorCode(65799i32);
9744 pub const U_ILLEGAL_PAD_POSITION: UErrorCode = UErrorCode(65800i32);
9745 pub const U_UNMATCHED_BRACES: UErrorCode = UErrorCode(65801i32);
9746 pub const U_UNSUPPORTED_PROPERTY: UErrorCode = UErrorCode(65802i32);
9747 pub const U_UNSUPPORTED_ATTRIBUTE: UErrorCode = UErrorCode(65803i32);
9748 pub const U_ARGUMENT_TYPE_MISMATCH: UErrorCode = UErrorCode(65804i32);
9749 pub const U_DUPLICATE_KEYWORD: UErrorCode = UErrorCode(65805i32);
9750 pub const U_UNDEFINED_KEYWORD: UErrorCode = UErrorCode(65806i32);
9751 pub const U_DEFAULT_KEYWORD_MISSING: UErrorCode = UErrorCode(65807i32);
9752 pub const U_DECIMAL_NUMBER_SYNTAX_ERROR: UErrorCode = UErrorCode(65808i32);
9753 pub const U_FORMAT_INEXACT_ERROR: UErrorCode = UErrorCode(65809i32);
9754 pub const U_NUMBER_ARG_OUTOFBOUNDS_ERROR: UErrorCode = UErrorCode(65810i32);
9755 pub const U_NUMBER_SKELETON_SYNTAX_ERROR: UErrorCode = UErrorCode(65811i32);
9756 pub const U_BRK_INTERNAL_ERROR: UErrorCode = UErrorCode(66048i32);
9757 pub const U_BRK_ERROR_START: UErrorCode = UErrorCode(66048i32);
9758 pub const U_BRK_HEX_DIGITS_EXPECTED: UErrorCode = UErrorCode(66049i32);
9759 pub const U_BRK_SEMICOLON_EXPECTED: UErrorCode = UErrorCode(66050i32);
9760 pub const U_BRK_RULE_SYNTAX: UErrorCode = UErrorCode(66051i32);
9761 pub const U_BRK_UNCLOSED_SET: UErrorCode = UErrorCode(66052i32);
9762 pub const U_BRK_ASSIGN_ERROR: UErrorCode = UErrorCode(66053i32);
9763 pub const U_BRK_VARIABLE_REDFINITION: UErrorCode = UErrorCode(66054i32);
9764 pub const U_BRK_MISMATCHED_PAREN: UErrorCode = UErrorCode(66055i32);
9765 pub const U_BRK_NEW_LINE_IN_QUOTED_STRING: UErrorCode = UErrorCode(66056i32);
9766 pub const U_BRK_UNDEFINED_VARIABLE: UErrorCode = UErrorCode(66057i32);
9767 pub const U_BRK_INIT_ERROR: UErrorCode = UErrorCode(66058i32);
9768 pub const U_BRK_RULE_EMPTY_SET: UErrorCode = UErrorCode(66059i32);
9769 pub const U_BRK_UNRECOGNIZED_OPTION: UErrorCode = UErrorCode(66060i32);
9770 pub const U_BRK_MALFORMED_RULE_TAG: UErrorCode = UErrorCode(66061i32);
9771 pub const U_REGEX_INTERNAL_ERROR: UErrorCode = UErrorCode(66304i32);
9772 pub const U_REGEX_ERROR_START: UErrorCode = UErrorCode(66304i32);
9773 pub const U_REGEX_RULE_SYNTAX: UErrorCode = UErrorCode(66305i32);
9774 pub const U_REGEX_INVALID_STATE: UErrorCode = UErrorCode(66306i32);
9775 pub const U_REGEX_BAD_ESCAPE_SEQUENCE: UErrorCode = UErrorCode(66307i32);
9776 pub const U_REGEX_PROPERTY_SYNTAX: UErrorCode = UErrorCode(66308i32);
9777 pub const U_REGEX_UNIMPLEMENTED: UErrorCode = UErrorCode(66309i32);
9778 pub const U_REGEX_MISMATCHED_PAREN: UErrorCode = UErrorCode(66310i32);
9779 pub const U_REGEX_NUMBER_TOO_BIG: UErrorCode = UErrorCode(66311i32);
9780 pub const U_REGEX_BAD_INTERVAL: UErrorCode = UErrorCode(66312i32);
9781 pub const U_REGEX_MAX_LT_MIN: UErrorCode = UErrorCode(66313i32);
9782 pub const U_REGEX_INVALID_BACK_REF: UErrorCode = UErrorCode(66314i32);
9783 pub const U_REGEX_INVALID_FLAG: UErrorCode = UErrorCode(66315i32);
9784 pub const U_REGEX_LOOK_BEHIND_LIMIT: UErrorCode = UErrorCode(66316i32);
9785 pub const U_REGEX_SET_CONTAINS_STRING: UErrorCode = UErrorCode(66317i32);
9786 pub const U_REGEX_MISSING_CLOSE_BRACKET: UErrorCode = UErrorCode(66319i32);
9787 pub const U_REGEX_INVALID_RANGE: UErrorCode = UErrorCode(66320i32);
9788 pub const U_REGEX_STACK_OVERFLOW: UErrorCode = UErrorCode(66321i32);
9789 pub const U_REGEX_TIME_OUT: UErrorCode = UErrorCode(66322i32);
9790 pub const U_REGEX_STOPPED_BY_CALLER: UErrorCode = UErrorCode(66323i32);
9791 pub const U_REGEX_PATTERN_TOO_BIG: UErrorCode = UErrorCode(66324i32);
9792 pub const U_REGEX_INVALID_CAPTURE_GROUP_NAME: UErrorCode = UErrorCode(66325i32);
9793 pub const U_IDNA_PROHIBITED_ERROR: UErrorCode = UErrorCode(66560i32);
9794 pub const U_IDNA_ERROR_START: UErrorCode = UErrorCode(66560i32);
9795 pub const U_IDNA_UNASSIGNED_ERROR: UErrorCode = UErrorCode(66561i32);
9796 pub const U_IDNA_CHECK_BIDI_ERROR: UErrorCode = UErrorCode(66562i32);
9797 pub const U_IDNA_STD3_ASCII_RULES_ERROR: UErrorCode = UErrorCode(66563i32);
9798 pub const U_IDNA_ACE_PREFIX_ERROR: UErrorCode = UErrorCode(66564i32);
9799 pub const U_IDNA_VERIFICATION_ERROR: UErrorCode = UErrorCode(66565i32);
9800 pub const U_IDNA_LABEL_TOO_LONG_ERROR: UErrorCode = UErrorCode(66566i32);
9801 pub const U_IDNA_ZERO_LENGTH_LABEL_ERROR: UErrorCode = UErrorCode(66567i32);
9802 pub const U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR: UErrorCode = UErrorCode(66568i32);
9803 pub const U_STRINGPREP_PROHIBITED_ERROR: UErrorCode = UErrorCode(66560i32);
9804 pub const U_STRINGPREP_UNASSIGNED_ERROR: UErrorCode = UErrorCode(66561i32);
9805 pub const U_STRINGPREP_CHECK_BIDI_ERROR: UErrorCode = UErrorCode(66562i32);
9806 pub const U_PLUGIN_ERROR_START: UErrorCode = UErrorCode(66816i32);
9807 pub const U_PLUGIN_TOO_HIGH: UErrorCode = UErrorCode(66816i32);
9808 pub const U_PLUGIN_DIDNT_SET_LEVEL: UErrorCode = UErrorCode(66817i32);
9809 impl ::std::convert::From<i32> for UErrorCode {
from(value: i32) -> Self9810     fn from(value: i32) -> Self {
9811         Self(value)
9812     }
9813 }
9814 unsafe impl ::windows::runtime::Abi for UErrorCode {
9815     type Abi = Self;
9816     type DefaultType = Self;
9817 }
9818 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9819 #[repr(transparent)]
9820 pub struct UFieldCategory(pub i32);
9821 pub const UFIELD_CATEGORY_UNDEFINED: UFieldCategory = UFieldCategory(0i32);
9822 pub const UFIELD_CATEGORY_DATE: UFieldCategory = UFieldCategory(1i32);
9823 pub const UFIELD_CATEGORY_NUMBER: UFieldCategory = UFieldCategory(2i32);
9824 pub const UFIELD_CATEGORY_LIST: UFieldCategory = UFieldCategory(3i32);
9825 pub const UFIELD_CATEGORY_RELATIVE_DATETIME: UFieldCategory = UFieldCategory(4i32);
9826 pub const UFIELD_CATEGORY_DATE_INTERVAL: UFieldCategory = UFieldCategory(5i32);
9827 pub const UFIELD_CATEGORY_LIST_SPAN: UFieldCategory = UFieldCategory(4099i32);
9828 pub const UFIELD_CATEGORY_DATE_INTERVAL_SPAN: UFieldCategory = UFieldCategory(4101i32);
9829 impl ::std::convert::From<i32> for UFieldCategory {
from(value: i32) -> Self9830     fn from(value: i32) -> Self {
9831         Self(value)
9832     }
9833 }
9834 unsafe impl ::windows::runtime::Abi for UFieldCategory {
9835     type Abi = Self;
9836     type DefaultType = Self;
9837 }
9838 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9839 #[repr(C)]
9840 pub struct UFieldPosition {
9841     pub field: i32,
9842     pub beginIndex: i32,
9843     pub endIndex: i32,
9844 }
9845 impl UFieldPosition {}
9846 impl ::std::default::Default for UFieldPosition {
default() -> Self9847     fn default() -> Self {
9848         unsafe { ::std::mem::zeroed() }
9849     }
9850 }
9851 impl ::std::fmt::Debug for UFieldPosition {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9852     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9853         fmt.debug_struct("UFieldPosition").field("field", &self.field).field("beginIndex", &self.beginIndex).field("endIndex", &self.endIndex).finish()
9854     }
9855 }
9856 impl ::std::cmp::PartialEq for UFieldPosition {
eq(&self, other: &Self) -> bool9857     fn eq(&self, other: &Self) -> bool {
9858         self.field == other.field && self.beginIndex == other.beginIndex && self.endIndex == other.endIndex
9859     }
9860 }
9861 impl ::std::cmp::Eq for UFieldPosition {}
9862 unsafe impl ::windows::runtime::Abi for UFieldPosition {
9863     type Abi = Self;
9864     type DefaultType = Self;
9865 }
9866 #[repr(C)]
9867 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9868 pub struct UFieldPositionIterator(pub u8);
9869 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9870 #[repr(transparent)]
9871 pub struct UFormattableType(pub i32);
9872 pub const UFMT_DATE: UFormattableType = UFormattableType(0i32);
9873 pub const UFMT_DOUBLE: UFormattableType = UFormattableType(1i32);
9874 pub const UFMT_LONG: UFormattableType = UFormattableType(2i32);
9875 pub const UFMT_STRING: UFormattableType = UFormattableType(3i32);
9876 pub const UFMT_ARRAY: UFormattableType = UFormattableType(4i32);
9877 pub const UFMT_INT64: UFormattableType = UFormattableType(5i32);
9878 pub const UFMT_OBJECT: UFormattableType = UFormattableType(6i32);
9879 impl ::std::convert::From<i32> for UFormattableType {
from(value: i32) -> Self9880     fn from(value: i32) -> Self {
9881         Self(value)
9882     }
9883 }
9884 unsafe impl ::windows::runtime::Abi for UFormattableType {
9885     type Abi = Self;
9886     type DefaultType = Self;
9887 }
9888 #[repr(C)]
9889 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9890 pub struct UFormattedDateInterval(pub u8);
9891 #[repr(C)]
9892 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9893 pub struct UFormattedList(pub u8);
9894 #[repr(C)]
9895 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9896 pub struct UFormattedNumber(pub u8);
9897 #[repr(C)]
9898 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9899 pub struct UFormattedNumberRange(pub u8);
9900 #[repr(C)]
9901 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9902 pub struct UFormattedRelativeDateTime(pub u8);
9903 #[repr(C)]
9904 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9905 pub struct UFormattedValue(pub u8);
9906 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9907 #[repr(transparent)]
9908 pub struct UGender(pub i32);
9909 pub const UGENDER_MALE: UGender = UGender(0i32);
9910 pub const UGENDER_FEMALE: UGender = UGender(1i32);
9911 pub const UGENDER_OTHER: UGender = UGender(2i32);
9912 impl ::std::convert::From<i32> for UGender {
from(value: i32) -> Self9913     fn from(value: i32) -> Self {
9914         Self(value)
9915     }
9916 }
9917 unsafe impl ::windows::runtime::Abi for UGender {
9918     type Abi = Self;
9919     type DefaultType = Self;
9920 }
9921 #[repr(C)]
9922 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9923 pub struct UGenderInfo(pub u8);
9924 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9925 #[repr(transparent)]
9926 pub struct UGraphemeClusterBreak(pub i32);
9927 pub const U_GCB_OTHER: UGraphemeClusterBreak = UGraphemeClusterBreak(0i32);
9928 pub const U_GCB_CONTROL: UGraphemeClusterBreak = UGraphemeClusterBreak(1i32);
9929 pub const U_GCB_CR: UGraphemeClusterBreak = UGraphemeClusterBreak(2i32);
9930 pub const U_GCB_EXTEND: UGraphemeClusterBreak = UGraphemeClusterBreak(3i32);
9931 pub const U_GCB_L: UGraphemeClusterBreak = UGraphemeClusterBreak(4i32);
9932 pub const U_GCB_LF: UGraphemeClusterBreak = UGraphemeClusterBreak(5i32);
9933 pub const U_GCB_LV: UGraphemeClusterBreak = UGraphemeClusterBreak(6i32);
9934 pub const U_GCB_LVT: UGraphemeClusterBreak = UGraphemeClusterBreak(7i32);
9935 pub const U_GCB_T: UGraphemeClusterBreak = UGraphemeClusterBreak(8i32);
9936 pub const U_GCB_V: UGraphemeClusterBreak = UGraphemeClusterBreak(9i32);
9937 pub const U_GCB_SPACING_MARK: UGraphemeClusterBreak = UGraphemeClusterBreak(10i32);
9938 pub const U_GCB_PREPEND: UGraphemeClusterBreak = UGraphemeClusterBreak(11i32);
9939 pub const U_GCB_REGIONAL_INDICATOR: UGraphemeClusterBreak = UGraphemeClusterBreak(12i32);
9940 pub const U_GCB_E_BASE: UGraphemeClusterBreak = UGraphemeClusterBreak(13i32);
9941 pub const U_GCB_E_BASE_GAZ: UGraphemeClusterBreak = UGraphemeClusterBreak(14i32);
9942 pub const U_GCB_E_MODIFIER: UGraphemeClusterBreak = UGraphemeClusterBreak(15i32);
9943 pub const U_GCB_GLUE_AFTER_ZWJ: UGraphemeClusterBreak = UGraphemeClusterBreak(16i32);
9944 pub const U_GCB_ZWJ: UGraphemeClusterBreak = UGraphemeClusterBreak(17i32);
9945 impl ::std::convert::From<i32> for UGraphemeClusterBreak {
from(value: i32) -> Self9946     fn from(value: i32) -> Self {
9947         Self(value)
9948     }
9949 }
9950 unsafe impl ::windows::runtime::Abi for UGraphemeClusterBreak {
9951     type Abi = Self;
9952     type DefaultType = Self;
9953 }
9954 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
9955 #[repr(transparent)]
9956 pub struct UHangulSyllableType(pub i32);
9957 pub const U_HST_NOT_APPLICABLE: UHangulSyllableType = UHangulSyllableType(0i32);
9958 pub const U_HST_LEADING_JAMO: UHangulSyllableType = UHangulSyllableType(1i32);
9959 pub const U_HST_VOWEL_JAMO: UHangulSyllableType = UHangulSyllableType(2i32);
9960 pub const U_HST_TRAILING_JAMO: UHangulSyllableType = UHangulSyllableType(3i32);
9961 pub const U_HST_LV_SYLLABLE: UHangulSyllableType = UHangulSyllableType(4i32);
9962 pub const U_HST_LVT_SYLLABLE: UHangulSyllableType = UHangulSyllableType(5i32);
9963 impl ::std::convert::From<i32> for UHangulSyllableType {
from(value: i32) -> Self9964     fn from(value: i32) -> Self {
9965         Self(value)
9966     }
9967 }
9968 unsafe impl ::windows::runtime::Abi for UHangulSyllableType {
9969     type Abi = Self;
9970     type DefaultType = Self;
9971 }
9972 #[repr(C)]
9973 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9974 pub struct UHashtable(pub u8);
9975 #[repr(C)]
9976 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
9977 pub struct UIDNA(pub u8);
9978 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
9979 #[repr(C)]
9980 pub struct UIDNAInfo {
9981     pub size: i16,
9982     pub isTransitionalDifferent: i8,
9983     pub reservedB3: i8,
9984     pub errors: u32,
9985     pub reservedI2: i32,
9986     pub reservedI3: i32,
9987 }
9988 impl UIDNAInfo {}
9989 impl ::std::default::Default for UIDNAInfo {
default() -> Self9990     fn default() -> Self {
9991         unsafe { ::std::mem::zeroed() }
9992     }
9993 }
9994 impl ::std::fmt::Debug for UIDNAInfo {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result9995     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9996         fmt.debug_struct("UIDNAInfo").field("size", &self.size).field("isTransitionalDifferent", &self.isTransitionalDifferent).field("reservedB3", &self.reservedB3).field("errors", &self.errors).field("reservedI2", &self.reservedI2).field("reservedI3", &self.reservedI3).finish()
9997     }
9998 }
9999 impl ::std::cmp::PartialEq for UIDNAInfo {
eq(&self, other: &Self) -> bool10000     fn eq(&self, other: &Self) -> bool {
10001         self.size == other.size && self.isTransitionalDifferent == other.isTransitionalDifferent && self.reservedB3 == other.reservedB3 && self.errors == other.errors && self.reservedI2 == other.reservedI2 && self.reservedI3 == other.reservedI3
10002     }
10003 }
10004 impl ::std::cmp::Eq for UIDNAInfo {}
10005 unsafe impl ::windows::runtime::Abi for UIDNAInfo {
10006     type Abi = Self;
10007     type DefaultType = Self;
10008 }
10009 pub const UIDNA_CHECK_BIDI: i32 = 4i32;
10010 pub const UIDNA_CHECK_CONTEXTJ: i32 = 8i32;
10011 pub const UIDNA_CHECK_CONTEXTO: i32 = 64i32;
10012 pub const UIDNA_DEFAULT: i32 = 0i32;
10013 pub const UIDNA_ERROR_BIDI: i32 = 2048i32;
10014 pub const UIDNA_ERROR_CONTEXTJ: i32 = 4096i32;
10015 pub const UIDNA_ERROR_CONTEXTO_DIGITS: i32 = 16384i32;
10016 pub const UIDNA_ERROR_CONTEXTO_PUNCTUATION: i32 = 8192i32;
10017 pub const UIDNA_ERROR_DISALLOWED: i32 = 128i32;
10018 pub const UIDNA_ERROR_DOMAIN_NAME_TOO_LONG: i32 = 4i32;
10019 pub const UIDNA_ERROR_EMPTY_LABEL: i32 = 1i32;
10020 pub const UIDNA_ERROR_HYPHEN_3_4: i32 = 32i32;
10021 pub const UIDNA_ERROR_INVALID_ACE_LABEL: i32 = 1024i32;
10022 pub const UIDNA_ERROR_LABEL_HAS_DOT: i32 = 512i32;
10023 pub const UIDNA_ERROR_LABEL_TOO_LONG: i32 = 2i32;
10024 pub const UIDNA_ERROR_LEADING_COMBINING_MARK: i32 = 64i32;
10025 pub const UIDNA_ERROR_LEADING_HYPHEN: i32 = 8i32;
10026 pub const UIDNA_ERROR_PUNYCODE: i32 = 256i32;
10027 pub const UIDNA_ERROR_TRAILING_HYPHEN: i32 = 16i32;
10028 pub const UIDNA_NONTRANSITIONAL_TO_ASCII: i32 = 16i32;
10029 pub const UIDNA_NONTRANSITIONAL_TO_UNICODE: i32 = 32i32;
10030 pub const UIDNA_USE_STD3_RULES: i32 = 2i32;
10031 #[cfg(feature = "Win32_Foundation")]
10032 pub type UILANGUAGE_ENUMPROCA = unsafe extern "system" fn(param0: super::Foundation::PSTR, param1: isize) -> super::Foundation::BOOL;
10033 #[cfg(feature = "Win32_Foundation")]
10034 pub type UILANGUAGE_ENUMPROCW = unsafe extern "system" fn(param0: super::Foundation::PWSTR, param1: isize) -> super::Foundation::BOOL;
10035 pub const UITER_UNKNOWN_INDEX: i32 = -2i32;
10036 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10037 #[repr(transparent)]
10038 pub struct UIndicPositionalCategory(pub i32);
10039 pub const U_INPC_NA: UIndicPositionalCategory = UIndicPositionalCategory(0i32);
10040 pub const U_INPC_BOTTOM: UIndicPositionalCategory = UIndicPositionalCategory(1i32);
10041 pub const U_INPC_BOTTOM_AND_LEFT: UIndicPositionalCategory = UIndicPositionalCategory(2i32);
10042 pub const U_INPC_BOTTOM_AND_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(3i32);
10043 pub const U_INPC_LEFT: UIndicPositionalCategory = UIndicPositionalCategory(4i32);
10044 pub const U_INPC_LEFT_AND_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(5i32);
10045 pub const U_INPC_OVERSTRUCK: UIndicPositionalCategory = UIndicPositionalCategory(6i32);
10046 pub const U_INPC_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(7i32);
10047 pub const U_INPC_TOP: UIndicPositionalCategory = UIndicPositionalCategory(8i32);
10048 pub const U_INPC_TOP_AND_BOTTOM: UIndicPositionalCategory = UIndicPositionalCategory(9i32);
10049 pub const U_INPC_TOP_AND_BOTTOM_AND_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(10i32);
10050 pub const U_INPC_TOP_AND_LEFT: UIndicPositionalCategory = UIndicPositionalCategory(11i32);
10051 pub const U_INPC_TOP_AND_LEFT_AND_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(12i32);
10052 pub const U_INPC_TOP_AND_RIGHT: UIndicPositionalCategory = UIndicPositionalCategory(13i32);
10053 pub const U_INPC_VISUAL_ORDER_LEFT: UIndicPositionalCategory = UIndicPositionalCategory(14i32);
10054 pub const U_INPC_TOP_AND_BOTTOM_AND_LEFT: UIndicPositionalCategory = UIndicPositionalCategory(15i32);
10055 impl ::std::convert::From<i32> for UIndicPositionalCategory {
from(value: i32) -> Self10056     fn from(value: i32) -> Self {
10057         Self(value)
10058     }
10059 }
10060 unsafe impl ::windows::runtime::Abi for UIndicPositionalCategory {
10061     type Abi = Self;
10062     type DefaultType = Self;
10063 }
10064 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10065 #[repr(transparent)]
10066 pub struct UIndicSyllabicCategory(pub i32);
10067 pub const U_INSC_OTHER: UIndicSyllabicCategory = UIndicSyllabicCategory(0i32);
10068 pub const U_INSC_AVAGRAHA: UIndicSyllabicCategory = UIndicSyllabicCategory(1i32);
10069 pub const U_INSC_BINDU: UIndicSyllabicCategory = UIndicSyllabicCategory(2i32);
10070 pub const U_INSC_BRAHMI_JOINING_NUMBER: UIndicSyllabicCategory = UIndicSyllabicCategory(3i32);
10071 pub const U_INSC_CANTILLATION_MARK: UIndicSyllabicCategory = UIndicSyllabicCategory(4i32);
10072 pub const U_INSC_CONSONANT: UIndicSyllabicCategory = UIndicSyllabicCategory(5i32);
10073 pub const U_INSC_CONSONANT_DEAD: UIndicSyllabicCategory = UIndicSyllabicCategory(6i32);
10074 pub const U_INSC_CONSONANT_FINAL: UIndicSyllabicCategory = UIndicSyllabicCategory(7i32);
10075 pub const U_INSC_CONSONANT_HEAD_LETTER: UIndicSyllabicCategory = UIndicSyllabicCategory(8i32);
10076 pub const U_INSC_CONSONANT_INITIAL_POSTFIXED: UIndicSyllabicCategory = UIndicSyllabicCategory(9i32);
10077 pub const U_INSC_CONSONANT_KILLER: UIndicSyllabicCategory = UIndicSyllabicCategory(10i32);
10078 pub const U_INSC_CONSONANT_MEDIAL: UIndicSyllabicCategory = UIndicSyllabicCategory(11i32);
10079 pub const U_INSC_CONSONANT_PLACEHOLDER: UIndicSyllabicCategory = UIndicSyllabicCategory(12i32);
10080 pub const U_INSC_CONSONANT_PRECEDING_REPHA: UIndicSyllabicCategory = UIndicSyllabicCategory(13i32);
10081 pub const U_INSC_CONSONANT_PREFIXED: UIndicSyllabicCategory = UIndicSyllabicCategory(14i32);
10082 pub const U_INSC_CONSONANT_SUBJOINED: UIndicSyllabicCategory = UIndicSyllabicCategory(15i32);
10083 pub const U_INSC_CONSONANT_SUCCEEDING_REPHA: UIndicSyllabicCategory = UIndicSyllabicCategory(16i32);
10084 pub const U_INSC_CONSONANT_WITH_STACKER: UIndicSyllabicCategory = UIndicSyllabicCategory(17i32);
10085 pub const U_INSC_GEMINATION_MARK: UIndicSyllabicCategory = UIndicSyllabicCategory(18i32);
10086 pub const U_INSC_INVISIBLE_STACKER: UIndicSyllabicCategory = UIndicSyllabicCategory(19i32);
10087 pub const U_INSC_JOINER: UIndicSyllabicCategory = UIndicSyllabicCategory(20i32);
10088 pub const U_INSC_MODIFYING_LETTER: UIndicSyllabicCategory = UIndicSyllabicCategory(21i32);
10089 pub const U_INSC_NON_JOINER: UIndicSyllabicCategory = UIndicSyllabicCategory(22i32);
10090 pub const U_INSC_NUKTA: UIndicSyllabicCategory = UIndicSyllabicCategory(23i32);
10091 pub const U_INSC_NUMBER: UIndicSyllabicCategory = UIndicSyllabicCategory(24i32);
10092 pub const U_INSC_NUMBER_JOINER: UIndicSyllabicCategory = UIndicSyllabicCategory(25i32);
10093 pub const U_INSC_PURE_KILLER: UIndicSyllabicCategory = UIndicSyllabicCategory(26i32);
10094 pub const U_INSC_REGISTER_SHIFTER: UIndicSyllabicCategory = UIndicSyllabicCategory(27i32);
10095 pub const U_INSC_SYLLABLE_MODIFIER: UIndicSyllabicCategory = UIndicSyllabicCategory(28i32);
10096 pub const U_INSC_TONE_LETTER: UIndicSyllabicCategory = UIndicSyllabicCategory(29i32);
10097 pub const U_INSC_TONE_MARK: UIndicSyllabicCategory = UIndicSyllabicCategory(30i32);
10098 pub const U_INSC_VIRAMA: UIndicSyllabicCategory = UIndicSyllabicCategory(31i32);
10099 pub const U_INSC_VISARGA: UIndicSyllabicCategory = UIndicSyllabicCategory(32i32);
10100 pub const U_INSC_VOWEL: UIndicSyllabicCategory = UIndicSyllabicCategory(33i32);
10101 pub const U_INSC_VOWEL_DEPENDENT: UIndicSyllabicCategory = UIndicSyllabicCategory(34i32);
10102 pub const U_INSC_VOWEL_INDEPENDENT: UIndicSyllabicCategory = UIndicSyllabicCategory(35i32);
10103 impl ::std::convert::From<i32> for UIndicSyllabicCategory {
from(value: i32) -> Self10104     fn from(value: i32) -> Self {
10105         Self(value)
10106     }
10107 }
10108 unsafe impl ::windows::runtime::Abi for UIndicSyllabicCategory {
10109     type Abi = Self;
10110     type DefaultType = Self;
10111 }
10112 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10113 #[repr(transparent)]
10114 pub struct UJoiningGroup(pub i32);
10115 pub const U_JG_NO_JOINING_GROUP: UJoiningGroup = UJoiningGroup(0i32);
10116 pub const U_JG_AIN: UJoiningGroup = UJoiningGroup(1i32);
10117 pub const U_JG_ALAPH: UJoiningGroup = UJoiningGroup(2i32);
10118 pub const U_JG_ALEF: UJoiningGroup = UJoiningGroup(3i32);
10119 pub const U_JG_BEH: UJoiningGroup = UJoiningGroup(4i32);
10120 pub const U_JG_BETH: UJoiningGroup = UJoiningGroup(5i32);
10121 pub const U_JG_DAL: UJoiningGroup = UJoiningGroup(6i32);
10122 pub const U_JG_DALATH_RISH: UJoiningGroup = UJoiningGroup(7i32);
10123 pub const U_JG_E: UJoiningGroup = UJoiningGroup(8i32);
10124 pub const U_JG_FEH: UJoiningGroup = UJoiningGroup(9i32);
10125 pub const U_JG_FINAL_SEMKATH: UJoiningGroup = UJoiningGroup(10i32);
10126 pub const U_JG_GAF: UJoiningGroup = UJoiningGroup(11i32);
10127 pub const U_JG_GAMAL: UJoiningGroup = UJoiningGroup(12i32);
10128 pub const U_JG_HAH: UJoiningGroup = UJoiningGroup(13i32);
10129 pub const U_JG_TEH_MARBUTA_GOAL: UJoiningGroup = UJoiningGroup(14i32);
10130 pub const U_JG_HAMZA_ON_HEH_GOAL: UJoiningGroup = UJoiningGroup(14i32);
10131 pub const U_JG_HE: UJoiningGroup = UJoiningGroup(15i32);
10132 pub const U_JG_HEH: UJoiningGroup = UJoiningGroup(16i32);
10133 pub const U_JG_HEH_GOAL: UJoiningGroup = UJoiningGroup(17i32);
10134 pub const U_JG_HETH: UJoiningGroup = UJoiningGroup(18i32);
10135 pub const U_JG_KAF: UJoiningGroup = UJoiningGroup(19i32);
10136 pub const U_JG_KAPH: UJoiningGroup = UJoiningGroup(20i32);
10137 pub const U_JG_KNOTTED_HEH: UJoiningGroup = UJoiningGroup(21i32);
10138 pub const U_JG_LAM: UJoiningGroup = UJoiningGroup(22i32);
10139 pub const U_JG_LAMADH: UJoiningGroup = UJoiningGroup(23i32);
10140 pub const U_JG_MEEM: UJoiningGroup = UJoiningGroup(24i32);
10141 pub const U_JG_MIM: UJoiningGroup = UJoiningGroup(25i32);
10142 pub const U_JG_NOON: UJoiningGroup = UJoiningGroup(26i32);
10143 pub const U_JG_NUN: UJoiningGroup = UJoiningGroup(27i32);
10144 pub const U_JG_PE: UJoiningGroup = UJoiningGroup(28i32);
10145 pub const U_JG_QAF: UJoiningGroup = UJoiningGroup(29i32);
10146 pub const U_JG_QAPH: UJoiningGroup = UJoiningGroup(30i32);
10147 pub const U_JG_REH: UJoiningGroup = UJoiningGroup(31i32);
10148 pub const U_JG_REVERSED_PE: UJoiningGroup = UJoiningGroup(32i32);
10149 pub const U_JG_SAD: UJoiningGroup = UJoiningGroup(33i32);
10150 pub const U_JG_SADHE: UJoiningGroup = UJoiningGroup(34i32);
10151 pub const U_JG_SEEN: UJoiningGroup = UJoiningGroup(35i32);
10152 pub const U_JG_SEMKATH: UJoiningGroup = UJoiningGroup(36i32);
10153 pub const U_JG_SHIN: UJoiningGroup = UJoiningGroup(37i32);
10154 pub const U_JG_SWASH_KAF: UJoiningGroup = UJoiningGroup(38i32);
10155 pub const U_JG_SYRIAC_WAW: UJoiningGroup = UJoiningGroup(39i32);
10156 pub const U_JG_TAH: UJoiningGroup = UJoiningGroup(40i32);
10157 pub const U_JG_TAW: UJoiningGroup = UJoiningGroup(41i32);
10158 pub const U_JG_TEH_MARBUTA: UJoiningGroup = UJoiningGroup(42i32);
10159 pub const U_JG_TETH: UJoiningGroup = UJoiningGroup(43i32);
10160 pub const U_JG_WAW: UJoiningGroup = UJoiningGroup(44i32);
10161 pub const U_JG_YEH: UJoiningGroup = UJoiningGroup(45i32);
10162 pub const U_JG_YEH_BARREE: UJoiningGroup = UJoiningGroup(46i32);
10163 pub const U_JG_YEH_WITH_TAIL: UJoiningGroup = UJoiningGroup(47i32);
10164 pub const U_JG_YUDH: UJoiningGroup = UJoiningGroup(48i32);
10165 pub const U_JG_YUDH_HE: UJoiningGroup = UJoiningGroup(49i32);
10166 pub const U_JG_ZAIN: UJoiningGroup = UJoiningGroup(50i32);
10167 pub const U_JG_FE: UJoiningGroup = UJoiningGroup(51i32);
10168 pub const U_JG_KHAPH: UJoiningGroup = UJoiningGroup(52i32);
10169 pub const U_JG_ZHAIN: UJoiningGroup = UJoiningGroup(53i32);
10170 pub const U_JG_BURUSHASKI_YEH_BARREE: UJoiningGroup = UJoiningGroup(54i32);
10171 pub const U_JG_FARSI_YEH: UJoiningGroup = UJoiningGroup(55i32);
10172 pub const U_JG_NYA: UJoiningGroup = UJoiningGroup(56i32);
10173 pub const U_JG_ROHINGYA_YEH: UJoiningGroup = UJoiningGroup(57i32);
10174 pub const U_JG_MANICHAEAN_ALEPH: UJoiningGroup = UJoiningGroup(58i32);
10175 pub const U_JG_MANICHAEAN_AYIN: UJoiningGroup = UJoiningGroup(59i32);
10176 pub const U_JG_MANICHAEAN_BETH: UJoiningGroup = UJoiningGroup(60i32);
10177 pub const U_JG_MANICHAEAN_DALETH: UJoiningGroup = UJoiningGroup(61i32);
10178 pub const U_JG_MANICHAEAN_DHAMEDH: UJoiningGroup = UJoiningGroup(62i32);
10179 pub const U_JG_MANICHAEAN_FIVE: UJoiningGroup = UJoiningGroup(63i32);
10180 pub const U_JG_MANICHAEAN_GIMEL: UJoiningGroup = UJoiningGroup(64i32);
10181 pub const U_JG_MANICHAEAN_HETH: UJoiningGroup = UJoiningGroup(65i32);
10182 pub const U_JG_MANICHAEAN_HUNDRED: UJoiningGroup = UJoiningGroup(66i32);
10183 pub const U_JG_MANICHAEAN_KAPH: UJoiningGroup = UJoiningGroup(67i32);
10184 pub const U_JG_MANICHAEAN_LAMEDH: UJoiningGroup = UJoiningGroup(68i32);
10185 pub const U_JG_MANICHAEAN_MEM: UJoiningGroup = UJoiningGroup(69i32);
10186 pub const U_JG_MANICHAEAN_NUN: UJoiningGroup = UJoiningGroup(70i32);
10187 pub const U_JG_MANICHAEAN_ONE: UJoiningGroup = UJoiningGroup(71i32);
10188 pub const U_JG_MANICHAEAN_PE: UJoiningGroup = UJoiningGroup(72i32);
10189 pub const U_JG_MANICHAEAN_QOPH: UJoiningGroup = UJoiningGroup(73i32);
10190 pub const U_JG_MANICHAEAN_RESH: UJoiningGroup = UJoiningGroup(74i32);
10191 pub const U_JG_MANICHAEAN_SADHE: UJoiningGroup = UJoiningGroup(75i32);
10192 pub const U_JG_MANICHAEAN_SAMEKH: UJoiningGroup = UJoiningGroup(76i32);
10193 pub const U_JG_MANICHAEAN_TAW: UJoiningGroup = UJoiningGroup(77i32);
10194 pub const U_JG_MANICHAEAN_TEN: UJoiningGroup = UJoiningGroup(78i32);
10195 pub const U_JG_MANICHAEAN_TETH: UJoiningGroup = UJoiningGroup(79i32);
10196 pub const U_JG_MANICHAEAN_THAMEDH: UJoiningGroup = UJoiningGroup(80i32);
10197 pub const U_JG_MANICHAEAN_TWENTY: UJoiningGroup = UJoiningGroup(81i32);
10198 pub const U_JG_MANICHAEAN_WAW: UJoiningGroup = UJoiningGroup(82i32);
10199 pub const U_JG_MANICHAEAN_YODH: UJoiningGroup = UJoiningGroup(83i32);
10200 pub const U_JG_MANICHAEAN_ZAYIN: UJoiningGroup = UJoiningGroup(84i32);
10201 pub const U_JG_STRAIGHT_WAW: UJoiningGroup = UJoiningGroup(85i32);
10202 pub const U_JG_AFRICAN_FEH: UJoiningGroup = UJoiningGroup(86i32);
10203 pub const U_JG_AFRICAN_NOON: UJoiningGroup = UJoiningGroup(87i32);
10204 pub const U_JG_AFRICAN_QAF: UJoiningGroup = UJoiningGroup(88i32);
10205 pub const U_JG_MALAYALAM_BHA: UJoiningGroup = UJoiningGroup(89i32);
10206 pub const U_JG_MALAYALAM_JA: UJoiningGroup = UJoiningGroup(90i32);
10207 pub const U_JG_MALAYALAM_LLA: UJoiningGroup = UJoiningGroup(91i32);
10208 pub const U_JG_MALAYALAM_LLLA: UJoiningGroup = UJoiningGroup(92i32);
10209 pub const U_JG_MALAYALAM_NGA: UJoiningGroup = UJoiningGroup(93i32);
10210 pub const U_JG_MALAYALAM_NNA: UJoiningGroup = UJoiningGroup(94i32);
10211 pub const U_JG_MALAYALAM_NNNA: UJoiningGroup = UJoiningGroup(95i32);
10212 pub const U_JG_MALAYALAM_NYA: UJoiningGroup = UJoiningGroup(96i32);
10213 pub const U_JG_MALAYALAM_RA: UJoiningGroup = UJoiningGroup(97i32);
10214 pub const U_JG_MALAYALAM_SSA: UJoiningGroup = UJoiningGroup(98i32);
10215 pub const U_JG_MALAYALAM_TTA: UJoiningGroup = UJoiningGroup(99i32);
10216 pub const U_JG_HANIFI_ROHINGYA_KINNA_YA: UJoiningGroup = UJoiningGroup(100i32);
10217 pub const U_JG_HANIFI_ROHINGYA_PA: UJoiningGroup = UJoiningGroup(101i32);
10218 impl ::std::convert::From<i32> for UJoiningGroup {
from(value: i32) -> Self10219     fn from(value: i32) -> Self {
10220         Self(value)
10221     }
10222 }
10223 unsafe impl ::windows::runtime::Abi for UJoiningGroup {
10224     type Abi = Self;
10225     type DefaultType = Self;
10226 }
10227 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10228 #[repr(transparent)]
10229 pub struct UJoiningType(pub i32);
10230 pub const U_JT_NON_JOINING: UJoiningType = UJoiningType(0i32);
10231 pub const U_JT_JOIN_CAUSING: UJoiningType = UJoiningType(1i32);
10232 pub const U_JT_DUAL_JOINING: UJoiningType = UJoiningType(2i32);
10233 pub const U_JT_LEFT_JOINING: UJoiningType = UJoiningType(3i32);
10234 pub const U_JT_RIGHT_JOINING: UJoiningType = UJoiningType(4i32);
10235 pub const U_JT_TRANSPARENT: UJoiningType = UJoiningType(5i32);
10236 impl ::std::convert::From<i32> for UJoiningType {
from(value: i32) -> Self10237     fn from(value: i32) -> Self {
10238         Self(value)
10239     }
10240 }
10241 unsafe impl ::windows::runtime::Abi for UJoiningType {
10242     type Abi = Self;
10243     type DefaultType = Self;
10244 }
10245 pub const ULOC_COUNTRY_CAPACITY: u32 = 4u32;
10246 pub const ULOC_FULLNAME_CAPACITY: u32 = 157u32;
10247 pub const ULOC_KEYWORDS_CAPACITY: u32 = 96u32;
10248 pub const ULOC_KEYWORD_AND_VALUES_CAPACITY: u32 = 100u32;
10249 pub const ULOC_KEYWORD_ASSIGN_UNICODE: u32 = 61u32;
10250 pub const ULOC_KEYWORD_ITEM_SEPARATOR_UNICODE: u32 = 59u32;
10251 pub const ULOC_KEYWORD_SEPARATOR_UNICODE: u32 = 64u32;
10252 pub const ULOC_LANG_CAPACITY: u32 = 12u32;
10253 pub const ULOC_SCRIPT_CAPACITY: u32 = 6u32;
10254 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10255 #[repr(transparent)]
10256 pub struct ULayoutType(pub i32);
10257 pub const ULOC_LAYOUT_LTR: ULayoutType = ULayoutType(0i32);
10258 pub const ULOC_LAYOUT_RTL: ULayoutType = ULayoutType(1i32);
10259 pub const ULOC_LAYOUT_TTB: ULayoutType = ULayoutType(2i32);
10260 pub const ULOC_LAYOUT_BTT: ULayoutType = ULayoutType(3i32);
10261 pub const ULOC_LAYOUT_UNKNOWN: ULayoutType = ULayoutType(4i32);
10262 impl ::std::convert::From<i32> for ULayoutType {
from(value: i32) -> Self10263     fn from(value: i32) -> Self {
10264         Self(value)
10265     }
10266 }
10267 unsafe impl ::windows::runtime::Abi for ULayoutType {
10268     type Abi = Self;
10269     type DefaultType = Self;
10270 }
10271 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10272 #[repr(transparent)]
10273 pub struct ULineBreak(pub i32);
10274 pub const U_LB_UNKNOWN: ULineBreak = ULineBreak(0i32);
10275 pub const U_LB_AMBIGUOUS: ULineBreak = ULineBreak(1i32);
10276 pub const U_LB_ALPHABETIC: ULineBreak = ULineBreak(2i32);
10277 pub const U_LB_BREAK_BOTH: ULineBreak = ULineBreak(3i32);
10278 pub const U_LB_BREAK_AFTER: ULineBreak = ULineBreak(4i32);
10279 pub const U_LB_BREAK_BEFORE: ULineBreak = ULineBreak(5i32);
10280 pub const U_LB_MANDATORY_BREAK: ULineBreak = ULineBreak(6i32);
10281 pub const U_LB_CONTINGENT_BREAK: ULineBreak = ULineBreak(7i32);
10282 pub const U_LB_CLOSE_PUNCTUATION: ULineBreak = ULineBreak(8i32);
10283 pub const U_LB_COMBINING_MARK: ULineBreak = ULineBreak(9i32);
10284 pub const U_LB_CARRIAGE_RETURN: ULineBreak = ULineBreak(10i32);
10285 pub const U_LB_EXCLAMATION: ULineBreak = ULineBreak(11i32);
10286 pub const U_LB_GLUE: ULineBreak = ULineBreak(12i32);
10287 pub const U_LB_HYPHEN: ULineBreak = ULineBreak(13i32);
10288 pub const U_LB_IDEOGRAPHIC: ULineBreak = ULineBreak(14i32);
10289 pub const U_LB_INSEPARABLE: ULineBreak = ULineBreak(15i32);
10290 pub const U_LB_INSEPERABLE: ULineBreak = ULineBreak(15i32);
10291 pub const U_LB_INFIX_NUMERIC: ULineBreak = ULineBreak(16i32);
10292 pub const U_LB_LINE_FEED: ULineBreak = ULineBreak(17i32);
10293 pub const U_LB_NONSTARTER: ULineBreak = ULineBreak(18i32);
10294 pub const U_LB_NUMERIC: ULineBreak = ULineBreak(19i32);
10295 pub const U_LB_OPEN_PUNCTUATION: ULineBreak = ULineBreak(20i32);
10296 pub const U_LB_POSTFIX_NUMERIC: ULineBreak = ULineBreak(21i32);
10297 pub const U_LB_PREFIX_NUMERIC: ULineBreak = ULineBreak(22i32);
10298 pub const U_LB_QUOTATION: ULineBreak = ULineBreak(23i32);
10299 pub const U_LB_COMPLEX_CONTEXT: ULineBreak = ULineBreak(24i32);
10300 pub const U_LB_SURROGATE: ULineBreak = ULineBreak(25i32);
10301 pub const U_LB_SPACE: ULineBreak = ULineBreak(26i32);
10302 pub const U_LB_BREAK_SYMBOLS: ULineBreak = ULineBreak(27i32);
10303 pub const U_LB_ZWSPACE: ULineBreak = ULineBreak(28i32);
10304 pub const U_LB_NEXT_LINE: ULineBreak = ULineBreak(29i32);
10305 pub const U_LB_WORD_JOINER: ULineBreak = ULineBreak(30i32);
10306 pub const U_LB_H2: ULineBreak = ULineBreak(31i32);
10307 pub const U_LB_H3: ULineBreak = ULineBreak(32i32);
10308 pub const U_LB_JL: ULineBreak = ULineBreak(33i32);
10309 pub const U_LB_JT: ULineBreak = ULineBreak(34i32);
10310 pub const U_LB_JV: ULineBreak = ULineBreak(35i32);
10311 pub const U_LB_CLOSE_PARENTHESIS: ULineBreak = ULineBreak(36i32);
10312 pub const U_LB_CONDITIONAL_JAPANESE_STARTER: ULineBreak = ULineBreak(37i32);
10313 pub const U_LB_HEBREW_LETTER: ULineBreak = ULineBreak(38i32);
10314 pub const U_LB_REGIONAL_INDICATOR: ULineBreak = ULineBreak(39i32);
10315 pub const U_LB_E_BASE: ULineBreak = ULineBreak(40i32);
10316 pub const U_LB_E_MODIFIER: ULineBreak = ULineBreak(41i32);
10317 pub const U_LB_ZWJ: ULineBreak = ULineBreak(42i32);
10318 impl ::std::convert::From<i32> for ULineBreak {
from(value: i32) -> Self10319     fn from(value: i32) -> Self {
10320         Self(value)
10321     }
10322 }
10323 unsafe impl ::windows::runtime::Abi for ULineBreak {
10324     type Abi = Self;
10325     type DefaultType = Self;
10326 }
10327 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10328 #[repr(transparent)]
10329 pub struct ULineBreakTag(pub i32);
10330 pub const UBRK_LINE_SOFT: ULineBreakTag = ULineBreakTag(0i32);
10331 pub const UBRK_LINE_SOFT_LIMIT: ULineBreakTag = ULineBreakTag(100i32);
10332 pub const UBRK_LINE_HARD: ULineBreakTag = ULineBreakTag(100i32);
10333 pub const UBRK_LINE_HARD_LIMIT: ULineBreakTag = ULineBreakTag(200i32);
10334 impl ::std::convert::From<i32> for ULineBreakTag {
from(value: i32) -> Self10335     fn from(value: i32) -> Self {
10336         Self(value)
10337     }
10338 }
10339 unsafe impl ::windows::runtime::Abi for ULineBreakTag {
10340     type Abi = Self;
10341     type DefaultType = Self;
10342 }
10343 #[repr(C)]
10344 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10345 pub struct UListFormatter(pub u8);
10346 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10347 #[repr(transparent)]
10348 pub struct UListFormatterField(pub i32);
10349 pub const ULISTFMT_LITERAL_FIELD: UListFormatterField = UListFormatterField(0i32);
10350 pub const ULISTFMT_ELEMENT_FIELD: UListFormatterField = UListFormatterField(1i32);
10351 impl ::std::convert::From<i32> for UListFormatterField {
from(value: i32) -> Self10352     fn from(value: i32) -> Self {
10353         Self(value)
10354     }
10355 }
10356 unsafe impl ::windows::runtime::Abi for UListFormatterField {
10357     type Abi = Self;
10358     type DefaultType = Self;
10359 }
10360 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10361 #[repr(transparent)]
10362 pub struct UListFormatterType(pub i32);
10363 pub const ULISTFMT_TYPE_AND: UListFormatterType = UListFormatterType(0i32);
10364 pub const ULISTFMT_TYPE_OR: UListFormatterType = UListFormatterType(1i32);
10365 pub const ULISTFMT_TYPE_UNITS: UListFormatterType = UListFormatterType(2i32);
10366 impl ::std::convert::From<i32> for UListFormatterType {
from(value: i32) -> Self10367     fn from(value: i32) -> Self {
10368         Self(value)
10369     }
10370 }
10371 unsafe impl ::windows::runtime::Abi for UListFormatterType {
10372     type Abi = Self;
10373     type DefaultType = Self;
10374 }
10375 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10376 #[repr(transparent)]
10377 pub struct UListFormatterWidth(pub i32);
10378 pub const ULISTFMT_WIDTH_WIDE: UListFormatterWidth = UListFormatterWidth(0i32);
10379 pub const ULISTFMT_WIDTH_SHORT: UListFormatterWidth = UListFormatterWidth(1i32);
10380 pub const ULISTFMT_WIDTH_NARROW: UListFormatterWidth = UListFormatterWidth(2i32);
10381 impl ::std::convert::From<i32> for UListFormatterWidth {
from(value: i32) -> Self10382     fn from(value: i32) -> Self {
10383         Self(value)
10384     }
10385 }
10386 unsafe impl ::windows::runtime::Abi for UListFormatterWidth {
10387     type Abi = Self;
10388     type DefaultType = Self;
10389 }
10390 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10391 #[repr(transparent)]
10392 pub struct ULocAvailableType(pub i32);
10393 pub const ULOC_AVAILABLE_DEFAULT: ULocAvailableType = ULocAvailableType(0i32);
10394 pub const ULOC_AVAILABLE_ONLY_LEGACY_ALIASES: ULocAvailableType = ULocAvailableType(1i32);
10395 pub const ULOC_AVAILABLE_WITH_LEGACY_ALIASES: ULocAvailableType = ULocAvailableType(2i32);
10396 impl ::std::convert::From<i32> for ULocAvailableType {
from(value: i32) -> Self10397     fn from(value: i32) -> Self {
10398         Self(value)
10399     }
10400 }
10401 unsafe impl ::windows::runtime::Abi for ULocAvailableType {
10402     type Abi = Self;
10403     type DefaultType = Self;
10404 }
10405 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10406 #[repr(transparent)]
10407 pub struct ULocDataLocaleType(pub i32);
10408 pub const ULOC_ACTUAL_LOCALE: ULocDataLocaleType = ULocDataLocaleType(0i32);
10409 pub const ULOC_VALID_LOCALE: ULocDataLocaleType = ULocDataLocaleType(1i32);
10410 impl ::std::convert::From<i32> for ULocDataLocaleType {
from(value: i32) -> Self10411     fn from(value: i32) -> Self {
10412         Self(value)
10413     }
10414 }
10415 unsafe impl ::windows::runtime::Abi for ULocDataLocaleType {
10416     type Abi = Self;
10417     type DefaultType = Self;
10418 }
10419 #[repr(C)]
10420 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10421 pub struct ULocaleData(pub u8);
10422 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10423 #[repr(transparent)]
10424 pub struct ULocaleDataDelimiterType(pub i32);
10425 pub const ULOCDATA_QUOTATION_START: ULocaleDataDelimiterType = ULocaleDataDelimiterType(0i32);
10426 pub const ULOCDATA_QUOTATION_END: ULocaleDataDelimiterType = ULocaleDataDelimiterType(1i32);
10427 pub const ULOCDATA_ALT_QUOTATION_START: ULocaleDataDelimiterType = ULocaleDataDelimiterType(2i32);
10428 pub const ULOCDATA_ALT_QUOTATION_END: ULocaleDataDelimiterType = ULocaleDataDelimiterType(3i32);
10429 impl ::std::convert::From<i32> for ULocaleDataDelimiterType {
from(value: i32) -> Self10430     fn from(value: i32) -> Self {
10431         Self(value)
10432     }
10433 }
10434 unsafe impl ::windows::runtime::Abi for ULocaleDataDelimiterType {
10435     type Abi = Self;
10436     type DefaultType = Self;
10437 }
10438 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10439 #[repr(transparent)]
10440 pub struct ULocaleDataExemplarSetType(pub i32);
10441 pub const ULOCDATA_ES_STANDARD: ULocaleDataExemplarSetType = ULocaleDataExemplarSetType(0i32);
10442 pub const ULOCDATA_ES_AUXILIARY: ULocaleDataExemplarSetType = ULocaleDataExemplarSetType(1i32);
10443 pub const ULOCDATA_ES_INDEX: ULocaleDataExemplarSetType = ULocaleDataExemplarSetType(2i32);
10444 pub const ULOCDATA_ES_PUNCTUATION: ULocaleDataExemplarSetType = ULocaleDataExemplarSetType(3i32);
10445 impl ::std::convert::From<i32> for ULocaleDataExemplarSetType {
from(value: i32) -> Self10446     fn from(value: i32) -> Self {
10447         Self(value)
10448     }
10449 }
10450 unsafe impl ::windows::runtime::Abi for ULocaleDataExemplarSetType {
10451     type Abi = Self;
10452     type DefaultType = Self;
10453 }
10454 #[repr(C)]
10455 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10456 pub struct ULocaleDisplayNames(pub u8);
10457 pub const UMSGPAT_ARG_NAME_NOT_NUMBER: i32 = -1i32;
10458 pub const UMSGPAT_ARG_NAME_NOT_VALID: i32 = -2i32;
10459 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10460 #[repr(transparent)]
10461 pub struct UMeasureFormatWidth(pub i32);
10462 pub const UMEASFMT_WIDTH_WIDE: UMeasureFormatWidth = UMeasureFormatWidth(0i32);
10463 pub const UMEASFMT_WIDTH_SHORT: UMeasureFormatWidth = UMeasureFormatWidth(1i32);
10464 pub const UMEASFMT_WIDTH_NARROW: UMeasureFormatWidth = UMeasureFormatWidth(2i32);
10465 pub const UMEASFMT_WIDTH_NUMERIC: UMeasureFormatWidth = UMeasureFormatWidth(3i32);
10466 pub const UMEASFMT_WIDTH_COUNT: UMeasureFormatWidth = UMeasureFormatWidth(4i32);
10467 impl ::std::convert::From<i32> for UMeasureFormatWidth {
from(value: i32) -> Self10468     fn from(value: i32) -> Self {
10469         Self(value)
10470     }
10471 }
10472 unsafe impl ::windows::runtime::Abi for UMeasureFormatWidth {
10473     type Abi = Self;
10474     type DefaultType = Self;
10475 }
10476 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10477 #[repr(transparent)]
10478 pub struct UMeasurementSystem(pub i32);
10479 pub const UMS_SI: UMeasurementSystem = UMeasurementSystem(0i32);
10480 pub const UMS_US: UMeasurementSystem = UMeasurementSystem(1i32);
10481 pub const UMS_UK: UMeasurementSystem = UMeasurementSystem(2i32);
10482 impl ::std::convert::From<i32> for UMeasurementSystem {
from(value: i32) -> Self10483     fn from(value: i32) -> Self {
10484         Self(value)
10485     }
10486 }
10487 unsafe impl ::windows::runtime::Abi for UMeasurementSystem {
10488     type Abi = Self;
10489     type DefaultType = Self;
10490 }
10491 pub type UMemAllocFn = unsafe extern "system" fn(context: *const ::std::ffi::c_void, size: usize) -> *mut ::std::ffi::c_void;
10492 pub type UMemFreeFn = unsafe extern "system" fn(context: *const ::std::ffi::c_void, mem: *mut ::std::ffi::c_void);
10493 pub type UMemReallocFn = unsafe extern "system" fn(context: *const ::std::ffi::c_void, mem: *mut ::std::ffi::c_void, size: usize) -> *mut ::std::ffi::c_void;
10494 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10495 #[repr(transparent)]
10496 pub struct UMessagePatternApostropheMode(pub i32);
10497 pub const UMSGPAT_APOS_DOUBLE_OPTIONAL: UMessagePatternApostropheMode = UMessagePatternApostropheMode(0i32);
10498 pub const UMSGPAT_APOS_DOUBLE_REQUIRED: UMessagePatternApostropheMode = UMessagePatternApostropheMode(1i32);
10499 impl ::std::convert::From<i32> for UMessagePatternApostropheMode {
from(value: i32) -> Self10500     fn from(value: i32) -> Self {
10501         Self(value)
10502     }
10503 }
10504 unsafe impl ::windows::runtime::Abi for UMessagePatternApostropheMode {
10505     type Abi = Self;
10506     type DefaultType = Self;
10507 }
10508 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10509 #[repr(transparent)]
10510 pub struct UMessagePatternArgType(pub i32);
10511 pub const UMSGPAT_ARG_TYPE_NONE: UMessagePatternArgType = UMessagePatternArgType(0i32);
10512 pub const UMSGPAT_ARG_TYPE_SIMPLE: UMessagePatternArgType = UMessagePatternArgType(1i32);
10513 pub const UMSGPAT_ARG_TYPE_CHOICE: UMessagePatternArgType = UMessagePatternArgType(2i32);
10514 pub const UMSGPAT_ARG_TYPE_PLURAL: UMessagePatternArgType = UMessagePatternArgType(3i32);
10515 pub const UMSGPAT_ARG_TYPE_SELECT: UMessagePatternArgType = UMessagePatternArgType(4i32);
10516 pub const UMSGPAT_ARG_TYPE_SELECTORDINAL: UMessagePatternArgType = UMessagePatternArgType(5i32);
10517 impl ::std::convert::From<i32> for UMessagePatternArgType {
from(value: i32) -> Self10518     fn from(value: i32) -> Self {
10519         Self(value)
10520     }
10521 }
10522 unsafe impl ::windows::runtime::Abi for UMessagePatternArgType {
10523     type Abi = Self;
10524     type DefaultType = Self;
10525 }
10526 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10527 #[repr(transparent)]
10528 pub struct UMessagePatternPartType(pub i32);
10529 pub const UMSGPAT_PART_TYPE_MSG_START: UMessagePatternPartType = UMessagePatternPartType(0i32);
10530 pub const UMSGPAT_PART_TYPE_MSG_LIMIT: UMessagePatternPartType = UMessagePatternPartType(1i32);
10531 pub const UMSGPAT_PART_TYPE_SKIP_SYNTAX: UMessagePatternPartType = UMessagePatternPartType(2i32);
10532 pub const UMSGPAT_PART_TYPE_INSERT_CHAR: UMessagePatternPartType = UMessagePatternPartType(3i32);
10533 pub const UMSGPAT_PART_TYPE_REPLACE_NUMBER: UMessagePatternPartType = UMessagePatternPartType(4i32);
10534 pub const UMSGPAT_PART_TYPE_ARG_START: UMessagePatternPartType = UMessagePatternPartType(5i32);
10535 pub const UMSGPAT_PART_TYPE_ARG_LIMIT: UMessagePatternPartType = UMessagePatternPartType(6i32);
10536 pub const UMSGPAT_PART_TYPE_ARG_NUMBER: UMessagePatternPartType = UMessagePatternPartType(7i32);
10537 pub const UMSGPAT_PART_TYPE_ARG_NAME: UMessagePatternPartType = UMessagePatternPartType(8i32);
10538 pub const UMSGPAT_PART_TYPE_ARG_TYPE: UMessagePatternPartType = UMessagePatternPartType(9i32);
10539 pub const UMSGPAT_PART_TYPE_ARG_STYLE: UMessagePatternPartType = UMessagePatternPartType(10i32);
10540 pub const UMSGPAT_PART_TYPE_ARG_SELECTOR: UMessagePatternPartType = UMessagePatternPartType(11i32);
10541 pub const UMSGPAT_PART_TYPE_ARG_INT: UMessagePatternPartType = UMessagePatternPartType(12i32);
10542 pub const UMSGPAT_PART_TYPE_ARG_DOUBLE: UMessagePatternPartType = UMessagePatternPartType(13i32);
10543 impl ::std::convert::From<i32> for UMessagePatternPartType {
from(value: i32) -> Self10544     fn from(value: i32) -> Self {
10545         Self(value)
10546     }
10547 }
10548 unsafe impl ::windows::runtime::Abi for UMessagePatternPartType {
10549     type Abi = Self;
10550     type DefaultType = Self;
10551 }
10552 #[repr(C)]
10553 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10554 pub struct UMutableCPTrie(pub u8);
10555 pub type UNESCAPE_CHAR_AT = unsafe extern "system" fn(offset: i32, context: *mut ::std::ffi::c_void) -> u16;
10556 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10557 #[repr(C)]
10558 pub struct UNICODERANGE {
10559     pub wcFrom: u16,
10560     pub wcTo: u16,
10561 }
10562 impl UNICODERANGE {}
10563 impl ::std::default::Default for UNICODERANGE {
default() -> Self10564     fn default() -> Self {
10565         unsafe { ::std::mem::zeroed() }
10566     }
10567 }
10568 impl ::std::fmt::Debug for UNICODERANGE {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result10569     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10570         fmt.debug_struct("UNICODERANGE").field("wcFrom", &self.wcFrom).field("wcTo", &self.wcTo).finish()
10571     }
10572 }
10573 impl ::std::cmp::PartialEq for UNICODERANGE {
eq(&self, other: &Self) -> bool10574     fn eq(&self, other: &Self) -> bool {
10575         self.wcFrom == other.wcFrom && self.wcTo == other.wcTo
10576     }
10577 }
10578 impl ::std::cmp::Eq for UNICODERANGE {}
10579 unsafe impl ::windows::runtime::Abi for UNICODERANGE {
10580     type Abi = Self;
10581     type DefaultType = Self;
10582 }
10583 pub const UNISCRIBE_OPENTYPE: u32 = 256u32;
10584 pub const UNORM_INPUT_IS_FCD: u32 = 131072u32;
10585 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10586 #[repr(transparent)]
10587 pub struct UNormalization2Mode(pub i32);
10588 pub const UNORM2_COMPOSE: UNormalization2Mode = UNormalization2Mode(0i32);
10589 pub const UNORM2_DECOMPOSE: UNormalization2Mode = UNormalization2Mode(1i32);
10590 pub const UNORM2_FCD: UNormalization2Mode = UNormalization2Mode(2i32);
10591 pub const UNORM2_COMPOSE_CONTIGUOUS: UNormalization2Mode = UNormalization2Mode(3i32);
10592 impl ::std::convert::From<i32> for UNormalization2Mode {
from(value: i32) -> Self10593     fn from(value: i32) -> Self {
10594         Self(value)
10595     }
10596 }
10597 unsafe impl ::windows::runtime::Abi for UNormalization2Mode {
10598     type Abi = Self;
10599     type DefaultType = Self;
10600 }
10601 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10602 #[repr(transparent)]
10603 pub struct UNormalizationCheckResult(pub i32);
10604 pub const UNORM_NO: UNormalizationCheckResult = UNormalizationCheckResult(0i32);
10605 pub const UNORM_YES: UNormalizationCheckResult = UNormalizationCheckResult(1i32);
10606 pub const UNORM_MAYBE: UNormalizationCheckResult = UNormalizationCheckResult(2i32);
10607 impl ::std::convert::From<i32> for UNormalizationCheckResult {
from(value: i32) -> Self10608     fn from(value: i32) -> Self {
10609         Self(value)
10610     }
10611 }
10612 unsafe impl ::windows::runtime::Abi for UNormalizationCheckResult {
10613     type Abi = Self;
10614     type DefaultType = Self;
10615 }
10616 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10617 #[repr(transparent)]
10618 pub struct UNormalizationMode(pub i32);
10619 pub const UNORM_NONE: UNormalizationMode = UNormalizationMode(1i32);
10620 pub const UNORM_NFD: UNormalizationMode = UNormalizationMode(2i32);
10621 pub const UNORM_NFKD: UNormalizationMode = UNormalizationMode(3i32);
10622 pub const UNORM_NFC: UNormalizationMode = UNormalizationMode(4i32);
10623 pub const UNORM_DEFAULT: UNormalizationMode = UNormalizationMode(4i32);
10624 pub const UNORM_NFKC: UNormalizationMode = UNormalizationMode(5i32);
10625 pub const UNORM_FCD: UNormalizationMode = UNormalizationMode(6i32);
10626 pub const UNORM_MODE_COUNT: UNormalizationMode = UNormalizationMode(7i32);
10627 impl ::std::convert::From<i32> for UNormalizationMode {
from(value: i32) -> Self10628     fn from(value: i32) -> Self {
10629         Self(value)
10630     }
10631 }
10632 unsafe impl ::windows::runtime::Abi for UNormalizationMode {
10633     type Abi = Self;
10634     type DefaultType = Self;
10635 }
10636 #[repr(C)]
10637 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10638 pub struct UNormalizer2(pub u8);
10639 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10640 #[repr(transparent)]
10641 pub struct UNumberCompactStyle(pub i32);
10642 pub const UNUM_SHORT: UNumberCompactStyle = UNumberCompactStyle(0i32);
10643 pub const UNUM_LONG: UNumberCompactStyle = UNumberCompactStyle(1i32);
10644 impl ::std::convert::From<i32> for UNumberCompactStyle {
from(value: i32) -> Self10645     fn from(value: i32) -> Self {
10646         Self(value)
10647     }
10648 }
10649 unsafe impl ::windows::runtime::Abi for UNumberCompactStyle {
10650     type Abi = Self;
10651     type DefaultType = Self;
10652 }
10653 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10654 #[repr(transparent)]
10655 pub struct UNumberDecimalSeparatorDisplay(pub i32);
10656 pub const UNUM_DECIMAL_SEPARATOR_AUTO: UNumberDecimalSeparatorDisplay = UNumberDecimalSeparatorDisplay(0i32);
10657 pub const UNUM_DECIMAL_SEPARATOR_ALWAYS: UNumberDecimalSeparatorDisplay = UNumberDecimalSeparatorDisplay(1i32);
10658 pub const UNUM_DECIMAL_SEPARATOR_COUNT: UNumberDecimalSeparatorDisplay = UNumberDecimalSeparatorDisplay(2i32);
10659 impl ::std::convert::From<i32> for UNumberDecimalSeparatorDisplay {
from(value: i32) -> Self10660     fn from(value: i32) -> Self {
10661         Self(value)
10662     }
10663 }
10664 unsafe impl ::windows::runtime::Abi for UNumberDecimalSeparatorDisplay {
10665     type Abi = Self;
10666     type DefaultType = Self;
10667 }
10668 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10669 #[repr(transparent)]
10670 pub struct UNumberFormatAttribute(pub i32);
10671 pub const UNUM_PARSE_INT_ONLY: UNumberFormatAttribute = UNumberFormatAttribute(0i32);
10672 pub const UNUM_GROUPING_USED: UNumberFormatAttribute = UNumberFormatAttribute(1i32);
10673 pub const UNUM_DECIMAL_ALWAYS_SHOWN: UNumberFormatAttribute = UNumberFormatAttribute(2i32);
10674 pub const UNUM_MAX_INTEGER_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(3i32);
10675 pub const UNUM_MIN_INTEGER_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(4i32);
10676 pub const UNUM_INTEGER_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(5i32);
10677 pub const UNUM_MAX_FRACTION_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(6i32);
10678 pub const UNUM_MIN_FRACTION_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(7i32);
10679 pub const UNUM_FRACTION_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(8i32);
10680 pub const UNUM_MULTIPLIER: UNumberFormatAttribute = UNumberFormatAttribute(9i32);
10681 pub const UNUM_GROUPING_SIZE: UNumberFormatAttribute = UNumberFormatAttribute(10i32);
10682 pub const UNUM_ROUNDING_MODE: UNumberFormatAttribute = UNumberFormatAttribute(11i32);
10683 pub const UNUM_ROUNDING_INCREMENT: UNumberFormatAttribute = UNumberFormatAttribute(12i32);
10684 pub const UNUM_FORMAT_WIDTH: UNumberFormatAttribute = UNumberFormatAttribute(13i32);
10685 pub const UNUM_PADDING_POSITION: UNumberFormatAttribute = UNumberFormatAttribute(14i32);
10686 pub const UNUM_SECONDARY_GROUPING_SIZE: UNumberFormatAttribute = UNumberFormatAttribute(15i32);
10687 pub const UNUM_SIGNIFICANT_DIGITS_USED: UNumberFormatAttribute = UNumberFormatAttribute(16i32);
10688 pub const UNUM_MIN_SIGNIFICANT_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(17i32);
10689 pub const UNUM_MAX_SIGNIFICANT_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(18i32);
10690 pub const UNUM_LENIENT_PARSE: UNumberFormatAttribute = UNumberFormatAttribute(19i32);
10691 pub const UNUM_PARSE_ALL_INPUT: UNumberFormatAttribute = UNumberFormatAttribute(20i32);
10692 pub const UNUM_SCALE: UNumberFormatAttribute = UNumberFormatAttribute(21i32);
10693 pub const UNUM_MINIMUM_GROUPING_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(22i32);
10694 pub const UNUM_CURRENCY_USAGE: UNumberFormatAttribute = UNumberFormatAttribute(23i32);
10695 pub const UNUM_FORMAT_FAIL_IF_MORE_THAN_MAX_DIGITS: UNumberFormatAttribute = UNumberFormatAttribute(4096i32);
10696 pub const UNUM_PARSE_NO_EXPONENT: UNumberFormatAttribute = UNumberFormatAttribute(4097i32);
10697 pub const UNUM_PARSE_DECIMAL_MARK_REQUIRED: UNumberFormatAttribute = UNumberFormatAttribute(4098i32);
10698 pub const UNUM_PARSE_CASE_SENSITIVE: UNumberFormatAttribute = UNumberFormatAttribute(4099i32);
10699 pub const UNUM_SIGN_ALWAYS_SHOWN: UNumberFormatAttribute = UNumberFormatAttribute(4100i32);
10700 impl ::std::convert::From<i32> for UNumberFormatAttribute {
from(value: i32) -> Self10701     fn from(value: i32) -> Self {
10702         Self(value)
10703     }
10704 }
10705 unsafe impl ::windows::runtime::Abi for UNumberFormatAttribute {
10706     type Abi = Self;
10707     type DefaultType = Self;
10708 }
10709 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10710 #[repr(transparent)]
10711 pub struct UNumberFormatAttributeValue(pub i32);
10712 pub const UNUM_FORMAT_ATTRIBUTE_VALUE_HIDDEN: UNumberFormatAttributeValue = UNumberFormatAttributeValue(0i32);
10713 impl ::std::convert::From<i32> for UNumberFormatAttributeValue {
from(value: i32) -> Self10714     fn from(value: i32) -> Self {
10715         Self(value)
10716     }
10717 }
10718 unsafe impl ::windows::runtime::Abi for UNumberFormatAttributeValue {
10719     type Abi = Self;
10720     type DefaultType = Self;
10721 }
10722 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10723 #[repr(transparent)]
10724 pub struct UNumberFormatFields(pub i32);
10725 pub const UNUM_INTEGER_FIELD: UNumberFormatFields = UNumberFormatFields(0i32);
10726 pub const UNUM_FRACTION_FIELD: UNumberFormatFields = UNumberFormatFields(1i32);
10727 pub const UNUM_DECIMAL_SEPARATOR_FIELD: UNumberFormatFields = UNumberFormatFields(2i32);
10728 pub const UNUM_EXPONENT_SYMBOL_FIELD: UNumberFormatFields = UNumberFormatFields(3i32);
10729 pub const UNUM_EXPONENT_SIGN_FIELD: UNumberFormatFields = UNumberFormatFields(4i32);
10730 pub const UNUM_EXPONENT_FIELD: UNumberFormatFields = UNumberFormatFields(5i32);
10731 pub const UNUM_GROUPING_SEPARATOR_FIELD: UNumberFormatFields = UNumberFormatFields(6i32);
10732 pub const UNUM_CURRENCY_FIELD: UNumberFormatFields = UNumberFormatFields(7i32);
10733 pub const UNUM_PERCENT_FIELD: UNumberFormatFields = UNumberFormatFields(8i32);
10734 pub const UNUM_PERMILL_FIELD: UNumberFormatFields = UNumberFormatFields(9i32);
10735 pub const UNUM_SIGN_FIELD: UNumberFormatFields = UNumberFormatFields(10i32);
10736 pub const UNUM_MEASURE_UNIT_FIELD: UNumberFormatFields = UNumberFormatFields(11i32);
10737 pub const UNUM_COMPACT_FIELD: UNumberFormatFields = UNumberFormatFields(12i32);
10738 impl ::std::convert::From<i32> for UNumberFormatFields {
from(value: i32) -> Self10739     fn from(value: i32) -> Self {
10740         Self(value)
10741     }
10742 }
10743 unsafe impl ::windows::runtime::Abi for UNumberFormatFields {
10744     type Abi = Self;
10745     type DefaultType = Self;
10746 }
10747 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10748 #[repr(transparent)]
10749 pub struct UNumberFormatPadPosition(pub i32);
10750 pub const UNUM_PAD_BEFORE_PREFIX: UNumberFormatPadPosition = UNumberFormatPadPosition(0i32);
10751 pub const UNUM_PAD_AFTER_PREFIX: UNumberFormatPadPosition = UNumberFormatPadPosition(1i32);
10752 pub const UNUM_PAD_BEFORE_SUFFIX: UNumberFormatPadPosition = UNumberFormatPadPosition(2i32);
10753 pub const UNUM_PAD_AFTER_SUFFIX: UNumberFormatPadPosition = UNumberFormatPadPosition(3i32);
10754 impl ::std::convert::From<i32> for UNumberFormatPadPosition {
from(value: i32) -> Self10755     fn from(value: i32) -> Self {
10756         Self(value)
10757     }
10758 }
10759 unsafe impl ::windows::runtime::Abi for UNumberFormatPadPosition {
10760     type Abi = Self;
10761     type DefaultType = Self;
10762 }
10763 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10764 #[repr(transparent)]
10765 pub struct UNumberFormatRoundingMode(pub i32);
10766 pub const UNUM_ROUND_CEILING: UNumberFormatRoundingMode = UNumberFormatRoundingMode(0i32);
10767 pub const UNUM_ROUND_FLOOR: UNumberFormatRoundingMode = UNumberFormatRoundingMode(1i32);
10768 pub const UNUM_ROUND_DOWN: UNumberFormatRoundingMode = UNumberFormatRoundingMode(2i32);
10769 pub const UNUM_ROUND_UP: UNumberFormatRoundingMode = UNumberFormatRoundingMode(3i32);
10770 pub const UNUM_ROUND_HALFEVEN: UNumberFormatRoundingMode = UNumberFormatRoundingMode(4i32);
10771 pub const UNUM_ROUND_HALFDOWN: UNumberFormatRoundingMode = UNumberFormatRoundingMode(5i32);
10772 pub const UNUM_ROUND_HALFUP: UNumberFormatRoundingMode = UNumberFormatRoundingMode(6i32);
10773 pub const UNUM_ROUND_UNNECESSARY: UNumberFormatRoundingMode = UNumberFormatRoundingMode(7i32);
10774 impl ::std::convert::From<i32> for UNumberFormatRoundingMode {
from(value: i32) -> Self10775     fn from(value: i32) -> Self {
10776         Self(value)
10777     }
10778 }
10779 unsafe impl ::windows::runtime::Abi for UNumberFormatRoundingMode {
10780     type Abi = Self;
10781     type DefaultType = Self;
10782 }
10783 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10784 #[repr(transparent)]
10785 pub struct UNumberFormatStyle(pub i32);
10786 pub const UNUM_PATTERN_DECIMAL: UNumberFormatStyle = UNumberFormatStyle(0i32);
10787 pub const UNUM_DECIMAL: UNumberFormatStyle = UNumberFormatStyle(1i32);
10788 pub const UNUM_CURRENCY: UNumberFormatStyle = UNumberFormatStyle(2i32);
10789 pub const UNUM_PERCENT: UNumberFormatStyle = UNumberFormatStyle(3i32);
10790 pub const UNUM_SCIENTIFIC: UNumberFormatStyle = UNumberFormatStyle(4i32);
10791 pub const UNUM_SPELLOUT: UNumberFormatStyle = UNumberFormatStyle(5i32);
10792 pub const UNUM_ORDINAL: UNumberFormatStyle = UNumberFormatStyle(6i32);
10793 pub const UNUM_DURATION: UNumberFormatStyle = UNumberFormatStyle(7i32);
10794 pub const UNUM_NUMBERING_SYSTEM: UNumberFormatStyle = UNumberFormatStyle(8i32);
10795 pub const UNUM_PATTERN_RULEBASED: UNumberFormatStyle = UNumberFormatStyle(9i32);
10796 pub const UNUM_CURRENCY_ISO: UNumberFormatStyle = UNumberFormatStyle(10i32);
10797 pub const UNUM_CURRENCY_PLURAL: UNumberFormatStyle = UNumberFormatStyle(11i32);
10798 pub const UNUM_CURRENCY_ACCOUNTING: UNumberFormatStyle = UNumberFormatStyle(12i32);
10799 pub const UNUM_CASH_CURRENCY: UNumberFormatStyle = UNumberFormatStyle(13i32);
10800 pub const UNUM_DECIMAL_COMPACT_SHORT: UNumberFormatStyle = UNumberFormatStyle(14i32);
10801 pub const UNUM_DECIMAL_COMPACT_LONG: UNumberFormatStyle = UNumberFormatStyle(15i32);
10802 pub const UNUM_CURRENCY_STANDARD: UNumberFormatStyle = UNumberFormatStyle(16i32);
10803 pub const UNUM_DEFAULT: UNumberFormatStyle = UNumberFormatStyle(1i32);
10804 pub const UNUM_IGNORE: UNumberFormatStyle = UNumberFormatStyle(0i32);
10805 impl ::std::convert::From<i32> for UNumberFormatStyle {
from(value: i32) -> Self10806     fn from(value: i32) -> Self {
10807         Self(value)
10808     }
10809 }
10810 unsafe impl ::windows::runtime::Abi for UNumberFormatStyle {
10811     type Abi = Self;
10812     type DefaultType = Self;
10813 }
10814 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10815 #[repr(transparent)]
10816 pub struct UNumberFormatSymbol(pub i32);
10817 pub const UNUM_DECIMAL_SEPARATOR_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(0i32);
10818 pub const UNUM_GROUPING_SEPARATOR_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(1i32);
10819 pub const UNUM_PATTERN_SEPARATOR_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(2i32);
10820 pub const UNUM_PERCENT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(3i32);
10821 pub const UNUM_ZERO_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(4i32);
10822 pub const UNUM_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(5i32);
10823 pub const UNUM_MINUS_SIGN_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(6i32);
10824 pub const UNUM_PLUS_SIGN_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(7i32);
10825 pub const UNUM_CURRENCY_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(8i32);
10826 pub const UNUM_INTL_CURRENCY_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(9i32);
10827 pub const UNUM_MONETARY_SEPARATOR_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(10i32);
10828 pub const UNUM_EXPONENTIAL_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(11i32);
10829 pub const UNUM_PERMILL_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(12i32);
10830 pub const UNUM_PAD_ESCAPE_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(13i32);
10831 pub const UNUM_INFINITY_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(14i32);
10832 pub const UNUM_NAN_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(15i32);
10833 pub const UNUM_SIGNIFICANT_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(16i32);
10834 pub const UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(17i32);
10835 pub const UNUM_ONE_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(18i32);
10836 pub const UNUM_TWO_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(19i32);
10837 pub const UNUM_THREE_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(20i32);
10838 pub const UNUM_FOUR_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(21i32);
10839 pub const UNUM_FIVE_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(22i32);
10840 pub const UNUM_SIX_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(23i32);
10841 pub const UNUM_SEVEN_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(24i32);
10842 pub const UNUM_EIGHT_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(25i32);
10843 pub const UNUM_NINE_DIGIT_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(26i32);
10844 pub const UNUM_EXPONENT_MULTIPLICATION_SYMBOL: UNumberFormatSymbol = UNumberFormatSymbol(27i32);
10845 impl ::std::convert::From<i32> for UNumberFormatSymbol {
from(value: i32) -> Self10846     fn from(value: i32) -> Self {
10847         Self(value)
10848     }
10849 }
10850 unsafe impl ::windows::runtime::Abi for UNumberFormatSymbol {
10851     type Abi = Self;
10852     type DefaultType = Self;
10853 }
10854 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10855 #[repr(transparent)]
10856 pub struct UNumberFormatTextAttribute(pub i32);
10857 pub const UNUM_POSITIVE_PREFIX: UNumberFormatTextAttribute = UNumberFormatTextAttribute(0i32);
10858 pub const UNUM_POSITIVE_SUFFIX: UNumberFormatTextAttribute = UNumberFormatTextAttribute(1i32);
10859 pub const UNUM_NEGATIVE_PREFIX: UNumberFormatTextAttribute = UNumberFormatTextAttribute(2i32);
10860 pub const UNUM_NEGATIVE_SUFFIX: UNumberFormatTextAttribute = UNumberFormatTextAttribute(3i32);
10861 pub const UNUM_PADDING_CHARACTER: UNumberFormatTextAttribute = UNumberFormatTextAttribute(4i32);
10862 pub const UNUM_CURRENCY_CODE: UNumberFormatTextAttribute = UNumberFormatTextAttribute(5i32);
10863 pub const UNUM_DEFAULT_RULESET: UNumberFormatTextAttribute = UNumberFormatTextAttribute(6i32);
10864 pub const UNUM_PUBLIC_RULESETS: UNumberFormatTextAttribute = UNumberFormatTextAttribute(7i32);
10865 impl ::std::convert::From<i32> for UNumberFormatTextAttribute {
from(value: i32) -> Self10866     fn from(value: i32) -> Self {
10867         Self(value)
10868     }
10869 }
10870 unsafe impl ::windows::runtime::Abi for UNumberFormatTextAttribute {
10871     type Abi = Self;
10872     type DefaultType = Self;
10873 }
10874 #[repr(C)]
10875 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10876 pub struct UNumberFormatter(pub u8);
10877 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10878 #[repr(transparent)]
10879 pub struct UNumberGroupingStrategy(pub i32);
10880 pub const UNUM_GROUPING_OFF: UNumberGroupingStrategy = UNumberGroupingStrategy(0i32);
10881 pub const UNUM_GROUPING_MIN2: UNumberGroupingStrategy = UNumberGroupingStrategy(1i32);
10882 pub const UNUM_GROUPING_AUTO: UNumberGroupingStrategy = UNumberGroupingStrategy(2i32);
10883 pub const UNUM_GROUPING_ON_ALIGNED: UNumberGroupingStrategy = UNumberGroupingStrategy(3i32);
10884 pub const UNUM_GROUPING_THOUSANDS: UNumberGroupingStrategy = UNumberGroupingStrategy(4i32);
10885 impl ::std::convert::From<i32> for UNumberGroupingStrategy {
from(value: i32) -> Self10886     fn from(value: i32) -> Self {
10887         Self(value)
10888     }
10889 }
10890 unsafe impl ::windows::runtime::Abi for UNumberGroupingStrategy {
10891     type Abi = Self;
10892     type DefaultType = Self;
10893 }
10894 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10895 #[repr(transparent)]
10896 pub struct UNumberRangeCollapse(pub i32);
10897 pub const UNUM_RANGE_COLLAPSE_AUTO: UNumberRangeCollapse = UNumberRangeCollapse(0i32);
10898 pub const UNUM_RANGE_COLLAPSE_NONE: UNumberRangeCollapse = UNumberRangeCollapse(1i32);
10899 pub const UNUM_RANGE_COLLAPSE_UNIT: UNumberRangeCollapse = UNumberRangeCollapse(2i32);
10900 pub const UNUM_RANGE_COLLAPSE_ALL: UNumberRangeCollapse = UNumberRangeCollapse(3i32);
10901 impl ::std::convert::From<i32> for UNumberRangeCollapse {
from(value: i32) -> Self10902     fn from(value: i32) -> Self {
10903         Self(value)
10904     }
10905 }
10906 unsafe impl ::windows::runtime::Abi for UNumberRangeCollapse {
10907     type Abi = Self;
10908     type DefaultType = Self;
10909 }
10910 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10911 #[repr(transparent)]
10912 pub struct UNumberRangeIdentityFallback(pub i32);
10913 pub const UNUM_IDENTITY_FALLBACK_SINGLE_VALUE: UNumberRangeIdentityFallback = UNumberRangeIdentityFallback(0i32);
10914 pub const UNUM_IDENTITY_FALLBACK_APPROXIMATELY_OR_SINGLE_VALUE: UNumberRangeIdentityFallback = UNumberRangeIdentityFallback(1i32);
10915 pub const UNUM_IDENTITY_FALLBACK_APPROXIMATELY: UNumberRangeIdentityFallback = UNumberRangeIdentityFallback(2i32);
10916 pub const UNUM_IDENTITY_FALLBACK_RANGE: UNumberRangeIdentityFallback = UNumberRangeIdentityFallback(3i32);
10917 impl ::std::convert::From<i32> for UNumberRangeIdentityFallback {
from(value: i32) -> Self10918     fn from(value: i32) -> Self {
10919         Self(value)
10920     }
10921 }
10922 unsafe impl ::windows::runtime::Abi for UNumberRangeIdentityFallback {
10923     type Abi = Self;
10924     type DefaultType = Self;
10925 }
10926 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10927 #[repr(transparent)]
10928 pub struct UNumberRangeIdentityResult(pub i32);
10929 pub const UNUM_IDENTITY_RESULT_EQUAL_BEFORE_ROUNDING: UNumberRangeIdentityResult = UNumberRangeIdentityResult(0i32);
10930 pub const UNUM_IDENTITY_RESULT_EQUAL_AFTER_ROUNDING: UNumberRangeIdentityResult = UNumberRangeIdentityResult(1i32);
10931 pub const UNUM_IDENTITY_RESULT_NOT_EQUAL: UNumberRangeIdentityResult = UNumberRangeIdentityResult(2i32);
10932 impl ::std::convert::From<i32> for UNumberRangeIdentityResult {
from(value: i32) -> Self10933     fn from(value: i32) -> Self {
10934         Self(value)
10935     }
10936 }
10937 unsafe impl ::windows::runtime::Abi for UNumberRangeIdentityResult {
10938     type Abi = Self;
10939     type DefaultType = Self;
10940 }
10941 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10942 #[repr(transparent)]
10943 pub struct UNumberSignDisplay(pub i32);
10944 pub const UNUM_SIGN_AUTO: UNumberSignDisplay = UNumberSignDisplay(0i32);
10945 pub const UNUM_SIGN_ALWAYS: UNumberSignDisplay = UNumberSignDisplay(1i32);
10946 pub const UNUM_SIGN_NEVER: UNumberSignDisplay = UNumberSignDisplay(2i32);
10947 pub const UNUM_SIGN_ACCOUNTING: UNumberSignDisplay = UNumberSignDisplay(3i32);
10948 pub const UNUM_SIGN_ACCOUNTING_ALWAYS: UNumberSignDisplay = UNumberSignDisplay(4i32);
10949 pub const UNUM_SIGN_EXCEPT_ZERO: UNumberSignDisplay = UNumberSignDisplay(5i32);
10950 pub const UNUM_SIGN_ACCOUNTING_EXCEPT_ZERO: UNumberSignDisplay = UNumberSignDisplay(6i32);
10951 pub const UNUM_SIGN_COUNT: UNumberSignDisplay = UNumberSignDisplay(7i32);
10952 impl ::std::convert::From<i32> for UNumberSignDisplay {
from(value: i32) -> Self10953     fn from(value: i32) -> Self {
10954         Self(value)
10955     }
10956 }
10957 unsafe impl ::windows::runtime::Abi for UNumberSignDisplay {
10958     type Abi = Self;
10959     type DefaultType = Self;
10960 }
10961 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10962 #[repr(transparent)]
10963 pub struct UNumberUnitWidth(pub i32);
10964 pub const UNUM_UNIT_WIDTH_NARROW: UNumberUnitWidth = UNumberUnitWidth(0i32);
10965 pub const UNUM_UNIT_WIDTH_SHORT: UNumberUnitWidth = UNumberUnitWidth(1i32);
10966 pub const UNUM_UNIT_WIDTH_FULL_NAME: UNumberUnitWidth = UNumberUnitWidth(2i32);
10967 pub const UNUM_UNIT_WIDTH_ISO_CODE: UNumberUnitWidth = UNumberUnitWidth(3i32);
10968 pub const UNUM_UNIT_WIDTH_HIDDEN: UNumberUnitWidth = UNumberUnitWidth(4i32);
10969 pub const UNUM_UNIT_WIDTH_COUNT: UNumberUnitWidth = UNumberUnitWidth(5i32);
10970 impl ::std::convert::From<i32> for UNumberUnitWidth {
from(value: i32) -> Self10971     fn from(value: i32) -> Self {
10972         Self(value)
10973     }
10974 }
10975 unsafe impl ::windows::runtime::Abi for UNumberUnitWidth {
10976     type Abi = Self;
10977     type DefaultType = Self;
10978 }
10979 #[repr(C)]
10980 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
10981 pub struct UNumberingSystem(pub u8);
10982 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
10983 #[repr(transparent)]
10984 pub struct UNumericType(pub i32);
10985 pub const U_NT_NONE: UNumericType = UNumericType(0i32);
10986 pub const U_NT_DECIMAL: UNumericType = UNumericType(1i32);
10987 pub const U_NT_DIGIT: UNumericType = UNumericType(2i32);
10988 pub const U_NT_NUMERIC: UNumericType = UNumericType(3i32);
10989 impl ::std::convert::From<i32> for UNumericType {
from(value: i32) -> Self10990     fn from(value: i32) -> Self {
10991         Self(value)
10992     }
10993 }
10994 unsafe impl ::windows::runtime::Abi for UNumericType {
10995     type Abi = Self;
10996     type DefaultType = Self;
10997 }
10998 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
10999 #[repr(C)]
11000 pub struct UParseError {
11001     pub line: i32,
11002     pub offset: i32,
11003     pub preContext: [u16; 16],
11004     pub postContext: [u16; 16],
11005 }
11006 impl UParseError {}
11007 impl ::std::default::Default for UParseError {
default() -> Self11008     fn default() -> Self {
11009         unsafe { ::std::mem::zeroed() }
11010     }
11011 }
11012 impl ::std::fmt::Debug for UParseError {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11013     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11014         fmt.debug_struct("UParseError").field("line", &self.line).field("offset", &self.offset).field("preContext", &self.preContext).field("postContext", &self.postContext).finish()
11015     }
11016 }
11017 impl ::std::cmp::PartialEq for UParseError {
eq(&self, other: &Self) -> bool11018     fn eq(&self, other: &Self) -> bool {
11019         self.line == other.line && self.offset == other.offset && self.preContext == other.preContext && self.postContext == other.postContext
11020     }
11021 }
11022 impl ::std::cmp::Eq for UParseError {}
11023 unsafe impl ::windows::runtime::Abi for UParseError {
11024     type Abi = Self;
11025     type DefaultType = Self;
11026 }
11027 #[repr(C)]
11028 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11029 pub struct UPluralRules(pub u8);
11030 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11031 #[repr(transparent)]
11032 pub struct UPluralType(pub i32);
11033 pub const UPLURAL_TYPE_CARDINAL: UPluralType = UPluralType(0i32);
11034 pub const UPLURAL_TYPE_ORDINAL: UPluralType = UPluralType(1i32);
11035 impl ::std::convert::From<i32> for UPluralType {
from(value: i32) -> Self11036     fn from(value: i32) -> Self {
11037         Self(value)
11038     }
11039 }
11040 unsafe impl ::windows::runtime::Abi for UPluralType {
11041     type Abi = Self;
11042     type DefaultType = Self;
11043 }
11044 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11045 #[repr(transparent)]
11046 pub struct UProperty(pub i32);
11047 pub const UCHAR_ALPHABETIC: UProperty = UProperty(0i32);
11048 pub const UCHAR_BINARY_START: UProperty = UProperty(0i32);
11049 pub const UCHAR_ASCII_HEX_DIGIT: UProperty = UProperty(1i32);
11050 pub const UCHAR_BIDI_CONTROL: UProperty = UProperty(2i32);
11051 pub const UCHAR_BIDI_MIRRORED: UProperty = UProperty(3i32);
11052 pub const UCHAR_DASH: UProperty = UProperty(4i32);
11053 pub const UCHAR_DEFAULT_IGNORABLE_CODE_POINT: UProperty = UProperty(5i32);
11054 pub const UCHAR_DEPRECATED: UProperty = UProperty(6i32);
11055 pub const UCHAR_DIACRITIC: UProperty = UProperty(7i32);
11056 pub const UCHAR_EXTENDER: UProperty = UProperty(8i32);
11057 pub const UCHAR_FULL_COMPOSITION_EXCLUSION: UProperty = UProperty(9i32);
11058 pub const UCHAR_GRAPHEME_BASE: UProperty = UProperty(10i32);
11059 pub const UCHAR_GRAPHEME_EXTEND: UProperty = UProperty(11i32);
11060 pub const UCHAR_GRAPHEME_LINK: UProperty = UProperty(12i32);
11061 pub const UCHAR_HEX_DIGIT: UProperty = UProperty(13i32);
11062 pub const UCHAR_HYPHEN: UProperty = UProperty(14i32);
11063 pub const UCHAR_ID_CONTINUE: UProperty = UProperty(15i32);
11064 pub const UCHAR_ID_START: UProperty = UProperty(16i32);
11065 pub const UCHAR_IDEOGRAPHIC: UProperty = UProperty(17i32);
11066 pub const UCHAR_IDS_BINARY_OPERATOR: UProperty = UProperty(18i32);
11067 pub const UCHAR_IDS_TRINARY_OPERATOR: UProperty = UProperty(19i32);
11068 pub const UCHAR_JOIN_CONTROL: UProperty = UProperty(20i32);
11069 pub const UCHAR_LOGICAL_ORDER_EXCEPTION: UProperty = UProperty(21i32);
11070 pub const UCHAR_LOWERCASE: UProperty = UProperty(22i32);
11071 pub const UCHAR_MATH: UProperty = UProperty(23i32);
11072 pub const UCHAR_NONCHARACTER_CODE_POINT: UProperty = UProperty(24i32);
11073 pub const UCHAR_QUOTATION_MARK: UProperty = UProperty(25i32);
11074 pub const UCHAR_RADICAL: UProperty = UProperty(26i32);
11075 pub const UCHAR_SOFT_DOTTED: UProperty = UProperty(27i32);
11076 pub const UCHAR_TERMINAL_PUNCTUATION: UProperty = UProperty(28i32);
11077 pub const UCHAR_UNIFIED_IDEOGRAPH: UProperty = UProperty(29i32);
11078 pub const UCHAR_UPPERCASE: UProperty = UProperty(30i32);
11079 pub const UCHAR_WHITE_SPACE: UProperty = UProperty(31i32);
11080 pub const UCHAR_XID_CONTINUE: UProperty = UProperty(32i32);
11081 pub const UCHAR_XID_START: UProperty = UProperty(33i32);
11082 pub const UCHAR_CASE_SENSITIVE: UProperty = UProperty(34i32);
11083 pub const UCHAR_S_TERM: UProperty = UProperty(35i32);
11084 pub const UCHAR_VARIATION_SELECTOR: UProperty = UProperty(36i32);
11085 pub const UCHAR_NFD_INERT: UProperty = UProperty(37i32);
11086 pub const UCHAR_NFKD_INERT: UProperty = UProperty(38i32);
11087 pub const UCHAR_NFC_INERT: UProperty = UProperty(39i32);
11088 pub const UCHAR_NFKC_INERT: UProperty = UProperty(40i32);
11089 pub const UCHAR_SEGMENT_STARTER: UProperty = UProperty(41i32);
11090 pub const UCHAR_PATTERN_SYNTAX: UProperty = UProperty(42i32);
11091 pub const UCHAR_PATTERN_WHITE_SPACE: UProperty = UProperty(43i32);
11092 pub const UCHAR_POSIX_ALNUM: UProperty = UProperty(44i32);
11093 pub const UCHAR_POSIX_BLANK: UProperty = UProperty(45i32);
11094 pub const UCHAR_POSIX_GRAPH: UProperty = UProperty(46i32);
11095 pub const UCHAR_POSIX_PRINT: UProperty = UProperty(47i32);
11096 pub const UCHAR_POSIX_XDIGIT: UProperty = UProperty(48i32);
11097 pub const UCHAR_CASED: UProperty = UProperty(49i32);
11098 pub const UCHAR_CASE_IGNORABLE: UProperty = UProperty(50i32);
11099 pub const UCHAR_CHANGES_WHEN_LOWERCASED: UProperty = UProperty(51i32);
11100 pub const UCHAR_CHANGES_WHEN_UPPERCASED: UProperty = UProperty(52i32);
11101 pub const UCHAR_CHANGES_WHEN_TITLECASED: UProperty = UProperty(53i32);
11102 pub const UCHAR_CHANGES_WHEN_CASEFOLDED: UProperty = UProperty(54i32);
11103 pub const UCHAR_CHANGES_WHEN_CASEMAPPED: UProperty = UProperty(55i32);
11104 pub const UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED: UProperty = UProperty(56i32);
11105 pub const UCHAR_EMOJI: UProperty = UProperty(57i32);
11106 pub const UCHAR_EMOJI_PRESENTATION: UProperty = UProperty(58i32);
11107 pub const UCHAR_EMOJI_MODIFIER: UProperty = UProperty(59i32);
11108 pub const UCHAR_EMOJI_MODIFIER_BASE: UProperty = UProperty(60i32);
11109 pub const UCHAR_EMOJI_COMPONENT: UProperty = UProperty(61i32);
11110 pub const UCHAR_REGIONAL_INDICATOR: UProperty = UProperty(62i32);
11111 pub const UCHAR_PREPENDED_CONCATENATION_MARK: UProperty = UProperty(63i32);
11112 pub const UCHAR_EXTENDED_PICTOGRAPHIC: UProperty = UProperty(64i32);
11113 pub const UCHAR_BIDI_CLASS: UProperty = UProperty(4096i32);
11114 pub const UCHAR_INT_START: UProperty = UProperty(4096i32);
11115 pub const UCHAR_BLOCK: UProperty = UProperty(4097i32);
11116 pub const UCHAR_CANONICAL_COMBINING_CLASS: UProperty = UProperty(4098i32);
11117 pub const UCHAR_DECOMPOSITION_TYPE: UProperty = UProperty(4099i32);
11118 pub const UCHAR_EAST_ASIAN_WIDTH: UProperty = UProperty(4100i32);
11119 pub const UCHAR_GENERAL_CATEGORY: UProperty = UProperty(4101i32);
11120 pub const UCHAR_JOINING_GROUP: UProperty = UProperty(4102i32);
11121 pub const UCHAR_JOINING_TYPE: UProperty = UProperty(4103i32);
11122 pub const UCHAR_LINE_BREAK: UProperty = UProperty(4104i32);
11123 pub const UCHAR_NUMERIC_TYPE: UProperty = UProperty(4105i32);
11124 pub const UCHAR_SCRIPT: UProperty = UProperty(4106i32);
11125 pub const UCHAR_HANGUL_SYLLABLE_TYPE: UProperty = UProperty(4107i32);
11126 pub const UCHAR_NFD_QUICK_CHECK: UProperty = UProperty(4108i32);
11127 pub const UCHAR_NFKD_QUICK_CHECK: UProperty = UProperty(4109i32);
11128 pub const UCHAR_NFC_QUICK_CHECK: UProperty = UProperty(4110i32);
11129 pub const UCHAR_NFKC_QUICK_CHECK: UProperty = UProperty(4111i32);
11130 pub const UCHAR_LEAD_CANONICAL_COMBINING_CLASS: UProperty = UProperty(4112i32);
11131 pub const UCHAR_TRAIL_CANONICAL_COMBINING_CLASS: UProperty = UProperty(4113i32);
11132 pub const UCHAR_GRAPHEME_CLUSTER_BREAK: UProperty = UProperty(4114i32);
11133 pub const UCHAR_SENTENCE_BREAK: UProperty = UProperty(4115i32);
11134 pub const UCHAR_WORD_BREAK: UProperty = UProperty(4116i32);
11135 pub const UCHAR_BIDI_PAIRED_BRACKET_TYPE: UProperty = UProperty(4117i32);
11136 pub const UCHAR_INDIC_POSITIONAL_CATEGORY: UProperty = UProperty(4118i32);
11137 pub const UCHAR_INDIC_SYLLABIC_CATEGORY: UProperty = UProperty(4119i32);
11138 pub const UCHAR_VERTICAL_ORIENTATION: UProperty = UProperty(4120i32);
11139 pub const UCHAR_GENERAL_CATEGORY_MASK: UProperty = UProperty(8192i32);
11140 pub const UCHAR_MASK_START: UProperty = UProperty(8192i32);
11141 pub const UCHAR_NUMERIC_VALUE: UProperty = UProperty(12288i32);
11142 pub const UCHAR_DOUBLE_START: UProperty = UProperty(12288i32);
11143 pub const UCHAR_AGE: UProperty = UProperty(16384i32);
11144 pub const UCHAR_STRING_START: UProperty = UProperty(16384i32);
11145 pub const UCHAR_BIDI_MIRRORING_GLYPH: UProperty = UProperty(16385i32);
11146 pub const UCHAR_CASE_FOLDING: UProperty = UProperty(16386i32);
11147 pub const UCHAR_LOWERCASE_MAPPING: UProperty = UProperty(16388i32);
11148 pub const UCHAR_NAME: UProperty = UProperty(16389i32);
11149 pub const UCHAR_SIMPLE_CASE_FOLDING: UProperty = UProperty(16390i32);
11150 pub const UCHAR_SIMPLE_LOWERCASE_MAPPING: UProperty = UProperty(16391i32);
11151 pub const UCHAR_SIMPLE_TITLECASE_MAPPING: UProperty = UProperty(16392i32);
11152 pub const UCHAR_SIMPLE_UPPERCASE_MAPPING: UProperty = UProperty(16393i32);
11153 pub const UCHAR_TITLECASE_MAPPING: UProperty = UProperty(16394i32);
11154 pub const UCHAR_UPPERCASE_MAPPING: UProperty = UProperty(16396i32);
11155 pub const UCHAR_BIDI_PAIRED_BRACKET: UProperty = UProperty(16397i32);
11156 pub const UCHAR_SCRIPT_EXTENSIONS: UProperty = UProperty(28672i32);
11157 pub const UCHAR_OTHER_PROPERTY_START: UProperty = UProperty(28672i32);
11158 pub const UCHAR_INVALID_CODE: UProperty = UProperty(-1i32);
11159 impl ::std::convert::From<i32> for UProperty {
from(value: i32) -> Self11160     fn from(value: i32) -> Self {
11161         Self(value)
11162     }
11163 }
11164 unsafe impl ::windows::runtime::Abi for UProperty {
11165     type Abi = Self;
11166     type DefaultType = Self;
11167 }
11168 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11169 #[repr(transparent)]
11170 pub struct UPropertyNameChoice(pub i32);
11171 pub const U_SHORT_PROPERTY_NAME: UPropertyNameChoice = UPropertyNameChoice(0i32);
11172 pub const U_LONG_PROPERTY_NAME: UPropertyNameChoice = UPropertyNameChoice(1i32);
11173 impl ::std::convert::From<i32> for UPropertyNameChoice {
from(value: i32) -> Self11174     fn from(value: i32) -> Self {
11175         Self(value)
11176     }
11177 }
11178 unsafe impl ::windows::runtime::Abi for UPropertyNameChoice {
11179     type Abi = Self;
11180     type DefaultType = Self;
11181 }
11182 pub type URegexFindProgressCallback = unsafe extern "system" fn(context: *const ::std::ffi::c_void, matchindex: i64) -> i8;
11183 pub type URegexMatchCallback = unsafe extern "system" fn(context: *const ::std::ffi::c_void, steps: i32) -> i8;
11184 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11185 #[repr(transparent)]
11186 pub struct URegexpFlag(pub i32);
11187 pub const UREGEX_CASE_INSENSITIVE: URegexpFlag = URegexpFlag(2i32);
11188 pub const UREGEX_COMMENTS: URegexpFlag = URegexpFlag(4i32);
11189 pub const UREGEX_DOTALL: URegexpFlag = URegexpFlag(32i32);
11190 pub const UREGEX_LITERAL: URegexpFlag = URegexpFlag(16i32);
11191 pub const UREGEX_MULTILINE: URegexpFlag = URegexpFlag(8i32);
11192 pub const UREGEX_UNIX_LINES: URegexpFlag = URegexpFlag(1i32);
11193 pub const UREGEX_UWORD: URegexpFlag = URegexpFlag(256i32);
11194 pub const UREGEX_ERROR_ON_UNKNOWN_ESCAPES: URegexpFlag = URegexpFlag(512i32);
11195 impl ::std::convert::From<i32> for URegexpFlag {
from(value: i32) -> Self11196     fn from(value: i32) -> Self {
11197         Self(value)
11198     }
11199 }
11200 unsafe impl ::windows::runtime::Abi for URegexpFlag {
11201     type Abi = Self;
11202     type DefaultType = Self;
11203 }
11204 #[repr(C)]
11205 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11206 pub struct URegion(pub u8);
11207 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11208 #[repr(transparent)]
11209 pub struct URegionType(pub i32);
11210 pub const URGN_UNKNOWN: URegionType = URegionType(0i32);
11211 pub const URGN_TERRITORY: URegionType = URegionType(1i32);
11212 pub const URGN_WORLD: URegionType = URegionType(2i32);
11213 pub const URGN_CONTINENT: URegionType = URegionType(3i32);
11214 pub const URGN_SUBCONTINENT: URegionType = URegionType(4i32);
11215 pub const URGN_GROUPING: URegionType = URegionType(5i32);
11216 pub const URGN_DEPRECATED: URegionType = URegionType(6i32);
11217 impl ::std::convert::From<i32> for URegionType {
from(value: i32) -> Self11218     fn from(value: i32) -> Self {
11219         Self(value)
11220     }
11221 }
11222 unsafe impl ::windows::runtime::Abi for URegionType {
11223     type Abi = Self;
11224     type DefaultType = Self;
11225 }
11226 #[repr(C)]
11227 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11228 pub struct URegularExpression(pub u8);
11229 #[repr(C)]
11230 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11231 pub struct URelativeDateTimeFormatter(pub u8);
11232 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11233 #[repr(transparent)]
11234 pub struct URelativeDateTimeFormatterField(pub i32);
11235 pub const UDAT_REL_LITERAL_FIELD: URelativeDateTimeFormatterField = URelativeDateTimeFormatterField(0i32);
11236 pub const UDAT_REL_NUMERIC_FIELD: URelativeDateTimeFormatterField = URelativeDateTimeFormatterField(1i32);
11237 impl ::std::convert::From<i32> for URelativeDateTimeFormatterField {
from(value: i32) -> Self11238     fn from(value: i32) -> Self {
11239         Self(value)
11240     }
11241 }
11242 unsafe impl ::windows::runtime::Abi for URelativeDateTimeFormatterField {
11243     type Abi = Self;
11244     type DefaultType = Self;
11245 }
11246 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11247 #[repr(transparent)]
11248 pub struct URelativeDateTimeUnit(pub i32);
11249 pub const UDAT_REL_UNIT_YEAR: URelativeDateTimeUnit = URelativeDateTimeUnit(0i32);
11250 pub const UDAT_REL_UNIT_QUARTER: URelativeDateTimeUnit = URelativeDateTimeUnit(1i32);
11251 pub const UDAT_REL_UNIT_MONTH: URelativeDateTimeUnit = URelativeDateTimeUnit(2i32);
11252 pub const UDAT_REL_UNIT_WEEK: URelativeDateTimeUnit = URelativeDateTimeUnit(3i32);
11253 pub const UDAT_REL_UNIT_DAY: URelativeDateTimeUnit = URelativeDateTimeUnit(4i32);
11254 pub const UDAT_REL_UNIT_HOUR: URelativeDateTimeUnit = URelativeDateTimeUnit(5i32);
11255 pub const UDAT_REL_UNIT_MINUTE: URelativeDateTimeUnit = URelativeDateTimeUnit(6i32);
11256 pub const UDAT_REL_UNIT_SECOND: URelativeDateTimeUnit = URelativeDateTimeUnit(7i32);
11257 pub const UDAT_REL_UNIT_SUNDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(8i32);
11258 pub const UDAT_REL_UNIT_MONDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(9i32);
11259 pub const UDAT_REL_UNIT_TUESDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(10i32);
11260 pub const UDAT_REL_UNIT_WEDNESDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(11i32);
11261 pub const UDAT_REL_UNIT_THURSDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(12i32);
11262 pub const UDAT_REL_UNIT_FRIDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(13i32);
11263 pub const UDAT_REL_UNIT_SATURDAY: URelativeDateTimeUnit = URelativeDateTimeUnit(14i32);
11264 impl ::std::convert::From<i32> for URelativeDateTimeUnit {
from(value: i32) -> Self11265     fn from(value: i32) -> Self {
11266         Self(value)
11267     }
11268 }
11269 unsafe impl ::windows::runtime::Abi for URelativeDateTimeUnit {
11270     type Abi = Self;
11271     type DefaultType = Self;
11272 }
11273 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11274 #[repr(C)]
11275 pub struct UReplaceableCallbacks {
11276     pub length: isize,
11277     pub charAt: isize,
11278     pub char32At: isize,
11279     pub replace: isize,
11280     pub extract: isize,
11281     pub copy: isize,
11282 }
11283 impl UReplaceableCallbacks {}
11284 impl ::std::default::Default for UReplaceableCallbacks {
default() -> Self11285     fn default() -> Self {
11286         unsafe { ::std::mem::zeroed() }
11287     }
11288 }
11289 impl ::std::fmt::Debug for UReplaceableCallbacks {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11290     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11291         fmt.debug_struct("UReplaceableCallbacks").field("length", &self.length).field("charAt", &self.charAt).field("char32At", &self.char32At).field("replace", &self.replace).field("extract", &self.extract).field("copy", &self.copy).finish()
11292     }
11293 }
11294 impl ::std::cmp::PartialEq for UReplaceableCallbacks {
eq(&self, other: &Self) -> bool11295     fn eq(&self, other: &Self) -> bool {
11296         self.length == other.length && self.charAt == other.charAt && self.char32At == other.char32At && self.replace == other.replace && self.extract == other.extract && self.copy == other.copy
11297     }
11298 }
11299 impl ::std::cmp::Eq for UReplaceableCallbacks {}
11300 unsafe impl ::windows::runtime::Abi for UReplaceableCallbacks {
11301     type Abi = Self;
11302     type DefaultType = Self;
11303 }
11304 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11305 #[repr(transparent)]
11306 pub struct UResType(pub i32);
11307 pub const URES_NONE: UResType = UResType(-1i32);
11308 pub const URES_STRING: UResType = UResType(0i32);
11309 pub const URES_BINARY: UResType = UResType(1i32);
11310 pub const URES_TABLE: UResType = UResType(2i32);
11311 pub const URES_ALIAS: UResType = UResType(3i32);
11312 pub const URES_INT: UResType = UResType(7i32);
11313 pub const URES_ARRAY: UResType = UResType(8i32);
11314 pub const URES_INT_VECTOR: UResType = UResType(14i32);
11315 impl ::std::convert::From<i32> for UResType {
from(value: i32) -> Self11316     fn from(value: i32) -> Self {
11317         Self(value)
11318     }
11319 }
11320 unsafe impl ::windows::runtime::Abi for UResType {
11321     type Abi = Self;
11322     type DefaultType = Self;
11323 }
11324 #[repr(C)]
11325 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11326 pub struct UResourceBundle(pub u8);
11327 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11328 #[repr(transparent)]
11329 pub struct URestrictionLevel(pub i32);
11330 pub const USPOOF_ASCII: URestrictionLevel = URestrictionLevel(268435456i32);
11331 pub const USPOOF_SINGLE_SCRIPT_RESTRICTIVE: URestrictionLevel = URestrictionLevel(536870912i32);
11332 pub const USPOOF_HIGHLY_RESTRICTIVE: URestrictionLevel = URestrictionLevel(805306368i32);
11333 pub const USPOOF_MODERATELY_RESTRICTIVE: URestrictionLevel = URestrictionLevel(1073741824i32);
11334 pub const USPOOF_MINIMALLY_RESTRICTIVE: URestrictionLevel = URestrictionLevel(1342177280i32);
11335 pub const USPOOF_UNRESTRICTIVE: URestrictionLevel = URestrictionLevel(1610612736i32);
11336 pub const USPOOF_RESTRICTION_LEVEL_MASK: URestrictionLevel = URestrictionLevel(2130706432i32);
11337 impl ::std::convert::From<i32> for URestrictionLevel {
from(value: i32) -> Self11338     fn from(value: i32) -> Self {
11339         Self(value)
11340     }
11341 }
11342 unsafe impl ::windows::runtime::Abi for URestrictionLevel {
11343     type Abi = Self;
11344     type DefaultType = Self;
11345 }
11346 pub const USEARCH_DONE: i32 = -1i32;
11347 pub const USET_ADD_CASE_MAPPINGS: i32 = 4i32;
11348 pub const USET_CASE_INSENSITIVE: i32 = 2i32;
11349 pub const USET_IGNORE_SPACE: i32 = 1i32;
11350 pub const USET_SERIALIZED_STATIC_ARRAY_CAPACITY: i32 = 8i32;
11351 pub const USPREP_ALLOW_UNASSIGNED: u32 = 1u32;
11352 pub const USPREP_DEFAULT: u32 = 0u32;
11353 pub const USP_E_SCRIPT_NOT_IN_FONT: ::windows::runtime::HRESULT = ::windows::runtime::HRESULT(-2147220992i32 as _);
11354 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11355 #[repr(transparent)]
11356 pub struct UScriptCode(pub i32);
11357 pub const USCRIPT_INVALID_CODE: UScriptCode = UScriptCode(-1i32);
11358 pub const USCRIPT_COMMON: UScriptCode = UScriptCode(0i32);
11359 pub const USCRIPT_INHERITED: UScriptCode = UScriptCode(1i32);
11360 pub const USCRIPT_ARABIC: UScriptCode = UScriptCode(2i32);
11361 pub const USCRIPT_ARMENIAN: UScriptCode = UScriptCode(3i32);
11362 pub const USCRIPT_BENGALI: UScriptCode = UScriptCode(4i32);
11363 pub const USCRIPT_BOPOMOFO: UScriptCode = UScriptCode(5i32);
11364 pub const USCRIPT_CHEROKEE: UScriptCode = UScriptCode(6i32);
11365 pub const USCRIPT_COPTIC: UScriptCode = UScriptCode(7i32);
11366 pub const USCRIPT_CYRILLIC: UScriptCode = UScriptCode(8i32);
11367 pub const USCRIPT_DESERET: UScriptCode = UScriptCode(9i32);
11368 pub const USCRIPT_DEVANAGARI: UScriptCode = UScriptCode(10i32);
11369 pub const USCRIPT_ETHIOPIC: UScriptCode = UScriptCode(11i32);
11370 pub const USCRIPT_GEORGIAN: UScriptCode = UScriptCode(12i32);
11371 pub const USCRIPT_GOTHIC: UScriptCode = UScriptCode(13i32);
11372 pub const USCRIPT_GREEK: UScriptCode = UScriptCode(14i32);
11373 pub const USCRIPT_GUJARATI: UScriptCode = UScriptCode(15i32);
11374 pub const USCRIPT_GURMUKHI: UScriptCode = UScriptCode(16i32);
11375 pub const USCRIPT_HAN: UScriptCode = UScriptCode(17i32);
11376 pub const USCRIPT_HANGUL: UScriptCode = UScriptCode(18i32);
11377 pub const USCRIPT_HEBREW: UScriptCode = UScriptCode(19i32);
11378 pub const USCRIPT_HIRAGANA: UScriptCode = UScriptCode(20i32);
11379 pub const USCRIPT_KANNADA: UScriptCode = UScriptCode(21i32);
11380 pub const USCRIPT_KATAKANA: UScriptCode = UScriptCode(22i32);
11381 pub const USCRIPT_KHMER: UScriptCode = UScriptCode(23i32);
11382 pub const USCRIPT_LAO: UScriptCode = UScriptCode(24i32);
11383 pub const USCRIPT_LATIN: UScriptCode = UScriptCode(25i32);
11384 pub const USCRIPT_MALAYALAM: UScriptCode = UScriptCode(26i32);
11385 pub const USCRIPT_MONGOLIAN: UScriptCode = UScriptCode(27i32);
11386 pub const USCRIPT_MYANMAR: UScriptCode = UScriptCode(28i32);
11387 pub const USCRIPT_OGHAM: UScriptCode = UScriptCode(29i32);
11388 pub const USCRIPT_OLD_ITALIC: UScriptCode = UScriptCode(30i32);
11389 pub const USCRIPT_ORIYA: UScriptCode = UScriptCode(31i32);
11390 pub const USCRIPT_RUNIC: UScriptCode = UScriptCode(32i32);
11391 pub const USCRIPT_SINHALA: UScriptCode = UScriptCode(33i32);
11392 pub const USCRIPT_SYRIAC: UScriptCode = UScriptCode(34i32);
11393 pub const USCRIPT_TAMIL: UScriptCode = UScriptCode(35i32);
11394 pub const USCRIPT_TELUGU: UScriptCode = UScriptCode(36i32);
11395 pub const USCRIPT_THAANA: UScriptCode = UScriptCode(37i32);
11396 pub const USCRIPT_THAI: UScriptCode = UScriptCode(38i32);
11397 pub const USCRIPT_TIBETAN: UScriptCode = UScriptCode(39i32);
11398 pub const USCRIPT_CANADIAN_ABORIGINAL: UScriptCode = UScriptCode(40i32);
11399 pub const USCRIPT_UCAS: UScriptCode = UScriptCode(40i32);
11400 pub const USCRIPT_YI: UScriptCode = UScriptCode(41i32);
11401 pub const USCRIPT_TAGALOG: UScriptCode = UScriptCode(42i32);
11402 pub const USCRIPT_HANUNOO: UScriptCode = UScriptCode(43i32);
11403 pub const USCRIPT_BUHID: UScriptCode = UScriptCode(44i32);
11404 pub const USCRIPT_TAGBANWA: UScriptCode = UScriptCode(45i32);
11405 pub const USCRIPT_BRAILLE: UScriptCode = UScriptCode(46i32);
11406 pub const USCRIPT_CYPRIOT: UScriptCode = UScriptCode(47i32);
11407 pub const USCRIPT_LIMBU: UScriptCode = UScriptCode(48i32);
11408 pub const USCRIPT_LINEAR_B: UScriptCode = UScriptCode(49i32);
11409 pub const USCRIPT_OSMANYA: UScriptCode = UScriptCode(50i32);
11410 pub const USCRIPT_SHAVIAN: UScriptCode = UScriptCode(51i32);
11411 pub const USCRIPT_TAI_LE: UScriptCode = UScriptCode(52i32);
11412 pub const USCRIPT_UGARITIC: UScriptCode = UScriptCode(53i32);
11413 pub const USCRIPT_KATAKANA_OR_HIRAGANA: UScriptCode = UScriptCode(54i32);
11414 pub const USCRIPT_BUGINESE: UScriptCode = UScriptCode(55i32);
11415 pub const USCRIPT_GLAGOLITIC: UScriptCode = UScriptCode(56i32);
11416 pub const USCRIPT_KHAROSHTHI: UScriptCode = UScriptCode(57i32);
11417 pub const USCRIPT_SYLOTI_NAGRI: UScriptCode = UScriptCode(58i32);
11418 pub const USCRIPT_NEW_TAI_LUE: UScriptCode = UScriptCode(59i32);
11419 pub const USCRIPT_TIFINAGH: UScriptCode = UScriptCode(60i32);
11420 pub const USCRIPT_OLD_PERSIAN: UScriptCode = UScriptCode(61i32);
11421 pub const USCRIPT_BALINESE: UScriptCode = UScriptCode(62i32);
11422 pub const USCRIPT_BATAK: UScriptCode = UScriptCode(63i32);
11423 pub const USCRIPT_BLISSYMBOLS: UScriptCode = UScriptCode(64i32);
11424 pub const USCRIPT_BRAHMI: UScriptCode = UScriptCode(65i32);
11425 pub const USCRIPT_CHAM: UScriptCode = UScriptCode(66i32);
11426 pub const USCRIPT_CIRTH: UScriptCode = UScriptCode(67i32);
11427 pub const USCRIPT_OLD_CHURCH_SLAVONIC_CYRILLIC: UScriptCode = UScriptCode(68i32);
11428 pub const USCRIPT_DEMOTIC_EGYPTIAN: UScriptCode = UScriptCode(69i32);
11429 pub const USCRIPT_HIERATIC_EGYPTIAN: UScriptCode = UScriptCode(70i32);
11430 pub const USCRIPT_EGYPTIAN_HIEROGLYPHS: UScriptCode = UScriptCode(71i32);
11431 pub const USCRIPT_KHUTSURI: UScriptCode = UScriptCode(72i32);
11432 pub const USCRIPT_SIMPLIFIED_HAN: UScriptCode = UScriptCode(73i32);
11433 pub const USCRIPT_TRADITIONAL_HAN: UScriptCode = UScriptCode(74i32);
11434 pub const USCRIPT_PAHAWH_HMONG: UScriptCode = UScriptCode(75i32);
11435 pub const USCRIPT_OLD_HUNGARIAN: UScriptCode = UScriptCode(76i32);
11436 pub const USCRIPT_HARAPPAN_INDUS: UScriptCode = UScriptCode(77i32);
11437 pub const USCRIPT_JAVANESE: UScriptCode = UScriptCode(78i32);
11438 pub const USCRIPT_KAYAH_LI: UScriptCode = UScriptCode(79i32);
11439 pub const USCRIPT_LATIN_FRAKTUR: UScriptCode = UScriptCode(80i32);
11440 pub const USCRIPT_LATIN_GAELIC: UScriptCode = UScriptCode(81i32);
11441 pub const USCRIPT_LEPCHA: UScriptCode = UScriptCode(82i32);
11442 pub const USCRIPT_LINEAR_A: UScriptCode = UScriptCode(83i32);
11443 pub const USCRIPT_MANDAIC: UScriptCode = UScriptCode(84i32);
11444 pub const USCRIPT_MANDAEAN: UScriptCode = UScriptCode(84i32);
11445 pub const USCRIPT_MAYAN_HIEROGLYPHS: UScriptCode = UScriptCode(85i32);
11446 pub const USCRIPT_MEROITIC_HIEROGLYPHS: UScriptCode = UScriptCode(86i32);
11447 pub const USCRIPT_MEROITIC: UScriptCode = UScriptCode(86i32);
11448 pub const USCRIPT_NKO: UScriptCode = UScriptCode(87i32);
11449 pub const USCRIPT_ORKHON: UScriptCode = UScriptCode(88i32);
11450 pub const USCRIPT_OLD_PERMIC: UScriptCode = UScriptCode(89i32);
11451 pub const USCRIPT_PHAGS_PA: UScriptCode = UScriptCode(90i32);
11452 pub const USCRIPT_PHOENICIAN: UScriptCode = UScriptCode(91i32);
11453 pub const USCRIPT_MIAO: UScriptCode = UScriptCode(92i32);
11454 pub const USCRIPT_PHONETIC_POLLARD: UScriptCode = UScriptCode(92i32);
11455 pub const USCRIPT_RONGORONGO: UScriptCode = UScriptCode(93i32);
11456 pub const USCRIPT_SARATI: UScriptCode = UScriptCode(94i32);
11457 pub const USCRIPT_ESTRANGELO_SYRIAC: UScriptCode = UScriptCode(95i32);
11458 pub const USCRIPT_WESTERN_SYRIAC: UScriptCode = UScriptCode(96i32);
11459 pub const USCRIPT_EASTERN_SYRIAC: UScriptCode = UScriptCode(97i32);
11460 pub const USCRIPT_TENGWAR: UScriptCode = UScriptCode(98i32);
11461 pub const USCRIPT_VAI: UScriptCode = UScriptCode(99i32);
11462 pub const USCRIPT_VISIBLE_SPEECH: UScriptCode = UScriptCode(100i32);
11463 pub const USCRIPT_CUNEIFORM: UScriptCode = UScriptCode(101i32);
11464 pub const USCRIPT_UNWRITTEN_LANGUAGES: UScriptCode = UScriptCode(102i32);
11465 pub const USCRIPT_UNKNOWN: UScriptCode = UScriptCode(103i32);
11466 pub const USCRIPT_CARIAN: UScriptCode = UScriptCode(104i32);
11467 pub const USCRIPT_JAPANESE: UScriptCode = UScriptCode(105i32);
11468 pub const USCRIPT_LANNA: UScriptCode = UScriptCode(106i32);
11469 pub const USCRIPT_LYCIAN: UScriptCode = UScriptCode(107i32);
11470 pub const USCRIPT_LYDIAN: UScriptCode = UScriptCode(108i32);
11471 pub const USCRIPT_OL_CHIKI: UScriptCode = UScriptCode(109i32);
11472 pub const USCRIPT_REJANG: UScriptCode = UScriptCode(110i32);
11473 pub const USCRIPT_SAURASHTRA: UScriptCode = UScriptCode(111i32);
11474 pub const USCRIPT_SIGN_WRITING: UScriptCode = UScriptCode(112i32);
11475 pub const USCRIPT_SUNDANESE: UScriptCode = UScriptCode(113i32);
11476 pub const USCRIPT_MOON: UScriptCode = UScriptCode(114i32);
11477 pub const USCRIPT_MEITEI_MAYEK: UScriptCode = UScriptCode(115i32);
11478 pub const USCRIPT_IMPERIAL_ARAMAIC: UScriptCode = UScriptCode(116i32);
11479 pub const USCRIPT_AVESTAN: UScriptCode = UScriptCode(117i32);
11480 pub const USCRIPT_CHAKMA: UScriptCode = UScriptCode(118i32);
11481 pub const USCRIPT_KOREAN: UScriptCode = UScriptCode(119i32);
11482 pub const USCRIPT_KAITHI: UScriptCode = UScriptCode(120i32);
11483 pub const USCRIPT_MANICHAEAN: UScriptCode = UScriptCode(121i32);
11484 pub const USCRIPT_INSCRIPTIONAL_PAHLAVI: UScriptCode = UScriptCode(122i32);
11485 pub const USCRIPT_PSALTER_PAHLAVI: UScriptCode = UScriptCode(123i32);
11486 pub const USCRIPT_BOOK_PAHLAVI: UScriptCode = UScriptCode(124i32);
11487 pub const USCRIPT_INSCRIPTIONAL_PARTHIAN: UScriptCode = UScriptCode(125i32);
11488 pub const USCRIPT_SAMARITAN: UScriptCode = UScriptCode(126i32);
11489 pub const USCRIPT_TAI_VIET: UScriptCode = UScriptCode(127i32);
11490 pub const USCRIPT_MATHEMATICAL_NOTATION: UScriptCode = UScriptCode(128i32);
11491 pub const USCRIPT_SYMBOLS: UScriptCode = UScriptCode(129i32);
11492 pub const USCRIPT_BAMUM: UScriptCode = UScriptCode(130i32);
11493 pub const USCRIPT_LISU: UScriptCode = UScriptCode(131i32);
11494 pub const USCRIPT_NAKHI_GEBA: UScriptCode = UScriptCode(132i32);
11495 pub const USCRIPT_OLD_SOUTH_ARABIAN: UScriptCode = UScriptCode(133i32);
11496 pub const USCRIPT_BASSA_VAH: UScriptCode = UScriptCode(134i32);
11497 pub const USCRIPT_DUPLOYAN: UScriptCode = UScriptCode(135i32);
11498 pub const USCRIPT_ELBASAN: UScriptCode = UScriptCode(136i32);
11499 pub const USCRIPT_GRANTHA: UScriptCode = UScriptCode(137i32);
11500 pub const USCRIPT_KPELLE: UScriptCode = UScriptCode(138i32);
11501 pub const USCRIPT_LOMA: UScriptCode = UScriptCode(139i32);
11502 pub const USCRIPT_MENDE: UScriptCode = UScriptCode(140i32);
11503 pub const USCRIPT_MEROITIC_CURSIVE: UScriptCode = UScriptCode(141i32);
11504 pub const USCRIPT_OLD_NORTH_ARABIAN: UScriptCode = UScriptCode(142i32);
11505 pub const USCRIPT_NABATAEAN: UScriptCode = UScriptCode(143i32);
11506 pub const USCRIPT_PALMYRENE: UScriptCode = UScriptCode(144i32);
11507 pub const USCRIPT_KHUDAWADI: UScriptCode = UScriptCode(145i32);
11508 pub const USCRIPT_SINDHI: UScriptCode = UScriptCode(145i32);
11509 pub const USCRIPT_WARANG_CITI: UScriptCode = UScriptCode(146i32);
11510 pub const USCRIPT_AFAKA: UScriptCode = UScriptCode(147i32);
11511 pub const USCRIPT_JURCHEN: UScriptCode = UScriptCode(148i32);
11512 pub const USCRIPT_MRO: UScriptCode = UScriptCode(149i32);
11513 pub const USCRIPT_NUSHU: UScriptCode = UScriptCode(150i32);
11514 pub const USCRIPT_SHARADA: UScriptCode = UScriptCode(151i32);
11515 pub const USCRIPT_SORA_SOMPENG: UScriptCode = UScriptCode(152i32);
11516 pub const USCRIPT_TAKRI: UScriptCode = UScriptCode(153i32);
11517 pub const USCRIPT_TANGUT: UScriptCode = UScriptCode(154i32);
11518 pub const USCRIPT_WOLEAI: UScriptCode = UScriptCode(155i32);
11519 pub const USCRIPT_ANATOLIAN_HIEROGLYPHS: UScriptCode = UScriptCode(156i32);
11520 pub const USCRIPT_KHOJKI: UScriptCode = UScriptCode(157i32);
11521 pub const USCRIPT_TIRHUTA: UScriptCode = UScriptCode(158i32);
11522 pub const USCRIPT_CAUCASIAN_ALBANIAN: UScriptCode = UScriptCode(159i32);
11523 pub const USCRIPT_MAHAJANI: UScriptCode = UScriptCode(160i32);
11524 pub const USCRIPT_AHOM: UScriptCode = UScriptCode(161i32);
11525 pub const USCRIPT_HATRAN: UScriptCode = UScriptCode(162i32);
11526 pub const USCRIPT_MODI: UScriptCode = UScriptCode(163i32);
11527 pub const USCRIPT_MULTANI: UScriptCode = UScriptCode(164i32);
11528 pub const USCRIPT_PAU_CIN_HAU: UScriptCode = UScriptCode(165i32);
11529 pub const USCRIPT_SIDDHAM: UScriptCode = UScriptCode(166i32);
11530 pub const USCRIPT_ADLAM: UScriptCode = UScriptCode(167i32);
11531 pub const USCRIPT_BHAIKSUKI: UScriptCode = UScriptCode(168i32);
11532 pub const USCRIPT_MARCHEN: UScriptCode = UScriptCode(169i32);
11533 pub const USCRIPT_NEWA: UScriptCode = UScriptCode(170i32);
11534 pub const USCRIPT_OSAGE: UScriptCode = UScriptCode(171i32);
11535 pub const USCRIPT_HAN_WITH_BOPOMOFO: UScriptCode = UScriptCode(172i32);
11536 pub const USCRIPT_JAMO: UScriptCode = UScriptCode(173i32);
11537 pub const USCRIPT_SYMBOLS_EMOJI: UScriptCode = UScriptCode(174i32);
11538 pub const USCRIPT_MASARAM_GONDI: UScriptCode = UScriptCode(175i32);
11539 pub const USCRIPT_SOYOMBO: UScriptCode = UScriptCode(176i32);
11540 pub const USCRIPT_ZANABAZAR_SQUARE: UScriptCode = UScriptCode(177i32);
11541 pub const USCRIPT_DOGRA: UScriptCode = UScriptCode(178i32);
11542 pub const USCRIPT_GUNJALA_GONDI: UScriptCode = UScriptCode(179i32);
11543 pub const USCRIPT_MAKASAR: UScriptCode = UScriptCode(180i32);
11544 pub const USCRIPT_MEDEFAIDRIN: UScriptCode = UScriptCode(181i32);
11545 pub const USCRIPT_HANIFI_ROHINGYA: UScriptCode = UScriptCode(182i32);
11546 pub const USCRIPT_SOGDIAN: UScriptCode = UScriptCode(183i32);
11547 pub const USCRIPT_OLD_SOGDIAN: UScriptCode = UScriptCode(184i32);
11548 pub const USCRIPT_ELYMAIC: UScriptCode = UScriptCode(185i32);
11549 pub const USCRIPT_NYIAKENG_PUACHUE_HMONG: UScriptCode = UScriptCode(186i32);
11550 pub const USCRIPT_NANDINAGARI: UScriptCode = UScriptCode(187i32);
11551 pub const USCRIPT_WANCHO: UScriptCode = UScriptCode(188i32);
11552 pub const USCRIPT_CHORASMIAN: UScriptCode = UScriptCode(189i32);
11553 pub const USCRIPT_DIVES_AKURU: UScriptCode = UScriptCode(190i32);
11554 pub const USCRIPT_KHITAN_SMALL_SCRIPT: UScriptCode = UScriptCode(191i32);
11555 pub const USCRIPT_YEZIDI: UScriptCode = UScriptCode(192i32);
11556 impl ::std::convert::From<i32> for UScriptCode {
from(value: i32) -> Self11557     fn from(value: i32) -> Self {
11558         Self(value)
11559     }
11560 }
11561 unsafe impl ::windows::runtime::Abi for UScriptCode {
11562     type Abi = Self;
11563     type DefaultType = Self;
11564 }
11565 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11566 #[repr(transparent)]
11567 pub struct UScriptUsage(pub i32);
11568 pub const USCRIPT_USAGE_NOT_ENCODED: UScriptUsage = UScriptUsage(0i32);
11569 pub const USCRIPT_USAGE_UNKNOWN: UScriptUsage = UScriptUsage(1i32);
11570 pub const USCRIPT_USAGE_EXCLUDED: UScriptUsage = UScriptUsage(2i32);
11571 pub const USCRIPT_USAGE_LIMITED_USE: UScriptUsage = UScriptUsage(3i32);
11572 pub const USCRIPT_USAGE_ASPIRATIONAL: UScriptUsage = UScriptUsage(4i32);
11573 pub const USCRIPT_USAGE_RECOMMENDED: UScriptUsage = UScriptUsage(5i32);
11574 impl ::std::convert::From<i32> for UScriptUsage {
from(value: i32) -> Self11575     fn from(value: i32) -> Self {
11576         Self(value)
11577     }
11578 }
11579 unsafe impl ::windows::runtime::Abi for UScriptUsage {
11580     type Abi = Self;
11581     type DefaultType = Self;
11582 }
11583 #[repr(C)]
11584 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11585 pub struct USearch(pub u8);
11586 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11587 #[repr(transparent)]
11588 pub struct USearchAttribute(pub i32);
11589 pub const USEARCH_OVERLAP: USearchAttribute = USearchAttribute(0i32);
11590 pub const USEARCH_ELEMENT_COMPARISON: USearchAttribute = USearchAttribute(2i32);
11591 impl ::std::convert::From<i32> for USearchAttribute {
from(value: i32) -> Self11592     fn from(value: i32) -> Self {
11593         Self(value)
11594     }
11595 }
11596 unsafe impl ::windows::runtime::Abi for USearchAttribute {
11597     type Abi = Self;
11598     type DefaultType = Self;
11599 }
11600 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11601 #[repr(transparent)]
11602 pub struct USearchAttributeValue(pub i32);
11603 pub const USEARCH_DEFAULT: USearchAttributeValue = USearchAttributeValue(-1i32);
11604 pub const USEARCH_OFF: USearchAttributeValue = USearchAttributeValue(0i32);
11605 pub const USEARCH_ON: USearchAttributeValue = USearchAttributeValue(1i32);
11606 pub const USEARCH_STANDARD_ELEMENT_COMPARISON: USearchAttributeValue = USearchAttributeValue(2i32);
11607 pub const USEARCH_PATTERN_BASE_WEIGHT_IS_WILDCARD: USearchAttributeValue = USearchAttributeValue(3i32);
11608 pub const USEARCH_ANY_BASE_WEIGHT_IS_WILDCARD: USearchAttributeValue = USearchAttributeValue(4i32);
11609 impl ::std::convert::From<i32> for USearchAttributeValue {
from(value: i32) -> Self11610     fn from(value: i32) -> Self {
11611         Self(value)
11612     }
11613 }
11614 unsafe impl ::windows::runtime::Abi for USearchAttributeValue {
11615     type Abi = Self;
11616     type DefaultType = Self;
11617 }
11618 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11619 #[repr(transparent)]
11620 pub struct USentenceBreak(pub i32);
11621 pub const U_SB_OTHER: USentenceBreak = USentenceBreak(0i32);
11622 pub const U_SB_ATERM: USentenceBreak = USentenceBreak(1i32);
11623 pub const U_SB_CLOSE: USentenceBreak = USentenceBreak(2i32);
11624 pub const U_SB_FORMAT: USentenceBreak = USentenceBreak(3i32);
11625 pub const U_SB_LOWER: USentenceBreak = USentenceBreak(4i32);
11626 pub const U_SB_NUMERIC: USentenceBreak = USentenceBreak(5i32);
11627 pub const U_SB_OLETTER: USentenceBreak = USentenceBreak(6i32);
11628 pub const U_SB_SEP: USentenceBreak = USentenceBreak(7i32);
11629 pub const U_SB_SP: USentenceBreak = USentenceBreak(8i32);
11630 pub const U_SB_STERM: USentenceBreak = USentenceBreak(9i32);
11631 pub const U_SB_UPPER: USentenceBreak = USentenceBreak(10i32);
11632 pub const U_SB_CR: USentenceBreak = USentenceBreak(11i32);
11633 pub const U_SB_EXTEND: USentenceBreak = USentenceBreak(12i32);
11634 pub const U_SB_LF: USentenceBreak = USentenceBreak(13i32);
11635 pub const U_SB_SCONTINUE: USentenceBreak = USentenceBreak(14i32);
11636 impl ::std::convert::From<i32> for USentenceBreak {
from(value: i32) -> Self11637     fn from(value: i32) -> Self {
11638         Self(value)
11639     }
11640 }
11641 unsafe impl ::windows::runtime::Abi for USentenceBreak {
11642     type Abi = Self;
11643     type DefaultType = Self;
11644 }
11645 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11646 #[repr(transparent)]
11647 pub struct USentenceBreakTag(pub i32);
11648 pub const UBRK_SENTENCE_TERM: USentenceBreakTag = USentenceBreakTag(0i32);
11649 pub const UBRK_SENTENCE_TERM_LIMIT: USentenceBreakTag = USentenceBreakTag(100i32);
11650 pub const UBRK_SENTENCE_SEP: USentenceBreakTag = USentenceBreakTag(100i32);
11651 pub const UBRK_SENTENCE_SEP_LIMIT: USentenceBreakTag = USentenceBreakTag(200i32);
11652 impl ::std::convert::From<i32> for USentenceBreakTag {
from(value: i32) -> Self11653     fn from(value: i32) -> Self {
11654         Self(value)
11655     }
11656 }
11657 unsafe impl ::windows::runtime::Abi for USentenceBreakTag {
11658     type Abi = Self;
11659     type DefaultType = Self;
11660 }
11661 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11662 #[repr(C)]
11663 pub struct USerializedSet {
11664     pub array: *mut u16,
11665     pub bmpLength: i32,
11666     pub length: i32,
11667     pub staticArray: [u16; 8],
11668 }
11669 impl USerializedSet {}
11670 impl ::std::default::Default for USerializedSet {
default() -> Self11671     fn default() -> Self {
11672         unsafe { ::std::mem::zeroed() }
11673     }
11674 }
11675 impl ::std::fmt::Debug for USerializedSet {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11676     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11677         fmt.debug_struct("USerializedSet").field("array", &self.array).field("bmpLength", &self.bmpLength).field("length", &self.length).field("staticArray", &self.staticArray).finish()
11678     }
11679 }
11680 impl ::std::cmp::PartialEq for USerializedSet {
eq(&self, other: &Self) -> bool11681     fn eq(&self, other: &Self) -> bool {
11682         self.array == other.array && self.bmpLength == other.bmpLength && self.length == other.length && self.staticArray == other.staticArray
11683     }
11684 }
11685 impl ::std::cmp::Eq for USerializedSet {}
11686 unsafe impl ::windows::runtime::Abi for USerializedSet {
11687     type Abi = Self;
11688     type DefaultType = Self;
11689 }
11690 #[repr(C)]
11691 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11692 pub struct USet(pub u8);
11693 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11694 #[repr(transparent)]
11695 pub struct USetSpanCondition(pub i32);
11696 pub const USET_SPAN_NOT_CONTAINED: USetSpanCondition = USetSpanCondition(0i32);
11697 pub const USET_SPAN_CONTAINED: USetSpanCondition = USetSpanCondition(1i32);
11698 pub const USET_SPAN_SIMPLE: USetSpanCondition = USetSpanCondition(2i32);
11699 impl ::std::convert::From<i32> for USetSpanCondition {
from(value: i32) -> Self11700     fn from(value: i32) -> Self {
11701         Self(value)
11702     }
11703 }
11704 unsafe impl ::windows::runtime::Abi for USetSpanCondition {
11705     type Abi = Self;
11706     type DefaultType = Self;
11707 }
11708 #[repr(C)]
11709 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11710 pub struct USpoofCheckResult(pub u8);
11711 #[repr(C)]
11712 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11713 pub struct USpoofChecker(pub u8);
11714 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11715 #[repr(transparent)]
11716 pub struct USpoofChecks(pub i32);
11717 pub const USPOOF_SINGLE_SCRIPT_CONFUSABLE: USpoofChecks = USpoofChecks(1i32);
11718 pub const USPOOF_MIXED_SCRIPT_CONFUSABLE: USpoofChecks = USpoofChecks(2i32);
11719 pub const USPOOF_WHOLE_SCRIPT_CONFUSABLE: USpoofChecks = USpoofChecks(4i32);
11720 pub const USPOOF_CONFUSABLE: USpoofChecks = USpoofChecks(7i32);
11721 pub const USPOOF_RESTRICTION_LEVEL: USpoofChecks = USpoofChecks(16i32);
11722 pub const USPOOF_INVISIBLE: USpoofChecks = USpoofChecks(32i32);
11723 pub const USPOOF_CHAR_LIMIT: USpoofChecks = USpoofChecks(64i32);
11724 pub const USPOOF_MIXED_NUMBERS: USpoofChecks = USpoofChecks(128i32);
11725 pub const USPOOF_HIDDEN_OVERLAY: USpoofChecks = USpoofChecks(256i32);
11726 pub const USPOOF_ALL_CHECKS: USpoofChecks = USpoofChecks(65535i32);
11727 pub const USPOOF_AUX_INFO: USpoofChecks = USpoofChecks(1073741824i32);
11728 impl ::std::convert::From<i32> for USpoofChecks {
from(value: i32) -> Self11729     fn from(value: i32) -> Self {
11730         Self(value)
11731     }
11732 }
11733 unsafe impl ::windows::runtime::Abi for USpoofChecks {
11734     type Abi = Self;
11735     type DefaultType = Self;
11736 }
11737 pub type UStringCaseMapper = unsafe extern "system" fn(csm: *const UCaseMap, dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
11738 #[repr(C)]
11739 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11740 pub struct UStringPrepProfile(pub u8);
11741 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11742 #[repr(transparent)]
11743 pub struct UStringPrepProfileType(pub i32);
11744 pub const USPREP_RFC3491_NAMEPREP: UStringPrepProfileType = UStringPrepProfileType(0i32);
11745 pub const USPREP_RFC3530_NFS4_CS_PREP: UStringPrepProfileType = UStringPrepProfileType(1i32);
11746 pub const USPREP_RFC3530_NFS4_CS_PREP_CI: UStringPrepProfileType = UStringPrepProfileType(2i32);
11747 pub const USPREP_RFC3530_NFS4_CIS_PREP: UStringPrepProfileType = UStringPrepProfileType(3i32);
11748 pub const USPREP_RFC3530_NFS4_MIXED_PREP_PREFIX: UStringPrepProfileType = UStringPrepProfileType(4i32);
11749 pub const USPREP_RFC3530_NFS4_MIXED_PREP_SUFFIX: UStringPrepProfileType = UStringPrepProfileType(5i32);
11750 pub const USPREP_RFC3722_ISCSI: UStringPrepProfileType = UStringPrepProfileType(6i32);
11751 pub const USPREP_RFC3920_NODEPREP: UStringPrepProfileType = UStringPrepProfileType(7i32);
11752 pub const USPREP_RFC3920_RESOURCEPREP: UStringPrepProfileType = UStringPrepProfileType(8i32);
11753 pub const USPREP_RFC4011_MIB: UStringPrepProfileType = UStringPrepProfileType(9i32);
11754 pub const USPREP_RFC4013_SASLPREP: UStringPrepProfileType = UStringPrepProfileType(10i32);
11755 pub const USPREP_RFC4505_TRACE: UStringPrepProfileType = UStringPrepProfileType(11i32);
11756 pub const USPREP_RFC4518_LDAP: UStringPrepProfileType = UStringPrepProfileType(12i32);
11757 pub const USPREP_RFC4518_LDAP_CI: UStringPrepProfileType = UStringPrepProfileType(13i32);
11758 impl ::std::convert::From<i32> for UStringPrepProfileType {
from(value: i32) -> Self11759     fn from(value: i32) -> Self {
11760         Self(value)
11761     }
11762 }
11763 unsafe impl ::windows::runtime::Abi for UStringPrepProfileType {
11764     type Abi = Self;
11765     type DefaultType = Self;
11766 }
11767 #[repr(C)]
11768 #[derive(:: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug, :: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy)]
11769 pub struct UStringSearch(pub u8);
11770 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11771 #[repr(transparent)]
11772 pub struct UStringTrieBuildOption(pub i32);
11773 pub const USTRINGTRIE_BUILD_FAST: UStringTrieBuildOption = UStringTrieBuildOption(0i32);
11774 pub const USTRINGTRIE_BUILD_SMALL: UStringTrieBuildOption = UStringTrieBuildOption(1i32);
11775 impl ::std::convert::From<i32> for UStringTrieBuildOption {
from(value: i32) -> Self11776     fn from(value: i32) -> Self {
11777         Self(value)
11778     }
11779 }
11780 unsafe impl ::windows::runtime::Abi for UStringTrieBuildOption {
11781     type Abi = Self;
11782     type DefaultType = Self;
11783 }
11784 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11785 #[repr(transparent)]
11786 pub struct UStringTrieResult(pub i32);
11787 pub const USTRINGTRIE_NO_MATCH: UStringTrieResult = UStringTrieResult(0i32);
11788 pub const USTRINGTRIE_NO_VALUE: UStringTrieResult = UStringTrieResult(1i32);
11789 pub const USTRINGTRIE_FINAL_VALUE: UStringTrieResult = UStringTrieResult(2i32);
11790 pub const USTRINGTRIE_INTERMEDIATE_VALUE: UStringTrieResult = UStringTrieResult(3i32);
11791 impl ::std::convert::From<i32> for UStringTrieResult {
from(value: i32) -> Self11792     fn from(value: i32) -> Self {
11793         Self(value)
11794     }
11795 }
11796 unsafe impl ::windows::runtime::Abi for UStringTrieResult {
11797     type Abi = Self;
11798     type DefaultType = Self;
11799 }
11800 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11801 #[repr(transparent)]
11802 pub struct USystemTimeZoneType(pub i32);
11803 pub const UCAL_ZONE_TYPE_ANY: USystemTimeZoneType = USystemTimeZoneType(0i32);
11804 pub const UCAL_ZONE_TYPE_CANONICAL: USystemTimeZoneType = USystemTimeZoneType(1i32);
11805 pub const UCAL_ZONE_TYPE_CANONICAL_LOCATION: USystemTimeZoneType = USystemTimeZoneType(2i32);
11806 impl ::std::convert::From<i32> for USystemTimeZoneType {
from(value: i32) -> Self11807     fn from(value: i32) -> Self {
11808         Self(value)
11809     }
11810 }
11811 unsafe impl ::windows::runtime::Abi for USystemTimeZoneType {
11812     type Abi = Self;
11813     type DefaultType = Self;
11814 }
11815 pub const UTEXT_MAGIC: i32 = 878368812i32;
11816 pub const UTEXT_PROVIDER_HAS_META_DATA: i32 = 4i32;
11817 pub const UTEXT_PROVIDER_LENGTH_IS_EXPENSIVE: i32 = 1i32;
11818 pub const UTEXT_PROVIDER_OWNS_TEXT: i32 = 5i32;
11819 pub const UTEXT_PROVIDER_STABLE_CHUNKS: i32 = 2i32;
11820 pub const UTEXT_PROVIDER_WRITABLE: i32 = 3i32;
11821 pub const UTF16_MAX_CHAR_LENGTH: u32 = 2u32;
11822 pub const UTF32_MAX_CHAR_LENGTH: u32 = 1u32;
11823 pub const UTF8_ERROR_VALUE_1: u32 = 21u32;
11824 pub const UTF8_ERROR_VALUE_2: u32 = 159u32;
11825 pub const UTF8_MAX_CHAR_LENGTH: u32 = 4u32;
11826 pub const UTF_ERROR_VALUE: u32 = 65535u32;
11827 pub const UTF_MAX_CHAR_LENGTH: u32 = 2u32;
11828 pub const UTF_SIZE: u32 = 16u32;
11829 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
11830 #[repr(C)]
11831 pub struct UText {
11832     pub magic: u32,
11833     pub flags: i32,
11834     pub providerProperties: i32,
11835     pub sizeOfStruct: i32,
11836     pub chunkNativeLimit: i64,
11837     pub extraSize: i32,
11838     pub nativeIndexingLimit: i32,
11839     pub chunkNativeStart: i64,
11840     pub chunkOffset: i32,
11841     pub chunkLength: i32,
11842     pub chunkContents: *mut u16,
11843     pub pFuncs: *mut UTextFuncs,
11844     pub pExtra: *mut ::std::ffi::c_void,
11845     pub context: *mut ::std::ffi::c_void,
11846     pub p: *mut ::std::ffi::c_void,
11847     pub q: *mut ::std::ffi::c_void,
11848     pub r: *mut ::std::ffi::c_void,
11849     pub privP: *mut ::std::ffi::c_void,
11850     pub a: i64,
11851     pub b: i32,
11852     pub c: i32,
11853     pub privA: i64,
11854     pub privB: i32,
11855     pub privC: i32,
11856 }
11857 impl UText {}
11858 impl ::std::default::Default for UText {
default() -> Self11859     fn default() -> Self {
11860         unsafe { ::std::mem::zeroed() }
11861     }
11862 }
11863 impl ::std::fmt::Debug for UText {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11864     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11865         fmt.debug_struct("UText")
11866             .field("magic", &self.magic)
11867             .field("flags", &self.flags)
11868             .field("providerProperties", &self.providerProperties)
11869             .field("sizeOfStruct", &self.sizeOfStruct)
11870             .field("chunkNativeLimit", &self.chunkNativeLimit)
11871             .field("extraSize", &self.extraSize)
11872             .field("nativeIndexingLimit", &self.nativeIndexingLimit)
11873             .field("chunkNativeStart", &self.chunkNativeStart)
11874             .field("chunkOffset", &self.chunkOffset)
11875             .field("chunkLength", &self.chunkLength)
11876             .field("chunkContents", &self.chunkContents)
11877             .field("pFuncs", &self.pFuncs)
11878             .field("pExtra", &self.pExtra)
11879             .field("context", &self.context)
11880             .field("p", &self.p)
11881             .field("q", &self.q)
11882             .field("r", &self.r)
11883             .field("privP", &self.privP)
11884             .field("a", &self.a)
11885             .field("b", &self.b)
11886             .field("c", &self.c)
11887             .field("privA", &self.privA)
11888             .field("privB", &self.privB)
11889             .field("privC", &self.privC)
11890             .finish()
11891     }
11892 }
11893 impl ::std::cmp::PartialEq for UText {
eq(&self, other: &Self) -> bool11894     fn eq(&self, other: &Self) -> bool {
11895         self.magic == other.magic
11896             && self.flags == other.flags
11897             && self.providerProperties == other.providerProperties
11898             && self.sizeOfStruct == other.sizeOfStruct
11899             && self.chunkNativeLimit == other.chunkNativeLimit
11900             && self.extraSize == other.extraSize
11901             && self.nativeIndexingLimit == other.nativeIndexingLimit
11902             && self.chunkNativeStart == other.chunkNativeStart
11903             && self.chunkOffset == other.chunkOffset
11904             && self.chunkLength == other.chunkLength
11905             && self.chunkContents == other.chunkContents
11906             && self.pFuncs == other.pFuncs
11907             && self.pExtra == other.pExtra
11908             && self.context == other.context
11909             && self.p == other.p
11910             && self.q == other.q
11911             && self.r == other.r
11912             && self.privP == other.privP
11913             && self.a == other.a
11914             && self.b == other.b
11915             && self.c == other.c
11916             && self.privA == other.privA
11917             && self.privB == other.privB
11918             && self.privC == other.privC
11919     }
11920 }
11921 impl ::std::cmp::Eq for UText {}
11922 unsafe impl ::windows::runtime::Abi for UText {
11923     type Abi = Self;
11924     type DefaultType = Self;
11925 }
11926 pub type UTextAccess = unsafe extern "system" fn(ut: *mut UText, nativeindex: i64, forward: i8) -> i8;
11927 pub type UTextClone = unsafe extern "system" fn(dest: *mut UText, src: *const UText, deep: i8, status: *mut UErrorCode) -> *mut UText;
11928 pub type UTextClose = unsafe extern "system" fn(ut: *mut UText);
11929 pub type UTextCopy = unsafe extern "system" fn(ut: *mut UText, nativestart: i64, nativelimit: i64, nativedest: i64, r#move: i8, status: *mut UErrorCode);
11930 pub type UTextExtract = unsafe extern "system" fn(ut: *mut UText, nativestart: i64, nativelimit: i64, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
11931 #[derive(:: std :: clone :: Clone)]
11932 #[repr(C)]
11933 pub struct UTextFuncs {
11934     pub tableSize: i32,
11935     pub reserved1: i32,
11936     pub reserved2: i32,
11937     pub reserved3: i32,
11938     pub clone: ::std::option::Option<UTextClone>,
11939     pub nativeLength: ::std::option::Option<UTextNativeLength>,
11940     pub access: ::std::option::Option<UTextAccess>,
11941     pub extract: ::std::option::Option<UTextExtract>,
11942     pub replace: ::std::option::Option<UTextReplace>,
11943     pub copy: ::std::option::Option<UTextCopy>,
11944     pub mapOffsetToNative: ::std::option::Option<UTextMapOffsetToNative>,
11945     pub mapNativeIndexToUTF16: ::std::option::Option<UTextMapNativeIndexToUTF16>,
11946     pub close: ::std::option::Option<UTextClose>,
11947     pub spare1: ::std::option::Option<UTextClose>,
11948     pub spare2: ::std::option::Option<UTextClose>,
11949     pub spare3: ::std::option::Option<UTextClose>,
11950 }
11951 impl UTextFuncs {}
11952 impl ::std::default::Default for UTextFuncs {
default() -> Self11953     fn default() -> Self {
11954         unsafe { ::std::mem::zeroed() }
11955     }
11956 }
11957 impl ::std::fmt::Debug for UTextFuncs {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result11958     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
11959         fmt.debug_struct("UTextFuncs").field("tableSize", &self.tableSize).field("reserved1", &self.reserved1).field("reserved2", &self.reserved2).field("reserved3", &self.reserved3).finish()
11960     }
11961 }
11962 impl ::std::cmp::PartialEq for UTextFuncs {
eq(&self, other: &Self) -> bool11963     fn eq(&self, other: &Self) -> bool {
11964         self.tableSize == other.tableSize
11965             && self.reserved1 == other.reserved1
11966             && self.reserved2 == other.reserved2
11967             && self.reserved3 == other.reserved3
11968             && self.clone.map(|f| f as usize) == other.clone.map(|f| f as usize)
11969             && self.nativeLength.map(|f| f as usize) == other.nativeLength.map(|f| f as usize)
11970             && self.access.map(|f| f as usize) == other.access.map(|f| f as usize)
11971             && self.extract.map(|f| f as usize) == other.extract.map(|f| f as usize)
11972             && self.replace.map(|f| f as usize) == other.replace.map(|f| f as usize)
11973             && self.copy.map(|f| f as usize) == other.copy.map(|f| f as usize)
11974             && self.mapOffsetToNative.map(|f| f as usize) == other.mapOffsetToNative.map(|f| f as usize)
11975             && self.mapNativeIndexToUTF16.map(|f| f as usize) == other.mapNativeIndexToUTF16.map(|f| f as usize)
11976             && self.close.map(|f| f as usize) == other.close.map(|f| f as usize)
11977             && self.spare1.map(|f| f as usize) == other.spare1.map(|f| f as usize)
11978             && self.spare2.map(|f| f as usize) == other.spare2.map(|f| f as usize)
11979             && self.spare3.map(|f| f as usize) == other.spare3.map(|f| f as usize)
11980     }
11981 }
11982 impl ::std::cmp::Eq for UTextFuncs {}
11983 unsafe impl ::windows::runtime::Abi for UTextFuncs {
11984     type Abi = ::std::mem::ManuallyDrop<Self>;
11985     type DefaultType = Self;
11986 }
11987 pub type UTextMapNativeIndexToUTF16 = unsafe extern "system" fn(ut: *const UText, nativeindex: i64) -> i32;
11988 pub type UTextMapOffsetToNative = unsafe extern "system" fn(ut: *const UText) -> i64;
11989 pub type UTextNativeLength = unsafe extern "system" fn(ut: *mut UText) -> i64;
11990 pub type UTextReplace = unsafe extern "system" fn(ut: *mut UText, nativestart: i64, nativelimit: i64, replacementtext: *const u16, replacmentlength: i32, status: *mut UErrorCode) -> i32;
11991 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
11992 #[repr(transparent)]
11993 pub struct UTimeScaleValue(pub i32);
11994 pub const UTSV_UNITS_VALUE: UTimeScaleValue = UTimeScaleValue(0i32);
11995 pub const UTSV_EPOCH_OFFSET_VALUE: UTimeScaleValue = UTimeScaleValue(1i32);
11996 pub const UTSV_FROM_MIN_VALUE: UTimeScaleValue = UTimeScaleValue(2i32);
11997 pub const UTSV_FROM_MAX_VALUE: UTimeScaleValue = UTimeScaleValue(3i32);
11998 pub const UTSV_TO_MIN_VALUE: UTimeScaleValue = UTimeScaleValue(4i32);
11999 pub const UTSV_TO_MAX_VALUE: UTimeScaleValue = UTimeScaleValue(5i32);
12000 impl ::std::convert::From<i32> for UTimeScaleValue {
from(value: i32) -> Self12001     fn from(value: i32) -> Self {
12002         Self(value)
12003     }
12004 }
12005 unsafe impl ::windows::runtime::Abi for UTimeScaleValue {
12006     type Abi = Self;
12007     type DefaultType = Self;
12008 }
12009 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12010 #[repr(transparent)]
12011 pub struct UTimeZoneFormatGMTOffsetPatternType(pub i32);
12012 pub const UTZFMT_PAT_POSITIVE_HM: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(0i32);
12013 pub const UTZFMT_PAT_POSITIVE_HMS: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(1i32);
12014 pub const UTZFMT_PAT_NEGATIVE_HM: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(2i32);
12015 pub const UTZFMT_PAT_NEGATIVE_HMS: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(3i32);
12016 pub const UTZFMT_PAT_POSITIVE_H: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(4i32);
12017 pub const UTZFMT_PAT_NEGATIVE_H: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(5i32);
12018 pub const UTZFMT_PAT_COUNT: UTimeZoneFormatGMTOffsetPatternType = UTimeZoneFormatGMTOffsetPatternType(6i32);
12019 impl ::std::convert::From<i32> for UTimeZoneFormatGMTOffsetPatternType {
from(value: i32) -> Self12020     fn from(value: i32) -> Self {
12021         Self(value)
12022     }
12023 }
12024 unsafe impl ::windows::runtime::Abi for UTimeZoneFormatGMTOffsetPatternType {
12025     type Abi = Self;
12026     type DefaultType = Self;
12027 }
12028 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12029 #[repr(transparent)]
12030 pub struct UTimeZoneFormatParseOption(pub i32);
12031 pub const UTZFMT_PARSE_OPTION_NONE: UTimeZoneFormatParseOption = UTimeZoneFormatParseOption(0i32);
12032 pub const UTZFMT_PARSE_OPTION_ALL_STYLES: UTimeZoneFormatParseOption = UTimeZoneFormatParseOption(1i32);
12033 pub const UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS: UTimeZoneFormatParseOption = UTimeZoneFormatParseOption(2i32);
12034 impl ::std::convert::From<i32> for UTimeZoneFormatParseOption {
from(value: i32) -> Self12035     fn from(value: i32) -> Self {
12036         Self(value)
12037     }
12038 }
12039 unsafe impl ::windows::runtime::Abi for UTimeZoneFormatParseOption {
12040     type Abi = Self;
12041     type DefaultType = Self;
12042 }
12043 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12044 #[repr(transparent)]
12045 pub struct UTimeZoneFormatStyle(pub i32);
12046 pub const UTZFMT_STYLE_GENERIC_LOCATION: UTimeZoneFormatStyle = UTimeZoneFormatStyle(0i32);
12047 pub const UTZFMT_STYLE_GENERIC_LONG: UTimeZoneFormatStyle = UTimeZoneFormatStyle(1i32);
12048 pub const UTZFMT_STYLE_GENERIC_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(2i32);
12049 pub const UTZFMT_STYLE_SPECIFIC_LONG: UTimeZoneFormatStyle = UTimeZoneFormatStyle(3i32);
12050 pub const UTZFMT_STYLE_SPECIFIC_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(4i32);
12051 pub const UTZFMT_STYLE_LOCALIZED_GMT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(5i32);
12052 pub const UTZFMT_STYLE_LOCALIZED_GMT_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(6i32);
12053 pub const UTZFMT_STYLE_ISO_BASIC_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(7i32);
12054 pub const UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(8i32);
12055 pub const UTZFMT_STYLE_ISO_BASIC_FIXED: UTimeZoneFormatStyle = UTimeZoneFormatStyle(9i32);
12056 pub const UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED: UTimeZoneFormatStyle = UTimeZoneFormatStyle(10i32);
12057 pub const UTZFMT_STYLE_ISO_BASIC_FULL: UTimeZoneFormatStyle = UTimeZoneFormatStyle(11i32);
12058 pub const UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL: UTimeZoneFormatStyle = UTimeZoneFormatStyle(12i32);
12059 pub const UTZFMT_STYLE_ISO_EXTENDED_FIXED: UTimeZoneFormatStyle = UTimeZoneFormatStyle(13i32);
12060 pub const UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED: UTimeZoneFormatStyle = UTimeZoneFormatStyle(14i32);
12061 pub const UTZFMT_STYLE_ISO_EXTENDED_FULL: UTimeZoneFormatStyle = UTimeZoneFormatStyle(15i32);
12062 pub const UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL: UTimeZoneFormatStyle = UTimeZoneFormatStyle(16i32);
12063 pub const UTZFMT_STYLE_ZONE_ID: UTimeZoneFormatStyle = UTimeZoneFormatStyle(17i32);
12064 pub const UTZFMT_STYLE_ZONE_ID_SHORT: UTimeZoneFormatStyle = UTimeZoneFormatStyle(18i32);
12065 pub const UTZFMT_STYLE_EXEMPLAR_LOCATION: UTimeZoneFormatStyle = UTimeZoneFormatStyle(19i32);
12066 impl ::std::convert::From<i32> for UTimeZoneFormatStyle {
from(value: i32) -> Self12067     fn from(value: i32) -> Self {
12068         Self(value)
12069     }
12070 }
12071 unsafe impl ::windows::runtime::Abi for UTimeZoneFormatStyle {
12072     type Abi = Self;
12073     type DefaultType = Self;
12074 }
12075 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12076 #[repr(transparent)]
12077 pub struct UTimeZoneFormatTimeType(pub i32);
12078 pub const UTZFMT_TIME_TYPE_UNKNOWN: UTimeZoneFormatTimeType = UTimeZoneFormatTimeType(0i32);
12079 pub const UTZFMT_TIME_TYPE_STANDARD: UTimeZoneFormatTimeType = UTimeZoneFormatTimeType(1i32);
12080 pub const UTZFMT_TIME_TYPE_DAYLIGHT: UTimeZoneFormatTimeType = UTimeZoneFormatTimeType(2i32);
12081 impl ::std::convert::From<i32> for UTimeZoneFormatTimeType {
from(value: i32) -> Self12082     fn from(value: i32) -> Self {
12083         Self(value)
12084     }
12085 }
12086 unsafe impl ::windows::runtime::Abi for UTimeZoneFormatTimeType {
12087     type Abi = Self;
12088     type DefaultType = Self;
12089 }
12090 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12091 #[repr(transparent)]
12092 pub struct UTimeZoneNameType(pub i32);
12093 pub const UTZNM_UNKNOWN: UTimeZoneNameType = UTimeZoneNameType(0i32);
12094 pub const UTZNM_LONG_GENERIC: UTimeZoneNameType = UTimeZoneNameType(1i32);
12095 pub const UTZNM_LONG_STANDARD: UTimeZoneNameType = UTimeZoneNameType(2i32);
12096 pub const UTZNM_LONG_DAYLIGHT: UTimeZoneNameType = UTimeZoneNameType(4i32);
12097 pub const UTZNM_SHORT_GENERIC: UTimeZoneNameType = UTimeZoneNameType(8i32);
12098 pub const UTZNM_SHORT_STANDARD: UTimeZoneNameType = UTimeZoneNameType(16i32);
12099 pub const UTZNM_SHORT_DAYLIGHT: UTimeZoneNameType = UTimeZoneNameType(32i32);
12100 pub const UTZNM_EXEMPLAR_LOCATION: UTimeZoneNameType = UTimeZoneNameType(64i32);
12101 impl ::std::convert::From<i32> for UTimeZoneNameType {
from(value: i32) -> Self12102     fn from(value: i32) -> Self {
12103         Self(value)
12104     }
12105 }
12106 unsafe impl ::windows::runtime::Abi for UTimeZoneNameType {
12107     type Abi = Self;
12108     type DefaultType = Self;
12109 }
12110 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12111 #[repr(transparent)]
12112 pub struct UTimeZoneTransitionType(pub i32);
12113 pub const UCAL_TZ_TRANSITION_NEXT: UTimeZoneTransitionType = UTimeZoneTransitionType(0i32);
12114 pub const UCAL_TZ_TRANSITION_NEXT_INCLUSIVE: UTimeZoneTransitionType = UTimeZoneTransitionType(1i32);
12115 pub const UCAL_TZ_TRANSITION_PREVIOUS: UTimeZoneTransitionType = UTimeZoneTransitionType(2i32);
12116 pub const UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE: UTimeZoneTransitionType = UTimeZoneTransitionType(3i32);
12117 impl ::std::convert::From<i32> for UTimeZoneTransitionType {
from(value: i32) -> Self12118     fn from(value: i32) -> Self {
12119         Self(value)
12120     }
12121 }
12122 unsafe impl ::windows::runtime::Abi for UTimeZoneTransitionType {
12123     type Abi = Self;
12124     type DefaultType = Self;
12125 }
12126 #[cfg(feature = "Win32_Foundation")]
12127 pub type UTraceData = unsafe extern "system" fn(context: *const ::std::ffi::c_void, fnnumber: i32, level: i32, fmt: super::Foundation::PSTR, args: *mut i8);
12128 pub type UTraceEntry = unsafe extern "system" fn(context: *const ::std::ffi::c_void, fnnumber: i32);
12129 #[cfg(feature = "Win32_Foundation")]
12130 pub type UTraceExit = unsafe extern "system" fn(context: *const ::std::ffi::c_void, fnnumber: i32, fmt: super::Foundation::PSTR, args: *mut i8);
12131 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12132 #[repr(transparent)]
12133 pub struct UTraceFunctionNumber(pub i32);
12134 pub const UTRACE_FUNCTION_START: UTraceFunctionNumber = UTraceFunctionNumber(0i32);
12135 pub const UTRACE_U_INIT: UTraceFunctionNumber = UTraceFunctionNumber(0i32);
12136 pub const UTRACE_U_CLEANUP: UTraceFunctionNumber = UTraceFunctionNumber(1i32);
12137 pub const UTRACE_CONVERSION_START: UTraceFunctionNumber = UTraceFunctionNumber(4096i32);
12138 pub const UTRACE_UCNV_OPEN: UTraceFunctionNumber = UTraceFunctionNumber(4096i32);
12139 pub const UTRACE_UCNV_OPEN_PACKAGE: UTraceFunctionNumber = UTraceFunctionNumber(4097i32);
12140 pub const UTRACE_UCNV_OPEN_ALGORITHMIC: UTraceFunctionNumber = UTraceFunctionNumber(4098i32);
12141 pub const UTRACE_UCNV_CLONE: UTraceFunctionNumber = UTraceFunctionNumber(4099i32);
12142 pub const UTRACE_UCNV_CLOSE: UTraceFunctionNumber = UTraceFunctionNumber(4100i32);
12143 pub const UTRACE_UCNV_FLUSH_CACHE: UTraceFunctionNumber = UTraceFunctionNumber(4101i32);
12144 pub const UTRACE_UCNV_LOAD: UTraceFunctionNumber = UTraceFunctionNumber(4102i32);
12145 pub const UTRACE_UCNV_UNLOAD: UTraceFunctionNumber = UTraceFunctionNumber(4103i32);
12146 pub const UTRACE_COLLATION_START: UTraceFunctionNumber = UTraceFunctionNumber(8192i32);
12147 pub const UTRACE_UCOL_OPEN: UTraceFunctionNumber = UTraceFunctionNumber(8192i32);
12148 pub const UTRACE_UCOL_CLOSE: UTraceFunctionNumber = UTraceFunctionNumber(8193i32);
12149 pub const UTRACE_UCOL_STRCOLL: UTraceFunctionNumber = UTraceFunctionNumber(8194i32);
12150 pub const UTRACE_UCOL_GET_SORTKEY: UTraceFunctionNumber = UTraceFunctionNumber(8195i32);
12151 pub const UTRACE_UCOL_GETLOCALE: UTraceFunctionNumber = UTraceFunctionNumber(8196i32);
12152 pub const UTRACE_UCOL_NEXTSORTKEYPART: UTraceFunctionNumber = UTraceFunctionNumber(8197i32);
12153 pub const UTRACE_UCOL_STRCOLLITER: UTraceFunctionNumber = UTraceFunctionNumber(8198i32);
12154 pub const UTRACE_UCOL_OPEN_FROM_SHORT_STRING: UTraceFunctionNumber = UTraceFunctionNumber(8199i32);
12155 pub const UTRACE_UCOL_STRCOLLUTF8: UTraceFunctionNumber = UTraceFunctionNumber(8200i32);
12156 pub const UTRACE_UDATA_START: UTraceFunctionNumber = UTraceFunctionNumber(12288i32);
12157 pub const UTRACE_UDATA_RESOURCE: UTraceFunctionNumber = UTraceFunctionNumber(12288i32);
12158 pub const UTRACE_UDATA_BUNDLE: UTraceFunctionNumber = UTraceFunctionNumber(12289i32);
12159 pub const UTRACE_UDATA_DATA_FILE: UTraceFunctionNumber = UTraceFunctionNumber(12290i32);
12160 pub const UTRACE_UDATA_RES_FILE: UTraceFunctionNumber = UTraceFunctionNumber(12291i32);
12161 impl ::std::convert::From<i32> for UTraceFunctionNumber {
from(value: i32) -> Self12162     fn from(value: i32) -> Self {
12163         Self(value)
12164     }
12165 }
12166 unsafe impl ::windows::runtime::Abi for UTraceFunctionNumber {
12167     type Abi = Self;
12168     type DefaultType = Self;
12169 }
12170 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12171 #[repr(transparent)]
12172 pub struct UTraceLevel(pub i32);
12173 pub const UTRACE_OFF: UTraceLevel = UTraceLevel(-1i32);
12174 pub const UTRACE_ERROR: UTraceLevel = UTraceLevel(0i32);
12175 pub const UTRACE_WARNING: UTraceLevel = UTraceLevel(3i32);
12176 pub const UTRACE_OPEN_CLOSE: UTraceLevel = UTraceLevel(5i32);
12177 pub const UTRACE_INFO: UTraceLevel = UTraceLevel(7i32);
12178 pub const UTRACE_VERBOSE: UTraceLevel = UTraceLevel(9i32);
12179 impl ::std::convert::From<i32> for UTraceLevel {
from(value: i32) -> Self12180     fn from(value: i32) -> Self {
12181         Self(value)
12182     }
12183 }
12184 unsafe impl ::windows::runtime::Abi for UTraceLevel {
12185     type Abi = Self;
12186     type DefaultType = Self;
12187 }
12188 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12189 #[repr(transparent)]
12190 pub struct UTransDirection(pub i32);
12191 pub const UTRANS_FORWARD: UTransDirection = UTransDirection(0i32);
12192 pub const UTRANS_REVERSE: UTransDirection = UTransDirection(1i32);
12193 impl ::std::convert::From<i32> for UTransDirection {
from(value: i32) -> Self12194     fn from(value: i32) -> Self {
12195         Self(value)
12196     }
12197 }
12198 unsafe impl ::windows::runtime::Abi for UTransDirection {
12199     type Abi = Self;
12200     type DefaultType = Self;
12201 }
12202 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12203 #[repr(C)]
12204 pub struct UTransPosition {
12205     pub contextStart: i32,
12206     pub contextLimit: i32,
12207     pub start: i32,
12208     pub limit: i32,
12209 }
12210 impl UTransPosition {}
12211 impl ::std::default::Default for UTransPosition {
default() -> Self12212     fn default() -> Self {
12213         unsafe { ::std::mem::zeroed() }
12214     }
12215 }
12216 impl ::std::fmt::Debug for UTransPosition {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12217     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12218         fmt.debug_struct("UTransPosition").field("contextStart", &self.contextStart).field("contextLimit", &self.contextLimit).field("start", &self.start).field("limit", &self.limit).finish()
12219     }
12220 }
12221 impl ::std::cmp::PartialEq for UTransPosition {
eq(&self, other: &Self) -> bool12222     fn eq(&self, other: &Self) -> bool {
12223         self.contextStart == other.contextStart && self.contextLimit == other.contextLimit && self.start == other.start && self.limit == other.limit
12224     }
12225 }
12226 impl ::std::cmp::Eq for UTransPosition {}
12227 unsafe impl ::windows::runtime::Abi for UTransPosition {
12228     type Abi = Self;
12229     type DefaultType = Self;
12230 }
12231 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12232 #[repr(transparent)]
12233 pub struct UVerticalOrientation(pub i32);
12234 pub const U_VO_ROTATED: UVerticalOrientation = UVerticalOrientation(0i32);
12235 pub const U_VO_TRANSFORMED_ROTATED: UVerticalOrientation = UVerticalOrientation(1i32);
12236 pub const U_VO_TRANSFORMED_UPRIGHT: UVerticalOrientation = UVerticalOrientation(2i32);
12237 pub const U_VO_UPRIGHT: UVerticalOrientation = UVerticalOrientation(3i32);
12238 impl ::std::convert::From<i32> for UVerticalOrientation {
from(value: i32) -> Self12239     fn from(value: i32) -> Self {
12240         Self(value)
12241     }
12242 }
12243 unsafe impl ::windows::runtime::Abi for UVerticalOrientation {
12244     type Abi = Self;
12245     type DefaultType = Self;
12246 }
12247 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12248 #[repr(transparent)]
12249 pub struct UWordBreak(pub i32);
12250 pub const UBRK_WORD_NONE: UWordBreak = UWordBreak(0i32);
12251 pub const UBRK_WORD_NONE_LIMIT: UWordBreak = UWordBreak(100i32);
12252 pub const UBRK_WORD_NUMBER: UWordBreak = UWordBreak(100i32);
12253 pub const UBRK_WORD_NUMBER_LIMIT: UWordBreak = UWordBreak(200i32);
12254 pub const UBRK_WORD_LETTER: UWordBreak = UWordBreak(200i32);
12255 pub const UBRK_WORD_LETTER_LIMIT: UWordBreak = UWordBreak(300i32);
12256 pub const UBRK_WORD_KANA: UWordBreak = UWordBreak(300i32);
12257 pub const UBRK_WORD_KANA_LIMIT: UWordBreak = UWordBreak(400i32);
12258 pub const UBRK_WORD_IDEO: UWordBreak = UWordBreak(400i32);
12259 pub const UBRK_WORD_IDEO_LIMIT: UWordBreak = UWordBreak(500i32);
12260 impl ::std::convert::From<i32> for UWordBreak {
from(value: i32) -> Self12261     fn from(value: i32) -> Self {
12262         Self(value)
12263     }
12264 }
12265 unsafe impl ::windows::runtime::Abi for UWordBreak {
12266     type Abi = Self;
12267     type DefaultType = Self;
12268 }
12269 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12270 #[repr(transparent)]
12271 pub struct UWordBreakValues(pub i32);
12272 pub const U_WB_OTHER: UWordBreakValues = UWordBreakValues(0i32);
12273 pub const U_WB_ALETTER: UWordBreakValues = UWordBreakValues(1i32);
12274 pub const U_WB_FORMAT: UWordBreakValues = UWordBreakValues(2i32);
12275 pub const U_WB_KATAKANA: UWordBreakValues = UWordBreakValues(3i32);
12276 pub const U_WB_MIDLETTER: UWordBreakValues = UWordBreakValues(4i32);
12277 pub const U_WB_MIDNUM: UWordBreakValues = UWordBreakValues(5i32);
12278 pub const U_WB_NUMERIC: UWordBreakValues = UWordBreakValues(6i32);
12279 pub const U_WB_EXTENDNUMLET: UWordBreakValues = UWordBreakValues(7i32);
12280 pub const U_WB_CR: UWordBreakValues = UWordBreakValues(8i32);
12281 pub const U_WB_EXTEND: UWordBreakValues = UWordBreakValues(9i32);
12282 pub const U_WB_LF: UWordBreakValues = UWordBreakValues(10i32);
12283 pub const U_WB_MIDNUMLET: UWordBreakValues = UWordBreakValues(11i32);
12284 pub const U_WB_NEWLINE: UWordBreakValues = UWordBreakValues(12i32);
12285 pub const U_WB_REGIONAL_INDICATOR: UWordBreakValues = UWordBreakValues(13i32);
12286 pub const U_WB_HEBREW_LETTER: UWordBreakValues = UWordBreakValues(14i32);
12287 pub const U_WB_SINGLE_QUOTE: UWordBreakValues = UWordBreakValues(15i32);
12288 pub const U_WB_DOUBLE_QUOTE: UWordBreakValues = UWordBreakValues(16i32);
12289 pub const U_WB_E_BASE: UWordBreakValues = UWordBreakValues(17i32);
12290 pub const U_WB_E_BASE_GAZ: UWordBreakValues = UWordBreakValues(18i32);
12291 pub const U_WB_E_MODIFIER: UWordBreakValues = UWordBreakValues(19i32);
12292 pub const U_WB_GLUE_AFTER_ZWJ: UWordBreakValues = UWordBreakValues(20i32);
12293 pub const U_WB_ZWJ: UWordBreakValues = UWordBreakValues(21i32);
12294 pub const U_WB_WSEGSPACE: UWordBreakValues = UWordBreakValues(22i32);
12295 impl ::std::convert::From<i32> for UWordBreakValues {
from(value: i32) -> Self12296     fn from(value: i32) -> Self {
12297         Self(value)
12298     }
12299 }
12300 unsafe impl ::windows::runtime::Abi for UWordBreakValues {
12301     type Abi = Self;
12302     type DefaultType = Self;
12303 }
12304 pub const U_ASCII_FAMILY: u32 = 0u32;
12305 pub const U_CHECK_DYLOAD: u32 = 1u32;
12306 pub const U_COMBINED_IMPLEMENTATION: u32 = 1u32;
12307 pub const U_COMPARE_CODE_POINT_ORDER: u32 = 32768u32;
12308 pub const U_COMPARE_IGNORE_CASE: u32 = 65536u32;
12309 pub const U_COPYRIGHT_STRING_LENGTH: u32 = 128u32;
12310 pub const U_DEFAULT_SHOW_DRAFT: u32 = 0u32;
12311 pub const U_DEFINE_FALSE_AND_TRUE: u32 = 1u32;
12312 pub const U_DISABLE_RENAMING: u32 = 1u32;
12313 pub const U_EBCDIC_FAMILY: u32 = 1u32;
12314 pub const U_EDITS_NO_RESET: u32 = 8192u32;
12315 pub const U_ENABLE_DYLOAD: u32 = 1u32;
12316 pub const U_ENABLE_TRACING: u32 = 0u32;
12317 pub const U_FOLD_CASE_DEFAULT: u32 = 0u32;
12318 pub const U_FOLD_CASE_EXCLUDE_SPECIAL_I: u32 = 1u32;
12319 pub const U_HAVE_RBNF: u32 = 0u32;
12320 pub const U_HAVE_STD_STRING: u32 = 0u32;
12321 pub const U_HIDE_DEPRECATED_API: u32 = 1u32;
12322 pub const U_HIDE_DRAFT_API: u32 = 1u32;
12323 pub const U_HIDE_INTERNAL_API: u32 = 1u32;
12324 pub const U_HIDE_OBSOLETE_API: u32 = 1u32;
12325 pub const U_IOSTREAM_SOURCE: u32 = 199711u32;
12326 pub const U_MAX_VERSION_LENGTH: u32 = 4u32;
12327 pub const U_MAX_VERSION_STRING_LENGTH: u32 = 20u32;
12328 pub const U_MILLIS_PER_DAY: u32 = 86400000u32;
12329 pub const U_MILLIS_PER_HOUR: u32 = 3600000u32;
12330 pub const U_MILLIS_PER_MINUTE: u32 = 60000u32;
12331 pub const U_MILLIS_PER_SECOND: u32 = 1000u32;
12332 pub const U_NO_DEFAULT_INCLUDE_UTF_HEADERS: u32 = 1u32;
12333 pub const U_OMIT_UNCHANGED_TEXT: u32 = 16384u32;
12334 pub const U_OVERRIDE_CXX_ALLOCATION: u32 = 1u32;
12335 pub const U_PARSE_CONTEXT_LEN: i32 = 16i32;
12336 pub const U_PF_AIX: u32 = 3100u32;
12337 pub const U_PF_ANDROID: u32 = 4050u32;
12338 pub const U_PF_BROWSER_NATIVE_CLIENT: u32 = 4020u32;
12339 pub const U_PF_BSD: u32 = 3000u32;
12340 pub const U_PF_CYGWIN: u32 = 1900u32;
12341 pub const U_PF_DARWIN: u32 = 3500u32;
12342 pub const U_PF_EMSCRIPTEN: u32 = 5010u32;
12343 pub const U_PF_FUCHSIA: u32 = 4100u32;
12344 pub const U_PF_HPUX: u32 = 2100u32;
12345 pub const U_PF_IPHONE: u32 = 3550u32;
12346 pub const U_PF_IRIX: u32 = 3200u32;
12347 pub const U_PF_LINUX: u32 = 4000u32;
12348 pub const U_PF_MINGW: u32 = 1800u32;
12349 pub const U_PF_OS390: u32 = 9000u32;
12350 pub const U_PF_OS400: u32 = 9400u32;
12351 pub const U_PF_QNX: u32 = 3700u32;
12352 pub const U_PF_SOLARIS: u32 = 2600u32;
12353 pub const U_PF_UNKNOWN: u32 = 0u32;
12354 pub const U_PF_WINDOWS: u32 = 1000u32;
12355 pub const U_SENTINEL: i32 = -1i32;
12356 pub const U_SHAPE_AGGREGATE_TASHKEEL: u32 = 16384u32;
12357 pub const U_SHAPE_AGGREGATE_TASHKEEL_MASK: u32 = 16384u32;
12358 pub const U_SHAPE_AGGREGATE_TASHKEEL_NOOP: u32 = 0u32;
12359 pub const U_SHAPE_DIGITS_ALEN2AN_INIT_AL: u32 = 128u32;
12360 pub const U_SHAPE_DIGITS_ALEN2AN_INIT_LR: u32 = 96u32;
12361 pub const U_SHAPE_DIGITS_AN2EN: u32 = 64u32;
12362 pub const U_SHAPE_DIGITS_EN2AN: u32 = 32u32;
12363 pub const U_SHAPE_DIGITS_MASK: u32 = 224u32;
12364 pub const U_SHAPE_DIGITS_NOOP: u32 = 0u32;
12365 pub const U_SHAPE_DIGITS_RESERVED: u32 = 160u32;
12366 pub const U_SHAPE_DIGIT_TYPE_AN: u32 = 0u32;
12367 pub const U_SHAPE_DIGIT_TYPE_AN_EXTENDED: u32 = 256u32;
12368 pub const U_SHAPE_DIGIT_TYPE_MASK: u32 = 768u32;
12369 pub const U_SHAPE_DIGIT_TYPE_RESERVED: u32 = 512u32;
12370 pub const U_SHAPE_LAMALEF_AUTO: u32 = 65536u32;
12371 pub const U_SHAPE_LAMALEF_BEGIN: u32 = 3u32;
12372 pub const U_SHAPE_LAMALEF_END: u32 = 2u32;
12373 pub const U_SHAPE_LAMALEF_MASK: u32 = 65539u32;
12374 pub const U_SHAPE_LAMALEF_NEAR: u32 = 1u32;
12375 pub const U_SHAPE_LAMALEF_RESIZE: u32 = 0u32;
12376 pub const U_SHAPE_LENGTH_FIXED_SPACES_AT_BEGINNING: u32 = 3u32;
12377 pub const U_SHAPE_LENGTH_FIXED_SPACES_AT_END: u32 = 2u32;
12378 pub const U_SHAPE_LENGTH_FIXED_SPACES_NEAR: u32 = 1u32;
12379 pub const U_SHAPE_LENGTH_GROW_SHRINK: u32 = 0u32;
12380 pub const U_SHAPE_LENGTH_MASK: u32 = 65539u32;
12381 pub const U_SHAPE_LETTERS_MASK: u32 = 24u32;
12382 pub const U_SHAPE_LETTERS_NOOP: u32 = 0u32;
12383 pub const U_SHAPE_LETTERS_SHAPE: u32 = 8u32;
12384 pub const U_SHAPE_LETTERS_SHAPE_TASHKEEL_ISOLATED: u32 = 24u32;
12385 pub const U_SHAPE_LETTERS_UNSHAPE: u32 = 16u32;
12386 pub const U_SHAPE_PRESERVE_PRESENTATION: u32 = 32768u32;
12387 pub const U_SHAPE_PRESERVE_PRESENTATION_MASK: u32 = 32768u32;
12388 pub const U_SHAPE_PRESERVE_PRESENTATION_NOOP: u32 = 0u32;
12389 pub const U_SHAPE_SEEN_MASK: u32 = 7340032u32;
12390 pub const U_SHAPE_SEEN_TWOCELL_NEAR: u32 = 2097152u32;
12391 pub const U_SHAPE_SPACES_RELATIVE_TO_TEXT_BEGIN_END: u32 = 67108864u32;
12392 pub const U_SHAPE_SPACES_RELATIVE_TO_TEXT_MASK: u32 = 67108864u32;
12393 pub const U_SHAPE_TAIL_NEW_UNICODE: u32 = 134217728u32;
12394 pub const U_SHAPE_TAIL_TYPE_MASK: u32 = 134217728u32;
12395 pub const U_SHAPE_TASHKEEL_BEGIN: u32 = 262144u32;
12396 pub const U_SHAPE_TASHKEEL_END: u32 = 393216u32;
12397 pub const U_SHAPE_TASHKEEL_MASK: u32 = 917504u32;
12398 pub const U_SHAPE_TASHKEEL_REPLACE_BY_TATWEEL: u32 = 786432u32;
12399 pub const U_SHAPE_TASHKEEL_RESIZE: u32 = 524288u32;
12400 pub const U_SHAPE_TEXT_DIRECTION_LOGICAL: u32 = 0u32;
12401 pub const U_SHAPE_TEXT_DIRECTION_MASK: u32 = 4u32;
12402 pub const U_SHAPE_TEXT_DIRECTION_VISUAL_LTR: u32 = 4u32;
12403 pub const U_SHAPE_TEXT_DIRECTION_VISUAL_RTL: u32 = 0u32;
12404 pub const U_SHAPE_YEHHAMZA_MASK: u32 = 58720256u32;
12405 pub const U_SHAPE_YEHHAMZA_TWOCELL_NEAR: u32 = 16777216u32;
12406 pub const U_SHOW_CPLUSPLUS_API: u32 = 0u32;
12407 pub const U_SIZEOF_UCHAR: u32 = 2u32;
12408 pub const U_TITLECASE_ADJUST_TO_CASED: u32 = 1024u32;
12409 pub const U_TITLECASE_NO_BREAK_ADJUSTMENT: u32 = 512u32;
12410 pub const U_TITLECASE_NO_LOWERCASE: u32 = 256u32;
12411 pub const U_TITLECASE_SENTENCES: u32 = 64u32;
12412 pub const U_TITLECASE_WHOLE_STRING: u32 = 32u32;
12413 pub const VS_ALLOW_LATIN: u32 = 1u32;
12414 #[cfg(feature = "Win32_Foundation")]
12415 #[inline]
VerifyScripts<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lplocalescripts: Param1, cchlocalescripts: i32, lptestscripts: Param3, cchtestscripts: i32) -> super::Foundation::BOOL12416 pub unsafe fn VerifyScripts<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dwflags: u32, lplocalescripts: Param1, cchlocalescripts: i32, lptestscripts: Param3, cchtestscripts: i32) -> super::Foundation::BOOL {
12417     #[cfg(windows)]
12418     {
12419         #[link(name = "windows")]
12420         extern "system" {
12421             fn VerifyScripts(dwflags: u32, lplocalescripts: super::Foundation::PWSTR, cchlocalescripts: i32, lptestscripts: super::Foundation::PWSTR, cchtestscripts: i32) -> super::Foundation::BOOL;
12422         }
12423         ::std::mem::transmute(VerifyScripts(::std::mem::transmute(dwflags), lplocalescripts.into_param().abi(), ::std::mem::transmute(cchlocalescripts), lptestscripts.into_param().abi(), ::std::mem::transmute(cchtestscripts)))
12424     }
12425     #[cfg(not(windows))]
12426     unimplemented!("Unsupported target OS");
12427 }
12428 pub const WC_COMPOSITECHECK: u32 = 512u32;
12429 pub const WC_DEFAULTCHAR: u32 = 64u32;
12430 pub const WC_DISCARDNS: u32 = 16u32;
12431 pub const WC_ERR_INVALID_CHARS: u32 = 128u32;
12432 pub const WC_NO_BEST_FIT_CHARS: u32 = 1024u32;
12433 pub const WC_SEPCHARS: u32 = 32u32;
12434 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12435 #[repr(transparent)]
12436 pub struct WORDLIST_TYPE(pub i32);
12437 pub const WORDLIST_TYPE_IGNORE: WORDLIST_TYPE = WORDLIST_TYPE(0i32);
12438 pub const WORDLIST_TYPE_ADD: WORDLIST_TYPE = WORDLIST_TYPE(1i32);
12439 pub const WORDLIST_TYPE_EXCLUDE: WORDLIST_TYPE = WORDLIST_TYPE(2i32);
12440 pub const WORDLIST_TYPE_AUTOCORRECT: WORDLIST_TYPE = WORDLIST_TYPE(3i32);
12441 impl ::std::convert::From<i32> for WORDLIST_TYPE {
from(value: i32) -> Self12442     fn from(value: i32) -> Self {
12443         Self(value)
12444     }
12445 }
12446 unsafe impl ::windows::runtime::Abi for WORDLIST_TYPE {
12447     type Abi = Self;
12448     type DefaultType = Self;
12449 }
12450 #[cfg(feature = "Win32_Foundation")]
12451 #[inline]
WideCharToMultiByte<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(codepage: u32, dwflags: u32, lpwidecharstr: Param2, cchwidechar: i32, lpmultibytestr: super::Foundation::PSTR, cbmultibyte: i32, lpdefaultchar: Param6, lpuseddefaultchar: *mut i32) -> i3212452 pub unsafe fn WideCharToMultiByte<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param6: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(codepage: u32, dwflags: u32, lpwidecharstr: Param2, cchwidechar: i32, lpmultibytestr: super::Foundation::PSTR, cbmultibyte: i32, lpdefaultchar: Param6, lpuseddefaultchar: *mut i32) -> i32 {
12453     #[cfg(windows)]
12454     {
12455         #[link(name = "windows")]
12456         extern "system" {
12457             fn WideCharToMultiByte(codepage: u32, dwflags: u32, lpwidecharstr: super::Foundation::PWSTR, cchwidechar: i32, lpmultibytestr: super::Foundation::PSTR, cbmultibyte: i32, lpdefaultchar: super::Foundation::PSTR, lpuseddefaultchar: *mut i32) -> i32;
12458         }
12459         ::std::mem::transmute(WideCharToMultiByte(
12460             ::std::mem::transmute(codepage),
12461             ::std::mem::transmute(dwflags),
12462             lpwidecharstr.into_param().abi(),
12463             ::std::mem::transmute(cchwidechar),
12464             ::std::mem::transmute(lpmultibytestr),
12465             ::std::mem::transmute(cbmultibyte),
12466             lpdefaultchar.into_param().abi(),
12467             ::std::mem::transmute(lpuseddefaultchar),
12468         ))
12469     }
12470     #[cfg(not(windows))]
12471     unimplemented!("Unsupported target OS");
12472 }
12473 #[cfg(feature = "Win32_Foundation")]
12474 #[inline]
lstrcatA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> super::Foundation::PSTR12475 pub unsafe fn lstrcatA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> super::Foundation::PSTR {
12476     #[cfg(windows)]
12477     {
12478         #[link(name = "windows")]
12479         extern "system" {
12480             fn lstrcatA(lpstring1: super::Foundation::PSTR, lpstring2: super::Foundation::PSTR) -> super::Foundation::PSTR;
12481         }
12482         ::std::mem::transmute(lstrcatA(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12483     }
12484     #[cfg(not(windows))]
12485     unimplemented!("Unsupported target OS");
12486 }
12487 #[cfg(feature = "Win32_Foundation")]
12488 #[inline]
lstrcatW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> super::Foundation::PWSTR12489 pub unsafe fn lstrcatW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> super::Foundation::PWSTR {
12490     #[cfg(windows)]
12491     {
12492         #[link(name = "windows")]
12493         extern "system" {
12494             fn lstrcatW(lpstring1: super::Foundation::PWSTR, lpstring2: super::Foundation::PWSTR) -> super::Foundation::PWSTR;
12495         }
12496         ::std::mem::transmute(lstrcatW(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12497     }
12498     #[cfg(not(windows))]
12499     unimplemented!("Unsupported target OS");
12500 }
12501 #[cfg(feature = "Win32_Foundation")]
12502 #[inline]
lstrcmpA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> i3212503 pub unsafe fn lstrcmpA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> i32 {
12504     #[cfg(windows)]
12505     {
12506         #[link(name = "windows")]
12507         extern "system" {
12508             fn lstrcmpA(lpstring1: super::Foundation::PSTR, lpstring2: super::Foundation::PSTR) -> i32;
12509         }
12510         ::std::mem::transmute(lstrcmpA(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12511     }
12512     #[cfg(not(windows))]
12513     unimplemented!("Unsupported target OS");
12514 }
12515 #[cfg(feature = "Win32_Foundation")]
12516 #[inline]
lstrcmpW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> i3212517 pub unsafe fn lstrcmpW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> i32 {
12518     #[cfg(windows)]
12519     {
12520         #[link(name = "windows")]
12521         extern "system" {
12522             fn lstrcmpW(lpstring1: super::Foundation::PWSTR, lpstring2: super::Foundation::PWSTR) -> i32;
12523         }
12524         ::std::mem::transmute(lstrcmpW(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12525     }
12526     #[cfg(not(windows))]
12527     unimplemented!("Unsupported target OS");
12528 }
12529 #[cfg(feature = "Win32_Foundation")]
12530 #[inline]
lstrcmpiA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> i3212531 pub unsafe fn lstrcmpiA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: Param0, lpstring2: Param1) -> i32 {
12532     #[cfg(windows)]
12533     {
12534         #[link(name = "windows")]
12535         extern "system" {
12536             fn lstrcmpiA(lpstring1: super::Foundation::PSTR, lpstring2: super::Foundation::PSTR) -> i32;
12537         }
12538         ::std::mem::transmute(lstrcmpiA(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12539     }
12540     #[cfg(not(windows))]
12541     unimplemented!("Unsupported target OS");
12542 }
12543 #[cfg(feature = "Win32_Foundation")]
12544 #[inline]
lstrcmpiW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> i3212545 pub unsafe fn lstrcmpiW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: Param0, lpstring2: Param1) -> i32 {
12546     #[cfg(windows)]
12547     {
12548         #[link(name = "windows")]
12549         extern "system" {
12550             fn lstrcmpiW(lpstring1: super::Foundation::PWSTR, lpstring2: super::Foundation::PWSTR) -> i32;
12551         }
12552         ::std::mem::transmute(lstrcmpiW(lpstring1.into_param().abi(), lpstring2.into_param().abi()))
12553     }
12554     #[cfg(not(windows))]
12555     unimplemented!("Unsupported target OS");
12556 }
12557 #[cfg(feature = "Win32_Foundation")]
12558 #[inline]
lstrcpyA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: super::Foundation::PSTR, lpstring2: Param1) -> super::Foundation::PSTR12559 pub unsafe fn lstrcpyA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: super::Foundation::PSTR, lpstring2: Param1) -> super::Foundation::PSTR {
12560     #[cfg(windows)]
12561     {
12562         #[link(name = "windows")]
12563         extern "system" {
12564             fn lstrcpyA(lpstring1: super::Foundation::PSTR, lpstring2: super::Foundation::PSTR) -> super::Foundation::PSTR;
12565         }
12566         ::std::mem::transmute(lstrcpyA(::std::mem::transmute(lpstring1), lpstring2.into_param().abi()))
12567     }
12568     #[cfg(not(windows))]
12569     unimplemented!("Unsupported target OS");
12570 }
12571 #[cfg(feature = "Win32_Foundation")]
12572 #[inline]
lstrcpyW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: super::Foundation::PWSTR, lpstring2: Param1) -> super::Foundation::PWSTR12573 pub unsafe fn lstrcpyW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: super::Foundation::PWSTR, lpstring2: Param1) -> super::Foundation::PWSTR {
12574     #[cfg(windows)]
12575     {
12576         #[link(name = "windows")]
12577         extern "system" {
12578             fn lstrcpyW(lpstring1: super::Foundation::PWSTR, lpstring2: super::Foundation::PWSTR) -> super::Foundation::PWSTR;
12579         }
12580         ::std::mem::transmute(lstrcpyW(::std::mem::transmute(lpstring1), lpstring2.into_param().abi()))
12581     }
12582     #[cfg(not(windows))]
12583     unimplemented!("Unsupported target OS");
12584 }
12585 #[cfg(feature = "Win32_Foundation")]
12586 #[inline]
lstrcpynA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: super::Foundation::PSTR, lpstring2: Param1, imaxlength: i32) -> super::Foundation::PSTR12587 pub unsafe fn lstrcpynA<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring1: super::Foundation::PSTR, lpstring2: Param1, imaxlength: i32) -> super::Foundation::PSTR {
12588     #[cfg(windows)]
12589     {
12590         #[link(name = "windows")]
12591         extern "system" {
12592             fn lstrcpynA(lpstring1: super::Foundation::PSTR, lpstring2: super::Foundation::PSTR, imaxlength: i32) -> super::Foundation::PSTR;
12593         }
12594         ::std::mem::transmute(lstrcpynA(::std::mem::transmute(lpstring1), lpstring2.into_param().abi(), ::std::mem::transmute(imaxlength)))
12595     }
12596     #[cfg(not(windows))]
12597     unimplemented!("Unsupported target OS");
12598 }
12599 #[cfg(feature = "Win32_Foundation")]
12600 #[inline]
lstrcpynW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: super::Foundation::PWSTR, lpstring2: Param1, imaxlength: i32) -> super::Foundation::PWSTR12601 pub unsafe fn lstrcpynW<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring1: super::Foundation::PWSTR, lpstring2: Param1, imaxlength: i32) -> super::Foundation::PWSTR {
12602     #[cfg(windows)]
12603     {
12604         #[link(name = "windows")]
12605         extern "system" {
12606             fn lstrcpynW(lpstring1: super::Foundation::PWSTR, lpstring2: super::Foundation::PWSTR, imaxlength: i32) -> super::Foundation::PWSTR;
12607         }
12608         ::std::mem::transmute(lstrcpynW(::std::mem::transmute(lpstring1), lpstring2.into_param().abi(), ::std::mem::transmute(imaxlength)))
12609     }
12610     #[cfg(not(windows))]
12611     unimplemented!("Unsupported target OS");
12612 }
12613 #[cfg(feature = "Win32_Foundation")]
12614 #[inline]
lstrlenA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring: Param0) -> i3212615 pub unsafe fn lstrlenA<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(lpstring: Param0) -> i32 {
12616     #[cfg(windows)]
12617     {
12618         #[link(name = "windows")]
12619         extern "system" {
12620             fn lstrlenA(lpstring: super::Foundation::PSTR) -> i32;
12621         }
12622         ::std::mem::transmute(lstrlenA(lpstring.into_param().abi()))
12623     }
12624     #[cfg(not(windows))]
12625     unimplemented!("Unsupported target OS");
12626 }
12627 #[cfg(feature = "Win32_Foundation")]
12628 #[inline]
lstrlenW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring: Param0) -> i3212629 pub unsafe fn lstrlenW<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(lpstring: Param0) -> i32 {
12630     #[cfg(windows)]
12631     {
12632         #[link(name = "windows")]
12633         extern "system" {
12634             fn lstrlenW(lpstring: super::Foundation::PWSTR) -> i32;
12635         }
12636         ::std::mem::transmute(lstrlenW(lpstring.into_param().abi()))
12637     }
12638     #[cfg(not(windows))]
12639     unimplemented!("Unsupported target OS");
12640 }
12641 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12642 #[repr(C)]
12643 pub struct opentype_feature_record {
12644     pub tagFeature: u32,
12645     pub lParameter: i32,
12646 }
12647 impl opentype_feature_record {}
12648 impl ::std::default::Default for opentype_feature_record {
default() -> Self12649     fn default() -> Self {
12650         unsafe { ::std::mem::zeroed() }
12651     }
12652 }
12653 impl ::std::fmt::Debug for opentype_feature_record {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12654     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12655         fmt.debug_struct("opentype_feature_record").field("tagFeature", &self.tagFeature).field("lParameter", &self.lParameter).finish()
12656     }
12657 }
12658 impl ::std::cmp::PartialEq for opentype_feature_record {
eq(&self, other: &Self) -> bool12659     fn eq(&self, other: &Self) -> bool {
12660         self.tagFeature == other.tagFeature && self.lParameter == other.lParameter
12661     }
12662 }
12663 impl ::std::cmp::Eq for opentype_feature_record {}
12664 unsafe impl ::windows::runtime::Abi for opentype_feature_record {
12665     type Abi = Self;
12666     type DefaultType = Self;
12667 }
12668 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12669 #[repr(C)]
12670 pub struct script_charprop {
12671     pub _bitfield: u16,
12672 }
12673 impl script_charprop {}
12674 impl ::std::default::Default for script_charprop {
default() -> Self12675     fn default() -> Self {
12676         unsafe { ::std::mem::zeroed() }
12677     }
12678 }
12679 impl ::std::fmt::Debug for script_charprop {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12680     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12681         fmt.debug_struct("script_charprop").field("_bitfield", &self._bitfield).finish()
12682     }
12683 }
12684 impl ::std::cmp::PartialEq for script_charprop {
eq(&self, other: &Self) -> bool12685     fn eq(&self, other: &Self) -> bool {
12686         self._bitfield == other._bitfield
12687     }
12688 }
12689 impl ::std::cmp::Eq for script_charprop {}
12690 unsafe impl ::windows::runtime::Abi for script_charprop {
12691     type Abi = Self;
12692     type DefaultType = Self;
12693 }
12694 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12695 #[repr(C)]
12696 pub struct script_glyphprop {
12697     pub sva: SCRIPT_VISATTR,
12698     pub reserved: u16,
12699 }
12700 impl script_glyphprop {}
12701 impl ::std::default::Default for script_glyphprop {
default() -> Self12702     fn default() -> Self {
12703         unsafe { ::std::mem::zeroed() }
12704     }
12705 }
12706 impl ::std::fmt::Debug for script_glyphprop {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12707     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12708         fmt.debug_struct("script_glyphprop").field("sva", &self.sva).field("reserved", &self.reserved).finish()
12709     }
12710 }
12711 impl ::std::cmp::PartialEq for script_glyphprop {
eq(&self, other: &Self) -> bool12712     fn eq(&self, other: &Self) -> bool {
12713         self.sva == other.sva && self.reserved == other.reserved
12714     }
12715 }
12716 impl ::std::cmp::Eq for script_glyphprop {}
12717 unsafe impl ::windows::runtime::Abi for script_glyphprop {
12718     type Abi = Self;
12719     type DefaultType = Self;
12720 }
12721 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12722 #[repr(transparent)]
12723 pub struct tagMLCONVCHARF(pub i32);
12724 pub const MLCONVCHARF_AUTODETECT: tagMLCONVCHARF = tagMLCONVCHARF(1i32);
12725 pub const MLCONVCHARF_ENTITIZE: tagMLCONVCHARF = tagMLCONVCHARF(2i32);
12726 pub const MLCONVCHARF_NCR_ENTITIZE: tagMLCONVCHARF = tagMLCONVCHARF(2i32);
12727 pub const MLCONVCHARF_NAME_ENTITIZE: tagMLCONVCHARF = tagMLCONVCHARF(4i32);
12728 pub const MLCONVCHARF_USEDEFCHAR: tagMLCONVCHARF = tagMLCONVCHARF(8i32);
12729 pub const MLCONVCHARF_NOBESTFITCHARS: tagMLCONVCHARF = tagMLCONVCHARF(16i32);
12730 pub const MLCONVCHARF_DETECTJPN: tagMLCONVCHARF = tagMLCONVCHARF(32i32);
12731 impl ::std::convert::From<i32> for tagMLCONVCHARF {
from(value: i32) -> Self12732     fn from(value: i32) -> Self {
12733         Self(value)
12734     }
12735 }
12736 unsafe impl ::windows::runtime::Abi for tagMLCONVCHARF {
12737     type Abi = Self;
12738     type DefaultType = Self;
12739 }
12740 #[derive(:: std :: cmp :: PartialEq, :: std :: cmp :: Eq, :: std :: marker :: Copy, :: std :: clone :: Clone, :: std :: default :: Default, :: std :: fmt :: Debug)]
12741 #[repr(transparent)]
12742 pub struct tagMLCPF(pub i32);
12743 pub const MLDETECTF_MAILNEWS: tagMLCPF = tagMLCPF(1i32);
12744 pub const MLDETECTF_BROWSER: tagMLCPF = tagMLCPF(2i32);
12745 pub const MLDETECTF_VALID: tagMLCPF = tagMLCPF(4i32);
12746 pub const MLDETECTF_VALID_NLS: tagMLCPF = tagMLCPF(8i32);
12747 pub const MLDETECTF_PRESERVE_ORDER: tagMLCPF = tagMLCPF(16i32);
12748 pub const MLDETECTF_PREFERRED_ONLY: tagMLCPF = tagMLCPF(32i32);
12749 pub const MLDETECTF_FILTER_SPECIALCHAR: tagMLCPF = tagMLCPF(64i32);
12750 pub const MLDETECTF_EURO_UTF8: tagMLCPF = tagMLCPF(128i32);
12751 impl ::std::convert::From<i32> for tagMLCPF {
from(value: i32) -> Self12752     fn from(value: i32) -> Self {
12753         Self(value)
12754     }
12755 }
12756 unsafe impl ::windows::runtime::Abi for tagMLCPF {
12757     type Abi = Self;
12758     type DefaultType = Self;
12759 }
12760 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12761 #[repr(C)]
12762 pub struct tagSCRIPFONTINFO {
12763     pub scripts: i64,
12764     pub wszFont: [u16; 32],
12765 }
12766 impl tagSCRIPFONTINFO {}
12767 impl ::std::default::Default for tagSCRIPFONTINFO {
default() -> Self12768     fn default() -> Self {
12769         unsafe { ::std::mem::zeroed() }
12770     }
12771 }
12772 impl ::std::fmt::Debug for tagSCRIPFONTINFO {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12773     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12774         fmt.debug_struct("tagSCRIPFONTINFO").field("scripts", &self.scripts).field("wszFont", &self.wszFont).finish()
12775     }
12776 }
12777 impl ::std::cmp::PartialEq for tagSCRIPFONTINFO {
eq(&self, other: &Self) -> bool12778     fn eq(&self, other: &Self) -> bool {
12779         self.scripts == other.scripts && self.wszFont == other.wszFont
12780     }
12781 }
12782 impl ::std::cmp::Eq for tagSCRIPFONTINFO {}
12783 unsafe impl ::windows::runtime::Abi for tagSCRIPFONTINFO {
12784     type Abi = Self;
12785     type DefaultType = Self;
12786 }
12787 #[derive(:: std :: clone :: Clone, :: std :: marker :: Copy)]
12788 #[repr(C)]
12789 pub struct textrange_properties {
12790     pub potfRecords: *mut opentype_feature_record,
12791     pub cotfRecords: i32,
12792 }
12793 impl textrange_properties {}
12794 impl ::std::default::Default for textrange_properties {
default() -> Self12795     fn default() -> Self {
12796         unsafe { ::std::mem::zeroed() }
12797     }
12798 }
12799 impl ::std::fmt::Debug for textrange_properties {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result12800     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
12801         fmt.debug_struct("textrange_properties").field("potfRecords", &self.potfRecords).field("cotfRecords", &self.cotfRecords).finish()
12802     }
12803 }
12804 impl ::std::cmp::PartialEq for textrange_properties {
eq(&self, other: &Self) -> bool12805     fn eq(&self, other: &Self) -> bool {
12806         self.potfRecords == other.potfRecords && self.cotfRecords == other.cotfRecords
12807     }
12808 }
12809 impl ::std::cmp::Eq for textrange_properties {}
12810 unsafe impl ::windows::runtime::Abi for textrange_properties {
12811     type Abi = Self;
12812     type DefaultType = Self;
12813 }
12814 #[cfg(feature = "Win32_Foundation")]
12815 #[inline]
u_UCharsToChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(us: *const u16, cs: Param1, length: i32)12816 pub unsafe fn u_UCharsToChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(us: *const u16, cs: Param1, length: i32) {
12817     #[cfg(windows)]
12818     {
12819         #[link(name = "windows")]
12820         extern "system" {
12821             fn u_UCharsToChars(us: *const u16, cs: super::Foundation::PSTR, length: i32);
12822         }
12823         ::std::mem::transmute(u_UCharsToChars(::std::mem::transmute(us), cs.into_param().abi(), ::std::mem::transmute(length)))
12824     }
12825     #[cfg(not(windows))]
12826     unimplemented!("Unsupported target OS");
12827 }
12828 #[cfg(feature = "Win32_Foundation")]
12829 #[inline]
u_austrcpy<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: Param0, src: *const u16) -> super::Foundation::PSTR12830 pub unsafe fn u_austrcpy<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: Param0, src: *const u16) -> super::Foundation::PSTR {
12831     #[cfg(windows)]
12832     {
12833         #[link(name = "windows")]
12834         extern "system" {
12835             fn u_austrcpy(dst: super::Foundation::PSTR, src: *const u16) -> super::Foundation::PSTR;
12836         }
12837         ::std::mem::transmute(u_austrcpy(dst.into_param().abi(), ::std::mem::transmute(src)))
12838     }
12839     #[cfg(not(windows))]
12840     unimplemented!("Unsupported target OS");
12841 }
12842 #[cfg(feature = "Win32_Foundation")]
12843 #[inline]
u_austrncpy<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: Param0, src: *const u16, n: i32) -> super::Foundation::PSTR12844 pub unsafe fn u_austrncpy<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: Param0, src: *const u16, n: i32) -> super::Foundation::PSTR {
12845     #[cfg(windows)]
12846     {
12847         #[link(name = "windows")]
12848         extern "system" {
12849             fn u_austrncpy(dst: super::Foundation::PSTR, src: *const u16, n: i32) -> super::Foundation::PSTR;
12850         }
12851         ::std::mem::transmute(u_austrncpy(dst.into_param().abi(), ::std::mem::transmute(src), ::std::mem::transmute(n)))
12852     }
12853     #[cfg(not(windows))]
12854     unimplemented!("Unsupported target OS");
12855 }
12856 #[inline]
u_catclose(catd: *mut UResourceBundle)12857 pub unsafe fn u_catclose(catd: *mut UResourceBundle) {
12858     #[cfg(windows)]
12859     {
12860         #[link(name = "windows")]
12861         extern "system" {
12862             fn u_catclose(catd: *mut UResourceBundle);
12863         }
12864         ::std::mem::transmute(u_catclose(::std::mem::transmute(catd)))
12865     }
12866     #[cfg(not(windows))]
12867     unimplemented!("Unsupported target OS");
12868 }
12869 #[inline]
u_catgets(catd: *mut UResourceBundle, set_num: i32, msg_num: i32, s: *const u16, len: *mut i32, ec: *mut UErrorCode) -> *mut u1612870 pub unsafe fn u_catgets(catd: *mut UResourceBundle, set_num: i32, msg_num: i32, s: *const u16, len: *mut i32, ec: *mut UErrorCode) -> *mut u16 {
12871     #[cfg(windows)]
12872     {
12873         #[link(name = "windows")]
12874         extern "system" {
12875             fn u_catgets(catd: *mut UResourceBundle, set_num: i32, msg_num: i32, s: *const u16, len: *mut i32, ec: *mut UErrorCode) -> *mut u16;
12876         }
12877         ::std::mem::transmute(u_catgets(::std::mem::transmute(catd), ::std::mem::transmute(set_num), ::std::mem::transmute(msg_num), ::std::mem::transmute(s), ::std::mem::transmute(len), ::std::mem::transmute(ec)))
12878     }
12879     #[cfg(not(windows))]
12880     unimplemented!("Unsupported target OS");
12881 }
12882 #[cfg(feature = "Win32_Foundation")]
12883 #[inline]
u_catopen<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, locale: Param1, ec: *mut UErrorCode) -> *mut UResourceBundle12884 pub unsafe fn u_catopen<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, locale: Param1, ec: *mut UErrorCode) -> *mut UResourceBundle {
12885     #[cfg(windows)]
12886     {
12887         #[link(name = "windows")]
12888         extern "system" {
12889             fn u_catopen(name: super::Foundation::PSTR, locale: super::Foundation::PSTR, ec: *mut UErrorCode) -> *mut UResourceBundle;
12890         }
12891         ::std::mem::transmute(u_catopen(name.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(ec)))
12892     }
12893     #[cfg(not(windows))]
12894     unimplemented!("Unsupported target OS");
12895 }
12896 #[inline]
u_charAge(c: i32, versionarray: *mut u8)12897 pub unsafe fn u_charAge(c: i32, versionarray: *mut u8) {
12898     #[cfg(windows)]
12899     {
12900         #[link(name = "windows")]
12901         extern "system" {
12902             fn u_charAge(c: i32, versionarray: *mut u8);
12903         }
12904         ::std::mem::transmute(u_charAge(::std::mem::transmute(c), ::std::mem::transmute(versionarray)))
12905     }
12906     #[cfg(not(windows))]
12907     unimplemented!("Unsupported target OS");
12908 }
12909 #[inline]
u_charDigitValue(c: i32) -> i3212910 pub unsafe fn u_charDigitValue(c: i32) -> i32 {
12911     #[cfg(windows)]
12912     {
12913         #[link(name = "windows")]
12914         extern "system" {
12915             fn u_charDigitValue(c: i32) -> i32;
12916         }
12917         ::std::mem::transmute(u_charDigitValue(::std::mem::transmute(c)))
12918     }
12919     #[cfg(not(windows))]
12920     unimplemented!("Unsupported target OS");
12921 }
12922 #[inline]
u_charDirection(c: i32) -> UCharDirection12923 pub unsafe fn u_charDirection(c: i32) -> UCharDirection {
12924     #[cfg(windows)]
12925     {
12926         #[link(name = "windows")]
12927         extern "system" {
12928             fn u_charDirection(c: i32) -> UCharDirection;
12929         }
12930         ::std::mem::transmute(u_charDirection(::std::mem::transmute(c)))
12931     }
12932     #[cfg(not(windows))]
12933     unimplemented!("Unsupported target OS");
12934 }
12935 #[cfg(feature = "Win32_Foundation")]
12936 #[inline]
u_charFromName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(namechoice: UCharNameChoice, name: Param1, perrorcode: *mut UErrorCode) -> i3212937 pub unsafe fn u_charFromName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(namechoice: UCharNameChoice, name: Param1, perrorcode: *mut UErrorCode) -> i32 {
12938     #[cfg(windows)]
12939     {
12940         #[link(name = "windows")]
12941         extern "system" {
12942             fn u_charFromName(namechoice: UCharNameChoice, name: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> i32;
12943         }
12944         ::std::mem::transmute(u_charFromName(::std::mem::transmute(namechoice), name.into_param().abi(), ::std::mem::transmute(perrorcode)))
12945     }
12946     #[cfg(not(windows))]
12947     unimplemented!("Unsupported target OS");
12948 }
12949 #[inline]
u_charMirror(c: i32) -> i3212950 pub unsafe fn u_charMirror(c: i32) -> i32 {
12951     #[cfg(windows)]
12952     {
12953         #[link(name = "windows")]
12954         extern "system" {
12955             fn u_charMirror(c: i32) -> i32;
12956         }
12957         ::std::mem::transmute(u_charMirror(::std::mem::transmute(c)))
12958     }
12959     #[cfg(not(windows))]
12960     unimplemented!("Unsupported target OS");
12961 }
12962 #[cfg(feature = "Win32_Foundation")]
12963 #[inline]
u_charName<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(code: i32, namechoice: UCharNameChoice, buffer: Param2, bufferlength: i32, perrorcode: *mut UErrorCode) -> i3212964 pub unsafe fn u_charName<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(code: i32, namechoice: UCharNameChoice, buffer: Param2, bufferlength: i32, perrorcode: *mut UErrorCode) -> i32 {
12965     #[cfg(windows)]
12966     {
12967         #[link(name = "windows")]
12968         extern "system" {
12969             fn u_charName(code: i32, namechoice: UCharNameChoice, buffer: super::Foundation::PSTR, bufferlength: i32, perrorcode: *mut UErrorCode) -> i32;
12970         }
12971         ::std::mem::transmute(u_charName(::std::mem::transmute(code), ::std::mem::transmute(namechoice), buffer.into_param().abi(), ::std::mem::transmute(bufferlength), ::std::mem::transmute(perrorcode)))
12972     }
12973     #[cfg(not(windows))]
12974     unimplemented!("Unsupported target OS");
12975 }
12976 #[inline]
u_charType(c: i32) -> i812977 pub unsafe fn u_charType(c: i32) -> i8 {
12978     #[cfg(windows)]
12979     {
12980         #[link(name = "windows")]
12981         extern "system" {
12982             fn u_charType(c: i32) -> i8;
12983         }
12984         ::std::mem::transmute(u_charType(::std::mem::transmute(c)))
12985     }
12986     #[cfg(not(windows))]
12987     unimplemented!("Unsupported target OS");
12988 }
12989 #[cfg(feature = "Win32_Foundation")]
12990 #[inline]
u_charsToUChars<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cs: Param0, us: *mut u16, length: i32)12991 pub unsafe fn u_charsToUChars<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cs: Param0, us: *mut u16, length: i32) {
12992     #[cfg(windows)]
12993     {
12994         #[link(name = "windows")]
12995         extern "system" {
12996             fn u_charsToUChars(cs: super::Foundation::PSTR, us: *mut u16, length: i32);
12997         }
12998         ::std::mem::transmute(u_charsToUChars(cs.into_param().abi(), ::std::mem::transmute(us), ::std::mem::transmute(length)))
12999     }
13000     #[cfg(not(windows))]
13001     unimplemented!("Unsupported target OS");
13002 }
13003 #[inline]
u_cleanup()13004 pub unsafe fn u_cleanup() {
13005     #[cfg(windows)]
13006     {
13007         #[link(name = "windows")]
13008         extern "system" {
13009             fn u_cleanup();
13010         }
13011         ::std::mem::transmute(u_cleanup())
13012     }
13013     #[cfg(not(windows))]
13014     unimplemented!("Unsupported target OS");
13015 }
13016 #[inline]
u_countChar32(s: *const u16, length: i32) -> i3213017 pub unsafe fn u_countChar32(s: *const u16, length: i32) -> i32 {
13018     #[cfg(windows)]
13019     {
13020         #[link(name = "windows")]
13021         extern "system" {
13022             fn u_countChar32(s: *const u16, length: i32) -> i32;
13023         }
13024         ::std::mem::transmute(u_countChar32(::std::mem::transmute(s), ::std::mem::transmute(length)))
13025     }
13026     #[cfg(not(windows))]
13027     unimplemented!("Unsupported target OS");
13028 }
13029 #[inline]
u_digit(ch: i32, radix: i8) -> i3213030 pub unsafe fn u_digit(ch: i32, radix: i8) -> i32 {
13031     #[cfg(windows)]
13032     {
13033         #[link(name = "windows")]
13034         extern "system" {
13035             fn u_digit(ch: i32, radix: i8) -> i32;
13036         }
13037         ::std::mem::transmute(u_digit(::std::mem::transmute(ch), ::std::mem::transmute(radix)))
13038     }
13039     #[cfg(not(windows))]
13040     unimplemented!("Unsupported target OS");
13041 }
13042 #[cfg(feature = "Win32_Foundation")]
13043 #[inline]
u_enumCharNames(start: i32, limit: i32, r#fn: *mut ::std::option::Option<UEnumCharNamesFn>, context: *mut ::std::ffi::c_void, namechoice: UCharNameChoice, perrorcode: *mut UErrorCode)13044 pub unsafe fn u_enumCharNames(start: i32, limit: i32, r#fn: *mut ::std::option::Option<UEnumCharNamesFn>, context: *mut ::std::ffi::c_void, namechoice: UCharNameChoice, perrorcode: *mut UErrorCode) {
13045     #[cfg(windows)]
13046     {
13047         #[link(name = "windows")]
13048         extern "system" {
13049             fn u_enumCharNames(start: i32, limit: i32, r#fn: *mut ::windows::runtime::RawPtr, context: *mut ::std::ffi::c_void, namechoice: UCharNameChoice, perrorcode: *mut UErrorCode);
13050         }
13051         ::std::mem::transmute(u_enumCharNames(::std::mem::transmute(start), ::std::mem::transmute(limit), ::std::mem::transmute(r#fn), ::std::mem::transmute(context), ::std::mem::transmute(namechoice), ::std::mem::transmute(perrorcode)))
13052     }
13053     #[cfg(not(windows))]
13054     unimplemented!("Unsupported target OS");
13055 }
13056 #[inline]
u_enumCharTypes(enumrange: *mut ::std::option::Option<UCharEnumTypeRange>, context: *const ::std::ffi::c_void)13057 pub unsafe fn u_enumCharTypes(enumrange: *mut ::std::option::Option<UCharEnumTypeRange>, context: *const ::std::ffi::c_void) {
13058     #[cfg(windows)]
13059     {
13060         #[link(name = "windows")]
13061         extern "system" {
13062             fn u_enumCharTypes(enumrange: *mut ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void);
13063         }
13064         ::std::mem::transmute(u_enumCharTypes(::std::mem::transmute(enumrange), ::std::mem::transmute(context)))
13065     }
13066     #[cfg(not(windows))]
13067     unimplemented!("Unsupported target OS");
13068 }
13069 #[cfg(feature = "Win32_Foundation")]
13070 #[inline]
u_errorName(code: UErrorCode) -> super::Foundation::PSTR13071 pub unsafe fn u_errorName(code: UErrorCode) -> super::Foundation::PSTR {
13072     #[cfg(windows)]
13073     {
13074         #[link(name = "windows")]
13075         extern "system" {
13076             fn u_errorName(code: UErrorCode) -> super::Foundation::PSTR;
13077         }
13078         ::std::mem::transmute(u_errorName(::std::mem::transmute(code)))
13079     }
13080     #[cfg(not(windows))]
13081     unimplemented!("Unsupported target OS");
13082 }
13083 #[inline]
u_foldCase(c: i32, options: u32) -> i3213084 pub unsafe fn u_foldCase(c: i32, options: u32) -> i32 {
13085     #[cfg(windows)]
13086     {
13087         #[link(name = "windows")]
13088         extern "system" {
13089             fn u_foldCase(c: i32, options: u32) -> i32;
13090         }
13091         ::std::mem::transmute(u_foldCase(::std::mem::transmute(c), ::std::mem::transmute(options)))
13092     }
13093     #[cfg(not(windows))]
13094     unimplemented!("Unsupported target OS");
13095 }
13096 #[inline]
u_forDigit(digit: i32, radix: i8) -> i3213097 pub unsafe fn u_forDigit(digit: i32, radix: i8) -> i32 {
13098     #[cfg(windows)]
13099     {
13100         #[link(name = "windows")]
13101         extern "system" {
13102             fn u_forDigit(digit: i32, radix: i8) -> i32;
13103         }
13104         ::std::mem::transmute(u_forDigit(::std::mem::transmute(digit), ::std::mem::transmute(radix)))
13105     }
13106     #[cfg(not(windows))]
13107     unimplemented!("Unsupported target OS");
13108 }
13109 #[cfg(feature = "Win32_Foundation")]
13110 #[inline]
u_formatMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3213111 pub unsafe fn u_formatMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
13112     #[cfg(windows)]
13113     {
13114         #[link(name = "windows")]
13115         extern "system" {
13116             fn u_formatMessage(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
13117         }
13118         ::std::mem::transmute(u_formatMessage(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
13119     }
13120     #[cfg(not(windows))]
13121     unimplemented!("Unsupported target OS");
13122 }
13123 #[cfg(feature = "Win32_Foundation")]
13124 #[inline]
u_formatMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i3213125 pub unsafe fn u_formatMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i32 {
13126     #[cfg(windows)]
13127     {
13128         #[link(name = "windows")]
13129         extern "system" {
13130             fn u_formatMessageWithError(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i32;
13131         }
13132         ::std::mem::transmute(u_formatMessageWithError(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
13133     }
13134     #[cfg(not(windows))]
13135     unimplemented!("Unsupported target OS");
13136 }
13137 #[inline]
u_getBidiPairedBracket(c: i32) -> i3213138 pub unsafe fn u_getBidiPairedBracket(c: i32) -> i32 {
13139     #[cfg(windows)]
13140     {
13141         #[link(name = "windows")]
13142         extern "system" {
13143             fn u_getBidiPairedBracket(c: i32) -> i32;
13144         }
13145         ::std::mem::transmute(u_getBidiPairedBracket(::std::mem::transmute(c)))
13146     }
13147     #[cfg(not(windows))]
13148     unimplemented!("Unsupported target OS");
13149 }
13150 #[inline]
u_getBinaryPropertySet(property: UProperty, perrorcode: *mut UErrorCode) -> *mut USet13151 pub unsafe fn u_getBinaryPropertySet(property: UProperty, perrorcode: *mut UErrorCode) -> *mut USet {
13152     #[cfg(windows)]
13153     {
13154         #[link(name = "windows")]
13155         extern "system" {
13156             fn u_getBinaryPropertySet(property: UProperty, perrorcode: *mut UErrorCode) -> *mut USet;
13157         }
13158         ::std::mem::transmute(u_getBinaryPropertySet(::std::mem::transmute(property), ::std::mem::transmute(perrorcode)))
13159     }
13160     #[cfg(not(windows))]
13161     unimplemented!("Unsupported target OS");
13162 }
13163 #[inline]
u_getCombiningClass(c: i32) -> u813164 pub unsafe fn u_getCombiningClass(c: i32) -> u8 {
13165     #[cfg(windows)]
13166     {
13167         #[link(name = "windows")]
13168         extern "system" {
13169             fn u_getCombiningClass(c: i32) -> u8;
13170         }
13171         ::std::mem::transmute(u_getCombiningClass(::std::mem::transmute(c)))
13172     }
13173     #[cfg(not(windows))]
13174     unimplemented!("Unsupported target OS");
13175 }
13176 #[inline]
u_getDataVersion(dataversionfillin: *mut u8, status: *mut UErrorCode)13177 pub unsafe fn u_getDataVersion(dataversionfillin: *mut u8, status: *mut UErrorCode) {
13178     #[cfg(windows)]
13179     {
13180         #[link(name = "windows")]
13181         extern "system" {
13182             fn u_getDataVersion(dataversionfillin: *mut u8, status: *mut UErrorCode);
13183         }
13184         ::std::mem::transmute(u_getDataVersion(::std::mem::transmute(dataversionfillin), ::std::mem::transmute(status)))
13185     }
13186     #[cfg(not(windows))]
13187     unimplemented!("Unsupported target OS");
13188 }
13189 #[inline]
u_getFC_NFKC_Closure(c: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3213190 pub unsafe fn u_getFC_NFKC_Closure(c: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
13191     #[cfg(windows)]
13192     {
13193         #[link(name = "windows")]
13194         extern "system" {
13195             fn u_getFC_NFKC_Closure(c: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
13196         }
13197         ::std::mem::transmute(u_getFC_NFKC_Closure(::std::mem::transmute(c), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(perrorcode)))
13198     }
13199     #[cfg(not(windows))]
13200     unimplemented!("Unsupported target OS");
13201 }
13202 #[inline]
u_getIntPropertyMap(property: UProperty, perrorcode: *mut UErrorCode) -> *mut UCPMap13203 pub unsafe fn u_getIntPropertyMap(property: UProperty, perrorcode: *mut UErrorCode) -> *mut UCPMap {
13204     #[cfg(windows)]
13205     {
13206         #[link(name = "windows")]
13207         extern "system" {
13208             fn u_getIntPropertyMap(property: UProperty, perrorcode: *mut UErrorCode) -> *mut UCPMap;
13209         }
13210         ::std::mem::transmute(u_getIntPropertyMap(::std::mem::transmute(property), ::std::mem::transmute(perrorcode)))
13211     }
13212     #[cfg(not(windows))]
13213     unimplemented!("Unsupported target OS");
13214 }
13215 #[inline]
u_getIntPropertyMaxValue(which: UProperty) -> i3213216 pub unsafe fn u_getIntPropertyMaxValue(which: UProperty) -> i32 {
13217     #[cfg(windows)]
13218     {
13219         #[link(name = "windows")]
13220         extern "system" {
13221             fn u_getIntPropertyMaxValue(which: UProperty) -> i32;
13222         }
13223         ::std::mem::transmute(u_getIntPropertyMaxValue(::std::mem::transmute(which)))
13224     }
13225     #[cfg(not(windows))]
13226     unimplemented!("Unsupported target OS");
13227 }
13228 #[inline]
u_getIntPropertyMinValue(which: UProperty) -> i3213229 pub unsafe fn u_getIntPropertyMinValue(which: UProperty) -> i32 {
13230     #[cfg(windows)]
13231     {
13232         #[link(name = "windows")]
13233         extern "system" {
13234             fn u_getIntPropertyMinValue(which: UProperty) -> i32;
13235         }
13236         ::std::mem::transmute(u_getIntPropertyMinValue(::std::mem::transmute(which)))
13237     }
13238     #[cfg(not(windows))]
13239     unimplemented!("Unsupported target OS");
13240 }
13241 #[inline]
u_getIntPropertyValue(c: i32, which: UProperty) -> i3213242 pub unsafe fn u_getIntPropertyValue(c: i32, which: UProperty) -> i32 {
13243     #[cfg(windows)]
13244     {
13245         #[link(name = "windows")]
13246         extern "system" {
13247             fn u_getIntPropertyValue(c: i32, which: UProperty) -> i32;
13248         }
13249         ::std::mem::transmute(u_getIntPropertyValue(::std::mem::transmute(c), ::std::mem::transmute(which)))
13250     }
13251     #[cfg(not(windows))]
13252     unimplemented!("Unsupported target OS");
13253 }
13254 #[inline]
u_getNumericValue(c: i32) -> f6413255 pub unsafe fn u_getNumericValue(c: i32) -> f64 {
13256     #[cfg(windows)]
13257     {
13258         #[link(name = "windows")]
13259         extern "system" {
13260             fn u_getNumericValue(c: i32) -> f64;
13261         }
13262         ::std::mem::transmute(u_getNumericValue(::std::mem::transmute(c)))
13263     }
13264     #[cfg(not(windows))]
13265     unimplemented!("Unsupported target OS");
13266 }
13267 #[cfg(feature = "Win32_Foundation")]
13268 #[inline]
u_getPropertyEnum<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0) -> UProperty13269 pub unsafe fn u_getPropertyEnum<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0) -> UProperty {
13270     #[cfg(windows)]
13271     {
13272         #[link(name = "windows")]
13273         extern "system" {
13274             fn u_getPropertyEnum(alias: super::Foundation::PSTR) -> UProperty;
13275         }
13276         ::std::mem::transmute(u_getPropertyEnum(alias.into_param().abi()))
13277     }
13278     #[cfg(not(windows))]
13279     unimplemented!("Unsupported target OS");
13280 }
13281 #[cfg(feature = "Win32_Foundation")]
13282 #[inline]
u_getPropertyName(property: UProperty, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR13283 pub unsafe fn u_getPropertyName(property: UProperty, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR {
13284     #[cfg(windows)]
13285     {
13286         #[link(name = "windows")]
13287         extern "system" {
13288             fn u_getPropertyName(property: UProperty, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR;
13289         }
13290         ::std::mem::transmute(u_getPropertyName(::std::mem::transmute(property), ::std::mem::transmute(namechoice)))
13291     }
13292     #[cfg(not(windows))]
13293     unimplemented!("Unsupported target OS");
13294 }
13295 #[cfg(feature = "Win32_Foundation")]
13296 #[inline]
u_getPropertyValueEnum<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(property: UProperty, alias: Param1) -> i3213297 pub unsafe fn u_getPropertyValueEnum<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(property: UProperty, alias: Param1) -> i32 {
13298     #[cfg(windows)]
13299     {
13300         #[link(name = "windows")]
13301         extern "system" {
13302             fn u_getPropertyValueEnum(property: UProperty, alias: super::Foundation::PSTR) -> i32;
13303         }
13304         ::std::mem::transmute(u_getPropertyValueEnum(::std::mem::transmute(property), alias.into_param().abi()))
13305     }
13306     #[cfg(not(windows))]
13307     unimplemented!("Unsupported target OS");
13308 }
13309 #[cfg(feature = "Win32_Foundation")]
13310 #[inline]
u_getPropertyValueName(property: UProperty, value: i32, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR13311 pub unsafe fn u_getPropertyValueName(property: UProperty, value: i32, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR {
13312     #[cfg(windows)]
13313     {
13314         #[link(name = "windows")]
13315         extern "system" {
13316             fn u_getPropertyValueName(property: UProperty, value: i32, namechoice: UPropertyNameChoice) -> super::Foundation::PSTR;
13317         }
13318         ::std::mem::transmute(u_getPropertyValueName(::std::mem::transmute(property), ::std::mem::transmute(value), ::std::mem::transmute(namechoice)))
13319     }
13320     #[cfg(not(windows))]
13321     unimplemented!("Unsupported target OS");
13322 }
13323 #[inline]
u_getUnicodeVersion(versionarray: *mut u8)13324 pub unsafe fn u_getUnicodeVersion(versionarray: *mut u8) {
13325     #[cfg(windows)]
13326     {
13327         #[link(name = "windows")]
13328         extern "system" {
13329             fn u_getUnicodeVersion(versionarray: *mut u8);
13330         }
13331         ::std::mem::transmute(u_getUnicodeVersion(::std::mem::transmute(versionarray)))
13332     }
13333     #[cfg(not(windows))]
13334     unimplemented!("Unsupported target OS");
13335 }
13336 #[inline]
u_getVersion(versionarray: *mut u8)13337 pub unsafe fn u_getVersion(versionarray: *mut u8) {
13338     #[cfg(windows)]
13339     {
13340         #[link(name = "windows")]
13341         extern "system" {
13342             fn u_getVersion(versionarray: *mut u8);
13343         }
13344         ::std::mem::transmute(u_getVersion(::std::mem::transmute(versionarray)))
13345     }
13346     #[cfg(not(windows))]
13347     unimplemented!("Unsupported target OS");
13348 }
13349 #[inline]
u_hasBinaryProperty(c: i32, which: UProperty) -> i813350 pub unsafe fn u_hasBinaryProperty(c: i32, which: UProperty) -> i8 {
13351     #[cfg(windows)]
13352     {
13353         #[link(name = "windows")]
13354         extern "system" {
13355             fn u_hasBinaryProperty(c: i32, which: UProperty) -> i8;
13356         }
13357         ::std::mem::transmute(u_hasBinaryProperty(::std::mem::transmute(c), ::std::mem::transmute(which)))
13358     }
13359     #[cfg(not(windows))]
13360     unimplemented!("Unsupported target OS");
13361 }
13362 #[inline]
u_init(status: *mut UErrorCode)13363 pub unsafe fn u_init(status: *mut UErrorCode) {
13364     #[cfg(windows)]
13365     {
13366         #[link(name = "windows")]
13367         extern "system" {
13368             fn u_init(status: *mut UErrorCode);
13369         }
13370         ::std::mem::transmute(u_init(::std::mem::transmute(status)))
13371     }
13372     #[cfg(not(windows))]
13373     unimplemented!("Unsupported target OS");
13374 }
13375 #[inline]
u_isIDIgnorable(c: i32) -> i813376 pub unsafe fn u_isIDIgnorable(c: i32) -> i8 {
13377     #[cfg(windows)]
13378     {
13379         #[link(name = "windows")]
13380         extern "system" {
13381             fn u_isIDIgnorable(c: i32) -> i8;
13382         }
13383         ::std::mem::transmute(u_isIDIgnorable(::std::mem::transmute(c)))
13384     }
13385     #[cfg(not(windows))]
13386     unimplemented!("Unsupported target OS");
13387 }
13388 #[inline]
u_isIDPart(c: i32) -> i813389 pub unsafe fn u_isIDPart(c: i32) -> i8 {
13390     #[cfg(windows)]
13391     {
13392         #[link(name = "windows")]
13393         extern "system" {
13394             fn u_isIDPart(c: i32) -> i8;
13395         }
13396         ::std::mem::transmute(u_isIDPart(::std::mem::transmute(c)))
13397     }
13398     #[cfg(not(windows))]
13399     unimplemented!("Unsupported target OS");
13400 }
13401 #[inline]
u_isIDStart(c: i32) -> i813402 pub unsafe fn u_isIDStart(c: i32) -> i8 {
13403     #[cfg(windows)]
13404     {
13405         #[link(name = "windows")]
13406         extern "system" {
13407             fn u_isIDStart(c: i32) -> i8;
13408         }
13409         ::std::mem::transmute(u_isIDStart(::std::mem::transmute(c)))
13410     }
13411     #[cfg(not(windows))]
13412     unimplemented!("Unsupported target OS");
13413 }
13414 #[inline]
u_isISOControl(c: i32) -> i813415 pub unsafe fn u_isISOControl(c: i32) -> i8 {
13416     #[cfg(windows)]
13417     {
13418         #[link(name = "windows")]
13419         extern "system" {
13420             fn u_isISOControl(c: i32) -> i8;
13421         }
13422         ::std::mem::transmute(u_isISOControl(::std::mem::transmute(c)))
13423     }
13424     #[cfg(not(windows))]
13425     unimplemented!("Unsupported target OS");
13426 }
13427 #[inline]
u_isJavaIDPart(c: i32) -> i813428 pub unsafe fn u_isJavaIDPart(c: i32) -> i8 {
13429     #[cfg(windows)]
13430     {
13431         #[link(name = "windows")]
13432         extern "system" {
13433             fn u_isJavaIDPart(c: i32) -> i8;
13434         }
13435         ::std::mem::transmute(u_isJavaIDPart(::std::mem::transmute(c)))
13436     }
13437     #[cfg(not(windows))]
13438     unimplemented!("Unsupported target OS");
13439 }
13440 #[inline]
u_isJavaIDStart(c: i32) -> i813441 pub unsafe fn u_isJavaIDStart(c: i32) -> i8 {
13442     #[cfg(windows)]
13443     {
13444         #[link(name = "windows")]
13445         extern "system" {
13446             fn u_isJavaIDStart(c: i32) -> i8;
13447         }
13448         ::std::mem::transmute(u_isJavaIDStart(::std::mem::transmute(c)))
13449     }
13450     #[cfg(not(windows))]
13451     unimplemented!("Unsupported target OS");
13452 }
13453 #[inline]
u_isJavaSpaceChar(c: i32) -> i813454 pub unsafe fn u_isJavaSpaceChar(c: i32) -> i8 {
13455     #[cfg(windows)]
13456     {
13457         #[link(name = "windows")]
13458         extern "system" {
13459             fn u_isJavaSpaceChar(c: i32) -> i8;
13460         }
13461         ::std::mem::transmute(u_isJavaSpaceChar(::std::mem::transmute(c)))
13462     }
13463     #[cfg(not(windows))]
13464     unimplemented!("Unsupported target OS");
13465 }
13466 #[inline]
u_isMirrored(c: i32) -> i813467 pub unsafe fn u_isMirrored(c: i32) -> i8 {
13468     #[cfg(windows)]
13469     {
13470         #[link(name = "windows")]
13471         extern "system" {
13472             fn u_isMirrored(c: i32) -> i8;
13473         }
13474         ::std::mem::transmute(u_isMirrored(::std::mem::transmute(c)))
13475     }
13476     #[cfg(not(windows))]
13477     unimplemented!("Unsupported target OS");
13478 }
13479 #[inline]
u_isUAlphabetic(c: i32) -> i813480 pub unsafe fn u_isUAlphabetic(c: i32) -> i8 {
13481     #[cfg(windows)]
13482     {
13483         #[link(name = "windows")]
13484         extern "system" {
13485             fn u_isUAlphabetic(c: i32) -> i8;
13486         }
13487         ::std::mem::transmute(u_isUAlphabetic(::std::mem::transmute(c)))
13488     }
13489     #[cfg(not(windows))]
13490     unimplemented!("Unsupported target OS");
13491 }
13492 #[inline]
u_isULowercase(c: i32) -> i813493 pub unsafe fn u_isULowercase(c: i32) -> i8 {
13494     #[cfg(windows)]
13495     {
13496         #[link(name = "windows")]
13497         extern "system" {
13498             fn u_isULowercase(c: i32) -> i8;
13499         }
13500         ::std::mem::transmute(u_isULowercase(::std::mem::transmute(c)))
13501     }
13502     #[cfg(not(windows))]
13503     unimplemented!("Unsupported target OS");
13504 }
13505 #[inline]
u_isUUppercase(c: i32) -> i813506 pub unsafe fn u_isUUppercase(c: i32) -> i8 {
13507     #[cfg(windows)]
13508     {
13509         #[link(name = "windows")]
13510         extern "system" {
13511             fn u_isUUppercase(c: i32) -> i8;
13512         }
13513         ::std::mem::transmute(u_isUUppercase(::std::mem::transmute(c)))
13514     }
13515     #[cfg(not(windows))]
13516     unimplemented!("Unsupported target OS");
13517 }
13518 #[inline]
u_isUWhiteSpace(c: i32) -> i813519 pub unsafe fn u_isUWhiteSpace(c: i32) -> i8 {
13520     #[cfg(windows)]
13521     {
13522         #[link(name = "windows")]
13523         extern "system" {
13524             fn u_isUWhiteSpace(c: i32) -> i8;
13525         }
13526         ::std::mem::transmute(u_isUWhiteSpace(::std::mem::transmute(c)))
13527     }
13528     #[cfg(not(windows))]
13529     unimplemented!("Unsupported target OS");
13530 }
13531 #[inline]
u_isWhitespace(c: i32) -> i813532 pub unsafe fn u_isWhitespace(c: i32) -> i8 {
13533     #[cfg(windows)]
13534     {
13535         #[link(name = "windows")]
13536         extern "system" {
13537             fn u_isWhitespace(c: i32) -> i8;
13538         }
13539         ::std::mem::transmute(u_isWhitespace(::std::mem::transmute(c)))
13540     }
13541     #[cfg(not(windows))]
13542     unimplemented!("Unsupported target OS");
13543 }
13544 #[inline]
u_isalnum(c: i32) -> i813545 pub unsafe fn u_isalnum(c: i32) -> i8 {
13546     #[cfg(windows)]
13547     {
13548         #[link(name = "windows")]
13549         extern "system" {
13550             fn u_isalnum(c: i32) -> i8;
13551         }
13552         ::std::mem::transmute(u_isalnum(::std::mem::transmute(c)))
13553     }
13554     #[cfg(not(windows))]
13555     unimplemented!("Unsupported target OS");
13556 }
13557 #[inline]
u_isalpha(c: i32) -> i813558 pub unsafe fn u_isalpha(c: i32) -> i8 {
13559     #[cfg(windows)]
13560     {
13561         #[link(name = "windows")]
13562         extern "system" {
13563             fn u_isalpha(c: i32) -> i8;
13564         }
13565         ::std::mem::transmute(u_isalpha(::std::mem::transmute(c)))
13566     }
13567     #[cfg(not(windows))]
13568     unimplemented!("Unsupported target OS");
13569 }
13570 #[inline]
u_isbase(c: i32) -> i813571 pub unsafe fn u_isbase(c: i32) -> i8 {
13572     #[cfg(windows)]
13573     {
13574         #[link(name = "windows")]
13575         extern "system" {
13576             fn u_isbase(c: i32) -> i8;
13577         }
13578         ::std::mem::transmute(u_isbase(::std::mem::transmute(c)))
13579     }
13580     #[cfg(not(windows))]
13581     unimplemented!("Unsupported target OS");
13582 }
13583 #[inline]
u_isblank(c: i32) -> i813584 pub unsafe fn u_isblank(c: i32) -> i8 {
13585     #[cfg(windows)]
13586     {
13587         #[link(name = "windows")]
13588         extern "system" {
13589             fn u_isblank(c: i32) -> i8;
13590         }
13591         ::std::mem::transmute(u_isblank(::std::mem::transmute(c)))
13592     }
13593     #[cfg(not(windows))]
13594     unimplemented!("Unsupported target OS");
13595 }
13596 #[inline]
u_iscntrl(c: i32) -> i813597 pub unsafe fn u_iscntrl(c: i32) -> i8 {
13598     #[cfg(windows)]
13599     {
13600         #[link(name = "windows")]
13601         extern "system" {
13602             fn u_iscntrl(c: i32) -> i8;
13603         }
13604         ::std::mem::transmute(u_iscntrl(::std::mem::transmute(c)))
13605     }
13606     #[cfg(not(windows))]
13607     unimplemented!("Unsupported target OS");
13608 }
13609 #[inline]
u_isdefined(c: i32) -> i813610 pub unsafe fn u_isdefined(c: i32) -> i8 {
13611     #[cfg(windows)]
13612     {
13613         #[link(name = "windows")]
13614         extern "system" {
13615             fn u_isdefined(c: i32) -> i8;
13616         }
13617         ::std::mem::transmute(u_isdefined(::std::mem::transmute(c)))
13618     }
13619     #[cfg(not(windows))]
13620     unimplemented!("Unsupported target OS");
13621 }
13622 #[inline]
u_isdigit(c: i32) -> i813623 pub unsafe fn u_isdigit(c: i32) -> i8 {
13624     #[cfg(windows)]
13625     {
13626         #[link(name = "windows")]
13627         extern "system" {
13628             fn u_isdigit(c: i32) -> i8;
13629         }
13630         ::std::mem::transmute(u_isdigit(::std::mem::transmute(c)))
13631     }
13632     #[cfg(not(windows))]
13633     unimplemented!("Unsupported target OS");
13634 }
13635 #[inline]
u_isgraph(c: i32) -> i813636 pub unsafe fn u_isgraph(c: i32) -> i8 {
13637     #[cfg(windows)]
13638     {
13639         #[link(name = "windows")]
13640         extern "system" {
13641             fn u_isgraph(c: i32) -> i8;
13642         }
13643         ::std::mem::transmute(u_isgraph(::std::mem::transmute(c)))
13644     }
13645     #[cfg(not(windows))]
13646     unimplemented!("Unsupported target OS");
13647 }
13648 #[inline]
u_islower(c: i32) -> i813649 pub unsafe fn u_islower(c: i32) -> i8 {
13650     #[cfg(windows)]
13651     {
13652         #[link(name = "windows")]
13653         extern "system" {
13654             fn u_islower(c: i32) -> i8;
13655         }
13656         ::std::mem::transmute(u_islower(::std::mem::transmute(c)))
13657     }
13658     #[cfg(not(windows))]
13659     unimplemented!("Unsupported target OS");
13660 }
13661 #[inline]
u_isprint(c: i32) -> i813662 pub unsafe fn u_isprint(c: i32) -> i8 {
13663     #[cfg(windows)]
13664     {
13665         #[link(name = "windows")]
13666         extern "system" {
13667             fn u_isprint(c: i32) -> i8;
13668         }
13669         ::std::mem::transmute(u_isprint(::std::mem::transmute(c)))
13670     }
13671     #[cfg(not(windows))]
13672     unimplemented!("Unsupported target OS");
13673 }
13674 #[inline]
u_ispunct(c: i32) -> i813675 pub unsafe fn u_ispunct(c: i32) -> i8 {
13676     #[cfg(windows)]
13677     {
13678         #[link(name = "windows")]
13679         extern "system" {
13680             fn u_ispunct(c: i32) -> i8;
13681         }
13682         ::std::mem::transmute(u_ispunct(::std::mem::transmute(c)))
13683     }
13684     #[cfg(not(windows))]
13685     unimplemented!("Unsupported target OS");
13686 }
13687 #[inline]
u_isspace(c: i32) -> i813688 pub unsafe fn u_isspace(c: i32) -> i8 {
13689     #[cfg(windows)]
13690     {
13691         #[link(name = "windows")]
13692         extern "system" {
13693             fn u_isspace(c: i32) -> i8;
13694         }
13695         ::std::mem::transmute(u_isspace(::std::mem::transmute(c)))
13696     }
13697     #[cfg(not(windows))]
13698     unimplemented!("Unsupported target OS");
13699 }
13700 #[inline]
u_istitle(c: i32) -> i813701 pub unsafe fn u_istitle(c: i32) -> i8 {
13702     #[cfg(windows)]
13703     {
13704         #[link(name = "windows")]
13705         extern "system" {
13706             fn u_istitle(c: i32) -> i8;
13707         }
13708         ::std::mem::transmute(u_istitle(::std::mem::transmute(c)))
13709     }
13710     #[cfg(not(windows))]
13711     unimplemented!("Unsupported target OS");
13712 }
13713 #[inline]
u_isupper(c: i32) -> i813714 pub unsafe fn u_isupper(c: i32) -> i8 {
13715     #[cfg(windows)]
13716     {
13717         #[link(name = "windows")]
13718         extern "system" {
13719             fn u_isupper(c: i32) -> i8;
13720         }
13721         ::std::mem::transmute(u_isupper(::std::mem::transmute(c)))
13722     }
13723     #[cfg(not(windows))]
13724     unimplemented!("Unsupported target OS");
13725 }
13726 #[inline]
u_isxdigit(c: i32) -> i813727 pub unsafe fn u_isxdigit(c: i32) -> i8 {
13728     #[cfg(windows)]
13729     {
13730         #[link(name = "windows")]
13731         extern "system" {
13732             fn u_isxdigit(c: i32) -> i8;
13733         }
13734         ::std::mem::transmute(u_isxdigit(::std::mem::transmute(c)))
13735     }
13736     #[cfg(not(windows))]
13737     unimplemented!("Unsupported target OS");
13738 }
13739 #[inline]
u_memcasecmp(s1: *const u16, s2: *const u16, length: i32, options: u32) -> i3213740 pub unsafe fn u_memcasecmp(s1: *const u16, s2: *const u16, length: i32, options: u32) -> i32 {
13741     #[cfg(windows)]
13742     {
13743         #[link(name = "windows")]
13744         extern "system" {
13745             fn u_memcasecmp(s1: *const u16, s2: *const u16, length: i32, options: u32) -> i32;
13746         }
13747         ::std::mem::transmute(u_memcasecmp(::std::mem::transmute(s1), ::std::mem::transmute(s2), ::std::mem::transmute(length), ::std::mem::transmute(options)))
13748     }
13749     #[cfg(not(windows))]
13750     unimplemented!("Unsupported target OS");
13751 }
13752 #[inline]
u_memchr(s: *const u16, c: u16, count: i32) -> *mut u1613753 pub unsafe fn u_memchr(s: *const u16, c: u16, count: i32) -> *mut u16 {
13754     #[cfg(windows)]
13755     {
13756         #[link(name = "windows")]
13757         extern "system" {
13758             fn u_memchr(s: *const u16, c: u16, count: i32) -> *mut u16;
13759         }
13760         ::std::mem::transmute(u_memchr(::std::mem::transmute(s), ::std::mem::transmute(c), ::std::mem::transmute(count)))
13761     }
13762     #[cfg(not(windows))]
13763     unimplemented!("Unsupported target OS");
13764 }
13765 #[inline]
u_memchr32(s: *const u16, c: i32, count: i32) -> *mut u1613766 pub unsafe fn u_memchr32(s: *const u16, c: i32, count: i32) -> *mut u16 {
13767     #[cfg(windows)]
13768     {
13769         #[link(name = "windows")]
13770         extern "system" {
13771             fn u_memchr32(s: *const u16, c: i32, count: i32) -> *mut u16;
13772         }
13773         ::std::mem::transmute(u_memchr32(::std::mem::transmute(s), ::std::mem::transmute(c), ::std::mem::transmute(count)))
13774     }
13775     #[cfg(not(windows))]
13776     unimplemented!("Unsupported target OS");
13777 }
13778 #[inline]
u_memcmp(buf1: *const u16, buf2: *const u16, count: i32) -> i3213779 pub unsafe fn u_memcmp(buf1: *const u16, buf2: *const u16, count: i32) -> i32 {
13780     #[cfg(windows)]
13781     {
13782         #[link(name = "windows")]
13783         extern "system" {
13784             fn u_memcmp(buf1: *const u16, buf2: *const u16, count: i32) -> i32;
13785         }
13786         ::std::mem::transmute(u_memcmp(::std::mem::transmute(buf1), ::std::mem::transmute(buf2), ::std::mem::transmute(count)))
13787     }
13788     #[cfg(not(windows))]
13789     unimplemented!("Unsupported target OS");
13790 }
13791 #[inline]
u_memcmpCodePointOrder(s1: *const u16, s2: *const u16, count: i32) -> i3213792 pub unsafe fn u_memcmpCodePointOrder(s1: *const u16, s2: *const u16, count: i32) -> i32 {
13793     #[cfg(windows)]
13794     {
13795         #[link(name = "windows")]
13796         extern "system" {
13797             fn u_memcmpCodePointOrder(s1: *const u16, s2: *const u16, count: i32) -> i32;
13798         }
13799         ::std::mem::transmute(u_memcmpCodePointOrder(::std::mem::transmute(s1), ::std::mem::transmute(s2), ::std::mem::transmute(count)))
13800     }
13801     #[cfg(not(windows))]
13802     unimplemented!("Unsupported target OS");
13803 }
13804 #[inline]
u_memcpy(dest: *mut u16, src: *const u16, count: i32) -> *mut u1613805 pub unsafe fn u_memcpy(dest: *mut u16, src: *const u16, count: i32) -> *mut u16 {
13806     #[cfg(windows)]
13807     {
13808         #[link(name = "windows")]
13809         extern "system" {
13810             fn u_memcpy(dest: *mut u16, src: *const u16, count: i32) -> *mut u16;
13811         }
13812         ::std::mem::transmute(u_memcpy(::std::mem::transmute(dest), ::std::mem::transmute(src), ::std::mem::transmute(count)))
13813     }
13814     #[cfg(not(windows))]
13815     unimplemented!("Unsupported target OS");
13816 }
13817 #[inline]
u_memmove(dest: *mut u16, src: *const u16, count: i32) -> *mut u1613818 pub unsafe fn u_memmove(dest: *mut u16, src: *const u16, count: i32) -> *mut u16 {
13819     #[cfg(windows)]
13820     {
13821         #[link(name = "windows")]
13822         extern "system" {
13823             fn u_memmove(dest: *mut u16, src: *const u16, count: i32) -> *mut u16;
13824         }
13825         ::std::mem::transmute(u_memmove(::std::mem::transmute(dest), ::std::mem::transmute(src), ::std::mem::transmute(count)))
13826     }
13827     #[cfg(not(windows))]
13828     unimplemented!("Unsupported target OS");
13829 }
13830 #[inline]
u_memrchr(s: *const u16, c: u16, count: i32) -> *mut u1613831 pub unsafe fn u_memrchr(s: *const u16, c: u16, count: i32) -> *mut u16 {
13832     #[cfg(windows)]
13833     {
13834         #[link(name = "windows")]
13835         extern "system" {
13836             fn u_memrchr(s: *const u16, c: u16, count: i32) -> *mut u16;
13837         }
13838         ::std::mem::transmute(u_memrchr(::std::mem::transmute(s), ::std::mem::transmute(c), ::std::mem::transmute(count)))
13839     }
13840     #[cfg(not(windows))]
13841     unimplemented!("Unsupported target OS");
13842 }
13843 #[inline]
u_memrchr32(s: *const u16, c: i32, count: i32) -> *mut u1613844 pub unsafe fn u_memrchr32(s: *const u16, c: i32, count: i32) -> *mut u16 {
13845     #[cfg(windows)]
13846     {
13847         #[link(name = "windows")]
13848         extern "system" {
13849             fn u_memrchr32(s: *const u16, c: i32, count: i32) -> *mut u16;
13850         }
13851         ::std::mem::transmute(u_memrchr32(::std::mem::transmute(s), ::std::mem::transmute(c), ::std::mem::transmute(count)))
13852     }
13853     #[cfg(not(windows))]
13854     unimplemented!("Unsupported target OS");
13855 }
13856 #[inline]
u_memset(dest: *mut u16, c: u16, count: i32) -> *mut u1613857 pub unsafe fn u_memset(dest: *mut u16, c: u16, count: i32) -> *mut u16 {
13858     #[cfg(windows)]
13859     {
13860         #[link(name = "windows")]
13861         extern "system" {
13862             fn u_memset(dest: *mut u16, c: u16, count: i32) -> *mut u16;
13863         }
13864         ::std::mem::transmute(u_memset(::std::mem::transmute(dest), ::std::mem::transmute(c), ::std::mem::transmute(count)))
13865     }
13866     #[cfg(not(windows))]
13867     unimplemented!("Unsupported target OS");
13868 }
13869 #[cfg(feature = "Win32_Foundation")]
13870 #[inline]
u_parseMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, status: *mut UErrorCode)13871 pub unsafe fn u_parseMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, status: *mut UErrorCode) {
13872     #[cfg(windows)]
13873     {
13874         #[link(name = "windows")]
13875         extern "system" {
13876             fn u_parseMessage(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, status: *mut UErrorCode);
13877         }
13878         ::std::mem::transmute(u_parseMessage(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(status)))
13879     }
13880     #[cfg(not(windows))]
13881     unimplemented!("Unsupported target OS");
13882 }
13883 #[cfg(feature = "Win32_Foundation")]
13884 #[inline]
u_parseMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, parseerror: *mut UParseError, status: *mut UErrorCode)13885 pub unsafe fn u_parseMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) {
13886     #[cfg(windows)]
13887     {
13888         #[link(name = "windows")]
13889         extern "system" {
13890             fn u_parseMessageWithError(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, parseerror: *mut UParseError, status: *mut UErrorCode);
13891         }
13892         ::std::mem::transmute(u_parseMessageWithError(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
13893     }
13894     #[cfg(not(windows))]
13895     unimplemented!("Unsupported target OS");
13896 }
13897 #[inline]
u_setMemoryFunctions(context: *const ::std::ffi::c_void, a: *mut ::std::option::Option<UMemAllocFn>, r: *mut ::std::option::Option<UMemReallocFn>, f: *mut ::std::option::Option<UMemFreeFn>, status: *mut UErrorCode)13898 pub unsafe fn u_setMemoryFunctions(context: *const ::std::ffi::c_void, a: *mut ::std::option::Option<UMemAllocFn>, r: *mut ::std::option::Option<UMemReallocFn>, f: *mut ::std::option::Option<UMemFreeFn>, status: *mut UErrorCode) {
13899     #[cfg(windows)]
13900     {
13901         #[link(name = "windows")]
13902         extern "system" {
13903             fn u_setMemoryFunctions(context: *const ::std::ffi::c_void, a: *mut ::windows::runtime::RawPtr, r: *mut ::windows::runtime::RawPtr, f: *mut ::windows::runtime::RawPtr, status: *mut UErrorCode);
13904         }
13905         ::std::mem::transmute(u_setMemoryFunctions(::std::mem::transmute(context), ::std::mem::transmute(a), ::std::mem::transmute(r), ::std::mem::transmute(f), ::std::mem::transmute(status)))
13906     }
13907     #[cfg(not(windows))]
13908     unimplemented!("Unsupported target OS");
13909 }
13910 #[inline]
u_shapeArabic(source: *const u16, sourcelength: i32, dest: *mut u16, destsize: i32, options: u32, perrorcode: *mut UErrorCode) -> i3213911 pub unsafe fn u_shapeArabic(source: *const u16, sourcelength: i32, dest: *mut u16, destsize: i32, options: u32, perrorcode: *mut UErrorCode) -> i32 {
13912     #[cfg(windows)]
13913     {
13914         #[link(name = "windows")]
13915         extern "system" {
13916             fn u_shapeArabic(source: *const u16, sourcelength: i32, dest: *mut u16, destsize: i32, options: u32, perrorcode: *mut UErrorCode) -> i32;
13917         }
13918         ::std::mem::transmute(u_shapeArabic(::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(dest), ::std::mem::transmute(destsize), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
13919     }
13920     #[cfg(not(windows))]
13921     unimplemented!("Unsupported target OS");
13922 }
13923 #[inline]
u_strCaseCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i3213924 pub unsafe fn u_strCaseCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i32 {
13925     #[cfg(windows)]
13926     {
13927         #[link(name = "windows")]
13928         extern "system" {
13929             fn u_strCaseCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i32;
13930         }
13931         ::std::mem::transmute(u_strCaseCompare(::std::mem::transmute(s1), ::std::mem::transmute(length1), ::std::mem::transmute(s2), ::std::mem::transmute(length2), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
13932     }
13933     #[cfg(not(windows))]
13934     unimplemented!("Unsupported target OS");
13935 }
13936 #[inline]
u_strCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, codepointorder: i8) -> i3213937 pub unsafe fn u_strCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, codepointorder: i8) -> i32 {
13938     #[cfg(windows)]
13939     {
13940         #[link(name = "windows")]
13941         extern "system" {
13942             fn u_strCompare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, codepointorder: i8) -> i32;
13943         }
13944         ::std::mem::transmute(u_strCompare(::std::mem::transmute(s1), ::std::mem::transmute(length1), ::std::mem::transmute(s2), ::std::mem::transmute(length2), ::std::mem::transmute(codepointorder)))
13945     }
13946     #[cfg(not(windows))]
13947     unimplemented!("Unsupported target OS");
13948 }
13949 #[inline]
u_strCompareIter(iter1: *mut UCharIterator, iter2: *mut UCharIterator, codepointorder: i8) -> i3213950 pub unsafe fn u_strCompareIter(iter1: *mut UCharIterator, iter2: *mut UCharIterator, codepointorder: i8) -> i32 {
13951     #[cfg(windows)]
13952     {
13953         #[link(name = "windows")]
13954         extern "system" {
13955             fn u_strCompareIter(iter1: *mut ::std::mem::ManuallyDrop<UCharIterator>, iter2: *mut ::std::mem::ManuallyDrop<UCharIterator>, codepointorder: i8) -> i32;
13956         }
13957         ::std::mem::transmute(u_strCompareIter(::std::mem::transmute(iter1), ::std::mem::transmute(iter2), ::std::mem::transmute(codepointorder)))
13958     }
13959     #[cfg(not(windows))]
13960     unimplemented!("Unsupported target OS");
13961 }
13962 #[inline]
u_strFindFirst(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u1613963 pub unsafe fn u_strFindFirst(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u16 {
13964     #[cfg(windows)]
13965     {
13966         #[link(name = "windows")]
13967         extern "system" {
13968             fn u_strFindFirst(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u16;
13969         }
13970         ::std::mem::transmute(u_strFindFirst(::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(substring), ::std::mem::transmute(sublength)))
13971     }
13972     #[cfg(not(windows))]
13973     unimplemented!("Unsupported target OS");
13974 }
13975 #[inline]
u_strFindLast(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u1613976 pub unsafe fn u_strFindLast(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u16 {
13977     #[cfg(windows)]
13978     {
13979         #[link(name = "windows")]
13980         extern "system" {
13981             fn u_strFindLast(s: *const u16, length: i32, substring: *const u16, sublength: i32) -> *mut u16;
13982         }
13983         ::std::mem::transmute(u_strFindLast(::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(substring), ::std::mem::transmute(sublength)))
13984     }
13985     #[cfg(not(windows))]
13986     unimplemented!("Unsupported target OS");
13987 }
13988 #[inline]
u_strFoldCase(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, options: u32, perrorcode: *mut UErrorCode) -> i3213989 pub unsafe fn u_strFoldCase(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, options: u32, perrorcode: *mut UErrorCode) -> i32 {
13990     #[cfg(windows)]
13991     {
13992         #[link(name = "windows")]
13993         extern "system" {
13994             fn u_strFoldCase(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, options: u32, perrorcode: *mut UErrorCode) -> i32;
13995         }
13996         ::std::mem::transmute(u_strFoldCase(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
13997     }
13998     #[cfg(not(windows))]
13999     unimplemented!("Unsupported target OS");
14000 }
14001 #[cfg(feature = "Win32_Foundation")]
14002 #[inline]
u_strFromJavaModifiedUTF8WithSub<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u1614003 pub unsafe fn u_strFromJavaModifiedUTF8WithSub<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14004     #[cfg(windows)]
14005     {
14006         #[link(name = "windows")]
14007         extern "system" {
14008             fn u_strFromJavaModifiedUTF8WithSub(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: super::Foundation::PSTR, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16;
14009         }
14010         ::std::mem::transmute(u_strFromJavaModifiedUTF8WithSub(
14011             ::std::mem::transmute(dest),
14012             ::std::mem::transmute(destcapacity),
14013             ::std::mem::transmute(pdestlength),
14014             src.into_param().abi(),
14015             ::std::mem::transmute(srclength),
14016             ::std::mem::transmute(subchar),
14017             ::std::mem::transmute(pnumsubstitutions),
14018             ::std::mem::transmute(perrorcode),
14019         ))
14020     }
14021     #[cfg(not(windows))]
14022     unimplemented!("Unsupported target OS");
14023 }
14024 #[inline]
u_strFromUTF32(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u1614025 pub unsafe fn u_strFromUTF32(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14026     #[cfg(windows)]
14027     {
14028         #[link(name = "windows")]
14029         extern "system" {
14030             fn u_strFromUTF32(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16;
14031         }
14032         ::std::mem::transmute(u_strFromUTF32(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14033     }
14034     #[cfg(not(windows))]
14035     unimplemented!("Unsupported target OS");
14036 }
14037 #[inline]
u_strFromUTF32WithSub(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u1614038 pub unsafe fn u_strFromUTF32WithSub(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14039     #[cfg(windows)]
14040     {
14041         #[link(name = "windows")]
14042         extern "system" {
14043             fn u_strFromUTF32WithSub(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: *const i32, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16;
14044         }
14045         ::std::mem::transmute(u_strFromUTF32WithSub(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(subchar), ::std::mem::transmute(pnumsubstitutions), ::std::mem::transmute(perrorcode)))
14046     }
14047     #[cfg(not(windows))]
14048     unimplemented!("Unsupported target OS");
14049 }
14050 #[cfg(feature = "Win32_Foundation")]
14051 #[inline]
u_strFromUTF8<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u1614052 pub unsafe fn u_strFromUTF8<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14053     #[cfg(windows)]
14054     {
14055         #[link(name = "windows")]
14056         extern "system" {
14057             fn u_strFromUTF8(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16;
14058         }
14059         ::std::mem::transmute(u_strFromUTF8(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14060     }
14061     #[cfg(not(windows))]
14062     unimplemented!("Unsupported target OS");
14063 }
14064 #[cfg(feature = "Win32_Foundation")]
14065 #[inline]
u_strFromUTF8Lenient<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u1614066 pub unsafe fn u_strFromUTF8Lenient<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14067     #[cfg(windows)]
14068     {
14069         #[link(name = "windows")]
14070         extern "system" {
14071             fn u_strFromUTF8Lenient(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16;
14072         }
14073         ::std::mem::transmute(u_strFromUTF8Lenient(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14074     }
14075     #[cfg(not(windows))]
14076     unimplemented!("Unsupported target OS");
14077 }
14078 #[cfg(feature = "Win32_Foundation")]
14079 #[inline]
u_strFromUTF8WithSub<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u1614080 pub unsafe fn u_strFromUTF8WithSub<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14081     #[cfg(windows)]
14082     {
14083         #[link(name = "windows")]
14084         extern "system" {
14085             fn u_strFromUTF8WithSub(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: super::Foundation::PSTR, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut u16;
14086         }
14087         ::std::mem::transmute(u_strFromUTF8WithSub(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(subchar), ::std::mem::transmute(pnumsubstitutions), ::std::mem::transmute(perrorcode)))
14088     }
14089     #[cfg(not(windows))]
14090     unimplemented!("Unsupported target OS");
14091 }
14092 #[cfg(feature = "Win32_Foundation")]
14093 #[inline]
u_strFromWCS<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u1614094 pub unsafe fn u_strFromWCS<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16 {
14095     #[cfg(windows)]
14096     {
14097         #[link(name = "windows")]
14098         extern "system" {
14099             fn u_strFromWCS(dest: *mut u16, destcapacity: i32, pdestlength: *mut i32, src: super::Foundation::PWSTR, srclength: i32, perrorcode: *mut UErrorCode) -> *mut u16;
14100         }
14101         ::std::mem::transmute(u_strFromWCS(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14102     }
14103     #[cfg(not(windows))]
14104     unimplemented!("Unsupported target OS");
14105 }
14106 #[inline]
u_strHasMoreChar32Than(s: *const u16, length: i32, number: i32) -> i814107 pub unsafe fn u_strHasMoreChar32Than(s: *const u16, length: i32, number: i32) -> i8 {
14108     #[cfg(windows)]
14109     {
14110         #[link(name = "windows")]
14111         extern "system" {
14112             fn u_strHasMoreChar32Than(s: *const u16, length: i32, number: i32) -> i8;
14113         }
14114         ::std::mem::transmute(u_strHasMoreChar32Than(::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(number)))
14115     }
14116     #[cfg(not(windows))]
14117     unimplemented!("Unsupported target OS");
14118 }
14119 #[cfg(feature = "Win32_Foundation")]
14120 #[inline]
u_strToJavaModifiedUTF8<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR14121 pub unsafe fn u_strToJavaModifiedUTF8<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
14122     #[cfg(windows)]
14123     {
14124         #[link(name = "windows")]
14125         extern "system" {
14126             fn u_strToJavaModifiedUTF8(dest: super::Foundation::PSTR, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
14127         }
14128         ::std::mem::transmute(u_strToJavaModifiedUTF8(dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14129     }
14130     #[cfg(not(windows))]
14131     unimplemented!("Unsupported target OS");
14132 }
14133 #[cfg(feature = "Win32_Foundation")]
14134 #[inline]
u_strToLower<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: Param4, perrorcode: *mut UErrorCode) -> i3214135 pub unsafe fn u_strToLower<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: Param4, perrorcode: *mut UErrorCode) -> i32 {
14136     #[cfg(windows)]
14137     {
14138         #[link(name = "windows")]
14139         extern "system" {
14140             fn u_strToLower(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> i32;
14141         }
14142         ::std::mem::transmute(u_strToLower(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), locale.into_param().abi(), ::std::mem::transmute(perrorcode)))
14143     }
14144     #[cfg(not(windows))]
14145     unimplemented!("Unsupported target OS");
14146 }
14147 #[cfg(feature = "Win32_Foundation")]
14148 #[inline]
u_strToTitle<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, titleiter: *mut UBreakIterator, locale: Param5, perrorcode: *mut UErrorCode) -> i3214149 pub unsafe fn u_strToTitle<'a, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, titleiter: *mut UBreakIterator, locale: Param5, perrorcode: *mut UErrorCode) -> i32 {
14150     #[cfg(windows)]
14151     {
14152         #[link(name = "windows")]
14153         extern "system" {
14154             fn u_strToTitle(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, titleiter: *mut UBreakIterator, locale: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> i32;
14155         }
14156         ::std::mem::transmute(u_strToTitle(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(titleiter), locale.into_param().abi(), ::std::mem::transmute(perrorcode)))
14157     }
14158     #[cfg(not(windows))]
14159     unimplemented!("Unsupported target OS");
14160 }
14161 #[inline]
u_strToUTF32(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> *mut i3214162 pub unsafe fn u_strToUTF32(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> *mut i32 {
14163     #[cfg(windows)]
14164     {
14165         #[link(name = "windows")]
14166         extern "system" {
14167             fn u_strToUTF32(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> *mut i32;
14168         }
14169         ::std::mem::transmute(u_strToUTF32(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14170     }
14171     #[cfg(not(windows))]
14172     unimplemented!("Unsupported target OS");
14173 }
14174 #[inline]
u_strToUTF32WithSub(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut i3214175 pub unsafe fn u_strToUTF32WithSub(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut i32 {
14176     #[cfg(windows)]
14177     {
14178         #[link(name = "windows")]
14179         extern "system" {
14180             fn u_strToUTF32WithSub(dest: *mut i32, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> *mut i32;
14181         }
14182         ::std::mem::transmute(u_strToUTF32WithSub(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(subchar), ::std::mem::transmute(pnumsubstitutions), ::std::mem::transmute(perrorcode)))
14183     }
14184     #[cfg(not(windows))]
14185     unimplemented!("Unsupported target OS");
14186 }
14187 #[cfg(feature = "Win32_Foundation")]
14188 #[inline]
u_strToUTF8<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR14189 pub unsafe fn u_strToUTF8<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
14190     #[cfg(windows)]
14191     {
14192         #[link(name = "windows")]
14193         extern "system" {
14194             fn u_strToUTF8(dest: super::Foundation::PSTR, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
14195         }
14196         ::std::mem::transmute(u_strToUTF8(dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14197     }
14198     #[cfg(not(windows))]
14199     unimplemented!("Unsupported target OS");
14200 }
14201 #[cfg(feature = "Win32_Foundation")]
14202 #[inline]
u_strToUTF8WithSub<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR14203 pub unsafe fn u_strToUTF8WithSub<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
14204     #[cfg(windows)]
14205     {
14206         #[link(name = "windows")]
14207         extern "system" {
14208             fn u_strToUTF8WithSub(dest: super::Foundation::PSTR, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, subchar: i32, pnumsubstitutions: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
14209         }
14210         ::std::mem::transmute(u_strToUTF8WithSub(dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(subchar), ::std::mem::transmute(pnumsubstitutions), ::std::mem::transmute(perrorcode)))
14211     }
14212     #[cfg(not(windows))]
14213     unimplemented!("Unsupported target OS");
14214 }
14215 #[cfg(feature = "Win32_Foundation")]
14216 #[inline]
u_strToUpper<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: Param4, perrorcode: *mut UErrorCode) -> i3214217 pub unsafe fn u_strToUpper<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: Param4, perrorcode: *mut UErrorCode) -> i32 {
14218     #[cfg(windows)]
14219     {
14220         #[link(name = "windows")]
14221         extern "system" {
14222             fn u_strToUpper(dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, locale: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> i32;
14223         }
14224         ::std::mem::transmute(u_strToUpper(::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), locale.into_param().abi(), ::std::mem::transmute(perrorcode)))
14225     }
14226     #[cfg(not(windows))]
14227     unimplemented!("Unsupported target OS");
14228 }
14229 #[cfg(feature = "Win32_Foundation")]
14230 #[inline]
u_strToWCS<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PWSTR14231 pub unsafe fn u_strToWCS<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PWSTR>>(dest: Param0, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PWSTR {
14232     #[cfg(windows)]
14233     {
14234         #[link(name = "windows")]
14235         extern "system" {
14236             fn u_strToWCS(dest: super::Foundation::PWSTR, destcapacity: i32, pdestlength: *mut i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> super::Foundation::PWSTR;
14237         }
14238         ::std::mem::transmute(u_strToWCS(dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(pdestlength), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
14239     }
14240     #[cfg(not(windows))]
14241     unimplemented!("Unsupported target OS");
14242 }
14243 #[inline]
u_strcasecmp(s1: *const u16, s2: *const u16, options: u32) -> i3214244 pub unsafe fn u_strcasecmp(s1: *const u16, s2: *const u16, options: u32) -> i32 {
14245     #[cfg(windows)]
14246     {
14247         #[link(name = "windows")]
14248         extern "system" {
14249             fn u_strcasecmp(s1: *const u16, s2: *const u16, options: u32) -> i32;
14250         }
14251         ::std::mem::transmute(u_strcasecmp(::std::mem::transmute(s1), ::std::mem::transmute(s2), ::std::mem::transmute(options)))
14252     }
14253     #[cfg(not(windows))]
14254     unimplemented!("Unsupported target OS");
14255 }
14256 #[inline]
u_strcat(dst: *mut u16, src: *const u16) -> *mut u1614257 pub unsafe fn u_strcat(dst: *mut u16, src: *const u16) -> *mut u16 {
14258     #[cfg(windows)]
14259     {
14260         #[link(name = "windows")]
14261         extern "system" {
14262             fn u_strcat(dst: *mut u16, src: *const u16) -> *mut u16;
14263         }
14264         ::std::mem::transmute(u_strcat(::std::mem::transmute(dst), ::std::mem::transmute(src)))
14265     }
14266     #[cfg(not(windows))]
14267     unimplemented!("Unsupported target OS");
14268 }
14269 #[inline]
u_strchr(s: *const u16, c: u16) -> *mut u1614270 pub unsafe fn u_strchr(s: *const u16, c: u16) -> *mut u16 {
14271     #[cfg(windows)]
14272     {
14273         #[link(name = "windows")]
14274         extern "system" {
14275             fn u_strchr(s: *const u16, c: u16) -> *mut u16;
14276         }
14277         ::std::mem::transmute(u_strchr(::std::mem::transmute(s), ::std::mem::transmute(c)))
14278     }
14279     #[cfg(not(windows))]
14280     unimplemented!("Unsupported target OS");
14281 }
14282 #[inline]
u_strchr32(s: *const u16, c: i32) -> *mut u1614283 pub unsafe fn u_strchr32(s: *const u16, c: i32) -> *mut u16 {
14284     #[cfg(windows)]
14285     {
14286         #[link(name = "windows")]
14287         extern "system" {
14288             fn u_strchr32(s: *const u16, c: i32) -> *mut u16;
14289         }
14290         ::std::mem::transmute(u_strchr32(::std::mem::transmute(s), ::std::mem::transmute(c)))
14291     }
14292     #[cfg(not(windows))]
14293     unimplemented!("Unsupported target OS");
14294 }
14295 #[inline]
u_strcmp(s1: *const u16, s2: *const u16) -> i3214296 pub unsafe fn u_strcmp(s1: *const u16, s2: *const u16) -> i32 {
14297     #[cfg(windows)]
14298     {
14299         #[link(name = "windows")]
14300         extern "system" {
14301             fn u_strcmp(s1: *const u16, s2: *const u16) -> i32;
14302         }
14303         ::std::mem::transmute(u_strcmp(::std::mem::transmute(s1), ::std::mem::transmute(s2)))
14304     }
14305     #[cfg(not(windows))]
14306     unimplemented!("Unsupported target OS");
14307 }
14308 #[inline]
u_strcmpCodePointOrder(s1: *const u16, s2: *const u16) -> i3214309 pub unsafe fn u_strcmpCodePointOrder(s1: *const u16, s2: *const u16) -> i32 {
14310     #[cfg(windows)]
14311     {
14312         #[link(name = "windows")]
14313         extern "system" {
14314             fn u_strcmpCodePointOrder(s1: *const u16, s2: *const u16) -> i32;
14315         }
14316         ::std::mem::transmute(u_strcmpCodePointOrder(::std::mem::transmute(s1), ::std::mem::transmute(s2)))
14317     }
14318     #[cfg(not(windows))]
14319     unimplemented!("Unsupported target OS");
14320 }
14321 #[inline]
u_strcpy(dst: *mut u16, src: *const u16) -> *mut u1614322 pub unsafe fn u_strcpy(dst: *mut u16, src: *const u16) -> *mut u16 {
14323     #[cfg(windows)]
14324     {
14325         #[link(name = "windows")]
14326         extern "system" {
14327             fn u_strcpy(dst: *mut u16, src: *const u16) -> *mut u16;
14328         }
14329         ::std::mem::transmute(u_strcpy(::std::mem::transmute(dst), ::std::mem::transmute(src)))
14330     }
14331     #[cfg(not(windows))]
14332     unimplemented!("Unsupported target OS");
14333 }
14334 #[inline]
u_strcspn(string: *const u16, matchset: *const u16) -> i3214335 pub unsafe fn u_strcspn(string: *const u16, matchset: *const u16) -> i32 {
14336     #[cfg(windows)]
14337     {
14338         #[link(name = "windows")]
14339         extern "system" {
14340             fn u_strcspn(string: *const u16, matchset: *const u16) -> i32;
14341         }
14342         ::std::mem::transmute(u_strcspn(::std::mem::transmute(string), ::std::mem::transmute(matchset)))
14343     }
14344     #[cfg(not(windows))]
14345     unimplemented!("Unsupported target OS");
14346 }
14347 #[inline]
u_strlen(s: *const u16) -> i3214348 pub unsafe fn u_strlen(s: *const u16) -> i32 {
14349     #[cfg(windows)]
14350     {
14351         #[link(name = "windows")]
14352         extern "system" {
14353             fn u_strlen(s: *const u16) -> i32;
14354         }
14355         ::std::mem::transmute(u_strlen(::std::mem::transmute(s)))
14356     }
14357     #[cfg(not(windows))]
14358     unimplemented!("Unsupported target OS");
14359 }
14360 #[inline]
u_strncasecmp(s1: *const u16, s2: *const u16, n: i32, options: u32) -> i3214361 pub unsafe fn u_strncasecmp(s1: *const u16, s2: *const u16, n: i32, options: u32) -> i32 {
14362     #[cfg(windows)]
14363     {
14364         #[link(name = "windows")]
14365         extern "system" {
14366             fn u_strncasecmp(s1: *const u16, s2: *const u16, n: i32, options: u32) -> i32;
14367         }
14368         ::std::mem::transmute(u_strncasecmp(::std::mem::transmute(s1), ::std::mem::transmute(s2), ::std::mem::transmute(n), ::std::mem::transmute(options)))
14369     }
14370     #[cfg(not(windows))]
14371     unimplemented!("Unsupported target OS");
14372 }
14373 #[inline]
u_strncat(dst: *mut u16, src: *const u16, n: i32) -> *mut u1614374 pub unsafe fn u_strncat(dst: *mut u16, src: *const u16, n: i32) -> *mut u16 {
14375     #[cfg(windows)]
14376     {
14377         #[link(name = "windows")]
14378         extern "system" {
14379             fn u_strncat(dst: *mut u16, src: *const u16, n: i32) -> *mut u16;
14380         }
14381         ::std::mem::transmute(u_strncat(::std::mem::transmute(dst), ::std::mem::transmute(src), ::std::mem::transmute(n)))
14382     }
14383     #[cfg(not(windows))]
14384     unimplemented!("Unsupported target OS");
14385 }
14386 #[inline]
u_strncmp(ucs1: *const u16, ucs2: *const u16, n: i32) -> i3214387 pub unsafe fn u_strncmp(ucs1: *const u16, ucs2: *const u16, n: i32) -> i32 {
14388     #[cfg(windows)]
14389     {
14390         #[link(name = "windows")]
14391         extern "system" {
14392             fn u_strncmp(ucs1: *const u16, ucs2: *const u16, n: i32) -> i32;
14393         }
14394         ::std::mem::transmute(u_strncmp(::std::mem::transmute(ucs1), ::std::mem::transmute(ucs2), ::std::mem::transmute(n)))
14395     }
14396     #[cfg(not(windows))]
14397     unimplemented!("Unsupported target OS");
14398 }
14399 #[inline]
u_strncmpCodePointOrder(s1: *const u16, s2: *const u16, n: i32) -> i3214400 pub unsafe fn u_strncmpCodePointOrder(s1: *const u16, s2: *const u16, n: i32) -> i32 {
14401     #[cfg(windows)]
14402     {
14403         #[link(name = "windows")]
14404         extern "system" {
14405             fn u_strncmpCodePointOrder(s1: *const u16, s2: *const u16, n: i32) -> i32;
14406         }
14407         ::std::mem::transmute(u_strncmpCodePointOrder(::std::mem::transmute(s1), ::std::mem::transmute(s2), ::std::mem::transmute(n)))
14408     }
14409     #[cfg(not(windows))]
14410     unimplemented!("Unsupported target OS");
14411 }
14412 #[inline]
u_strncpy(dst: *mut u16, src: *const u16, n: i32) -> *mut u1614413 pub unsafe fn u_strncpy(dst: *mut u16, src: *const u16, n: i32) -> *mut u16 {
14414     #[cfg(windows)]
14415     {
14416         #[link(name = "windows")]
14417         extern "system" {
14418             fn u_strncpy(dst: *mut u16, src: *const u16, n: i32) -> *mut u16;
14419         }
14420         ::std::mem::transmute(u_strncpy(::std::mem::transmute(dst), ::std::mem::transmute(src), ::std::mem::transmute(n)))
14421     }
14422     #[cfg(not(windows))]
14423     unimplemented!("Unsupported target OS");
14424 }
14425 #[inline]
u_strpbrk(string: *const u16, matchset: *const u16) -> *mut u1614426 pub unsafe fn u_strpbrk(string: *const u16, matchset: *const u16) -> *mut u16 {
14427     #[cfg(windows)]
14428     {
14429         #[link(name = "windows")]
14430         extern "system" {
14431             fn u_strpbrk(string: *const u16, matchset: *const u16) -> *mut u16;
14432         }
14433         ::std::mem::transmute(u_strpbrk(::std::mem::transmute(string), ::std::mem::transmute(matchset)))
14434     }
14435     #[cfg(not(windows))]
14436     unimplemented!("Unsupported target OS");
14437 }
14438 #[inline]
u_strrchr(s: *const u16, c: u16) -> *mut u1614439 pub unsafe fn u_strrchr(s: *const u16, c: u16) -> *mut u16 {
14440     #[cfg(windows)]
14441     {
14442         #[link(name = "windows")]
14443         extern "system" {
14444             fn u_strrchr(s: *const u16, c: u16) -> *mut u16;
14445         }
14446         ::std::mem::transmute(u_strrchr(::std::mem::transmute(s), ::std::mem::transmute(c)))
14447     }
14448     #[cfg(not(windows))]
14449     unimplemented!("Unsupported target OS");
14450 }
14451 #[inline]
u_strrchr32(s: *const u16, c: i32) -> *mut u1614452 pub unsafe fn u_strrchr32(s: *const u16, c: i32) -> *mut u16 {
14453     #[cfg(windows)]
14454     {
14455         #[link(name = "windows")]
14456         extern "system" {
14457             fn u_strrchr32(s: *const u16, c: i32) -> *mut u16;
14458         }
14459         ::std::mem::transmute(u_strrchr32(::std::mem::transmute(s), ::std::mem::transmute(c)))
14460     }
14461     #[cfg(not(windows))]
14462     unimplemented!("Unsupported target OS");
14463 }
14464 #[inline]
u_strrstr(s: *const u16, substring: *const u16) -> *mut u1614465 pub unsafe fn u_strrstr(s: *const u16, substring: *const u16) -> *mut u16 {
14466     #[cfg(windows)]
14467     {
14468         #[link(name = "windows")]
14469         extern "system" {
14470             fn u_strrstr(s: *const u16, substring: *const u16) -> *mut u16;
14471         }
14472         ::std::mem::transmute(u_strrstr(::std::mem::transmute(s), ::std::mem::transmute(substring)))
14473     }
14474     #[cfg(not(windows))]
14475     unimplemented!("Unsupported target OS");
14476 }
14477 #[inline]
u_strspn(string: *const u16, matchset: *const u16) -> i3214478 pub unsafe fn u_strspn(string: *const u16, matchset: *const u16) -> i32 {
14479     #[cfg(windows)]
14480     {
14481         #[link(name = "windows")]
14482         extern "system" {
14483             fn u_strspn(string: *const u16, matchset: *const u16) -> i32;
14484         }
14485         ::std::mem::transmute(u_strspn(::std::mem::transmute(string), ::std::mem::transmute(matchset)))
14486     }
14487     #[cfg(not(windows))]
14488     unimplemented!("Unsupported target OS");
14489 }
14490 #[inline]
u_strstr(s: *const u16, substring: *const u16) -> *mut u1614491 pub unsafe fn u_strstr(s: *const u16, substring: *const u16) -> *mut u16 {
14492     #[cfg(windows)]
14493     {
14494         #[link(name = "windows")]
14495         extern "system" {
14496             fn u_strstr(s: *const u16, substring: *const u16) -> *mut u16;
14497         }
14498         ::std::mem::transmute(u_strstr(::std::mem::transmute(s), ::std::mem::transmute(substring)))
14499     }
14500     #[cfg(not(windows))]
14501     unimplemented!("Unsupported target OS");
14502 }
14503 #[inline]
u_strtok_r(src: *mut u16, delim: *const u16, savestate: *mut *mut u16) -> *mut u1614504 pub unsafe fn u_strtok_r(src: *mut u16, delim: *const u16, savestate: *mut *mut u16) -> *mut u16 {
14505     #[cfg(windows)]
14506     {
14507         #[link(name = "windows")]
14508         extern "system" {
14509             fn u_strtok_r(src: *mut u16, delim: *const u16, savestate: *mut *mut u16) -> *mut u16;
14510         }
14511         ::std::mem::transmute(u_strtok_r(::std::mem::transmute(src), ::std::mem::transmute(delim), ::std::mem::transmute(savestate)))
14512     }
14513     #[cfg(not(windows))]
14514     unimplemented!("Unsupported target OS");
14515 }
14516 #[inline]
u_tolower(c: i32) -> i3214517 pub unsafe fn u_tolower(c: i32) -> i32 {
14518     #[cfg(windows)]
14519     {
14520         #[link(name = "windows")]
14521         extern "system" {
14522             fn u_tolower(c: i32) -> i32;
14523         }
14524         ::std::mem::transmute(u_tolower(::std::mem::transmute(c)))
14525     }
14526     #[cfg(not(windows))]
14527     unimplemented!("Unsupported target OS");
14528 }
14529 #[inline]
u_totitle(c: i32) -> i3214530 pub unsafe fn u_totitle(c: i32) -> i32 {
14531     #[cfg(windows)]
14532     {
14533         #[link(name = "windows")]
14534         extern "system" {
14535             fn u_totitle(c: i32) -> i32;
14536         }
14537         ::std::mem::transmute(u_totitle(::std::mem::transmute(c)))
14538     }
14539     #[cfg(not(windows))]
14540     unimplemented!("Unsupported target OS");
14541 }
14542 #[inline]
u_toupper(c: i32) -> i3214543 pub unsafe fn u_toupper(c: i32) -> i32 {
14544     #[cfg(windows)]
14545     {
14546         #[link(name = "windows")]
14547         extern "system" {
14548             fn u_toupper(c: i32) -> i32;
14549         }
14550         ::std::mem::transmute(u_toupper(::std::mem::transmute(c)))
14551     }
14552     #[cfg(not(windows))]
14553     unimplemented!("Unsupported target OS");
14554 }
14555 #[cfg(feature = "Win32_Foundation")]
14556 #[inline]
u_uastrcpy<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: *mut u16, src: Param1) -> *mut u1614557 pub unsafe fn u_uastrcpy<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: *mut u16, src: Param1) -> *mut u16 {
14558     #[cfg(windows)]
14559     {
14560         #[link(name = "windows")]
14561         extern "system" {
14562             fn u_uastrcpy(dst: *mut u16, src: super::Foundation::PSTR) -> *mut u16;
14563         }
14564         ::std::mem::transmute(u_uastrcpy(::std::mem::transmute(dst), src.into_param().abi()))
14565     }
14566     #[cfg(not(windows))]
14567     unimplemented!("Unsupported target OS");
14568 }
14569 #[cfg(feature = "Win32_Foundation")]
14570 #[inline]
u_uastrncpy<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: *mut u16, src: Param1, n: i32) -> *mut u1614571 pub unsafe fn u_uastrncpy<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(dst: *mut u16, src: Param1, n: i32) -> *mut u16 {
14572     #[cfg(windows)]
14573     {
14574         #[link(name = "windows")]
14575         extern "system" {
14576             fn u_uastrncpy(dst: *mut u16, src: super::Foundation::PSTR, n: i32) -> *mut u16;
14577         }
14578         ::std::mem::transmute(u_uastrncpy(::std::mem::transmute(dst), src.into_param().abi(), ::std::mem::transmute(n)))
14579     }
14580     #[cfg(not(windows))]
14581     unimplemented!("Unsupported target OS");
14582 }
14583 #[cfg(feature = "Win32_Foundation")]
14584 #[inline]
u_unescape<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(src: Param0, dest: *mut u16, destcapacity: i32) -> i3214585 pub unsafe fn u_unescape<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(src: Param0, dest: *mut u16, destcapacity: i32) -> i32 {
14586     #[cfg(windows)]
14587     {
14588         #[link(name = "windows")]
14589         extern "system" {
14590             fn u_unescape(src: super::Foundation::PSTR, dest: *mut u16, destcapacity: i32) -> i32;
14591         }
14592         ::std::mem::transmute(u_unescape(src.into_param().abi(), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity)))
14593     }
14594     #[cfg(not(windows))]
14595     unimplemented!("Unsupported target OS");
14596 }
14597 #[inline]
u_unescapeAt(charat: ::std::option::Option<UNESCAPE_CHAR_AT>, offset: *mut i32, length: i32, context: *mut ::std::ffi::c_void) -> i3214598 pub unsafe fn u_unescapeAt(charat: ::std::option::Option<UNESCAPE_CHAR_AT>, offset: *mut i32, length: i32, context: *mut ::std::ffi::c_void) -> i32 {
14599     #[cfg(windows)]
14600     {
14601         #[link(name = "windows")]
14602         extern "system" {
14603             fn u_unescapeAt(charat: ::windows::runtime::RawPtr, offset: *mut i32, length: i32, context: *mut ::std::ffi::c_void) -> i32;
14604         }
14605         ::std::mem::transmute(u_unescapeAt(::std::mem::transmute(charat), ::std::mem::transmute(offset), ::std::mem::transmute(length), ::std::mem::transmute(context)))
14606     }
14607     #[cfg(not(windows))]
14608     unimplemented!("Unsupported target OS");
14609 }
14610 #[cfg(feature = "Win32_Foundation")]
14611 #[inline]
u_versionFromString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(versionarray: *mut u8, versionstring: Param1)14612 pub unsafe fn u_versionFromString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(versionarray: *mut u8, versionstring: Param1) {
14613     #[cfg(windows)]
14614     {
14615         #[link(name = "windows")]
14616         extern "system" {
14617             fn u_versionFromString(versionarray: *mut u8, versionstring: super::Foundation::PSTR);
14618         }
14619         ::std::mem::transmute(u_versionFromString(::std::mem::transmute(versionarray), versionstring.into_param().abi()))
14620     }
14621     #[cfg(not(windows))]
14622     unimplemented!("Unsupported target OS");
14623 }
14624 #[inline]
u_versionFromUString(versionarray: *mut u8, versionstring: *const u16)14625 pub unsafe fn u_versionFromUString(versionarray: *mut u8, versionstring: *const u16) {
14626     #[cfg(windows)]
14627     {
14628         #[link(name = "windows")]
14629         extern "system" {
14630             fn u_versionFromUString(versionarray: *mut u8, versionstring: *const u16);
14631         }
14632         ::std::mem::transmute(u_versionFromUString(::std::mem::transmute(versionarray), ::std::mem::transmute(versionstring)))
14633     }
14634     #[cfg(not(windows))]
14635     unimplemented!("Unsupported target OS");
14636 }
14637 #[cfg(feature = "Win32_Foundation")]
14638 #[inline]
u_versionToString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(versionarray: *const u8, versionstring: Param1)14639 pub unsafe fn u_versionToString<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(versionarray: *const u8, versionstring: Param1) {
14640     #[cfg(windows)]
14641     {
14642         #[link(name = "windows")]
14643         extern "system" {
14644             fn u_versionToString(versionarray: *const u8, versionstring: super::Foundation::PSTR);
14645         }
14646         ::std::mem::transmute(u_versionToString(::std::mem::transmute(versionarray), versionstring.into_param().abi()))
14647     }
14648     #[cfg(not(windows))]
14649     unimplemented!("Unsupported target OS");
14650 }
14651 #[cfg(feature = "Win32_Foundation")]
14652 #[inline]
u_vformatMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i3214653 pub unsafe fn u_vformatMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i32 {
14654     #[cfg(windows)]
14655     {
14656         #[link(name = "windows")]
14657         extern "system" {
14658             fn u_vformatMessage(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i32;
14659         }
14660         ::std::mem::transmute(u_vformatMessage(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(ap), ::std::mem::transmute(status)))
14661     }
14662     #[cfg(not(windows))]
14663     unimplemented!("Unsupported target OS");
14664 }
14665 #[cfg(feature = "Win32_Foundation")]
14666 #[inline]
u_vformatMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, ap: *mut i8, status: *mut UErrorCode) -> i3214667 pub unsafe fn u_vformatMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, ap: *mut i8, status: *mut UErrorCode) -> i32 {
14668     #[cfg(windows)]
14669     {
14670         #[link(name = "windows")]
14671         extern "system" {
14672             fn u_vformatMessageWithError(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, result: *mut u16, resultlength: i32, parseerror: *mut UParseError, ap: *mut i8, status: *mut UErrorCode) -> i32;
14673         }
14674         ::std::mem::transmute(u_vformatMessageWithError(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(parseerror), ::std::mem::transmute(ap), ::std::mem::transmute(status)))
14675     }
14676     #[cfg(not(windows))]
14677     unimplemented!("Unsupported target OS");
14678 }
14679 #[cfg(feature = "Win32_Foundation")]
14680 #[inline]
u_vparseMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, status: *mut UErrorCode)14681 pub unsafe fn u_vparseMessage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, status: *mut UErrorCode) {
14682     #[cfg(windows)]
14683     {
14684         #[link(name = "windows")]
14685         extern "system" {
14686             fn u_vparseMessage(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, status: *mut UErrorCode);
14687         }
14688         ::std::mem::transmute(u_vparseMessage(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(ap), ::std::mem::transmute(status)))
14689     }
14690     #[cfg(not(windows))]
14691     unimplemented!("Unsupported target OS");
14692 }
14693 #[cfg(feature = "Win32_Foundation")]
14694 #[inline]
u_vparseMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, parseerror: *mut UParseError, status: *mut UErrorCode)14695 pub unsafe fn u_vparseMessageWithError<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, parseerror: *mut UParseError, status: *mut UErrorCode) {
14696     #[cfg(windows)]
14697     {
14698         #[link(name = "windows")]
14699         extern "system" {
14700             fn u_vparseMessageWithError(locale: super::Foundation::PSTR, pattern: *const u16, patternlength: i32, source: *const u16, sourcelength: i32, ap: *mut i8, parseerror: *mut UParseError, status: *mut UErrorCode);
14701         }
14702         ::std::mem::transmute(u_vparseMessageWithError(locale.into_param().abi(), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(ap), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
14703     }
14704     #[cfg(not(windows))]
14705     unimplemented!("Unsupported target OS");
14706 }
14707 #[inline]
ubidi_close(pbidi: *mut UBiDi)14708 pub unsafe fn ubidi_close(pbidi: *mut UBiDi) {
14709     #[cfg(windows)]
14710     {
14711         #[link(name = "windows")]
14712         extern "system" {
14713             fn ubidi_close(pbidi: *mut UBiDi);
14714         }
14715         ::std::mem::transmute(ubidi_close(::std::mem::transmute(pbidi)))
14716     }
14717     #[cfg(not(windows))]
14718     unimplemented!("Unsupported target OS");
14719 }
14720 #[inline]
ubidi_countParagraphs(pbidi: *mut UBiDi) -> i3214721 pub unsafe fn ubidi_countParagraphs(pbidi: *mut UBiDi) -> i32 {
14722     #[cfg(windows)]
14723     {
14724         #[link(name = "windows")]
14725         extern "system" {
14726             fn ubidi_countParagraphs(pbidi: *mut UBiDi) -> i32;
14727         }
14728         ::std::mem::transmute(ubidi_countParagraphs(::std::mem::transmute(pbidi)))
14729     }
14730     #[cfg(not(windows))]
14731     unimplemented!("Unsupported target OS");
14732 }
14733 #[inline]
ubidi_countRuns(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> i3214734 pub unsafe fn ubidi_countRuns(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> i32 {
14735     #[cfg(windows)]
14736     {
14737         #[link(name = "windows")]
14738         extern "system" {
14739             fn ubidi_countRuns(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> i32;
14740         }
14741         ::std::mem::transmute(ubidi_countRuns(::std::mem::transmute(pbidi), ::std::mem::transmute(perrorcode)))
14742     }
14743     #[cfg(not(windows))]
14744     unimplemented!("Unsupported target OS");
14745 }
14746 #[inline]
ubidi_getBaseDirection(text: *const u16, length: i32) -> UBiDiDirection14747 pub unsafe fn ubidi_getBaseDirection(text: *const u16, length: i32) -> UBiDiDirection {
14748     #[cfg(windows)]
14749     {
14750         #[link(name = "windows")]
14751         extern "system" {
14752             fn ubidi_getBaseDirection(text: *const u16, length: i32) -> UBiDiDirection;
14753         }
14754         ::std::mem::transmute(ubidi_getBaseDirection(::std::mem::transmute(text), ::std::mem::transmute(length)))
14755     }
14756     #[cfg(not(windows))]
14757     unimplemented!("Unsupported target OS");
14758 }
14759 #[inline]
ubidi_getClassCallback(pbidi: *mut UBiDi, r#fn: *mut ::std::option::Option<UBiDiClassCallback>, context: *const *const ::std::ffi::c_void)14760 pub unsafe fn ubidi_getClassCallback(pbidi: *mut UBiDi, r#fn: *mut ::std::option::Option<UBiDiClassCallback>, context: *const *const ::std::ffi::c_void) {
14761     #[cfg(windows)]
14762     {
14763         #[link(name = "windows")]
14764         extern "system" {
14765             fn ubidi_getClassCallback(pbidi: *mut UBiDi, r#fn: *mut ::windows::runtime::RawPtr, context: *const *const ::std::ffi::c_void);
14766         }
14767         ::std::mem::transmute(ubidi_getClassCallback(::std::mem::transmute(pbidi), ::std::mem::transmute(r#fn), ::std::mem::transmute(context)))
14768     }
14769     #[cfg(not(windows))]
14770     unimplemented!("Unsupported target OS");
14771 }
14772 #[inline]
ubidi_getCustomizedClass(pbidi: *mut UBiDi, c: i32) -> UCharDirection14773 pub unsafe fn ubidi_getCustomizedClass(pbidi: *mut UBiDi, c: i32) -> UCharDirection {
14774     #[cfg(windows)]
14775     {
14776         #[link(name = "windows")]
14777         extern "system" {
14778             fn ubidi_getCustomizedClass(pbidi: *mut UBiDi, c: i32) -> UCharDirection;
14779         }
14780         ::std::mem::transmute(ubidi_getCustomizedClass(::std::mem::transmute(pbidi), ::std::mem::transmute(c)))
14781     }
14782     #[cfg(not(windows))]
14783     unimplemented!("Unsupported target OS");
14784 }
14785 #[inline]
ubidi_getDirection(pbidi: *const UBiDi) -> UBiDiDirection14786 pub unsafe fn ubidi_getDirection(pbidi: *const UBiDi) -> UBiDiDirection {
14787     #[cfg(windows)]
14788     {
14789         #[link(name = "windows")]
14790         extern "system" {
14791             fn ubidi_getDirection(pbidi: *const UBiDi) -> UBiDiDirection;
14792         }
14793         ::std::mem::transmute(ubidi_getDirection(::std::mem::transmute(pbidi)))
14794     }
14795     #[cfg(not(windows))]
14796     unimplemented!("Unsupported target OS");
14797 }
14798 #[inline]
ubidi_getLength(pbidi: *const UBiDi) -> i3214799 pub unsafe fn ubidi_getLength(pbidi: *const UBiDi) -> i32 {
14800     #[cfg(windows)]
14801     {
14802         #[link(name = "windows")]
14803         extern "system" {
14804             fn ubidi_getLength(pbidi: *const UBiDi) -> i32;
14805         }
14806         ::std::mem::transmute(ubidi_getLength(::std::mem::transmute(pbidi)))
14807     }
14808     #[cfg(not(windows))]
14809     unimplemented!("Unsupported target OS");
14810 }
14811 #[inline]
ubidi_getLevelAt(pbidi: *const UBiDi, charindex: i32) -> u814812 pub unsafe fn ubidi_getLevelAt(pbidi: *const UBiDi, charindex: i32) -> u8 {
14813     #[cfg(windows)]
14814     {
14815         #[link(name = "windows")]
14816         extern "system" {
14817             fn ubidi_getLevelAt(pbidi: *const UBiDi, charindex: i32) -> u8;
14818         }
14819         ::std::mem::transmute(ubidi_getLevelAt(::std::mem::transmute(pbidi), ::std::mem::transmute(charindex)))
14820     }
14821     #[cfg(not(windows))]
14822     unimplemented!("Unsupported target OS");
14823 }
14824 #[inline]
ubidi_getLevels(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> *mut u814825 pub unsafe fn ubidi_getLevels(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> *mut u8 {
14826     #[cfg(windows)]
14827     {
14828         #[link(name = "windows")]
14829         extern "system" {
14830             fn ubidi_getLevels(pbidi: *mut UBiDi, perrorcode: *mut UErrorCode) -> *mut u8;
14831         }
14832         ::std::mem::transmute(ubidi_getLevels(::std::mem::transmute(pbidi), ::std::mem::transmute(perrorcode)))
14833     }
14834     #[cfg(not(windows))]
14835     unimplemented!("Unsupported target OS");
14836 }
14837 #[inline]
ubidi_getLogicalIndex(pbidi: *mut UBiDi, visualindex: i32, perrorcode: *mut UErrorCode) -> i3214838 pub unsafe fn ubidi_getLogicalIndex(pbidi: *mut UBiDi, visualindex: i32, perrorcode: *mut UErrorCode) -> i32 {
14839     #[cfg(windows)]
14840     {
14841         #[link(name = "windows")]
14842         extern "system" {
14843             fn ubidi_getLogicalIndex(pbidi: *mut UBiDi, visualindex: i32, perrorcode: *mut UErrorCode) -> i32;
14844         }
14845         ::std::mem::transmute(ubidi_getLogicalIndex(::std::mem::transmute(pbidi), ::std::mem::transmute(visualindex), ::std::mem::transmute(perrorcode)))
14846     }
14847     #[cfg(not(windows))]
14848     unimplemented!("Unsupported target OS");
14849 }
14850 #[inline]
ubidi_getLogicalMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode)14851 pub unsafe fn ubidi_getLogicalMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode) {
14852     #[cfg(windows)]
14853     {
14854         #[link(name = "windows")]
14855         extern "system" {
14856             fn ubidi_getLogicalMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode);
14857         }
14858         ::std::mem::transmute(ubidi_getLogicalMap(::std::mem::transmute(pbidi), ::std::mem::transmute(indexmap), ::std::mem::transmute(perrorcode)))
14859     }
14860     #[cfg(not(windows))]
14861     unimplemented!("Unsupported target OS");
14862 }
14863 #[inline]
ubidi_getLogicalRun(pbidi: *const UBiDi, logicalposition: i32, plogicallimit: *mut i32, plevel: *mut u8)14864 pub unsafe fn ubidi_getLogicalRun(pbidi: *const UBiDi, logicalposition: i32, plogicallimit: *mut i32, plevel: *mut u8) {
14865     #[cfg(windows)]
14866     {
14867         #[link(name = "windows")]
14868         extern "system" {
14869             fn ubidi_getLogicalRun(pbidi: *const UBiDi, logicalposition: i32, plogicallimit: *mut i32, plevel: *mut u8);
14870         }
14871         ::std::mem::transmute(ubidi_getLogicalRun(::std::mem::transmute(pbidi), ::std::mem::transmute(logicalposition), ::std::mem::transmute(plogicallimit), ::std::mem::transmute(plevel)))
14872     }
14873     #[cfg(not(windows))]
14874     unimplemented!("Unsupported target OS");
14875 }
14876 #[inline]
ubidi_getParaLevel(pbidi: *const UBiDi) -> u814877 pub unsafe fn ubidi_getParaLevel(pbidi: *const UBiDi) -> u8 {
14878     #[cfg(windows)]
14879     {
14880         #[link(name = "windows")]
14881         extern "system" {
14882             fn ubidi_getParaLevel(pbidi: *const UBiDi) -> u8;
14883         }
14884         ::std::mem::transmute(ubidi_getParaLevel(::std::mem::transmute(pbidi)))
14885     }
14886     #[cfg(not(windows))]
14887     unimplemented!("Unsupported target OS");
14888 }
14889 #[inline]
ubidi_getParagraph(pbidi: *const UBiDi, charindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode) -> i3214890 pub unsafe fn ubidi_getParagraph(pbidi: *const UBiDi, charindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode) -> i32 {
14891     #[cfg(windows)]
14892     {
14893         #[link(name = "windows")]
14894         extern "system" {
14895             fn ubidi_getParagraph(pbidi: *const UBiDi, charindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode) -> i32;
14896         }
14897         ::std::mem::transmute(ubidi_getParagraph(::std::mem::transmute(pbidi), ::std::mem::transmute(charindex), ::std::mem::transmute(pparastart), ::std::mem::transmute(pparalimit), ::std::mem::transmute(pparalevel), ::std::mem::transmute(perrorcode)))
14898     }
14899     #[cfg(not(windows))]
14900     unimplemented!("Unsupported target OS");
14901 }
14902 #[inline]
ubidi_getParagraphByIndex(pbidi: *const UBiDi, paraindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode)14903 pub unsafe fn ubidi_getParagraphByIndex(pbidi: *const UBiDi, paraindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode) {
14904     #[cfg(windows)]
14905     {
14906         #[link(name = "windows")]
14907         extern "system" {
14908             fn ubidi_getParagraphByIndex(pbidi: *const UBiDi, paraindex: i32, pparastart: *mut i32, pparalimit: *mut i32, pparalevel: *mut u8, perrorcode: *mut UErrorCode);
14909         }
14910         ::std::mem::transmute(ubidi_getParagraphByIndex(::std::mem::transmute(pbidi), ::std::mem::transmute(paraindex), ::std::mem::transmute(pparastart), ::std::mem::transmute(pparalimit), ::std::mem::transmute(pparalevel), ::std::mem::transmute(perrorcode)))
14911     }
14912     #[cfg(not(windows))]
14913     unimplemented!("Unsupported target OS");
14914 }
14915 #[inline]
ubidi_getProcessedLength(pbidi: *const UBiDi) -> i3214916 pub unsafe fn ubidi_getProcessedLength(pbidi: *const UBiDi) -> i32 {
14917     #[cfg(windows)]
14918     {
14919         #[link(name = "windows")]
14920         extern "system" {
14921             fn ubidi_getProcessedLength(pbidi: *const UBiDi) -> i32;
14922         }
14923         ::std::mem::transmute(ubidi_getProcessedLength(::std::mem::transmute(pbidi)))
14924     }
14925     #[cfg(not(windows))]
14926     unimplemented!("Unsupported target OS");
14927 }
14928 #[inline]
ubidi_getReorderingMode(pbidi: *mut UBiDi) -> UBiDiReorderingMode14929 pub unsafe fn ubidi_getReorderingMode(pbidi: *mut UBiDi) -> UBiDiReorderingMode {
14930     #[cfg(windows)]
14931     {
14932         #[link(name = "windows")]
14933         extern "system" {
14934             fn ubidi_getReorderingMode(pbidi: *mut UBiDi) -> UBiDiReorderingMode;
14935         }
14936         ::std::mem::transmute(ubidi_getReorderingMode(::std::mem::transmute(pbidi)))
14937     }
14938     #[cfg(not(windows))]
14939     unimplemented!("Unsupported target OS");
14940 }
14941 #[inline]
ubidi_getReorderingOptions(pbidi: *mut UBiDi) -> u3214942 pub unsafe fn ubidi_getReorderingOptions(pbidi: *mut UBiDi) -> u32 {
14943     #[cfg(windows)]
14944     {
14945         #[link(name = "windows")]
14946         extern "system" {
14947             fn ubidi_getReorderingOptions(pbidi: *mut UBiDi) -> u32;
14948         }
14949         ::std::mem::transmute(ubidi_getReorderingOptions(::std::mem::transmute(pbidi)))
14950     }
14951     #[cfg(not(windows))]
14952     unimplemented!("Unsupported target OS");
14953 }
14954 #[inline]
ubidi_getResultLength(pbidi: *const UBiDi) -> i3214955 pub unsafe fn ubidi_getResultLength(pbidi: *const UBiDi) -> i32 {
14956     #[cfg(windows)]
14957     {
14958         #[link(name = "windows")]
14959         extern "system" {
14960             fn ubidi_getResultLength(pbidi: *const UBiDi) -> i32;
14961         }
14962         ::std::mem::transmute(ubidi_getResultLength(::std::mem::transmute(pbidi)))
14963     }
14964     #[cfg(not(windows))]
14965     unimplemented!("Unsupported target OS");
14966 }
14967 #[inline]
ubidi_getText(pbidi: *const UBiDi) -> *mut u1614968 pub unsafe fn ubidi_getText(pbidi: *const UBiDi) -> *mut u16 {
14969     #[cfg(windows)]
14970     {
14971         #[link(name = "windows")]
14972         extern "system" {
14973             fn ubidi_getText(pbidi: *const UBiDi) -> *mut u16;
14974         }
14975         ::std::mem::transmute(ubidi_getText(::std::mem::transmute(pbidi)))
14976     }
14977     #[cfg(not(windows))]
14978     unimplemented!("Unsupported target OS");
14979 }
14980 #[inline]
ubidi_getVisualIndex(pbidi: *mut UBiDi, logicalindex: i32, perrorcode: *mut UErrorCode) -> i3214981 pub unsafe fn ubidi_getVisualIndex(pbidi: *mut UBiDi, logicalindex: i32, perrorcode: *mut UErrorCode) -> i32 {
14982     #[cfg(windows)]
14983     {
14984         #[link(name = "windows")]
14985         extern "system" {
14986             fn ubidi_getVisualIndex(pbidi: *mut UBiDi, logicalindex: i32, perrorcode: *mut UErrorCode) -> i32;
14987         }
14988         ::std::mem::transmute(ubidi_getVisualIndex(::std::mem::transmute(pbidi), ::std::mem::transmute(logicalindex), ::std::mem::transmute(perrorcode)))
14989     }
14990     #[cfg(not(windows))]
14991     unimplemented!("Unsupported target OS");
14992 }
14993 #[inline]
ubidi_getVisualMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode)14994 pub unsafe fn ubidi_getVisualMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode) {
14995     #[cfg(windows)]
14996     {
14997         #[link(name = "windows")]
14998         extern "system" {
14999             fn ubidi_getVisualMap(pbidi: *mut UBiDi, indexmap: *mut i32, perrorcode: *mut UErrorCode);
15000         }
15001         ::std::mem::transmute(ubidi_getVisualMap(::std::mem::transmute(pbidi), ::std::mem::transmute(indexmap), ::std::mem::transmute(perrorcode)))
15002     }
15003     #[cfg(not(windows))]
15004     unimplemented!("Unsupported target OS");
15005 }
15006 #[inline]
ubidi_getVisualRun(pbidi: *mut UBiDi, runindex: i32, plogicalstart: *mut i32, plength: *mut i32) -> UBiDiDirection15007 pub unsafe fn ubidi_getVisualRun(pbidi: *mut UBiDi, runindex: i32, plogicalstart: *mut i32, plength: *mut i32) -> UBiDiDirection {
15008     #[cfg(windows)]
15009     {
15010         #[link(name = "windows")]
15011         extern "system" {
15012             fn ubidi_getVisualRun(pbidi: *mut UBiDi, runindex: i32, plogicalstart: *mut i32, plength: *mut i32) -> UBiDiDirection;
15013         }
15014         ::std::mem::transmute(ubidi_getVisualRun(::std::mem::transmute(pbidi), ::std::mem::transmute(runindex), ::std::mem::transmute(plogicalstart), ::std::mem::transmute(plength)))
15015     }
15016     #[cfg(not(windows))]
15017     unimplemented!("Unsupported target OS");
15018 }
15019 #[inline]
ubidi_invertMap(srcmap: *const i32, destmap: *mut i32, length: i32)15020 pub unsafe fn ubidi_invertMap(srcmap: *const i32, destmap: *mut i32, length: i32) {
15021     #[cfg(windows)]
15022     {
15023         #[link(name = "windows")]
15024         extern "system" {
15025             fn ubidi_invertMap(srcmap: *const i32, destmap: *mut i32, length: i32);
15026         }
15027         ::std::mem::transmute(ubidi_invertMap(::std::mem::transmute(srcmap), ::std::mem::transmute(destmap), ::std::mem::transmute(length)))
15028     }
15029     #[cfg(not(windows))]
15030     unimplemented!("Unsupported target OS");
15031 }
15032 #[inline]
ubidi_isInverse(pbidi: *mut UBiDi) -> i815033 pub unsafe fn ubidi_isInverse(pbidi: *mut UBiDi) -> i8 {
15034     #[cfg(windows)]
15035     {
15036         #[link(name = "windows")]
15037         extern "system" {
15038             fn ubidi_isInverse(pbidi: *mut UBiDi) -> i8;
15039         }
15040         ::std::mem::transmute(ubidi_isInverse(::std::mem::transmute(pbidi)))
15041     }
15042     #[cfg(not(windows))]
15043     unimplemented!("Unsupported target OS");
15044 }
15045 #[inline]
ubidi_isOrderParagraphsLTR(pbidi: *mut UBiDi) -> i815046 pub unsafe fn ubidi_isOrderParagraphsLTR(pbidi: *mut UBiDi) -> i8 {
15047     #[cfg(windows)]
15048     {
15049         #[link(name = "windows")]
15050         extern "system" {
15051             fn ubidi_isOrderParagraphsLTR(pbidi: *mut UBiDi) -> i8;
15052         }
15053         ::std::mem::transmute(ubidi_isOrderParagraphsLTR(::std::mem::transmute(pbidi)))
15054     }
15055     #[cfg(not(windows))]
15056     unimplemented!("Unsupported target OS");
15057 }
15058 #[inline]
ubidi_open() -> *mut UBiDi15059 pub unsafe fn ubidi_open() -> *mut UBiDi {
15060     #[cfg(windows)]
15061     {
15062         #[link(name = "windows")]
15063         extern "system" {
15064             fn ubidi_open() -> *mut UBiDi;
15065         }
15066         ::std::mem::transmute(ubidi_open())
15067     }
15068     #[cfg(not(windows))]
15069     unimplemented!("Unsupported target OS");
15070 }
15071 #[inline]
ubidi_openSized(maxlength: i32, maxruncount: i32, perrorcode: *mut UErrorCode) -> *mut UBiDi15072 pub unsafe fn ubidi_openSized(maxlength: i32, maxruncount: i32, perrorcode: *mut UErrorCode) -> *mut UBiDi {
15073     #[cfg(windows)]
15074     {
15075         #[link(name = "windows")]
15076         extern "system" {
15077             fn ubidi_openSized(maxlength: i32, maxruncount: i32, perrorcode: *mut UErrorCode) -> *mut UBiDi;
15078         }
15079         ::std::mem::transmute(ubidi_openSized(::std::mem::transmute(maxlength), ::std::mem::transmute(maxruncount), ::std::mem::transmute(perrorcode)))
15080     }
15081     #[cfg(not(windows))]
15082     unimplemented!("Unsupported target OS");
15083 }
15084 #[inline]
ubidi_orderParagraphsLTR(pbidi: *mut UBiDi, orderparagraphsltr: i8)15085 pub unsafe fn ubidi_orderParagraphsLTR(pbidi: *mut UBiDi, orderparagraphsltr: i8) {
15086     #[cfg(windows)]
15087     {
15088         #[link(name = "windows")]
15089         extern "system" {
15090             fn ubidi_orderParagraphsLTR(pbidi: *mut UBiDi, orderparagraphsltr: i8);
15091         }
15092         ::std::mem::transmute(ubidi_orderParagraphsLTR(::std::mem::transmute(pbidi), ::std::mem::transmute(orderparagraphsltr)))
15093     }
15094     #[cfg(not(windows))]
15095     unimplemented!("Unsupported target OS");
15096 }
15097 #[inline]
ubidi_reorderLogical(levels: *const u8, length: i32, indexmap: *mut i32)15098 pub unsafe fn ubidi_reorderLogical(levels: *const u8, length: i32, indexmap: *mut i32) {
15099     #[cfg(windows)]
15100     {
15101         #[link(name = "windows")]
15102         extern "system" {
15103             fn ubidi_reorderLogical(levels: *const u8, length: i32, indexmap: *mut i32);
15104         }
15105         ::std::mem::transmute(ubidi_reorderLogical(::std::mem::transmute(levels), ::std::mem::transmute(length), ::std::mem::transmute(indexmap)))
15106     }
15107     #[cfg(not(windows))]
15108     unimplemented!("Unsupported target OS");
15109 }
15110 #[inline]
ubidi_reorderVisual(levels: *const u8, length: i32, indexmap: *mut i32)15111 pub unsafe fn ubidi_reorderVisual(levels: *const u8, length: i32, indexmap: *mut i32) {
15112     #[cfg(windows)]
15113     {
15114         #[link(name = "windows")]
15115         extern "system" {
15116             fn ubidi_reorderVisual(levels: *const u8, length: i32, indexmap: *mut i32);
15117         }
15118         ::std::mem::transmute(ubidi_reorderVisual(::std::mem::transmute(levels), ::std::mem::transmute(length), ::std::mem::transmute(indexmap)))
15119     }
15120     #[cfg(not(windows))]
15121     unimplemented!("Unsupported target OS");
15122 }
15123 #[inline]
ubidi_setClassCallback(pbidi: *mut UBiDi, newfn: ::std::option::Option<UBiDiClassCallback>, newcontext: *const ::std::ffi::c_void, oldfn: *mut ::std::option::Option<UBiDiClassCallback>, oldcontext: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode)15124 pub unsafe fn ubidi_setClassCallback(pbidi: *mut UBiDi, newfn: ::std::option::Option<UBiDiClassCallback>, newcontext: *const ::std::ffi::c_void, oldfn: *mut ::std::option::Option<UBiDiClassCallback>, oldcontext: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) {
15125     #[cfg(windows)]
15126     {
15127         #[link(name = "windows")]
15128         extern "system" {
15129             fn ubidi_setClassCallback(pbidi: *mut UBiDi, newfn: ::windows::runtime::RawPtr, newcontext: *const ::std::ffi::c_void, oldfn: *mut ::windows::runtime::RawPtr, oldcontext: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode);
15130         }
15131         ::std::mem::transmute(ubidi_setClassCallback(::std::mem::transmute(pbidi), ::std::mem::transmute(newfn), ::std::mem::transmute(newcontext), ::std::mem::transmute(oldfn), ::std::mem::transmute(oldcontext), ::std::mem::transmute(perrorcode)))
15132     }
15133     #[cfg(not(windows))]
15134     unimplemented!("Unsupported target OS");
15135 }
15136 #[inline]
ubidi_setContext(pbidi: *mut UBiDi, prologue: *const u16, prolength: i32, epilogue: *const u16, epilength: i32, perrorcode: *mut UErrorCode)15137 pub unsafe fn ubidi_setContext(pbidi: *mut UBiDi, prologue: *const u16, prolength: i32, epilogue: *const u16, epilength: i32, perrorcode: *mut UErrorCode) {
15138     #[cfg(windows)]
15139     {
15140         #[link(name = "windows")]
15141         extern "system" {
15142             fn ubidi_setContext(pbidi: *mut UBiDi, prologue: *const u16, prolength: i32, epilogue: *const u16, epilength: i32, perrorcode: *mut UErrorCode);
15143         }
15144         ::std::mem::transmute(ubidi_setContext(::std::mem::transmute(pbidi), ::std::mem::transmute(prologue), ::std::mem::transmute(prolength), ::std::mem::transmute(epilogue), ::std::mem::transmute(epilength), ::std::mem::transmute(perrorcode)))
15145     }
15146     #[cfg(not(windows))]
15147     unimplemented!("Unsupported target OS");
15148 }
15149 #[inline]
ubidi_setInverse(pbidi: *mut UBiDi, isinverse: i8)15150 pub unsafe fn ubidi_setInverse(pbidi: *mut UBiDi, isinverse: i8) {
15151     #[cfg(windows)]
15152     {
15153         #[link(name = "windows")]
15154         extern "system" {
15155             fn ubidi_setInverse(pbidi: *mut UBiDi, isinverse: i8);
15156         }
15157         ::std::mem::transmute(ubidi_setInverse(::std::mem::transmute(pbidi), ::std::mem::transmute(isinverse)))
15158     }
15159     #[cfg(not(windows))]
15160     unimplemented!("Unsupported target OS");
15161 }
15162 #[inline]
ubidi_setLine(pparabidi: *const UBiDi, start: i32, limit: i32, plinebidi: *mut UBiDi, perrorcode: *mut UErrorCode)15163 pub unsafe fn ubidi_setLine(pparabidi: *const UBiDi, start: i32, limit: i32, plinebidi: *mut UBiDi, perrorcode: *mut UErrorCode) {
15164     #[cfg(windows)]
15165     {
15166         #[link(name = "windows")]
15167         extern "system" {
15168             fn ubidi_setLine(pparabidi: *const UBiDi, start: i32, limit: i32, plinebidi: *mut UBiDi, perrorcode: *mut UErrorCode);
15169         }
15170         ::std::mem::transmute(ubidi_setLine(::std::mem::transmute(pparabidi), ::std::mem::transmute(start), ::std::mem::transmute(limit), ::std::mem::transmute(plinebidi), ::std::mem::transmute(perrorcode)))
15171     }
15172     #[cfg(not(windows))]
15173     unimplemented!("Unsupported target OS");
15174 }
15175 #[inline]
ubidi_setPara(pbidi: *mut UBiDi, text: *const u16, length: i32, paralevel: u8, embeddinglevels: *mut u8, perrorcode: *mut UErrorCode)15176 pub unsafe fn ubidi_setPara(pbidi: *mut UBiDi, text: *const u16, length: i32, paralevel: u8, embeddinglevels: *mut u8, perrorcode: *mut UErrorCode) {
15177     #[cfg(windows)]
15178     {
15179         #[link(name = "windows")]
15180         extern "system" {
15181             fn ubidi_setPara(pbidi: *mut UBiDi, text: *const u16, length: i32, paralevel: u8, embeddinglevels: *mut u8, perrorcode: *mut UErrorCode);
15182         }
15183         ::std::mem::transmute(ubidi_setPara(::std::mem::transmute(pbidi), ::std::mem::transmute(text), ::std::mem::transmute(length), ::std::mem::transmute(paralevel), ::std::mem::transmute(embeddinglevels), ::std::mem::transmute(perrorcode)))
15184     }
15185     #[cfg(not(windows))]
15186     unimplemented!("Unsupported target OS");
15187 }
15188 #[inline]
ubidi_setReorderingMode(pbidi: *mut UBiDi, reorderingmode: UBiDiReorderingMode)15189 pub unsafe fn ubidi_setReorderingMode(pbidi: *mut UBiDi, reorderingmode: UBiDiReorderingMode) {
15190     #[cfg(windows)]
15191     {
15192         #[link(name = "windows")]
15193         extern "system" {
15194             fn ubidi_setReorderingMode(pbidi: *mut UBiDi, reorderingmode: UBiDiReorderingMode);
15195         }
15196         ::std::mem::transmute(ubidi_setReorderingMode(::std::mem::transmute(pbidi), ::std::mem::transmute(reorderingmode)))
15197     }
15198     #[cfg(not(windows))]
15199     unimplemented!("Unsupported target OS");
15200 }
15201 #[inline]
ubidi_setReorderingOptions(pbidi: *mut UBiDi, reorderingoptions: u32)15202 pub unsafe fn ubidi_setReorderingOptions(pbidi: *mut UBiDi, reorderingoptions: u32) {
15203     #[cfg(windows)]
15204     {
15205         #[link(name = "windows")]
15206         extern "system" {
15207             fn ubidi_setReorderingOptions(pbidi: *mut UBiDi, reorderingoptions: u32);
15208         }
15209         ::std::mem::transmute(ubidi_setReorderingOptions(::std::mem::transmute(pbidi), ::std::mem::transmute(reorderingoptions)))
15210     }
15211     #[cfg(not(windows))]
15212     unimplemented!("Unsupported target OS");
15213 }
15214 #[inline]
ubidi_writeReordered(pbidi: *mut UBiDi, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i3215215 pub unsafe fn ubidi_writeReordered(pbidi: *mut UBiDi, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i32 {
15216     #[cfg(windows)]
15217     {
15218         #[link(name = "windows")]
15219         extern "system" {
15220             fn ubidi_writeReordered(pbidi: *mut UBiDi, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i32;
15221         }
15222         ::std::mem::transmute(ubidi_writeReordered(::std::mem::transmute(pbidi), ::std::mem::transmute(dest), ::std::mem::transmute(destsize), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
15223     }
15224     #[cfg(not(windows))]
15225     unimplemented!("Unsupported target OS");
15226 }
15227 #[inline]
ubidi_writeReverse(src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i3215228 pub unsafe fn ubidi_writeReverse(src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i32 {
15229     #[cfg(windows)]
15230     {
15231         #[link(name = "windows")]
15232         extern "system" {
15233             fn ubidi_writeReverse(src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, options: u16, perrorcode: *mut UErrorCode) -> i32;
15234         }
15235         ::std::mem::transmute(ubidi_writeReverse(::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(dest), ::std::mem::transmute(destsize), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
15236     }
15237     #[cfg(not(windows))]
15238     unimplemented!("Unsupported target OS");
15239 }
15240 #[inline]
ubiditransform_close(pbiditransform: *mut UBiDiTransform)15241 pub unsafe fn ubiditransform_close(pbiditransform: *mut UBiDiTransform) {
15242     #[cfg(windows)]
15243     {
15244         #[link(name = "windows")]
15245         extern "system" {
15246             fn ubiditransform_close(pbiditransform: *mut UBiDiTransform);
15247         }
15248         ::std::mem::transmute(ubiditransform_close(::std::mem::transmute(pbiditransform)))
15249     }
15250     #[cfg(not(windows))]
15251     unimplemented!("Unsupported target OS");
15252 }
15253 #[inline]
ubiditransform_open(perrorcode: *mut UErrorCode) -> *mut UBiDiTransform15254 pub unsafe fn ubiditransform_open(perrorcode: *mut UErrorCode) -> *mut UBiDiTransform {
15255     #[cfg(windows)]
15256     {
15257         #[link(name = "windows")]
15258         extern "system" {
15259             fn ubiditransform_open(perrorcode: *mut UErrorCode) -> *mut UBiDiTransform;
15260         }
15261         ::std::mem::transmute(ubiditransform_open(::std::mem::transmute(perrorcode)))
15262     }
15263     #[cfg(not(windows))]
15264     unimplemented!("Unsupported target OS");
15265 }
15266 #[inline]
ubiditransform_transform(pbiditransform: *mut UBiDiTransform, src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, inparalevel: u8, inorder: UBiDiOrder, outparalevel: u8, outorder: UBiDiOrder, domirroring: UBiDiMirroring, shapingoptions: u32, perrorcode: *mut UErrorCode) -> u3215267 pub unsafe fn ubiditransform_transform(pbiditransform: *mut UBiDiTransform, src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, inparalevel: u8, inorder: UBiDiOrder, outparalevel: u8, outorder: UBiDiOrder, domirroring: UBiDiMirroring, shapingoptions: u32, perrorcode: *mut UErrorCode) -> u32 {
15268     #[cfg(windows)]
15269     {
15270         #[link(name = "windows")]
15271         extern "system" {
15272             fn ubiditransform_transform(pbiditransform: *mut UBiDiTransform, src: *const u16, srclength: i32, dest: *mut u16, destsize: i32, inparalevel: u8, inorder: UBiDiOrder, outparalevel: u8, outorder: UBiDiOrder, domirroring: UBiDiMirroring, shapingoptions: u32, perrorcode: *mut UErrorCode) -> u32;
15273         }
15274         ::std::mem::transmute(ubiditransform_transform(
15275             ::std::mem::transmute(pbiditransform),
15276             ::std::mem::transmute(src),
15277             ::std::mem::transmute(srclength),
15278             ::std::mem::transmute(dest),
15279             ::std::mem::transmute(destsize),
15280             ::std::mem::transmute(inparalevel),
15281             ::std::mem::transmute(inorder),
15282             ::std::mem::transmute(outparalevel),
15283             ::std::mem::transmute(outorder),
15284             ::std::mem::transmute(domirroring),
15285             ::std::mem::transmute(shapingoptions),
15286             ::std::mem::transmute(perrorcode),
15287         ))
15288     }
15289     #[cfg(not(windows))]
15290     unimplemented!("Unsupported target OS");
15291 }
15292 #[inline]
ublock_getCode(c: i32) -> UBlockCode15293 pub unsafe fn ublock_getCode(c: i32) -> UBlockCode {
15294     #[cfg(windows)]
15295     {
15296         #[link(name = "windows")]
15297         extern "system" {
15298             fn ublock_getCode(c: i32) -> UBlockCode;
15299         }
15300         ::std::mem::transmute(ublock_getCode(::std::mem::transmute(c)))
15301     }
15302     #[cfg(not(windows))]
15303     unimplemented!("Unsupported target OS");
15304 }
15305 #[inline]
ubrk_close(bi: *mut UBreakIterator)15306 pub unsafe fn ubrk_close(bi: *mut UBreakIterator) {
15307     #[cfg(windows)]
15308     {
15309         #[link(name = "windows")]
15310         extern "system" {
15311             fn ubrk_close(bi: *mut UBreakIterator);
15312         }
15313         ::std::mem::transmute(ubrk_close(::std::mem::transmute(bi)))
15314     }
15315     #[cfg(not(windows))]
15316     unimplemented!("Unsupported target OS");
15317 }
15318 #[inline]
ubrk_countAvailable() -> i3215319 pub unsafe fn ubrk_countAvailable() -> i32 {
15320     #[cfg(windows)]
15321     {
15322         #[link(name = "windows")]
15323         extern "system" {
15324             fn ubrk_countAvailable() -> i32;
15325         }
15326         ::std::mem::transmute(ubrk_countAvailable())
15327     }
15328     #[cfg(not(windows))]
15329     unimplemented!("Unsupported target OS");
15330 }
15331 #[inline]
ubrk_current(bi: *const UBreakIterator) -> i3215332 pub unsafe fn ubrk_current(bi: *const UBreakIterator) -> i32 {
15333     #[cfg(windows)]
15334     {
15335         #[link(name = "windows")]
15336         extern "system" {
15337             fn ubrk_current(bi: *const UBreakIterator) -> i32;
15338         }
15339         ::std::mem::transmute(ubrk_current(::std::mem::transmute(bi)))
15340     }
15341     #[cfg(not(windows))]
15342     unimplemented!("Unsupported target OS");
15343 }
15344 #[inline]
ubrk_first(bi: *mut UBreakIterator) -> i3215345 pub unsafe fn ubrk_first(bi: *mut UBreakIterator) -> i32 {
15346     #[cfg(windows)]
15347     {
15348         #[link(name = "windows")]
15349         extern "system" {
15350             fn ubrk_first(bi: *mut UBreakIterator) -> i32;
15351         }
15352         ::std::mem::transmute(ubrk_first(::std::mem::transmute(bi)))
15353     }
15354     #[cfg(not(windows))]
15355     unimplemented!("Unsupported target OS");
15356 }
15357 #[inline]
ubrk_following(bi: *mut UBreakIterator, offset: i32) -> i3215358 pub unsafe fn ubrk_following(bi: *mut UBreakIterator, offset: i32) -> i32 {
15359     #[cfg(windows)]
15360     {
15361         #[link(name = "windows")]
15362         extern "system" {
15363             fn ubrk_following(bi: *mut UBreakIterator, offset: i32) -> i32;
15364         }
15365         ::std::mem::transmute(ubrk_following(::std::mem::transmute(bi), ::std::mem::transmute(offset)))
15366     }
15367     #[cfg(not(windows))]
15368     unimplemented!("Unsupported target OS");
15369 }
15370 #[cfg(feature = "Win32_Foundation")]
15371 #[inline]
ubrk_getAvailable(index: i32) -> super::Foundation::PSTR15372 pub unsafe fn ubrk_getAvailable(index: i32) -> super::Foundation::PSTR {
15373     #[cfg(windows)]
15374     {
15375         #[link(name = "windows")]
15376         extern "system" {
15377             fn ubrk_getAvailable(index: i32) -> super::Foundation::PSTR;
15378         }
15379         ::std::mem::transmute(ubrk_getAvailable(::std::mem::transmute(index)))
15380     }
15381     #[cfg(not(windows))]
15382     unimplemented!("Unsupported target OS");
15383 }
15384 #[inline]
ubrk_getBinaryRules(bi: *mut UBreakIterator, binaryrules: *mut u8, rulescapacity: i32, status: *mut UErrorCode) -> i3215385 pub unsafe fn ubrk_getBinaryRules(bi: *mut UBreakIterator, binaryrules: *mut u8, rulescapacity: i32, status: *mut UErrorCode) -> i32 {
15386     #[cfg(windows)]
15387     {
15388         #[link(name = "windows")]
15389         extern "system" {
15390             fn ubrk_getBinaryRules(bi: *mut UBreakIterator, binaryrules: *mut u8, rulescapacity: i32, status: *mut UErrorCode) -> i32;
15391         }
15392         ::std::mem::transmute(ubrk_getBinaryRules(::std::mem::transmute(bi), ::std::mem::transmute(binaryrules), ::std::mem::transmute(rulescapacity), ::std::mem::transmute(status)))
15393     }
15394     #[cfg(not(windows))]
15395     unimplemented!("Unsupported target OS");
15396 }
15397 #[cfg(feature = "Win32_Foundation")]
15398 #[inline]
ubrk_getLocaleByType(bi: *const UBreakIterator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR15399 pub unsafe fn ubrk_getLocaleByType(bi: *const UBreakIterator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
15400     #[cfg(windows)]
15401     {
15402         #[link(name = "windows")]
15403         extern "system" {
15404             fn ubrk_getLocaleByType(bi: *const UBreakIterator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
15405         }
15406         ::std::mem::transmute(ubrk_getLocaleByType(::std::mem::transmute(bi), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
15407     }
15408     #[cfg(not(windows))]
15409     unimplemented!("Unsupported target OS");
15410 }
15411 #[inline]
ubrk_getRuleStatus(bi: *mut UBreakIterator) -> i3215412 pub unsafe fn ubrk_getRuleStatus(bi: *mut UBreakIterator) -> i32 {
15413     #[cfg(windows)]
15414     {
15415         #[link(name = "windows")]
15416         extern "system" {
15417             fn ubrk_getRuleStatus(bi: *mut UBreakIterator) -> i32;
15418         }
15419         ::std::mem::transmute(ubrk_getRuleStatus(::std::mem::transmute(bi)))
15420     }
15421     #[cfg(not(windows))]
15422     unimplemented!("Unsupported target OS");
15423 }
15424 #[inline]
ubrk_getRuleStatusVec(bi: *mut UBreakIterator, fillinvec: *mut i32, capacity: i32, status: *mut UErrorCode) -> i3215425 pub unsafe fn ubrk_getRuleStatusVec(bi: *mut UBreakIterator, fillinvec: *mut i32, capacity: i32, status: *mut UErrorCode) -> i32 {
15426     #[cfg(windows)]
15427     {
15428         #[link(name = "windows")]
15429         extern "system" {
15430             fn ubrk_getRuleStatusVec(bi: *mut UBreakIterator, fillinvec: *mut i32, capacity: i32, status: *mut UErrorCode) -> i32;
15431         }
15432         ::std::mem::transmute(ubrk_getRuleStatusVec(::std::mem::transmute(bi), ::std::mem::transmute(fillinvec), ::std::mem::transmute(capacity), ::std::mem::transmute(status)))
15433     }
15434     #[cfg(not(windows))]
15435     unimplemented!("Unsupported target OS");
15436 }
15437 #[inline]
ubrk_isBoundary(bi: *mut UBreakIterator, offset: i32) -> i815438 pub unsafe fn ubrk_isBoundary(bi: *mut UBreakIterator, offset: i32) -> i8 {
15439     #[cfg(windows)]
15440     {
15441         #[link(name = "windows")]
15442         extern "system" {
15443             fn ubrk_isBoundary(bi: *mut UBreakIterator, offset: i32) -> i8;
15444         }
15445         ::std::mem::transmute(ubrk_isBoundary(::std::mem::transmute(bi), ::std::mem::transmute(offset)))
15446     }
15447     #[cfg(not(windows))]
15448     unimplemented!("Unsupported target OS");
15449 }
15450 #[inline]
ubrk_last(bi: *mut UBreakIterator) -> i3215451 pub unsafe fn ubrk_last(bi: *mut UBreakIterator) -> i32 {
15452     #[cfg(windows)]
15453     {
15454         #[link(name = "windows")]
15455         extern "system" {
15456             fn ubrk_last(bi: *mut UBreakIterator) -> i32;
15457         }
15458         ::std::mem::transmute(ubrk_last(::std::mem::transmute(bi)))
15459     }
15460     #[cfg(not(windows))]
15461     unimplemented!("Unsupported target OS");
15462 }
15463 #[inline]
ubrk_next(bi: *mut UBreakIterator) -> i3215464 pub unsafe fn ubrk_next(bi: *mut UBreakIterator) -> i32 {
15465     #[cfg(windows)]
15466     {
15467         #[link(name = "windows")]
15468         extern "system" {
15469             fn ubrk_next(bi: *mut UBreakIterator) -> i32;
15470         }
15471         ::std::mem::transmute(ubrk_next(::std::mem::transmute(bi)))
15472     }
15473     #[cfg(not(windows))]
15474     unimplemented!("Unsupported target OS");
15475 }
15476 #[cfg(feature = "Win32_Foundation")]
15477 #[inline]
ubrk_open<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(r#type: UBreakIteratorType, locale: Param1, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator15478 pub unsafe fn ubrk_open<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(r#type: UBreakIteratorType, locale: Param1, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator {
15479     #[cfg(windows)]
15480     {
15481         #[link(name = "windows")]
15482         extern "system" {
15483             fn ubrk_open(r#type: UBreakIteratorType, locale: super::Foundation::PSTR, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator;
15484         }
15485         ::std::mem::transmute(ubrk_open(::std::mem::transmute(r#type), locale.into_param().abi(), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
15486     }
15487     #[cfg(not(windows))]
15488     unimplemented!("Unsupported target OS");
15489 }
15490 #[inline]
ubrk_openBinaryRules(binaryrules: *const u8, ruleslength: i32, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator15491 pub unsafe fn ubrk_openBinaryRules(binaryrules: *const u8, ruleslength: i32, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator {
15492     #[cfg(windows)]
15493     {
15494         #[link(name = "windows")]
15495         extern "system" {
15496             fn ubrk_openBinaryRules(binaryrules: *const u8, ruleslength: i32, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UBreakIterator;
15497         }
15498         ::std::mem::transmute(ubrk_openBinaryRules(::std::mem::transmute(binaryrules), ::std::mem::transmute(ruleslength), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
15499     }
15500     #[cfg(not(windows))]
15501     unimplemented!("Unsupported target OS");
15502 }
15503 #[inline]
ubrk_openRules(rules: *const u16, ruleslength: i32, text: *const u16, textlength: i32, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut UBreakIterator15504 pub unsafe fn ubrk_openRules(rules: *const u16, ruleslength: i32, text: *const u16, textlength: i32, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut UBreakIterator {
15505     #[cfg(windows)]
15506     {
15507         #[link(name = "windows")]
15508         extern "system" {
15509             fn ubrk_openRules(rules: *const u16, ruleslength: i32, text: *const u16, textlength: i32, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut UBreakIterator;
15510         }
15511         ::std::mem::transmute(ubrk_openRules(::std::mem::transmute(rules), ::std::mem::transmute(ruleslength), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parseerr), ::std::mem::transmute(status)))
15512     }
15513     #[cfg(not(windows))]
15514     unimplemented!("Unsupported target OS");
15515 }
15516 #[inline]
ubrk_preceding(bi: *mut UBreakIterator, offset: i32) -> i3215517 pub unsafe fn ubrk_preceding(bi: *mut UBreakIterator, offset: i32) -> i32 {
15518     #[cfg(windows)]
15519     {
15520         #[link(name = "windows")]
15521         extern "system" {
15522             fn ubrk_preceding(bi: *mut UBreakIterator, offset: i32) -> i32;
15523         }
15524         ::std::mem::transmute(ubrk_preceding(::std::mem::transmute(bi), ::std::mem::transmute(offset)))
15525     }
15526     #[cfg(not(windows))]
15527     unimplemented!("Unsupported target OS");
15528 }
15529 #[inline]
ubrk_previous(bi: *mut UBreakIterator) -> i3215530 pub unsafe fn ubrk_previous(bi: *mut UBreakIterator) -> i32 {
15531     #[cfg(windows)]
15532     {
15533         #[link(name = "windows")]
15534         extern "system" {
15535             fn ubrk_previous(bi: *mut UBreakIterator) -> i32;
15536         }
15537         ::std::mem::transmute(ubrk_previous(::std::mem::transmute(bi)))
15538     }
15539     #[cfg(not(windows))]
15540     unimplemented!("Unsupported target OS");
15541 }
15542 #[inline]
ubrk_refreshUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode)15543 pub unsafe fn ubrk_refreshUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode) {
15544     #[cfg(windows)]
15545     {
15546         #[link(name = "windows")]
15547         extern "system" {
15548             fn ubrk_refreshUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode);
15549         }
15550         ::std::mem::transmute(ubrk_refreshUText(::std::mem::transmute(bi), ::std::mem::transmute(text), ::std::mem::transmute(status)))
15551     }
15552     #[cfg(not(windows))]
15553     unimplemented!("Unsupported target OS");
15554 }
15555 #[inline]
ubrk_safeClone(bi: *const UBreakIterator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UBreakIterator15556 pub unsafe fn ubrk_safeClone(bi: *const UBreakIterator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UBreakIterator {
15557     #[cfg(windows)]
15558     {
15559         #[link(name = "windows")]
15560         extern "system" {
15561             fn ubrk_safeClone(bi: *const UBreakIterator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UBreakIterator;
15562         }
15563         ::std::mem::transmute(ubrk_safeClone(::std::mem::transmute(bi), ::std::mem::transmute(stackbuffer), ::std::mem::transmute(pbuffersize), ::std::mem::transmute(status)))
15564     }
15565     #[cfg(not(windows))]
15566     unimplemented!("Unsupported target OS");
15567 }
15568 #[inline]
ubrk_setText(bi: *mut UBreakIterator, text: *const u16, textlength: i32, status: *mut UErrorCode)15569 pub unsafe fn ubrk_setText(bi: *mut UBreakIterator, text: *const u16, textlength: i32, status: *mut UErrorCode) {
15570     #[cfg(windows)]
15571     {
15572         #[link(name = "windows")]
15573         extern "system" {
15574             fn ubrk_setText(bi: *mut UBreakIterator, text: *const u16, textlength: i32, status: *mut UErrorCode);
15575         }
15576         ::std::mem::transmute(ubrk_setText(::std::mem::transmute(bi), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
15577     }
15578     #[cfg(not(windows))]
15579     unimplemented!("Unsupported target OS");
15580 }
15581 #[inline]
ubrk_setUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode)15582 pub unsafe fn ubrk_setUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode) {
15583     #[cfg(windows)]
15584     {
15585         #[link(name = "windows")]
15586         extern "system" {
15587             fn ubrk_setUText(bi: *mut UBreakIterator, text: *mut UText, status: *mut UErrorCode);
15588         }
15589         ::std::mem::transmute(ubrk_setUText(::std::mem::transmute(bi), ::std::mem::transmute(text), ::std::mem::transmute(status)))
15590     }
15591     #[cfg(not(windows))]
15592     unimplemented!("Unsupported target OS");
15593 }
15594 #[inline]
ucal_add(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode)15595 pub unsafe fn ucal_add(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode) {
15596     #[cfg(windows)]
15597     {
15598         #[link(name = "windows")]
15599         extern "system" {
15600             fn ucal_add(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode);
15601         }
15602         ::std::mem::transmute(ucal_add(::std::mem::transmute(cal), ::std::mem::transmute(field), ::std::mem::transmute(amount), ::std::mem::transmute(status)))
15603     }
15604     #[cfg(not(windows))]
15605     unimplemented!("Unsupported target OS");
15606 }
15607 #[inline]
ucal_clear(calendar: *mut *mut ::std::ffi::c_void)15608 pub unsafe fn ucal_clear(calendar: *mut *mut ::std::ffi::c_void) {
15609     #[cfg(windows)]
15610     {
15611         #[link(name = "windows")]
15612         extern "system" {
15613             fn ucal_clear(calendar: *mut *mut ::std::ffi::c_void);
15614         }
15615         ::std::mem::transmute(ucal_clear(::std::mem::transmute(calendar)))
15616     }
15617     #[cfg(not(windows))]
15618     unimplemented!("Unsupported target OS");
15619 }
15620 #[inline]
ucal_clearField(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields)15621 pub unsafe fn ucal_clearField(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields) {
15622     #[cfg(windows)]
15623     {
15624         #[link(name = "windows")]
15625         extern "system" {
15626             fn ucal_clearField(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields);
15627         }
15628         ::std::mem::transmute(ucal_clearField(::std::mem::transmute(cal), ::std::mem::transmute(field)))
15629     }
15630     #[cfg(not(windows))]
15631     unimplemented!("Unsupported target OS");
15632 }
15633 #[inline]
ucal_clone(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void15634 pub unsafe fn ucal_clone(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
15635     #[cfg(windows)]
15636     {
15637         #[link(name = "windows")]
15638         extern "system" {
15639             fn ucal_clone(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
15640         }
15641         ::std::mem::transmute(ucal_clone(::std::mem::transmute(cal), ::std::mem::transmute(status)))
15642     }
15643     #[cfg(not(windows))]
15644     unimplemented!("Unsupported target OS");
15645 }
15646 #[inline]
ucal_close(cal: *mut *mut ::std::ffi::c_void)15647 pub unsafe fn ucal_close(cal: *mut *mut ::std::ffi::c_void) {
15648     #[cfg(windows)]
15649     {
15650         #[link(name = "windows")]
15651         extern "system" {
15652             fn ucal_close(cal: *mut *mut ::std::ffi::c_void);
15653         }
15654         ::std::mem::transmute(ucal_close(::std::mem::transmute(cal)))
15655     }
15656     #[cfg(not(windows))]
15657     unimplemented!("Unsupported target OS");
15658 }
15659 #[inline]
ucal_countAvailable() -> i3215660 pub unsafe fn ucal_countAvailable() -> i32 {
15661     #[cfg(windows)]
15662     {
15663         #[link(name = "windows")]
15664         extern "system" {
15665             fn ucal_countAvailable() -> i32;
15666         }
15667         ::std::mem::transmute(ucal_countAvailable())
15668     }
15669     #[cfg(not(windows))]
15670     unimplemented!("Unsupported target OS");
15671 }
15672 #[inline]
ucal_equivalentTo(cal1: *const *const ::std::ffi::c_void, cal2: *const *const ::std::ffi::c_void) -> i815673 pub unsafe fn ucal_equivalentTo(cal1: *const *const ::std::ffi::c_void, cal2: *const *const ::std::ffi::c_void) -> i8 {
15674     #[cfg(windows)]
15675     {
15676         #[link(name = "windows")]
15677         extern "system" {
15678             fn ucal_equivalentTo(cal1: *const *const ::std::ffi::c_void, cal2: *const *const ::std::ffi::c_void) -> i8;
15679         }
15680         ::std::mem::transmute(ucal_equivalentTo(::std::mem::transmute(cal1), ::std::mem::transmute(cal2)))
15681     }
15682     #[cfg(not(windows))]
15683     unimplemented!("Unsupported target OS");
15684 }
15685 #[inline]
ucal_get(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, status: *mut UErrorCode) -> i3215686 pub unsafe fn ucal_get(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, status: *mut UErrorCode) -> i32 {
15687     #[cfg(windows)]
15688     {
15689         #[link(name = "windows")]
15690         extern "system" {
15691             fn ucal_get(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, status: *mut UErrorCode) -> i32;
15692         }
15693         ::std::mem::transmute(ucal_get(::std::mem::transmute(cal), ::std::mem::transmute(field), ::std::mem::transmute(status)))
15694     }
15695     #[cfg(not(windows))]
15696     unimplemented!("Unsupported target OS");
15697 }
15698 #[inline]
ucal_getAttribute(cal: *const *const ::std::ffi::c_void, attr: UCalendarAttribute) -> i3215699 pub unsafe fn ucal_getAttribute(cal: *const *const ::std::ffi::c_void, attr: UCalendarAttribute) -> i32 {
15700     #[cfg(windows)]
15701     {
15702         #[link(name = "windows")]
15703         extern "system" {
15704             fn ucal_getAttribute(cal: *const *const ::std::ffi::c_void, attr: UCalendarAttribute) -> i32;
15705         }
15706         ::std::mem::transmute(ucal_getAttribute(::std::mem::transmute(cal), ::std::mem::transmute(attr)))
15707     }
15708     #[cfg(not(windows))]
15709     unimplemented!("Unsupported target OS");
15710 }
15711 #[cfg(feature = "Win32_Foundation")]
15712 #[inline]
ucal_getAvailable(localeindex: i32) -> super::Foundation::PSTR15713 pub unsafe fn ucal_getAvailable(localeindex: i32) -> super::Foundation::PSTR {
15714     #[cfg(windows)]
15715     {
15716         #[link(name = "windows")]
15717         extern "system" {
15718             fn ucal_getAvailable(localeindex: i32) -> super::Foundation::PSTR;
15719         }
15720         ::std::mem::transmute(ucal_getAvailable(::std::mem::transmute(localeindex)))
15721     }
15722     #[cfg(not(windows))]
15723     unimplemented!("Unsupported target OS");
15724 }
15725 #[inline]
ucal_getCanonicalTimeZoneID(id: *const u16, len: i32, result: *mut u16, resultcapacity: i32, issystemid: *mut i8, status: *mut UErrorCode) -> i3215726 pub unsafe fn ucal_getCanonicalTimeZoneID(id: *const u16, len: i32, result: *mut u16, resultcapacity: i32, issystemid: *mut i8, status: *mut UErrorCode) -> i32 {
15727     #[cfg(windows)]
15728     {
15729         #[link(name = "windows")]
15730         extern "system" {
15731             fn ucal_getCanonicalTimeZoneID(id: *const u16, len: i32, result: *mut u16, resultcapacity: i32, issystemid: *mut i8, status: *mut UErrorCode) -> i32;
15732         }
15733         ::std::mem::transmute(ucal_getCanonicalTimeZoneID(::std::mem::transmute(id), ::std::mem::transmute(len), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(issystemid), ::std::mem::transmute(status)))
15734     }
15735     #[cfg(not(windows))]
15736     unimplemented!("Unsupported target OS");
15737 }
15738 #[inline]
ucal_getDSTSavings(zoneid: *const u16, ec: *mut UErrorCode) -> i3215739 pub unsafe fn ucal_getDSTSavings(zoneid: *const u16, ec: *mut UErrorCode) -> i32 {
15740     #[cfg(windows)]
15741     {
15742         #[link(name = "windows")]
15743         extern "system" {
15744             fn ucal_getDSTSavings(zoneid: *const u16, ec: *mut UErrorCode) -> i32;
15745         }
15746         ::std::mem::transmute(ucal_getDSTSavings(::std::mem::transmute(zoneid), ::std::mem::transmute(ec)))
15747     }
15748     #[cfg(not(windows))]
15749     unimplemented!("Unsupported target OS");
15750 }
15751 #[inline]
ucal_getDayOfWeekType(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> UCalendarWeekdayType15752 pub unsafe fn ucal_getDayOfWeekType(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> UCalendarWeekdayType {
15753     #[cfg(windows)]
15754     {
15755         #[link(name = "windows")]
15756         extern "system" {
15757             fn ucal_getDayOfWeekType(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> UCalendarWeekdayType;
15758         }
15759         ::std::mem::transmute(ucal_getDayOfWeekType(::std::mem::transmute(cal), ::std::mem::transmute(dayofweek), ::std::mem::transmute(status)))
15760     }
15761     #[cfg(not(windows))]
15762     unimplemented!("Unsupported target OS");
15763 }
15764 #[inline]
ucal_getDefaultTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i3215765 pub unsafe fn ucal_getDefaultTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i32 {
15766     #[cfg(windows)]
15767     {
15768         #[link(name = "windows")]
15769         extern "system" {
15770             fn ucal_getDefaultTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i32;
15771         }
15772         ::std::mem::transmute(ucal_getDefaultTimeZone(::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(ec)))
15773     }
15774     #[cfg(not(windows))]
15775     unimplemented!("Unsupported target OS");
15776 }
15777 #[inline]
ucal_getFieldDifference(cal: *mut *mut ::std::ffi::c_void, target: f64, field: UCalendarDateFields, status: *mut UErrorCode) -> i3215778 pub unsafe fn ucal_getFieldDifference(cal: *mut *mut ::std::ffi::c_void, target: f64, field: UCalendarDateFields, status: *mut UErrorCode) -> i32 {
15779     #[cfg(windows)]
15780     {
15781         #[link(name = "windows")]
15782         extern "system" {
15783             fn ucal_getFieldDifference(cal: *mut *mut ::std::ffi::c_void, target: f64, field: UCalendarDateFields, status: *mut UErrorCode) -> i32;
15784         }
15785         ::std::mem::transmute(ucal_getFieldDifference(::std::mem::transmute(cal), ::std::mem::transmute(target), ::std::mem::transmute(field), ::std::mem::transmute(status)))
15786     }
15787     #[cfg(not(windows))]
15788     unimplemented!("Unsupported target OS");
15789 }
15790 #[inline]
ucal_getGregorianChange(cal: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> f6415791 pub unsafe fn ucal_getGregorianChange(cal: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> f64 {
15792     #[cfg(windows)]
15793     {
15794         #[link(name = "windows")]
15795         extern "system" {
15796             fn ucal_getGregorianChange(cal: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> f64;
15797         }
15798         ::std::mem::transmute(ucal_getGregorianChange(::std::mem::transmute(cal), ::std::mem::transmute(perrorcode)))
15799     }
15800     #[cfg(not(windows))]
15801     unimplemented!("Unsupported target OS");
15802 }
15803 #[inline]
ucal_getHostTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i3215804 pub unsafe fn ucal_getHostTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i32 {
15805     #[cfg(windows)]
15806     {
15807         #[link(name = "windows")]
15808         extern "system" {
15809             fn ucal_getHostTimeZone(result: *mut u16, resultcapacity: i32, ec: *mut UErrorCode) -> i32;
15810         }
15811         ::std::mem::transmute(ucal_getHostTimeZone(::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(ec)))
15812     }
15813     #[cfg(not(windows))]
15814     unimplemented!("Unsupported target OS");
15815 }
15816 #[cfg(feature = "Win32_Foundation")]
15817 #[inline]
ucal_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration15818 pub unsafe fn ucal_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration {
15819     #[cfg(windows)]
15820     {
15821         #[link(name = "windows")]
15822         extern "system" {
15823             fn ucal_getKeywordValuesForLocale(key: super::Foundation::PSTR, locale: super::Foundation::PSTR, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration;
15824         }
15825         ::std::mem::transmute(ucal_getKeywordValuesForLocale(key.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(commonlyused), ::std::mem::transmute(status)))
15826     }
15827     #[cfg(not(windows))]
15828     unimplemented!("Unsupported target OS");
15829 }
15830 #[inline]
ucal_getLimit(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, r#type: UCalendarLimitType, status: *mut UErrorCode) -> i3215831 pub unsafe fn ucal_getLimit(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, r#type: UCalendarLimitType, status: *mut UErrorCode) -> i32 {
15832     #[cfg(windows)]
15833     {
15834         #[link(name = "windows")]
15835         extern "system" {
15836             fn ucal_getLimit(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields, r#type: UCalendarLimitType, status: *mut UErrorCode) -> i32;
15837         }
15838         ::std::mem::transmute(ucal_getLimit(::std::mem::transmute(cal), ::std::mem::transmute(field), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
15839     }
15840     #[cfg(not(windows))]
15841     unimplemented!("Unsupported target OS");
15842 }
15843 #[cfg(feature = "Win32_Foundation")]
15844 #[inline]
ucal_getLocaleByType(cal: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR15845 pub unsafe fn ucal_getLocaleByType(cal: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
15846     #[cfg(windows)]
15847     {
15848         #[link(name = "windows")]
15849         extern "system" {
15850             fn ucal_getLocaleByType(cal: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
15851         }
15852         ::std::mem::transmute(ucal_getLocaleByType(::std::mem::transmute(cal), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
15853     }
15854     #[cfg(not(windows))]
15855     unimplemented!("Unsupported target OS");
15856 }
15857 #[inline]
ucal_getMillis(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f6415858 pub unsafe fn ucal_getMillis(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64 {
15859     #[cfg(windows)]
15860     {
15861         #[link(name = "windows")]
15862         extern "system" {
15863             fn ucal_getMillis(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64;
15864         }
15865         ::std::mem::transmute(ucal_getMillis(::std::mem::transmute(cal), ::std::mem::transmute(status)))
15866     }
15867     #[cfg(not(windows))]
15868     unimplemented!("Unsupported target OS");
15869 }
15870 #[inline]
ucal_getNow() -> f6415871 pub unsafe fn ucal_getNow() -> f64 {
15872     #[cfg(windows)]
15873     {
15874         #[link(name = "windows")]
15875         extern "system" {
15876             fn ucal_getNow() -> f64;
15877         }
15878         ::std::mem::transmute(ucal_getNow())
15879     }
15880     #[cfg(not(windows))]
15881     unimplemented!("Unsupported target OS");
15882 }
15883 #[cfg(feature = "Win32_Foundation")]
15884 #[inline]
ucal_getTZDataVersion(status: *mut UErrorCode) -> super::Foundation::PSTR15885 pub unsafe fn ucal_getTZDataVersion(status: *mut UErrorCode) -> super::Foundation::PSTR {
15886     #[cfg(windows)]
15887     {
15888         #[link(name = "windows")]
15889         extern "system" {
15890             fn ucal_getTZDataVersion(status: *mut UErrorCode) -> super::Foundation::PSTR;
15891         }
15892         ::std::mem::transmute(ucal_getTZDataVersion(::std::mem::transmute(status)))
15893     }
15894     #[cfg(not(windows))]
15895     unimplemented!("Unsupported target OS");
15896 }
15897 #[cfg(feature = "Win32_Foundation")]
15898 #[inline]
ucal_getTimeZoneDisplayName<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cal: *const *const ::std::ffi::c_void, r#type: UCalendarDisplayNameType, locale: Param2, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3215899 pub unsafe fn ucal_getTimeZoneDisplayName<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cal: *const *const ::std::ffi::c_void, r#type: UCalendarDisplayNameType, locale: Param2, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
15900     #[cfg(windows)]
15901     {
15902         #[link(name = "windows")]
15903         extern "system" {
15904             fn ucal_getTimeZoneDisplayName(cal: *const *const ::std::ffi::c_void, r#type: UCalendarDisplayNameType, locale: super::Foundation::PSTR, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
15905         }
15906         ::std::mem::transmute(ucal_getTimeZoneDisplayName(::std::mem::transmute(cal), ::std::mem::transmute(r#type), locale.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
15907     }
15908     #[cfg(not(windows))]
15909     unimplemented!("Unsupported target OS");
15910 }
15911 #[inline]
ucal_getTimeZoneID(cal: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3215912 pub unsafe fn ucal_getTimeZoneID(cal: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
15913     #[cfg(windows)]
15914     {
15915         #[link(name = "windows")]
15916         extern "system" {
15917             fn ucal_getTimeZoneID(cal: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
15918         }
15919         ::std::mem::transmute(ucal_getTimeZoneID(::std::mem::transmute(cal), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
15920     }
15921     #[cfg(not(windows))]
15922     unimplemented!("Unsupported target OS");
15923 }
15924 #[cfg(feature = "Win32_Foundation")]
15925 #[inline]
ucal_getTimeZoneIDForWindowsID<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(winid: *const u16, len: i32, region: Param2, id: *mut u16, idcapacity: i32, status: *mut UErrorCode) -> i3215926 pub unsafe fn ucal_getTimeZoneIDForWindowsID<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(winid: *const u16, len: i32, region: Param2, id: *mut u16, idcapacity: i32, status: *mut UErrorCode) -> i32 {
15927     #[cfg(windows)]
15928     {
15929         #[link(name = "windows")]
15930         extern "system" {
15931             fn ucal_getTimeZoneIDForWindowsID(winid: *const u16, len: i32, region: super::Foundation::PSTR, id: *mut u16, idcapacity: i32, status: *mut UErrorCode) -> i32;
15932         }
15933         ::std::mem::transmute(ucal_getTimeZoneIDForWindowsID(::std::mem::transmute(winid), ::std::mem::transmute(len), region.into_param().abi(), ::std::mem::transmute(id), ::std::mem::transmute(idcapacity), ::std::mem::transmute(status)))
15934     }
15935     #[cfg(not(windows))]
15936     unimplemented!("Unsupported target OS");
15937 }
15938 #[inline]
ucal_getTimeZoneTransitionDate(cal: *const *const ::std::ffi::c_void, r#type: UTimeZoneTransitionType, transition: *mut f64, status: *mut UErrorCode) -> i815939 pub unsafe fn ucal_getTimeZoneTransitionDate(cal: *const *const ::std::ffi::c_void, r#type: UTimeZoneTransitionType, transition: *mut f64, status: *mut UErrorCode) -> i8 {
15940     #[cfg(windows)]
15941     {
15942         #[link(name = "windows")]
15943         extern "system" {
15944             fn ucal_getTimeZoneTransitionDate(cal: *const *const ::std::ffi::c_void, r#type: UTimeZoneTransitionType, transition: *mut f64, status: *mut UErrorCode) -> i8;
15945         }
15946         ::std::mem::transmute(ucal_getTimeZoneTransitionDate(::std::mem::transmute(cal), ::std::mem::transmute(r#type), ::std::mem::transmute(transition), ::std::mem::transmute(status)))
15947     }
15948     #[cfg(not(windows))]
15949     unimplemented!("Unsupported target OS");
15950 }
15951 #[cfg(feature = "Win32_Foundation")]
15952 #[inline]
ucal_getType(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> super::Foundation::PSTR15953 pub unsafe fn ucal_getType(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> super::Foundation::PSTR {
15954     #[cfg(windows)]
15955     {
15956         #[link(name = "windows")]
15957         extern "system" {
15958             fn ucal_getType(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> super::Foundation::PSTR;
15959         }
15960         ::std::mem::transmute(ucal_getType(::std::mem::transmute(cal), ::std::mem::transmute(status)))
15961     }
15962     #[cfg(not(windows))]
15963     unimplemented!("Unsupported target OS");
15964 }
15965 #[inline]
ucal_getWeekendTransition(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> i3215966 pub unsafe fn ucal_getWeekendTransition(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> i32 {
15967     #[cfg(windows)]
15968     {
15969         #[link(name = "windows")]
15970         extern "system" {
15971             fn ucal_getWeekendTransition(cal: *const *const ::std::ffi::c_void, dayofweek: UCalendarDaysOfWeek, status: *mut UErrorCode) -> i32;
15972         }
15973         ::std::mem::transmute(ucal_getWeekendTransition(::std::mem::transmute(cal), ::std::mem::transmute(dayofweek), ::std::mem::transmute(status)))
15974     }
15975     #[cfg(not(windows))]
15976     unimplemented!("Unsupported target OS");
15977 }
15978 #[inline]
ucal_getWindowsTimeZoneID(id: *const u16, len: i32, winid: *mut u16, winidcapacity: i32, status: *mut UErrorCode) -> i3215979 pub unsafe fn ucal_getWindowsTimeZoneID(id: *const u16, len: i32, winid: *mut u16, winidcapacity: i32, status: *mut UErrorCode) -> i32 {
15980     #[cfg(windows)]
15981     {
15982         #[link(name = "windows")]
15983         extern "system" {
15984             fn ucal_getWindowsTimeZoneID(id: *const u16, len: i32, winid: *mut u16, winidcapacity: i32, status: *mut UErrorCode) -> i32;
15985         }
15986         ::std::mem::transmute(ucal_getWindowsTimeZoneID(::std::mem::transmute(id), ::std::mem::transmute(len), ::std::mem::transmute(winid), ::std::mem::transmute(winidcapacity), ::std::mem::transmute(status)))
15987     }
15988     #[cfg(not(windows))]
15989     unimplemented!("Unsupported target OS");
15990 }
15991 #[inline]
ucal_inDaylightTime(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i815992 pub unsafe fn ucal_inDaylightTime(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i8 {
15993     #[cfg(windows)]
15994     {
15995         #[link(name = "windows")]
15996         extern "system" {
15997             fn ucal_inDaylightTime(cal: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i8;
15998         }
15999         ::std::mem::transmute(ucal_inDaylightTime(::std::mem::transmute(cal), ::std::mem::transmute(status)))
16000     }
16001     #[cfg(not(windows))]
16002     unimplemented!("Unsupported target OS");
16003 }
16004 #[inline]
ucal_isSet(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields) -> i816005 pub unsafe fn ucal_isSet(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields) -> i8 {
16006     #[cfg(windows)]
16007     {
16008         #[link(name = "windows")]
16009         extern "system" {
16010             fn ucal_isSet(cal: *const *const ::std::ffi::c_void, field: UCalendarDateFields) -> i8;
16011         }
16012         ::std::mem::transmute(ucal_isSet(::std::mem::transmute(cal), ::std::mem::transmute(field)))
16013     }
16014     #[cfg(not(windows))]
16015     unimplemented!("Unsupported target OS");
16016 }
16017 #[inline]
ucal_isWeekend(cal: *const *const ::std::ffi::c_void, date: f64, status: *mut UErrorCode) -> i816018 pub unsafe fn ucal_isWeekend(cal: *const *const ::std::ffi::c_void, date: f64, status: *mut UErrorCode) -> i8 {
16019     #[cfg(windows)]
16020     {
16021         #[link(name = "windows")]
16022         extern "system" {
16023             fn ucal_isWeekend(cal: *const *const ::std::ffi::c_void, date: f64, status: *mut UErrorCode) -> i8;
16024         }
16025         ::std::mem::transmute(ucal_isWeekend(::std::mem::transmute(cal), ::std::mem::transmute(date), ::std::mem::transmute(status)))
16026     }
16027     #[cfg(not(windows))]
16028     unimplemented!("Unsupported target OS");
16029 }
16030 #[cfg(feature = "Win32_Foundation")]
16031 #[inline]
ucal_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(zoneid: *const u16, len: i32, locale: Param2, r#type: UCalendarType, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void16032 pub unsafe fn ucal_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(zoneid: *const u16, len: i32, locale: Param2, r#type: UCalendarType, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
16033     #[cfg(windows)]
16034     {
16035         #[link(name = "windows")]
16036         extern "system" {
16037             fn ucal_open(zoneid: *const u16, len: i32, locale: super::Foundation::PSTR, r#type: UCalendarType, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
16038         }
16039         ::std::mem::transmute(ucal_open(::std::mem::transmute(zoneid), ::std::mem::transmute(len), locale.into_param().abi(), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
16040     }
16041     #[cfg(not(windows))]
16042     unimplemented!("Unsupported target OS");
16043 }
16044 #[cfg(feature = "Win32_Foundation")]
16045 #[inline]
ucal_openCountryTimeZones<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(country: Param0, ec: *mut UErrorCode) -> *mut UEnumeration16046 pub unsafe fn ucal_openCountryTimeZones<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(country: Param0, ec: *mut UErrorCode) -> *mut UEnumeration {
16047     #[cfg(windows)]
16048     {
16049         #[link(name = "windows")]
16050         extern "system" {
16051             fn ucal_openCountryTimeZones(country: super::Foundation::PSTR, ec: *mut UErrorCode) -> *mut UEnumeration;
16052         }
16053         ::std::mem::transmute(ucal_openCountryTimeZones(country.into_param().abi(), ::std::mem::transmute(ec)))
16054     }
16055     #[cfg(not(windows))]
16056     unimplemented!("Unsupported target OS");
16057 }
16058 #[cfg(feature = "Win32_Foundation")]
16059 #[inline]
ucal_openTimeZoneIDEnumeration<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(zonetype: USystemTimeZoneType, region: Param1, rawoffset: *const i32, ec: *mut UErrorCode) -> *mut UEnumeration16060 pub unsafe fn ucal_openTimeZoneIDEnumeration<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(zonetype: USystemTimeZoneType, region: Param1, rawoffset: *const i32, ec: *mut UErrorCode) -> *mut UEnumeration {
16061     #[cfg(windows)]
16062     {
16063         #[link(name = "windows")]
16064         extern "system" {
16065             fn ucal_openTimeZoneIDEnumeration(zonetype: USystemTimeZoneType, region: super::Foundation::PSTR, rawoffset: *const i32, ec: *mut UErrorCode) -> *mut UEnumeration;
16066         }
16067         ::std::mem::transmute(ucal_openTimeZoneIDEnumeration(::std::mem::transmute(zonetype), region.into_param().abi(), ::std::mem::transmute(rawoffset), ::std::mem::transmute(ec)))
16068     }
16069     #[cfg(not(windows))]
16070     unimplemented!("Unsupported target OS");
16071 }
16072 #[inline]
ucal_openTimeZones(ec: *mut UErrorCode) -> *mut UEnumeration16073 pub unsafe fn ucal_openTimeZones(ec: *mut UErrorCode) -> *mut UEnumeration {
16074     #[cfg(windows)]
16075     {
16076         #[link(name = "windows")]
16077         extern "system" {
16078             fn ucal_openTimeZones(ec: *mut UErrorCode) -> *mut UEnumeration;
16079         }
16080         ::std::mem::transmute(ucal_openTimeZones(::std::mem::transmute(ec)))
16081     }
16082     #[cfg(not(windows))]
16083     unimplemented!("Unsupported target OS");
16084 }
16085 #[inline]
ucal_roll(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode)16086 pub unsafe fn ucal_roll(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode) {
16087     #[cfg(windows)]
16088     {
16089         #[link(name = "windows")]
16090         extern "system" {
16091             fn ucal_roll(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, amount: i32, status: *mut UErrorCode);
16092         }
16093         ::std::mem::transmute(ucal_roll(::std::mem::transmute(cal), ::std::mem::transmute(field), ::std::mem::transmute(amount), ::std::mem::transmute(status)))
16094     }
16095     #[cfg(not(windows))]
16096     unimplemented!("Unsupported target OS");
16097 }
16098 #[inline]
ucal_set(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, value: i32)16099 pub unsafe fn ucal_set(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, value: i32) {
16100     #[cfg(windows)]
16101     {
16102         #[link(name = "windows")]
16103         extern "system" {
16104             fn ucal_set(cal: *mut *mut ::std::ffi::c_void, field: UCalendarDateFields, value: i32);
16105         }
16106         ::std::mem::transmute(ucal_set(::std::mem::transmute(cal), ::std::mem::transmute(field), ::std::mem::transmute(value)))
16107     }
16108     #[cfg(not(windows))]
16109     unimplemented!("Unsupported target OS");
16110 }
16111 #[inline]
ucal_setAttribute(cal: *mut *mut ::std::ffi::c_void, attr: UCalendarAttribute, newvalue: i32)16112 pub unsafe fn ucal_setAttribute(cal: *mut *mut ::std::ffi::c_void, attr: UCalendarAttribute, newvalue: i32) {
16113     #[cfg(windows)]
16114     {
16115         #[link(name = "windows")]
16116         extern "system" {
16117             fn ucal_setAttribute(cal: *mut *mut ::std::ffi::c_void, attr: UCalendarAttribute, newvalue: i32);
16118         }
16119         ::std::mem::transmute(ucal_setAttribute(::std::mem::transmute(cal), ::std::mem::transmute(attr), ::std::mem::transmute(newvalue)))
16120     }
16121     #[cfg(not(windows))]
16122     unimplemented!("Unsupported target OS");
16123 }
16124 #[inline]
ucal_setDate(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, status: *mut UErrorCode)16125 pub unsafe fn ucal_setDate(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, status: *mut UErrorCode) {
16126     #[cfg(windows)]
16127     {
16128         #[link(name = "windows")]
16129         extern "system" {
16130             fn ucal_setDate(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, status: *mut UErrorCode);
16131         }
16132         ::std::mem::transmute(ucal_setDate(::std::mem::transmute(cal), ::std::mem::transmute(year), ::std::mem::transmute(month), ::std::mem::transmute(date), ::std::mem::transmute(status)))
16133     }
16134     #[cfg(not(windows))]
16135     unimplemented!("Unsupported target OS");
16136 }
16137 #[inline]
ucal_setDateTime(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, hour: i32, minute: i32, second: i32, status: *mut UErrorCode)16138 pub unsafe fn ucal_setDateTime(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, hour: i32, minute: i32, second: i32, status: *mut UErrorCode) {
16139     #[cfg(windows)]
16140     {
16141         #[link(name = "windows")]
16142         extern "system" {
16143             fn ucal_setDateTime(cal: *mut *mut ::std::ffi::c_void, year: i32, month: i32, date: i32, hour: i32, minute: i32, second: i32, status: *mut UErrorCode);
16144         }
16145         ::std::mem::transmute(ucal_setDateTime(::std::mem::transmute(cal), ::std::mem::transmute(year), ::std::mem::transmute(month), ::std::mem::transmute(date), ::std::mem::transmute(hour), ::std::mem::transmute(minute), ::std::mem::transmute(second), ::std::mem::transmute(status)))
16146     }
16147     #[cfg(not(windows))]
16148     unimplemented!("Unsupported target OS");
16149 }
16150 #[inline]
ucal_setDefaultTimeZone(zoneid: *const u16, ec: *mut UErrorCode)16151 pub unsafe fn ucal_setDefaultTimeZone(zoneid: *const u16, ec: *mut UErrorCode) {
16152     #[cfg(windows)]
16153     {
16154         #[link(name = "windows")]
16155         extern "system" {
16156             fn ucal_setDefaultTimeZone(zoneid: *const u16, ec: *mut UErrorCode);
16157         }
16158         ::std::mem::transmute(ucal_setDefaultTimeZone(::std::mem::transmute(zoneid), ::std::mem::transmute(ec)))
16159     }
16160     #[cfg(not(windows))]
16161     unimplemented!("Unsupported target OS");
16162 }
16163 #[inline]
ucal_setGregorianChange(cal: *mut *mut ::std::ffi::c_void, date: f64, perrorcode: *mut UErrorCode)16164 pub unsafe fn ucal_setGregorianChange(cal: *mut *mut ::std::ffi::c_void, date: f64, perrorcode: *mut UErrorCode) {
16165     #[cfg(windows)]
16166     {
16167         #[link(name = "windows")]
16168         extern "system" {
16169             fn ucal_setGregorianChange(cal: *mut *mut ::std::ffi::c_void, date: f64, perrorcode: *mut UErrorCode);
16170         }
16171         ::std::mem::transmute(ucal_setGregorianChange(::std::mem::transmute(cal), ::std::mem::transmute(date), ::std::mem::transmute(perrorcode)))
16172     }
16173     #[cfg(not(windows))]
16174     unimplemented!("Unsupported target OS");
16175 }
16176 #[inline]
ucal_setMillis(cal: *mut *mut ::std::ffi::c_void, datetime: f64, status: *mut UErrorCode)16177 pub unsafe fn ucal_setMillis(cal: *mut *mut ::std::ffi::c_void, datetime: f64, status: *mut UErrorCode) {
16178     #[cfg(windows)]
16179     {
16180         #[link(name = "windows")]
16181         extern "system" {
16182             fn ucal_setMillis(cal: *mut *mut ::std::ffi::c_void, datetime: f64, status: *mut UErrorCode);
16183         }
16184         ::std::mem::transmute(ucal_setMillis(::std::mem::transmute(cal), ::std::mem::transmute(datetime), ::std::mem::transmute(status)))
16185     }
16186     #[cfg(not(windows))]
16187     unimplemented!("Unsupported target OS");
16188 }
16189 #[inline]
ucal_setTimeZone(cal: *mut *mut ::std::ffi::c_void, zoneid: *const u16, len: i32, status: *mut UErrorCode)16190 pub unsafe fn ucal_setTimeZone(cal: *mut *mut ::std::ffi::c_void, zoneid: *const u16, len: i32, status: *mut UErrorCode) {
16191     #[cfg(windows)]
16192     {
16193         #[link(name = "windows")]
16194         extern "system" {
16195             fn ucal_setTimeZone(cal: *mut *mut ::std::ffi::c_void, zoneid: *const u16, len: i32, status: *mut UErrorCode);
16196         }
16197         ::std::mem::transmute(ucal_setTimeZone(::std::mem::transmute(cal), ::std::mem::transmute(zoneid), ::std::mem::transmute(len), ::std::mem::transmute(status)))
16198     }
16199     #[cfg(not(windows))]
16200     unimplemented!("Unsupported target OS");
16201 }
16202 #[inline]
ucasemap_close(csm: *mut UCaseMap)16203 pub unsafe fn ucasemap_close(csm: *mut UCaseMap) {
16204     #[cfg(windows)]
16205     {
16206         #[link(name = "windows")]
16207         extern "system" {
16208             fn ucasemap_close(csm: *mut UCaseMap);
16209         }
16210         ::std::mem::transmute(ucasemap_close(::std::mem::transmute(csm)))
16211     }
16212     #[cfg(not(windows))]
16213     unimplemented!("Unsupported target OS");
16214 }
16215 #[inline]
ucasemap_getBreakIterator(csm: *const UCaseMap) -> *mut UBreakIterator16216 pub unsafe fn ucasemap_getBreakIterator(csm: *const UCaseMap) -> *mut UBreakIterator {
16217     #[cfg(windows)]
16218     {
16219         #[link(name = "windows")]
16220         extern "system" {
16221             fn ucasemap_getBreakIterator(csm: *const UCaseMap) -> *mut UBreakIterator;
16222         }
16223         ::std::mem::transmute(ucasemap_getBreakIterator(::std::mem::transmute(csm)))
16224     }
16225     #[cfg(not(windows))]
16226     unimplemented!("Unsupported target OS");
16227 }
16228 #[cfg(feature = "Win32_Foundation")]
16229 #[inline]
ucasemap_getLocale(csm: *const UCaseMap) -> super::Foundation::PSTR16230 pub unsafe fn ucasemap_getLocale(csm: *const UCaseMap) -> super::Foundation::PSTR {
16231     #[cfg(windows)]
16232     {
16233         #[link(name = "windows")]
16234         extern "system" {
16235             fn ucasemap_getLocale(csm: *const UCaseMap) -> super::Foundation::PSTR;
16236         }
16237         ::std::mem::transmute(ucasemap_getLocale(::std::mem::transmute(csm)))
16238     }
16239     #[cfg(not(windows))]
16240     unimplemented!("Unsupported target OS");
16241 }
16242 #[inline]
ucasemap_getOptions(csm: *const UCaseMap) -> u3216243 pub unsafe fn ucasemap_getOptions(csm: *const UCaseMap) -> u32 {
16244     #[cfg(windows)]
16245     {
16246         #[link(name = "windows")]
16247         extern "system" {
16248             fn ucasemap_getOptions(csm: *const UCaseMap) -> u32;
16249         }
16250         ::std::mem::transmute(ucasemap_getOptions(::std::mem::transmute(csm)))
16251     }
16252     #[cfg(not(windows))]
16253     unimplemented!("Unsupported target OS");
16254 }
16255 #[cfg(feature = "Win32_Foundation")]
16256 #[inline]
ucasemap_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, options: u32, perrorcode: *mut UErrorCode) -> *mut UCaseMap16257 pub unsafe fn ucasemap_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, options: u32, perrorcode: *mut UErrorCode) -> *mut UCaseMap {
16258     #[cfg(windows)]
16259     {
16260         #[link(name = "windows")]
16261         extern "system" {
16262             fn ucasemap_open(locale: super::Foundation::PSTR, options: u32, perrorcode: *mut UErrorCode) -> *mut UCaseMap;
16263         }
16264         ::std::mem::transmute(ucasemap_open(locale.into_param().abi(), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
16265     }
16266     #[cfg(not(windows))]
16267     unimplemented!("Unsupported target OS");
16268 }
16269 #[inline]
ucasemap_setBreakIterator(csm: *mut UCaseMap, itertoadopt: *mut UBreakIterator, perrorcode: *mut UErrorCode)16270 pub unsafe fn ucasemap_setBreakIterator(csm: *mut UCaseMap, itertoadopt: *mut UBreakIterator, perrorcode: *mut UErrorCode) {
16271     #[cfg(windows)]
16272     {
16273         #[link(name = "windows")]
16274         extern "system" {
16275             fn ucasemap_setBreakIterator(csm: *mut UCaseMap, itertoadopt: *mut UBreakIterator, perrorcode: *mut UErrorCode);
16276         }
16277         ::std::mem::transmute(ucasemap_setBreakIterator(::std::mem::transmute(csm), ::std::mem::transmute(itertoadopt), ::std::mem::transmute(perrorcode)))
16278     }
16279     #[cfg(not(windows))]
16280     unimplemented!("Unsupported target OS");
16281 }
16282 #[cfg(feature = "Win32_Foundation")]
16283 #[inline]
ucasemap_setLocale<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *mut UCaseMap, locale: Param1, perrorcode: *mut UErrorCode)16284 pub unsafe fn ucasemap_setLocale<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *mut UCaseMap, locale: Param1, perrorcode: *mut UErrorCode) {
16285     #[cfg(windows)]
16286     {
16287         #[link(name = "windows")]
16288         extern "system" {
16289             fn ucasemap_setLocale(csm: *mut UCaseMap, locale: super::Foundation::PSTR, perrorcode: *mut UErrorCode);
16290         }
16291         ::std::mem::transmute(ucasemap_setLocale(::std::mem::transmute(csm), locale.into_param().abi(), ::std::mem::transmute(perrorcode)))
16292     }
16293     #[cfg(not(windows))]
16294     unimplemented!("Unsupported target OS");
16295 }
16296 #[inline]
ucasemap_setOptions(csm: *mut UCaseMap, options: u32, perrorcode: *mut UErrorCode)16297 pub unsafe fn ucasemap_setOptions(csm: *mut UCaseMap, options: u32, perrorcode: *mut UErrorCode) {
16298     #[cfg(windows)]
16299     {
16300         #[link(name = "windows")]
16301         extern "system" {
16302             fn ucasemap_setOptions(csm: *mut UCaseMap, options: u32, perrorcode: *mut UErrorCode);
16303         }
16304         ::std::mem::transmute(ucasemap_setOptions(::std::mem::transmute(csm), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
16305     }
16306     #[cfg(not(windows))]
16307     unimplemented!("Unsupported target OS");
16308 }
16309 #[inline]
ucasemap_toTitle(csm: *mut UCaseMap, dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i3216310 pub unsafe fn ucasemap_toTitle(csm: *mut UCaseMap, dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16311     #[cfg(windows)]
16312     {
16313         #[link(name = "windows")]
16314         extern "system" {
16315             fn ucasemap_toTitle(csm: *mut UCaseMap, dest: *mut u16, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16316         }
16317         ::std::mem::transmute(ucasemap_toTitle(::std::mem::transmute(csm), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16318     }
16319     #[cfg(not(windows))]
16320     unimplemented!("Unsupported target OS");
16321 }
16322 #[cfg(feature = "Win32_Foundation")]
16323 #[inline]
ucasemap_utf8FoldCase<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i3216324 pub unsafe fn ucasemap_utf8FoldCase<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16325     #[cfg(windows)]
16326     {
16327         #[link(name = "windows")]
16328         extern "system" {
16329             fn ucasemap_utf8FoldCase(csm: *const UCaseMap, dest: super::Foundation::PSTR, destcapacity: i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16330         }
16331         ::std::mem::transmute(ucasemap_utf8FoldCase(::std::mem::transmute(csm), dest.into_param().abi(), ::std::mem::transmute(destcapacity), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16332     }
16333     #[cfg(not(windows))]
16334     unimplemented!("Unsupported target OS");
16335 }
16336 #[cfg(feature = "Win32_Foundation")]
16337 #[inline]
ucasemap_utf8ToLower<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i3216338 pub unsafe fn ucasemap_utf8ToLower<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16339     #[cfg(windows)]
16340     {
16341         #[link(name = "windows")]
16342         extern "system" {
16343             fn ucasemap_utf8ToLower(csm: *const UCaseMap, dest: super::Foundation::PSTR, destcapacity: i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16344         }
16345         ::std::mem::transmute(ucasemap_utf8ToLower(::std::mem::transmute(csm), dest.into_param().abi(), ::std::mem::transmute(destcapacity), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16346     }
16347     #[cfg(not(windows))]
16348     unimplemented!("Unsupported target OS");
16349 }
16350 #[cfg(feature = "Win32_Foundation")]
16351 #[inline]
ucasemap_utf8ToTitle<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *mut UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i3216352 pub unsafe fn ucasemap_utf8ToTitle<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *mut UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16353     #[cfg(windows)]
16354     {
16355         #[link(name = "windows")]
16356         extern "system" {
16357             fn ucasemap_utf8ToTitle(csm: *mut UCaseMap, dest: super::Foundation::PSTR, destcapacity: i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16358         }
16359         ::std::mem::transmute(ucasemap_utf8ToTitle(::std::mem::transmute(csm), dest.into_param().abi(), ::std::mem::transmute(destcapacity), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16360     }
16361     #[cfg(not(windows))]
16362     unimplemented!("Unsupported target OS");
16363 }
16364 #[cfg(feature = "Win32_Foundation")]
16365 #[inline]
ucasemap_utf8ToUpper<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i3216366 pub unsafe fn ucasemap_utf8ToUpper<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(csm: *const UCaseMap, dest: Param1, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16367     #[cfg(windows)]
16368     {
16369         #[link(name = "windows")]
16370         extern "system" {
16371             fn ucasemap_utf8ToUpper(csm: *const UCaseMap, dest: super::Foundation::PSTR, destcapacity: i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16372         }
16373         ::std::mem::transmute(ucasemap_utf8ToUpper(::std::mem::transmute(csm), dest.into_param().abi(), ::std::mem::transmute(destcapacity), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16374     }
16375     #[cfg(not(windows))]
16376     unimplemented!("Unsupported target OS");
16377 }
16378 #[inline]
ucfpos_close(ucfpos: *mut UConstrainedFieldPosition)16379 pub unsafe fn ucfpos_close(ucfpos: *mut UConstrainedFieldPosition) {
16380     #[cfg(windows)]
16381     {
16382         #[link(name = "windows")]
16383         extern "system" {
16384             fn ucfpos_close(ucfpos: *mut UConstrainedFieldPosition);
16385         }
16386         ::std::mem::transmute(ucfpos_close(::std::mem::transmute(ucfpos)))
16387     }
16388     #[cfg(not(windows))]
16389     unimplemented!("Unsupported target OS");
16390 }
16391 #[inline]
ucfpos_constrainCategory(ucfpos: *mut UConstrainedFieldPosition, category: i32, ec: *mut UErrorCode)16392 pub unsafe fn ucfpos_constrainCategory(ucfpos: *mut UConstrainedFieldPosition, category: i32, ec: *mut UErrorCode) {
16393     #[cfg(windows)]
16394     {
16395         #[link(name = "windows")]
16396         extern "system" {
16397             fn ucfpos_constrainCategory(ucfpos: *mut UConstrainedFieldPosition, category: i32, ec: *mut UErrorCode);
16398         }
16399         ::std::mem::transmute(ucfpos_constrainCategory(::std::mem::transmute(ucfpos), ::std::mem::transmute(category), ::std::mem::transmute(ec)))
16400     }
16401     #[cfg(not(windows))]
16402     unimplemented!("Unsupported target OS");
16403 }
16404 #[inline]
ucfpos_constrainField(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode)16405 pub unsafe fn ucfpos_constrainField(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode) {
16406     #[cfg(windows)]
16407     {
16408         #[link(name = "windows")]
16409         extern "system" {
16410             fn ucfpos_constrainField(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode);
16411         }
16412         ::std::mem::transmute(ucfpos_constrainField(::std::mem::transmute(ucfpos), ::std::mem::transmute(category), ::std::mem::transmute(field), ::std::mem::transmute(ec)))
16413     }
16414     #[cfg(not(windows))]
16415     unimplemented!("Unsupported target OS");
16416 }
16417 #[inline]
ucfpos_getCategory(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i3216418 pub unsafe fn ucfpos_getCategory(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i32 {
16419     #[cfg(windows)]
16420     {
16421         #[link(name = "windows")]
16422         extern "system" {
16423             fn ucfpos_getCategory(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i32;
16424         }
16425         ::std::mem::transmute(ucfpos_getCategory(::std::mem::transmute(ucfpos), ::std::mem::transmute(ec)))
16426     }
16427     #[cfg(not(windows))]
16428     unimplemented!("Unsupported target OS");
16429 }
16430 #[inline]
ucfpos_getField(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i3216431 pub unsafe fn ucfpos_getField(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i32 {
16432     #[cfg(windows)]
16433     {
16434         #[link(name = "windows")]
16435         extern "system" {
16436             fn ucfpos_getField(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i32;
16437         }
16438         ::std::mem::transmute(ucfpos_getField(::std::mem::transmute(ucfpos), ::std::mem::transmute(ec)))
16439     }
16440     #[cfg(not(windows))]
16441     unimplemented!("Unsupported target OS");
16442 }
16443 #[inline]
ucfpos_getIndexes(ucfpos: *const UConstrainedFieldPosition, pstart: *mut i32, plimit: *mut i32, ec: *mut UErrorCode)16444 pub unsafe fn ucfpos_getIndexes(ucfpos: *const UConstrainedFieldPosition, pstart: *mut i32, plimit: *mut i32, ec: *mut UErrorCode) {
16445     #[cfg(windows)]
16446     {
16447         #[link(name = "windows")]
16448         extern "system" {
16449             fn ucfpos_getIndexes(ucfpos: *const UConstrainedFieldPosition, pstart: *mut i32, plimit: *mut i32, ec: *mut UErrorCode);
16450         }
16451         ::std::mem::transmute(ucfpos_getIndexes(::std::mem::transmute(ucfpos), ::std::mem::transmute(pstart), ::std::mem::transmute(plimit), ::std::mem::transmute(ec)))
16452     }
16453     #[cfg(not(windows))]
16454     unimplemented!("Unsupported target OS");
16455 }
16456 #[inline]
ucfpos_getInt64IterationContext(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i6416457 pub unsafe fn ucfpos_getInt64IterationContext(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i64 {
16458     #[cfg(windows)]
16459     {
16460         #[link(name = "windows")]
16461         extern "system" {
16462             fn ucfpos_getInt64IterationContext(ucfpos: *const UConstrainedFieldPosition, ec: *mut UErrorCode) -> i64;
16463         }
16464         ::std::mem::transmute(ucfpos_getInt64IterationContext(::std::mem::transmute(ucfpos), ::std::mem::transmute(ec)))
16465     }
16466     #[cfg(not(windows))]
16467     unimplemented!("Unsupported target OS");
16468 }
16469 #[inline]
ucfpos_matchesField(ucfpos: *const UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode) -> i816470 pub unsafe fn ucfpos_matchesField(ucfpos: *const UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode) -> i8 {
16471     #[cfg(windows)]
16472     {
16473         #[link(name = "windows")]
16474         extern "system" {
16475             fn ucfpos_matchesField(ucfpos: *const UConstrainedFieldPosition, category: i32, field: i32, ec: *mut UErrorCode) -> i8;
16476         }
16477         ::std::mem::transmute(ucfpos_matchesField(::std::mem::transmute(ucfpos), ::std::mem::transmute(category), ::std::mem::transmute(field), ::std::mem::transmute(ec)))
16478     }
16479     #[cfg(not(windows))]
16480     unimplemented!("Unsupported target OS");
16481 }
16482 #[inline]
ucfpos_open(ec: *mut UErrorCode) -> *mut UConstrainedFieldPosition16483 pub unsafe fn ucfpos_open(ec: *mut UErrorCode) -> *mut UConstrainedFieldPosition {
16484     #[cfg(windows)]
16485     {
16486         #[link(name = "windows")]
16487         extern "system" {
16488             fn ucfpos_open(ec: *mut UErrorCode) -> *mut UConstrainedFieldPosition;
16489         }
16490         ::std::mem::transmute(ucfpos_open(::std::mem::transmute(ec)))
16491     }
16492     #[cfg(not(windows))]
16493     unimplemented!("Unsupported target OS");
16494 }
16495 #[inline]
ucfpos_reset(ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode)16496 pub unsafe fn ucfpos_reset(ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode) {
16497     #[cfg(windows)]
16498     {
16499         #[link(name = "windows")]
16500         extern "system" {
16501             fn ucfpos_reset(ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode);
16502         }
16503         ::std::mem::transmute(ucfpos_reset(::std::mem::transmute(ucfpos), ::std::mem::transmute(ec)))
16504     }
16505     #[cfg(not(windows))]
16506     unimplemented!("Unsupported target OS");
16507 }
16508 #[inline]
ucfpos_setInt64IterationContext(ucfpos: *mut UConstrainedFieldPosition, context: i64, ec: *mut UErrorCode)16509 pub unsafe fn ucfpos_setInt64IterationContext(ucfpos: *mut UConstrainedFieldPosition, context: i64, ec: *mut UErrorCode) {
16510     #[cfg(windows)]
16511     {
16512         #[link(name = "windows")]
16513         extern "system" {
16514             fn ucfpos_setInt64IterationContext(ucfpos: *mut UConstrainedFieldPosition, context: i64, ec: *mut UErrorCode);
16515         }
16516         ::std::mem::transmute(ucfpos_setInt64IterationContext(::std::mem::transmute(ucfpos), ::std::mem::transmute(context), ::std::mem::transmute(ec)))
16517     }
16518     #[cfg(not(windows))]
16519     unimplemented!("Unsupported target OS");
16520 }
16521 #[inline]
ucfpos_setState(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, start: i32, limit: i32, ec: *mut UErrorCode)16522 pub unsafe fn ucfpos_setState(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, start: i32, limit: i32, ec: *mut UErrorCode) {
16523     #[cfg(windows)]
16524     {
16525         #[link(name = "windows")]
16526         extern "system" {
16527             fn ucfpos_setState(ucfpos: *mut UConstrainedFieldPosition, category: i32, field: i32, start: i32, limit: i32, ec: *mut UErrorCode);
16528         }
16529         ::std::mem::transmute(ucfpos_setState(::std::mem::transmute(ucfpos), ::std::mem::transmute(category), ::std::mem::transmute(field), ::std::mem::transmute(start), ::std::mem::transmute(limit), ::std::mem::transmute(ec)))
16530     }
16531     #[cfg(not(windows))]
16532     unimplemented!("Unsupported target OS");
16533 }
16534 #[cfg(feature = "Win32_Foundation")]
16535 #[inline]
ucnv_cbFromUWriteBytes<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(args: *mut UConverterFromUnicodeArgs, source: Param1, length: i32, offsetindex: i32, err: *mut UErrorCode)16536 pub unsafe fn ucnv_cbFromUWriteBytes<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(args: *mut UConverterFromUnicodeArgs, source: Param1, length: i32, offsetindex: i32, err: *mut UErrorCode) {
16537     #[cfg(windows)]
16538     {
16539         #[link(name = "windows")]
16540         extern "system" {
16541             fn ucnv_cbFromUWriteBytes(args: *mut UConverterFromUnicodeArgs, source: super::Foundation::PSTR, length: i32, offsetindex: i32, err: *mut UErrorCode);
16542         }
16543         ::std::mem::transmute(ucnv_cbFromUWriteBytes(::std::mem::transmute(args), source.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(offsetindex), ::std::mem::transmute(err)))
16544     }
16545     #[cfg(not(windows))]
16546     unimplemented!("Unsupported target OS");
16547 }
16548 #[cfg(feature = "Win32_Foundation")]
16549 #[inline]
ucnv_cbFromUWriteSub(args: *mut UConverterFromUnicodeArgs, offsetindex: i32, err: *mut UErrorCode)16550 pub unsafe fn ucnv_cbFromUWriteSub(args: *mut UConverterFromUnicodeArgs, offsetindex: i32, err: *mut UErrorCode) {
16551     #[cfg(windows)]
16552     {
16553         #[link(name = "windows")]
16554         extern "system" {
16555             fn ucnv_cbFromUWriteSub(args: *mut UConverterFromUnicodeArgs, offsetindex: i32, err: *mut UErrorCode);
16556         }
16557         ::std::mem::transmute(ucnv_cbFromUWriteSub(::std::mem::transmute(args), ::std::mem::transmute(offsetindex), ::std::mem::transmute(err)))
16558     }
16559     #[cfg(not(windows))]
16560     unimplemented!("Unsupported target OS");
16561 }
16562 #[cfg(feature = "Win32_Foundation")]
16563 #[inline]
ucnv_cbFromUWriteUChars(args: *mut UConverterFromUnicodeArgs, source: *const *const u16, sourcelimit: *const u16, offsetindex: i32, err: *mut UErrorCode)16564 pub unsafe fn ucnv_cbFromUWriteUChars(args: *mut UConverterFromUnicodeArgs, source: *const *const u16, sourcelimit: *const u16, offsetindex: i32, err: *mut UErrorCode) {
16565     #[cfg(windows)]
16566     {
16567         #[link(name = "windows")]
16568         extern "system" {
16569             fn ucnv_cbFromUWriteUChars(args: *mut UConverterFromUnicodeArgs, source: *const *const u16, sourcelimit: *const u16, offsetindex: i32, err: *mut UErrorCode);
16570         }
16571         ::std::mem::transmute(ucnv_cbFromUWriteUChars(::std::mem::transmute(args), ::std::mem::transmute(source), ::std::mem::transmute(sourcelimit), ::std::mem::transmute(offsetindex), ::std::mem::transmute(err)))
16572     }
16573     #[cfg(not(windows))]
16574     unimplemented!("Unsupported target OS");
16575 }
16576 #[cfg(feature = "Win32_Foundation")]
16577 #[inline]
ucnv_cbToUWriteSub(args: *mut UConverterToUnicodeArgs, offsetindex: i32, err: *mut UErrorCode)16578 pub unsafe fn ucnv_cbToUWriteSub(args: *mut UConverterToUnicodeArgs, offsetindex: i32, err: *mut UErrorCode) {
16579     #[cfg(windows)]
16580     {
16581         #[link(name = "windows")]
16582         extern "system" {
16583             fn ucnv_cbToUWriteSub(args: *mut UConverterToUnicodeArgs, offsetindex: i32, err: *mut UErrorCode);
16584         }
16585         ::std::mem::transmute(ucnv_cbToUWriteSub(::std::mem::transmute(args), ::std::mem::transmute(offsetindex), ::std::mem::transmute(err)))
16586     }
16587     #[cfg(not(windows))]
16588     unimplemented!("Unsupported target OS");
16589 }
16590 #[cfg(feature = "Win32_Foundation")]
16591 #[inline]
ucnv_cbToUWriteUChars(args: *mut UConverterToUnicodeArgs, source: *const u16, length: i32, offsetindex: i32, err: *mut UErrorCode)16592 pub unsafe fn ucnv_cbToUWriteUChars(args: *mut UConverterToUnicodeArgs, source: *const u16, length: i32, offsetindex: i32, err: *mut UErrorCode) {
16593     #[cfg(windows)]
16594     {
16595         #[link(name = "windows")]
16596         extern "system" {
16597             fn ucnv_cbToUWriteUChars(args: *mut UConverterToUnicodeArgs, source: *const u16, length: i32, offsetindex: i32, err: *mut UErrorCode);
16598         }
16599         ::std::mem::transmute(ucnv_cbToUWriteUChars(::std::mem::transmute(args), ::std::mem::transmute(source), ::std::mem::transmute(length), ::std::mem::transmute(offsetindex), ::std::mem::transmute(err)))
16600     }
16601     #[cfg(not(windows))]
16602     unimplemented!("Unsupported target OS");
16603 }
16604 #[inline]
ucnv_close(converter: *mut UConverter)16605 pub unsafe fn ucnv_close(converter: *mut UConverter) {
16606     #[cfg(windows)]
16607     {
16608         #[link(name = "windows")]
16609         extern "system" {
16610             fn ucnv_close(converter: *mut UConverter);
16611         }
16612         ::std::mem::transmute(ucnv_close(::std::mem::transmute(converter)))
16613     }
16614     #[cfg(not(windows))]
16615     unimplemented!("Unsupported target OS");
16616 }
16617 #[cfg(feature = "Win32_Foundation")]
16618 #[inline]
ucnv_compareNames<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name1: Param0, name2: Param1) -> i3216619 pub unsafe fn ucnv_compareNames<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name1: Param0, name2: Param1) -> i32 {
16620     #[cfg(windows)]
16621     {
16622         #[link(name = "windows")]
16623         extern "system" {
16624             fn ucnv_compareNames(name1: super::Foundation::PSTR, name2: super::Foundation::PSTR) -> i32;
16625         }
16626         ::std::mem::transmute(ucnv_compareNames(name1.into_param().abi(), name2.into_param().abi()))
16627     }
16628     #[cfg(not(windows))]
16629     unimplemented!("Unsupported target OS");
16630 }
16631 #[cfg(feature = "Win32_Foundation")]
16632 #[inline]
ucnv_convert<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(toconvertername: Param0, fromconvertername: Param1, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i3216633 pub unsafe fn ucnv_convert<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(toconvertername: Param0, fromconvertername: Param1, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32 {
16634     #[cfg(windows)]
16635     {
16636         #[link(name = "windows")]
16637         extern "system" {
16638             fn ucnv_convert(toconvertername: super::Foundation::PSTR, fromconvertername: super::Foundation::PSTR, target: super::Foundation::PSTR, targetcapacity: i32, source: super::Foundation::PSTR, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32;
16639         }
16640         ::std::mem::transmute(ucnv_convert(toconvertername.into_param().abi(), fromconvertername.into_param().abi(), target.into_param().abi(), ::std::mem::transmute(targetcapacity), source.into_param().abi(), ::std::mem::transmute(sourcelength), ::std::mem::transmute(perrorcode)))
16641     }
16642     #[cfg(not(windows))]
16643     unimplemented!("Unsupported target OS");
16644 }
16645 #[cfg(feature = "Win32_Foundation")]
16646 #[inline]
ucnv_convertEx<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(targetcnv: *mut UConverter, sourcecnv: *mut UConverter, target: *mut *mut i8, targetlimit: Param3, source: *const *const i8, sourcelimit: Param5, pivotstart: *mut u16, pivotsource: *mut *mut u16, pivottarget: *mut *mut u16, pivotlimit: *const u16, reset: i8, flush: i8, perrorcode: *mut UErrorCode)16647 pub unsafe fn ucnv_convertEx<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param5: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(targetcnv: *mut UConverter, sourcecnv: *mut UConverter, target: *mut *mut i8, targetlimit: Param3, source: *const *const i8, sourcelimit: Param5, pivotstart: *mut u16, pivotsource: *mut *mut u16, pivottarget: *mut *mut u16, pivotlimit: *const u16, reset: i8, flush: i8, perrorcode: *mut UErrorCode) {
16648     #[cfg(windows)]
16649     {
16650         #[link(name = "windows")]
16651         extern "system" {
16652             fn ucnv_convertEx(targetcnv: *mut UConverter, sourcecnv: *mut UConverter, target: *mut *mut i8, targetlimit: super::Foundation::PSTR, source: *const *const i8, sourcelimit: super::Foundation::PSTR, pivotstart: *mut u16, pivotsource: *mut *mut u16, pivottarget: *mut *mut u16, pivotlimit: *const u16, reset: i8, flush: i8, perrorcode: *mut UErrorCode);
16653         }
16654         ::std::mem::transmute(ucnv_convertEx(
16655             ::std::mem::transmute(targetcnv),
16656             ::std::mem::transmute(sourcecnv),
16657             ::std::mem::transmute(target),
16658             targetlimit.into_param().abi(),
16659             ::std::mem::transmute(source),
16660             sourcelimit.into_param().abi(),
16661             ::std::mem::transmute(pivotstart),
16662             ::std::mem::transmute(pivotsource),
16663             ::std::mem::transmute(pivottarget),
16664             ::std::mem::transmute(pivotlimit),
16665             ::std::mem::transmute(reset),
16666             ::std::mem::transmute(flush),
16667             ::std::mem::transmute(perrorcode),
16668         ))
16669     }
16670     #[cfg(not(windows))]
16671     unimplemented!("Unsupported target OS");
16672 }
16673 #[cfg(feature = "Win32_Foundation")]
16674 #[inline]
ucnv_countAliases<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, perrorcode: *mut UErrorCode) -> u1616675 pub unsafe fn ucnv_countAliases<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, perrorcode: *mut UErrorCode) -> u16 {
16676     #[cfg(windows)]
16677     {
16678         #[link(name = "windows")]
16679         extern "system" {
16680             fn ucnv_countAliases(alias: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> u16;
16681         }
16682         ::std::mem::transmute(ucnv_countAliases(alias.into_param().abi(), ::std::mem::transmute(perrorcode)))
16683     }
16684     #[cfg(not(windows))]
16685     unimplemented!("Unsupported target OS");
16686 }
16687 #[inline]
ucnv_countAvailable() -> i3216688 pub unsafe fn ucnv_countAvailable() -> i32 {
16689     #[cfg(windows)]
16690     {
16691         #[link(name = "windows")]
16692         extern "system" {
16693             fn ucnv_countAvailable() -> i32;
16694         }
16695         ::std::mem::transmute(ucnv_countAvailable())
16696     }
16697     #[cfg(not(windows))]
16698     unimplemented!("Unsupported target OS");
16699 }
16700 #[inline]
ucnv_countStandards() -> u1616701 pub unsafe fn ucnv_countStandards() -> u16 {
16702     #[cfg(windows)]
16703     {
16704         #[link(name = "windows")]
16705         extern "system" {
16706             fn ucnv_countStandards() -> u16;
16707         }
16708         ::std::mem::transmute(ucnv_countStandards())
16709     }
16710     #[cfg(not(windows))]
16711     unimplemented!("Unsupported target OS");
16712 }
16713 #[cfg(feature = "Win32_Foundation")]
16714 #[inline]
ucnv_detectUnicodeSignature<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(source: Param0, sourcelength: i32, signaturelength: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR16715 pub unsafe fn ucnv_detectUnicodeSignature<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(source: Param0, sourcelength: i32, signaturelength: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
16716     #[cfg(windows)]
16717     {
16718         #[link(name = "windows")]
16719         extern "system" {
16720             fn ucnv_detectUnicodeSignature(source: super::Foundation::PSTR, sourcelength: i32, signaturelength: *mut i32, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
16721         }
16722         ::std::mem::transmute(ucnv_detectUnicodeSignature(source.into_param().abi(), ::std::mem::transmute(sourcelength), ::std::mem::transmute(signaturelength), ::std::mem::transmute(perrorcode)))
16723     }
16724     #[cfg(not(windows))]
16725     unimplemented!("Unsupported target OS");
16726 }
16727 #[inline]
ucnv_fixFileSeparator(cnv: *const UConverter, source: *mut u16, sourcelen: i32)16728 pub unsafe fn ucnv_fixFileSeparator(cnv: *const UConverter, source: *mut u16, sourcelen: i32) {
16729     #[cfg(windows)]
16730     {
16731         #[link(name = "windows")]
16732         extern "system" {
16733             fn ucnv_fixFileSeparator(cnv: *const UConverter, source: *mut u16, sourcelen: i32);
16734         }
16735         ::std::mem::transmute(ucnv_fixFileSeparator(::std::mem::transmute(cnv), ::std::mem::transmute(source), ::std::mem::transmute(sourcelen)))
16736     }
16737     #[cfg(not(windows))]
16738     unimplemented!("Unsupported target OS");
16739 }
16740 #[inline]
ucnv_flushCache() -> i3216741 pub unsafe fn ucnv_flushCache() -> i32 {
16742     #[cfg(windows)]
16743     {
16744         #[link(name = "windows")]
16745         extern "system" {
16746             fn ucnv_flushCache() -> i32;
16747         }
16748         ::std::mem::transmute(ucnv_flushCache())
16749     }
16750     #[cfg(not(windows))]
16751     unimplemented!("Unsupported target OS");
16752 }
16753 #[cfg(feature = "Win32_Foundation")]
16754 #[inline]
ucnv_fromAlgorithmic<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, algorithmictype: UConverterType, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i3216755 pub unsafe fn ucnv_fromAlgorithmic<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, algorithmictype: UConverterType, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32 {
16756     #[cfg(windows)]
16757     {
16758         #[link(name = "windows")]
16759         extern "system" {
16760             fn ucnv_fromAlgorithmic(cnv: *mut UConverter, algorithmictype: UConverterType, target: super::Foundation::PSTR, targetcapacity: i32, source: super::Foundation::PSTR, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32;
16761         }
16762         ::std::mem::transmute(ucnv_fromAlgorithmic(::std::mem::transmute(cnv), ::std::mem::transmute(algorithmictype), target.into_param().abi(), ::std::mem::transmute(targetcapacity), source.into_param().abi(), ::std::mem::transmute(sourcelength), ::std::mem::transmute(perrorcode)))
16763     }
16764     #[cfg(not(windows))]
16765     unimplemented!("Unsupported target OS");
16766 }
16767 #[cfg(feature = "Win32_Foundation")]
16768 #[inline]
ucnv_fromUChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, dest: Param1, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i3216769 pub unsafe fn ucnv_fromUChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, dest: Param1, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
16770     #[cfg(windows)]
16771     {
16772         #[link(name = "windows")]
16773         extern "system" {
16774             fn ucnv_fromUChars(cnv: *mut UConverter, dest: super::Foundation::PSTR, destcapacity: i32, src: *const u16, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
16775         }
16776         ::std::mem::transmute(ucnv_fromUChars(::std::mem::transmute(cnv), dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
16777     }
16778     #[cfg(not(windows))]
16779     unimplemented!("Unsupported target OS");
16780 }
16781 #[inline]
ucnv_fromUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i3216782 pub unsafe fn ucnv_fromUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i32 {
16783     #[cfg(windows)]
16784     {
16785         #[link(name = "windows")]
16786         extern "system" {
16787             fn ucnv_fromUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i32;
16788         }
16789         ::std::mem::transmute(ucnv_fromUCountPending(::std::mem::transmute(cnv), ::std::mem::transmute(status)))
16790     }
16791     #[cfg(not(windows))]
16792     unimplemented!("Unsupported target OS");
16793 }
16794 #[cfg(feature = "Win32_Foundation")]
16795 #[inline]
ucnv_fromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, target: *mut *mut i8, targetlimit: Param2, source: *const *const u16, sourcelimit: *const u16, offsets: *mut i32, flush: i8, err: *mut UErrorCode)16796 pub unsafe fn ucnv_fromUnicode<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, target: *mut *mut i8, targetlimit: Param2, source: *const *const u16, sourcelimit: *const u16, offsets: *mut i32, flush: i8, err: *mut UErrorCode) {
16797     #[cfg(windows)]
16798     {
16799         #[link(name = "windows")]
16800         extern "system" {
16801             fn ucnv_fromUnicode(converter: *mut UConverter, target: *mut *mut i8, targetlimit: super::Foundation::PSTR, source: *const *const u16, sourcelimit: *const u16, offsets: *mut i32, flush: i8, err: *mut UErrorCode);
16802         }
16803         ::std::mem::transmute(ucnv_fromUnicode(::std::mem::transmute(converter), ::std::mem::transmute(target), targetlimit.into_param().abi(), ::std::mem::transmute(source), ::std::mem::transmute(sourcelimit), ::std::mem::transmute(offsets), ::std::mem::transmute(flush), ::std::mem::transmute(err)))
16804     }
16805     #[cfg(not(windows))]
16806     unimplemented!("Unsupported target OS");
16807 }
16808 #[cfg(feature = "Win32_Foundation")]
16809 #[inline]
ucnv_getAlias<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR16810 pub unsafe fn ucnv_getAlias<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
16811     #[cfg(windows)]
16812     {
16813         #[link(name = "windows")]
16814         extern "system" {
16815             fn ucnv_getAlias(alias: super::Foundation::PSTR, n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
16816         }
16817         ::std::mem::transmute(ucnv_getAlias(alias.into_param().abi(), ::std::mem::transmute(n), ::std::mem::transmute(perrorcode)))
16818     }
16819     #[cfg(not(windows))]
16820     unimplemented!("Unsupported target OS");
16821 }
16822 #[cfg(feature = "Win32_Foundation")]
16823 #[inline]
ucnv_getAliases<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, aliases: *const *const i8, perrorcode: *mut UErrorCode)16824 pub unsafe fn ucnv_getAliases<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, aliases: *const *const i8, perrorcode: *mut UErrorCode) {
16825     #[cfg(windows)]
16826     {
16827         #[link(name = "windows")]
16828         extern "system" {
16829             fn ucnv_getAliases(alias: super::Foundation::PSTR, aliases: *const *const i8, perrorcode: *mut UErrorCode);
16830         }
16831         ::std::mem::transmute(ucnv_getAliases(alias.into_param().abi(), ::std::mem::transmute(aliases), ::std::mem::transmute(perrorcode)))
16832     }
16833     #[cfg(not(windows))]
16834     unimplemented!("Unsupported target OS");
16835 }
16836 #[cfg(feature = "Win32_Foundation")]
16837 #[inline]
ucnv_getAvailableName(n: i32) -> super::Foundation::PSTR16838 pub unsafe fn ucnv_getAvailableName(n: i32) -> super::Foundation::PSTR {
16839     #[cfg(windows)]
16840     {
16841         #[link(name = "windows")]
16842         extern "system" {
16843             fn ucnv_getAvailableName(n: i32) -> super::Foundation::PSTR;
16844         }
16845         ::std::mem::transmute(ucnv_getAvailableName(::std::mem::transmute(n)))
16846     }
16847     #[cfg(not(windows))]
16848     unimplemented!("Unsupported target OS");
16849 }
16850 #[inline]
ucnv_getCCSID(converter: *const UConverter, err: *mut UErrorCode) -> i3216851 pub unsafe fn ucnv_getCCSID(converter: *const UConverter, err: *mut UErrorCode) -> i32 {
16852     #[cfg(windows)]
16853     {
16854         #[link(name = "windows")]
16855         extern "system" {
16856             fn ucnv_getCCSID(converter: *const UConverter, err: *mut UErrorCode) -> i32;
16857         }
16858         ::std::mem::transmute(ucnv_getCCSID(::std::mem::transmute(converter), ::std::mem::transmute(err)))
16859     }
16860     #[cfg(not(windows))]
16861     unimplemented!("Unsupported target OS");
16862 }
16863 #[cfg(feature = "Win32_Foundation")]
16864 #[inline]
ucnv_getCanonicalName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR16865 pub unsafe fn ucnv_getCanonicalName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(alias: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
16866     #[cfg(windows)]
16867     {
16868         #[link(name = "windows")]
16869         extern "system" {
16870             fn ucnv_getCanonicalName(alias: super::Foundation::PSTR, standard: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
16871         }
16872         ::std::mem::transmute(ucnv_getCanonicalName(alias.into_param().abi(), standard.into_param().abi(), ::std::mem::transmute(perrorcode)))
16873     }
16874     #[cfg(not(windows))]
16875     unimplemented!("Unsupported target OS");
16876 }
16877 #[cfg(feature = "Win32_Foundation")]
16878 #[inline]
ucnv_getDefaultName() -> super::Foundation::PSTR16879 pub unsafe fn ucnv_getDefaultName() -> super::Foundation::PSTR {
16880     #[cfg(windows)]
16881     {
16882         #[link(name = "windows")]
16883         extern "system" {
16884             fn ucnv_getDefaultName() -> super::Foundation::PSTR;
16885         }
16886         ::std::mem::transmute(ucnv_getDefaultName())
16887     }
16888     #[cfg(not(windows))]
16889     unimplemented!("Unsupported target OS");
16890 }
16891 #[cfg(feature = "Win32_Foundation")]
16892 #[inline]
ucnv_getDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, displaylocale: Param1, displayname: *mut u16, displaynamecapacity: i32, err: *mut UErrorCode) -> i3216893 pub unsafe fn ucnv_getDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, displaylocale: Param1, displayname: *mut u16, displaynamecapacity: i32, err: *mut UErrorCode) -> i32 {
16894     #[cfg(windows)]
16895     {
16896         #[link(name = "windows")]
16897         extern "system" {
16898             fn ucnv_getDisplayName(converter: *const UConverter, displaylocale: super::Foundation::PSTR, displayname: *mut u16, displaynamecapacity: i32, err: *mut UErrorCode) -> i32;
16899         }
16900         ::std::mem::transmute(ucnv_getDisplayName(::std::mem::transmute(converter), displaylocale.into_param().abi(), ::std::mem::transmute(displayname), ::std::mem::transmute(displaynamecapacity), ::std::mem::transmute(err)))
16901     }
16902     #[cfg(not(windows))]
16903     unimplemented!("Unsupported target OS");
16904 }
16905 #[cfg(feature = "Win32_Foundation")]
16906 #[inline]
ucnv_getFromUCallBack(converter: *const UConverter, action: *mut ::std::option::Option<UConverterFromUCallback>, context: *const *const ::std::ffi::c_void)16907 pub unsafe fn ucnv_getFromUCallBack(converter: *const UConverter, action: *mut ::std::option::Option<UConverterFromUCallback>, context: *const *const ::std::ffi::c_void) {
16908     #[cfg(windows)]
16909     {
16910         #[link(name = "windows")]
16911         extern "system" {
16912             fn ucnv_getFromUCallBack(converter: *const UConverter, action: *mut ::windows::runtime::RawPtr, context: *const *const ::std::ffi::c_void);
16913         }
16914         ::std::mem::transmute(ucnv_getFromUCallBack(::std::mem::transmute(converter), ::std::mem::transmute(action), ::std::mem::transmute(context)))
16915     }
16916     #[cfg(not(windows))]
16917     unimplemented!("Unsupported target OS");
16918 }
16919 #[cfg(feature = "Win32_Foundation")]
16920 #[inline]
ucnv_getInvalidChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, errbytes: Param1, len: *mut i8, err: *mut UErrorCode)16921 pub unsafe fn ucnv_getInvalidChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, errbytes: Param1, len: *mut i8, err: *mut UErrorCode) {
16922     #[cfg(windows)]
16923     {
16924         #[link(name = "windows")]
16925         extern "system" {
16926             fn ucnv_getInvalidChars(converter: *const UConverter, errbytes: super::Foundation::PSTR, len: *mut i8, err: *mut UErrorCode);
16927         }
16928         ::std::mem::transmute(ucnv_getInvalidChars(::std::mem::transmute(converter), errbytes.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(err)))
16929     }
16930     #[cfg(not(windows))]
16931     unimplemented!("Unsupported target OS");
16932 }
16933 #[inline]
ucnv_getInvalidUChars(converter: *const UConverter, erruchars: *mut u16, len: *mut i8, err: *mut UErrorCode)16934 pub unsafe fn ucnv_getInvalidUChars(converter: *const UConverter, erruchars: *mut u16, len: *mut i8, err: *mut UErrorCode) {
16935     #[cfg(windows)]
16936     {
16937         #[link(name = "windows")]
16938         extern "system" {
16939             fn ucnv_getInvalidUChars(converter: *const UConverter, erruchars: *mut u16, len: *mut i8, err: *mut UErrorCode);
16940         }
16941         ::std::mem::transmute(ucnv_getInvalidUChars(::std::mem::transmute(converter), ::std::mem::transmute(erruchars), ::std::mem::transmute(len), ::std::mem::transmute(err)))
16942     }
16943     #[cfg(not(windows))]
16944     unimplemented!("Unsupported target OS");
16945 }
16946 #[inline]
ucnv_getMaxCharSize(converter: *const UConverter) -> i816947 pub unsafe fn ucnv_getMaxCharSize(converter: *const UConverter) -> i8 {
16948     #[cfg(windows)]
16949     {
16950         #[link(name = "windows")]
16951         extern "system" {
16952             fn ucnv_getMaxCharSize(converter: *const UConverter) -> i8;
16953         }
16954         ::std::mem::transmute(ucnv_getMaxCharSize(::std::mem::transmute(converter)))
16955     }
16956     #[cfg(not(windows))]
16957     unimplemented!("Unsupported target OS");
16958 }
16959 #[inline]
ucnv_getMinCharSize(converter: *const UConverter) -> i816960 pub unsafe fn ucnv_getMinCharSize(converter: *const UConverter) -> i8 {
16961     #[cfg(windows)]
16962     {
16963         #[link(name = "windows")]
16964         extern "system" {
16965             fn ucnv_getMinCharSize(converter: *const UConverter) -> i8;
16966         }
16967         ::std::mem::transmute(ucnv_getMinCharSize(::std::mem::transmute(converter)))
16968     }
16969     #[cfg(not(windows))]
16970     unimplemented!("Unsupported target OS");
16971 }
16972 #[cfg(feature = "Win32_Foundation")]
16973 #[inline]
ucnv_getName(converter: *const UConverter, err: *mut UErrorCode) -> super::Foundation::PSTR16974 pub unsafe fn ucnv_getName(converter: *const UConverter, err: *mut UErrorCode) -> super::Foundation::PSTR {
16975     #[cfg(windows)]
16976     {
16977         #[link(name = "windows")]
16978         extern "system" {
16979             fn ucnv_getName(converter: *const UConverter, err: *mut UErrorCode) -> super::Foundation::PSTR;
16980         }
16981         ::std::mem::transmute(ucnv_getName(::std::mem::transmute(converter), ::std::mem::transmute(err)))
16982     }
16983     #[cfg(not(windows))]
16984     unimplemented!("Unsupported target OS");
16985 }
16986 #[cfg(feature = "Win32_Foundation")]
16987 #[inline]
ucnv_getNextUChar<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, source: *const *const i8, sourcelimit: Param2, err: *mut UErrorCode) -> i3216988 pub unsafe fn ucnv_getNextUChar<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, source: *const *const i8, sourcelimit: Param2, err: *mut UErrorCode) -> i32 {
16989     #[cfg(windows)]
16990     {
16991         #[link(name = "windows")]
16992         extern "system" {
16993             fn ucnv_getNextUChar(converter: *mut UConverter, source: *const *const i8, sourcelimit: super::Foundation::PSTR, err: *mut UErrorCode) -> i32;
16994         }
16995         ::std::mem::transmute(ucnv_getNextUChar(::std::mem::transmute(converter), ::std::mem::transmute(source), sourcelimit.into_param().abi(), ::std::mem::transmute(err)))
16996     }
16997     #[cfg(not(windows))]
16998     unimplemented!("Unsupported target OS");
16999 }
17000 #[inline]
ucnv_getPlatform(converter: *const UConverter, err: *mut UErrorCode) -> UConverterPlatform17001 pub unsafe fn ucnv_getPlatform(converter: *const UConverter, err: *mut UErrorCode) -> UConverterPlatform {
17002     #[cfg(windows)]
17003     {
17004         #[link(name = "windows")]
17005         extern "system" {
17006             fn ucnv_getPlatform(converter: *const UConverter, err: *mut UErrorCode) -> UConverterPlatform;
17007         }
17008         ::std::mem::transmute(ucnv_getPlatform(::std::mem::transmute(converter), ::std::mem::transmute(err)))
17009     }
17010     #[cfg(not(windows))]
17011     unimplemented!("Unsupported target OS");
17012 }
17013 #[cfg(feature = "Win32_Foundation")]
17014 #[inline]
ucnv_getStandard(n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR17015 pub unsafe fn ucnv_getStandard(n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
17016     #[cfg(windows)]
17017     {
17018         #[link(name = "windows")]
17019         extern "system" {
17020             fn ucnv_getStandard(n: u16, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
17021         }
17022         ::std::mem::transmute(ucnv_getStandard(::std::mem::transmute(n), ::std::mem::transmute(perrorcode)))
17023     }
17024     #[cfg(not(windows))]
17025     unimplemented!("Unsupported target OS");
17026 }
17027 #[cfg(feature = "Win32_Foundation")]
17028 #[inline]
ucnv_getStandardName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR17029 pub unsafe fn ucnv_getStandardName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR {
17030     #[cfg(windows)]
17031     {
17032         #[link(name = "windows")]
17033         extern "system" {
17034             fn ucnv_getStandardName(name: super::Foundation::PSTR, standard: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> super::Foundation::PSTR;
17035         }
17036         ::std::mem::transmute(ucnv_getStandardName(name.into_param().abi(), standard.into_param().abi(), ::std::mem::transmute(perrorcode)))
17037     }
17038     #[cfg(not(windows))]
17039     unimplemented!("Unsupported target OS");
17040 }
17041 #[inline]
ucnv_getStarters(converter: *const UConverter, starters: *mut i8, err: *mut UErrorCode)17042 pub unsafe fn ucnv_getStarters(converter: *const UConverter, starters: *mut i8, err: *mut UErrorCode) {
17043     #[cfg(windows)]
17044     {
17045         #[link(name = "windows")]
17046         extern "system" {
17047             fn ucnv_getStarters(converter: *const UConverter, starters: *mut i8, err: *mut UErrorCode);
17048         }
17049         ::std::mem::transmute(ucnv_getStarters(::std::mem::transmute(converter), ::std::mem::transmute(starters), ::std::mem::transmute(err)))
17050     }
17051     #[cfg(not(windows))]
17052     unimplemented!("Unsupported target OS");
17053 }
17054 #[cfg(feature = "Win32_Foundation")]
17055 #[inline]
ucnv_getSubstChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, subchars: Param1, len: *mut i8, err: *mut UErrorCode)17056 pub unsafe fn ucnv_getSubstChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *const UConverter, subchars: Param1, len: *mut i8, err: *mut UErrorCode) {
17057     #[cfg(windows)]
17058     {
17059         #[link(name = "windows")]
17060         extern "system" {
17061             fn ucnv_getSubstChars(converter: *const UConverter, subchars: super::Foundation::PSTR, len: *mut i8, err: *mut UErrorCode);
17062         }
17063         ::std::mem::transmute(ucnv_getSubstChars(::std::mem::transmute(converter), subchars.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(err)))
17064     }
17065     #[cfg(not(windows))]
17066     unimplemented!("Unsupported target OS");
17067 }
17068 #[cfg(feature = "Win32_Foundation")]
17069 #[inline]
ucnv_getToUCallBack(converter: *const UConverter, action: *mut ::std::option::Option<UConverterToUCallback>, context: *const *const ::std::ffi::c_void)17070 pub unsafe fn ucnv_getToUCallBack(converter: *const UConverter, action: *mut ::std::option::Option<UConverterToUCallback>, context: *const *const ::std::ffi::c_void) {
17071     #[cfg(windows)]
17072     {
17073         #[link(name = "windows")]
17074         extern "system" {
17075             fn ucnv_getToUCallBack(converter: *const UConverter, action: *mut ::windows::runtime::RawPtr, context: *const *const ::std::ffi::c_void);
17076         }
17077         ::std::mem::transmute(ucnv_getToUCallBack(::std::mem::transmute(converter), ::std::mem::transmute(action), ::std::mem::transmute(context)))
17078     }
17079     #[cfg(not(windows))]
17080     unimplemented!("Unsupported target OS");
17081 }
17082 #[inline]
ucnv_getType(converter: *const UConverter) -> UConverterType17083 pub unsafe fn ucnv_getType(converter: *const UConverter) -> UConverterType {
17084     #[cfg(windows)]
17085     {
17086         #[link(name = "windows")]
17087         extern "system" {
17088             fn ucnv_getType(converter: *const UConverter) -> UConverterType;
17089         }
17090         ::std::mem::transmute(ucnv_getType(::std::mem::transmute(converter)))
17091     }
17092     #[cfg(not(windows))]
17093     unimplemented!("Unsupported target OS");
17094 }
17095 #[inline]
ucnv_getUnicodeSet(cnv: *const UConverter, setfillin: *mut USet, whichset: UConverterUnicodeSet, perrorcode: *mut UErrorCode)17096 pub unsafe fn ucnv_getUnicodeSet(cnv: *const UConverter, setfillin: *mut USet, whichset: UConverterUnicodeSet, perrorcode: *mut UErrorCode) {
17097     #[cfg(windows)]
17098     {
17099         #[link(name = "windows")]
17100         extern "system" {
17101             fn ucnv_getUnicodeSet(cnv: *const UConverter, setfillin: *mut USet, whichset: UConverterUnicodeSet, perrorcode: *mut UErrorCode);
17102         }
17103         ::std::mem::transmute(ucnv_getUnicodeSet(::std::mem::transmute(cnv), ::std::mem::transmute(setfillin), ::std::mem::transmute(whichset), ::std::mem::transmute(perrorcode)))
17104     }
17105     #[cfg(not(windows))]
17106     unimplemented!("Unsupported target OS");
17107 }
17108 #[inline]
ucnv_isAmbiguous(cnv: *const UConverter) -> i817109 pub unsafe fn ucnv_isAmbiguous(cnv: *const UConverter) -> i8 {
17110     #[cfg(windows)]
17111     {
17112         #[link(name = "windows")]
17113         extern "system" {
17114             fn ucnv_isAmbiguous(cnv: *const UConverter) -> i8;
17115         }
17116         ::std::mem::transmute(ucnv_isAmbiguous(::std::mem::transmute(cnv)))
17117     }
17118     #[cfg(not(windows))]
17119     unimplemented!("Unsupported target OS");
17120 }
17121 #[inline]
ucnv_isFixedWidth(cnv: *mut UConverter, status: *mut UErrorCode) -> i817122 pub unsafe fn ucnv_isFixedWidth(cnv: *mut UConverter, status: *mut UErrorCode) -> i8 {
17123     #[cfg(windows)]
17124     {
17125         #[link(name = "windows")]
17126         extern "system" {
17127             fn ucnv_isFixedWidth(cnv: *mut UConverter, status: *mut UErrorCode) -> i8;
17128         }
17129         ::std::mem::transmute(ucnv_isFixedWidth(::std::mem::transmute(cnv), ::std::mem::transmute(status)))
17130     }
17131     #[cfg(not(windows))]
17132     unimplemented!("Unsupported target OS");
17133 }
17134 #[cfg(feature = "Win32_Foundation")]
17135 #[inline]
ucnv_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(convertername: Param0, err: *mut UErrorCode) -> *mut UConverter17136 pub unsafe fn ucnv_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(convertername: Param0, err: *mut UErrorCode) -> *mut UConverter {
17137     #[cfg(windows)]
17138     {
17139         #[link(name = "windows")]
17140         extern "system" {
17141             fn ucnv_open(convertername: super::Foundation::PSTR, err: *mut UErrorCode) -> *mut UConverter;
17142         }
17143         ::std::mem::transmute(ucnv_open(convertername.into_param().abi(), ::std::mem::transmute(err)))
17144     }
17145     #[cfg(not(windows))]
17146     unimplemented!("Unsupported target OS");
17147 }
17148 #[inline]
ucnv_openAllNames(perrorcode: *mut UErrorCode) -> *mut UEnumeration17149 pub unsafe fn ucnv_openAllNames(perrorcode: *mut UErrorCode) -> *mut UEnumeration {
17150     #[cfg(windows)]
17151     {
17152         #[link(name = "windows")]
17153         extern "system" {
17154             fn ucnv_openAllNames(perrorcode: *mut UErrorCode) -> *mut UEnumeration;
17155         }
17156         ::std::mem::transmute(ucnv_openAllNames(::std::mem::transmute(perrorcode)))
17157     }
17158     #[cfg(not(windows))]
17159     unimplemented!("Unsupported target OS");
17160 }
17161 #[inline]
ucnv_openCCSID(codepage: i32, platform: UConverterPlatform, err: *mut UErrorCode) -> *mut UConverter17162 pub unsafe fn ucnv_openCCSID(codepage: i32, platform: UConverterPlatform, err: *mut UErrorCode) -> *mut UConverter {
17163     #[cfg(windows)]
17164     {
17165         #[link(name = "windows")]
17166         extern "system" {
17167             fn ucnv_openCCSID(codepage: i32, platform: UConverterPlatform, err: *mut UErrorCode) -> *mut UConverter;
17168         }
17169         ::std::mem::transmute(ucnv_openCCSID(::std::mem::transmute(codepage), ::std::mem::transmute(platform), ::std::mem::transmute(err)))
17170     }
17171     #[cfg(not(windows))]
17172     unimplemented!("Unsupported target OS");
17173 }
17174 #[cfg(feature = "Win32_Foundation")]
17175 #[inline]
ucnv_openPackage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, convertername: Param1, err: *mut UErrorCode) -> *mut UConverter17176 pub unsafe fn ucnv_openPackage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, convertername: Param1, err: *mut UErrorCode) -> *mut UConverter {
17177     #[cfg(windows)]
17178     {
17179         #[link(name = "windows")]
17180         extern "system" {
17181             fn ucnv_openPackage(packagename: super::Foundation::PSTR, convertername: super::Foundation::PSTR, err: *mut UErrorCode) -> *mut UConverter;
17182         }
17183         ::std::mem::transmute(ucnv_openPackage(packagename.into_param().abi(), convertername.into_param().abi(), ::std::mem::transmute(err)))
17184     }
17185     #[cfg(not(windows))]
17186     unimplemented!("Unsupported target OS");
17187 }
17188 #[cfg(feature = "Win32_Foundation")]
17189 #[inline]
ucnv_openStandardNames<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(convname: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> *mut UEnumeration17190 pub unsafe fn ucnv_openStandardNames<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(convname: Param0, standard: Param1, perrorcode: *mut UErrorCode) -> *mut UEnumeration {
17191     #[cfg(windows)]
17192     {
17193         #[link(name = "windows")]
17194         extern "system" {
17195             fn ucnv_openStandardNames(convname: super::Foundation::PSTR, standard: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> *mut UEnumeration;
17196         }
17197         ::std::mem::transmute(ucnv_openStandardNames(convname.into_param().abi(), standard.into_param().abi(), ::std::mem::transmute(perrorcode)))
17198     }
17199     #[cfg(not(windows))]
17200     unimplemented!("Unsupported target OS");
17201 }
17202 #[inline]
ucnv_openU(name: *const u16, err: *mut UErrorCode) -> *mut UConverter17203 pub unsafe fn ucnv_openU(name: *const u16, err: *mut UErrorCode) -> *mut UConverter {
17204     #[cfg(windows)]
17205     {
17206         #[link(name = "windows")]
17207         extern "system" {
17208             fn ucnv_openU(name: *const u16, err: *mut UErrorCode) -> *mut UConverter;
17209         }
17210         ::std::mem::transmute(ucnv_openU(::std::mem::transmute(name), ::std::mem::transmute(err)))
17211     }
17212     #[cfg(not(windows))]
17213     unimplemented!("Unsupported target OS");
17214 }
17215 #[inline]
ucnv_reset(converter: *mut UConverter)17216 pub unsafe fn ucnv_reset(converter: *mut UConverter) {
17217     #[cfg(windows)]
17218     {
17219         #[link(name = "windows")]
17220         extern "system" {
17221             fn ucnv_reset(converter: *mut UConverter);
17222         }
17223         ::std::mem::transmute(ucnv_reset(::std::mem::transmute(converter)))
17224     }
17225     #[cfg(not(windows))]
17226     unimplemented!("Unsupported target OS");
17227 }
17228 #[inline]
ucnv_resetFromUnicode(converter: *mut UConverter)17229 pub unsafe fn ucnv_resetFromUnicode(converter: *mut UConverter) {
17230     #[cfg(windows)]
17231     {
17232         #[link(name = "windows")]
17233         extern "system" {
17234             fn ucnv_resetFromUnicode(converter: *mut UConverter);
17235         }
17236         ::std::mem::transmute(ucnv_resetFromUnicode(::std::mem::transmute(converter)))
17237     }
17238     #[cfg(not(windows))]
17239     unimplemented!("Unsupported target OS");
17240 }
17241 #[inline]
ucnv_resetToUnicode(converter: *mut UConverter)17242 pub unsafe fn ucnv_resetToUnicode(converter: *mut UConverter) {
17243     #[cfg(windows)]
17244     {
17245         #[link(name = "windows")]
17246         extern "system" {
17247             fn ucnv_resetToUnicode(converter: *mut UConverter);
17248         }
17249         ::std::mem::transmute(ucnv_resetToUnicode(::std::mem::transmute(converter)))
17250     }
17251     #[cfg(not(windows))]
17252     unimplemented!("Unsupported target OS");
17253 }
17254 #[inline]
ucnv_safeClone(cnv: *const UConverter, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UConverter17255 pub unsafe fn ucnv_safeClone(cnv: *const UConverter, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UConverter {
17256     #[cfg(windows)]
17257     {
17258         #[link(name = "windows")]
17259         extern "system" {
17260             fn ucnv_safeClone(cnv: *const UConverter, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UConverter;
17261         }
17262         ::std::mem::transmute(ucnv_safeClone(::std::mem::transmute(cnv), ::std::mem::transmute(stackbuffer), ::std::mem::transmute(pbuffersize), ::std::mem::transmute(status)))
17263     }
17264     #[cfg(not(windows))]
17265     unimplemented!("Unsupported target OS");
17266 }
17267 #[cfg(feature = "Win32_Foundation")]
17268 #[inline]
ucnv_setDefaultName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0)17269 pub unsafe fn ucnv_setDefaultName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0) {
17270     #[cfg(windows)]
17271     {
17272         #[link(name = "windows")]
17273         extern "system" {
17274             fn ucnv_setDefaultName(name: super::Foundation::PSTR);
17275         }
17276         ::std::mem::transmute(ucnv_setDefaultName(name.into_param().abi()))
17277     }
17278     #[cfg(not(windows))]
17279     unimplemented!("Unsupported target OS");
17280 }
17281 #[inline]
ucnv_setFallback(cnv: *mut UConverter, usesfallback: i8)17282 pub unsafe fn ucnv_setFallback(cnv: *mut UConverter, usesfallback: i8) {
17283     #[cfg(windows)]
17284     {
17285         #[link(name = "windows")]
17286         extern "system" {
17287             fn ucnv_setFallback(cnv: *mut UConverter, usesfallback: i8);
17288         }
17289         ::std::mem::transmute(ucnv_setFallback(::std::mem::transmute(cnv), ::std::mem::transmute(usesfallback)))
17290     }
17291     #[cfg(not(windows))]
17292     unimplemented!("Unsupported target OS");
17293 }
17294 #[cfg(feature = "Win32_Foundation")]
17295 #[inline]
ucnv_setFromUCallBack(converter: *mut UConverter, newaction: ::std::option::Option<UConverterFromUCallback>, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::std::option::Option<UConverterFromUCallback>, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode)17296 pub unsafe fn ucnv_setFromUCallBack(converter: *mut UConverter, newaction: ::std::option::Option<UConverterFromUCallback>, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::std::option::Option<UConverterFromUCallback>, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode) {
17297     #[cfg(windows)]
17298     {
17299         #[link(name = "windows")]
17300         extern "system" {
17301             fn ucnv_setFromUCallBack(converter: *mut UConverter, newaction: ::windows::runtime::RawPtr, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::windows::runtime::RawPtr, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode);
17302         }
17303         ::std::mem::transmute(ucnv_setFromUCallBack(::std::mem::transmute(converter), ::std::mem::transmute(newaction), ::std::mem::transmute(newcontext), ::std::mem::transmute(oldaction), ::std::mem::transmute(oldcontext), ::std::mem::transmute(err)))
17304     }
17305     #[cfg(not(windows))]
17306     unimplemented!("Unsupported target OS");
17307 }
17308 #[cfg(feature = "Win32_Foundation")]
17309 #[inline]
ucnv_setSubstChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, subchars: Param1, len: i8, err: *mut UErrorCode)17310 pub unsafe fn ucnv_setSubstChars<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, subchars: Param1, len: i8, err: *mut UErrorCode) {
17311     #[cfg(windows)]
17312     {
17313         #[link(name = "windows")]
17314         extern "system" {
17315             fn ucnv_setSubstChars(converter: *mut UConverter, subchars: super::Foundation::PSTR, len: i8, err: *mut UErrorCode);
17316         }
17317         ::std::mem::transmute(ucnv_setSubstChars(::std::mem::transmute(converter), subchars.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(err)))
17318     }
17319     #[cfg(not(windows))]
17320     unimplemented!("Unsupported target OS");
17321 }
17322 #[inline]
ucnv_setSubstString(cnv: *mut UConverter, s: *const u16, length: i32, err: *mut UErrorCode)17323 pub unsafe fn ucnv_setSubstString(cnv: *mut UConverter, s: *const u16, length: i32, err: *mut UErrorCode) {
17324     #[cfg(windows)]
17325     {
17326         #[link(name = "windows")]
17327         extern "system" {
17328             fn ucnv_setSubstString(cnv: *mut UConverter, s: *const u16, length: i32, err: *mut UErrorCode);
17329         }
17330         ::std::mem::transmute(ucnv_setSubstString(::std::mem::transmute(cnv), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(err)))
17331     }
17332     #[cfg(not(windows))]
17333     unimplemented!("Unsupported target OS");
17334 }
17335 #[cfg(feature = "Win32_Foundation")]
17336 #[inline]
ucnv_setToUCallBack(converter: *mut UConverter, newaction: ::std::option::Option<UConverterToUCallback>, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::std::option::Option<UConverterToUCallback>, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode)17337 pub unsafe fn ucnv_setToUCallBack(converter: *mut UConverter, newaction: ::std::option::Option<UConverterToUCallback>, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::std::option::Option<UConverterToUCallback>, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode) {
17338     #[cfg(windows)]
17339     {
17340         #[link(name = "windows")]
17341         extern "system" {
17342             fn ucnv_setToUCallBack(converter: *mut UConverter, newaction: ::windows::runtime::RawPtr, newcontext: *const ::std::ffi::c_void, oldaction: *mut ::windows::runtime::RawPtr, oldcontext: *const *const ::std::ffi::c_void, err: *mut UErrorCode);
17343         }
17344         ::std::mem::transmute(ucnv_setToUCallBack(::std::mem::transmute(converter), ::std::mem::transmute(newaction), ::std::mem::transmute(newcontext), ::std::mem::transmute(oldaction), ::std::mem::transmute(oldcontext), ::std::mem::transmute(err)))
17345     }
17346     #[cfg(not(windows))]
17347     unimplemented!("Unsupported target OS");
17348 }
17349 #[cfg(feature = "Win32_Foundation")]
17350 #[inline]
ucnv_toAlgorithmic<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(algorithmictype: UConverterType, cnv: *mut UConverter, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i3217351 pub unsafe fn ucnv_toAlgorithmic<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(algorithmictype: UConverterType, cnv: *mut UConverter, target: Param2, targetcapacity: i32, source: Param4, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32 {
17352     #[cfg(windows)]
17353     {
17354         #[link(name = "windows")]
17355         extern "system" {
17356             fn ucnv_toAlgorithmic(algorithmictype: UConverterType, cnv: *mut UConverter, target: super::Foundation::PSTR, targetcapacity: i32, source: super::Foundation::PSTR, sourcelength: i32, perrorcode: *mut UErrorCode) -> i32;
17357         }
17358         ::std::mem::transmute(ucnv_toAlgorithmic(::std::mem::transmute(algorithmictype), ::std::mem::transmute(cnv), target.into_param().abi(), ::std::mem::transmute(targetcapacity), source.into_param().abi(), ::std::mem::transmute(sourcelength), ::std::mem::transmute(perrorcode)))
17359     }
17360     #[cfg(not(windows))]
17361     unimplemented!("Unsupported target OS");
17362 }
17363 #[cfg(feature = "Win32_Foundation")]
17364 #[inline]
ucnv_toUChars<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, dest: *mut u16, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i3217365 pub unsafe fn ucnv_toUChars<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(cnv: *mut UConverter, dest: *mut u16, destcapacity: i32, src: Param3, srclength: i32, perrorcode: *mut UErrorCode) -> i32 {
17366     #[cfg(windows)]
17367     {
17368         #[link(name = "windows")]
17369         extern "system" {
17370             fn ucnv_toUChars(cnv: *mut UConverter, dest: *mut u16, destcapacity: i32, src: super::Foundation::PSTR, srclength: i32, perrorcode: *mut UErrorCode) -> i32;
17371         }
17372         ::std::mem::transmute(ucnv_toUChars(::std::mem::transmute(cnv), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), src.into_param().abi(), ::std::mem::transmute(srclength), ::std::mem::transmute(perrorcode)))
17373     }
17374     #[cfg(not(windows))]
17375     unimplemented!("Unsupported target OS");
17376 }
17377 #[inline]
ucnv_toUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i3217378 pub unsafe fn ucnv_toUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i32 {
17379     #[cfg(windows)]
17380     {
17381         #[link(name = "windows")]
17382         extern "system" {
17383             fn ucnv_toUCountPending(cnv: *const UConverter, status: *mut UErrorCode) -> i32;
17384         }
17385         ::std::mem::transmute(ucnv_toUCountPending(::std::mem::transmute(cnv), ::std::mem::transmute(status)))
17386     }
17387     #[cfg(not(windows))]
17388     unimplemented!("Unsupported target OS");
17389 }
17390 #[cfg(feature = "Win32_Foundation")]
17391 #[inline]
ucnv_toUnicode<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, target: *mut *mut u16, targetlimit: *const u16, source: *const *const i8, sourcelimit: Param4, offsets: *mut i32, flush: i8, err: *mut UErrorCode)17392 pub unsafe fn ucnv_toUnicode<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(converter: *mut UConverter, target: *mut *mut u16, targetlimit: *const u16, source: *const *const i8, sourcelimit: Param4, offsets: *mut i32, flush: i8, err: *mut UErrorCode) {
17393     #[cfg(windows)]
17394     {
17395         #[link(name = "windows")]
17396         extern "system" {
17397             fn ucnv_toUnicode(converter: *mut UConverter, target: *mut *mut u16, targetlimit: *const u16, source: *const *const i8, sourcelimit: super::Foundation::PSTR, offsets: *mut i32, flush: i8, err: *mut UErrorCode);
17398         }
17399         ::std::mem::transmute(ucnv_toUnicode(::std::mem::transmute(converter), ::std::mem::transmute(target), ::std::mem::transmute(targetlimit), ::std::mem::transmute(source), sourcelimit.into_param().abi(), ::std::mem::transmute(offsets), ::std::mem::transmute(flush), ::std::mem::transmute(err)))
17400     }
17401     #[cfg(not(windows))]
17402     unimplemented!("Unsupported target OS");
17403 }
17404 #[inline]
ucnv_usesFallback(cnv: *const UConverter) -> i817405 pub unsafe fn ucnv_usesFallback(cnv: *const UConverter) -> i8 {
17406     #[cfg(windows)]
17407     {
17408         #[link(name = "windows")]
17409         extern "system" {
17410             fn ucnv_usesFallback(cnv: *const UConverter) -> i8;
17411         }
17412         ::std::mem::transmute(ucnv_usesFallback(::std::mem::transmute(cnv)))
17413     }
17414     #[cfg(not(windows))]
17415     unimplemented!("Unsupported target OS");
17416 }
17417 #[inline]
ucnvsel_close(sel: *mut UConverterSelector)17418 pub unsafe fn ucnvsel_close(sel: *mut UConverterSelector) {
17419     #[cfg(windows)]
17420     {
17421         #[link(name = "windows")]
17422         extern "system" {
17423             fn ucnvsel_close(sel: *mut UConverterSelector);
17424         }
17425         ::std::mem::transmute(ucnvsel_close(::std::mem::transmute(sel)))
17426     }
17427     #[cfg(not(windows))]
17428     unimplemented!("Unsupported target OS");
17429 }
17430 #[inline]
ucnvsel_open(converterlist: *const *const i8, converterlistsize: i32, excludedcodepoints: *const USet, whichset: UConverterUnicodeSet, status: *mut UErrorCode) -> *mut UConverterSelector17431 pub unsafe fn ucnvsel_open(converterlist: *const *const i8, converterlistsize: i32, excludedcodepoints: *const USet, whichset: UConverterUnicodeSet, status: *mut UErrorCode) -> *mut UConverterSelector {
17432     #[cfg(windows)]
17433     {
17434         #[link(name = "windows")]
17435         extern "system" {
17436             fn ucnvsel_open(converterlist: *const *const i8, converterlistsize: i32, excludedcodepoints: *const USet, whichset: UConverterUnicodeSet, status: *mut UErrorCode) -> *mut UConverterSelector;
17437         }
17438         ::std::mem::transmute(ucnvsel_open(::std::mem::transmute(converterlist), ::std::mem::transmute(converterlistsize), ::std::mem::transmute(excludedcodepoints), ::std::mem::transmute(whichset), ::std::mem::transmute(status)))
17439     }
17440     #[cfg(not(windows))]
17441     unimplemented!("Unsupported target OS");
17442 }
17443 #[inline]
ucnvsel_openFromSerialized(buffer: *const ::std::ffi::c_void, length: i32, status: *mut UErrorCode) -> *mut UConverterSelector17444 pub unsafe fn ucnvsel_openFromSerialized(buffer: *const ::std::ffi::c_void, length: i32, status: *mut UErrorCode) -> *mut UConverterSelector {
17445     #[cfg(windows)]
17446     {
17447         #[link(name = "windows")]
17448         extern "system" {
17449             fn ucnvsel_openFromSerialized(buffer: *const ::std::ffi::c_void, length: i32, status: *mut UErrorCode) -> *mut UConverterSelector;
17450         }
17451         ::std::mem::transmute(ucnvsel_openFromSerialized(::std::mem::transmute(buffer), ::std::mem::transmute(length), ::std::mem::transmute(status)))
17452     }
17453     #[cfg(not(windows))]
17454     unimplemented!("Unsupported target OS");
17455 }
17456 #[inline]
ucnvsel_selectForString(sel: *const UConverterSelector, s: *const u16, length: i32, status: *mut UErrorCode) -> *mut UEnumeration17457 pub unsafe fn ucnvsel_selectForString(sel: *const UConverterSelector, s: *const u16, length: i32, status: *mut UErrorCode) -> *mut UEnumeration {
17458     #[cfg(windows)]
17459     {
17460         #[link(name = "windows")]
17461         extern "system" {
17462             fn ucnvsel_selectForString(sel: *const UConverterSelector, s: *const u16, length: i32, status: *mut UErrorCode) -> *mut UEnumeration;
17463         }
17464         ::std::mem::transmute(ucnvsel_selectForString(::std::mem::transmute(sel), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(status)))
17465     }
17466     #[cfg(not(windows))]
17467     unimplemented!("Unsupported target OS");
17468 }
17469 #[cfg(feature = "Win32_Foundation")]
17470 #[inline]
ucnvsel_selectForUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sel: *const UConverterSelector, s: Param1, length: i32, status: *mut UErrorCode) -> *mut UEnumeration17471 pub unsafe fn ucnvsel_selectForUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sel: *const UConverterSelector, s: Param1, length: i32, status: *mut UErrorCode) -> *mut UEnumeration {
17472     #[cfg(windows)]
17473     {
17474         #[link(name = "windows")]
17475         extern "system" {
17476             fn ucnvsel_selectForUTF8(sel: *const UConverterSelector, s: super::Foundation::PSTR, length: i32, status: *mut UErrorCode) -> *mut UEnumeration;
17477         }
17478         ::std::mem::transmute(ucnvsel_selectForUTF8(::std::mem::transmute(sel), s.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(status)))
17479     }
17480     #[cfg(not(windows))]
17481     unimplemented!("Unsupported target OS");
17482 }
17483 #[inline]
ucnvsel_serialize(sel: *const UConverterSelector, buffer: *mut ::std::ffi::c_void, buffercapacity: i32, status: *mut UErrorCode) -> i3217484 pub unsafe fn ucnvsel_serialize(sel: *const UConverterSelector, buffer: *mut ::std::ffi::c_void, buffercapacity: i32, status: *mut UErrorCode) -> i32 {
17485     #[cfg(windows)]
17486     {
17487         #[link(name = "windows")]
17488         extern "system" {
17489             fn ucnvsel_serialize(sel: *const UConverterSelector, buffer: *mut ::std::ffi::c_void, buffercapacity: i32, status: *mut UErrorCode) -> i32;
17490         }
17491         ::std::mem::transmute(ucnvsel_serialize(::std::mem::transmute(sel), ::std::mem::transmute(buffer), ::std::mem::transmute(buffercapacity), ::std::mem::transmute(status)))
17492     }
17493     #[cfg(not(windows))]
17494     unimplemented!("Unsupported target OS");
17495 }
17496 #[inline]
ucol_cloneBinary(coll: *const UCollator, buffer: *mut u8, capacity: i32, status: *mut UErrorCode) -> i3217497 pub unsafe fn ucol_cloneBinary(coll: *const UCollator, buffer: *mut u8, capacity: i32, status: *mut UErrorCode) -> i32 {
17498     #[cfg(windows)]
17499     {
17500         #[link(name = "windows")]
17501         extern "system" {
17502             fn ucol_cloneBinary(coll: *const UCollator, buffer: *mut u8, capacity: i32, status: *mut UErrorCode) -> i32;
17503         }
17504         ::std::mem::transmute(ucol_cloneBinary(::std::mem::transmute(coll), ::std::mem::transmute(buffer), ::std::mem::transmute(capacity), ::std::mem::transmute(status)))
17505     }
17506     #[cfg(not(windows))]
17507     unimplemented!("Unsupported target OS");
17508 }
17509 #[inline]
ucol_close(coll: *mut UCollator)17510 pub unsafe fn ucol_close(coll: *mut UCollator) {
17511     #[cfg(windows)]
17512     {
17513         #[link(name = "windows")]
17514         extern "system" {
17515             fn ucol_close(coll: *mut UCollator);
17516         }
17517         ::std::mem::transmute(ucol_close(::std::mem::transmute(coll)))
17518     }
17519     #[cfg(not(windows))]
17520     unimplemented!("Unsupported target OS");
17521 }
17522 #[inline]
ucol_closeElements(elems: *mut UCollationElements)17523 pub unsafe fn ucol_closeElements(elems: *mut UCollationElements) {
17524     #[cfg(windows)]
17525     {
17526         #[link(name = "windows")]
17527         extern "system" {
17528             fn ucol_closeElements(elems: *mut UCollationElements);
17529         }
17530         ::std::mem::transmute(ucol_closeElements(::std::mem::transmute(elems)))
17531     }
17532     #[cfg(not(windows))]
17533     unimplemented!("Unsupported target OS");
17534 }
17535 #[inline]
ucol_countAvailable() -> i3217536 pub unsafe fn ucol_countAvailable() -> i32 {
17537     #[cfg(windows)]
17538     {
17539         #[link(name = "windows")]
17540         extern "system" {
17541             fn ucol_countAvailable() -> i32;
17542         }
17543         ::std::mem::transmute(ucol_countAvailable())
17544     }
17545     #[cfg(not(windows))]
17546     unimplemented!("Unsupported target OS");
17547 }
17548 #[inline]
ucol_equal(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i817549 pub unsafe fn ucol_equal(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8 {
17550     #[cfg(windows)]
17551     {
17552         #[link(name = "windows")]
17553         extern "system" {
17554             fn ucol_equal(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8;
17555         }
17556         ::std::mem::transmute(ucol_equal(::std::mem::transmute(coll), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(target), ::std::mem::transmute(targetlength)))
17557     }
17558     #[cfg(not(windows))]
17559     unimplemented!("Unsupported target OS");
17560 }
17561 #[inline]
ucol_getAttribute(coll: *const UCollator, attr: UColAttribute, status: *mut UErrorCode) -> UColAttributeValue17562 pub unsafe fn ucol_getAttribute(coll: *const UCollator, attr: UColAttribute, status: *mut UErrorCode) -> UColAttributeValue {
17563     #[cfg(windows)]
17564     {
17565         #[link(name = "windows")]
17566         extern "system" {
17567             fn ucol_getAttribute(coll: *const UCollator, attr: UColAttribute, status: *mut UErrorCode) -> UColAttributeValue;
17568         }
17569         ::std::mem::transmute(ucol_getAttribute(::std::mem::transmute(coll), ::std::mem::transmute(attr), ::std::mem::transmute(status)))
17570     }
17571     #[cfg(not(windows))]
17572     unimplemented!("Unsupported target OS");
17573 }
17574 #[cfg(feature = "Win32_Foundation")]
17575 #[inline]
ucol_getAvailable(localeindex: i32) -> super::Foundation::PSTR17576 pub unsafe fn ucol_getAvailable(localeindex: i32) -> super::Foundation::PSTR {
17577     #[cfg(windows)]
17578     {
17579         #[link(name = "windows")]
17580         extern "system" {
17581             fn ucol_getAvailable(localeindex: i32) -> super::Foundation::PSTR;
17582         }
17583         ::std::mem::transmute(ucol_getAvailable(::std::mem::transmute(localeindex)))
17584     }
17585     #[cfg(not(windows))]
17586     unimplemented!("Unsupported target OS");
17587 }
17588 #[inline]
ucol_getBound(source: *const u8, sourcelength: i32, boundtype: UColBoundMode, nooflevels: u32, result: *mut u8, resultlength: i32, status: *mut UErrorCode) -> i3217589 pub unsafe fn ucol_getBound(source: *const u8, sourcelength: i32, boundtype: UColBoundMode, nooflevels: u32, result: *mut u8, resultlength: i32, status: *mut UErrorCode) -> i32 {
17590     #[cfg(windows)]
17591     {
17592         #[link(name = "windows")]
17593         extern "system" {
17594             fn ucol_getBound(source: *const u8, sourcelength: i32, boundtype: UColBoundMode, nooflevels: u32, result: *mut u8, resultlength: i32, status: *mut UErrorCode) -> i32;
17595         }
17596         ::std::mem::transmute(ucol_getBound(::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(boundtype), ::std::mem::transmute(nooflevels), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
17597     }
17598     #[cfg(not(windows))]
17599     unimplemented!("Unsupported target OS");
17600 }
17601 #[inline]
ucol_getContractionsAndExpansions(coll: *const UCollator, contractions: *mut USet, expansions: *mut USet, addprefixes: i8, status: *mut UErrorCode)17602 pub unsafe fn ucol_getContractionsAndExpansions(coll: *const UCollator, contractions: *mut USet, expansions: *mut USet, addprefixes: i8, status: *mut UErrorCode) {
17603     #[cfg(windows)]
17604     {
17605         #[link(name = "windows")]
17606         extern "system" {
17607             fn ucol_getContractionsAndExpansions(coll: *const UCollator, contractions: *mut USet, expansions: *mut USet, addprefixes: i8, status: *mut UErrorCode);
17608         }
17609         ::std::mem::transmute(ucol_getContractionsAndExpansions(::std::mem::transmute(coll), ::std::mem::transmute(contractions), ::std::mem::transmute(expansions), ::std::mem::transmute(addprefixes), ::std::mem::transmute(status)))
17610     }
17611     #[cfg(not(windows))]
17612     unimplemented!("Unsupported target OS");
17613 }
17614 #[cfg(feature = "Win32_Foundation")]
17615 #[inline]
ucol_getDisplayName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(objloc: Param0, disploc: Param1, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3217616 pub unsafe fn ucol_getDisplayName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(objloc: Param0, disploc: Param1, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
17617     #[cfg(windows)]
17618     {
17619         #[link(name = "windows")]
17620         extern "system" {
17621             fn ucol_getDisplayName(objloc: super::Foundation::PSTR, disploc: super::Foundation::PSTR, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
17622         }
17623         ::std::mem::transmute(ucol_getDisplayName(objloc.into_param().abi(), disploc.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
17624     }
17625     #[cfg(not(windows))]
17626     unimplemented!("Unsupported target OS");
17627 }
17628 #[inline]
ucol_getEquivalentReorderCodes(reordercode: i32, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3217629 pub unsafe fn ucol_getEquivalentReorderCodes(reordercode: i32, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
17630     #[cfg(windows)]
17631     {
17632         #[link(name = "windows")]
17633         extern "system" {
17634             fn ucol_getEquivalentReorderCodes(reordercode: i32, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
17635         }
17636         ::std::mem::transmute(ucol_getEquivalentReorderCodes(::std::mem::transmute(reordercode), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(perrorcode)))
17637     }
17638     #[cfg(not(windows))]
17639     unimplemented!("Unsupported target OS");
17640 }
17641 #[cfg(feature = "Win32_Foundation")]
17642 #[inline]
ucol_getFunctionalEquivalent<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultcapacity: i32, keyword: Param2, locale: Param3, isavailable: *mut i8, status: *mut UErrorCode) -> i3217643 pub unsafe fn ucol_getFunctionalEquivalent<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultcapacity: i32, keyword: Param2, locale: Param3, isavailable: *mut i8, status: *mut UErrorCode) -> i32 {
17644     #[cfg(windows)]
17645     {
17646         #[link(name = "windows")]
17647         extern "system" {
17648             fn ucol_getFunctionalEquivalent(result: super::Foundation::PSTR, resultcapacity: i32, keyword: super::Foundation::PSTR, locale: super::Foundation::PSTR, isavailable: *mut i8, status: *mut UErrorCode) -> i32;
17649         }
17650         ::std::mem::transmute(ucol_getFunctionalEquivalent(result.into_param().abi(), ::std::mem::transmute(resultcapacity), keyword.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(isavailable), ::std::mem::transmute(status)))
17651     }
17652     #[cfg(not(windows))]
17653     unimplemented!("Unsupported target OS");
17654 }
17655 #[cfg(feature = "Win32_Foundation")]
17656 #[inline]
ucol_getKeywordValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, status: *mut UErrorCode) -> *mut UEnumeration17657 pub unsafe fn ucol_getKeywordValues<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, status: *mut UErrorCode) -> *mut UEnumeration {
17658     #[cfg(windows)]
17659     {
17660         #[link(name = "windows")]
17661         extern "system" {
17662             fn ucol_getKeywordValues(keyword: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UEnumeration;
17663         }
17664         ::std::mem::transmute(ucol_getKeywordValues(keyword.into_param().abi(), ::std::mem::transmute(status)))
17665     }
17666     #[cfg(not(windows))]
17667     unimplemented!("Unsupported target OS");
17668 }
17669 #[cfg(feature = "Win32_Foundation")]
17670 #[inline]
ucol_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration17671 pub unsafe fn ucol_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration {
17672     #[cfg(windows)]
17673     {
17674         #[link(name = "windows")]
17675         extern "system" {
17676             fn ucol_getKeywordValuesForLocale(key: super::Foundation::PSTR, locale: super::Foundation::PSTR, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration;
17677         }
17678         ::std::mem::transmute(ucol_getKeywordValuesForLocale(key.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(commonlyused), ::std::mem::transmute(status)))
17679     }
17680     #[cfg(not(windows))]
17681     unimplemented!("Unsupported target OS");
17682 }
17683 #[inline]
ucol_getKeywords(status: *mut UErrorCode) -> *mut UEnumeration17684 pub unsafe fn ucol_getKeywords(status: *mut UErrorCode) -> *mut UEnumeration {
17685     #[cfg(windows)]
17686     {
17687         #[link(name = "windows")]
17688         extern "system" {
17689             fn ucol_getKeywords(status: *mut UErrorCode) -> *mut UEnumeration;
17690         }
17691         ::std::mem::transmute(ucol_getKeywords(::std::mem::transmute(status)))
17692     }
17693     #[cfg(not(windows))]
17694     unimplemented!("Unsupported target OS");
17695 }
17696 #[cfg(feature = "Win32_Foundation")]
17697 #[inline]
ucol_getLocaleByType(coll: *const UCollator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR17698 pub unsafe fn ucol_getLocaleByType(coll: *const UCollator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
17699     #[cfg(windows)]
17700     {
17701         #[link(name = "windows")]
17702         extern "system" {
17703             fn ucol_getLocaleByType(coll: *const UCollator, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
17704         }
17705         ::std::mem::transmute(ucol_getLocaleByType(::std::mem::transmute(coll), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
17706     }
17707     #[cfg(not(windows))]
17708     unimplemented!("Unsupported target OS");
17709 }
17710 #[inline]
ucol_getMaxExpansion(elems: *const UCollationElements, order: i32) -> i3217711 pub unsafe fn ucol_getMaxExpansion(elems: *const UCollationElements, order: i32) -> i32 {
17712     #[cfg(windows)]
17713     {
17714         #[link(name = "windows")]
17715         extern "system" {
17716             fn ucol_getMaxExpansion(elems: *const UCollationElements, order: i32) -> i32;
17717         }
17718         ::std::mem::transmute(ucol_getMaxExpansion(::std::mem::transmute(elems), ::std::mem::transmute(order)))
17719     }
17720     #[cfg(not(windows))]
17721     unimplemented!("Unsupported target OS");
17722 }
17723 #[inline]
ucol_getMaxVariable(coll: *const UCollator) -> UColReorderCode17724 pub unsafe fn ucol_getMaxVariable(coll: *const UCollator) -> UColReorderCode {
17725     #[cfg(windows)]
17726     {
17727         #[link(name = "windows")]
17728         extern "system" {
17729             fn ucol_getMaxVariable(coll: *const UCollator) -> UColReorderCode;
17730         }
17731         ::std::mem::transmute(ucol_getMaxVariable(::std::mem::transmute(coll)))
17732     }
17733     #[cfg(not(windows))]
17734     unimplemented!("Unsupported target OS");
17735 }
17736 #[inline]
ucol_getOffset(elems: *const UCollationElements) -> i3217737 pub unsafe fn ucol_getOffset(elems: *const UCollationElements) -> i32 {
17738     #[cfg(windows)]
17739     {
17740         #[link(name = "windows")]
17741         extern "system" {
17742             fn ucol_getOffset(elems: *const UCollationElements) -> i32;
17743         }
17744         ::std::mem::transmute(ucol_getOffset(::std::mem::transmute(elems)))
17745     }
17746     #[cfg(not(windows))]
17747     unimplemented!("Unsupported target OS");
17748 }
17749 #[inline]
ucol_getReorderCodes(coll: *const UCollator, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3217750 pub unsafe fn ucol_getReorderCodes(coll: *const UCollator, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
17751     #[cfg(windows)]
17752     {
17753         #[link(name = "windows")]
17754         extern "system" {
17755             fn ucol_getReorderCodes(coll: *const UCollator, dest: *mut i32, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
17756         }
17757         ::std::mem::transmute(ucol_getReorderCodes(::std::mem::transmute(coll), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(perrorcode)))
17758     }
17759     #[cfg(not(windows))]
17760     unimplemented!("Unsupported target OS");
17761 }
17762 #[inline]
ucol_getRules(coll: *const UCollator, length: *mut i32) -> *mut u1617763 pub unsafe fn ucol_getRules(coll: *const UCollator, length: *mut i32) -> *mut u16 {
17764     #[cfg(windows)]
17765     {
17766         #[link(name = "windows")]
17767         extern "system" {
17768             fn ucol_getRules(coll: *const UCollator, length: *mut i32) -> *mut u16;
17769         }
17770         ::std::mem::transmute(ucol_getRules(::std::mem::transmute(coll), ::std::mem::transmute(length)))
17771     }
17772     #[cfg(not(windows))]
17773     unimplemented!("Unsupported target OS");
17774 }
17775 #[inline]
ucol_getRulesEx(coll: *const UCollator, delta: UColRuleOption, buffer: *mut u16, bufferlen: i32) -> i3217776 pub unsafe fn ucol_getRulesEx(coll: *const UCollator, delta: UColRuleOption, buffer: *mut u16, bufferlen: i32) -> i32 {
17777     #[cfg(windows)]
17778     {
17779         #[link(name = "windows")]
17780         extern "system" {
17781             fn ucol_getRulesEx(coll: *const UCollator, delta: UColRuleOption, buffer: *mut u16, bufferlen: i32) -> i32;
17782         }
17783         ::std::mem::transmute(ucol_getRulesEx(::std::mem::transmute(coll), ::std::mem::transmute(delta), ::std::mem::transmute(buffer), ::std::mem::transmute(bufferlen)))
17784     }
17785     #[cfg(not(windows))]
17786     unimplemented!("Unsupported target OS");
17787 }
17788 #[inline]
ucol_getSortKey(coll: *const UCollator, source: *const u16, sourcelength: i32, result: *mut u8, resultlength: i32) -> i3217789 pub unsafe fn ucol_getSortKey(coll: *const UCollator, source: *const u16, sourcelength: i32, result: *mut u8, resultlength: i32) -> i32 {
17790     #[cfg(windows)]
17791     {
17792         #[link(name = "windows")]
17793         extern "system" {
17794             fn ucol_getSortKey(coll: *const UCollator, source: *const u16, sourcelength: i32, result: *mut u8, resultlength: i32) -> i32;
17795         }
17796         ::std::mem::transmute(ucol_getSortKey(::std::mem::transmute(coll), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(result), ::std::mem::transmute(resultlength)))
17797     }
17798     #[cfg(not(windows))]
17799     unimplemented!("Unsupported target OS");
17800 }
17801 #[inline]
ucol_getStrength(coll: *const UCollator) -> UColAttributeValue17802 pub unsafe fn ucol_getStrength(coll: *const UCollator) -> UColAttributeValue {
17803     #[cfg(windows)]
17804     {
17805         #[link(name = "windows")]
17806         extern "system" {
17807             fn ucol_getStrength(coll: *const UCollator) -> UColAttributeValue;
17808         }
17809         ::std::mem::transmute(ucol_getStrength(::std::mem::transmute(coll)))
17810     }
17811     #[cfg(not(windows))]
17812     unimplemented!("Unsupported target OS");
17813 }
17814 #[inline]
ucol_getTailoredSet(coll: *const UCollator, status: *mut UErrorCode) -> *mut USet17815 pub unsafe fn ucol_getTailoredSet(coll: *const UCollator, status: *mut UErrorCode) -> *mut USet {
17816     #[cfg(windows)]
17817     {
17818         #[link(name = "windows")]
17819         extern "system" {
17820             fn ucol_getTailoredSet(coll: *const UCollator, status: *mut UErrorCode) -> *mut USet;
17821         }
17822         ::std::mem::transmute(ucol_getTailoredSet(::std::mem::transmute(coll), ::std::mem::transmute(status)))
17823     }
17824     #[cfg(not(windows))]
17825     unimplemented!("Unsupported target OS");
17826 }
17827 #[inline]
ucol_getUCAVersion(coll: *const UCollator, info: *mut u8)17828 pub unsafe fn ucol_getUCAVersion(coll: *const UCollator, info: *mut u8) {
17829     #[cfg(windows)]
17830     {
17831         #[link(name = "windows")]
17832         extern "system" {
17833             fn ucol_getUCAVersion(coll: *const UCollator, info: *mut u8);
17834         }
17835         ::std::mem::transmute(ucol_getUCAVersion(::std::mem::transmute(coll), ::std::mem::transmute(info)))
17836     }
17837     #[cfg(not(windows))]
17838     unimplemented!("Unsupported target OS");
17839 }
17840 #[inline]
ucol_getVariableTop(coll: *const UCollator, status: *mut UErrorCode) -> u3217841 pub unsafe fn ucol_getVariableTop(coll: *const UCollator, status: *mut UErrorCode) -> u32 {
17842     #[cfg(windows)]
17843     {
17844         #[link(name = "windows")]
17845         extern "system" {
17846             fn ucol_getVariableTop(coll: *const UCollator, status: *mut UErrorCode) -> u32;
17847         }
17848         ::std::mem::transmute(ucol_getVariableTop(::std::mem::transmute(coll), ::std::mem::transmute(status)))
17849     }
17850     #[cfg(not(windows))]
17851     unimplemented!("Unsupported target OS");
17852 }
17853 #[inline]
ucol_getVersion(coll: *const UCollator, info: *mut u8)17854 pub unsafe fn ucol_getVersion(coll: *const UCollator, info: *mut u8) {
17855     #[cfg(windows)]
17856     {
17857         #[link(name = "windows")]
17858         extern "system" {
17859             fn ucol_getVersion(coll: *const UCollator, info: *mut u8);
17860         }
17861         ::std::mem::transmute(ucol_getVersion(::std::mem::transmute(coll), ::std::mem::transmute(info)))
17862     }
17863     #[cfg(not(windows))]
17864     unimplemented!("Unsupported target OS");
17865 }
17866 #[inline]
ucol_greater(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i817867 pub unsafe fn ucol_greater(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8 {
17868     #[cfg(windows)]
17869     {
17870         #[link(name = "windows")]
17871         extern "system" {
17872             fn ucol_greater(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8;
17873         }
17874         ::std::mem::transmute(ucol_greater(::std::mem::transmute(coll), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(target), ::std::mem::transmute(targetlength)))
17875     }
17876     #[cfg(not(windows))]
17877     unimplemented!("Unsupported target OS");
17878 }
17879 #[inline]
ucol_greaterOrEqual(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i817880 pub unsafe fn ucol_greaterOrEqual(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8 {
17881     #[cfg(windows)]
17882     {
17883         #[link(name = "windows")]
17884         extern "system" {
17885             fn ucol_greaterOrEqual(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> i8;
17886         }
17887         ::std::mem::transmute(ucol_greaterOrEqual(::std::mem::transmute(coll), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(target), ::std::mem::transmute(targetlength)))
17888     }
17889     #[cfg(not(windows))]
17890     unimplemented!("Unsupported target OS");
17891 }
17892 #[inline]
ucol_keyHashCode(key: *const u8, length: i32) -> i3217893 pub unsafe fn ucol_keyHashCode(key: *const u8, length: i32) -> i32 {
17894     #[cfg(windows)]
17895     {
17896         #[link(name = "windows")]
17897         extern "system" {
17898             fn ucol_keyHashCode(key: *const u8, length: i32) -> i32;
17899         }
17900         ::std::mem::transmute(ucol_keyHashCode(::std::mem::transmute(key), ::std::mem::transmute(length)))
17901     }
17902     #[cfg(not(windows))]
17903     unimplemented!("Unsupported target OS");
17904 }
17905 #[inline]
ucol_mergeSortkeys(src1: *const u8, src1length: i32, src2: *const u8, src2length: i32, dest: *mut u8, destcapacity: i32) -> i3217906 pub unsafe fn ucol_mergeSortkeys(src1: *const u8, src1length: i32, src2: *const u8, src2length: i32, dest: *mut u8, destcapacity: i32) -> i32 {
17907     #[cfg(windows)]
17908     {
17909         #[link(name = "windows")]
17910         extern "system" {
17911             fn ucol_mergeSortkeys(src1: *const u8, src1length: i32, src2: *const u8, src2length: i32, dest: *mut u8, destcapacity: i32) -> i32;
17912         }
17913         ::std::mem::transmute(ucol_mergeSortkeys(::std::mem::transmute(src1), ::std::mem::transmute(src1length), ::std::mem::transmute(src2), ::std::mem::transmute(src2length), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity)))
17914     }
17915     #[cfg(not(windows))]
17916     unimplemented!("Unsupported target OS");
17917 }
17918 #[inline]
ucol_next(elems: *mut UCollationElements, status: *mut UErrorCode) -> i3217919 pub unsafe fn ucol_next(elems: *mut UCollationElements, status: *mut UErrorCode) -> i32 {
17920     #[cfg(windows)]
17921     {
17922         #[link(name = "windows")]
17923         extern "system" {
17924             fn ucol_next(elems: *mut UCollationElements, status: *mut UErrorCode) -> i32;
17925         }
17926         ::std::mem::transmute(ucol_next(::std::mem::transmute(elems), ::std::mem::transmute(status)))
17927     }
17928     #[cfg(not(windows))]
17929     unimplemented!("Unsupported target OS");
17930 }
17931 #[inline]
ucol_nextSortKeyPart(coll: *const UCollator, iter: *mut UCharIterator, state: *mut u32, dest: *mut u8, count: i32, status: *mut UErrorCode) -> i3217932 pub unsafe fn ucol_nextSortKeyPart(coll: *const UCollator, iter: *mut UCharIterator, state: *mut u32, dest: *mut u8, count: i32, status: *mut UErrorCode) -> i32 {
17933     #[cfg(windows)]
17934     {
17935         #[link(name = "windows")]
17936         extern "system" {
17937             fn ucol_nextSortKeyPart(coll: *const UCollator, iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, state: *mut u32, dest: *mut u8, count: i32, status: *mut UErrorCode) -> i32;
17938         }
17939         ::std::mem::transmute(ucol_nextSortKeyPart(::std::mem::transmute(coll), ::std::mem::transmute(iter), ::std::mem::transmute(state), ::std::mem::transmute(dest), ::std::mem::transmute(count), ::std::mem::transmute(status)))
17940     }
17941     #[cfg(not(windows))]
17942     unimplemented!("Unsupported target OS");
17943 }
17944 #[cfg(feature = "Win32_Foundation")]
17945 #[inline]
ucol_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(loc: Param0, status: *mut UErrorCode) -> *mut UCollator17946 pub unsafe fn ucol_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(loc: Param0, status: *mut UErrorCode) -> *mut UCollator {
17947     #[cfg(windows)]
17948     {
17949         #[link(name = "windows")]
17950         extern "system" {
17951             fn ucol_open(loc: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UCollator;
17952         }
17953         ::std::mem::transmute(ucol_open(loc.into_param().abi(), ::std::mem::transmute(status)))
17954     }
17955     #[cfg(not(windows))]
17956     unimplemented!("Unsupported target OS");
17957 }
17958 #[inline]
ucol_openAvailableLocales(status: *mut UErrorCode) -> *mut UEnumeration17959 pub unsafe fn ucol_openAvailableLocales(status: *mut UErrorCode) -> *mut UEnumeration {
17960     #[cfg(windows)]
17961     {
17962         #[link(name = "windows")]
17963         extern "system" {
17964             fn ucol_openAvailableLocales(status: *mut UErrorCode) -> *mut UEnumeration;
17965         }
17966         ::std::mem::transmute(ucol_openAvailableLocales(::std::mem::transmute(status)))
17967     }
17968     #[cfg(not(windows))]
17969     unimplemented!("Unsupported target OS");
17970 }
17971 #[inline]
ucol_openBinary(bin: *const u8, length: i32, base: *const UCollator, status: *mut UErrorCode) -> *mut UCollator17972 pub unsafe fn ucol_openBinary(bin: *const u8, length: i32, base: *const UCollator, status: *mut UErrorCode) -> *mut UCollator {
17973     #[cfg(windows)]
17974     {
17975         #[link(name = "windows")]
17976         extern "system" {
17977             fn ucol_openBinary(bin: *const u8, length: i32, base: *const UCollator, status: *mut UErrorCode) -> *mut UCollator;
17978         }
17979         ::std::mem::transmute(ucol_openBinary(::std::mem::transmute(bin), ::std::mem::transmute(length), ::std::mem::transmute(base), ::std::mem::transmute(status)))
17980     }
17981     #[cfg(not(windows))]
17982     unimplemented!("Unsupported target OS");
17983 }
17984 #[inline]
ucol_openElements(coll: *const UCollator, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UCollationElements17985 pub unsafe fn ucol_openElements(coll: *const UCollator, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UCollationElements {
17986     #[cfg(windows)]
17987     {
17988         #[link(name = "windows")]
17989         extern "system" {
17990             fn ucol_openElements(coll: *const UCollator, text: *const u16, textlength: i32, status: *mut UErrorCode) -> *mut UCollationElements;
17991         }
17992         ::std::mem::transmute(ucol_openElements(::std::mem::transmute(coll), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
17993     }
17994     #[cfg(not(windows))]
17995     unimplemented!("Unsupported target OS");
17996 }
17997 #[inline]
ucol_openRules(rules: *const u16, ruleslength: i32, normalizationmode: UColAttributeValue, strength: UColAttributeValue, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut UCollator17998 pub unsafe fn ucol_openRules(rules: *const u16, ruleslength: i32, normalizationmode: UColAttributeValue, strength: UColAttributeValue, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut UCollator {
17999     #[cfg(windows)]
18000     {
18001         #[link(name = "windows")]
18002         extern "system" {
18003             fn ucol_openRules(rules: *const u16, ruleslength: i32, normalizationmode: UColAttributeValue, strength: UColAttributeValue, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut UCollator;
18004         }
18005         ::std::mem::transmute(ucol_openRules(::std::mem::transmute(rules), ::std::mem::transmute(ruleslength), ::std::mem::transmute(normalizationmode), ::std::mem::transmute(strength), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
18006     }
18007     #[cfg(not(windows))]
18008     unimplemented!("Unsupported target OS");
18009 }
18010 #[inline]
ucol_previous(elems: *mut UCollationElements, status: *mut UErrorCode) -> i3218011 pub unsafe fn ucol_previous(elems: *mut UCollationElements, status: *mut UErrorCode) -> i32 {
18012     #[cfg(windows)]
18013     {
18014         #[link(name = "windows")]
18015         extern "system" {
18016             fn ucol_previous(elems: *mut UCollationElements, status: *mut UErrorCode) -> i32;
18017         }
18018         ::std::mem::transmute(ucol_previous(::std::mem::transmute(elems), ::std::mem::transmute(status)))
18019     }
18020     #[cfg(not(windows))]
18021     unimplemented!("Unsupported target OS");
18022 }
18023 #[inline]
ucol_primaryOrder(order: i32) -> i3218024 pub unsafe fn ucol_primaryOrder(order: i32) -> i32 {
18025     #[cfg(windows)]
18026     {
18027         #[link(name = "windows")]
18028         extern "system" {
18029             fn ucol_primaryOrder(order: i32) -> i32;
18030         }
18031         ::std::mem::transmute(ucol_primaryOrder(::std::mem::transmute(order)))
18032     }
18033     #[cfg(not(windows))]
18034     unimplemented!("Unsupported target OS");
18035 }
18036 #[inline]
ucol_reset(elems: *mut UCollationElements)18037 pub unsafe fn ucol_reset(elems: *mut UCollationElements) {
18038     #[cfg(windows)]
18039     {
18040         #[link(name = "windows")]
18041         extern "system" {
18042             fn ucol_reset(elems: *mut UCollationElements);
18043         }
18044         ::std::mem::transmute(ucol_reset(::std::mem::transmute(elems)))
18045     }
18046     #[cfg(not(windows))]
18047     unimplemented!("Unsupported target OS");
18048 }
18049 #[inline]
ucol_safeClone(coll: *const UCollator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UCollator18050 pub unsafe fn ucol_safeClone(coll: *const UCollator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UCollator {
18051     #[cfg(windows)]
18052     {
18053         #[link(name = "windows")]
18054         extern "system" {
18055             fn ucol_safeClone(coll: *const UCollator, stackbuffer: *mut ::std::ffi::c_void, pbuffersize: *mut i32, status: *mut UErrorCode) -> *mut UCollator;
18056         }
18057         ::std::mem::transmute(ucol_safeClone(::std::mem::transmute(coll), ::std::mem::transmute(stackbuffer), ::std::mem::transmute(pbuffersize), ::std::mem::transmute(status)))
18058     }
18059     #[cfg(not(windows))]
18060     unimplemented!("Unsupported target OS");
18061 }
18062 #[inline]
ucol_secondaryOrder(order: i32) -> i3218063 pub unsafe fn ucol_secondaryOrder(order: i32) -> i32 {
18064     #[cfg(windows)]
18065     {
18066         #[link(name = "windows")]
18067         extern "system" {
18068             fn ucol_secondaryOrder(order: i32) -> i32;
18069         }
18070         ::std::mem::transmute(ucol_secondaryOrder(::std::mem::transmute(order)))
18071     }
18072     #[cfg(not(windows))]
18073     unimplemented!("Unsupported target OS");
18074 }
18075 #[inline]
ucol_setAttribute(coll: *mut UCollator, attr: UColAttribute, value: UColAttributeValue, status: *mut UErrorCode)18076 pub unsafe fn ucol_setAttribute(coll: *mut UCollator, attr: UColAttribute, value: UColAttributeValue, status: *mut UErrorCode) {
18077     #[cfg(windows)]
18078     {
18079         #[link(name = "windows")]
18080         extern "system" {
18081             fn ucol_setAttribute(coll: *mut UCollator, attr: UColAttribute, value: UColAttributeValue, status: *mut UErrorCode);
18082         }
18083         ::std::mem::transmute(ucol_setAttribute(::std::mem::transmute(coll), ::std::mem::transmute(attr), ::std::mem::transmute(value), ::std::mem::transmute(status)))
18084     }
18085     #[cfg(not(windows))]
18086     unimplemented!("Unsupported target OS");
18087 }
18088 #[inline]
ucol_setMaxVariable(coll: *mut UCollator, group: UColReorderCode, perrorcode: *mut UErrorCode)18089 pub unsafe fn ucol_setMaxVariable(coll: *mut UCollator, group: UColReorderCode, perrorcode: *mut UErrorCode) {
18090     #[cfg(windows)]
18091     {
18092         #[link(name = "windows")]
18093         extern "system" {
18094             fn ucol_setMaxVariable(coll: *mut UCollator, group: UColReorderCode, perrorcode: *mut UErrorCode);
18095         }
18096         ::std::mem::transmute(ucol_setMaxVariable(::std::mem::transmute(coll), ::std::mem::transmute(group), ::std::mem::transmute(perrorcode)))
18097     }
18098     #[cfg(not(windows))]
18099     unimplemented!("Unsupported target OS");
18100 }
18101 #[inline]
ucol_setOffset(elems: *mut UCollationElements, offset: i32, status: *mut UErrorCode)18102 pub unsafe fn ucol_setOffset(elems: *mut UCollationElements, offset: i32, status: *mut UErrorCode) {
18103     #[cfg(windows)]
18104     {
18105         #[link(name = "windows")]
18106         extern "system" {
18107             fn ucol_setOffset(elems: *mut UCollationElements, offset: i32, status: *mut UErrorCode);
18108         }
18109         ::std::mem::transmute(ucol_setOffset(::std::mem::transmute(elems), ::std::mem::transmute(offset), ::std::mem::transmute(status)))
18110     }
18111     #[cfg(not(windows))]
18112     unimplemented!("Unsupported target OS");
18113 }
18114 #[inline]
ucol_setReorderCodes(coll: *mut UCollator, reordercodes: *const i32, reordercodeslength: i32, perrorcode: *mut UErrorCode)18115 pub unsafe fn ucol_setReorderCodes(coll: *mut UCollator, reordercodes: *const i32, reordercodeslength: i32, perrorcode: *mut UErrorCode) {
18116     #[cfg(windows)]
18117     {
18118         #[link(name = "windows")]
18119         extern "system" {
18120             fn ucol_setReorderCodes(coll: *mut UCollator, reordercodes: *const i32, reordercodeslength: i32, perrorcode: *mut UErrorCode);
18121         }
18122         ::std::mem::transmute(ucol_setReorderCodes(::std::mem::transmute(coll), ::std::mem::transmute(reordercodes), ::std::mem::transmute(reordercodeslength), ::std::mem::transmute(perrorcode)))
18123     }
18124     #[cfg(not(windows))]
18125     unimplemented!("Unsupported target OS");
18126 }
18127 #[inline]
ucol_setStrength(coll: *mut UCollator, strength: UColAttributeValue)18128 pub unsafe fn ucol_setStrength(coll: *mut UCollator, strength: UColAttributeValue) {
18129     #[cfg(windows)]
18130     {
18131         #[link(name = "windows")]
18132         extern "system" {
18133             fn ucol_setStrength(coll: *mut UCollator, strength: UColAttributeValue);
18134         }
18135         ::std::mem::transmute(ucol_setStrength(::std::mem::transmute(coll), ::std::mem::transmute(strength)))
18136     }
18137     #[cfg(not(windows))]
18138     unimplemented!("Unsupported target OS");
18139 }
18140 #[inline]
ucol_setText(elems: *mut UCollationElements, text: *const u16, textlength: i32, status: *mut UErrorCode)18141 pub unsafe fn ucol_setText(elems: *mut UCollationElements, text: *const u16, textlength: i32, status: *mut UErrorCode) {
18142     #[cfg(windows)]
18143     {
18144         #[link(name = "windows")]
18145         extern "system" {
18146             fn ucol_setText(elems: *mut UCollationElements, text: *const u16, textlength: i32, status: *mut UErrorCode);
18147         }
18148         ::std::mem::transmute(ucol_setText(::std::mem::transmute(elems), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
18149     }
18150     #[cfg(not(windows))]
18151     unimplemented!("Unsupported target OS");
18152 }
18153 #[inline]
ucol_strcoll(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> UCollationResult18154 pub unsafe fn ucol_strcoll(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> UCollationResult {
18155     #[cfg(windows)]
18156     {
18157         #[link(name = "windows")]
18158         extern "system" {
18159             fn ucol_strcoll(coll: *const UCollator, source: *const u16, sourcelength: i32, target: *const u16, targetlength: i32) -> UCollationResult;
18160         }
18161         ::std::mem::transmute(ucol_strcoll(::std::mem::transmute(coll), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(target), ::std::mem::transmute(targetlength)))
18162     }
18163     #[cfg(not(windows))]
18164     unimplemented!("Unsupported target OS");
18165 }
18166 #[inline]
ucol_strcollIter(coll: *const UCollator, siter: *mut UCharIterator, titer: *mut UCharIterator, status: *mut UErrorCode) -> UCollationResult18167 pub unsafe fn ucol_strcollIter(coll: *const UCollator, siter: *mut UCharIterator, titer: *mut UCharIterator, status: *mut UErrorCode) -> UCollationResult {
18168     #[cfg(windows)]
18169     {
18170         #[link(name = "windows")]
18171         extern "system" {
18172             fn ucol_strcollIter(coll: *const UCollator, siter: *mut ::std::mem::ManuallyDrop<UCharIterator>, titer: *mut ::std::mem::ManuallyDrop<UCharIterator>, status: *mut UErrorCode) -> UCollationResult;
18173         }
18174         ::std::mem::transmute(ucol_strcollIter(::std::mem::transmute(coll), ::std::mem::transmute(siter), ::std::mem::transmute(titer), ::std::mem::transmute(status)))
18175     }
18176     #[cfg(not(windows))]
18177     unimplemented!("Unsupported target OS");
18178 }
18179 #[cfg(feature = "Win32_Foundation")]
18180 #[inline]
ucol_strcollUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(coll: *const UCollator, source: Param1, sourcelength: i32, target: Param3, targetlength: i32, status: *mut UErrorCode) -> UCollationResult18181 pub unsafe fn ucol_strcollUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(coll: *const UCollator, source: Param1, sourcelength: i32, target: Param3, targetlength: i32, status: *mut UErrorCode) -> UCollationResult {
18182     #[cfg(windows)]
18183     {
18184         #[link(name = "windows")]
18185         extern "system" {
18186             fn ucol_strcollUTF8(coll: *const UCollator, source: super::Foundation::PSTR, sourcelength: i32, target: super::Foundation::PSTR, targetlength: i32, status: *mut UErrorCode) -> UCollationResult;
18187         }
18188         ::std::mem::transmute(ucol_strcollUTF8(::std::mem::transmute(coll), source.into_param().abi(), ::std::mem::transmute(sourcelength), target.into_param().abi(), ::std::mem::transmute(targetlength), ::std::mem::transmute(status)))
18189     }
18190     #[cfg(not(windows))]
18191     unimplemented!("Unsupported target OS");
18192 }
18193 #[inline]
ucol_tertiaryOrder(order: i32) -> i3218194 pub unsafe fn ucol_tertiaryOrder(order: i32) -> i32 {
18195     #[cfg(windows)]
18196     {
18197         #[link(name = "windows")]
18198         extern "system" {
18199             fn ucol_tertiaryOrder(order: i32) -> i32;
18200         }
18201         ::std::mem::transmute(ucol_tertiaryOrder(::std::mem::transmute(order)))
18202     }
18203     #[cfg(not(windows))]
18204     unimplemented!("Unsupported target OS");
18205 }
18206 #[inline]
ucpmap_get(map: *const UCPMap, c: i32) -> u3218207 pub unsafe fn ucpmap_get(map: *const UCPMap, c: i32) -> u32 {
18208     #[cfg(windows)]
18209     {
18210         #[link(name = "windows")]
18211         extern "system" {
18212             fn ucpmap_get(map: *const UCPMap, c: i32) -> u32;
18213         }
18214         ::std::mem::transmute(ucpmap_get(::std::mem::transmute(map), ::std::mem::transmute(c)))
18215     }
18216     #[cfg(not(windows))]
18217     unimplemented!("Unsupported target OS");
18218 }
18219 #[inline]
ucpmap_getRange(map: *const UCPMap, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i3218220 pub unsafe fn ucpmap_getRange(map: *const UCPMap, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32 {
18221     #[cfg(windows)]
18222     {
18223         #[link(name = "windows")]
18224         extern "system" {
18225             fn ucpmap_getRange(map: *const UCPMap, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32;
18226         }
18227         ::std::mem::transmute(ucpmap_getRange(::std::mem::transmute(map), ::std::mem::transmute(start), ::std::mem::transmute(option), ::std::mem::transmute(surrogatevalue), ::std::mem::transmute(filter), ::std::mem::transmute(context), ::std::mem::transmute(pvalue)))
18228     }
18229     #[cfg(not(windows))]
18230     unimplemented!("Unsupported target OS");
18231 }
18232 #[inline]
ucptrie_close(trie: *mut UCPTrie)18233 pub unsafe fn ucptrie_close(trie: *mut UCPTrie) {
18234     #[cfg(windows)]
18235     {
18236         #[link(name = "windows")]
18237         extern "system" {
18238             fn ucptrie_close(trie: *mut UCPTrie);
18239         }
18240         ::std::mem::transmute(ucptrie_close(::std::mem::transmute(trie)))
18241     }
18242     #[cfg(not(windows))]
18243     unimplemented!("Unsupported target OS");
18244 }
18245 #[inline]
ucptrie_get(trie: *const UCPTrie, c: i32) -> u3218246 pub unsafe fn ucptrie_get(trie: *const UCPTrie, c: i32) -> u32 {
18247     #[cfg(windows)]
18248     {
18249         #[link(name = "windows")]
18250         extern "system" {
18251             fn ucptrie_get(trie: *const UCPTrie, c: i32) -> u32;
18252         }
18253         ::std::mem::transmute(ucptrie_get(::std::mem::transmute(trie), ::std::mem::transmute(c)))
18254     }
18255     #[cfg(not(windows))]
18256     unimplemented!("Unsupported target OS");
18257 }
18258 #[inline]
ucptrie_getRange(trie: *const UCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i3218259 pub unsafe fn ucptrie_getRange(trie: *const UCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32 {
18260     #[cfg(windows)]
18261     {
18262         #[link(name = "windows")]
18263         extern "system" {
18264             fn ucptrie_getRange(trie: *const UCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32;
18265         }
18266         ::std::mem::transmute(ucptrie_getRange(::std::mem::transmute(trie), ::std::mem::transmute(start), ::std::mem::transmute(option), ::std::mem::transmute(surrogatevalue), ::std::mem::transmute(filter), ::std::mem::transmute(context), ::std::mem::transmute(pvalue)))
18267     }
18268     #[cfg(not(windows))]
18269     unimplemented!("Unsupported target OS");
18270 }
18271 #[inline]
ucptrie_getType(trie: *const UCPTrie) -> UCPTrieType18272 pub unsafe fn ucptrie_getType(trie: *const UCPTrie) -> UCPTrieType {
18273     #[cfg(windows)]
18274     {
18275         #[link(name = "windows")]
18276         extern "system" {
18277             fn ucptrie_getType(trie: *const UCPTrie) -> UCPTrieType;
18278         }
18279         ::std::mem::transmute(ucptrie_getType(::std::mem::transmute(trie)))
18280     }
18281     #[cfg(not(windows))]
18282     unimplemented!("Unsupported target OS");
18283 }
18284 #[inline]
ucptrie_getValueWidth(trie: *const UCPTrie) -> UCPTrieValueWidth18285 pub unsafe fn ucptrie_getValueWidth(trie: *const UCPTrie) -> UCPTrieValueWidth {
18286     #[cfg(windows)]
18287     {
18288         #[link(name = "windows")]
18289         extern "system" {
18290             fn ucptrie_getValueWidth(trie: *const UCPTrie) -> UCPTrieValueWidth;
18291         }
18292         ::std::mem::transmute(ucptrie_getValueWidth(::std::mem::transmute(trie)))
18293     }
18294     #[cfg(not(windows))]
18295     unimplemented!("Unsupported target OS");
18296 }
18297 #[inline]
ucptrie_internalSmallIndex(trie: *const UCPTrie, c: i32) -> i3218298 pub unsafe fn ucptrie_internalSmallIndex(trie: *const UCPTrie, c: i32) -> i32 {
18299     #[cfg(windows)]
18300     {
18301         #[link(name = "windows")]
18302         extern "system" {
18303             fn ucptrie_internalSmallIndex(trie: *const UCPTrie, c: i32) -> i32;
18304         }
18305         ::std::mem::transmute(ucptrie_internalSmallIndex(::std::mem::transmute(trie), ::std::mem::transmute(c)))
18306     }
18307     #[cfg(not(windows))]
18308     unimplemented!("Unsupported target OS");
18309 }
18310 #[inline]
ucptrie_internalSmallU8Index(trie: *const UCPTrie, lt1: i32, t2: u8, t3: u8) -> i3218311 pub unsafe fn ucptrie_internalSmallU8Index(trie: *const UCPTrie, lt1: i32, t2: u8, t3: u8) -> i32 {
18312     #[cfg(windows)]
18313     {
18314         #[link(name = "windows")]
18315         extern "system" {
18316             fn ucptrie_internalSmallU8Index(trie: *const UCPTrie, lt1: i32, t2: u8, t3: u8) -> i32;
18317         }
18318         ::std::mem::transmute(ucptrie_internalSmallU8Index(::std::mem::transmute(trie), ::std::mem::transmute(lt1), ::std::mem::transmute(t2), ::std::mem::transmute(t3)))
18319     }
18320     #[cfg(not(windows))]
18321     unimplemented!("Unsupported target OS");
18322 }
18323 #[inline]
ucptrie_internalU8PrevIndex(trie: *const UCPTrie, c: i32, start: *const u8, src: *const u8) -> i3218324 pub unsafe fn ucptrie_internalU8PrevIndex(trie: *const UCPTrie, c: i32, start: *const u8, src: *const u8) -> i32 {
18325     #[cfg(windows)]
18326     {
18327         #[link(name = "windows")]
18328         extern "system" {
18329             fn ucptrie_internalU8PrevIndex(trie: *const UCPTrie, c: i32, start: *const u8, src: *const u8) -> i32;
18330         }
18331         ::std::mem::transmute(ucptrie_internalU8PrevIndex(::std::mem::transmute(trie), ::std::mem::transmute(c), ::std::mem::transmute(start), ::std::mem::transmute(src)))
18332     }
18333     #[cfg(not(windows))]
18334     unimplemented!("Unsupported target OS");
18335 }
18336 #[inline]
ucptrie_openFromBinary(r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut UCPTrie18337 pub unsafe fn ucptrie_openFromBinary(r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut UCPTrie {
18338     #[cfg(windows)]
18339     {
18340         #[link(name = "windows")]
18341         extern "system" {
18342             fn ucptrie_openFromBinary(r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut UCPTrie;
18343         }
18344         ::std::mem::transmute(ucptrie_openFromBinary(::std::mem::transmute(r#type), ::std::mem::transmute(valuewidth), ::std::mem::transmute(data), ::std::mem::transmute(length), ::std::mem::transmute(pactuallength), ::std::mem::transmute(perrorcode)))
18345     }
18346     #[cfg(not(windows))]
18347     unimplemented!("Unsupported target OS");
18348 }
18349 #[inline]
ucptrie_toBinary(trie: *const UCPTrie, data: *mut ::std::ffi::c_void, capacity: i32, perrorcode: *mut UErrorCode) -> i3218350 pub unsafe fn ucptrie_toBinary(trie: *const UCPTrie, data: *mut ::std::ffi::c_void, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
18351     #[cfg(windows)]
18352     {
18353         #[link(name = "windows")]
18354         extern "system" {
18355             fn ucptrie_toBinary(trie: *const UCPTrie, data: *mut ::std::ffi::c_void, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
18356         }
18357         ::std::mem::transmute(ucptrie_toBinary(::std::mem::transmute(trie), ::std::mem::transmute(data), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
18358     }
18359     #[cfg(not(windows))]
18360     unimplemented!("Unsupported target OS");
18361 }
18362 #[inline]
ucsdet_close(ucsd: *mut UCharsetDetector)18363 pub unsafe fn ucsdet_close(ucsd: *mut UCharsetDetector) {
18364     #[cfg(windows)]
18365     {
18366         #[link(name = "windows")]
18367         extern "system" {
18368             fn ucsdet_close(ucsd: *mut UCharsetDetector);
18369         }
18370         ::std::mem::transmute(ucsdet_close(::std::mem::transmute(ucsd)))
18371     }
18372     #[cfg(not(windows))]
18373     unimplemented!("Unsupported target OS");
18374 }
18375 #[inline]
ucsdet_detect(ucsd: *mut UCharsetDetector, status: *mut UErrorCode) -> *mut UCharsetMatch18376 pub unsafe fn ucsdet_detect(ucsd: *mut UCharsetDetector, status: *mut UErrorCode) -> *mut UCharsetMatch {
18377     #[cfg(windows)]
18378     {
18379         #[link(name = "windows")]
18380         extern "system" {
18381             fn ucsdet_detect(ucsd: *mut UCharsetDetector, status: *mut UErrorCode) -> *mut UCharsetMatch;
18382         }
18383         ::std::mem::transmute(ucsdet_detect(::std::mem::transmute(ucsd), ::std::mem::transmute(status)))
18384     }
18385     #[cfg(not(windows))]
18386     unimplemented!("Unsupported target OS");
18387 }
18388 #[inline]
ucsdet_detectAll(ucsd: *mut UCharsetDetector, matchesfound: *mut i32, status: *mut UErrorCode) -> *mut *mut UCharsetMatch18389 pub unsafe fn ucsdet_detectAll(ucsd: *mut UCharsetDetector, matchesfound: *mut i32, status: *mut UErrorCode) -> *mut *mut UCharsetMatch {
18390     #[cfg(windows)]
18391     {
18392         #[link(name = "windows")]
18393         extern "system" {
18394             fn ucsdet_detectAll(ucsd: *mut UCharsetDetector, matchesfound: *mut i32, status: *mut UErrorCode) -> *mut *mut UCharsetMatch;
18395         }
18396         ::std::mem::transmute(ucsdet_detectAll(::std::mem::transmute(ucsd), ::std::mem::transmute(matchesfound), ::std::mem::transmute(status)))
18397     }
18398     #[cfg(not(windows))]
18399     unimplemented!("Unsupported target OS");
18400 }
18401 #[inline]
ucsdet_enableInputFilter(ucsd: *mut UCharsetDetector, filter: i8) -> i818402 pub unsafe fn ucsdet_enableInputFilter(ucsd: *mut UCharsetDetector, filter: i8) -> i8 {
18403     #[cfg(windows)]
18404     {
18405         #[link(name = "windows")]
18406         extern "system" {
18407             fn ucsdet_enableInputFilter(ucsd: *mut UCharsetDetector, filter: i8) -> i8;
18408         }
18409         ::std::mem::transmute(ucsdet_enableInputFilter(::std::mem::transmute(ucsd), ::std::mem::transmute(filter)))
18410     }
18411     #[cfg(not(windows))]
18412     unimplemented!("Unsupported target OS");
18413 }
18414 #[inline]
ucsdet_getAllDetectableCharsets(ucsd: *const UCharsetDetector, status: *mut UErrorCode) -> *mut UEnumeration18415 pub unsafe fn ucsdet_getAllDetectableCharsets(ucsd: *const UCharsetDetector, status: *mut UErrorCode) -> *mut UEnumeration {
18416     #[cfg(windows)]
18417     {
18418         #[link(name = "windows")]
18419         extern "system" {
18420             fn ucsdet_getAllDetectableCharsets(ucsd: *const UCharsetDetector, status: *mut UErrorCode) -> *mut UEnumeration;
18421         }
18422         ::std::mem::transmute(ucsdet_getAllDetectableCharsets(::std::mem::transmute(ucsd), ::std::mem::transmute(status)))
18423     }
18424     #[cfg(not(windows))]
18425     unimplemented!("Unsupported target OS");
18426 }
18427 #[inline]
ucsdet_getConfidence(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> i3218428 pub unsafe fn ucsdet_getConfidence(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> i32 {
18429     #[cfg(windows)]
18430     {
18431         #[link(name = "windows")]
18432         extern "system" {
18433             fn ucsdet_getConfidence(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> i32;
18434         }
18435         ::std::mem::transmute(ucsdet_getConfidence(::std::mem::transmute(ucsm), ::std::mem::transmute(status)))
18436     }
18437     #[cfg(not(windows))]
18438     unimplemented!("Unsupported target OS");
18439 }
18440 #[cfg(feature = "Win32_Foundation")]
18441 #[inline]
ucsdet_getLanguage(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR18442 pub unsafe fn ucsdet_getLanguage(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR {
18443     #[cfg(windows)]
18444     {
18445         #[link(name = "windows")]
18446         extern "system" {
18447             fn ucsdet_getLanguage(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR;
18448         }
18449         ::std::mem::transmute(ucsdet_getLanguage(::std::mem::transmute(ucsm), ::std::mem::transmute(status)))
18450     }
18451     #[cfg(not(windows))]
18452     unimplemented!("Unsupported target OS");
18453 }
18454 #[cfg(feature = "Win32_Foundation")]
18455 #[inline]
ucsdet_getName(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR18456 pub unsafe fn ucsdet_getName(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR {
18457     #[cfg(windows)]
18458     {
18459         #[link(name = "windows")]
18460         extern "system" {
18461             fn ucsdet_getName(ucsm: *const UCharsetMatch, status: *mut UErrorCode) -> super::Foundation::PSTR;
18462         }
18463         ::std::mem::transmute(ucsdet_getName(::std::mem::transmute(ucsm), ::std::mem::transmute(status)))
18464     }
18465     #[cfg(not(windows))]
18466     unimplemented!("Unsupported target OS");
18467 }
18468 #[inline]
ucsdet_getUChars(ucsm: *const UCharsetMatch, buf: *mut u16, cap: i32, status: *mut UErrorCode) -> i3218469 pub unsafe fn ucsdet_getUChars(ucsm: *const UCharsetMatch, buf: *mut u16, cap: i32, status: *mut UErrorCode) -> i32 {
18470     #[cfg(windows)]
18471     {
18472         #[link(name = "windows")]
18473         extern "system" {
18474             fn ucsdet_getUChars(ucsm: *const UCharsetMatch, buf: *mut u16, cap: i32, status: *mut UErrorCode) -> i32;
18475         }
18476         ::std::mem::transmute(ucsdet_getUChars(::std::mem::transmute(ucsm), ::std::mem::transmute(buf), ::std::mem::transmute(cap), ::std::mem::transmute(status)))
18477     }
18478     #[cfg(not(windows))]
18479     unimplemented!("Unsupported target OS");
18480 }
18481 #[inline]
ucsdet_isInputFilterEnabled(ucsd: *const UCharsetDetector) -> i818482 pub unsafe fn ucsdet_isInputFilterEnabled(ucsd: *const UCharsetDetector) -> i8 {
18483     #[cfg(windows)]
18484     {
18485         #[link(name = "windows")]
18486         extern "system" {
18487             fn ucsdet_isInputFilterEnabled(ucsd: *const UCharsetDetector) -> i8;
18488         }
18489         ::std::mem::transmute(ucsdet_isInputFilterEnabled(::std::mem::transmute(ucsd)))
18490     }
18491     #[cfg(not(windows))]
18492     unimplemented!("Unsupported target OS");
18493 }
18494 #[inline]
ucsdet_open(status: *mut UErrorCode) -> *mut UCharsetDetector18495 pub unsafe fn ucsdet_open(status: *mut UErrorCode) -> *mut UCharsetDetector {
18496     #[cfg(windows)]
18497     {
18498         #[link(name = "windows")]
18499         extern "system" {
18500             fn ucsdet_open(status: *mut UErrorCode) -> *mut UCharsetDetector;
18501         }
18502         ::std::mem::transmute(ucsdet_open(::std::mem::transmute(status)))
18503     }
18504     #[cfg(not(windows))]
18505     unimplemented!("Unsupported target OS");
18506 }
18507 #[cfg(feature = "Win32_Foundation")]
18508 #[inline]
ucsdet_setDeclaredEncoding<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ucsd: *mut UCharsetDetector, encoding: Param1, length: i32, status: *mut UErrorCode)18509 pub unsafe fn ucsdet_setDeclaredEncoding<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ucsd: *mut UCharsetDetector, encoding: Param1, length: i32, status: *mut UErrorCode) {
18510     #[cfg(windows)]
18511     {
18512         #[link(name = "windows")]
18513         extern "system" {
18514             fn ucsdet_setDeclaredEncoding(ucsd: *mut UCharsetDetector, encoding: super::Foundation::PSTR, length: i32, status: *mut UErrorCode);
18515         }
18516         ::std::mem::transmute(ucsdet_setDeclaredEncoding(::std::mem::transmute(ucsd), encoding.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(status)))
18517     }
18518     #[cfg(not(windows))]
18519     unimplemented!("Unsupported target OS");
18520 }
18521 #[cfg(feature = "Win32_Foundation")]
18522 #[inline]
ucsdet_setText<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ucsd: *mut UCharsetDetector, textin: Param1, len: i32, status: *mut UErrorCode)18523 pub unsafe fn ucsdet_setText<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ucsd: *mut UCharsetDetector, textin: Param1, len: i32, status: *mut UErrorCode) {
18524     #[cfg(windows)]
18525     {
18526         #[link(name = "windows")]
18527         extern "system" {
18528             fn ucsdet_setText(ucsd: *mut UCharsetDetector, textin: super::Foundation::PSTR, len: i32, status: *mut UErrorCode);
18529         }
18530         ::std::mem::transmute(ucsdet_setText(::std::mem::transmute(ucsd), textin.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(status)))
18531     }
18532     #[cfg(not(windows))]
18533     unimplemented!("Unsupported target OS");
18534 }
18535 #[cfg(feature = "Win32_Foundation")]
18536 #[inline]
ucurr_countCurrencies<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, date: f64, ec: *mut UErrorCode) -> i3218537 pub unsafe fn ucurr_countCurrencies<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, date: f64, ec: *mut UErrorCode) -> i32 {
18538     #[cfg(windows)]
18539     {
18540         #[link(name = "windows")]
18541         extern "system" {
18542             fn ucurr_countCurrencies(locale: super::Foundation::PSTR, date: f64, ec: *mut UErrorCode) -> i32;
18543         }
18544         ::std::mem::transmute(ucurr_countCurrencies(locale.into_param().abi(), ::std::mem::transmute(date), ::std::mem::transmute(ec)))
18545     }
18546     #[cfg(not(windows))]
18547     unimplemented!("Unsupported target OS");
18548 }
18549 #[cfg(feature = "Win32_Foundation")]
18550 #[inline]
ucurr_forLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i3218551 pub unsafe fn ucurr_forLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i32 {
18552     #[cfg(windows)]
18553     {
18554         #[link(name = "windows")]
18555         extern "system" {
18556             fn ucurr_forLocale(locale: super::Foundation::PSTR, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i32;
18557         }
18558         ::std::mem::transmute(ucurr_forLocale(locale.into_param().abi(), ::std::mem::transmute(buff), ::std::mem::transmute(buffcapacity), ::std::mem::transmute(ec)))
18559     }
18560     #[cfg(not(windows))]
18561     unimplemented!("Unsupported target OS");
18562 }
18563 #[cfg(feature = "Win32_Foundation")]
18564 #[inline]
ucurr_forLocaleAndDate<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, date: f64, index: i32, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i3218565 pub unsafe fn ucurr_forLocaleAndDate<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, date: f64, index: i32, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i32 {
18566     #[cfg(windows)]
18567     {
18568         #[link(name = "windows")]
18569         extern "system" {
18570             fn ucurr_forLocaleAndDate(locale: super::Foundation::PSTR, date: f64, index: i32, buff: *mut u16, buffcapacity: i32, ec: *mut UErrorCode) -> i32;
18571         }
18572         ::std::mem::transmute(ucurr_forLocaleAndDate(locale.into_param().abi(), ::std::mem::transmute(date), ::std::mem::transmute(index), ::std::mem::transmute(buff), ::std::mem::transmute(buffcapacity), ::std::mem::transmute(ec)))
18573     }
18574     #[cfg(not(windows))]
18575     unimplemented!("Unsupported target OS");
18576 }
18577 #[inline]
ucurr_getDefaultFractionDigits(currency: *const u16, ec: *mut UErrorCode) -> i3218578 pub unsafe fn ucurr_getDefaultFractionDigits(currency: *const u16, ec: *mut UErrorCode) -> i32 {
18579     #[cfg(windows)]
18580     {
18581         #[link(name = "windows")]
18582         extern "system" {
18583             fn ucurr_getDefaultFractionDigits(currency: *const u16, ec: *mut UErrorCode) -> i32;
18584         }
18585         ::std::mem::transmute(ucurr_getDefaultFractionDigits(::std::mem::transmute(currency), ::std::mem::transmute(ec)))
18586     }
18587     #[cfg(not(windows))]
18588     unimplemented!("Unsupported target OS");
18589 }
18590 #[inline]
ucurr_getDefaultFractionDigitsForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> i3218591 pub unsafe fn ucurr_getDefaultFractionDigitsForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> i32 {
18592     #[cfg(windows)]
18593     {
18594         #[link(name = "windows")]
18595         extern "system" {
18596             fn ucurr_getDefaultFractionDigitsForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> i32;
18597         }
18598         ::std::mem::transmute(ucurr_getDefaultFractionDigitsForUsage(::std::mem::transmute(currency), ::std::mem::transmute(usage), ::std::mem::transmute(ec)))
18599     }
18600     #[cfg(not(windows))]
18601     unimplemented!("Unsupported target OS");
18602 }
18603 #[cfg(feature = "Win32_Foundation")]
18604 #[inline]
ucurr_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration18605 pub unsafe fn ucurr_getKeywordValuesForLocale<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(key: Param0, locale: Param1, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration {
18606     #[cfg(windows)]
18607     {
18608         #[link(name = "windows")]
18609         extern "system" {
18610             fn ucurr_getKeywordValuesForLocale(key: super::Foundation::PSTR, locale: super::Foundation::PSTR, commonlyused: i8, status: *mut UErrorCode) -> *mut UEnumeration;
18611         }
18612         ::std::mem::transmute(ucurr_getKeywordValuesForLocale(key.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(commonlyused), ::std::mem::transmute(status)))
18613     }
18614     #[cfg(not(windows))]
18615     unimplemented!("Unsupported target OS");
18616 }
18617 #[cfg(feature = "Win32_Foundation")]
18618 #[inline]
ucurr_getName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(currency: *const u16, locale: Param1, namestyle: UCurrNameStyle, ischoiceformat: *mut i8, len: *mut i32, ec: *mut UErrorCode) -> *mut u1618619 pub unsafe fn ucurr_getName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(currency: *const u16, locale: Param1, namestyle: UCurrNameStyle, ischoiceformat: *mut i8, len: *mut i32, ec: *mut UErrorCode) -> *mut u16 {
18620     #[cfg(windows)]
18621     {
18622         #[link(name = "windows")]
18623         extern "system" {
18624             fn ucurr_getName(currency: *const u16, locale: super::Foundation::PSTR, namestyle: UCurrNameStyle, ischoiceformat: *mut i8, len: *mut i32, ec: *mut UErrorCode) -> *mut u16;
18625         }
18626         ::std::mem::transmute(ucurr_getName(::std::mem::transmute(currency), locale.into_param().abi(), ::std::mem::transmute(namestyle), ::std::mem::transmute(ischoiceformat), ::std::mem::transmute(len), ::std::mem::transmute(ec)))
18627     }
18628     #[cfg(not(windows))]
18629     unimplemented!("Unsupported target OS");
18630 }
18631 #[inline]
ucurr_getNumericCode(currency: *const u16) -> i3218632 pub unsafe fn ucurr_getNumericCode(currency: *const u16) -> i32 {
18633     #[cfg(windows)]
18634     {
18635         #[link(name = "windows")]
18636         extern "system" {
18637             fn ucurr_getNumericCode(currency: *const u16) -> i32;
18638         }
18639         ::std::mem::transmute(ucurr_getNumericCode(::std::mem::transmute(currency)))
18640     }
18641     #[cfg(not(windows))]
18642     unimplemented!("Unsupported target OS");
18643 }
18644 #[cfg(feature = "Win32_Foundation")]
18645 #[inline]
ucurr_getPluralName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(currency: *const u16, locale: Param1, ischoiceformat: *mut i8, pluralcount: Param3, len: *mut i32, ec: *mut UErrorCode) -> *mut u1618646 pub unsafe fn ucurr_getPluralName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(currency: *const u16, locale: Param1, ischoiceformat: *mut i8, pluralcount: Param3, len: *mut i32, ec: *mut UErrorCode) -> *mut u16 {
18647     #[cfg(windows)]
18648     {
18649         #[link(name = "windows")]
18650         extern "system" {
18651             fn ucurr_getPluralName(currency: *const u16, locale: super::Foundation::PSTR, ischoiceformat: *mut i8, pluralcount: super::Foundation::PSTR, len: *mut i32, ec: *mut UErrorCode) -> *mut u16;
18652         }
18653         ::std::mem::transmute(ucurr_getPluralName(::std::mem::transmute(currency), locale.into_param().abi(), ::std::mem::transmute(ischoiceformat), pluralcount.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(ec)))
18654     }
18655     #[cfg(not(windows))]
18656     unimplemented!("Unsupported target OS");
18657 }
18658 #[inline]
ucurr_getRoundingIncrement(currency: *const u16, ec: *mut UErrorCode) -> f6418659 pub unsafe fn ucurr_getRoundingIncrement(currency: *const u16, ec: *mut UErrorCode) -> f64 {
18660     #[cfg(windows)]
18661     {
18662         #[link(name = "windows")]
18663         extern "system" {
18664             fn ucurr_getRoundingIncrement(currency: *const u16, ec: *mut UErrorCode) -> f64;
18665         }
18666         ::std::mem::transmute(ucurr_getRoundingIncrement(::std::mem::transmute(currency), ::std::mem::transmute(ec)))
18667     }
18668     #[cfg(not(windows))]
18669     unimplemented!("Unsupported target OS");
18670 }
18671 #[inline]
ucurr_getRoundingIncrementForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> f6418672 pub unsafe fn ucurr_getRoundingIncrementForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> f64 {
18673     #[cfg(windows)]
18674     {
18675         #[link(name = "windows")]
18676         extern "system" {
18677             fn ucurr_getRoundingIncrementForUsage(currency: *const u16, usage: UCurrencyUsage, ec: *mut UErrorCode) -> f64;
18678         }
18679         ::std::mem::transmute(ucurr_getRoundingIncrementForUsage(::std::mem::transmute(currency), ::std::mem::transmute(usage), ::std::mem::transmute(ec)))
18680     }
18681     #[cfg(not(windows))]
18682     unimplemented!("Unsupported target OS");
18683 }
18684 #[inline]
ucurr_isAvailable(isocode: *const u16, from: f64, to: f64, errorcode: *mut UErrorCode) -> i818685 pub unsafe fn ucurr_isAvailable(isocode: *const u16, from: f64, to: f64, errorcode: *mut UErrorCode) -> i8 {
18686     #[cfg(windows)]
18687     {
18688         #[link(name = "windows")]
18689         extern "system" {
18690             fn ucurr_isAvailable(isocode: *const u16, from: f64, to: f64, errorcode: *mut UErrorCode) -> i8;
18691         }
18692         ::std::mem::transmute(ucurr_isAvailable(::std::mem::transmute(isocode), ::std::mem::transmute(from), ::std::mem::transmute(to), ::std::mem::transmute(errorcode)))
18693     }
18694     #[cfg(not(windows))]
18695     unimplemented!("Unsupported target OS");
18696 }
18697 #[inline]
ucurr_openISOCurrencies(currtype: u32, perrorcode: *mut UErrorCode) -> *mut UEnumeration18698 pub unsafe fn ucurr_openISOCurrencies(currtype: u32, perrorcode: *mut UErrorCode) -> *mut UEnumeration {
18699     #[cfg(windows)]
18700     {
18701         #[link(name = "windows")]
18702         extern "system" {
18703             fn ucurr_openISOCurrencies(currtype: u32, perrorcode: *mut UErrorCode) -> *mut UEnumeration;
18704         }
18705         ::std::mem::transmute(ucurr_openISOCurrencies(::std::mem::transmute(currtype), ::std::mem::transmute(perrorcode)))
18706     }
18707     #[cfg(not(windows))]
18708     unimplemented!("Unsupported target OS");
18709 }
18710 #[cfg(feature = "Win32_Foundation")]
18711 #[inline]
ucurr_register<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(isocode: *const u16, locale: Param1, status: *mut UErrorCode) -> *mut ::std::ffi::c_void18712 pub unsafe fn ucurr_register<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(isocode: *const u16, locale: Param1, status: *mut UErrorCode) -> *mut ::std::ffi::c_void {
18713     #[cfg(windows)]
18714     {
18715         #[link(name = "windows")]
18716         extern "system" {
18717             fn ucurr_register(isocode: *const u16, locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut ::std::ffi::c_void;
18718         }
18719         ::std::mem::transmute(ucurr_register(::std::mem::transmute(isocode), locale.into_param().abi(), ::std::mem::transmute(status)))
18720     }
18721     #[cfg(not(windows))]
18722     unimplemented!("Unsupported target OS");
18723 }
18724 #[inline]
ucurr_unregister(key: *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i818725 pub unsafe fn ucurr_unregister(key: *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i8 {
18726     #[cfg(windows)]
18727     {
18728         #[link(name = "windows")]
18729         extern "system" {
18730             fn ucurr_unregister(key: *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i8;
18731         }
18732         ::std::mem::transmute(ucurr_unregister(::std::mem::transmute(key), ::std::mem::transmute(status)))
18733     }
18734     #[cfg(not(windows))]
18735     unimplemented!("Unsupported target OS");
18736 }
18737 #[inline]
udat_adoptNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoadopt: *mut *mut ::std::ffi::c_void)18738 pub unsafe fn udat_adoptNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoadopt: *mut *mut ::std::ffi::c_void) {
18739     #[cfg(windows)]
18740     {
18741         #[link(name = "windows")]
18742         extern "system" {
18743             fn udat_adoptNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoadopt: *mut *mut ::std::ffi::c_void);
18744         }
18745         ::std::mem::transmute(udat_adoptNumberFormat(::std::mem::transmute(fmt), ::std::mem::transmute(numberformattoadopt)))
18746     }
18747     #[cfg(not(windows))]
18748     unimplemented!("Unsupported target OS");
18749 }
18750 #[inline]
udat_adoptNumberFormatForFields(fmt: *mut *mut ::std::ffi::c_void, fields: *const u16, numberformattoset: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode)18751 pub unsafe fn udat_adoptNumberFormatForFields(fmt: *mut *mut ::std::ffi::c_void, fields: *const u16, numberformattoset: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) {
18752     #[cfg(windows)]
18753     {
18754         #[link(name = "windows")]
18755         extern "system" {
18756             fn udat_adoptNumberFormatForFields(fmt: *mut *mut ::std::ffi::c_void, fields: *const u16, numberformattoset: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode);
18757         }
18758         ::std::mem::transmute(udat_adoptNumberFormatForFields(::std::mem::transmute(fmt), ::std::mem::transmute(fields), ::std::mem::transmute(numberformattoset), ::std::mem::transmute(status)))
18759     }
18760     #[cfg(not(windows))]
18761     unimplemented!("Unsupported target OS");
18762 }
18763 #[inline]
udat_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32)18764 pub unsafe fn udat_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32) {
18765     #[cfg(windows)]
18766     {
18767         #[link(name = "windows")]
18768         extern "system" {
18769             fn udat_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32);
18770         }
18771         ::std::mem::transmute(udat_applyPattern(::std::mem::transmute(format), ::std::mem::transmute(localized), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength)))
18772     }
18773     #[cfg(not(windows))]
18774     unimplemented!("Unsupported target OS");
18775 }
18776 #[inline]
udat_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void18777 pub unsafe fn udat_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
18778     #[cfg(windows)]
18779     {
18780         #[link(name = "windows")]
18781         extern "system" {
18782             fn udat_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
18783         }
18784         ::std::mem::transmute(udat_clone(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
18785     }
18786     #[cfg(not(windows))]
18787     unimplemented!("Unsupported target OS");
18788 }
18789 #[inline]
udat_close(format: *mut *mut ::std::ffi::c_void)18790 pub unsafe fn udat_close(format: *mut *mut ::std::ffi::c_void) {
18791     #[cfg(windows)]
18792     {
18793         #[link(name = "windows")]
18794         extern "system" {
18795             fn udat_close(format: *mut *mut ::std::ffi::c_void);
18796         }
18797         ::std::mem::transmute(udat_close(::std::mem::transmute(format)))
18798     }
18799     #[cfg(not(windows))]
18800     unimplemented!("Unsupported target OS");
18801 }
18802 #[inline]
udat_countAvailable() -> i3218803 pub unsafe fn udat_countAvailable() -> i32 {
18804     #[cfg(windows)]
18805     {
18806         #[link(name = "windows")]
18807         extern "system" {
18808             fn udat_countAvailable() -> i32;
18809         }
18810         ::std::mem::transmute(udat_countAvailable())
18811     }
18812     #[cfg(not(windows))]
18813     unimplemented!("Unsupported target OS");
18814 }
18815 #[inline]
udat_countSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType) -> i3218816 pub unsafe fn udat_countSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType) -> i32 {
18817     #[cfg(windows)]
18818     {
18819         #[link(name = "windows")]
18820         extern "system" {
18821             fn udat_countSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType) -> i32;
18822         }
18823         ::std::mem::transmute(udat_countSymbols(::std::mem::transmute(fmt), ::std::mem::transmute(r#type)))
18824     }
18825     #[cfg(not(windows))]
18826     unimplemented!("Unsupported target OS");
18827 }
18828 #[inline]
udat_format(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i3218829 pub unsafe fn udat_format(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
18830     #[cfg(windows)]
18831     {
18832         #[link(name = "windows")]
18833         extern "system" {
18834             fn udat_format(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
18835         }
18836         ::std::mem::transmute(udat_format(::std::mem::transmute(format), ::std::mem::transmute(datetoformat), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(position), ::std::mem::transmute(status)))
18837     }
18838     #[cfg(not(windows))]
18839     unimplemented!("Unsupported target OS");
18840 }
18841 #[inline]
udat_formatCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i3218842 pub unsafe fn udat_formatCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
18843     #[cfg(windows)]
18844     {
18845         #[link(name = "windows")]
18846         extern "system" {
18847             fn udat_formatCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
18848         }
18849         ::std::mem::transmute(udat_formatCalendar(::std::mem::transmute(format), ::std::mem::transmute(calendar), ::std::mem::transmute(result), ::std::mem::transmute(capacity), ::std::mem::transmute(position), ::std::mem::transmute(status)))
18850     }
18851     #[cfg(not(windows))]
18852     unimplemented!("Unsupported target OS");
18853 }
18854 #[inline]
udat_formatCalendarForFields(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i3218855 pub unsafe fn udat_formatCalendarForFields(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32 {
18856     #[cfg(windows)]
18857     {
18858         #[link(name = "windows")]
18859         extern "system" {
18860             fn udat_formatCalendarForFields(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, result: *mut u16, capacity: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32;
18861         }
18862         ::std::mem::transmute(udat_formatCalendarForFields(::std::mem::transmute(format), ::std::mem::transmute(calendar), ::std::mem::transmute(result), ::std::mem::transmute(capacity), ::std::mem::transmute(fpositer), ::std::mem::transmute(status)))
18863     }
18864     #[cfg(not(windows))]
18865     unimplemented!("Unsupported target OS");
18866 }
18867 #[inline]
udat_formatForFields(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i3218868 pub unsafe fn udat_formatForFields(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32 {
18869     #[cfg(windows)]
18870     {
18871         #[link(name = "windows")]
18872         extern "system" {
18873             fn udat_formatForFields(format: *const *const ::std::ffi::c_void, datetoformat: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32;
18874         }
18875         ::std::mem::transmute(udat_formatForFields(::std::mem::transmute(format), ::std::mem::transmute(datetoformat), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(fpositer), ::std::mem::transmute(status)))
18876     }
18877     #[cfg(not(windows))]
18878     unimplemented!("Unsupported target OS");
18879 }
18880 #[inline]
udat_get2DigitYearStart(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f6418881 pub unsafe fn udat_get2DigitYearStart(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64 {
18882     #[cfg(windows)]
18883     {
18884         #[link(name = "windows")]
18885         extern "system" {
18886             fn udat_get2DigitYearStart(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64;
18887         }
18888         ::std::mem::transmute(udat_get2DigitYearStart(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
18889     }
18890     #[cfg(not(windows))]
18891     unimplemented!("Unsupported target OS");
18892 }
18893 #[cfg(feature = "Win32_Foundation")]
18894 #[inline]
udat_getAvailable(localeindex: i32) -> super::Foundation::PSTR18895 pub unsafe fn udat_getAvailable(localeindex: i32) -> super::Foundation::PSTR {
18896     #[cfg(windows)]
18897     {
18898         #[link(name = "windows")]
18899         extern "system" {
18900             fn udat_getAvailable(localeindex: i32) -> super::Foundation::PSTR;
18901         }
18902         ::std::mem::transmute(udat_getAvailable(::std::mem::transmute(localeindex)))
18903     }
18904     #[cfg(not(windows))]
18905     unimplemented!("Unsupported target OS");
18906 }
18907 #[inline]
udat_getBooleanAttribute(fmt: *const *const ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, status: *mut UErrorCode) -> i818908 pub unsafe fn udat_getBooleanAttribute(fmt: *const *const ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, status: *mut UErrorCode) -> i8 {
18909     #[cfg(windows)]
18910     {
18911         #[link(name = "windows")]
18912         extern "system" {
18913             fn udat_getBooleanAttribute(fmt: *const *const ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, status: *mut UErrorCode) -> i8;
18914         }
18915         ::std::mem::transmute(udat_getBooleanAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr), ::std::mem::transmute(status)))
18916     }
18917     #[cfg(not(windows))]
18918     unimplemented!("Unsupported target OS");
18919 }
18920 #[inline]
udat_getCalendar(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void18921 pub unsafe fn udat_getCalendar(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void {
18922     #[cfg(windows)]
18923     {
18924         #[link(name = "windows")]
18925         extern "system" {
18926             fn udat_getCalendar(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void;
18927         }
18928         ::std::mem::transmute(udat_getCalendar(::std::mem::transmute(fmt)))
18929     }
18930     #[cfg(not(windows))]
18931     unimplemented!("Unsupported target OS");
18932 }
18933 #[inline]
udat_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext18934 pub unsafe fn udat_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext {
18935     #[cfg(windows)]
18936     {
18937         #[link(name = "windows")]
18938         extern "system" {
18939             fn udat_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext;
18940         }
18941         ::std::mem::transmute(udat_getContext(::std::mem::transmute(fmt), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
18942     }
18943     #[cfg(not(windows))]
18944     unimplemented!("Unsupported target OS");
18945 }
18946 #[cfg(feature = "Win32_Foundation")]
18947 #[inline]
udat_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR18948 pub unsafe fn udat_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
18949     #[cfg(windows)]
18950     {
18951         #[link(name = "windows")]
18952         extern "system" {
18953             fn udat_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
18954         }
18955         ::std::mem::transmute(udat_getLocaleByType(::std::mem::transmute(fmt), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
18956     }
18957     #[cfg(not(windows))]
18958     unimplemented!("Unsupported target OS");
18959 }
18960 #[inline]
udat_getNumberFormat(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void18961 pub unsafe fn udat_getNumberFormat(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void {
18962     #[cfg(windows)]
18963     {
18964         #[link(name = "windows")]
18965         extern "system" {
18966             fn udat_getNumberFormat(fmt: *const *const ::std::ffi::c_void) -> *mut *mut ::std::ffi::c_void;
18967         }
18968         ::std::mem::transmute(udat_getNumberFormat(::std::mem::transmute(fmt)))
18969     }
18970     #[cfg(not(windows))]
18971     unimplemented!("Unsupported target OS");
18972 }
18973 #[inline]
udat_getNumberFormatForField(fmt: *const *const ::std::ffi::c_void, field: u16) -> *mut *mut ::std::ffi::c_void18974 pub unsafe fn udat_getNumberFormatForField(fmt: *const *const ::std::ffi::c_void, field: u16) -> *mut *mut ::std::ffi::c_void {
18975     #[cfg(windows)]
18976     {
18977         #[link(name = "windows")]
18978         extern "system" {
18979             fn udat_getNumberFormatForField(fmt: *const *const ::std::ffi::c_void, field: u16) -> *mut *mut ::std::ffi::c_void;
18980         }
18981         ::std::mem::transmute(udat_getNumberFormatForField(::std::mem::transmute(fmt), ::std::mem::transmute(field)))
18982     }
18983     #[cfg(not(windows))]
18984     unimplemented!("Unsupported target OS");
18985 }
18986 #[inline]
udat_getSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3218987 pub unsafe fn udat_getSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
18988     #[cfg(windows)]
18989     {
18990         #[link(name = "windows")]
18991         extern "system" {
18992             fn udat_getSymbols(fmt: *const *const ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
18993         }
18994         ::std::mem::transmute(udat_getSymbols(::std::mem::transmute(fmt), ::std::mem::transmute(r#type), ::std::mem::transmute(symbolindex), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
18995     }
18996     #[cfg(not(windows))]
18997     unimplemented!("Unsupported target OS");
18998 }
18999 #[inline]
udat_isLenient(fmt: *const *const ::std::ffi::c_void) -> i819000 pub unsafe fn udat_isLenient(fmt: *const *const ::std::ffi::c_void) -> i8 {
19001     #[cfg(windows)]
19002     {
19003         #[link(name = "windows")]
19004         extern "system" {
19005             fn udat_isLenient(fmt: *const *const ::std::ffi::c_void) -> i8;
19006         }
19007         ::std::mem::transmute(udat_isLenient(::std::mem::transmute(fmt)))
19008     }
19009     #[cfg(not(windows))]
19010     unimplemented!("Unsupported target OS");
19011 }
19012 #[cfg(feature = "Win32_Foundation")]
19013 #[inline]
udat_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(timestyle: UDateFormatStyle, datestyle: UDateFormatStyle, locale: Param2, tzid: *const u16, tzidlength: i32, pattern: *const u16, patternlength: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19014 pub unsafe fn udat_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(timestyle: UDateFormatStyle, datestyle: UDateFormatStyle, locale: Param2, tzid: *const u16, tzidlength: i32, pattern: *const u16, patternlength: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19015     #[cfg(windows)]
19016     {
19017         #[link(name = "windows")]
19018         extern "system" {
19019             fn udat_open(timestyle: UDateFormatStyle, datestyle: UDateFormatStyle, locale: super::Foundation::PSTR, tzid: *const u16, tzidlength: i32, pattern: *const u16, patternlength: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19020         }
19021         ::std::mem::transmute(udat_open(::std::mem::transmute(timestyle), ::std::mem::transmute(datestyle), locale.into_param().abi(), ::std::mem::transmute(tzid), ::std::mem::transmute(tzidlength), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(status)))
19022     }
19023     #[cfg(not(windows))]
19024     unimplemented!("Unsupported target OS");
19025 }
19026 #[inline]
udat_parse(format: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f6419027 pub unsafe fn udat_parse(format: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f64 {
19028     #[cfg(windows)]
19029     {
19030         #[link(name = "windows")]
19031         extern "system" {
19032             fn udat_parse(format: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f64;
19033         }
19034         ::std::mem::transmute(udat_parse(::std::mem::transmute(format), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
19035     }
19036     #[cfg(not(windows))]
19037     unimplemented!("Unsupported target OS");
19038 }
19039 #[inline]
udat_parseCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode)19040 pub unsafe fn udat_parseCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) {
19041     #[cfg(windows)]
19042     {
19043         #[link(name = "windows")]
19044         extern "system" {
19045             fn udat_parseCalendar(format: *const *const ::std::ffi::c_void, calendar: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode);
19046         }
19047         ::std::mem::transmute(udat_parseCalendar(::std::mem::transmute(format), ::std::mem::transmute(calendar), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
19048     }
19049     #[cfg(not(windows))]
19050     unimplemented!("Unsupported target OS");
19051 }
19052 #[inline]
udat_set2DigitYearStart(fmt: *mut *mut ::std::ffi::c_void, d: f64, status: *mut UErrorCode)19053 pub unsafe fn udat_set2DigitYearStart(fmt: *mut *mut ::std::ffi::c_void, d: f64, status: *mut UErrorCode) {
19054     #[cfg(windows)]
19055     {
19056         #[link(name = "windows")]
19057         extern "system" {
19058             fn udat_set2DigitYearStart(fmt: *mut *mut ::std::ffi::c_void, d: f64, status: *mut UErrorCode);
19059         }
19060         ::std::mem::transmute(udat_set2DigitYearStart(::std::mem::transmute(fmt), ::std::mem::transmute(d), ::std::mem::transmute(status)))
19061     }
19062     #[cfg(not(windows))]
19063     unimplemented!("Unsupported target OS");
19064 }
19065 #[inline]
udat_setBooleanAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, newvalue: i8, status: *mut UErrorCode)19066 pub unsafe fn udat_setBooleanAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, newvalue: i8, status: *mut UErrorCode) {
19067     #[cfg(windows)]
19068     {
19069         #[link(name = "windows")]
19070         extern "system" {
19071             fn udat_setBooleanAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UDateFormatBooleanAttribute, newvalue: i8, status: *mut UErrorCode);
19072         }
19073         ::std::mem::transmute(udat_setBooleanAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr), ::std::mem::transmute(newvalue), ::std::mem::transmute(status)))
19074     }
19075     #[cfg(not(windows))]
19076     unimplemented!("Unsupported target OS");
19077 }
19078 #[inline]
udat_setCalendar(fmt: *mut *mut ::std::ffi::c_void, calendartoset: *const *const ::std::ffi::c_void)19079 pub unsafe fn udat_setCalendar(fmt: *mut *mut ::std::ffi::c_void, calendartoset: *const *const ::std::ffi::c_void) {
19080     #[cfg(windows)]
19081     {
19082         #[link(name = "windows")]
19083         extern "system" {
19084             fn udat_setCalendar(fmt: *mut *mut ::std::ffi::c_void, calendartoset: *const *const ::std::ffi::c_void);
19085         }
19086         ::std::mem::transmute(udat_setCalendar(::std::mem::transmute(fmt), ::std::mem::transmute(calendartoset)))
19087     }
19088     #[cfg(not(windows))]
19089     unimplemented!("Unsupported target OS");
19090 }
19091 #[inline]
udat_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode)19092 pub unsafe fn udat_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode) {
19093     #[cfg(windows)]
19094     {
19095         #[link(name = "windows")]
19096         extern "system" {
19097             fn udat_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode);
19098         }
19099         ::std::mem::transmute(udat_setContext(::std::mem::transmute(fmt), ::std::mem::transmute(value), ::std::mem::transmute(status)))
19100     }
19101     #[cfg(not(windows))]
19102     unimplemented!("Unsupported target OS");
19103 }
19104 #[inline]
udat_setLenient(fmt: *mut *mut ::std::ffi::c_void, islenient: i8)19105 pub unsafe fn udat_setLenient(fmt: *mut *mut ::std::ffi::c_void, islenient: i8) {
19106     #[cfg(windows)]
19107     {
19108         #[link(name = "windows")]
19109         extern "system" {
19110             fn udat_setLenient(fmt: *mut *mut ::std::ffi::c_void, islenient: i8);
19111         }
19112         ::std::mem::transmute(udat_setLenient(::std::mem::transmute(fmt), ::std::mem::transmute(islenient)))
19113     }
19114     #[cfg(not(windows))]
19115     unimplemented!("Unsupported target OS");
19116 }
19117 #[inline]
udat_setNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoset: *const *const ::std::ffi::c_void)19118 pub unsafe fn udat_setNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoset: *const *const ::std::ffi::c_void) {
19119     #[cfg(windows)]
19120     {
19121         #[link(name = "windows")]
19122         extern "system" {
19123             fn udat_setNumberFormat(fmt: *mut *mut ::std::ffi::c_void, numberformattoset: *const *const ::std::ffi::c_void);
19124         }
19125         ::std::mem::transmute(udat_setNumberFormat(::std::mem::transmute(fmt), ::std::mem::transmute(numberformattoset)))
19126     }
19127     #[cfg(not(windows))]
19128     unimplemented!("Unsupported target OS");
19129 }
19130 #[inline]
udat_setSymbols(format: *mut *mut ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, value: *mut u16, valuelength: i32, status: *mut UErrorCode)19131 pub unsafe fn udat_setSymbols(format: *mut *mut ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, value: *mut u16, valuelength: i32, status: *mut UErrorCode) {
19132     #[cfg(windows)]
19133     {
19134         #[link(name = "windows")]
19135         extern "system" {
19136             fn udat_setSymbols(format: *mut *mut ::std::ffi::c_void, r#type: UDateFormatSymbolType, symbolindex: i32, value: *mut u16, valuelength: i32, status: *mut UErrorCode);
19137         }
19138         ::std::mem::transmute(udat_setSymbols(::std::mem::transmute(format), ::std::mem::transmute(r#type), ::std::mem::transmute(symbolindex), ::std::mem::transmute(value), ::std::mem::transmute(valuelength), ::std::mem::transmute(status)))
19139     }
19140     #[cfg(not(windows))]
19141     unimplemented!("Unsupported target OS");
19142 }
19143 #[inline]
udat_toCalendarDateField(field: UDateFormatField) -> UCalendarDateFields19144 pub unsafe fn udat_toCalendarDateField(field: UDateFormatField) -> UCalendarDateFields {
19145     #[cfg(windows)]
19146     {
19147         #[link(name = "windows")]
19148         extern "system" {
19149             fn udat_toCalendarDateField(field: UDateFormatField) -> UCalendarDateFields;
19150         }
19151         ::std::mem::transmute(udat_toCalendarDateField(::std::mem::transmute(field)))
19152     }
19153     #[cfg(not(windows))]
19154     unimplemented!("Unsupported target OS");
19155 }
19156 #[inline]
udat_toPattern(fmt: *const *const ::std::ffi::c_void, localized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3219157 pub unsafe fn udat_toPattern(fmt: *const *const ::std::ffi::c_void, localized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
19158     #[cfg(windows)]
19159     {
19160         #[link(name = "windows")]
19161         extern "system" {
19162             fn udat_toPattern(fmt: *const *const ::std::ffi::c_void, localized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
19163         }
19164         ::std::mem::transmute(udat_toPattern(::std::mem::transmute(fmt), ::std::mem::transmute(localized), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
19165     }
19166     #[cfg(not(windows))]
19167     unimplemented!("Unsupported target OS");
19168 }
19169 #[inline]
udatpg_addPattern(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, r#override: i8, conflictingpattern: *mut u16, capacity: i32, plength: *mut i32, perrorcode: *mut UErrorCode) -> UDateTimePatternConflict19170 pub unsafe fn udatpg_addPattern(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, r#override: i8, conflictingpattern: *mut u16, capacity: i32, plength: *mut i32, perrorcode: *mut UErrorCode) -> UDateTimePatternConflict {
19171     #[cfg(windows)]
19172     {
19173         #[link(name = "windows")]
19174         extern "system" {
19175             fn udatpg_addPattern(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, r#override: i8, conflictingpattern: *mut u16, capacity: i32, plength: *mut i32, perrorcode: *mut UErrorCode) -> UDateTimePatternConflict;
19176         }
19177         ::std::mem::transmute(udatpg_addPattern(::std::mem::transmute(dtpg), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(r#override), ::std::mem::transmute(conflictingpattern), ::std::mem::transmute(capacity), ::std::mem::transmute(plength), ::std::mem::transmute(perrorcode)))
19178     }
19179     #[cfg(not(windows))]
19180     unimplemented!("Unsupported target OS");
19181 }
19182 #[inline]
udatpg_clone(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19183 pub unsafe fn udatpg_clone(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19184     #[cfg(windows)]
19185     {
19186         #[link(name = "windows")]
19187         extern "system" {
19188             fn udatpg_clone(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19189         }
19190         ::std::mem::transmute(udatpg_clone(::std::mem::transmute(dtpg), ::std::mem::transmute(perrorcode)))
19191     }
19192     #[cfg(not(windows))]
19193     unimplemented!("Unsupported target OS");
19194 }
19195 #[inline]
udatpg_close(dtpg: *mut *mut ::std::ffi::c_void)19196 pub unsafe fn udatpg_close(dtpg: *mut *mut ::std::ffi::c_void) {
19197     #[cfg(windows)]
19198     {
19199         #[link(name = "windows")]
19200         extern "system" {
19201             fn udatpg_close(dtpg: *mut *mut ::std::ffi::c_void);
19202         }
19203         ::std::mem::transmute(udatpg_close(::std::mem::transmute(dtpg)))
19204     }
19205     #[cfg(not(windows))]
19206     unimplemented!("Unsupported target OS");
19207 }
19208 #[inline]
udatpg_getAppendItemFormat(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u1619209 pub unsafe fn udatpg_getAppendItemFormat(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u16 {
19210     #[cfg(windows)]
19211     {
19212         #[link(name = "windows")]
19213         extern "system" {
19214             fn udatpg_getAppendItemFormat(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u16;
19215         }
19216         ::std::mem::transmute(udatpg_getAppendItemFormat(::std::mem::transmute(dtpg), ::std::mem::transmute(field), ::std::mem::transmute(plength)))
19217     }
19218     #[cfg(not(windows))]
19219     unimplemented!("Unsupported target OS");
19220 }
19221 #[inline]
udatpg_getAppendItemName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u1619222 pub unsafe fn udatpg_getAppendItemName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u16 {
19223     #[cfg(windows)]
19224     {
19225         #[link(name = "windows")]
19226         extern "system" {
19227             fn udatpg_getAppendItemName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, plength: *mut i32) -> *mut u16;
19228         }
19229         ::std::mem::transmute(udatpg_getAppendItemName(::std::mem::transmute(dtpg), ::std::mem::transmute(field), ::std::mem::transmute(plength)))
19230     }
19231     #[cfg(not(windows))]
19232     unimplemented!("Unsupported target OS");
19233 }
19234 #[inline]
udatpg_getBaseSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, baseskeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3219235 pub unsafe fn udatpg_getBaseSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, baseskeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19236     #[cfg(windows)]
19237     {
19238         #[link(name = "windows")]
19239         extern "system" {
19240             fn udatpg_getBaseSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, baseskeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
19241         }
19242         ::std::mem::transmute(udatpg_getBaseSkeleton(::std::mem::transmute(unuseddtpg), ::std::mem::transmute(pattern), ::std::mem::transmute(length), ::std::mem::transmute(baseskeleton), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
19243     }
19244     #[cfg(not(windows))]
19245     unimplemented!("Unsupported target OS");
19246 }
19247 #[inline]
udatpg_getBestPattern(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3219248 pub unsafe fn udatpg_getBestPattern(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19249     #[cfg(windows)]
19250     {
19251         #[link(name = "windows")]
19252         extern "system" {
19253             fn udatpg_getBestPattern(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
19254         }
19255         ::std::mem::transmute(udatpg_getBestPattern(::std::mem::transmute(dtpg), ::std::mem::transmute(skeleton), ::std::mem::transmute(length), ::std::mem::transmute(bestpattern), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
19256     }
19257     #[cfg(not(windows))]
19258     unimplemented!("Unsupported target OS");
19259 }
19260 #[inline]
udatpg_getBestPatternWithOptions(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, options: UDateTimePatternMatchOptions, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3219261 pub unsafe fn udatpg_getBestPatternWithOptions(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, options: UDateTimePatternMatchOptions, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19262     #[cfg(windows)]
19263     {
19264         #[link(name = "windows")]
19265         extern "system" {
19266             fn udatpg_getBestPatternWithOptions(dtpg: *mut *mut ::std::ffi::c_void, skeleton: *const u16, length: i32, options: UDateTimePatternMatchOptions, bestpattern: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
19267         }
19268         ::std::mem::transmute(udatpg_getBestPatternWithOptions(::std::mem::transmute(dtpg), ::std::mem::transmute(skeleton), ::std::mem::transmute(length), ::std::mem::transmute(options), ::std::mem::transmute(bestpattern), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
19269     }
19270     #[cfg(not(windows))]
19271     unimplemented!("Unsupported target OS");
19272 }
19273 #[inline]
udatpg_getDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u1619274 pub unsafe fn udatpg_getDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u16 {
19275     #[cfg(windows)]
19276     {
19277         #[link(name = "windows")]
19278         extern "system" {
19279             fn udatpg_getDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u16;
19280         }
19281         ::std::mem::transmute(udatpg_getDateTimeFormat(::std::mem::transmute(dtpg), ::std::mem::transmute(plength)))
19282     }
19283     #[cfg(not(windows))]
19284     unimplemented!("Unsupported target OS");
19285 }
19286 #[inline]
udatpg_getDecimal(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u1619287 pub unsafe fn udatpg_getDecimal(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u16 {
19288     #[cfg(windows)]
19289     {
19290         #[link(name = "windows")]
19291         extern "system" {
19292             fn udatpg_getDecimal(dtpg: *const *const ::std::ffi::c_void, plength: *mut i32) -> *mut u16;
19293         }
19294         ::std::mem::transmute(udatpg_getDecimal(::std::mem::transmute(dtpg), ::std::mem::transmute(plength)))
19295     }
19296     #[cfg(not(windows))]
19297     unimplemented!("Unsupported target OS");
19298 }
19299 #[inline]
udatpg_getFieldDisplayName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, width: UDateTimePGDisplayWidth, fieldname: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3219300 pub unsafe fn udatpg_getFieldDisplayName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, width: UDateTimePGDisplayWidth, fieldname: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19301     #[cfg(windows)]
19302     {
19303         #[link(name = "windows")]
19304         extern "system" {
19305             fn udatpg_getFieldDisplayName(dtpg: *const *const ::std::ffi::c_void, field: UDateTimePatternField, width: UDateTimePGDisplayWidth, fieldname: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
19306         }
19307         ::std::mem::transmute(udatpg_getFieldDisplayName(::std::mem::transmute(dtpg), ::std::mem::transmute(field), ::std::mem::transmute(width), ::std::mem::transmute(fieldname), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
19308     }
19309     #[cfg(not(windows))]
19310     unimplemented!("Unsupported target OS");
19311 }
19312 #[inline]
udatpg_getPatternForSkeleton(dtpg: *const *const ::std::ffi::c_void, skeleton: *const u16, skeletonlength: i32, plength: *mut i32) -> *mut u1619313 pub unsafe fn udatpg_getPatternForSkeleton(dtpg: *const *const ::std::ffi::c_void, skeleton: *const u16, skeletonlength: i32, plength: *mut i32) -> *mut u16 {
19314     #[cfg(windows)]
19315     {
19316         #[link(name = "windows")]
19317         extern "system" {
19318             fn udatpg_getPatternForSkeleton(dtpg: *const *const ::std::ffi::c_void, skeleton: *const u16, skeletonlength: i32, plength: *mut i32) -> *mut u16;
19319         }
19320         ::std::mem::transmute(udatpg_getPatternForSkeleton(::std::mem::transmute(dtpg), ::std::mem::transmute(skeleton), ::std::mem::transmute(skeletonlength), ::std::mem::transmute(plength)))
19321     }
19322     #[cfg(not(windows))]
19323     unimplemented!("Unsupported target OS");
19324 }
19325 #[inline]
udatpg_getSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, skeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3219326 pub unsafe fn udatpg_getSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, skeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19327     #[cfg(windows)]
19328     {
19329         #[link(name = "windows")]
19330         extern "system" {
19331             fn udatpg_getSkeleton(unuseddtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, length: i32, skeleton: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
19332         }
19333         ::std::mem::transmute(udatpg_getSkeleton(::std::mem::transmute(unuseddtpg), ::std::mem::transmute(pattern), ::std::mem::transmute(length), ::std::mem::transmute(skeleton), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
19334     }
19335     #[cfg(not(windows))]
19336     unimplemented!("Unsupported target OS");
19337 }
19338 #[cfg(feature = "Win32_Foundation")]
19339 #[inline]
udatpg_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19340 pub unsafe fn udatpg_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19341     #[cfg(windows)]
19342     {
19343         #[link(name = "windows")]
19344         extern "system" {
19345             fn udatpg_open(locale: super::Foundation::PSTR, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19346         }
19347         ::std::mem::transmute(udatpg_open(locale.into_param().abi(), ::std::mem::transmute(perrorcode)))
19348     }
19349     #[cfg(not(windows))]
19350     unimplemented!("Unsupported target OS");
19351 }
19352 #[inline]
udatpg_openBaseSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration19353 pub unsafe fn udatpg_openBaseSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration {
19354     #[cfg(windows)]
19355     {
19356         #[link(name = "windows")]
19357         extern "system" {
19358             fn udatpg_openBaseSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration;
19359         }
19360         ::std::mem::transmute(udatpg_openBaseSkeletons(::std::mem::transmute(dtpg), ::std::mem::transmute(perrorcode)))
19361     }
19362     #[cfg(not(windows))]
19363     unimplemented!("Unsupported target OS");
19364 }
19365 #[inline]
udatpg_openEmpty(perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19366 pub unsafe fn udatpg_openEmpty(perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19367     #[cfg(windows)]
19368     {
19369         #[link(name = "windows")]
19370         extern "system" {
19371             fn udatpg_openEmpty(perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19372         }
19373         ::std::mem::transmute(udatpg_openEmpty(::std::mem::transmute(perrorcode)))
19374     }
19375     #[cfg(not(windows))]
19376     unimplemented!("Unsupported target OS");
19377 }
19378 #[inline]
udatpg_openSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration19379 pub unsafe fn udatpg_openSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration {
19380     #[cfg(windows)]
19381     {
19382         #[link(name = "windows")]
19383         extern "system" {
19384             fn udatpg_openSkeletons(dtpg: *const *const ::std::ffi::c_void, perrorcode: *mut UErrorCode) -> *mut UEnumeration;
19385         }
19386         ::std::mem::transmute(udatpg_openSkeletons(::std::mem::transmute(dtpg), ::std::mem::transmute(perrorcode)))
19387     }
19388     #[cfg(not(windows))]
19389     unimplemented!("Unsupported target OS");
19390 }
19391 #[inline]
udatpg_replaceFieldTypes(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3219392 pub unsafe fn udatpg_replaceFieldTypes(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19393     #[cfg(windows)]
19394     {
19395         #[link(name = "windows")]
19396         extern "system" {
19397             fn udatpg_replaceFieldTypes(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
19398         }
19399         ::std::mem::transmute(udatpg_replaceFieldTypes(::std::mem::transmute(dtpg), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(skeleton), ::std::mem::transmute(skeletonlength), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(perrorcode)))
19400     }
19401     #[cfg(not(windows))]
19402     unimplemented!("Unsupported target OS");
19403 }
19404 #[inline]
udatpg_replaceFieldTypesWithOptions(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, options: UDateTimePatternMatchOptions, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3219405 pub unsafe fn udatpg_replaceFieldTypesWithOptions(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, options: UDateTimePatternMatchOptions, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
19406     #[cfg(windows)]
19407     {
19408         #[link(name = "windows")]
19409         extern "system" {
19410             fn udatpg_replaceFieldTypesWithOptions(dtpg: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, skeleton: *const u16, skeletonlength: i32, options: UDateTimePatternMatchOptions, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
19411         }
19412         ::std::mem::transmute(udatpg_replaceFieldTypesWithOptions(
19413             ::std::mem::transmute(dtpg),
19414             ::std::mem::transmute(pattern),
19415             ::std::mem::transmute(patternlength),
19416             ::std::mem::transmute(skeleton),
19417             ::std::mem::transmute(skeletonlength),
19418             ::std::mem::transmute(options),
19419             ::std::mem::transmute(dest),
19420             ::std::mem::transmute(destcapacity),
19421             ::std::mem::transmute(perrorcode),
19422         ))
19423     }
19424     #[cfg(not(windows))]
19425     unimplemented!("Unsupported target OS");
19426 }
19427 #[inline]
udatpg_setAppendItemFormat(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32)19428 pub unsafe fn udatpg_setAppendItemFormat(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32) {
19429     #[cfg(windows)]
19430     {
19431         #[link(name = "windows")]
19432         extern "system" {
19433             fn udatpg_setAppendItemFormat(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32);
19434         }
19435         ::std::mem::transmute(udatpg_setAppendItemFormat(::std::mem::transmute(dtpg), ::std::mem::transmute(field), ::std::mem::transmute(value), ::std::mem::transmute(length)))
19436     }
19437     #[cfg(not(windows))]
19438     unimplemented!("Unsupported target OS");
19439 }
19440 #[inline]
udatpg_setAppendItemName(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32)19441 pub unsafe fn udatpg_setAppendItemName(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32) {
19442     #[cfg(windows)]
19443     {
19444         #[link(name = "windows")]
19445         extern "system" {
19446             fn udatpg_setAppendItemName(dtpg: *mut *mut ::std::ffi::c_void, field: UDateTimePatternField, value: *const u16, length: i32);
19447         }
19448         ::std::mem::transmute(udatpg_setAppendItemName(::std::mem::transmute(dtpg), ::std::mem::transmute(field), ::std::mem::transmute(value), ::std::mem::transmute(length)))
19449     }
19450     #[cfg(not(windows))]
19451     unimplemented!("Unsupported target OS");
19452 }
19453 #[inline]
udatpg_setDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, dtformat: *const u16, length: i32)19454 pub unsafe fn udatpg_setDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, dtformat: *const u16, length: i32) {
19455     #[cfg(windows)]
19456     {
19457         #[link(name = "windows")]
19458         extern "system" {
19459             fn udatpg_setDateTimeFormat(dtpg: *const *const ::std::ffi::c_void, dtformat: *const u16, length: i32);
19460         }
19461         ::std::mem::transmute(udatpg_setDateTimeFormat(::std::mem::transmute(dtpg), ::std::mem::transmute(dtformat), ::std::mem::transmute(length)))
19462     }
19463     #[cfg(not(windows))]
19464     unimplemented!("Unsupported target OS");
19465 }
19466 #[inline]
udatpg_setDecimal(dtpg: *mut *mut ::std::ffi::c_void, decimal: *const u16, length: i32)19467 pub unsafe fn udatpg_setDecimal(dtpg: *mut *mut ::std::ffi::c_void, decimal: *const u16, length: i32) {
19468     #[cfg(windows)]
19469     {
19470         #[link(name = "windows")]
19471         extern "system" {
19472             fn udatpg_setDecimal(dtpg: *mut *mut ::std::ffi::c_void, decimal: *const u16, length: i32);
19473         }
19474         ::std::mem::transmute(udatpg_setDecimal(::std::mem::transmute(dtpg), ::std::mem::transmute(decimal), ::std::mem::transmute(length)))
19475     }
19476     #[cfg(not(windows))]
19477     unimplemented!("Unsupported target OS");
19478 }
19479 #[inline]
udtitvfmt_close(formatter: *mut UDateIntervalFormat)19480 pub unsafe fn udtitvfmt_close(formatter: *mut UDateIntervalFormat) {
19481     #[cfg(windows)]
19482     {
19483         #[link(name = "windows")]
19484         extern "system" {
19485             fn udtitvfmt_close(formatter: *mut UDateIntervalFormat);
19486         }
19487         ::std::mem::transmute(udtitvfmt_close(::std::mem::transmute(formatter)))
19488     }
19489     #[cfg(not(windows))]
19490     unimplemented!("Unsupported target OS");
19491 }
19492 #[inline]
udtitvfmt_closeResult(uresult: *mut UFormattedDateInterval)19493 pub unsafe fn udtitvfmt_closeResult(uresult: *mut UFormattedDateInterval) {
19494     #[cfg(windows)]
19495     {
19496         #[link(name = "windows")]
19497         extern "system" {
19498             fn udtitvfmt_closeResult(uresult: *mut UFormattedDateInterval);
19499         }
19500         ::std::mem::transmute(udtitvfmt_closeResult(::std::mem::transmute(uresult)))
19501     }
19502     #[cfg(not(windows))]
19503     unimplemented!("Unsupported target OS");
19504 }
19505 #[inline]
udtitvfmt_format(formatter: *const UDateIntervalFormat, fromdate: f64, todate: f64, result: *mut u16, resultcapacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i3219506 pub unsafe fn udtitvfmt_format(formatter: *const UDateIntervalFormat, fromdate: f64, todate: f64, result: *mut u16, resultcapacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
19507     #[cfg(windows)]
19508     {
19509         #[link(name = "windows")]
19510         extern "system" {
19511             fn udtitvfmt_format(formatter: *const UDateIntervalFormat, fromdate: f64, todate: f64, result: *mut u16, resultcapacity: i32, position: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
19512         }
19513         ::std::mem::transmute(udtitvfmt_format(::std::mem::transmute(formatter), ::std::mem::transmute(fromdate), ::std::mem::transmute(todate), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(position), ::std::mem::transmute(status)))
19514     }
19515     #[cfg(not(windows))]
19516     unimplemented!("Unsupported target OS");
19517 }
19518 #[cfg(feature = "Win32_Foundation")]
19519 #[inline]
udtitvfmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, skeleton: *const u16, skeletonlength: i32, tzid: *const u16, tzidlength: i32, status: *mut UErrorCode) -> *mut UDateIntervalFormat19520 pub unsafe fn udtitvfmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, skeleton: *const u16, skeletonlength: i32, tzid: *const u16, tzidlength: i32, status: *mut UErrorCode) -> *mut UDateIntervalFormat {
19521     #[cfg(windows)]
19522     {
19523         #[link(name = "windows")]
19524         extern "system" {
19525             fn udtitvfmt_open(locale: super::Foundation::PSTR, skeleton: *const u16, skeletonlength: i32, tzid: *const u16, tzidlength: i32, status: *mut UErrorCode) -> *mut UDateIntervalFormat;
19526         }
19527         ::std::mem::transmute(udtitvfmt_open(locale.into_param().abi(), ::std::mem::transmute(skeleton), ::std::mem::transmute(skeletonlength), ::std::mem::transmute(tzid), ::std::mem::transmute(tzidlength), ::std::mem::transmute(status)))
19528     }
19529     #[cfg(not(windows))]
19530     unimplemented!("Unsupported target OS");
19531 }
19532 #[inline]
udtitvfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedDateInterval19533 pub unsafe fn udtitvfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedDateInterval {
19534     #[cfg(windows)]
19535     {
19536         #[link(name = "windows")]
19537         extern "system" {
19538             fn udtitvfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedDateInterval;
19539         }
19540         ::std::mem::transmute(udtitvfmt_openResult(::std::mem::transmute(ec)))
19541     }
19542     #[cfg(not(windows))]
19543     unimplemented!("Unsupported target OS");
19544 }
19545 #[inline]
udtitvfmt_resultAsValue(uresult: *const UFormattedDateInterval, ec: *mut UErrorCode) -> *mut UFormattedValue19546 pub unsafe fn udtitvfmt_resultAsValue(uresult: *const UFormattedDateInterval, ec: *mut UErrorCode) -> *mut UFormattedValue {
19547     #[cfg(windows)]
19548     {
19549         #[link(name = "windows")]
19550         extern "system" {
19551             fn udtitvfmt_resultAsValue(uresult: *const UFormattedDateInterval, ec: *mut UErrorCode) -> *mut UFormattedValue;
19552         }
19553         ::std::mem::transmute(udtitvfmt_resultAsValue(::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
19554     }
19555     #[cfg(not(windows))]
19556     unimplemented!("Unsupported target OS");
19557 }
19558 #[inline]
uenum_close(en: *mut UEnumeration)19559 pub unsafe fn uenum_close(en: *mut UEnumeration) {
19560     #[cfg(windows)]
19561     {
19562         #[link(name = "windows")]
19563         extern "system" {
19564             fn uenum_close(en: *mut UEnumeration);
19565         }
19566         ::std::mem::transmute(uenum_close(::std::mem::transmute(en)))
19567     }
19568     #[cfg(not(windows))]
19569     unimplemented!("Unsupported target OS");
19570 }
19571 #[inline]
uenum_count(en: *mut UEnumeration, status: *mut UErrorCode) -> i3219572 pub unsafe fn uenum_count(en: *mut UEnumeration, status: *mut UErrorCode) -> i32 {
19573     #[cfg(windows)]
19574     {
19575         #[link(name = "windows")]
19576         extern "system" {
19577             fn uenum_count(en: *mut UEnumeration, status: *mut UErrorCode) -> i32;
19578         }
19579         ::std::mem::transmute(uenum_count(::std::mem::transmute(en), ::std::mem::transmute(status)))
19580     }
19581     #[cfg(not(windows))]
19582     unimplemented!("Unsupported target OS");
19583 }
19584 #[cfg(feature = "Win32_Foundation")]
19585 #[inline]
uenum_next(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR19586 pub unsafe fn uenum_next(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR {
19587     #[cfg(windows)]
19588     {
19589         #[link(name = "windows")]
19590         extern "system" {
19591             fn uenum_next(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR;
19592         }
19593         ::std::mem::transmute(uenum_next(::std::mem::transmute(en), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
19594     }
19595     #[cfg(not(windows))]
19596     unimplemented!("Unsupported target OS");
19597 }
19598 #[inline]
uenum_openCharStringsEnumeration(strings: *const *const i8, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration19599 pub unsafe fn uenum_openCharStringsEnumeration(strings: *const *const i8, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration {
19600     #[cfg(windows)]
19601     {
19602         #[link(name = "windows")]
19603         extern "system" {
19604             fn uenum_openCharStringsEnumeration(strings: *const *const i8, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration;
19605         }
19606         ::std::mem::transmute(uenum_openCharStringsEnumeration(::std::mem::transmute(strings), ::std::mem::transmute(count), ::std::mem::transmute(ec)))
19607     }
19608     #[cfg(not(windows))]
19609     unimplemented!("Unsupported target OS");
19610 }
19611 #[inline]
uenum_openUCharStringsEnumeration(strings: *const *const u16, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration19612 pub unsafe fn uenum_openUCharStringsEnumeration(strings: *const *const u16, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration {
19613     #[cfg(windows)]
19614     {
19615         #[link(name = "windows")]
19616         extern "system" {
19617             fn uenum_openUCharStringsEnumeration(strings: *const *const u16, count: i32, ec: *mut UErrorCode) -> *mut UEnumeration;
19618         }
19619         ::std::mem::transmute(uenum_openUCharStringsEnumeration(::std::mem::transmute(strings), ::std::mem::transmute(count), ::std::mem::transmute(ec)))
19620     }
19621     #[cfg(not(windows))]
19622     unimplemented!("Unsupported target OS");
19623 }
19624 #[inline]
uenum_reset(en: *mut UEnumeration, status: *mut UErrorCode)19625 pub unsafe fn uenum_reset(en: *mut UEnumeration, status: *mut UErrorCode) {
19626     #[cfg(windows)]
19627     {
19628         #[link(name = "windows")]
19629         extern "system" {
19630             fn uenum_reset(en: *mut UEnumeration, status: *mut UErrorCode);
19631         }
19632         ::std::mem::transmute(uenum_reset(::std::mem::transmute(en), ::std::mem::transmute(status)))
19633     }
19634     #[cfg(not(windows))]
19635     unimplemented!("Unsupported target OS");
19636 }
19637 #[inline]
uenum_unext(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> *mut u1619638 pub unsafe fn uenum_unext(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> *mut u16 {
19639     #[cfg(windows)]
19640     {
19641         #[link(name = "windows")]
19642         extern "system" {
19643             fn uenum_unext(en: *mut UEnumeration, resultlength: *mut i32, status: *mut UErrorCode) -> *mut u16;
19644         }
19645         ::std::mem::transmute(uenum_unext(::std::mem::transmute(en), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
19646     }
19647     #[cfg(not(windows))]
19648     unimplemented!("Unsupported target OS");
19649 }
19650 #[inline]
ufieldpositer_close(fpositer: *mut UFieldPositionIterator)19651 pub unsafe fn ufieldpositer_close(fpositer: *mut UFieldPositionIterator) {
19652     #[cfg(windows)]
19653     {
19654         #[link(name = "windows")]
19655         extern "system" {
19656             fn ufieldpositer_close(fpositer: *mut UFieldPositionIterator);
19657         }
19658         ::std::mem::transmute(ufieldpositer_close(::std::mem::transmute(fpositer)))
19659     }
19660     #[cfg(not(windows))]
19661     unimplemented!("Unsupported target OS");
19662 }
19663 #[inline]
ufieldpositer_next(fpositer: *mut UFieldPositionIterator, beginindex: *mut i32, endindex: *mut i32) -> i3219664 pub unsafe fn ufieldpositer_next(fpositer: *mut UFieldPositionIterator, beginindex: *mut i32, endindex: *mut i32) -> i32 {
19665     #[cfg(windows)]
19666     {
19667         #[link(name = "windows")]
19668         extern "system" {
19669             fn ufieldpositer_next(fpositer: *mut UFieldPositionIterator, beginindex: *mut i32, endindex: *mut i32) -> i32;
19670         }
19671         ::std::mem::transmute(ufieldpositer_next(::std::mem::transmute(fpositer), ::std::mem::transmute(beginindex), ::std::mem::transmute(endindex)))
19672     }
19673     #[cfg(not(windows))]
19674     unimplemented!("Unsupported target OS");
19675 }
19676 #[inline]
ufieldpositer_open(status: *mut UErrorCode) -> *mut UFieldPositionIterator19677 pub unsafe fn ufieldpositer_open(status: *mut UErrorCode) -> *mut UFieldPositionIterator {
19678     #[cfg(windows)]
19679     {
19680         #[link(name = "windows")]
19681         extern "system" {
19682             fn ufieldpositer_open(status: *mut UErrorCode) -> *mut UFieldPositionIterator;
19683         }
19684         ::std::mem::transmute(ufieldpositer_open(::std::mem::transmute(status)))
19685     }
19686     #[cfg(not(windows))]
19687     unimplemented!("Unsupported target OS");
19688 }
19689 #[inline]
ufmt_close(fmt: *mut *mut ::std::ffi::c_void)19690 pub unsafe fn ufmt_close(fmt: *mut *mut ::std::ffi::c_void) {
19691     #[cfg(windows)]
19692     {
19693         #[link(name = "windows")]
19694         extern "system" {
19695             fn ufmt_close(fmt: *mut *mut ::std::ffi::c_void);
19696         }
19697         ::std::mem::transmute(ufmt_close(::std::mem::transmute(fmt)))
19698     }
19699     #[cfg(not(windows))]
19700     unimplemented!("Unsupported target OS");
19701 }
19702 #[inline]
ufmt_getArrayItemByIndex(fmt: *mut *mut ::std::ffi::c_void, n: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19703 pub unsafe fn ufmt_getArrayItemByIndex(fmt: *mut *mut ::std::ffi::c_void, n: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19704     #[cfg(windows)]
19705     {
19706         #[link(name = "windows")]
19707         extern "system" {
19708             fn ufmt_getArrayItemByIndex(fmt: *mut *mut ::std::ffi::c_void, n: i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19709         }
19710         ::std::mem::transmute(ufmt_getArrayItemByIndex(::std::mem::transmute(fmt), ::std::mem::transmute(n), ::std::mem::transmute(status)))
19711     }
19712     #[cfg(not(windows))]
19713     unimplemented!("Unsupported target OS");
19714 }
19715 #[inline]
ufmt_getArrayLength(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i3219716 pub unsafe fn ufmt_getArrayLength(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i32 {
19717     #[cfg(windows)]
19718     {
19719         #[link(name = "windows")]
19720         extern "system" {
19721             fn ufmt_getArrayLength(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> i32;
19722         }
19723         ::std::mem::transmute(ufmt_getArrayLength(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19724     }
19725     #[cfg(not(windows))]
19726     unimplemented!("Unsupported target OS");
19727 }
19728 #[inline]
ufmt_getDate(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f6419729 pub unsafe fn ufmt_getDate(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64 {
19730     #[cfg(windows)]
19731     {
19732         #[link(name = "windows")]
19733         extern "system" {
19734             fn ufmt_getDate(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> f64;
19735         }
19736         ::std::mem::transmute(ufmt_getDate(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19737     }
19738     #[cfg(not(windows))]
19739     unimplemented!("Unsupported target OS");
19740 }
19741 #[cfg(feature = "Win32_Foundation")]
19742 #[inline]
ufmt_getDecNumChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR19743 pub unsafe fn ufmt_getDecNumChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR {
19744     #[cfg(windows)]
19745     {
19746         #[link(name = "windows")]
19747         extern "system" {
19748             fn ufmt_getDecNumChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> super::Foundation::PSTR;
19749         }
19750         ::std::mem::transmute(ufmt_getDecNumChars(::std::mem::transmute(fmt), ::std::mem::transmute(len), ::std::mem::transmute(status)))
19751     }
19752     #[cfg(not(windows))]
19753     unimplemented!("Unsupported target OS");
19754 }
19755 #[inline]
ufmt_getDouble(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> f6419756 pub unsafe fn ufmt_getDouble(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> f64 {
19757     #[cfg(windows)]
19758     {
19759         #[link(name = "windows")]
19760         extern "system" {
19761             fn ufmt_getDouble(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> f64;
19762         }
19763         ::std::mem::transmute(ufmt_getDouble(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19764     }
19765     #[cfg(not(windows))]
19766     unimplemented!("Unsupported target OS");
19767 }
19768 #[inline]
ufmt_getInt64(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i6419769 pub unsafe fn ufmt_getInt64(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i64 {
19770     #[cfg(windows)]
19771     {
19772         #[link(name = "windows")]
19773         extern "system" {
19774             fn ufmt_getInt64(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i64;
19775         }
19776         ::std::mem::transmute(ufmt_getInt64(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19777     }
19778     #[cfg(not(windows))]
19779     unimplemented!("Unsupported target OS");
19780 }
19781 #[inline]
ufmt_getLong(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i3219782 pub unsafe fn ufmt_getLong(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i32 {
19783     #[cfg(windows)]
19784     {
19785         #[link(name = "windows")]
19786         extern "system" {
19787             fn ufmt_getLong(fmt: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) -> i32;
19788         }
19789         ::std::mem::transmute(ufmt_getLong(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19790     }
19791     #[cfg(not(windows))]
19792     unimplemented!("Unsupported target OS");
19793 }
19794 #[inline]
ufmt_getObject(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void19795 pub unsafe fn ufmt_getObject(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void {
19796     #[cfg(windows)]
19797     {
19798         #[link(name = "windows")]
19799         extern "system" {
19800             fn ufmt_getObject(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void;
19801         }
19802         ::std::mem::transmute(ufmt_getObject(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19803     }
19804     #[cfg(not(windows))]
19805     unimplemented!("Unsupported target OS");
19806 }
19807 #[inline]
ufmt_getType(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> UFormattableType19808 pub unsafe fn ufmt_getType(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> UFormattableType {
19809     #[cfg(windows)]
19810     {
19811         #[link(name = "windows")]
19812         extern "system" {
19813             fn ufmt_getType(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> UFormattableType;
19814         }
19815         ::std::mem::transmute(ufmt_getType(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
19816     }
19817     #[cfg(not(windows))]
19818     unimplemented!("Unsupported target OS");
19819 }
19820 #[inline]
ufmt_getUChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> *mut u1619821 pub unsafe fn ufmt_getUChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> *mut u16 {
19822     #[cfg(windows)]
19823     {
19824         #[link(name = "windows")]
19825         extern "system" {
19826             fn ufmt_getUChars(fmt: *mut *mut ::std::ffi::c_void, len: *mut i32, status: *mut UErrorCode) -> *mut u16;
19827         }
19828         ::std::mem::transmute(ufmt_getUChars(::std::mem::transmute(fmt), ::std::mem::transmute(len), ::std::mem::transmute(status)))
19829     }
19830     #[cfg(not(windows))]
19831     unimplemented!("Unsupported target OS");
19832 }
19833 #[inline]
ufmt_isNumeric(fmt: *const *const ::std::ffi::c_void) -> i819834 pub unsafe fn ufmt_isNumeric(fmt: *const *const ::std::ffi::c_void) -> i8 {
19835     #[cfg(windows)]
19836     {
19837         #[link(name = "windows")]
19838         extern "system" {
19839             fn ufmt_isNumeric(fmt: *const *const ::std::ffi::c_void) -> i8;
19840         }
19841         ::std::mem::transmute(ufmt_isNumeric(::std::mem::transmute(fmt)))
19842     }
19843     #[cfg(not(windows))]
19844     unimplemented!("Unsupported target OS");
19845 }
19846 #[inline]
ufmt_open(status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void19847 pub unsafe fn ufmt_open(status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
19848     #[cfg(windows)]
19849     {
19850         #[link(name = "windows")]
19851         extern "system" {
19852             fn ufmt_open(status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
19853         }
19854         ::std::mem::transmute(ufmt_open(::std::mem::transmute(status)))
19855     }
19856     #[cfg(not(windows))]
19857     unimplemented!("Unsupported target OS");
19858 }
19859 #[inline]
ufmtval_getString(ufmtval: *const UFormattedValue, plength: *mut i32, ec: *mut UErrorCode) -> *mut u1619860 pub unsafe fn ufmtval_getString(ufmtval: *const UFormattedValue, plength: *mut i32, ec: *mut UErrorCode) -> *mut u16 {
19861     #[cfg(windows)]
19862     {
19863         #[link(name = "windows")]
19864         extern "system" {
19865             fn ufmtval_getString(ufmtval: *const UFormattedValue, plength: *mut i32, ec: *mut UErrorCode) -> *mut u16;
19866         }
19867         ::std::mem::transmute(ufmtval_getString(::std::mem::transmute(ufmtval), ::std::mem::transmute(plength), ::std::mem::transmute(ec)))
19868     }
19869     #[cfg(not(windows))]
19870     unimplemented!("Unsupported target OS");
19871 }
19872 #[inline]
ufmtval_nextPosition(ufmtval: *const UFormattedValue, ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode) -> i819873 pub unsafe fn ufmtval_nextPosition(ufmtval: *const UFormattedValue, ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode) -> i8 {
19874     #[cfg(windows)]
19875     {
19876         #[link(name = "windows")]
19877         extern "system" {
19878             fn ufmtval_nextPosition(ufmtval: *const UFormattedValue, ucfpos: *mut UConstrainedFieldPosition, ec: *mut UErrorCode) -> i8;
19879         }
19880         ::std::mem::transmute(ufmtval_nextPosition(::std::mem::transmute(ufmtval), ::std::mem::transmute(ucfpos), ::std::mem::transmute(ec)))
19881     }
19882     #[cfg(not(windows))]
19883     unimplemented!("Unsupported target OS");
19884 }
19885 #[cfg(feature = "Win32_Foundation")]
19886 #[inline]
ugender_getInstance<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UGenderInfo19887 pub unsafe fn ugender_getInstance<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UGenderInfo {
19888     #[cfg(windows)]
19889     {
19890         #[link(name = "windows")]
19891         extern "system" {
19892             fn ugender_getInstance(locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UGenderInfo;
19893         }
19894         ::std::mem::transmute(ugender_getInstance(locale.into_param().abi(), ::std::mem::transmute(status)))
19895     }
19896     #[cfg(not(windows))]
19897     unimplemented!("Unsupported target OS");
19898 }
19899 #[inline]
ugender_getListGender(genderinfo: *const UGenderInfo, genders: *const UGender, size: i32, status: *mut UErrorCode) -> UGender19900 pub unsafe fn ugender_getListGender(genderinfo: *const UGenderInfo, genders: *const UGender, size: i32, status: *mut UErrorCode) -> UGender {
19901     #[cfg(windows)]
19902     {
19903         #[link(name = "windows")]
19904         extern "system" {
19905             fn ugender_getListGender(genderinfo: *const UGenderInfo, genders: *const UGender, size: i32, status: *mut UErrorCode) -> UGender;
19906         }
19907         ::std::mem::transmute(ugender_getListGender(::std::mem::transmute(genderinfo), ::std::mem::transmute(genders), ::std::mem::transmute(size), ::std::mem::transmute(status)))
19908     }
19909     #[cfg(not(windows))]
19910     unimplemented!("Unsupported target OS");
19911 }
19912 #[inline]
uidna_close(idna: *mut UIDNA)19913 pub unsafe fn uidna_close(idna: *mut UIDNA) {
19914     #[cfg(windows)]
19915     {
19916         #[link(name = "windows")]
19917         extern "system" {
19918             fn uidna_close(idna: *mut UIDNA);
19919         }
19920         ::std::mem::transmute(uidna_close(::std::mem::transmute(idna)))
19921     }
19922     #[cfg(not(windows))]
19923     unimplemented!("Unsupported target OS");
19924 }
19925 #[inline]
uidna_labelToASCII(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219926 pub unsafe fn uidna_labelToASCII(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19927     #[cfg(windows)]
19928     {
19929         #[link(name = "windows")]
19930         extern "system" {
19931             fn uidna_labelToASCII(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
19932         }
19933         ::std::mem::transmute(uidna_labelToASCII(::std::mem::transmute(idna), ::std::mem::transmute(label), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
19934     }
19935     #[cfg(not(windows))]
19936     unimplemented!("Unsupported target OS");
19937 }
19938 #[cfg(feature = "Win32_Foundation")]
19939 #[inline]
uidna_labelToASCII_UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, label: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219940 pub unsafe fn uidna_labelToASCII_UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, label: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19941     #[cfg(windows)]
19942     {
19943         #[link(name = "windows")]
19944         extern "system" {
19945             fn uidna_labelToASCII_UTF8(idna: *const UIDNA, label: super::Foundation::PSTR, length: i32, dest: super::Foundation::PSTR, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
19946         }
19947         ::std::mem::transmute(uidna_labelToASCII_UTF8(::std::mem::transmute(idna), label.into_param().abi(), ::std::mem::transmute(length), dest.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
19948     }
19949     #[cfg(not(windows))]
19950     unimplemented!("Unsupported target OS");
19951 }
19952 #[inline]
uidna_labelToUnicode(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219953 pub unsafe fn uidna_labelToUnicode(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19954     #[cfg(windows)]
19955     {
19956         #[link(name = "windows")]
19957         extern "system" {
19958             fn uidna_labelToUnicode(idna: *const UIDNA, label: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
19959         }
19960         ::std::mem::transmute(uidna_labelToUnicode(::std::mem::transmute(idna), ::std::mem::transmute(label), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
19961     }
19962     #[cfg(not(windows))]
19963     unimplemented!("Unsupported target OS");
19964 }
19965 #[cfg(feature = "Win32_Foundation")]
19966 #[inline]
uidna_labelToUnicodeUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, label: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219967 pub unsafe fn uidna_labelToUnicodeUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, label: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19968     #[cfg(windows)]
19969     {
19970         #[link(name = "windows")]
19971         extern "system" {
19972             fn uidna_labelToUnicodeUTF8(idna: *const UIDNA, label: super::Foundation::PSTR, length: i32, dest: super::Foundation::PSTR, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
19973         }
19974         ::std::mem::transmute(uidna_labelToUnicodeUTF8(::std::mem::transmute(idna), label.into_param().abi(), ::std::mem::transmute(length), dest.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
19975     }
19976     #[cfg(not(windows))]
19977     unimplemented!("Unsupported target OS");
19978 }
19979 #[inline]
uidna_nameToASCII(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219980 pub unsafe fn uidna_nameToASCII(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19981     #[cfg(windows)]
19982     {
19983         #[link(name = "windows")]
19984         extern "system" {
19985             fn uidna_nameToASCII(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
19986         }
19987         ::std::mem::transmute(uidna_nameToASCII(::std::mem::transmute(idna), ::std::mem::transmute(name), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
19988     }
19989     #[cfg(not(windows))]
19990     unimplemented!("Unsupported target OS");
19991 }
19992 #[cfg(feature = "Win32_Foundation")]
19993 #[inline]
uidna_nameToASCII_UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, name: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3219994 pub unsafe fn uidna_nameToASCII_UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, name: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
19995     #[cfg(windows)]
19996     {
19997         #[link(name = "windows")]
19998         extern "system" {
19999             fn uidna_nameToASCII_UTF8(idna: *const UIDNA, name: super::Foundation::PSTR, length: i32, dest: super::Foundation::PSTR, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
20000         }
20001         ::std::mem::transmute(uidna_nameToASCII_UTF8(::std::mem::transmute(idna), name.into_param().abi(), ::std::mem::transmute(length), dest.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
20002     }
20003     #[cfg(not(windows))]
20004     unimplemented!("Unsupported target OS");
20005 }
20006 #[inline]
uidna_nameToUnicode(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3220007 pub unsafe fn uidna_nameToUnicode(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
20008     #[cfg(windows)]
20009     {
20010         #[link(name = "windows")]
20011         extern "system" {
20012             fn uidna_nameToUnicode(idna: *const UIDNA, name: *const u16, length: i32, dest: *mut u16, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
20013         }
20014         ::std::mem::transmute(uidna_nameToUnicode(::std::mem::transmute(idna), ::std::mem::transmute(name), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
20015     }
20016     #[cfg(not(windows))]
20017     unimplemented!("Unsupported target OS");
20018 }
20019 #[cfg(feature = "Win32_Foundation")]
20020 #[inline]
uidna_nameToUnicodeUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, name: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i3220021 pub unsafe fn uidna_nameToUnicodeUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(idna: *const UIDNA, name: Param1, length: i32, dest: Param3, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32 {
20022     #[cfg(windows)]
20023     {
20024         #[link(name = "windows")]
20025         extern "system" {
20026             fn uidna_nameToUnicodeUTF8(idna: *const UIDNA, name: super::Foundation::PSTR, length: i32, dest: super::Foundation::PSTR, capacity: i32, pinfo: *mut UIDNAInfo, perrorcode: *mut UErrorCode) -> i32;
20027         }
20028         ::std::mem::transmute(uidna_nameToUnicodeUTF8(::std::mem::transmute(idna), name.into_param().abi(), ::std::mem::transmute(length), dest.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(pinfo), ::std::mem::transmute(perrorcode)))
20029     }
20030     #[cfg(not(windows))]
20031     unimplemented!("Unsupported target OS");
20032 }
20033 #[inline]
uidna_openUTS46(options: u32, perrorcode: *mut UErrorCode) -> *mut UIDNA20034 pub unsafe fn uidna_openUTS46(options: u32, perrorcode: *mut UErrorCode) -> *mut UIDNA {
20035     #[cfg(windows)]
20036     {
20037         #[link(name = "windows")]
20038         extern "system" {
20039             fn uidna_openUTS46(options: u32, perrorcode: *mut UErrorCode) -> *mut UIDNA;
20040         }
20041         ::std::mem::transmute(uidna_openUTS46(::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
20042     }
20043     #[cfg(not(windows))]
20044     unimplemented!("Unsupported target OS");
20045 }
20046 #[inline]
uiter_current32(iter: *mut UCharIterator) -> i3220047 pub unsafe fn uiter_current32(iter: *mut UCharIterator) -> i32 {
20048     #[cfg(windows)]
20049     {
20050         #[link(name = "windows")]
20051         extern "system" {
20052             fn uiter_current32(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
20053         }
20054         ::std::mem::transmute(uiter_current32(::std::mem::transmute(iter)))
20055     }
20056     #[cfg(not(windows))]
20057     unimplemented!("Unsupported target OS");
20058 }
20059 #[inline]
uiter_getState(iter: *const UCharIterator) -> u3220060 pub unsafe fn uiter_getState(iter: *const UCharIterator) -> u32 {
20061     #[cfg(windows)]
20062     {
20063         #[link(name = "windows")]
20064         extern "system" {
20065             fn uiter_getState(iter: *const ::std::mem::ManuallyDrop<UCharIterator>) -> u32;
20066         }
20067         ::std::mem::transmute(uiter_getState(::std::mem::transmute(iter)))
20068     }
20069     #[cfg(not(windows))]
20070     unimplemented!("Unsupported target OS");
20071 }
20072 #[inline]
uiter_next32(iter: *mut UCharIterator) -> i3220073 pub unsafe fn uiter_next32(iter: *mut UCharIterator) -> i32 {
20074     #[cfg(windows)]
20075     {
20076         #[link(name = "windows")]
20077         extern "system" {
20078             fn uiter_next32(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
20079         }
20080         ::std::mem::transmute(uiter_next32(::std::mem::transmute(iter)))
20081     }
20082     #[cfg(not(windows))]
20083     unimplemented!("Unsupported target OS");
20084 }
20085 #[inline]
uiter_previous32(iter: *mut UCharIterator) -> i3220086 pub unsafe fn uiter_previous32(iter: *mut UCharIterator) -> i32 {
20087     #[cfg(windows)]
20088     {
20089         #[link(name = "windows")]
20090         extern "system" {
20091             fn uiter_previous32(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>) -> i32;
20092         }
20093         ::std::mem::transmute(uiter_previous32(::std::mem::transmute(iter)))
20094     }
20095     #[cfg(not(windows))]
20096     unimplemented!("Unsupported target OS");
20097 }
20098 #[inline]
uiter_setState(iter: *mut UCharIterator, state: u32, perrorcode: *mut UErrorCode)20099 pub unsafe fn uiter_setState(iter: *mut UCharIterator, state: u32, perrorcode: *mut UErrorCode) {
20100     #[cfg(windows)]
20101     {
20102         #[link(name = "windows")]
20103         extern "system" {
20104             fn uiter_setState(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, state: u32, perrorcode: *mut UErrorCode);
20105         }
20106         ::std::mem::transmute(uiter_setState(::std::mem::transmute(iter), ::std::mem::transmute(state), ::std::mem::transmute(perrorcode)))
20107     }
20108     #[cfg(not(windows))]
20109     unimplemented!("Unsupported target OS");
20110 }
20111 #[inline]
uiter_setString(iter: *mut UCharIterator, s: *const u16, length: i32)20112 pub unsafe fn uiter_setString(iter: *mut UCharIterator, s: *const u16, length: i32) {
20113     #[cfg(windows)]
20114     {
20115         #[link(name = "windows")]
20116         extern "system" {
20117             fn uiter_setString(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, s: *const u16, length: i32);
20118         }
20119         ::std::mem::transmute(uiter_setString(::std::mem::transmute(iter), ::std::mem::transmute(s), ::std::mem::transmute(length)))
20120     }
20121     #[cfg(not(windows))]
20122     unimplemented!("Unsupported target OS");
20123 }
20124 #[cfg(feature = "Win32_Foundation")]
20125 #[inline]
uiter_setUTF16BE<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(iter: *mut UCharIterator, s: Param1, length: i32)20126 pub unsafe fn uiter_setUTF16BE<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(iter: *mut UCharIterator, s: Param1, length: i32) {
20127     #[cfg(windows)]
20128     {
20129         #[link(name = "windows")]
20130         extern "system" {
20131             fn uiter_setUTF16BE(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, s: super::Foundation::PSTR, length: i32);
20132         }
20133         ::std::mem::transmute(uiter_setUTF16BE(::std::mem::transmute(iter), s.into_param().abi(), ::std::mem::transmute(length)))
20134     }
20135     #[cfg(not(windows))]
20136     unimplemented!("Unsupported target OS");
20137 }
20138 #[cfg(feature = "Win32_Foundation")]
20139 #[inline]
uiter_setUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(iter: *mut UCharIterator, s: Param1, length: i32)20140 pub unsafe fn uiter_setUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(iter: *mut UCharIterator, s: Param1, length: i32) {
20141     #[cfg(windows)]
20142     {
20143         #[link(name = "windows")]
20144         extern "system" {
20145             fn uiter_setUTF8(iter: *mut ::std::mem::ManuallyDrop<UCharIterator>, s: super::Foundation::PSTR, length: i32);
20146         }
20147         ::std::mem::transmute(uiter_setUTF8(::std::mem::transmute(iter), s.into_param().abi(), ::std::mem::transmute(length)))
20148     }
20149     #[cfg(not(windows))]
20150     unimplemented!("Unsupported target OS");
20151 }
20152 #[inline]
uldn_close(ldn: *mut ULocaleDisplayNames)20153 pub unsafe fn uldn_close(ldn: *mut ULocaleDisplayNames) {
20154     #[cfg(windows)]
20155     {
20156         #[link(name = "windows")]
20157         extern "system" {
20158             fn uldn_close(ldn: *mut ULocaleDisplayNames);
20159         }
20160         ::std::mem::transmute(uldn_close(::std::mem::transmute(ldn)))
20161     }
20162     #[cfg(not(windows))]
20163     unimplemented!("Unsupported target OS");
20164 }
20165 #[inline]
uldn_getContext(ldn: *const ULocaleDisplayNames, r#type: UDisplayContextType, perrorcode: *mut UErrorCode) -> UDisplayContext20166 pub unsafe fn uldn_getContext(ldn: *const ULocaleDisplayNames, r#type: UDisplayContextType, perrorcode: *mut UErrorCode) -> UDisplayContext {
20167     #[cfg(windows)]
20168     {
20169         #[link(name = "windows")]
20170         extern "system" {
20171             fn uldn_getContext(ldn: *const ULocaleDisplayNames, r#type: UDisplayContextType, perrorcode: *mut UErrorCode) -> UDisplayContext;
20172         }
20173         ::std::mem::transmute(uldn_getContext(::std::mem::transmute(ldn), ::std::mem::transmute(r#type), ::std::mem::transmute(perrorcode)))
20174     }
20175     #[cfg(not(windows))]
20176     unimplemented!("Unsupported target OS");
20177 }
20178 #[inline]
uldn_getDialectHandling(ldn: *const ULocaleDisplayNames) -> UDialectHandling20179 pub unsafe fn uldn_getDialectHandling(ldn: *const ULocaleDisplayNames) -> UDialectHandling {
20180     #[cfg(windows)]
20181     {
20182         #[link(name = "windows")]
20183         extern "system" {
20184             fn uldn_getDialectHandling(ldn: *const ULocaleDisplayNames) -> UDialectHandling;
20185         }
20186         ::std::mem::transmute(uldn_getDialectHandling(::std::mem::transmute(ldn)))
20187     }
20188     #[cfg(not(windows))]
20189     unimplemented!("Unsupported target OS");
20190 }
20191 #[cfg(feature = "Win32_Foundation")]
20192 #[inline]
uldn_getLocale(ldn: *const ULocaleDisplayNames) -> super::Foundation::PSTR20193 pub unsafe fn uldn_getLocale(ldn: *const ULocaleDisplayNames) -> super::Foundation::PSTR {
20194     #[cfg(windows)]
20195     {
20196         #[link(name = "windows")]
20197         extern "system" {
20198             fn uldn_getLocale(ldn: *const ULocaleDisplayNames) -> super::Foundation::PSTR;
20199         }
20200         ::std::mem::transmute(uldn_getLocale(::std::mem::transmute(ldn)))
20201     }
20202     #[cfg(not(windows))]
20203     unimplemented!("Unsupported target OS");
20204 }
20205 #[cfg(feature = "Win32_Foundation")]
20206 #[inline]
uldn_keyDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, key: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220207 pub unsafe fn uldn_keyDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, key: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20208     #[cfg(windows)]
20209     {
20210         #[link(name = "windows")]
20211         extern "system" {
20212             fn uldn_keyDisplayName(ldn: *const ULocaleDisplayNames, key: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20213         }
20214         ::std::mem::transmute(uldn_keyDisplayName(::std::mem::transmute(ldn), key.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20215     }
20216     #[cfg(not(windows))]
20217     unimplemented!("Unsupported target OS");
20218 }
20219 #[cfg(feature = "Win32_Foundation")]
20220 #[inline]
uldn_keyValueDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, key: Param1, value: Param2, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220221 pub unsafe fn uldn_keyValueDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, key: Param1, value: Param2, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20222     #[cfg(windows)]
20223     {
20224         #[link(name = "windows")]
20225         extern "system" {
20226             fn uldn_keyValueDisplayName(ldn: *const ULocaleDisplayNames, key: super::Foundation::PSTR, value: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20227         }
20228         ::std::mem::transmute(uldn_keyValueDisplayName(::std::mem::transmute(ldn), key.into_param().abi(), value.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20229     }
20230     #[cfg(not(windows))]
20231     unimplemented!("Unsupported target OS");
20232 }
20233 #[cfg(feature = "Win32_Foundation")]
20234 #[inline]
uldn_languageDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, lang: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220235 pub unsafe fn uldn_languageDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, lang: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20236     #[cfg(windows)]
20237     {
20238         #[link(name = "windows")]
20239         extern "system" {
20240             fn uldn_languageDisplayName(ldn: *const ULocaleDisplayNames, lang: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20241         }
20242         ::std::mem::transmute(uldn_languageDisplayName(::std::mem::transmute(ldn), lang.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20243     }
20244     #[cfg(not(windows))]
20245     unimplemented!("Unsupported target OS");
20246 }
20247 #[cfg(feature = "Win32_Foundation")]
20248 #[inline]
uldn_localeDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, locale: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220249 pub unsafe fn uldn_localeDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, locale: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20250     #[cfg(windows)]
20251     {
20252         #[link(name = "windows")]
20253         extern "system" {
20254             fn uldn_localeDisplayName(ldn: *const ULocaleDisplayNames, locale: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20255         }
20256         ::std::mem::transmute(uldn_localeDisplayName(::std::mem::transmute(ldn), locale.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20257     }
20258     #[cfg(not(windows))]
20259     unimplemented!("Unsupported target OS");
20260 }
20261 #[cfg(feature = "Win32_Foundation")]
20262 #[inline]
uldn_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, dialecthandling: UDialectHandling, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames20263 pub unsafe fn uldn_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, dialecthandling: UDialectHandling, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames {
20264     #[cfg(windows)]
20265     {
20266         #[link(name = "windows")]
20267         extern "system" {
20268             fn uldn_open(locale: super::Foundation::PSTR, dialecthandling: UDialectHandling, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames;
20269         }
20270         ::std::mem::transmute(uldn_open(locale.into_param().abi(), ::std::mem::transmute(dialecthandling), ::std::mem::transmute(perrorcode)))
20271     }
20272     #[cfg(not(windows))]
20273     unimplemented!("Unsupported target OS");
20274 }
20275 #[cfg(feature = "Win32_Foundation")]
20276 #[inline]
uldn_openForContext<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, contexts: *mut UDisplayContext, length: i32, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames20277 pub unsafe fn uldn_openForContext<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, contexts: *mut UDisplayContext, length: i32, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames {
20278     #[cfg(windows)]
20279     {
20280         #[link(name = "windows")]
20281         extern "system" {
20282             fn uldn_openForContext(locale: super::Foundation::PSTR, contexts: *mut UDisplayContext, length: i32, perrorcode: *mut UErrorCode) -> *mut ULocaleDisplayNames;
20283         }
20284         ::std::mem::transmute(uldn_openForContext(locale.into_param().abi(), ::std::mem::transmute(contexts), ::std::mem::transmute(length), ::std::mem::transmute(perrorcode)))
20285     }
20286     #[cfg(not(windows))]
20287     unimplemented!("Unsupported target OS");
20288 }
20289 #[cfg(feature = "Win32_Foundation")]
20290 #[inline]
uldn_regionDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, region: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220291 pub unsafe fn uldn_regionDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, region: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20292     #[cfg(windows)]
20293     {
20294         #[link(name = "windows")]
20295         extern "system" {
20296             fn uldn_regionDisplayName(ldn: *const ULocaleDisplayNames, region: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20297         }
20298         ::std::mem::transmute(uldn_regionDisplayName(::std::mem::transmute(ldn), region.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20299     }
20300     #[cfg(not(windows))]
20301     unimplemented!("Unsupported target OS");
20302 }
20303 #[inline]
uldn_scriptCodeDisplayName(ldn: *const ULocaleDisplayNames, scriptcode: UScriptCode, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220304 pub unsafe fn uldn_scriptCodeDisplayName(ldn: *const ULocaleDisplayNames, scriptcode: UScriptCode, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20305     #[cfg(windows)]
20306     {
20307         #[link(name = "windows")]
20308         extern "system" {
20309             fn uldn_scriptCodeDisplayName(ldn: *const ULocaleDisplayNames, scriptcode: UScriptCode, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20310         }
20311         ::std::mem::transmute(uldn_scriptCodeDisplayName(::std::mem::transmute(ldn), ::std::mem::transmute(scriptcode), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20312     }
20313     #[cfg(not(windows))]
20314     unimplemented!("Unsupported target OS");
20315 }
20316 #[cfg(feature = "Win32_Foundation")]
20317 #[inline]
uldn_scriptDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, script: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220318 pub unsafe fn uldn_scriptDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, script: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20319     #[cfg(windows)]
20320     {
20321         #[link(name = "windows")]
20322         extern "system" {
20323             fn uldn_scriptDisplayName(ldn: *const ULocaleDisplayNames, script: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20324         }
20325         ::std::mem::transmute(uldn_scriptDisplayName(::std::mem::transmute(ldn), script.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20326     }
20327     #[cfg(not(windows))]
20328     unimplemented!("Unsupported target OS");
20329 }
20330 #[cfg(feature = "Win32_Foundation")]
20331 #[inline]
uldn_variantDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, variant: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i3220332 pub unsafe fn uldn_variantDisplayName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ldn: *const ULocaleDisplayNames, variant: Param1, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32 {
20333     #[cfg(windows)]
20334     {
20335         #[link(name = "windows")]
20336         extern "system" {
20337             fn uldn_variantDisplayName(ldn: *const ULocaleDisplayNames, variant: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, perrorcode: *mut UErrorCode) -> i32;
20338         }
20339         ::std::mem::transmute(uldn_variantDisplayName(::std::mem::transmute(ldn), variant.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(perrorcode)))
20340     }
20341     #[cfg(not(windows))]
20342     unimplemented!("Unsupported target OS");
20343 }
20344 #[inline]
ulistfmt_close(listfmt: *mut UListFormatter)20345 pub unsafe fn ulistfmt_close(listfmt: *mut UListFormatter) {
20346     #[cfg(windows)]
20347     {
20348         #[link(name = "windows")]
20349         extern "system" {
20350             fn ulistfmt_close(listfmt: *mut UListFormatter);
20351         }
20352         ::std::mem::transmute(ulistfmt_close(::std::mem::transmute(listfmt)))
20353     }
20354     #[cfg(not(windows))]
20355     unimplemented!("Unsupported target OS");
20356 }
20357 #[inline]
ulistfmt_closeResult(uresult: *mut UFormattedList)20358 pub unsafe fn ulistfmt_closeResult(uresult: *mut UFormattedList) {
20359     #[cfg(windows)]
20360     {
20361         #[link(name = "windows")]
20362         extern "system" {
20363             fn ulistfmt_closeResult(uresult: *mut UFormattedList);
20364         }
20365         ::std::mem::transmute(ulistfmt_closeResult(::std::mem::transmute(uresult)))
20366     }
20367     #[cfg(not(windows))]
20368     unimplemented!("Unsupported target OS");
20369 }
20370 #[inline]
ulistfmt_format(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i3220371 pub unsafe fn ulistfmt_format(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32 {
20372     #[cfg(windows)]
20373     {
20374         #[link(name = "windows")]
20375         extern "system" {
20376             fn ulistfmt_format(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32;
20377         }
20378         ::std::mem::transmute(ulistfmt_format(::std::mem::transmute(listfmt), ::std::mem::transmute(strings), ::std::mem::transmute(stringlengths), ::std::mem::transmute(stringcount), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(status)))
20379     }
20380     #[cfg(not(windows))]
20381     unimplemented!("Unsupported target OS");
20382 }
20383 #[inline]
ulistfmt_formatStringsToResult(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, uresult: *mut UFormattedList, status: *mut UErrorCode)20384 pub unsafe fn ulistfmt_formatStringsToResult(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, uresult: *mut UFormattedList, status: *mut UErrorCode) {
20385     #[cfg(windows)]
20386     {
20387         #[link(name = "windows")]
20388         extern "system" {
20389             fn ulistfmt_formatStringsToResult(listfmt: *const UListFormatter, strings: *const *const u16, stringlengths: *const i32, stringcount: i32, uresult: *mut UFormattedList, status: *mut UErrorCode);
20390         }
20391         ::std::mem::transmute(ulistfmt_formatStringsToResult(::std::mem::transmute(listfmt), ::std::mem::transmute(strings), ::std::mem::transmute(stringlengths), ::std::mem::transmute(stringcount), ::std::mem::transmute(uresult), ::std::mem::transmute(status)))
20392     }
20393     #[cfg(not(windows))]
20394     unimplemented!("Unsupported target OS");
20395 }
20396 #[cfg(feature = "Win32_Foundation")]
20397 #[inline]
ulistfmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UListFormatter20398 pub unsafe fn ulistfmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UListFormatter {
20399     #[cfg(windows)]
20400     {
20401         #[link(name = "windows")]
20402         extern "system" {
20403             fn ulistfmt_open(locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UListFormatter;
20404         }
20405         ::std::mem::transmute(ulistfmt_open(locale.into_param().abi(), ::std::mem::transmute(status)))
20406     }
20407     #[cfg(not(windows))]
20408     unimplemented!("Unsupported target OS");
20409 }
20410 #[cfg(feature = "Win32_Foundation")]
20411 #[inline]
ulistfmt_openForType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, r#type: UListFormatterType, width: UListFormatterWidth, status: *mut UErrorCode) -> *mut UListFormatter20412 pub unsafe fn ulistfmt_openForType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, r#type: UListFormatterType, width: UListFormatterWidth, status: *mut UErrorCode) -> *mut UListFormatter {
20413     #[cfg(windows)]
20414     {
20415         #[link(name = "windows")]
20416         extern "system" {
20417             fn ulistfmt_openForType(locale: super::Foundation::PSTR, r#type: UListFormatterType, width: UListFormatterWidth, status: *mut UErrorCode) -> *mut UListFormatter;
20418         }
20419         ::std::mem::transmute(ulistfmt_openForType(locale.into_param().abi(), ::std::mem::transmute(r#type), ::std::mem::transmute(width), ::std::mem::transmute(status)))
20420     }
20421     #[cfg(not(windows))]
20422     unimplemented!("Unsupported target OS");
20423 }
20424 #[inline]
ulistfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedList20425 pub unsafe fn ulistfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedList {
20426     #[cfg(windows)]
20427     {
20428         #[link(name = "windows")]
20429         extern "system" {
20430             fn ulistfmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedList;
20431         }
20432         ::std::mem::transmute(ulistfmt_openResult(::std::mem::transmute(ec)))
20433     }
20434     #[cfg(not(windows))]
20435     unimplemented!("Unsupported target OS");
20436 }
20437 #[inline]
ulistfmt_resultAsValue(uresult: *const UFormattedList, ec: *mut UErrorCode) -> *mut UFormattedValue20438 pub unsafe fn ulistfmt_resultAsValue(uresult: *const UFormattedList, ec: *mut UErrorCode) -> *mut UFormattedValue {
20439     #[cfg(windows)]
20440     {
20441         #[link(name = "windows")]
20442         extern "system" {
20443             fn ulistfmt_resultAsValue(uresult: *const UFormattedList, ec: *mut UErrorCode) -> *mut UFormattedValue;
20444         }
20445         ::std::mem::transmute(ulistfmt_resultAsValue(::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
20446     }
20447     #[cfg(not(windows))]
20448     unimplemented!("Unsupported target OS");
20449 }
20450 #[cfg(feature = "Win32_Foundation")]
20451 #[inline]
uloc_acceptLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultavailable: i32, outresult: *mut UAcceptResult, acceptlist: *const *const i8, acceptlistcount: i32, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i3220452 pub unsafe fn uloc_acceptLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultavailable: i32, outresult: *mut UAcceptResult, acceptlist: *const *const i8, acceptlistcount: i32, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i32 {
20453     #[cfg(windows)]
20454     {
20455         #[link(name = "windows")]
20456         extern "system" {
20457             fn uloc_acceptLanguage(result: super::Foundation::PSTR, resultavailable: i32, outresult: *mut UAcceptResult, acceptlist: *const *const i8, acceptlistcount: i32, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i32;
20458         }
20459         ::std::mem::transmute(uloc_acceptLanguage(result.into_param().abi(), ::std::mem::transmute(resultavailable), ::std::mem::transmute(outresult), ::std::mem::transmute(acceptlist), ::std::mem::transmute(acceptlistcount), ::std::mem::transmute(availablelocales), ::std::mem::transmute(status)))
20460     }
20461     #[cfg(not(windows))]
20462     unimplemented!("Unsupported target OS");
20463 }
20464 #[cfg(feature = "Win32_Foundation")]
20465 #[inline]
uloc_acceptLanguageFromHTTP<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultavailable: i32, outresult: *mut UAcceptResult, httpacceptlanguage: Param3, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i3220466 pub unsafe fn uloc_acceptLanguageFromHTTP<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(result: Param0, resultavailable: i32, outresult: *mut UAcceptResult, httpacceptlanguage: Param3, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i32 {
20467     #[cfg(windows)]
20468     {
20469         #[link(name = "windows")]
20470         extern "system" {
20471             fn uloc_acceptLanguageFromHTTP(result: super::Foundation::PSTR, resultavailable: i32, outresult: *mut UAcceptResult, httpacceptlanguage: super::Foundation::PSTR, availablelocales: *mut UEnumeration, status: *mut UErrorCode) -> i32;
20472         }
20473         ::std::mem::transmute(uloc_acceptLanguageFromHTTP(result.into_param().abi(), ::std::mem::transmute(resultavailable), ::std::mem::transmute(outresult), httpacceptlanguage.into_param().abi(), ::std::mem::transmute(availablelocales), ::std::mem::transmute(status)))
20474     }
20475     #[cfg(not(windows))]
20476     unimplemented!("Unsupported target OS");
20477 }
20478 #[cfg(feature = "Win32_Foundation")]
20479 #[inline]
uloc_addLikelySubtags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, maximizedlocaleid: Param1, maximizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i3220480 pub unsafe fn uloc_addLikelySubtags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, maximizedlocaleid: Param1, maximizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i32 {
20481     #[cfg(windows)]
20482     {
20483         #[link(name = "windows")]
20484         extern "system" {
20485             fn uloc_addLikelySubtags(localeid: super::Foundation::PSTR, maximizedlocaleid: super::Foundation::PSTR, maximizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i32;
20486         }
20487         ::std::mem::transmute(uloc_addLikelySubtags(localeid.into_param().abi(), maximizedlocaleid.into_param().abi(), ::std::mem::transmute(maximizedlocaleidcapacity), ::std::mem::transmute(err)))
20488     }
20489     #[cfg(not(windows))]
20490     unimplemented!("Unsupported target OS");
20491 }
20492 #[cfg(feature = "Win32_Foundation")]
20493 #[inline]
uloc_canonicalize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i3220494 pub unsafe fn uloc_canonicalize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i32 {
20495     #[cfg(windows)]
20496     {
20497         #[link(name = "windows")]
20498         extern "system" {
20499             fn uloc_canonicalize(localeid: super::Foundation::PSTR, name: super::Foundation::PSTR, namecapacity: i32, err: *mut UErrorCode) -> i32;
20500         }
20501         ::std::mem::transmute(uloc_canonicalize(localeid.into_param().abi(), name.into_param().abi(), ::std::mem::transmute(namecapacity), ::std::mem::transmute(err)))
20502     }
20503     #[cfg(not(windows))]
20504     unimplemented!("Unsupported target OS");
20505 }
20506 #[inline]
uloc_countAvailable() -> i3220507 pub unsafe fn uloc_countAvailable() -> i32 {
20508     #[cfg(windows)]
20509     {
20510         #[link(name = "windows")]
20511         extern "system" {
20512             fn uloc_countAvailable() -> i32;
20513         }
20514         ::std::mem::transmute(uloc_countAvailable())
20515     }
20516     #[cfg(not(windows))]
20517     unimplemented!("Unsupported target OS");
20518 }
20519 #[cfg(feature = "Win32_Foundation")]
20520 #[inline]
uloc_forLanguageTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(langtag: Param0, localeid: Param1, localeidcapacity: i32, parsedlength: *mut i32, err: *mut UErrorCode) -> i3220521 pub unsafe fn uloc_forLanguageTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(langtag: Param0, localeid: Param1, localeidcapacity: i32, parsedlength: *mut i32, err: *mut UErrorCode) -> i32 {
20522     #[cfg(windows)]
20523     {
20524         #[link(name = "windows")]
20525         extern "system" {
20526             fn uloc_forLanguageTag(langtag: super::Foundation::PSTR, localeid: super::Foundation::PSTR, localeidcapacity: i32, parsedlength: *mut i32, err: *mut UErrorCode) -> i32;
20527         }
20528         ::std::mem::transmute(uloc_forLanguageTag(langtag.into_param().abi(), localeid.into_param().abi(), ::std::mem::transmute(localeidcapacity), ::std::mem::transmute(parsedlength), ::std::mem::transmute(err)))
20529     }
20530     #[cfg(not(windows))]
20531     unimplemented!("Unsupported target OS");
20532 }
20533 #[cfg(feature = "Win32_Foundation")]
20534 #[inline]
uloc_getAvailable(n: i32) -> super::Foundation::PSTR20535 pub unsafe fn uloc_getAvailable(n: i32) -> super::Foundation::PSTR {
20536     #[cfg(windows)]
20537     {
20538         #[link(name = "windows")]
20539         extern "system" {
20540             fn uloc_getAvailable(n: i32) -> super::Foundation::PSTR;
20541         }
20542         ::std::mem::transmute(uloc_getAvailable(::std::mem::transmute(n)))
20543     }
20544     #[cfg(not(windows))]
20545     unimplemented!("Unsupported target OS");
20546 }
20547 #[cfg(feature = "Win32_Foundation")]
20548 #[inline]
uloc_getBaseName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i3220549 pub unsafe fn uloc_getBaseName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i32 {
20550     #[cfg(windows)]
20551     {
20552         #[link(name = "windows")]
20553         extern "system" {
20554             fn uloc_getBaseName(localeid: super::Foundation::PSTR, name: super::Foundation::PSTR, namecapacity: i32, err: *mut UErrorCode) -> i32;
20555         }
20556         ::std::mem::transmute(uloc_getBaseName(localeid.into_param().abi(), name.into_param().abi(), ::std::mem::transmute(namecapacity), ::std::mem::transmute(err)))
20557     }
20558     #[cfg(not(windows))]
20559     unimplemented!("Unsupported target OS");
20560 }
20561 #[cfg(feature = "Win32_Foundation")]
20562 #[inline]
uloc_getCharacterOrientation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> ULayoutType20563 pub unsafe fn uloc_getCharacterOrientation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> ULayoutType {
20564     #[cfg(windows)]
20565     {
20566         #[link(name = "windows")]
20567         extern "system" {
20568             fn uloc_getCharacterOrientation(localeid: super::Foundation::PSTR, status: *mut UErrorCode) -> ULayoutType;
20569         }
20570         ::std::mem::transmute(uloc_getCharacterOrientation(localeid.into_param().abi(), ::std::mem::transmute(status)))
20571     }
20572     #[cfg(not(windows))]
20573     unimplemented!("Unsupported target OS");
20574 }
20575 #[cfg(feature = "Win32_Foundation")]
20576 #[inline]
uloc_getCountry<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, country: Param1, countrycapacity: i32, err: *mut UErrorCode) -> i3220577 pub unsafe fn uloc_getCountry<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, country: Param1, countrycapacity: i32, err: *mut UErrorCode) -> i32 {
20578     #[cfg(windows)]
20579     {
20580         #[link(name = "windows")]
20581         extern "system" {
20582             fn uloc_getCountry(localeid: super::Foundation::PSTR, country: super::Foundation::PSTR, countrycapacity: i32, err: *mut UErrorCode) -> i32;
20583         }
20584         ::std::mem::transmute(uloc_getCountry(localeid.into_param().abi(), country.into_param().abi(), ::std::mem::transmute(countrycapacity), ::std::mem::transmute(err)))
20585     }
20586     #[cfg(not(windows))]
20587     unimplemented!("Unsupported target OS");
20588 }
20589 #[cfg(feature = "Win32_Foundation")]
20590 #[inline]
uloc_getDefault() -> super::Foundation::PSTR20591 pub unsafe fn uloc_getDefault() -> super::Foundation::PSTR {
20592     #[cfg(windows)]
20593     {
20594         #[link(name = "windows")]
20595         extern "system" {
20596             fn uloc_getDefault() -> super::Foundation::PSTR;
20597         }
20598         ::std::mem::transmute(uloc_getDefault())
20599     }
20600     #[cfg(not(windows))]
20601     unimplemented!("Unsupported target OS");
20602 }
20603 #[cfg(feature = "Win32_Foundation")]
20604 #[inline]
uloc_getDisplayCountry<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, country: *mut u16, countrycapacity: i32, status: *mut UErrorCode) -> i3220605 pub unsafe fn uloc_getDisplayCountry<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, country: *mut u16, countrycapacity: i32, status: *mut UErrorCode) -> i32 {
20606     #[cfg(windows)]
20607     {
20608         #[link(name = "windows")]
20609         extern "system" {
20610             fn uloc_getDisplayCountry(locale: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, country: *mut u16, countrycapacity: i32, status: *mut UErrorCode) -> i32;
20611         }
20612         ::std::mem::transmute(uloc_getDisplayCountry(locale.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(country), ::std::mem::transmute(countrycapacity), ::std::mem::transmute(status)))
20613     }
20614     #[cfg(not(windows))]
20615     unimplemented!("Unsupported target OS");
20616 }
20617 #[cfg(feature = "Win32_Foundation")]
20618 #[inline]
uloc_getDisplayKeyword<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, displaylocale: Param1, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3220619 pub unsafe fn uloc_getDisplayKeyword<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, displaylocale: Param1, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
20620     #[cfg(windows)]
20621     {
20622         #[link(name = "windows")]
20623         extern "system" {
20624             fn uloc_getDisplayKeyword(keyword: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
20625         }
20626         ::std::mem::transmute(uloc_getDisplayKeyword(keyword.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
20627     }
20628     #[cfg(not(windows))]
20629     unimplemented!("Unsupported target OS");
20630 }
20631 #[cfg(feature = "Win32_Foundation")]
20632 #[inline]
uloc_getDisplayKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, keyword: Param1, displaylocale: Param2, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3220633 pub unsafe fn uloc_getDisplayKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, keyword: Param1, displaylocale: Param2, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
20634     #[cfg(windows)]
20635     {
20636         #[link(name = "windows")]
20637         extern "system" {
20638             fn uloc_getDisplayKeywordValue(locale: super::Foundation::PSTR, keyword: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
20639         }
20640         ::std::mem::transmute(uloc_getDisplayKeywordValue(locale.into_param().abi(), keyword.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
20641     }
20642     #[cfg(not(windows))]
20643     unimplemented!("Unsupported target OS");
20644 }
20645 #[cfg(feature = "Win32_Foundation")]
20646 #[inline]
uloc_getDisplayLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, language: *mut u16, languagecapacity: i32, status: *mut UErrorCode) -> i3220647 pub unsafe fn uloc_getDisplayLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, language: *mut u16, languagecapacity: i32, status: *mut UErrorCode) -> i32 {
20648     #[cfg(windows)]
20649     {
20650         #[link(name = "windows")]
20651         extern "system" {
20652             fn uloc_getDisplayLanguage(locale: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, language: *mut u16, languagecapacity: i32, status: *mut UErrorCode) -> i32;
20653         }
20654         ::std::mem::transmute(uloc_getDisplayLanguage(locale.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(language), ::std::mem::transmute(languagecapacity), ::std::mem::transmute(status)))
20655     }
20656     #[cfg(not(windows))]
20657     unimplemented!("Unsupported target OS");
20658 }
20659 #[cfg(feature = "Win32_Foundation")]
20660 #[inline]
uloc_getDisplayName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, inlocaleid: Param1, result: *mut u16, maxresultsize: i32, err: *mut UErrorCode) -> i3220661 pub unsafe fn uloc_getDisplayName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, inlocaleid: Param1, result: *mut u16, maxresultsize: i32, err: *mut UErrorCode) -> i32 {
20662     #[cfg(windows)]
20663     {
20664         #[link(name = "windows")]
20665         extern "system" {
20666             fn uloc_getDisplayName(localeid: super::Foundation::PSTR, inlocaleid: super::Foundation::PSTR, result: *mut u16, maxresultsize: i32, err: *mut UErrorCode) -> i32;
20667         }
20668         ::std::mem::transmute(uloc_getDisplayName(localeid.into_param().abi(), inlocaleid.into_param().abi(), ::std::mem::transmute(result), ::std::mem::transmute(maxresultsize), ::std::mem::transmute(err)))
20669     }
20670     #[cfg(not(windows))]
20671     unimplemented!("Unsupported target OS");
20672 }
20673 #[cfg(feature = "Win32_Foundation")]
20674 #[inline]
uloc_getDisplayScript<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, script: *mut u16, scriptcapacity: i32, status: *mut UErrorCode) -> i3220675 pub unsafe fn uloc_getDisplayScript<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, script: *mut u16, scriptcapacity: i32, status: *mut UErrorCode) -> i32 {
20676     #[cfg(windows)]
20677     {
20678         #[link(name = "windows")]
20679         extern "system" {
20680             fn uloc_getDisplayScript(locale: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, script: *mut u16, scriptcapacity: i32, status: *mut UErrorCode) -> i32;
20681         }
20682         ::std::mem::transmute(uloc_getDisplayScript(locale.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(script), ::std::mem::transmute(scriptcapacity), ::std::mem::transmute(status)))
20683     }
20684     #[cfg(not(windows))]
20685     unimplemented!("Unsupported target OS");
20686 }
20687 #[cfg(feature = "Win32_Foundation")]
20688 #[inline]
uloc_getDisplayVariant<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, variant: *mut u16, variantcapacity: i32, status: *mut UErrorCode) -> i3220689 pub unsafe fn uloc_getDisplayVariant<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, displaylocale: Param1, variant: *mut u16, variantcapacity: i32, status: *mut UErrorCode) -> i32 {
20690     #[cfg(windows)]
20691     {
20692         #[link(name = "windows")]
20693         extern "system" {
20694             fn uloc_getDisplayVariant(locale: super::Foundation::PSTR, displaylocale: super::Foundation::PSTR, variant: *mut u16, variantcapacity: i32, status: *mut UErrorCode) -> i32;
20695         }
20696         ::std::mem::transmute(uloc_getDisplayVariant(locale.into_param().abi(), displaylocale.into_param().abi(), ::std::mem::transmute(variant), ::std::mem::transmute(variantcapacity), ::std::mem::transmute(status)))
20697     }
20698     #[cfg(not(windows))]
20699     unimplemented!("Unsupported target OS");
20700 }
20701 #[cfg(feature = "Win32_Foundation")]
20702 #[inline]
uloc_getISO3Country<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> super::Foundation::PSTR20703 pub unsafe fn uloc_getISO3Country<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> super::Foundation::PSTR {
20704     #[cfg(windows)]
20705     {
20706         #[link(name = "windows")]
20707         extern "system" {
20708             fn uloc_getISO3Country(localeid: super::Foundation::PSTR) -> super::Foundation::PSTR;
20709         }
20710         ::std::mem::transmute(uloc_getISO3Country(localeid.into_param().abi()))
20711     }
20712     #[cfg(not(windows))]
20713     unimplemented!("Unsupported target OS");
20714 }
20715 #[cfg(feature = "Win32_Foundation")]
20716 #[inline]
uloc_getISO3Language<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> super::Foundation::PSTR20717 pub unsafe fn uloc_getISO3Language<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> super::Foundation::PSTR {
20718     #[cfg(windows)]
20719     {
20720         #[link(name = "windows")]
20721         extern "system" {
20722             fn uloc_getISO3Language(localeid: super::Foundation::PSTR) -> super::Foundation::PSTR;
20723         }
20724         ::std::mem::transmute(uloc_getISO3Language(localeid.into_param().abi()))
20725     }
20726     #[cfg(not(windows))]
20727     unimplemented!("Unsupported target OS");
20728 }
20729 #[inline]
uloc_getISOCountries() -> *mut *mut i820730 pub unsafe fn uloc_getISOCountries() -> *mut *mut i8 {
20731     #[cfg(windows)]
20732     {
20733         #[link(name = "windows")]
20734         extern "system" {
20735             fn uloc_getISOCountries() -> *mut *mut i8;
20736         }
20737         ::std::mem::transmute(uloc_getISOCountries())
20738     }
20739     #[cfg(not(windows))]
20740     unimplemented!("Unsupported target OS");
20741 }
20742 #[inline]
uloc_getISOLanguages() -> *mut *mut i820743 pub unsafe fn uloc_getISOLanguages() -> *mut *mut i8 {
20744     #[cfg(windows)]
20745     {
20746         #[link(name = "windows")]
20747         extern "system" {
20748             fn uloc_getISOLanguages() -> *mut *mut i8;
20749         }
20750         ::std::mem::transmute(uloc_getISOLanguages())
20751     }
20752     #[cfg(not(windows))]
20753     unimplemented!("Unsupported target OS");
20754 }
20755 #[cfg(feature = "Win32_Foundation")]
20756 #[inline]
uloc_getKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, keywordname: Param1, buffer: Param2, buffercapacity: i32, status: *mut UErrorCode) -> i3220757 pub unsafe fn uloc_getKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, keywordname: Param1, buffer: Param2, buffercapacity: i32, status: *mut UErrorCode) -> i32 {
20758     #[cfg(windows)]
20759     {
20760         #[link(name = "windows")]
20761         extern "system" {
20762             fn uloc_getKeywordValue(localeid: super::Foundation::PSTR, keywordname: super::Foundation::PSTR, buffer: super::Foundation::PSTR, buffercapacity: i32, status: *mut UErrorCode) -> i32;
20763         }
20764         ::std::mem::transmute(uloc_getKeywordValue(localeid.into_param().abi(), keywordname.into_param().abi(), buffer.into_param().abi(), ::std::mem::transmute(buffercapacity), ::std::mem::transmute(status)))
20765     }
20766     #[cfg(not(windows))]
20767     unimplemented!("Unsupported target OS");
20768 }
20769 #[cfg(feature = "Win32_Foundation")]
20770 #[inline]
uloc_getLCID<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> u3220771 pub unsafe fn uloc_getLCID<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0) -> u32 {
20772     #[cfg(windows)]
20773     {
20774         #[link(name = "windows")]
20775         extern "system" {
20776             fn uloc_getLCID(localeid: super::Foundation::PSTR) -> u32;
20777         }
20778         ::std::mem::transmute(uloc_getLCID(localeid.into_param().abi()))
20779     }
20780     #[cfg(not(windows))]
20781     unimplemented!("Unsupported target OS");
20782 }
20783 #[cfg(feature = "Win32_Foundation")]
20784 #[inline]
uloc_getLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, language: Param1, languagecapacity: i32, err: *mut UErrorCode) -> i3220785 pub unsafe fn uloc_getLanguage<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, language: Param1, languagecapacity: i32, err: *mut UErrorCode) -> i32 {
20786     #[cfg(windows)]
20787     {
20788         #[link(name = "windows")]
20789         extern "system" {
20790             fn uloc_getLanguage(localeid: super::Foundation::PSTR, language: super::Foundation::PSTR, languagecapacity: i32, err: *mut UErrorCode) -> i32;
20791         }
20792         ::std::mem::transmute(uloc_getLanguage(localeid.into_param().abi(), language.into_param().abi(), ::std::mem::transmute(languagecapacity), ::std::mem::transmute(err)))
20793     }
20794     #[cfg(not(windows))]
20795     unimplemented!("Unsupported target OS");
20796 }
20797 #[cfg(feature = "Win32_Foundation")]
20798 #[inline]
uloc_getLineOrientation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> ULayoutType20799 pub unsafe fn uloc_getLineOrientation<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> ULayoutType {
20800     #[cfg(windows)]
20801     {
20802         #[link(name = "windows")]
20803         extern "system" {
20804             fn uloc_getLineOrientation(localeid: super::Foundation::PSTR, status: *mut UErrorCode) -> ULayoutType;
20805         }
20806         ::std::mem::transmute(uloc_getLineOrientation(localeid.into_param().abi(), ::std::mem::transmute(status)))
20807     }
20808     #[cfg(not(windows))]
20809     unimplemented!("Unsupported target OS");
20810 }
20811 #[cfg(feature = "Win32_Foundation")]
20812 #[inline]
uloc_getLocaleForLCID<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(hostid: u32, locale: Param1, localecapacity: i32, status: *mut UErrorCode) -> i3220813 pub unsafe fn uloc_getLocaleForLCID<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(hostid: u32, locale: Param1, localecapacity: i32, status: *mut UErrorCode) -> i32 {
20814     #[cfg(windows)]
20815     {
20816         #[link(name = "windows")]
20817         extern "system" {
20818             fn uloc_getLocaleForLCID(hostid: u32, locale: super::Foundation::PSTR, localecapacity: i32, status: *mut UErrorCode) -> i32;
20819         }
20820         ::std::mem::transmute(uloc_getLocaleForLCID(::std::mem::transmute(hostid), locale.into_param().abi(), ::std::mem::transmute(localecapacity), ::std::mem::transmute(status)))
20821     }
20822     #[cfg(not(windows))]
20823     unimplemented!("Unsupported target OS");
20824 }
20825 #[cfg(feature = "Win32_Foundation")]
20826 #[inline]
uloc_getName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i3220827 pub unsafe fn uloc_getName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, name: Param1, namecapacity: i32, err: *mut UErrorCode) -> i32 {
20828     #[cfg(windows)]
20829     {
20830         #[link(name = "windows")]
20831         extern "system" {
20832             fn uloc_getName(localeid: super::Foundation::PSTR, name: super::Foundation::PSTR, namecapacity: i32, err: *mut UErrorCode) -> i32;
20833         }
20834         ::std::mem::transmute(uloc_getName(localeid.into_param().abi(), name.into_param().abi(), ::std::mem::transmute(namecapacity), ::std::mem::transmute(err)))
20835     }
20836     #[cfg(not(windows))]
20837     unimplemented!("Unsupported target OS");
20838 }
20839 #[cfg(feature = "Win32_Foundation")]
20840 #[inline]
uloc_getParent<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, parent: Param1, parentcapacity: i32, err: *mut UErrorCode) -> i3220841 pub unsafe fn uloc_getParent<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, parent: Param1, parentcapacity: i32, err: *mut UErrorCode) -> i32 {
20842     #[cfg(windows)]
20843     {
20844         #[link(name = "windows")]
20845         extern "system" {
20846             fn uloc_getParent(localeid: super::Foundation::PSTR, parent: super::Foundation::PSTR, parentcapacity: i32, err: *mut UErrorCode) -> i32;
20847         }
20848         ::std::mem::transmute(uloc_getParent(localeid.into_param().abi(), parent.into_param().abi(), ::std::mem::transmute(parentcapacity), ::std::mem::transmute(err)))
20849     }
20850     #[cfg(not(windows))]
20851     unimplemented!("Unsupported target OS");
20852 }
20853 #[cfg(feature = "Win32_Foundation")]
20854 #[inline]
uloc_getScript<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, script: Param1, scriptcapacity: i32, err: *mut UErrorCode) -> i3220855 pub unsafe fn uloc_getScript<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, script: Param1, scriptcapacity: i32, err: *mut UErrorCode) -> i32 {
20856     #[cfg(windows)]
20857     {
20858         #[link(name = "windows")]
20859         extern "system" {
20860             fn uloc_getScript(localeid: super::Foundation::PSTR, script: super::Foundation::PSTR, scriptcapacity: i32, err: *mut UErrorCode) -> i32;
20861         }
20862         ::std::mem::transmute(uloc_getScript(localeid.into_param().abi(), script.into_param().abi(), ::std::mem::transmute(scriptcapacity), ::std::mem::transmute(err)))
20863     }
20864     #[cfg(not(windows))]
20865     unimplemented!("Unsupported target OS");
20866 }
20867 #[cfg(feature = "Win32_Foundation")]
20868 #[inline]
uloc_getVariant<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, variant: Param1, variantcapacity: i32, err: *mut UErrorCode) -> i3220869 pub unsafe fn uloc_getVariant<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, variant: Param1, variantcapacity: i32, err: *mut UErrorCode) -> i32 {
20870     #[cfg(windows)]
20871     {
20872         #[link(name = "windows")]
20873         extern "system" {
20874             fn uloc_getVariant(localeid: super::Foundation::PSTR, variant: super::Foundation::PSTR, variantcapacity: i32, err: *mut UErrorCode) -> i32;
20875         }
20876         ::std::mem::transmute(uloc_getVariant(localeid.into_param().abi(), variant.into_param().abi(), ::std::mem::transmute(variantcapacity), ::std::mem::transmute(err)))
20877     }
20878     #[cfg(not(windows))]
20879     unimplemented!("Unsupported target OS");
20880 }
20881 #[cfg(feature = "Win32_Foundation")]
20882 #[inline]
uloc_isRightToLeft<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0) -> i820883 pub unsafe fn uloc_isRightToLeft<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0) -> i8 {
20884     #[cfg(windows)]
20885     {
20886         #[link(name = "windows")]
20887         extern "system" {
20888             fn uloc_isRightToLeft(locale: super::Foundation::PSTR) -> i8;
20889         }
20890         ::std::mem::transmute(uloc_isRightToLeft(locale.into_param().abi()))
20891     }
20892     #[cfg(not(windows))]
20893     unimplemented!("Unsupported target OS");
20894 }
20895 #[cfg(feature = "Win32_Foundation")]
20896 #[inline]
uloc_minimizeSubtags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, minimizedlocaleid: Param1, minimizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i3220897 pub unsafe fn uloc_minimizeSubtags<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, minimizedlocaleid: Param1, minimizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i32 {
20898     #[cfg(windows)]
20899     {
20900         #[link(name = "windows")]
20901         extern "system" {
20902             fn uloc_minimizeSubtags(localeid: super::Foundation::PSTR, minimizedlocaleid: super::Foundation::PSTR, minimizedlocaleidcapacity: i32, err: *mut UErrorCode) -> i32;
20903         }
20904         ::std::mem::transmute(uloc_minimizeSubtags(localeid.into_param().abi(), minimizedlocaleid.into_param().abi(), ::std::mem::transmute(minimizedlocaleidcapacity), ::std::mem::transmute(err)))
20905     }
20906     #[cfg(not(windows))]
20907     unimplemented!("Unsupported target OS");
20908 }
20909 #[inline]
uloc_openAvailableByType(r#type: ULocAvailableType, status: *mut UErrorCode) -> *mut UEnumeration20910 pub unsafe fn uloc_openAvailableByType(r#type: ULocAvailableType, status: *mut UErrorCode) -> *mut UEnumeration {
20911     #[cfg(windows)]
20912     {
20913         #[link(name = "windows")]
20914         extern "system" {
20915             fn uloc_openAvailableByType(r#type: ULocAvailableType, status: *mut UErrorCode) -> *mut UEnumeration;
20916         }
20917         ::std::mem::transmute(uloc_openAvailableByType(::std::mem::transmute(r#type), ::std::mem::transmute(status)))
20918     }
20919     #[cfg(not(windows))]
20920     unimplemented!("Unsupported target OS");
20921 }
20922 #[cfg(feature = "Win32_Foundation")]
20923 #[inline]
uloc_openKeywords<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> *mut UEnumeration20924 pub unsafe fn uloc_openKeywords<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> *mut UEnumeration {
20925     #[cfg(windows)]
20926     {
20927         #[link(name = "windows")]
20928         extern "system" {
20929             fn uloc_openKeywords(localeid: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UEnumeration;
20930         }
20931         ::std::mem::transmute(uloc_openKeywords(localeid.into_param().abi(), ::std::mem::transmute(status)))
20932     }
20933     #[cfg(not(windows))]
20934     unimplemented!("Unsupported target OS");
20935 }
20936 #[cfg(feature = "Win32_Foundation")]
20937 #[inline]
uloc_setDefault<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode)20938 pub unsafe fn uloc_setDefault<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) {
20939     #[cfg(windows)]
20940     {
20941         #[link(name = "windows")]
20942         extern "system" {
20943             fn uloc_setDefault(localeid: super::Foundation::PSTR, status: *mut UErrorCode);
20944         }
20945         ::std::mem::transmute(uloc_setDefault(localeid.into_param().abi(), ::std::mem::transmute(status)))
20946     }
20947     #[cfg(not(windows))]
20948     unimplemented!("Unsupported target OS");
20949 }
20950 #[cfg(feature = "Win32_Foundation")]
20951 #[inline]
uloc_setKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keywordname: Param0, keywordvalue: Param1, buffer: Param2, buffercapacity: i32, status: *mut UErrorCode) -> i3220952 pub unsafe fn uloc_setKeywordValue<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keywordname: Param0, keywordvalue: Param1, buffer: Param2, buffercapacity: i32, status: *mut UErrorCode) -> i32 {
20953     #[cfg(windows)]
20954     {
20955         #[link(name = "windows")]
20956         extern "system" {
20957             fn uloc_setKeywordValue(keywordname: super::Foundation::PSTR, keywordvalue: super::Foundation::PSTR, buffer: super::Foundation::PSTR, buffercapacity: i32, status: *mut UErrorCode) -> i32;
20958         }
20959         ::std::mem::transmute(uloc_setKeywordValue(keywordname.into_param().abi(), keywordvalue.into_param().abi(), buffer.into_param().abi(), ::std::mem::transmute(buffercapacity), ::std::mem::transmute(status)))
20960     }
20961     #[cfg(not(windows))]
20962     unimplemented!("Unsupported target OS");
20963 }
20964 #[cfg(feature = "Win32_Foundation")]
20965 #[inline]
uloc_toLanguageTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, langtag: Param1, langtagcapacity: i32, strict: i8, err: *mut UErrorCode) -> i3220966 pub unsafe fn uloc_toLanguageTag<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, langtag: Param1, langtagcapacity: i32, strict: i8, err: *mut UErrorCode) -> i32 {
20967     #[cfg(windows)]
20968     {
20969         #[link(name = "windows")]
20970         extern "system" {
20971             fn uloc_toLanguageTag(localeid: super::Foundation::PSTR, langtag: super::Foundation::PSTR, langtagcapacity: i32, strict: i8, err: *mut UErrorCode) -> i32;
20972         }
20973         ::std::mem::transmute(uloc_toLanguageTag(localeid.into_param().abi(), langtag.into_param().abi(), ::std::mem::transmute(langtagcapacity), ::std::mem::transmute(strict), ::std::mem::transmute(err)))
20974     }
20975     #[cfg(not(windows))]
20976     unimplemented!("Unsupported target OS");
20977 }
20978 #[cfg(feature = "Win32_Foundation")]
20979 #[inline]
uloc_toLegacyKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0) -> super::Foundation::PSTR20980 pub unsafe fn uloc_toLegacyKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0) -> super::Foundation::PSTR {
20981     #[cfg(windows)]
20982     {
20983         #[link(name = "windows")]
20984         extern "system" {
20985             fn uloc_toLegacyKey(keyword: super::Foundation::PSTR) -> super::Foundation::PSTR;
20986         }
20987         ::std::mem::transmute(uloc_toLegacyKey(keyword.into_param().abi()))
20988     }
20989     #[cfg(not(windows))]
20990     unimplemented!("Unsupported target OS");
20991 }
20992 #[cfg(feature = "Win32_Foundation")]
20993 #[inline]
uloc_toLegacyType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, value: Param1) -> super::Foundation::PSTR20994 pub unsafe fn uloc_toLegacyType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, value: Param1) -> super::Foundation::PSTR {
20995     #[cfg(windows)]
20996     {
20997         #[link(name = "windows")]
20998         extern "system" {
20999             fn uloc_toLegacyType(keyword: super::Foundation::PSTR, value: super::Foundation::PSTR) -> super::Foundation::PSTR;
21000         }
21001         ::std::mem::transmute(uloc_toLegacyType(keyword.into_param().abi(), value.into_param().abi()))
21002     }
21003     #[cfg(not(windows))]
21004     unimplemented!("Unsupported target OS");
21005 }
21006 #[cfg(feature = "Win32_Foundation")]
21007 #[inline]
uloc_toUnicodeLocaleKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0) -> super::Foundation::PSTR21008 pub unsafe fn uloc_toUnicodeLocaleKey<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0) -> super::Foundation::PSTR {
21009     #[cfg(windows)]
21010     {
21011         #[link(name = "windows")]
21012         extern "system" {
21013             fn uloc_toUnicodeLocaleKey(keyword: super::Foundation::PSTR) -> super::Foundation::PSTR;
21014         }
21015         ::std::mem::transmute(uloc_toUnicodeLocaleKey(keyword.into_param().abi()))
21016     }
21017     #[cfg(not(windows))]
21018     unimplemented!("Unsupported target OS");
21019 }
21020 #[cfg(feature = "Win32_Foundation")]
21021 #[inline]
uloc_toUnicodeLocaleType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, value: Param1) -> super::Foundation::PSTR21022 pub unsafe fn uloc_toUnicodeLocaleType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(keyword: Param0, value: Param1) -> super::Foundation::PSTR {
21023     #[cfg(windows)]
21024     {
21025         #[link(name = "windows")]
21026         extern "system" {
21027             fn uloc_toUnicodeLocaleType(keyword: super::Foundation::PSTR, value: super::Foundation::PSTR) -> super::Foundation::PSTR;
21028         }
21029         ::std::mem::transmute(uloc_toUnicodeLocaleType(keyword.into_param().abi(), value.into_param().abi()))
21030     }
21031     #[cfg(not(windows))]
21032     unimplemented!("Unsupported target OS");
21033 }
21034 #[inline]
ulocdata_close(uld: *mut ULocaleData)21035 pub unsafe fn ulocdata_close(uld: *mut ULocaleData) {
21036     #[cfg(windows)]
21037     {
21038         #[link(name = "windows")]
21039         extern "system" {
21040             fn ulocdata_close(uld: *mut ULocaleData);
21041         }
21042         ::std::mem::transmute(ulocdata_close(::std::mem::transmute(uld)))
21043     }
21044     #[cfg(not(windows))]
21045     unimplemented!("Unsupported target OS");
21046 }
21047 #[inline]
ulocdata_getCLDRVersion(versionarray: *mut u8, status: *mut UErrorCode)21048 pub unsafe fn ulocdata_getCLDRVersion(versionarray: *mut u8, status: *mut UErrorCode) {
21049     #[cfg(windows)]
21050     {
21051         #[link(name = "windows")]
21052         extern "system" {
21053             fn ulocdata_getCLDRVersion(versionarray: *mut u8, status: *mut UErrorCode);
21054         }
21055         ::std::mem::transmute(ulocdata_getCLDRVersion(::std::mem::transmute(versionarray), ::std::mem::transmute(status)))
21056     }
21057     #[cfg(not(windows))]
21058     unimplemented!("Unsupported target OS");
21059 }
21060 #[inline]
ulocdata_getDelimiter(uld: *mut ULocaleData, r#type: ULocaleDataDelimiterType, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3221061 pub unsafe fn ulocdata_getDelimiter(uld: *mut ULocaleData, r#type: ULocaleDataDelimiterType, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
21062     #[cfg(windows)]
21063     {
21064         #[link(name = "windows")]
21065         extern "system" {
21066             fn ulocdata_getDelimiter(uld: *mut ULocaleData, r#type: ULocaleDataDelimiterType, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
21067         }
21068         ::std::mem::transmute(ulocdata_getDelimiter(::std::mem::transmute(uld), ::std::mem::transmute(r#type), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
21069     }
21070     #[cfg(not(windows))]
21071     unimplemented!("Unsupported target OS");
21072 }
21073 #[inline]
ulocdata_getExemplarSet(uld: *mut ULocaleData, fillin: *mut USet, options: u32, extype: ULocaleDataExemplarSetType, status: *mut UErrorCode) -> *mut USet21074 pub unsafe fn ulocdata_getExemplarSet(uld: *mut ULocaleData, fillin: *mut USet, options: u32, extype: ULocaleDataExemplarSetType, status: *mut UErrorCode) -> *mut USet {
21075     #[cfg(windows)]
21076     {
21077         #[link(name = "windows")]
21078         extern "system" {
21079             fn ulocdata_getExemplarSet(uld: *mut ULocaleData, fillin: *mut USet, options: u32, extype: ULocaleDataExemplarSetType, status: *mut UErrorCode) -> *mut USet;
21080         }
21081         ::std::mem::transmute(ulocdata_getExemplarSet(::std::mem::transmute(uld), ::std::mem::transmute(fillin), ::std::mem::transmute(options), ::std::mem::transmute(extype), ::std::mem::transmute(status)))
21082     }
21083     #[cfg(not(windows))]
21084     unimplemented!("Unsupported target OS");
21085 }
21086 #[inline]
ulocdata_getLocaleDisplayPattern(uld: *mut ULocaleData, pattern: *mut u16, patterncapacity: i32, status: *mut UErrorCode) -> i3221087 pub unsafe fn ulocdata_getLocaleDisplayPattern(uld: *mut ULocaleData, pattern: *mut u16, patterncapacity: i32, status: *mut UErrorCode) -> i32 {
21088     #[cfg(windows)]
21089     {
21090         #[link(name = "windows")]
21091         extern "system" {
21092             fn ulocdata_getLocaleDisplayPattern(uld: *mut ULocaleData, pattern: *mut u16, patterncapacity: i32, status: *mut UErrorCode) -> i32;
21093         }
21094         ::std::mem::transmute(ulocdata_getLocaleDisplayPattern(::std::mem::transmute(uld), ::std::mem::transmute(pattern), ::std::mem::transmute(patterncapacity), ::std::mem::transmute(status)))
21095     }
21096     #[cfg(not(windows))]
21097     unimplemented!("Unsupported target OS");
21098 }
21099 #[inline]
ulocdata_getLocaleSeparator(uld: *mut ULocaleData, separator: *mut u16, separatorcapacity: i32, status: *mut UErrorCode) -> i3221100 pub unsafe fn ulocdata_getLocaleSeparator(uld: *mut ULocaleData, separator: *mut u16, separatorcapacity: i32, status: *mut UErrorCode) -> i32 {
21101     #[cfg(windows)]
21102     {
21103         #[link(name = "windows")]
21104         extern "system" {
21105             fn ulocdata_getLocaleSeparator(uld: *mut ULocaleData, separator: *mut u16, separatorcapacity: i32, status: *mut UErrorCode) -> i32;
21106         }
21107         ::std::mem::transmute(ulocdata_getLocaleSeparator(::std::mem::transmute(uld), ::std::mem::transmute(separator), ::std::mem::transmute(separatorcapacity), ::std::mem::transmute(status)))
21108     }
21109     #[cfg(not(windows))]
21110     unimplemented!("Unsupported target OS");
21111 }
21112 #[cfg(feature = "Win32_Foundation")]
21113 #[inline]
ulocdata_getMeasurementSystem<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> UMeasurementSystem21114 pub unsafe fn ulocdata_getMeasurementSystem<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> UMeasurementSystem {
21115     #[cfg(windows)]
21116     {
21117         #[link(name = "windows")]
21118         extern "system" {
21119             fn ulocdata_getMeasurementSystem(localeid: super::Foundation::PSTR, status: *mut UErrorCode) -> UMeasurementSystem;
21120         }
21121         ::std::mem::transmute(ulocdata_getMeasurementSystem(localeid.into_param().abi(), ::std::mem::transmute(status)))
21122     }
21123     #[cfg(not(windows))]
21124     unimplemented!("Unsupported target OS");
21125 }
21126 #[inline]
ulocdata_getNoSubstitute(uld: *mut ULocaleData) -> i821127 pub unsafe fn ulocdata_getNoSubstitute(uld: *mut ULocaleData) -> i8 {
21128     #[cfg(windows)]
21129     {
21130         #[link(name = "windows")]
21131         extern "system" {
21132             fn ulocdata_getNoSubstitute(uld: *mut ULocaleData) -> i8;
21133         }
21134         ::std::mem::transmute(ulocdata_getNoSubstitute(::std::mem::transmute(uld)))
21135     }
21136     #[cfg(not(windows))]
21137     unimplemented!("Unsupported target OS");
21138 }
21139 #[cfg(feature = "Win32_Foundation")]
21140 #[inline]
ulocdata_getPaperSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, height: *mut i32, width: *mut i32, status: *mut UErrorCode)21141 pub unsafe fn ulocdata_getPaperSize<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, height: *mut i32, width: *mut i32, status: *mut UErrorCode) {
21142     #[cfg(windows)]
21143     {
21144         #[link(name = "windows")]
21145         extern "system" {
21146             fn ulocdata_getPaperSize(localeid: super::Foundation::PSTR, height: *mut i32, width: *mut i32, status: *mut UErrorCode);
21147         }
21148         ::std::mem::transmute(ulocdata_getPaperSize(localeid.into_param().abi(), ::std::mem::transmute(height), ::std::mem::transmute(width), ::std::mem::transmute(status)))
21149     }
21150     #[cfg(not(windows))]
21151     unimplemented!("Unsupported target OS");
21152 }
21153 #[cfg(feature = "Win32_Foundation")]
21154 #[inline]
ulocdata_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> *mut ULocaleData21155 pub unsafe fn ulocdata_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(localeid: Param0, status: *mut UErrorCode) -> *mut ULocaleData {
21156     #[cfg(windows)]
21157     {
21158         #[link(name = "windows")]
21159         extern "system" {
21160             fn ulocdata_open(localeid: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut ULocaleData;
21161         }
21162         ::std::mem::transmute(ulocdata_open(localeid.into_param().abi(), ::std::mem::transmute(status)))
21163     }
21164     #[cfg(not(windows))]
21165     unimplemented!("Unsupported target OS");
21166 }
21167 #[inline]
ulocdata_setNoSubstitute(uld: *mut ULocaleData, setting: i8)21168 pub unsafe fn ulocdata_setNoSubstitute(uld: *mut ULocaleData, setting: i8) {
21169     #[cfg(windows)]
21170     {
21171         #[link(name = "windows")]
21172         extern "system" {
21173             fn ulocdata_setNoSubstitute(uld: *mut ULocaleData, setting: i8);
21174         }
21175         ::std::mem::transmute(ulocdata_setNoSubstitute(::std::mem::transmute(uld), ::std::mem::transmute(setting)))
21176     }
21177     #[cfg(not(windows))]
21178     unimplemented!("Unsupported target OS");
21179 }
21180 #[inline]
umsg_applyPattern(fmt: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode)21181 pub unsafe fn umsg_applyPattern(fmt: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) {
21182     #[cfg(windows)]
21183     {
21184         #[link(name = "windows")]
21185         extern "system" {
21186             fn umsg_applyPattern(fmt: *mut *mut ::std::ffi::c_void, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode);
21187         }
21188         ::std::mem::transmute(umsg_applyPattern(::std::mem::transmute(fmt), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
21189     }
21190     #[cfg(not(windows))]
21191     unimplemented!("Unsupported target OS");
21192 }
21193 #[inline]
umsg_autoQuoteApostrophe(pattern: *const u16, patternlength: i32, dest: *mut u16, destcapacity: i32, ec: *mut UErrorCode) -> i3221194 pub unsafe fn umsg_autoQuoteApostrophe(pattern: *const u16, patternlength: i32, dest: *mut u16, destcapacity: i32, ec: *mut UErrorCode) -> i32 {
21195     #[cfg(windows)]
21196     {
21197         #[link(name = "windows")]
21198         extern "system" {
21199             fn umsg_autoQuoteApostrophe(pattern: *const u16, patternlength: i32, dest: *mut u16, destcapacity: i32, ec: *mut UErrorCode) -> i32;
21200         }
21201         ::std::mem::transmute(umsg_autoQuoteApostrophe(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(ec)))
21202     }
21203     #[cfg(not(windows))]
21204     unimplemented!("Unsupported target OS");
21205 }
21206 #[inline]
umsg_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void21207 pub unsafe fn umsg_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void {
21208     #[cfg(windows)]
21209     {
21210         #[link(name = "windows")]
21211         extern "system" {
21212             fn umsg_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut ::std::ffi::c_void;
21213         }
21214         ::std::mem::transmute(umsg_clone(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
21215     }
21216     #[cfg(not(windows))]
21217     unimplemented!("Unsupported target OS");
21218 }
21219 #[inline]
umsg_close(format: *mut *mut ::std::ffi::c_void)21220 pub unsafe fn umsg_close(format: *mut *mut ::std::ffi::c_void) {
21221     #[cfg(windows)]
21222     {
21223         #[link(name = "windows")]
21224         extern "system" {
21225             fn umsg_close(format: *mut *mut ::std::ffi::c_void);
21226         }
21227         ::std::mem::transmute(umsg_close(::std::mem::transmute(format)))
21228     }
21229     #[cfg(not(windows))]
21230     unimplemented!("Unsupported target OS");
21231 }
21232 #[inline]
umsg_format(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3221233 pub unsafe fn umsg_format(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
21234     #[cfg(windows)]
21235     {
21236         #[link(name = "windows")]
21237         extern "system" {
21238             fn umsg_format(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
21239         }
21240         ::std::mem::transmute(umsg_format(::std::mem::transmute(fmt), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
21241     }
21242     #[cfg(not(windows))]
21243     unimplemented!("Unsupported target OS");
21244 }
21245 #[cfg(feature = "Win32_Foundation")]
21246 #[inline]
umsg_getLocale(fmt: *const *const ::std::ffi::c_void) -> super::Foundation::PSTR21247 pub unsafe fn umsg_getLocale(fmt: *const *const ::std::ffi::c_void) -> super::Foundation::PSTR {
21248     #[cfg(windows)]
21249     {
21250         #[link(name = "windows")]
21251         extern "system" {
21252             fn umsg_getLocale(fmt: *const *const ::std::ffi::c_void) -> super::Foundation::PSTR;
21253         }
21254         ::std::mem::transmute(umsg_getLocale(::std::mem::transmute(fmt)))
21255     }
21256     #[cfg(not(windows))]
21257     unimplemented!("Unsupported target OS");
21258 }
21259 #[cfg(feature = "Win32_Foundation")]
21260 #[inline]
umsg_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: *const u16, patternlength: i32, locale: Param2, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void21261 pub unsafe fn umsg_open<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: *const u16, patternlength: i32, locale: Param2, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
21262     #[cfg(windows)]
21263     {
21264         #[link(name = "windows")]
21265         extern "system" {
21266             fn umsg_open(pattern: *const u16, patternlength: i32, locale: super::Foundation::PSTR, parseerror: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
21267         }
21268         ::std::mem::transmute(umsg_open(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), locale.into_param().abi(), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
21269     }
21270     #[cfg(not(windows))]
21271     unimplemented!("Unsupported target OS");
21272 }
21273 #[inline]
umsg_parse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, status: *mut UErrorCode)21274 pub unsafe fn umsg_parse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, status: *mut UErrorCode) {
21275     #[cfg(windows)]
21276     {
21277         #[link(name = "windows")]
21278         extern "system" {
21279             fn umsg_parse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, status: *mut UErrorCode);
21280         }
21281         ::std::mem::transmute(umsg_parse(::std::mem::transmute(fmt), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(count), ::std::mem::transmute(status)))
21282     }
21283     #[cfg(not(windows))]
21284     unimplemented!("Unsupported target OS");
21285 }
21286 #[cfg(feature = "Win32_Foundation")]
21287 #[inline]
umsg_setLocale<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *mut *mut ::std::ffi::c_void, locale: Param1)21288 pub unsafe fn umsg_setLocale<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *mut *mut ::std::ffi::c_void, locale: Param1) {
21289     #[cfg(windows)]
21290     {
21291         #[link(name = "windows")]
21292         extern "system" {
21293             fn umsg_setLocale(fmt: *mut *mut ::std::ffi::c_void, locale: super::Foundation::PSTR);
21294         }
21295         ::std::mem::transmute(umsg_setLocale(::std::mem::transmute(fmt), locale.into_param().abi()))
21296     }
21297     #[cfg(not(windows))]
21298     unimplemented!("Unsupported target OS");
21299 }
21300 #[inline]
umsg_toPattern(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3221301 pub unsafe fn umsg_toPattern(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
21302     #[cfg(windows)]
21303     {
21304         #[link(name = "windows")]
21305         extern "system" {
21306             fn umsg_toPattern(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
21307         }
21308         ::std::mem::transmute(umsg_toPattern(::std::mem::transmute(fmt), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
21309     }
21310     #[cfg(not(windows))]
21311     unimplemented!("Unsupported target OS");
21312 }
21313 #[inline]
umsg_vformat(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i3221314 pub unsafe fn umsg_vformat(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i32 {
21315     #[cfg(windows)]
21316     {
21317         #[link(name = "windows")]
21318         extern "system" {
21319             fn umsg_vformat(fmt: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, ap: *mut i8, status: *mut UErrorCode) -> i32;
21320         }
21321         ::std::mem::transmute(umsg_vformat(::std::mem::transmute(fmt), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(ap), ::std::mem::transmute(status)))
21322     }
21323     #[cfg(not(windows))]
21324     unimplemented!("Unsupported target OS");
21325 }
21326 #[inline]
umsg_vparse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, ap: *mut i8, status: *mut UErrorCode)21327 pub unsafe fn umsg_vparse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, ap: *mut i8, status: *mut UErrorCode) {
21328     #[cfg(windows)]
21329     {
21330         #[link(name = "windows")]
21331         extern "system" {
21332             fn umsg_vparse(fmt: *const *const ::std::ffi::c_void, source: *const u16, sourcelength: i32, count: *mut i32, ap: *mut i8, status: *mut UErrorCode);
21333         }
21334         ::std::mem::transmute(umsg_vparse(::std::mem::transmute(fmt), ::std::mem::transmute(source), ::std::mem::transmute(sourcelength), ::std::mem::transmute(count), ::std::mem::transmute(ap), ::std::mem::transmute(status)))
21335     }
21336     #[cfg(not(windows))]
21337     unimplemented!("Unsupported target OS");
21338 }
21339 #[inline]
umutablecptrie_buildImmutable(trie: *mut UMutableCPTrie, r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, perrorcode: *mut UErrorCode) -> *mut UCPTrie21340 pub unsafe fn umutablecptrie_buildImmutable(trie: *mut UMutableCPTrie, r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, perrorcode: *mut UErrorCode) -> *mut UCPTrie {
21341     #[cfg(windows)]
21342     {
21343         #[link(name = "windows")]
21344         extern "system" {
21345             fn umutablecptrie_buildImmutable(trie: *mut UMutableCPTrie, r#type: UCPTrieType, valuewidth: UCPTrieValueWidth, perrorcode: *mut UErrorCode) -> *mut UCPTrie;
21346         }
21347         ::std::mem::transmute(umutablecptrie_buildImmutable(::std::mem::transmute(trie), ::std::mem::transmute(r#type), ::std::mem::transmute(valuewidth), ::std::mem::transmute(perrorcode)))
21348     }
21349     #[cfg(not(windows))]
21350     unimplemented!("Unsupported target OS");
21351 }
21352 #[inline]
umutablecptrie_clone(other: *const UMutableCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie21353 pub unsafe fn umutablecptrie_clone(other: *const UMutableCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie {
21354     #[cfg(windows)]
21355     {
21356         #[link(name = "windows")]
21357         extern "system" {
21358             fn umutablecptrie_clone(other: *const UMutableCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie;
21359         }
21360         ::std::mem::transmute(umutablecptrie_clone(::std::mem::transmute(other), ::std::mem::transmute(perrorcode)))
21361     }
21362     #[cfg(not(windows))]
21363     unimplemented!("Unsupported target OS");
21364 }
21365 #[inline]
umutablecptrie_close(trie: *mut UMutableCPTrie)21366 pub unsafe fn umutablecptrie_close(trie: *mut UMutableCPTrie) {
21367     #[cfg(windows)]
21368     {
21369         #[link(name = "windows")]
21370         extern "system" {
21371             fn umutablecptrie_close(trie: *mut UMutableCPTrie);
21372         }
21373         ::std::mem::transmute(umutablecptrie_close(::std::mem::transmute(trie)))
21374     }
21375     #[cfg(not(windows))]
21376     unimplemented!("Unsupported target OS");
21377 }
21378 #[inline]
umutablecptrie_fromUCPMap(map: *const UCPMap, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie21379 pub unsafe fn umutablecptrie_fromUCPMap(map: *const UCPMap, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie {
21380     #[cfg(windows)]
21381     {
21382         #[link(name = "windows")]
21383         extern "system" {
21384             fn umutablecptrie_fromUCPMap(map: *const UCPMap, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie;
21385         }
21386         ::std::mem::transmute(umutablecptrie_fromUCPMap(::std::mem::transmute(map), ::std::mem::transmute(perrorcode)))
21387     }
21388     #[cfg(not(windows))]
21389     unimplemented!("Unsupported target OS");
21390 }
21391 #[inline]
umutablecptrie_fromUCPTrie(trie: *const UCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie21392 pub unsafe fn umutablecptrie_fromUCPTrie(trie: *const UCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie {
21393     #[cfg(windows)]
21394     {
21395         #[link(name = "windows")]
21396         extern "system" {
21397             fn umutablecptrie_fromUCPTrie(trie: *const UCPTrie, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie;
21398         }
21399         ::std::mem::transmute(umutablecptrie_fromUCPTrie(::std::mem::transmute(trie), ::std::mem::transmute(perrorcode)))
21400     }
21401     #[cfg(not(windows))]
21402     unimplemented!("Unsupported target OS");
21403 }
21404 #[inline]
umutablecptrie_get(trie: *const UMutableCPTrie, c: i32) -> u3221405 pub unsafe fn umutablecptrie_get(trie: *const UMutableCPTrie, c: i32) -> u32 {
21406     #[cfg(windows)]
21407     {
21408         #[link(name = "windows")]
21409         extern "system" {
21410             fn umutablecptrie_get(trie: *const UMutableCPTrie, c: i32) -> u32;
21411         }
21412         ::std::mem::transmute(umutablecptrie_get(::std::mem::transmute(trie), ::std::mem::transmute(c)))
21413     }
21414     #[cfg(not(windows))]
21415     unimplemented!("Unsupported target OS");
21416 }
21417 #[inline]
umutablecptrie_getRange(trie: *const UMutableCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i3221418 pub unsafe fn umutablecptrie_getRange(trie: *const UMutableCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::std::option::Option<UCPMapValueFilter>, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32 {
21419     #[cfg(windows)]
21420     {
21421         #[link(name = "windows")]
21422         extern "system" {
21423             fn umutablecptrie_getRange(trie: *const UMutableCPTrie, start: i32, option: UCPMapRangeOption, surrogatevalue: u32, filter: *mut ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void, pvalue: *mut u32) -> i32;
21424         }
21425         ::std::mem::transmute(umutablecptrie_getRange(::std::mem::transmute(trie), ::std::mem::transmute(start), ::std::mem::transmute(option), ::std::mem::transmute(surrogatevalue), ::std::mem::transmute(filter), ::std::mem::transmute(context), ::std::mem::transmute(pvalue)))
21426     }
21427     #[cfg(not(windows))]
21428     unimplemented!("Unsupported target OS");
21429 }
21430 #[inline]
umutablecptrie_open(initialvalue: u32, errorvalue: u32, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie21431 pub unsafe fn umutablecptrie_open(initialvalue: u32, errorvalue: u32, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie {
21432     #[cfg(windows)]
21433     {
21434         #[link(name = "windows")]
21435         extern "system" {
21436             fn umutablecptrie_open(initialvalue: u32, errorvalue: u32, perrorcode: *mut UErrorCode) -> *mut UMutableCPTrie;
21437         }
21438         ::std::mem::transmute(umutablecptrie_open(::std::mem::transmute(initialvalue), ::std::mem::transmute(errorvalue), ::std::mem::transmute(perrorcode)))
21439     }
21440     #[cfg(not(windows))]
21441     unimplemented!("Unsupported target OS");
21442 }
21443 #[inline]
umutablecptrie_set(trie: *mut UMutableCPTrie, c: i32, value: u32, perrorcode: *mut UErrorCode)21444 pub unsafe fn umutablecptrie_set(trie: *mut UMutableCPTrie, c: i32, value: u32, perrorcode: *mut UErrorCode) {
21445     #[cfg(windows)]
21446     {
21447         #[link(name = "windows")]
21448         extern "system" {
21449             fn umutablecptrie_set(trie: *mut UMutableCPTrie, c: i32, value: u32, perrorcode: *mut UErrorCode);
21450         }
21451         ::std::mem::transmute(umutablecptrie_set(::std::mem::transmute(trie), ::std::mem::transmute(c), ::std::mem::transmute(value), ::std::mem::transmute(perrorcode)))
21452     }
21453     #[cfg(not(windows))]
21454     unimplemented!("Unsupported target OS");
21455 }
21456 #[inline]
umutablecptrie_setRange(trie: *mut UMutableCPTrie, start: i32, end: i32, value: u32, perrorcode: *mut UErrorCode)21457 pub unsafe fn umutablecptrie_setRange(trie: *mut UMutableCPTrie, start: i32, end: i32, value: u32, perrorcode: *mut UErrorCode) {
21458     #[cfg(windows)]
21459     {
21460         #[link(name = "windows")]
21461         extern "system" {
21462             fn umutablecptrie_setRange(trie: *mut UMutableCPTrie, start: i32, end: i32, value: u32, perrorcode: *mut UErrorCode);
21463         }
21464         ::std::mem::transmute(umutablecptrie_setRange(::std::mem::transmute(trie), ::std::mem::transmute(start), ::std::mem::transmute(end), ::std::mem::transmute(value), ::std::mem::transmute(perrorcode)))
21465     }
21466     #[cfg(not(windows))]
21467     unimplemented!("Unsupported target OS");
21468 }
21469 #[inline]
unorm2_append(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i3221470 pub unsafe fn unorm2_append(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i32 {
21471     #[cfg(windows)]
21472     {
21473         #[link(name = "windows")]
21474         extern "system" {
21475             fn unorm2_append(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i32;
21476         }
21477         ::std::mem::transmute(unorm2_append(::std::mem::transmute(norm2), ::std::mem::transmute(first), ::std::mem::transmute(firstlength), ::std::mem::transmute(firstcapacity), ::std::mem::transmute(second), ::std::mem::transmute(secondlength), ::std::mem::transmute(perrorcode)))
21478     }
21479     #[cfg(not(windows))]
21480     unimplemented!("Unsupported target OS");
21481 }
21482 #[inline]
unorm2_close(norm2: *mut UNormalizer2)21483 pub unsafe fn unorm2_close(norm2: *mut UNormalizer2) {
21484     #[cfg(windows)]
21485     {
21486         #[link(name = "windows")]
21487         extern "system" {
21488             fn unorm2_close(norm2: *mut UNormalizer2);
21489         }
21490         ::std::mem::transmute(unorm2_close(::std::mem::transmute(norm2)))
21491     }
21492     #[cfg(not(windows))]
21493     unimplemented!("Unsupported target OS");
21494 }
21495 #[inline]
unorm2_composePair(norm2: *const UNormalizer2, a: i32, b: i32) -> i3221496 pub unsafe fn unorm2_composePair(norm2: *const UNormalizer2, a: i32, b: i32) -> i32 {
21497     #[cfg(windows)]
21498     {
21499         #[link(name = "windows")]
21500         extern "system" {
21501             fn unorm2_composePair(norm2: *const UNormalizer2, a: i32, b: i32) -> i32;
21502         }
21503         ::std::mem::transmute(unorm2_composePair(::std::mem::transmute(norm2), ::std::mem::transmute(a), ::std::mem::transmute(b)))
21504     }
21505     #[cfg(not(windows))]
21506     unimplemented!("Unsupported target OS");
21507 }
21508 #[inline]
unorm2_getCombiningClass(norm2: *const UNormalizer2, c: i32) -> u821509 pub unsafe fn unorm2_getCombiningClass(norm2: *const UNormalizer2, c: i32) -> u8 {
21510     #[cfg(windows)]
21511     {
21512         #[link(name = "windows")]
21513         extern "system" {
21514             fn unorm2_getCombiningClass(norm2: *const UNormalizer2, c: i32) -> u8;
21515         }
21516         ::std::mem::transmute(unorm2_getCombiningClass(::std::mem::transmute(norm2), ::std::mem::transmute(c)))
21517     }
21518     #[cfg(not(windows))]
21519     unimplemented!("Unsupported target OS");
21520 }
21521 #[inline]
unorm2_getDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3221522 pub unsafe fn unorm2_getDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
21523     #[cfg(windows)]
21524     {
21525         #[link(name = "windows")]
21526         extern "system" {
21527             fn unorm2_getDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
21528         }
21529         ::std::mem::transmute(unorm2_getDecomposition(::std::mem::transmute(norm2), ::std::mem::transmute(c), ::std::mem::transmute(decomposition), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
21530     }
21531     #[cfg(not(windows))]
21532     unimplemented!("Unsupported target OS");
21533 }
21534 #[cfg(feature = "Win32_Foundation")]
21535 #[inline]
unorm2_getInstance<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, name: Param1, mode: UNormalization2Mode, perrorcode: *mut UErrorCode) -> *mut UNormalizer221536 pub unsafe fn unorm2_getInstance<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, name: Param1, mode: UNormalization2Mode, perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21537     #[cfg(windows)]
21538     {
21539         #[link(name = "windows")]
21540         extern "system" {
21541             fn unorm2_getInstance(packagename: super::Foundation::PSTR, name: super::Foundation::PSTR, mode: UNormalization2Mode, perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21542         }
21543         ::std::mem::transmute(unorm2_getInstance(packagename.into_param().abi(), name.into_param().abi(), ::std::mem::transmute(mode), ::std::mem::transmute(perrorcode)))
21544     }
21545     #[cfg(not(windows))]
21546     unimplemented!("Unsupported target OS");
21547 }
21548 #[inline]
unorm2_getNFCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer221549 pub unsafe fn unorm2_getNFCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21550     #[cfg(windows)]
21551     {
21552         #[link(name = "windows")]
21553         extern "system" {
21554             fn unorm2_getNFCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21555         }
21556         ::std::mem::transmute(unorm2_getNFCInstance(::std::mem::transmute(perrorcode)))
21557     }
21558     #[cfg(not(windows))]
21559     unimplemented!("Unsupported target OS");
21560 }
21561 #[inline]
unorm2_getNFDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer221562 pub unsafe fn unorm2_getNFDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21563     #[cfg(windows)]
21564     {
21565         #[link(name = "windows")]
21566         extern "system" {
21567             fn unorm2_getNFDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21568         }
21569         ::std::mem::transmute(unorm2_getNFDInstance(::std::mem::transmute(perrorcode)))
21570     }
21571     #[cfg(not(windows))]
21572     unimplemented!("Unsupported target OS");
21573 }
21574 #[inline]
unorm2_getNFKCCasefoldInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer221575 pub unsafe fn unorm2_getNFKCCasefoldInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21576     #[cfg(windows)]
21577     {
21578         #[link(name = "windows")]
21579         extern "system" {
21580             fn unorm2_getNFKCCasefoldInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21581         }
21582         ::std::mem::transmute(unorm2_getNFKCCasefoldInstance(::std::mem::transmute(perrorcode)))
21583     }
21584     #[cfg(not(windows))]
21585     unimplemented!("Unsupported target OS");
21586 }
21587 #[inline]
unorm2_getNFKCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer221588 pub unsafe fn unorm2_getNFKCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21589     #[cfg(windows)]
21590     {
21591         #[link(name = "windows")]
21592         extern "system" {
21593             fn unorm2_getNFKCInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21594         }
21595         ::std::mem::transmute(unorm2_getNFKCInstance(::std::mem::transmute(perrorcode)))
21596     }
21597     #[cfg(not(windows))]
21598     unimplemented!("Unsupported target OS");
21599 }
21600 #[inline]
unorm2_getNFKDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer221601 pub unsafe fn unorm2_getNFKDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21602     #[cfg(windows)]
21603     {
21604         #[link(name = "windows")]
21605         extern "system" {
21606             fn unorm2_getNFKDInstance(perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21607         }
21608         ::std::mem::transmute(unorm2_getNFKDInstance(::std::mem::transmute(perrorcode)))
21609     }
21610     #[cfg(not(windows))]
21611     unimplemented!("Unsupported target OS");
21612 }
21613 #[inline]
unorm2_getRawDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3221614 pub unsafe fn unorm2_getRawDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
21615     #[cfg(windows)]
21616     {
21617         #[link(name = "windows")]
21618         extern "system" {
21619             fn unorm2_getRawDecomposition(norm2: *const UNormalizer2, c: i32, decomposition: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
21620         }
21621         ::std::mem::transmute(unorm2_getRawDecomposition(::std::mem::transmute(norm2), ::std::mem::transmute(c), ::std::mem::transmute(decomposition), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
21622     }
21623     #[cfg(not(windows))]
21624     unimplemented!("Unsupported target OS");
21625 }
21626 #[inline]
unorm2_hasBoundaryAfter(norm2: *const UNormalizer2, c: i32) -> i821627 pub unsafe fn unorm2_hasBoundaryAfter(norm2: *const UNormalizer2, c: i32) -> i8 {
21628     #[cfg(windows)]
21629     {
21630         #[link(name = "windows")]
21631         extern "system" {
21632             fn unorm2_hasBoundaryAfter(norm2: *const UNormalizer2, c: i32) -> i8;
21633         }
21634         ::std::mem::transmute(unorm2_hasBoundaryAfter(::std::mem::transmute(norm2), ::std::mem::transmute(c)))
21635     }
21636     #[cfg(not(windows))]
21637     unimplemented!("Unsupported target OS");
21638 }
21639 #[inline]
unorm2_hasBoundaryBefore(norm2: *const UNormalizer2, c: i32) -> i821640 pub unsafe fn unorm2_hasBoundaryBefore(norm2: *const UNormalizer2, c: i32) -> i8 {
21641     #[cfg(windows)]
21642     {
21643         #[link(name = "windows")]
21644         extern "system" {
21645             fn unorm2_hasBoundaryBefore(norm2: *const UNormalizer2, c: i32) -> i8;
21646         }
21647         ::std::mem::transmute(unorm2_hasBoundaryBefore(::std::mem::transmute(norm2), ::std::mem::transmute(c)))
21648     }
21649     #[cfg(not(windows))]
21650     unimplemented!("Unsupported target OS");
21651 }
21652 #[inline]
unorm2_isInert(norm2: *const UNormalizer2, c: i32) -> i821653 pub unsafe fn unorm2_isInert(norm2: *const UNormalizer2, c: i32) -> i8 {
21654     #[cfg(windows)]
21655     {
21656         #[link(name = "windows")]
21657         extern "system" {
21658             fn unorm2_isInert(norm2: *const UNormalizer2, c: i32) -> i8;
21659         }
21660         ::std::mem::transmute(unorm2_isInert(::std::mem::transmute(norm2), ::std::mem::transmute(c)))
21661     }
21662     #[cfg(not(windows))]
21663     unimplemented!("Unsupported target OS");
21664 }
21665 #[inline]
unorm2_isNormalized(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i821666 pub unsafe fn unorm2_isNormalized(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i8 {
21667     #[cfg(windows)]
21668     {
21669         #[link(name = "windows")]
21670         extern "system" {
21671             fn unorm2_isNormalized(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i8;
21672         }
21673         ::std::mem::transmute(unorm2_isNormalized(::std::mem::transmute(norm2), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(perrorcode)))
21674     }
21675     #[cfg(not(windows))]
21676     unimplemented!("Unsupported target OS");
21677 }
21678 #[inline]
unorm2_normalize(norm2: *const UNormalizer2, src: *const u16, length: i32, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3221679 pub unsafe fn unorm2_normalize(norm2: *const UNormalizer2, src: *const u16, length: i32, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
21680     #[cfg(windows)]
21681     {
21682         #[link(name = "windows")]
21683         extern "system" {
21684             fn unorm2_normalize(norm2: *const UNormalizer2, src: *const u16, length: i32, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
21685         }
21686         ::std::mem::transmute(unorm2_normalize(::std::mem::transmute(norm2), ::std::mem::transmute(src), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
21687     }
21688     #[cfg(not(windows))]
21689     unimplemented!("Unsupported target OS");
21690 }
21691 #[inline]
unorm2_normalizeSecondAndAppend(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i3221692 pub unsafe fn unorm2_normalizeSecondAndAppend(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i32 {
21693     #[cfg(windows)]
21694     {
21695         #[link(name = "windows")]
21696         extern "system" {
21697             fn unorm2_normalizeSecondAndAppend(norm2: *const UNormalizer2, first: *mut u16, firstlength: i32, firstcapacity: i32, second: *const u16, secondlength: i32, perrorcode: *mut UErrorCode) -> i32;
21698         }
21699         ::std::mem::transmute(unorm2_normalizeSecondAndAppend(::std::mem::transmute(norm2), ::std::mem::transmute(first), ::std::mem::transmute(firstlength), ::std::mem::transmute(firstcapacity), ::std::mem::transmute(second), ::std::mem::transmute(secondlength), ::std::mem::transmute(perrorcode)))
21700     }
21701     #[cfg(not(windows))]
21702     unimplemented!("Unsupported target OS");
21703 }
21704 #[inline]
unorm2_openFiltered(norm2: *const UNormalizer2, filterset: *const USet, perrorcode: *mut UErrorCode) -> *mut UNormalizer221705 pub unsafe fn unorm2_openFiltered(norm2: *const UNormalizer2, filterset: *const USet, perrorcode: *mut UErrorCode) -> *mut UNormalizer2 {
21706     #[cfg(windows)]
21707     {
21708         #[link(name = "windows")]
21709         extern "system" {
21710             fn unorm2_openFiltered(norm2: *const UNormalizer2, filterset: *const USet, perrorcode: *mut UErrorCode) -> *mut UNormalizer2;
21711         }
21712         ::std::mem::transmute(unorm2_openFiltered(::std::mem::transmute(norm2), ::std::mem::transmute(filterset), ::std::mem::transmute(perrorcode)))
21713     }
21714     #[cfg(not(windows))]
21715     unimplemented!("Unsupported target OS");
21716 }
21717 #[inline]
unorm2_quickCheck(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> UNormalizationCheckResult21718 pub unsafe fn unorm2_quickCheck(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> UNormalizationCheckResult {
21719     #[cfg(windows)]
21720     {
21721         #[link(name = "windows")]
21722         extern "system" {
21723             fn unorm2_quickCheck(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> UNormalizationCheckResult;
21724         }
21725         ::std::mem::transmute(unorm2_quickCheck(::std::mem::transmute(norm2), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(perrorcode)))
21726     }
21727     #[cfg(not(windows))]
21728     unimplemented!("Unsupported target OS");
21729 }
21730 #[inline]
unorm2_spanQuickCheckYes(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i3221731 pub unsafe fn unorm2_spanQuickCheckYes(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i32 {
21732     #[cfg(windows)]
21733     {
21734         #[link(name = "windows")]
21735         extern "system" {
21736             fn unorm2_spanQuickCheckYes(norm2: *const UNormalizer2, s: *const u16, length: i32, perrorcode: *mut UErrorCode) -> i32;
21737         }
21738         ::std::mem::transmute(unorm2_spanQuickCheckYes(::std::mem::transmute(norm2), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(perrorcode)))
21739     }
21740     #[cfg(not(windows))]
21741     unimplemented!("Unsupported target OS");
21742 }
21743 #[inline]
unorm_compare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i3221744 pub unsafe fn unorm_compare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i32 {
21745     #[cfg(windows)]
21746     {
21747         #[link(name = "windows")]
21748         extern "system" {
21749             fn unorm_compare(s1: *const u16, length1: i32, s2: *const u16, length2: i32, options: u32, perrorcode: *mut UErrorCode) -> i32;
21750         }
21751         ::std::mem::transmute(unorm_compare(::std::mem::transmute(s1), ::std::mem::transmute(length1), ::std::mem::transmute(s2), ::std::mem::transmute(length2), ::std::mem::transmute(options), ::std::mem::transmute(perrorcode)))
21752     }
21753     #[cfg(not(windows))]
21754     unimplemented!("Unsupported target OS");
21755 }
21756 #[inline]
unum_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode)21757 pub unsafe fn unum_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode) {
21758     #[cfg(windows)]
21759     {
21760         #[link(name = "windows")]
21761         extern "system" {
21762             fn unum_applyPattern(format: *mut *mut ::std::ffi::c_void, localized: i8, pattern: *const u16, patternlength: i32, parseerror: *mut UParseError, status: *mut UErrorCode);
21763         }
21764         ::std::mem::transmute(unum_applyPattern(::std::mem::transmute(format), ::std::mem::transmute(localized), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
21765     }
21766     #[cfg(not(windows))]
21767     unimplemented!("Unsupported target OS");
21768 }
21769 #[inline]
unum_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void21770 pub unsafe fn unum_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
21771     #[cfg(windows)]
21772     {
21773         #[link(name = "windows")]
21774         extern "system" {
21775             fn unum_clone(fmt: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
21776         }
21777         ::std::mem::transmute(unum_clone(::std::mem::transmute(fmt), ::std::mem::transmute(status)))
21778     }
21779     #[cfg(not(windows))]
21780     unimplemented!("Unsupported target OS");
21781 }
21782 #[inline]
unum_close(fmt: *mut *mut ::std::ffi::c_void)21783 pub unsafe fn unum_close(fmt: *mut *mut ::std::ffi::c_void) {
21784     #[cfg(windows)]
21785     {
21786         #[link(name = "windows")]
21787         extern "system" {
21788             fn unum_close(fmt: *mut *mut ::std::ffi::c_void);
21789         }
21790         ::std::mem::transmute(unum_close(::std::mem::transmute(fmt)))
21791     }
21792     #[cfg(not(windows))]
21793     unimplemented!("Unsupported target OS");
21794 }
21795 #[inline]
unum_countAvailable() -> i3221796 pub unsafe fn unum_countAvailable() -> i32 {
21797     #[cfg(windows)]
21798     {
21799         #[link(name = "windows")]
21800         extern "system" {
21801             fn unum_countAvailable() -> i32;
21802         }
21803         ::std::mem::transmute(unum_countAvailable())
21804     }
21805     #[cfg(not(windows))]
21806     unimplemented!("Unsupported target OS");
21807 }
21808 #[inline]
unum_format(fmt: *const *const ::std::ffi::c_void, number: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221809 pub unsafe fn unum_format(fmt: *const *const ::std::ffi::c_void, number: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21810     #[cfg(windows)]
21811     {
21812         #[link(name = "windows")]
21813         extern "system" {
21814             fn unum_format(fmt: *const *const ::std::ffi::c_void, number: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21815         }
21816         ::std::mem::transmute(unum_format(::std::mem::transmute(fmt), ::std::mem::transmute(number), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21817     }
21818     #[cfg(not(windows))]
21819     unimplemented!("Unsupported target OS");
21820 }
21821 #[cfg(feature = "Win32_Foundation")]
21822 #[inline]
unum_formatDecimal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *const *const ::std::ffi::c_void, number: Param1, length: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221823 pub unsafe fn unum_formatDecimal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *const *const ::std::ffi::c_void, number: Param1, length: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21824     #[cfg(windows)]
21825     {
21826         #[link(name = "windows")]
21827         extern "system" {
21828             fn unum_formatDecimal(fmt: *const *const ::std::ffi::c_void, number: super::Foundation::PSTR, length: i32, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21829         }
21830         ::std::mem::transmute(unum_formatDecimal(::std::mem::transmute(fmt), number.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21831     }
21832     #[cfg(not(windows))]
21833     unimplemented!("Unsupported target OS");
21834 }
21835 #[inline]
unum_formatDouble(fmt: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221836 pub unsafe fn unum_formatDouble(fmt: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21837     #[cfg(windows)]
21838     {
21839         #[link(name = "windows")]
21840         extern "system" {
21841             fn unum_formatDouble(fmt: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21842         }
21843         ::std::mem::transmute(unum_formatDouble(::std::mem::transmute(fmt), ::std::mem::transmute(number), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21844     }
21845     #[cfg(not(windows))]
21846     unimplemented!("Unsupported target OS");
21847 }
21848 #[inline]
unum_formatDoubleCurrency(fmt: *const *const ::std::ffi::c_void, number: f64, currency: *mut u16, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221849 pub unsafe fn unum_formatDoubleCurrency(fmt: *const *const ::std::ffi::c_void, number: f64, currency: *mut u16, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21850     #[cfg(windows)]
21851     {
21852         #[link(name = "windows")]
21853         extern "system" {
21854             fn unum_formatDoubleCurrency(fmt: *const *const ::std::ffi::c_void, number: f64, currency: *mut u16, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21855         }
21856         ::std::mem::transmute(unum_formatDoubleCurrency(::std::mem::transmute(fmt), ::std::mem::transmute(number), ::std::mem::transmute(currency), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21857     }
21858     #[cfg(not(windows))]
21859     unimplemented!("Unsupported target OS");
21860 }
21861 #[inline]
unum_formatDoubleForFields(format: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i3221862 pub unsafe fn unum_formatDoubleForFields(format: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32 {
21863     #[cfg(windows)]
21864     {
21865         #[link(name = "windows")]
21866         extern "system" {
21867             fn unum_formatDoubleForFields(format: *const *const ::std::ffi::c_void, number: f64, result: *mut u16, resultlength: i32, fpositer: *mut UFieldPositionIterator, status: *mut UErrorCode) -> i32;
21868         }
21869         ::std::mem::transmute(unum_formatDoubleForFields(::std::mem::transmute(format), ::std::mem::transmute(number), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(fpositer), ::std::mem::transmute(status)))
21870     }
21871     #[cfg(not(windows))]
21872     unimplemented!("Unsupported target OS");
21873 }
21874 #[inline]
unum_formatInt64(fmt: *const *const ::std::ffi::c_void, number: i64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221875 pub unsafe fn unum_formatInt64(fmt: *const *const ::std::ffi::c_void, number: i64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21876     #[cfg(windows)]
21877     {
21878         #[link(name = "windows")]
21879         extern "system" {
21880             fn unum_formatInt64(fmt: *const *const ::std::ffi::c_void, number: i64, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21881         }
21882         ::std::mem::transmute(unum_formatInt64(::std::mem::transmute(fmt), ::std::mem::transmute(number), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21883     }
21884     #[cfg(not(windows))]
21885     unimplemented!("Unsupported target OS");
21886 }
21887 #[inline]
unum_formatUFormattable(fmt: *const *const ::std::ffi::c_void, number: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i3221888 pub unsafe fn unum_formatUFormattable(fmt: *const *const ::std::ffi::c_void, number: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32 {
21889     #[cfg(windows)]
21890     {
21891         #[link(name = "windows")]
21892         extern "system" {
21893             fn unum_formatUFormattable(fmt: *const *const ::std::ffi::c_void, number: *const *const ::std::ffi::c_void, result: *mut u16, resultlength: i32, pos: *mut UFieldPosition, status: *mut UErrorCode) -> i32;
21894         }
21895         ::std::mem::transmute(unum_formatUFormattable(::std::mem::transmute(fmt), ::std::mem::transmute(number), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
21896     }
21897     #[cfg(not(windows))]
21898     unimplemented!("Unsupported target OS");
21899 }
21900 #[inline]
unum_getAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> i3221901 pub unsafe fn unum_getAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> i32 {
21902     #[cfg(windows)]
21903     {
21904         #[link(name = "windows")]
21905         extern "system" {
21906             fn unum_getAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> i32;
21907         }
21908         ::std::mem::transmute(unum_getAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr)))
21909     }
21910     #[cfg(not(windows))]
21911     unimplemented!("Unsupported target OS");
21912 }
21913 #[cfg(feature = "Win32_Foundation")]
21914 #[inline]
unum_getAvailable(localeindex: i32) -> super::Foundation::PSTR21915 pub unsafe fn unum_getAvailable(localeindex: i32) -> super::Foundation::PSTR {
21916     #[cfg(windows)]
21917     {
21918         #[link(name = "windows")]
21919         extern "system" {
21920             fn unum_getAvailable(localeindex: i32) -> super::Foundation::PSTR;
21921         }
21922         ::std::mem::transmute(unum_getAvailable(::std::mem::transmute(localeindex)))
21923     }
21924     #[cfg(not(windows))]
21925     unimplemented!("Unsupported target OS");
21926 }
21927 #[inline]
unum_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext21928 pub unsafe fn unum_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext {
21929     #[cfg(windows)]
21930     {
21931         #[link(name = "windows")]
21932         extern "system" {
21933             fn unum_getContext(fmt: *const *const ::std::ffi::c_void, r#type: UDisplayContextType, status: *mut UErrorCode) -> UDisplayContext;
21934         }
21935         ::std::mem::transmute(unum_getContext(::std::mem::transmute(fmt), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
21936     }
21937     #[cfg(not(windows))]
21938     unimplemented!("Unsupported target OS");
21939 }
21940 #[inline]
unum_getDoubleAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> f6421941 pub unsafe fn unum_getDoubleAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> f64 {
21942     #[cfg(windows)]
21943     {
21944         #[link(name = "windows")]
21945         extern "system" {
21946             fn unum_getDoubleAttribute(fmt: *const *const ::std::ffi::c_void, attr: UNumberFormatAttribute) -> f64;
21947         }
21948         ::std::mem::transmute(unum_getDoubleAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr)))
21949     }
21950     #[cfg(not(windows))]
21951     unimplemented!("Unsupported target OS");
21952 }
21953 #[cfg(feature = "Win32_Foundation")]
21954 #[inline]
unum_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR21955 pub unsafe fn unum_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
21956     #[cfg(windows)]
21957     {
21958         #[link(name = "windows")]
21959         extern "system" {
21960             fn unum_getLocaleByType(fmt: *const *const ::std::ffi::c_void, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
21961         }
21962         ::std::mem::transmute(unum_getLocaleByType(::std::mem::transmute(fmt), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
21963     }
21964     #[cfg(not(windows))]
21965     unimplemented!("Unsupported target OS");
21966 }
21967 #[inline]
unum_getSymbol(fmt: *const *const ::std::ffi::c_void, symbol: UNumberFormatSymbol, buffer: *mut u16, size: i32, status: *mut UErrorCode) -> i3221968 pub unsafe fn unum_getSymbol(fmt: *const *const ::std::ffi::c_void, symbol: UNumberFormatSymbol, buffer: *mut u16, size: i32, status: *mut UErrorCode) -> i32 {
21969     #[cfg(windows)]
21970     {
21971         #[link(name = "windows")]
21972         extern "system" {
21973             fn unum_getSymbol(fmt: *const *const ::std::ffi::c_void, symbol: UNumberFormatSymbol, buffer: *mut u16, size: i32, status: *mut UErrorCode) -> i32;
21974         }
21975         ::std::mem::transmute(unum_getSymbol(::std::mem::transmute(fmt), ::std::mem::transmute(symbol), ::std::mem::transmute(buffer), ::std::mem::transmute(size), ::std::mem::transmute(status)))
21976     }
21977     #[cfg(not(windows))]
21978     unimplemented!("Unsupported target OS");
21979 }
21980 #[inline]
unum_getTextAttribute(fmt: *const *const ::std::ffi::c_void, tag: UNumberFormatTextAttribute, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3221981 pub unsafe fn unum_getTextAttribute(fmt: *const *const ::std::ffi::c_void, tag: UNumberFormatTextAttribute, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
21982     #[cfg(windows)]
21983     {
21984         #[link(name = "windows")]
21985         extern "system" {
21986             fn unum_getTextAttribute(fmt: *const *const ::std::ffi::c_void, tag: UNumberFormatTextAttribute, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
21987         }
21988         ::std::mem::transmute(unum_getTextAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(tag), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
21989     }
21990     #[cfg(not(windows))]
21991     unimplemented!("Unsupported target OS");
21992 }
21993 #[cfg(feature = "Win32_Foundation")]
21994 #[inline]
unum_open<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(style: UNumberFormatStyle, pattern: *const u16, patternlength: i32, locale: Param3, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void21995 pub unsafe fn unum_open<'a, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(style: UNumberFormatStyle, pattern: *const u16, patternlength: i32, locale: Param3, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
21996     #[cfg(windows)]
21997     {
21998         #[link(name = "windows")]
21999         extern "system" {
22000             fn unum_open(style: UNumberFormatStyle, pattern: *const u16, patternlength: i32, locale: super::Foundation::PSTR, parseerr: *mut UParseError, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
22001         }
22002         ::std::mem::transmute(unum_open(::std::mem::transmute(style), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), locale.into_param().abi(), ::std::mem::transmute(parseerr), ::std::mem::transmute(status)))
22003     }
22004     #[cfg(not(windows))]
22005     unimplemented!("Unsupported target OS");
22006 }
22007 #[inline]
unum_parse(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i3222008 pub unsafe fn unum_parse(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i32 {
22009     #[cfg(windows)]
22010     {
22011         #[link(name = "windows")]
22012         extern "system" {
22013             fn unum_parse(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i32;
22014         }
22015         ::std::mem::transmute(unum_parse(::std::mem::transmute(fmt), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
22016     }
22017     #[cfg(not(windows))]
22018     unimplemented!("Unsupported target OS");
22019 }
22020 #[cfg(feature = "Win32_Foundation")]
22021 #[inline]
unum_parseDecimal<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, outbuf: Param4, outbuflength: i32, status: *mut UErrorCode) -> i3222022 pub unsafe fn unum_parseDecimal<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, outbuf: Param4, outbuflength: i32, status: *mut UErrorCode) -> i32 {
22023     #[cfg(windows)]
22024     {
22025         #[link(name = "windows")]
22026         extern "system" {
22027             fn unum_parseDecimal(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, outbuf: super::Foundation::PSTR, outbuflength: i32, status: *mut UErrorCode) -> i32;
22028         }
22029         ::std::mem::transmute(unum_parseDecimal(::std::mem::transmute(fmt), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), outbuf.into_param().abi(), ::std::mem::transmute(outbuflength), ::std::mem::transmute(status)))
22030     }
22031     #[cfg(not(windows))]
22032     unimplemented!("Unsupported target OS");
22033 }
22034 #[inline]
unum_parseDouble(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f6422035 pub unsafe fn unum_parseDouble(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f64 {
22036     #[cfg(windows)]
22037     {
22038         #[link(name = "windows")]
22039         extern "system" {
22040             fn unum_parseDouble(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> f64;
22041         }
22042         ::std::mem::transmute(unum_parseDouble(::std::mem::transmute(fmt), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
22043     }
22044     #[cfg(not(windows))]
22045     unimplemented!("Unsupported target OS");
22046 }
22047 #[inline]
unum_parseDoubleCurrency(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, currency: *mut u16, status: *mut UErrorCode) -> f6422048 pub unsafe fn unum_parseDoubleCurrency(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, currency: *mut u16, status: *mut UErrorCode) -> f64 {
22049     #[cfg(windows)]
22050     {
22051         #[link(name = "windows")]
22052         extern "system" {
22053             fn unum_parseDoubleCurrency(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, currency: *mut u16, status: *mut UErrorCode) -> f64;
22054         }
22055         ::std::mem::transmute(unum_parseDoubleCurrency(::std::mem::transmute(fmt), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(currency), ::std::mem::transmute(status)))
22056     }
22057     #[cfg(not(windows))]
22058     unimplemented!("Unsupported target OS");
22059 }
22060 #[inline]
unum_parseInt64(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i6422061 pub unsafe fn unum_parseInt64(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i64 {
22062     #[cfg(windows)]
22063     {
22064         #[link(name = "windows")]
22065         extern "system" {
22066             fn unum_parseInt64(fmt: *const *const ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> i64;
22067         }
22068         ::std::mem::transmute(unum_parseInt64(::std::mem::transmute(fmt), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
22069     }
22070     #[cfg(not(windows))]
22071     unimplemented!("Unsupported target OS");
22072 }
22073 #[inline]
unum_parseToUFormattable(fmt: *const *const ::std::ffi::c_void, result: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void22074 pub unsafe fn unum_parseToUFormattable(fmt: *const *const ::std::ffi::c_void, result: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
22075     #[cfg(windows)]
22076     {
22077         #[link(name = "windows")]
22078         extern "system" {
22079             fn unum_parseToUFormattable(fmt: *const *const ::std::ffi::c_void, result: *mut *mut ::std::ffi::c_void, text: *const u16, textlength: i32, parsepos: *mut i32, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
22080         }
22081         ::std::mem::transmute(unum_parseToUFormattable(::std::mem::transmute(fmt), ::std::mem::transmute(result), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(parsepos), ::std::mem::transmute(status)))
22082     }
22083     #[cfg(not(windows))]
22084     unimplemented!("Unsupported target OS");
22085 }
22086 #[inline]
unum_setAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: i32)22087 pub unsafe fn unum_setAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: i32) {
22088     #[cfg(windows)]
22089     {
22090         #[link(name = "windows")]
22091         extern "system" {
22092             fn unum_setAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: i32);
22093         }
22094         ::std::mem::transmute(unum_setAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr), ::std::mem::transmute(newvalue)))
22095     }
22096     #[cfg(not(windows))]
22097     unimplemented!("Unsupported target OS");
22098 }
22099 #[inline]
unum_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode)22100 pub unsafe fn unum_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode) {
22101     #[cfg(windows)]
22102     {
22103         #[link(name = "windows")]
22104         extern "system" {
22105             fn unum_setContext(fmt: *mut *mut ::std::ffi::c_void, value: UDisplayContext, status: *mut UErrorCode);
22106         }
22107         ::std::mem::transmute(unum_setContext(::std::mem::transmute(fmt), ::std::mem::transmute(value), ::std::mem::transmute(status)))
22108     }
22109     #[cfg(not(windows))]
22110     unimplemented!("Unsupported target OS");
22111 }
22112 #[inline]
unum_setDoubleAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: f64)22113 pub unsafe fn unum_setDoubleAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: f64) {
22114     #[cfg(windows)]
22115     {
22116         #[link(name = "windows")]
22117         extern "system" {
22118             fn unum_setDoubleAttribute(fmt: *mut *mut ::std::ffi::c_void, attr: UNumberFormatAttribute, newvalue: f64);
22119         }
22120         ::std::mem::transmute(unum_setDoubleAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(attr), ::std::mem::transmute(newvalue)))
22121     }
22122     #[cfg(not(windows))]
22123     unimplemented!("Unsupported target OS");
22124 }
22125 #[inline]
unum_setSymbol(fmt: *mut *mut ::std::ffi::c_void, symbol: UNumberFormatSymbol, value: *const u16, length: i32, status: *mut UErrorCode)22126 pub unsafe fn unum_setSymbol(fmt: *mut *mut ::std::ffi::c_void, symbol: UNumberFormatSymbol, value: *const u16, length: i32, status: *mut UErrorCode) {
22127     #[cfg(windows)]
22128     {
22129         #[link(name = "windows")]
22130         extern "system" {
22131             fn unum_setSymbol(fmt: *mut *mut ::std::ffi::c_void, symbol: UNumberFormatSymbol, value: *const u16, length: i32, status: *mut UErrorCode);
22132         }
22133         ::std::mem::transmute(unum_setSymbol(::std::mem::transmute(fmt), ::std::mem::transmute(symbol), ::std::mem::transmute(value), ::std::mem::transmute(length), ::std::mem::transmute(status)))
22134     }
22135     #[cfg(not(windows))]
22136     unimplemented!("Unsupported target OS");
22137 }
22138 #[inline]
unum_setTextAttribute(fmt: *mut *mut ::std::ffi::c_void, tag: UNumberFormatTextAttribute, newvalue: *const u16, newvaluelength: i32, status: *mut UErrorCode)22139 pub unsafe fn unum_setTextAttribute(fmt: *mut *mut ::std::ffi::c_void, tag: UNumberFormatTextAttribute, newvalue: *const u16, newvaluelength: i32, status: *mut UErrorCode) {
22140     #[cfg(windows)]
22141     {
22142         #[link(name = "windows")]
22143         extern "system" {
22144             fn unum_setTextAttribute(fmt: *mut *mut ::std::ffi::c_void, tag: UNumberFormatTextAttribute, newvalue: *const u16, newvaluelength: i32, status: *mut UErrorCode);
22145         }
22146         ::std::mem::transmute(unum_setTextAttribute(::std::mem::transmute(fmt), ::std::mem::transmute(tag), ::std::mem::transmute(newvalue), ::std::mem::transmute(newvaluelength), ::std::mem::transmute(status)))
22147     }
22148     #[cfg(not(windows))]
22149     unimplemented!("Unsupported target OS");
22150 }
22151 #[inline]
unum_toPattern(fmt: *const *const ::std::ffi::c_void, ispatternlocalized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3222152 pub unsafe fn unum_toPattern(fmt: *const *const ::std::ffi::c_void, ispatternlocalized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
22153     #[cfg(windows)]
22154     {
22155         #[link(name = "windows")]
22156         extern "system" {
22157             fn unum_toPattern(fmt: *const *const ::std::ffi::c_void, ispatternlocalized: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
22158         }
22159         ::std::mem::transmute(unum_toPattern(::std::mem::transmute(fmt), ::std::mem::transmute(ispatternlocalized), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
22160     }
22161     #[cfg(not(windows))]
22162     unimplemented!("Unsupported target OS");
22163 }
22164 #[inline]
unumf_close(uformatter: *mut UNumberFormatter)22165 pub unsafe fn unumf_close(uformatter: *mut UNumberFormatter) {
22166     #[cfg(windows)]
22167     {
22168         #[link(name = "windows")]
22169         extern "system" {
22170             fn unumf_close(uformatter: *mut UNumberFormatter);
22171         }
22172         ::std::mem::transmute(unumf_close(::std::mem::transmute(uformatter)))
22173     }
22174     #[cfg(not(windows))]
22175     unimplemented!("Unsupported target OS");
22176 }
22177 #[inline]
unumf_closeResult(uresult: *mut UFormattedNumber)22178 pub unsafe fn unumf_closeResult(uresult: *mut UFormattedNumber) {
22179     #[cfg(windows)]
22180     {
22181         #[link(name = "windows")]
22182         extern "system" {
22183             fn unumf_closeResult(uresult: *mut UFormattedNumber);
22184         }
22185         ::std::mem::transmute(unumf_closeResult(::std::mem::transmute(uresult)))
22186     }
22187     #[cfg(not(windows))]
22188     unimplemented!("Unsupported target OS");
22189 }
22190 #[cfg(feature = "Win32_Foundation")]
22191 #[inline]
unumf_formatDecimal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(uformatter: *const UNumberFormatter, value: Param1, valuelen: i32, uresult: *mut UFormattedNumber, ec: *mut UErrorCode)22192 pub unsafe fn unumf_formatDecimal<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(uformatter: *const UNumberFormatter, value: Param1, valuelen: i32, uresult: *mut UFormattedNumber, ec: *mut UErrorCode) {
22193     #[cfg(windows)]
22194     {
22195         #[link(name = "windows")]
22196         extern "system" {
22197             fn unumf_formatDecimal(uformatter: *const UNumberFormatter, value: super::Foundation::PSTR, valuelen: i32, uresult: *mut UFormattedNumber, ec: *mut UErrorCode);
22198         }
22199         ::std::mem::transmute(unumf_formatDecimal(::std::mem::transmute(uformatter), value.into_param().abi(), ::std::mem::transmute(valuelen), ::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
22200     }
22201     #[cfg(not(windows))]
22202     unimplemented!("Unsupported target OS");
22203 }
22204 #[inline]
unumf_formatDouble(uformatter: *const UNumberFormatter, value: f64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode)22205 pub unsafe fn unumf_formatDouble(uformatter: *const UNumberFormatter, value: f64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode) {
22206     #[cfg(windows)]
22207     {
22208         #[link(name = "windows")]
22209         extern "system" {
22210             fn unumf_formatDouble(uformatter: *const UNumberFormatter, value: f64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode);
22211         }
22212         ::std::mem::transmute(unumf_formatDouble(::std::mem::transmute(uformatter), ::std::mem::transmute(value), ::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
22213     }
22214     #[cfg(not(windows))]
22215     unimplemented!("Unsupported target OS");
22216 }
22217 #[inline]
unumf_formatInt(uformatter: *const UNumberFormatter, value: i64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode)22218 pub unsafe fn unumf_formatInt(uformatter: *const UNumberFormatter, value: i64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode) {
22219     #[cfg(windows)]
22220     {
22221         #[link(name = "windows")]
22222         extern "system" {
22223             fn unumf_formatInt(uformatter: *const UNumberFormatter, value: i64, uresult: *mut UFormattedNumber, ec: *mut UErrorCode);
22224         }
22225         ::std::mem::transmute(unumf_formatInt(::std::mem::transmute(uformatter), ::std::mem::transmute(value), ::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
22226     }
22227     #[cfg(not(windows))]
22228     unimplemented!("Unsupported target OS");
22229 }
22230 #[cfg(feature = "Win32_Foundation")]
22231 #[inline]
unumf_openForSkeletonAndLocale<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(skeleton: *const u16, skeletonlen: i32, locale: Param2, ec: *mut UErrorCode) -> *mut UNumberFormatter22232 pub unsafe fn unumf_openForSkeletonAndLocale<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(skeleton: *const u16, skeletonlen: i32, locale: Param2, ec: *mut UErrorCode) -> *mut UNumberFormatter {
22233     #[cfg(windows)]
22234     {
22235         #[link(name = "windows")]
22236         extern "system" {
22237             fn unumf_openForSkeletonAndLocale(skeleton: *const u16, skeletonlen: i32, locale: super::Foundation::PSTR, ec: *mut UErrorCode) -> *mut UNumberFormatter;
22238         }
22239         ::std::mem::transmute(unumf_openForSkeletonAndLocale(::std::mem::transmute(skeleton), ::std::mem::transmute(skeletonlen), locale.into_param().abi(), ::std::mem::transmute(ec)))
22240     }
22241     #[cfg(not(windows))]
22242     unimplemented!("Unsupported target OS");
22243 }
22244 #[cfg(feature = "Win32_Foundation")]
22245 #[inline]
unumf_openForSkeletonAndLocaleWithError<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(skeleton: *const u16, skeletonlen: i32, locale: Param2, perror: *mut UParseError, ec: *mut UErrorCode) -> *mut UNumberFormatter22246 pub unsafe fn unumf_openForSkeletonAndLocaleWithError<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(skeleton: *const u16, skeletonlen: i32, locale: Param2, perror: *mut UParseError, ec: *mut UErrorCode) -> *mut UNumberFormatter {
22247     #[cfg(windows)]
22248     {
22249         #[link(name = "windows")]
22250         extern "system" {
22251             fn unumf_openForSkeletonAndLocaleWithError(skeleton: *const u16, skeletonlen: i32, locale: super::Foundation::PSTR, perror: *mut UParseError, ec: *mut UErrorCode) -> *mut UNumberFormatter;
22252         }
22253         ::std::mem::transmute(unumf_openForSkeletonAndLocaleWithError(::std::mem::transmute(skeleton), ::std::mem::transmute(skeletonlen), locale.into_param().abi(), ::std::mem::transmute(perror), ::std::mem::transmute(ec)))
22254     }
22255     #[cfg(not(windows))]
22256     unimplemented!("Unsupported target OS");
22257 }
22258 #[inline]
unumf_openResult(ec: *mut UErrorCode) -> *mut UFormattedNumber22259 pub unsafe fn unumf_openResult(ec: *mut UErrorCode) -> *mut UFormattedNumber {
22260     #[cfg(windows)]
22261     {
22262         #[link(name = "windows")]
22263         extern "system" {
22264             fn unumf_openResult(ec: *mut UErrorCode) -> *mut UFormattedNumber;
22265         }
22266         ::std::mem::transmute(unumf_openResult(::std::mem::transmute(ec)))
22267     }
22268     #[cfg(not(windows))]
22269     unimplemented!("Unsupported target OS");
22270 }
22271 #[inline]
unumf_resultAsValue(uresult: *const UFormattedNumber, ec: *mut UErrorCode) -> *mut UFormattedValue22272 pub unsafe fn unumf_resultAsValue(uresult: *const UFormattedNumber, ec: *mut UErrorCode) -> *mut UFormattedValue {
22273     #[cfg(windows)]
22274     {
22275         #[link(name = "windows")]
22276         extern "system" {
22277             fn unumf_resultAsValue(uresult: *const UFormattedNumber, ec: *mut UErrorCode) -> *mut UFormattedValue;
22278         }
22279         ::std::mem::transmute(unumf_resultAsValue(::std::mem::transmute(uresult), ::std::mem::transmute(ec)))
22280     }
22281     #[cfg(not(windows))]
22282     unimplemented!("Unsupported target OS");
22283 }
22284 #[inline]
unumf_resultGetAllFieldPositions(uresult: *const UFormattedNumber, ufpositer: *mut UFieldPositionIterator, ec: *mut UErrorCode)22285 pub unsafe fn unumf_resultGetAllFieldPositions(uresult: *const UFormattedNumber, ufpositer: *mut UFieldPositionIterator, ec: *mut UErrorCode) {
22286     #[cfg(windows)]
22287     {
22288         #[link(name = "windows")]
22289         extern "system" {
22290             fn unumf_resultGetAllFieldPositions(uresult: *const UFormattedNumber, ufpositer: *mut UFieldPositionIterator, ec: *mut UErrorCode);
22291         }
22292         ::std::mem::transmute(unumf_resultGetAllFieldPositions(::std::mem::transmute(uresult), ::std::mem::transmute(ufpositer), ::std::mem::transmute(ec)))
22293     }
22294     #[cfg(not(windows))]
22295     unimplemented!("Unsupported target OS");
22296 }
22297 #[inline]
unumf_resultNextFieldPosition(uresult: *const UFormattedNumber, ufpos: *mut UFieldPosition, ec: *mut UErrorCode) -> i822298 pub unsafe fn unumf_resultNextFieldPosition(uresult: *const UFormattedNumber, ufpos: *mut UFieldPosition, ec: *mut UErrorCode) -> i8 {
22299     #[cfg(windows)]
22300     {
22301         #[link(name = "windows")]
22302         extern "system" {
22303             fn unumf_resultNextFieldPosition(uresult: *const UFormattedNumber, ufpos: *mut UFieldPosition, ec: *mut UErrorCode) -> i8;
22304         }
22305         ::std::mem::transmute(unumf_resultNextFieldPosition(::std::mem::transmute(uresult), ::std::mem::transmute(ufpos), ::std::mem::transmute(ec)))
22306     }
22307     #[cfg(not(windows))]
22308     unimplemented!("Unsupported target OS");
22309 }
22310 #[inline]
unumf_resultToString(uresult: *const UFormattedNumber, buffer: *mut u16, buffercapacity: i32, ec: *mut UErrorCode) -> i3222311 pub unsafe fn unumf_resultToString(uresult: *const UFormattedNumber, buffer: *mut u16, buffercapacity: i32, ec: *mut UErrorCode) -> i32 {
22312     #[cfg(windows)]
22313     {
22314         #[link(name = "windows")]
22315         extern "system" {
22316             fn unumf_resultToString(uresult: *const UFormattedNumber, buffer: *mut u16, buffercapacity: i32, ec: *mut UErrorCode) -> i32;
22317         }
22318         ::std::mem::transmute(unumf_resultToString(::std::mem::transmute(uresult), ::std::mem::transmute(buffer), ::std::mem::transmute(buffercapacity), ::std::mem::transmute(ec)))
22319     }
22320     #[cfg(not(windows))]
22321     unimplemented!("Unsupported target OS");
22322 }
22323 #[inline]
unumsys_close(unumsys: *mut UNumberingSystem)22324 pub unsafe fn unumsys_close(unumsys: *mut UNumberingSystem) {
22325     #[cfg(windows)]
22326     {
22327         #[link(name = "windows")]
22328         extern "system" {
22329             fn unumsys_close(unumsys: *mut UNumberingSystem);
22330         }
22331         ::std::mem::transmute(unumsys_close(::std::mem::transmute(unumsys)))
22332     }
22333     #[cfg(not(windows))]
22334     unimplemented!("Unsupported target OS");
22335 }
22336 #[inline]
unumsys_getDescription(unumsys: *const UNumberingSystem, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3222337 pub unsafe fn unumsys_getDescription(unumsys: *const UNumberingSystem, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
22338     #[cfg(windows)]
22339     {
22340         #[link(name = "windows")]
22341         extern "system" {
22342             fn unumsys_getDescription(unumsys: *const UNumberingSystem, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
22343         }
22344         ::std::mem::transmute(unumsys_getDescription(::std::mem::transmute(unumsys), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
22345     }
22346     #[cfg(not(windows))]
22347     unimplemented!("Unsupported target OS");
22348 }
22349 #[cfg(feature = "Win32_Foundation")]
22350 #[inline]
unumsys_getName(unumsys: *const UNumberingSystem) -> super::Foundation::PSTR22351 pub unsafe fn unumsys_getName(unumsys: *const UNumberingSystem) -> super::Foundation::PSTR {
22352     #[cfg(windows)]
22353     {
22354         #[link(name = "windows")]
22355         extern "system" {
22356             fn unumsys_getName(unumsys: *const UNumberingSystem) -> super::Foundation::PSTR;
22357         }
22358         ::std::mem::transmute(unumsys_getName(::std::mem::transmute(unumsys)))
22359     }
22360     #[cfg(not(windows))]
22361     unimplemented!("Unsupported target OS");
22362 }
22363 #[inline]
unumsys_getRadix(unumsys: *const UNumberingSystem) -> i3222364 pub unsafe fn unumsys_getRadix(unumsys: *const UNumberingSystem) -> i32 {
22365     #[cfg(windows)]
22366     {
22367         #[link(name = "windows")]
22368         extern "system" {
22369             fn unumsys_getRadix(unumsys: *const UNumberingSystem) -> i32;
22370         }
22371         ::std::mem::transmute(unumsys_getRadix(::std::mem::transmute(unumsys)))
22372     }
22373     #[cfg(not(windows))]
22374     unimplemented!("Unsupported target OS");
22375 }
22376 #[inline]
unumsys_isAlgorithmic(unumsys: *const UNumberingSystem) -> i822377 pub unsafe fn unumsys_isAlgorithmic(unumsys: *const UNumberingSystem) -> i8 {
22378     #[cfg(windows)]
22379     {
22380         #[link(name = "windows")]
22381         extern "system" {
22382             fn unumsys_isAlgorithmic(unumsys: *const UNumberingSystem) -> i8;
22383         }
22384         ::std::mem::transmute(unumsys_isAlgorithmic(::std::mem::transmute(unumsys)))
22385     }
22386     #[cfg(not(windows))]
22387     unimplemented!("Unsupported target OS");
22388 }
22389 #[cfg(feature = "Win32_Foundation")]
22390 #[inline]
unumsys_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UNumberingSystem22391 pub unsafe fn unumsys_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UNumberingSystem {
22392     #[cfg(windows)]
22393     {
22394         #[link(name = "windows")]
22395         extern "system" {
22396             fn unumsys_open(locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UNumberingSystem;
22397         }
22398         ::std::mem::transmute(unumsys_open(locale.into_param().abi(), ::std::mem::transmute(status)))
22399     }
22400     #[cfg(not(windows))]
22401     unimplemented!("Unsupported target OS");
22402 }
22403 #[inline]
unumsys_openAvailableNames(status: *mut UErrorCode) -> *mut UEnumeration22404 pub unsafe fn unumsys_openAvailableNames(status: *mut UErrorCode) -> *mut UEnumeration {
22405     #[cfg(windows)]
22406     {
22407         #[link(name = "windows")]
22408         extern "system" {
22409             fn unumsys_openAvailableNames(status: *mut UErrorCode) -> *mut UEnumeration;
22410         }
22411         ::std::mem::transmute(unumsys_openAvailableNames(::std::mem::transmute(status)))
22412     }
22413     #[cfg(not(windows))]
22414     unimplemented!("Unsupported target OS");
22415 }
22416 #[cfg(feature = "Win32_Foundation")]
22417 #[inline]
unumsys_openByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, status: *mut UErrorCode) -> *mut UNumberingSystem22418 pub unsafe fn unumsys_openByName<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(name: Param0, status: *mut UErrorCode) -> *mut UNumberingSystem {
22419     #[cfg(windows)]
22420     {
22421         #[link(name = "windows")]
22422         extern "system" {
22423             fn unumsys_openByName(name: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UNumberingSystem;
22424         }
22425         ::std::mem::transmute(unumsys_openByName(name.into_param().abi(), ::std::mem::transmute(status)))
22426     }
22427     #[cfg(not(windows))]
22428     unimplemented!("Unsupported target OS");
22429 }
22430 #[inline]
uplrules_close(uplrules: *mut UPluralRules)22431 pub unsafe fn uplrules_close(uplrules: *mut UPluralRules) {
22432     #[cfg(windows)]
22433     {
22434         #[link(name = "windows")]
22435         extern "system" {
22436             fn uplrules_close(uplrules: *mut UPluralRules);
22437         }
22438         ::std::mem::transmute(uplrules_close(::std::mem::transmute(uplrules)))
22439     }
22440     #[cfg(not(windows))]
22441     unimplemented!("Unsupported target OS");
22442 }
22443 #[inline]
uplrules_getKeywords(uplrules: *const UPluralRules, status: *mut UErrorCode) -> *mut UEnumeration22444 pub unsafe fn uplrules_getKeywords(uplrules: *const UPluralRules, status: *mut UErrorCode) -> *mut UEnumeration {
22445     #[cfg(windows)]
22446     {
22447         #[link(name = "windows")]
22448         extern "system" {
22449             fn uplrules_getKeywords(uplrules: *const UPluralRules, status: *mut UErrorCode) -> *mut UEnumeration;
22450         }
22451         ::std::mem::transmute(uplrules_getKeywords(::std::mem::transmute(uplrules), ::std::mem::transmute(status)))
22452     }
22453     #[cfg(not(windows))]
22454     unimplemented!("Unsupported target OS");
22455 }
22456 #[cfg(feature = "Win32_Foundation")]
22457 #[inline]
uplrules_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UPluralRules22458 pub unsafe fn uplrules_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, status: *mut UErrorCode) -> *mut UPluralRules {
22459     #[cfg(windows)]
22460     {
22461         #[link(name = "windows")]
22462         extern "system" {
22463             fn uplrules_open(locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UPluralRules;
22464         }
22465         ::std::mem::transmute(uplrules_open(locale.into_param().abi(), ::std::mem::transmute(status)))
22466     }
22467     #[cfg(not(windows))]
22468     unimplemented!("Unsupported target OS");
22469 }
22470 #[cfg(feature = "Win32_Foundation")]
22471 #[inline]
uplrules_openForType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, r#type: UPluralType, status: *mut UErrorCode) -> *mut UPluralRules22472 pub unsafe fn uplrules_openForType<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, r#type: UPluralType, status: *mut UErrorCode) -> *mut UPluralRules {
22473     #[cfg(windows)]
22474     {
22475         #[link(name = "windows")]
22476         extern "system" {
22477             fn uplrules_openForType(locale: super::Foundation::PSTR, r#type: UPluralType, status: *mut UErrorCode) -> *mut UPluralRules;
22478         }
22479         ::std::mem::transmute(uplrules_openForType(locale.into_param().abi(), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
22480     }
22481     #[cfg(not(windows))]
22482     unimplemented!("Unsupported target OS");
22483 }
22484 #[inline]
uplrules_select(uplrules: *const UPluralRules, number: f64, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i3222485 pub unsafe fn uplrules_select(uplrules: *const UPluralRules, number: f64, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i32 {
22486     #[cfg(windows)]
22487     {
22488         #[link(name = "windows")]
22489         extern "system" {
22490             fn uplrules_select(uplrules: *const UPluralRules, number: f64, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i32;
22491         }
22492         ::std::mem::transmute(uplrules_select(::std::mem::transmute(uplrules), ::std::mem::transmute(number), ::std::mem::transmute(keyword), ::std::mem::transmute(capacity), ::std::mem::transmute(status)))
22493     }
22494     #[cfg(not(windows))]
22495     unimplemented!("Unsupported target OS");
22496 }
22497 #[inline]
uplrules_selectFormatted(uplrules: *const UPluralRules, number: *const UFormattedNumber, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i3222498 pub unsafe fn uplrules_selectFormatted(uplrules: *const UPluralRules, number: *const UFormattedNumber, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i32 {
22499     #[cfg(windows)]
22500     {
22501         #[link(name = "windows")]
22502         extern "system" {
22503             fn uplrules_selectFormatted(uplrules: *const UPluralRules, number: *const UFormattedNumber, keyword: *mut u16, capacity: i32, status: *mut UErrorCode) -> i32;
22504         }
22505         ::std::mem::transmute(uplrules_selectFormatted(::std::mem::transmute(uplrules), ::std::mem::transmute(number), ::std::mem::transmute(keyword), ::std::mem::transmute(capacity), ::std::mem::transmute(status)))
22506     }
22507     #[cfg(not(windows))]
22508     unimplemented!("Unsupported target OS");
22509 }
22510 #[inline]
uregex_appendReplacement(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i3222511 pub unsafe fn uregex_appendReplacement(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i32 {
22512     #[cfg(windows)]
22513     {
22514         #[link(name = "windows")]
22515         extern "system" {
22516             fn uregex_appendReplacement(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i32;
22517         }
22518         ::std::mem::transmute(uregex_appendReplacement(::std::mem::transmute(regexp), ::std::mem::transmute(replacementtext), ::std::mem::transmute(replacementlength), ::std::mem::transmute(destbuf), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
22519     }
22520     #[cfg(not(windows))]
22521     unimplemented!("Unsupported target OS");
22522 }
22523 #[inline]
uregex_appendReplacementUText(regexp: *mut URegularExpression, replacementtext: *mut UText, dest: *mut UText, status: *mut UErrorCode)22524 pub unsafe fn uregex_appendReplacementUText(regexp: *mut URegularExpression, replacementtext: *mut UText, dest: *mut UText, status: *mut UErrorCode) {
22525     #[cfg(windows)]
22526     {
22527         #[link(name = "windows")]
22528         extern "system" {
22529             fn uregex_appendReplacementUText(regexp: *mut URegularExpression, replacementtext: *mut UText, dest: *mut UText, status: *mut UErrorCode);
22530         }
22531         ::std::mem::transmute(uregex_appendReplacementUText(::std::mem::transmute(regexp), ::std::mem::transmute(replacementtext), ::std::mem::transmute(dest), ::std::mem::transmute(status)))
22532     }
22533     #[cfg(not(windows))]
22534     unimplemented!("Unsupported target OS");
22535 }
22536 #[inline]
uregex_appendTail(regexp: *mut URegularExpression, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i3222537 pub unsafe fn uregex_appendTail(regexp: *mut URegularExpression, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i32 {
22538     #[cfg(windows)]
22539     {
22540         #[link(name = "windows")]
22541         extern "system" {
22542             fn uregex_appendTail(regexp: *mut URegularExpression, destbuf: *mut *mut u16, destcapacity: *mut i32, status: *mut UErrorCode) -> i32;
22543         }
22544         ::std::mem::transmute(uregex_appendTail(::std::mem::transmute(regexp), ::std::mem::transmute(destbuf), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
22545     }
22546     #[cfg(not(windows))]
22547     unimplemented!("Unsupported target OS");
22548 }
22549 #[inline]
uregex_appendTailUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText22550 pub unsafe fn uregex_appendTailUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText {
22551     #[cfg(windows)]
22552     {
22553         #[link(name = "windows")]
22554         extern "system" {
22555             fn uregex_appendTailUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText;
22556         }
22557         ::std::mem::transmute(uregex_appendTailUText(::std::mem::transmute(regexp), ::std::mem::transmute(dest), ::std::mem::transmute(status)))
22558     }
22559     #[cfg(not(windows))]
22560     unimplemented!("Unsupported target OS");
22561 }
22562 #[inline]
uregex_clone(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut URegularExpression22563 pub unsafe fn uregex_clone(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut URegularExpression {
22564     #[cfg(windows)]
22565     {
22566         #[link(name = "windows")]
22567         extern "system" {
22568             fn uregex_clone(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut URegularExpression;
22569         }
22570         ::std::mem::transmute(uregex_clone(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22571     }
22572     #[cfg(not(windows))]
22573     unimplemented!("Unsupported target OS");
22574 }
22575 #[inline]
uregex_close(regexp: *mut URegularExpression)22576 pub unsafe fn uregex_close(regexp: *mut URegularExpression) {
22577     #[cfg(windows)]
22578     {
22579         #[link(name = "windows")]
22580         extern "system" {
22581             fn uregex_close(regexp: *mut URegularExpression);
22582         }
22583         ::std::mem::transmute(uregex_close(::std::mem::transmute(regexp)))
22584     }
22585     #[cfg(not(windows))]
22586     unimplemented!("Unsupported target OS");
22587 }
22588 #[inline]
uregex_end(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i3222589 pub unsafe fn uregex_end(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i32 {
22590     #[cfg(windows)]
22591     {
22592         #[link(name = "windows")]
22593         extern "system" {
22594             fn uregex_end(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i32;
22595         }
22596         ::std::mem::transmute(uregex_end(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(status)))
22597     }
22598     #[cfg(not(windows))]
22599     unimplemented!("Unsupported target OS");
22600 }
22601 #[inline]
uregex_end64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i6422602 pub unsafe fn uregex_end64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i64 {
22603     #[cfg(windows)]
22604     {
22605         #[link(name = "windows")]
22606         extern "system" {
22607             fn uregex_end64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i64;
22608         }
22609         ::std::mem::transmute(uregex_end64(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(status)))
22610     }
22611     #[cfg(not(windows))]
22612     unimplemented!("Unsupported target OS");
22613 }
22614 #[inline]
uregex_find(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i822615 pub unsafe fn uregex_find(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8 {
22616     #[cfg(windows)]
22617     {
22618         #[link(name = "windows")]
22619         extern "system" {
22620             fn uregex_find(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8;
22621         }
22622         ::std::mem::transmute(uregex_find(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22623     }
22624     #[cfg(not(windows))]
22625     unimplemented!("Unsupported target OS");
22626 }
22627 #[inline]
uregex_find64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i822628 pub unsafe fn uregex_find64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8 {
22629     #[cfg(windows)]
22630     {
22631         #[link(name = "windows")]
22632         extern "system" {
22633             fn uregex_find64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8;
22634         }
22635         ::std::mem::transmute(uregex_find64(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22636     }
22637     #[cfg(not(windows))]
22638     unimplemented!("Unsupported target OS");
22639 }
22640 #[inline]
uregex_findNext(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i822641 pub unsafe fn uregex_findNext(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i8 {
22642     #[cfg(windows)]
22643     {
22644         #[link(name = "windows")]
22645         extern "system" {
22646             fn uregex_findNext(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i8;
22647         }
22648         ::std::mem::transmute(uregex_findNext(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22649     }
22650     #[cfg(not(windows))]
22651     unimplemented!("Unsupported target OS");
22652 }
22653 #[inline]
uregex_flags(regexp: *const URegularExpression, status: *mut UErrorCode) -> i3222654 pub unsafe fn uregex_flags(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32 {
22655     #[cfg(windows)]
22656     {
22657         #[link(name = "windows")]
22658         extern "system" {
22659             fn uregex_flags(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32;
22660         }
22661         ::std::mem::transmute(uregex_flags(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22662     }
22663     #[cfg(not(windows))]
22664     unimplemented!("Unsupported target OS");
22665 }
22666 #[inline]
uregex_getFindProgressCallback(regexp: *const URegularExpression, callback: *mut ::std::option::Option<URegexFindProgressCallback>, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode)22667 pub unsafe fn uregex_getFindProgressCallback(regexp: *const URegularExpression, callback: *mut ::std::option::Option<URegexFindProgressCallback>, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode) {
22668     #[cfg(windows)]
22669     {
22670         #[link(name = "windows")]
22671         extern "system" {
22672             fn uregex_getFindProgressCallback(regexp: *const URegularExpression, callback: *mut ::windows::runtime::RawPtr, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode);
22673         }
22674         ::std::mem::transmute(uregex_getFindProgressCallback(::std::mem::transmute(regexp), ::std::mem::transmute(callback), ::std::mem::transmute(context), ::std::mem::transmute(status)))
22675     }
22676     #[cfg(not(windows))]
22677     unimplemented!("Unsupported target OS");
22678 }
22679 #[inline]
uregex_getMatchCallback(regexp: *const URegularExpression, callback: *mut ::std::option::Option<URegexMatchCallback>, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode)22680 pub unsafe fn uregex_getMatchCallback(regexp: *const URegularExpression, callback: *mut ::std::option::Option<URegexMatchCallback>, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode) {
22681     #[cfg(windows)]
22682     {
22683         #[link(name = "windows")]
22684         extern "system" {
22685             fn uregex_getMatchCallback(regexp: *const URegularExpression, callback: *mut ::windows::runtime::RawPtr, context: *const *const ::std::ffi::c_void, status: *mut UErrorCode);
22686         }
22687         ::std::mem::transmute(uregex_getMatchCallback(::std::mem::transmute(regexp), ::std::mem::transmute(callback), ::std::mem::transmute(context), ::std::mem::transmute(status)))
22688     }
22689     #[cfg(not(windows))]
22690     unimplemented!("Unsupported target OS");
22691 }
22692 #[inline]
uregex_getStackLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i3222693 pub unsafe fn uregex_getStackLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32 {
22694     #[cfg(windows)]
22695     {
22696         #[link(name = "windows")]
22697         extern "system" {
22698             fn uregex_getStackLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32;
22699         }
22700         ::std::mem::transmute(uregex_getStackLimit(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22701     }
22702     #[cfg(not(windows))]
22703     unimplemented!("Unsupported target OS");
22704 }
22705 #[inline]
uregex_getText(regexp: *mut URegularExpression, textlength: *mut i32, status: *mut UErrorCode) -> *mut u1622706 pub unsafe fn uregex_getText(regexp: *mut URegularExpression, textlength: *mut i32, status: *mut UErrorCode) -> *mut u16 {
22707     #[cfg(windows)]
22708     {
22709         #[link(name = "windows")]
22710         extern "system" {
22711             fn uregex_getText(regexp: *mut URegularExpression, textlength: *mut i32, status: *mut UErrorCode) -> *mut u16;
22712         }
22713         ::std::mem::transmute(uregex_getText(::std::mem::transmute(regexp), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
22714     }
22715     #[cfg(not(windows))]
22716     unimplemented!("Unsupported target OS");
22717 }
22718 #[inline]
uregex_getTimeLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i3222719 pub unsafe fn uregex_getTimeLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32 {
22720     #[cfg(windows)]
22721     {
22722         #[link(name = "windows")]
22723         extern "system" {
22724             fn uregex_getTimeLimit(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32;
22725         }
22726         ::std::mem::transmute(uregex_getTimeLimit(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22727     }
22728     #[cfg(not(windows))]
22729     unimplemented!("Unsupported target OS");
22730 }
22731 #[inline]
uregex_getUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText22732 pub unsafe fn uregex_getUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText {
22733     #[cfg(windows)]
22734     {
22735         #[link(name = "windows")]
22736         extern "system" {
22737             fn uregex_getUText(regexp: *mut URegularExpression, dest: *mut UText, status: *mut UErrorCode) -> *mut UText;
22738         }
22739         ::std::mem::transmute(uregex_getUText(::std::mem::transmute(regexp), ::std::mem::transmute(dest), ::std::mem::transmute(status)))
22740     }
22741     #[cfg(not(windows))]
22742     unimplemented!("Unsupported target OS");
22743 }
22744 #[inline]
uregex_group(regexp: *mut URegularExpression, groupnum: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3222745 pub unsafe fn uregex_group(regexp: *mut URegularExpression, groupnum: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
22746     #[cfg(windows)]
22747     {
22748         #[link(name = "windows")]
22749         extern "system" {
22750             fn uregex_group(regexp: *mut URegularExpression, groupnum: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
22751         }
22752         ::std::mem::transmute(uregex_group(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
22753     }
22754     #[cfg(not(windows))]
22755     unimplemented!("Unsupported target OS");
22756 }
22757 #[inline]
uregex_groupCount(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i3222758 pub unsafe fn uregex_groupCount(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i32 {
22759     #[cfg(windows)]
22760     {
22761         #[link(name = "windows")]
22762         extern "system" {
22763             fn uregex_groupCount(regexp: *mut URegularExpression, status: *mut UErrorCode) -> i32;
22764         }
22765         ::std::mem::transmute(uregex_groupCount(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22766     }
22767     #[cfg(not(windows))]
22768     unimplemented!("Unsupported target OS");
22769 }
22770 #[cfg(feature = "Win32_Foundation")]
22771 #[inline]
uregex_groupNumberFromCName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(regexp: *mut URegularExpression, groupname: Param1, namelength: i32, status: *mut UErrorCode) -> i3222772 pub unsafe fn uregex_groupNumberFromCName<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(regexp: *mut URegularExpression, groupname: Param1, namelength: i32, status: *mut UErrorCode) -> i32 {
22773     #[cfg(windows)]
22774     {
22775         #[link(name = "windows")]
22776         extern "system" {
22777             fn uregex_groupNumberFromCName(regexp: *mut URegularExpression, groupname: super::Foundation::PSTR, namelength: i32, status: *mut UErrorCode) -> i32;
22778         }
22779         ::std::mem::transmute(uregex_groupNumberFromCName(::std::mem::transmute(regexp), groupname.into_param().abi(), ::std::mem::transmute(namelength), ::std::mem::transmute(status)))
22780     }
22781     #[cfg(not(windows))]
22782     unimplemented!("Unsupported target OS");
22783 }
22784 #[inline]
uregex_groupNumberFromName(regexp: *mut URegularExpression, groupname: *const u16, namelength: i32, status: *mut UErrorCode) -> i3222785 pub unsafe fn uregex_groupNumberFromName(regexp: *mut URegularExpression, groupname: *const u16, namelength: i32, status: *mut UErrorCode) -> i32 {
22786     #[cfg(windows)]
22787     {
22788         #[link(name = "windows")]
22789         extern "system" {
22790             fn uregex_groupNumberFromName(regexp: *mut URegularExpression, groupname: *const u16, namelength: i32, status: *mut UErrorCode) -> i32;
22791         }
22792         ::std::mem::transmute(uregex_groupNumberFromName(::std::mem::transmute(regexp), ::std::mem::transmute(groupname), ::std::mem::transmute(namelength), ::std::mem::transmute(status)))
22793     }
22794     #[cfg(not(windows))]
22795     unimplemented!("Unsupported target OS");
22796 }
22797 #[inline]
uregex_groupUText(regexp: *mut URegularExpression, groupnum: i32, dest: *mut UText, grouplength: *mut i64, status: *mut UErrorCode) -> *mut UText22798 pub unsafe fn uregex_groupUText(regexp: *mut URegularExpression, groupnum: i32, dest: *mut UText, grouplength: *mut i64, status: *mut UErrorCode) -> *mut UText {
22799     #[cfg(windows)]
22800     {
22801         #[link(name = "windows")]
22802         extern "system" {
22803             fn uregex_groupUText(regexp: *mut URegularExpression, groupnum: i32, dest: *mut UText, grouplength: *mut i64, status: *mut UErrorCode) -> *mut UText;
22804         }
22805         ::std::mem::transmute(uregex_groupUText(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(dest), ::std::mem::transmute(grouplength), ::std::mem::transmute(status)))
22806     }
22807     #[cfg(not(windows))]
22808     unimplemented!("Unsupported target OS");
22809 }
22810 #[inline]
uregex_hasAnchoringBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i822811 pub unsafe fn uregex_hasAnchoringBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8 {
22812     #[cfg(windows)]
22813     {
22814         #[link(name = "windows")]
22815         extern "system" {
22816             fn uregex_hasAnchoringBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8;
22817         }
22818         ::std::mem::transmute(uregex_hasAnchoringBounds(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22819     }
22820     #[cfg(not(windows))]
22821     unimplemented!("Unsupported target OS");
22822 }
22823 #[inline]
uregex_hasTransparentBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i822824 pub unsafe fn uregex_hasTransparentBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8 {
22825     #[cfg(windows)]
22826     {
22827         #[link(name = "windows")]
22828         extern "system" {
22829             fn uregex_hasTransparentBounds(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8;
22830         }
22831         ::std::mem::transmute(uregex_hasTransparentBounds(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22832     }
22833     #[cfg(not(windows))]
22834     unimplemented!("Unsupported target OS");
22835 }
22836 #[inline]
uregex_hitEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i822837 pub unsafe fn uregex_hitEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8 {
22838     #[cfg(windows)]
22839     {
22840         #[link(name = "windows")]
22841         extern "system" {
22842             fn uregex_hitEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8;
22843         }
22844         ::std::mem::transmute(uregex_hitEnd(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22845     }
22846     #[cfg(not(windows))]
22847     unimplemented!("Unsupported target OS");
22848 }
22849 #[inline]
uregex_lookingAt(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i822850 pub unsafe fn uregex_lookingAt(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8 {
22851     #[cfg(windows)]
22852     {
22853         #[link(name = "windows")]
22854         extern "system" {
22855             fn uregex_lookingAt(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8;
22856         }
22857         ::std::mem::transmute(uregex_lookingAt(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22858     }
22859     #[cfg(not(windows))]
22860     unimplemented!("Unsupported target OS");
22861 }
22862 #[inline]
uregex_lookingAt64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i822863 pub unsafe fn uregex_lookingAt64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8 {
22864     #[cfg(windows)]
22865     {
22866         #[link(name = "windows")]
22867         extern "system" {
22868             fn uregex_lookingAt64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8;
22869         }
22870         ::std::mem::transmute(uregex_lookingAt64(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22871     }
22872     #[cfg(not(windows))]
22873     unimplemented!("Unsupported target OS");
22874 }
22875 #[inline]
uregex_matches(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i822876 pub unsafe fn uregex_matches(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8 {
22877     #[cfg(windows)]
22878     {
22879         #[link(name = "windows")]
22880         extern "system" {
22881             fn uregex_matches(regexp: *mut URegularExpression, startindex: i32, status: *mut UErrorCode) -> i8;
22882         }
22883         ::std::mem::transmute(uregex_matches(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22884     }
22885     #[cfg(not(windows))]
22886     unimplemented!("Unsupported target OS");
22887 }
22888 #[inline]
uregex_matches64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i822889 pub unsafe fn uregex_matches64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8 {
22890     #[cfg(windows)]
22891     {
22892         #[link(name = "windows")]
22893         extern "system" {
22894             fn uregex_matches64(regexp: *mut URegularExpression, startindex: i64, status: *mut UErrorCode) -> i8;
22895         }
22896         ::std::mem::transmute(uregex_matches64(::std::mem::transmute(regexp), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
22897     }
22898     #[cfg(not(windows))]
22899     unimplemented!("Unsupported target OS");
22900 }
22901 #[inline]
uregex_open(pattern: *const u16, patternlength: i32, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression22902 pub unsafe fn uregex_open(pattern: *const u16, patternlength: i32, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression {
22903     #[cfg(windows)]
22904     {
22905         #[link(name = "windows")]
22906         extern "system" {
22907             fn uregex_open(pattern: *const u16, patternlength: i32, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression;
22908         }
22909         ::std::mem::transmute(uregex_open(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(flags), ::std::mem::transmute(pe), ::std::mem::transmute(status)))
22910     }
22911     #[cfg(not(windows))]
22912     unimplemented!("Unsupported target OS");
22913 }
22914 #[cfg(feature = "Win32_Foundation")]
22915 #[inline]
uregex_openC<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: Param0, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression22916 pub unsafe fn uregex_openC<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: Param0, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression {
22917     #[cfg(windows)]
22918     {
22919         #[link(name = "windows")]
22920         extern "system" {
22921             fn uregex_openC(pattern: super::Foundation::PSTR, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression;
22922         }
22923         ::std::mem::transmute(uregex_openC(pattern.into_param().abi(), ::std::mem::transmute(flags), ::std::mem::transmute(pe), ::std::mem::transmute(status)))
22924     }
22925     #[cfg(not(windows))]
22926     unimplemented!("Unsupported target OS");
22927 }
22928 #[inline]
uregex_openUText(pattern: *mut UText, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression22929 pub unsafe fn uregex_openUText(pattern: *mut UText, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression {
22930     #[cfg(windows)]
22931     {
22932         #[link(name = "windows")]
22933         extern "system" {
22934             fn uregex_openUText(pattern: *mut UText, flags: u32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut URegularExpression;
22935         }
22936         ::std::mem::transmute(uregex_openUText(::std::mem::transmute(pattern), ::std::mem::transmute(flags), ::std::mem::transmute(pe), ::std::mem::transmute(status)))
22937     }
22938     #[cfg(not(windows))]
22939     unimplemented!("Unsupported target OS");
22940 }
22941 #[inline]
uregex_pattern(regexp: *const URegularExpression, patlength: *mut i32, status: *mut UErrorCode) -> *mut u1622942 pub unsafe fn uregex_pattern(regexp: *const URegularExpression, patlength: *mut i32, status: *mut UErrorCode) -> *mut u16 {
22943     #[cfg(windows)]
22944     {
22945         #[link(name = "windows")]
22946         extern "system" {
22947             fn uregex_pattern(regexp: *const URegularExpression, patlength: *mut i32, status: *mut UErrorCode) -> *mut u16;
22948         }
22949         ::std::mem::transmute(uregex_pattern(::std::mem::transmute(regexp), ::std::mem::transmute(patlength), ::std::mem::transmute(status)))
22950     }
22951     #[cfg(not(windows))]
22952     unimplemented!("Unsupported target OS");
22953 }
22954 #[inline]
uregex_patternUText(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut UText22955 pub unsafe fn uregex_patternUText(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut UText {
22956     #[cfg(windows)]
22957     {
22958         #[link(name = "windows")]
22959         extern "system" {
22960             fn uregex_patternUText(regexp: *const URegularExpression, status: *mut UErrorCode) -> *mut UText;
22961         }
22962         ::std::mem::transmute(uregex_patternUText(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22963     }
22964     #[cfg(not(windows))]
22965     unimplemented!("Unsupported target OS");
22966 }
22967 #[inline]
uregex_refreshUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode)22968 pub unsafe fn uregex_refreshUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode) {
22969     #[cfg(windows)]
22970     {
22971         #[link(name = "windows")]
22972         extern "system" {
22973             fn uregex_refreshUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode);
22974         }
22975         ::std::mem::transmute(uregex_refreshUText(::std::mem::transmute(regexp), ::std::mem::transmute(text), ::std::mem::transmute(status)))
22976     }
22977     #[cfg(not(windows))]
22978     unimplemented!("Unsupported target OS");
22979 }
22980 #[inline]
uregex_regionEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i3222981 pub unsafe fn uregex_regionEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32 {
22982     #[cfg(windows)]
22983     {
22984         #[link(name = "windows")]
22985         extern "system" {
22986             fn uregex_regionEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32;
22987         }
22988         ::std::mem::transmute(uregex_regionEnd(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
22989     }
22990     #[cfg(not(windows))]
22991     unimplemented!("Unsupported target OS");
22992 }
22993 #[inline]
uregex_regionEnd64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i6422994 pub unsafe fn uregex_regionEnd64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i64 {
22995     #[cfg(windows)]
22996     {
22997         #[link(name = "windows")]
22998         extern "system" {
22999             fn uregex_regionEnd64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i64;
23000         }
23001         ::std::mem::transmute(uregex_regionEnd64(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
23002     }
23003     #[cfg(not(windows))]
23004     unimplemented!("Unsupported target OS");
23005 }
23006 #[inline]
uregex_regionStart(regexp: *const URegularExpression, status: *mut UErrorCode) -> i3223007 pub unsafe fn uregex_regionStart(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32 {
23008     #[cfg(windows)]
23009     {
23010         #[link(name = "windows")]
23011         extern "system" {
23012             fn uregex_regionStart(regexp: *const URegularExpression, status: *mut UErrorCode) -> i32;
23013         }
23014         ::std::mem::transmute(uregex_regionStart(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
23015     }
23016     #[cfg(not(windows))]
23017     unimplemented!("Unsupported target OS");
23018 }
23019 #[inline]
uregex_regionStart64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i6423020 pub unsafe fn uregex_regionStart64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i64 {
23021     #[cfg(windows)]
23022     {
23023         #[link(name = "windows")]
23024         extern "system" {
23025             fn uregex_regionStart64(regexp: *const URegularExpression, status: *mut UErrorCode) -> i64;
23026         }
23027         ::std::mem::transmute(uregex_regionStart64(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
23028     }
23029     #[cfg(not(windows))]
23030     unimplemented!("Unsupported target OS");
23031 }
23032 #[inline]
uregex_replaceAll(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3223033 pub unsafe fn uregex_replaceAll(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
23034     #[cfg(windows)]
23035     {
23036         #[link(name = "windows")]
23037         extern "system" {
23038             fn uregex_replaceAll(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
23039         }
23040         ::std::mem::transmute(uregex_replaceAll(::std::mem::transmute(regexp), ::std::mem::transmute(replacementtext), ::std::mem::transmute(replacementlength), ::std::mem::transmute(destbuf), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
23041     }
23042     #[cfg(not(windows))]
23043     unimplemented!("Unsupported target OS");
23044 }
23045 #[inline]
uregex_replaceAllUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText23046 pub unsafe fn uregex_replaceAllUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText {
23047     #[cfg(windows)]
23048     {
23049         #[link(name = "windows")]
23050         extern "system" {
23051             fn uregex_replaceAllUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText;
23052         }
23053         ::std::mem::transmute(uregex_replaceAllUText(::std::mem::transmute(regexp), ::std::mem::transmute(replacement), ::std::mem::transmute(dest), ::std::mem::transmute(status)))
23054     }
23055     #[cfg(not(windows))]
23056     unimplemented!("Unsupported target OS");
23057 }
23058 #[inline]
uregex_replaceFirst(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3223059 pub unsafe fn uregex_replaceFirst(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
23060     #[cfg(windows)]
23061     {
23062         #[link(name = "windows")]
23063         extern "system" {
23064             fn uregex_replaceFirst(regexp: *mut URegularExpression, replacementtext: *const u16, replacementlength: i32, destbuf: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
23065         }
23066         ::std::mem::transmute(uregex_replaceFirst(::std::mem::transmute(regexp), ::std::mem::transmute(replacementtext), ::std::mem::transmute(replacementlength), ::std::mem::transmute(destbuf), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
23067     }
23068     #[cfg(not(windows))]
23069     unimplemented!("Unsupported target OS");
23070 }
23071 #[inline]
uregex_replaceFirstUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText23072 pub unsafe fn uregex_replaceFirstUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText {
23073     #[cfg(windows)]
23074     {
23075         #[link(name = "windows")]
23076         extern "system" {
23077             fn uregex_replaceFirstUText(regexp: *mut URegularExpression, replacement: *mut UText, dest: *mut UText, status: *mut UErrorCode) -> *mut UText;
23078         }
23079         ::std::mem::transmute(uregex_replaceFirstUText(::std::mem::transmute(regexp), ::std::mem::transmute(replacement), ::std::mem::transmute(dest), ::std::mem::transmute(status)))
23080     }
23081     #[cfg(not(windows))]
23082     unimplemented!("Unsupported target OS");
23083 }
23084 #[inline]
uregex_requireEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i823085 pub unsafe fn uregex_requireEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8 {
23086     #[cfg(windows)]
23087     {
23088         #[link(name = "windows")]
23089         extern "system" {
23090             fn uregex_requireEnd(regexp: *const URegularExpression, status: *mut UErrorCode) -> i8;
23091         }
23092         ::std::mem::transmute(uregex_requireEnd(::std::mem::transmute(regexp), ::std::mem::transmute(status)))
23093     }
23094     #[cfg(not(windows))]
23095     unimplemented!("Unsupported target OS");
23096 }
23097 #[inline]
uregex_reset(regexp: *mut URegularExpression, index: i32, status: *mut UErrorCode)23098 pub unsafe fn uregex_reset(regexp: *mut URegularExpression, index: i32, status: *mut UErrorCode) {
23099     #[cfg(windows)]
23100     {
23101         #[link(name = "windows")]
23102         extern "system" {
23103             fn uregex_reset(regexp: *mut URegularExpression, index: i32, status: *mut UErrorCode);
23104         }
23105         ::std::mem::transmute(uregex_reset(::std::mem::transmute(regexp), ::std::mem::transmute(index), ::std::mem::transmute(status)))
23106     }
23107     #[cfg(not(windows))]
23108     unimplemented!("Unsupported target OS");
23109 }
23110 #[inline]
uregex_reset64(regexp: *mut URegularExpression, index: i64, status: *mut UErrorCode)23111 pub unsafe fn uregex_reset64(regexp: *mut URegularExpression, index: i64, status: *mut UErrorCode) {
23112     #[cfg(windows)]
23113     {
23114         #[link(name = "windows")]
23115         extern "system" {
23116             fn uregex_reset64(regexp: *mut URegularExpression, index: i64, status: *mut UErrorCode);
23117         }
23118         ::std::mem::transmute(uregex_reset64(::std::mem::transmute(regexp), ::std::mem::transmute(index), ::std::mem::transmute(status)))
23119     }
23120     #[cfg(not(windows))]
23121     unimplemented!("Unsupported target OS");
23122 }
23123 #[inline]
uregex_setFindProgressCallback(regexp: *mut URegularExpression, callback: ::std::option::Option<URegexFindProgressCallback>, context: *const ::std::ffi::c_void, status: *mut UErrorCode)23124 pub unsafe fn uregex_setFindProgressCallback(regexp: *mut URegularExpression, callback: ::std::option::Option<URegexFindProgressCallback>, context: *const ::std::ffi::c_void, status: *mut UErrorCode) {
23125     #[cfg(windows)]
23126     {
23127         #[link(name = "windows")]
23128         extern "system" {
23129             fn uregex_setFindProgressCallback(regexp: *mut URegularExpression, callback: ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void, status: *mut UErrorCode);
23130         }
23131         ::std::mem::transmute(uregex_setFindProgressCallback(::std::mem::transmute(regexp), ::std::mem::transmute(callback), ::std::mem::transmute(context), ::std::mem::transmute(status)))
23132     }
23133     #[cfg(not(windows))]
23134     unimplemented!("Unsupported target OS");
23135 }
23136 #[inline]
uregex_setMatchCallback(regexp: *mut URegularExpression, callback: ::std::option::Option<URegexMatchCallback>, context: *const ::std::ffi::c_void, status: *mut UErrorCode)23137 pub unsafe fn uregex_setMatchCallback(regexp: *mut URegularExpression, callback: ::std::option::Option<URegexMatchCallback>, context: *const ::std::ffi::c_void, status: *mut UErrorCode) {
23138     #[cfg(windows)]
23139     {
23140         #[link(name = "windows")]
23141         extern "system" {
23142             fn uregex_setMatchCallback(regexp: *mut URegularExpression, callback: ::windows::runtime::RawPtr, context: *const ::std::ffi::c_void, status: *mut UErrorCode);
23143         }
23144         ::std::mem::transmute(uregex_setMatchCallback(::std::mem::transmute(regexp), ::std::mem::transmute(callback), ::std::mem::transmute(context), ::std::mem::transmute(status)))
23145     }
23146     #[cfg(not(windows))]
23147     unimplemented!("Unsupported target OS");
23148 }
23149 #[inline]
uregex_setRegion(regexp: *mut URegularExpression, regionstart: i32, regionlimit: i32, status: *mut UErrorCode)23150 pub unsafe fn uregex_setRegion(regexp: *mut URegularExpression, regionstart: i32, regionlimit: i32, status: *mut UErrorCode) {
23151     #[cfg(windows)]
23152     {
23153         #[link(name = "windows")]
23154         extern "system" {
23155             fn uregex_setRegion(regexp: *mut URegularExpression, regionstart: i32, regionlimit: i32, status: *mut UErrorCode);
23156         }
23157         ::std::mem::transmute(uregex_setRegion(::std::mem::transmute(regexp), ::std::mem::transmute(regionstart), ::std::mem::transmute(regionlimit), ::std::mem::transmute(status)))
23158     }
23159     #[cfg(not(windows))]
23160     unimplemented!("Unsupported target OS");
23161 }
23162 #[inline]
uregex_setRegion64(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, status: *mut UErrorCode)23163 pub unsafe fn uregex_setRegion64(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, status: *mut UErrorCode) {
23164     #[cfg(windows)]
23165     {
23166         #[link(name = "windows")]
23167         extern "system" {
23168             fn uregex_setRegion64(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, status: *mut UErrorCode);
23169         }
23170         ::std::mem::transmute(uregex_setRegion64(::std::mem::transmute(regexp), ::std::mem::transmute(regionstart), ::std::mem::transmute(regionlimit), ::std::mem::transmute(status)))
23171     }
23172     #[cfg(not(windows))]
23173     unimplemented!("Unsupported target OS");
23174 }
23175 #[inline]
uregex_setRegionAndStart(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, startindex: i64, status: *mut UErrorCode)23176 pub unsafe fn uregex_setRegionAndStart(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, startindex: i64, status: *mut UErrorCode) {
23177     #[cfg(windows)]
23178     {
23179         #[link(name = "windows")]
23180         extern "system" {
23181             fn uregex_setRegionAndStart(regexp: *mut URegularExpression, regionstart: i64, regionlimit: i64, startindex: i64, status: *mut UErrorCode);
23182         }
23183         ::std::mem::transmute(uregex_setRegionAndStart(::std::mem::transmute(regexp), ::std::mem::transmute(regionstart), ::std::mem::transmute(regionlimit), ::std::mem::transmute(startindex), ::std::mem::transmute(status)))
23184     }
23185     #[cfg(not(windows))]
23186     unimplemented!("Unsupported target OS");
23187 }
23188 #[inline]
uregex_setStackLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode)23189 pub unsafe fn uregex_setStackLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode) {
23190     #[cfg(windows)]
23191     {
23192         #[link(name = "windows")]
23193         extern "system" {
23194             fn uregex_setStackLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode);
23195         }
23196         ::std::mem::transmute(uregex_setStackLimit(::std::mem::transmute(regexp), ::std::mem::transmute(limit), ::std::mem::transmute(status)))
23197     }
23198     #[cfg(not(windows))]
23199     unimplemented!("Unsupported target OS");
23200 }
23201 #[inline]
uregex_setText(regexp: *mut URegularExpression, text: *const u16, textlength: i32, status: *mut UErrorCode)23202 pub unsafe fn uregex_setText(regexp: *mut URegularExpression, text: *const u16, textlength: i32, status: *mut UErrorCode) {
23203     #[cfg(windows)]
23204     {
23205         #[link(name = "windows")]
23206         extern "system" {
23207             fn uregex_setText(regexp: *mut URegularExpression, text: *const u16, textlength: i32, status: *mut UErrorCode);
23208         }
23209         ::std::mem::transmute(uregex_setText(::std::mem::transmute(regexp), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
23210     }
23211     #[cfg(not(windows))]
23212     unimplemented!("Unsupported target OS");
23213 }
23214 #[inline]
uregex_setTimeLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode)23215 pub unsafe fn uregex_setTimeLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode) {
23216     #[cfg(windows)]
23217     {
23218         #[link(name = "windows")]
23219         extern "system" {
23220             fn uregex_setTimeLimit(regexp: *mut URegularExpression, limit: i32, status: *mut UErrorCode);
23221         }
23222         ::std::mem::transmute(uregex_setTimeLimit(::std::mem::transmute(regexp), ::std::mem::transmute(limit), ::std::mem::transmute(status)))
23223     }
23224     #[cfg(not(windows))]
23225     unimplemented!("Unsupported target OS");
23226 }
23227 #[inline]
uregex_setUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode)23228 pub unsafe fn uregex_setUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode) {
23229     #[cfg(windows)]
23230     {
23231         #[link(name = "windows")]
23232         extern "system" {
23233             fn uregex_setUText(regexp: *mut URegularExpression, text: *mut UText, status: *mut UErrorCode);
23234         }
23235         ::std::mem::transmute(uregex_setUText(::std::mem::transmute(regexp), ::std::mem::transmute(text), ::std::mem::transmute(status)))
23236     }
23237     #[cfg(not(windows))]
23238     unimplemented!("Unsupported target OS");
23239 }
23240 #[inline]
uregex_split(regexp: *mut URegularExpression, destbuf: *mut u16, destcapacity: i32, requiredcapacity: *mut i32, destfields: *mut *mut u16, destfieldscapacity: i32, status: *mut UErrorCode) -> i3223241 pub unsafe fn uregex_split(regexp: *mut URegularExpression, destbuf: *mut u16, destcapacity: i32, requiredcapacity: *mut i32, destfields: *mut *mut u16, destfieldscapacity: i32, status: *mut UErrorCode) -> i32 {
23242     #[cfg(windows)]
23243     {
23244         #[link(name = "windows")]
23245         extern "system" {
23246             fn uregex_split(regexp: *mut URegularExpression, destbuf: *mut u16, destcapacity: i32, requiredcapacity: *mut i32, destfields: *mut *mut u16, destfieldscapacity: i32, status: *mut UErrorCode) -> i32;
23247         }
23248         ::std::mem::transmute(uregex_split(::std::mem::transmute(regexp), ::std::mem::transmute(destbuf), ::std::mem::transmute(destcapacity), ::std::mem::transmute(requiredcapacity), ::std::mem::transmute(destfields), ::std::mem::transmute(destfieldscapacity), ::std::mem::transmute(status)))
23249     }
23250     #[cfg(not(windows))]
23251     unimplemented!("Unsupported target OS");
23252 }
23253 #[inline]
uregex_splitUText(regexp: *mut URegularExpression, destfields: *mut *mut UText, destfieldscapacity: i32, status: *mut UErrorCode) -> i3223254 pub unsafe fn uregex_splitUText(regexp: *mut URegularExpression, destfields: *mut *mut UText, destfieldscapacity: i32, status: *mut UErrorCode) -> i32 {
23255     #[cfg(windows)]
23256     {
23257         #[link(name = "windows")]
23258         extern "system" {
23259             fn uregex_splitUText(regexp: *mut URegularExpression, destfields: *mut *mut UText, destfieldscapacity: i32, status: *mut UErrorCode) -> i32;
23260         }
23261         ::std::mem::transmute(uregex_splitUText(::std::mem::transmute(regexp), ::std::mem::transmute(destfields), ::std::mem::transmute(destfieldscapacity), ::std::mem::transmute(status)))
23262     }
23263     #[cfg(not(windows))]
23264     unimplemented!("Unsupported target OS");
23265 }
23266 #[inline]
uregex_start(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i3223267 pub unsafe fn uregex_start(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i32 {
23268     #[cfg(windows)]
23269     {
23270         #[link(name = "windows")]
23271         extern "system" {
23272             fn uregex_start(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i32;
23273         }
23274         ::std::mem::transmute(uregex_start(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(status)))
23275     }
23276     #[cfg(not(windows))]
23277     unimplemented!("Unsupported target OS");
23278 }
23279 #[inline]
uregex_start64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i6423280 pub unsafe fn uregex_start64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i64 {
23281     #[cfg(windows)]
23282     {
23283         #[link(name = "windows")]
23284         extern "system" {
23285             fn uregex_start64(regexp: *mut URegularExpression, groupnum: i32, status: *mut UErrorCode) -> i64;
23286         }
23287         ::std::mem::transmute(uregex_start64(::std::mem::transmute(regexp), ::std::mem::transmute(groupnum), ::std::mem::transmute(status)))
23288     }
23289     #[cfg(not(windows))]
23290     unimplemented!("Unsupported target OS");
23291 }
23292 #[inline]
uregex_useAnchoringBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode)23293 pub unsafe fn uregex_useAnchoringBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode) {
23294     #[cfg(windows)]
23295     {
23296         #[link(name = "windows")]
23297         extern "system" {
23298             fn uregex_useAnchoringBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode);
23299         }
23300         ::std::mem::transmute(uregex_useAnchoringBounds(::std::mem::transmute(regexp), ::std::mem::transmute(b), ::std::mem::transmute(status)))
23301     }
23302     #[cfg(not(windows))]
23303     unimplemented!("Unsupported target OS");
23304 }
23305 #[inline]
uregex_useTransparentBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode)23306 pub unsafe fn uregex_useTransparentBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode) {
23307     #[cfg(windows)]
23308     {
23309         #[link(name = "windows")]
23310         extern "system" {
23311             fn uregex_useTransparentBounds(regexp: *mut URegularExpression, b: i8, status: *mut UErrorCode);
23312         }
23313         ::std::mem::transmute(uregex_useTransparentBounds(::std::mem::transmute(regexp), ::std::mem::transmute(b), ::std::mem::transmute(status)))
23314     }
23315     #[cfg(not(windows))]
23316     unimplemented!("Unsupported target OS");
23317 }
23318 #[inline]
uregion_areEqual(uregion: *const URegion, otherregion: *const URegion) -> i823319 pub unsafe fn uregion_areEqual(uregion: *const URegion, otherregion: *const URegion) -> i8 {
23320     #[cfg(windows)]
23321     {
23322         #[link(name = "windows")]
23323         extern "system" {
23324             fn uregion_areEqual(uregion: *const URegion, otherregion: *const URegion) -> i8;
23325         }
23326         ::std::mem::transmute(uregion_areEqual(::std::mem::transmute(uregion), ::std::mem::transmute(otherregion)))
23327     }
23328     #[cfg(not(windows))]
23329     unimplemented!("Unsupported target OS");
23330 }
23331 #[inline]
uregion_contains(uregion: *const URegion, otherregion: *const URegion) -> i823332 pub unsafe fn uregion_contains(uregion: *const URegion, otherregion: *const URegion) -> i8 {
23333     #[cfg(windows)]
23334     {
23335         #[link(name = "windows")]
23336         extern "system" {
23337             fn uregion_contains(uregion: *const URegion, otherregion: *const URegion) -> i8;
23338         }
23339         ::std::mem::transmute(uregion_contains(::std::mem::transmute(uregion), ::std::mem::transmute(otherregion)))
23340     }
23341     #[cfg(not(windows))]
23342     unimplemented!("Unsupported target OS");
23343 }
23344 #[inline]
uregion_getAvailable(r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration23345 pub unsafe fn uregion_getAvailable(r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration {
23346     #[cfg(windows)]
23347     {
23348         #[link(name = "windows")]
23349         extern "system" {
23350             fn uregion_getAvailable(r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration;
23351         }
23352         ::std::mem::transmute(uregion_getAvailable(::std::mem::transmute(r#type), ::std::mem::transmute(status)))
23353     }
23354     #[cfg(not(windows))]
23355     unimplemented!("Unsupported target OS");
23356 }
23357 #[inline]
uregion_getContainedRegions(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration23358 pub unsafe fn uregion_getContainedRegions(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration {
23359     #[cfg(windows)]
23360     {
23361         #[link(name = "windows")]
23362         extern "system" {
23363             fn uregion_getContainedRegions(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration;
23364         }
23365         ::std::mem::transmute(uregion_getContainedRegions(::std::mem::transmute(uregion), ::std::mem::transmute(status)))
23366     }
23367     #[cfg(not(windows))]
23368     unimplemented!("Unsupported target OS");
23369 }
23370 #[inline]
uregion_getContainedRegionsOfType(uregion: *const URegion, r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration23371 pub unsafe fn uregion_getContainedRegionsOfType(uregion: *const URegion, r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration {
23372     #[cfg(windows)]
23373     {
23374         #[link(name = "windows")]
23375         extern "system" {
23376             fn uregion_getContainedRegionsOfType(uregion: *const URegion, r#type: URegionType, status: *mut UErrorCode) -> *mut UEnumeration;
23377         }
23378         ::std::mem::transmute(uregion_getContainedRegionsOfType(::std::mem::transmute(uregion), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
23379     }
23380     #[cfg(not(windows))]
23381     unimplemented!("Unsupported target OS");
23382 }
23383 #[inline]
uregion_getContainingRegion(uregion: *const URegion) -> *mut URegion23384 pub unsafe fn uregion_getContainingRegion(uregion: *const URegion) -> *mut URegion {
23385     #[cfg(windows)]
23386     {
23387         #[link(name = "windows")]
23388         extern "system" {
23389             fn uregion_getContainingRegion(uregion: *const URegion) -> *mut URegion;
23390         }
23391         ::std::mem::transmute(uregion_getContainingRegion(::std::mem::transmute(uregion)))
23392     }
23393     #[cfg(not(windows))]
23394     unimplemented!("Unsupported target OS");
23395 }
23396 #[inline]
uregion_getContainingRegionOfType(uregion: *const URegion, r#type: URegionType) -> *mut URegion23397 pub unsafe fn uregion_getContainingRegionOfType(uregion: *const URegion, r#type: URegionType) -> *mut URegion {
23398     #[cfg(windows)]
23399     {
23400         #[link(name = "windows")]
23401         extern "system" {
23402             fn uregion_getContainingRegionOfType(uregion: *const URegion, r#type: URegionType) -> *mut URegion;
23403         }
23404         ::std::mem::transmute(uregion_getContainingRegionOfType(::std::mem::transmute(uregion), ::std::mem::transmute(r#type)))
23405     }
23406     #[cfg(not(windows))]
23407     unimplemented!("Unsupported target OS");
23408 }
23409 #[inline]
uregion_getNumericCode(uregion: *const URegion) -> i3223410 pub unsafe fn uregion_getNumericCode(uregion: *const URegion) -> i32 {
23411     #[cfg(windows)]
23412     {
23413         #[link(name = "windows")]
23414         extern "system" {
23415             fn uregion_getNumericCode(uregion: *const URegion) -> i32;
23416         }
23417         ::std::mem::transmute(uregion_getNumericCode(::std::mem::transmute(uregion)))
23418     }
23419     #[cfg(not(windows))]
23420     unimplemented!("Unsupported target OS");
23421 }
23422 #[inline]
uregion_getPreferredValues(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration23423 pub unsafe fn uregion_getPreferredValues(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration {
23424     #[cfg(windows)]
23425     {
23426         #[link(name = "windows")]
23427         extern "system" {
23428             fn uregion_getPreferredValues(uregion: *const URegion, status: *mut UErrorCode) -> *mut UEnumeration;
23429         }
23430         ::std::mem::transmute(uregion_getPreferredValues(::std::mem::transmute(uregion), ::std::mem::transmute(status)))
23431     }
23432     #[cfg(not(windows))]
23433     unimplemented!("Unsupported target OS");
23434 }
23435 #[cfg(feature = "Win32_Foundation")]
23436 #[inline]
uregion_getRegionCode(uregion: *const URegion) -> super::Foundation::PSTR23437 pub unsafe fn uregion_getRegionCode(uregion: *const URegion) -> super::Foundation::PSTR {
23438     #[cfg(windows)]
23439     {
23440         #[link(name = "windows")]
23441         extern "system" {
23442             fn uregion_getRegionCode(uregion: *const URegion) -> super::Foundation::PSTR;
23443         }
23444         ::std::mem::transmute(uregion_getRegionCode(::std::mem::transmute(uregion)))
23445     }
23446     #[cfg(not(windows))]
23447     unimplemented!("Unsupported target OS");
23448 }
23449 #[cfg(feature = "Win32_Foundation")]
23450 #[inline]
uregion_getRegionFromCode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(regioncode: Param0, status: *mut UErrorCode) -> *mut URegion23451 pub unsafe fn uregion_getRegionFromCode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(regioncode: Param0, status: *mut UErrorCode) -> *mut URegion {
23452     #[cfg(windows)]
23453     {
23454         #[link(name = "windows")]
23455         extern "system" {
23456             fn uregion_getRegionFromCode(regioncode: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut URegion;
23457         }
23458         ::std::mem::transmute(uregion_getRegionFromCode(regioncode.into_param().abi(), ::std::mem::transmute(status)))
23459     }
23460     #[cfg(not(windows))]
23461     unimplemented!("Unsupported target OS");
23462 }
23463 #[inline]
uregion_getRegionFromNumericCode(code: i32, status: *mut UErrorCode) -> *mut URegion23464 pub unsafe fn uregion_getRegionFromNumericCode(code: i32, status: *mut UErrorCode) -> *mut URegion {
23465     #[cfg(windows)]
23466     {
23467         #[link(name = "windows")]
23468         extern "system" {
23469             fn uregion_getRegionFromNumericCode(code: i32, status: *mut UErrorCode) -> *mut URegion;
23470         }
23471         ::std::mem::transmute(uregion_getRegionFromNumericCode(::std::mem::transmute(code), ::std::mem::transmute(status)))
23472     }
23473     #[cfg(not(windows))]
23474     unimplemented!("Unsupported target OS");
23475 }
23476 #[inline]
uregion_getType(uregion: *const URegion) -> URegionType23477 pub unsafe fn uregion_getType(uregion: *const URegion) -> URegionType {
23478     #[cfg(windows)]
23479     {
23480         #[link(name = "windows")]
23481         extern "system" {
23482             fn uregion_getType(uregion: *const URegion) -> URegionType;
23483         }
23484         ::std::mem::transmute(uregion_getType(::std::mem::transmute(uregion)))
23485     }
23486     #[cfg(not(windows))]
23487     unimplemented!("Unsupported target OS");
23488 }
23489 #[inline]
ureldatefmt_close(reldatefmt: *mut URelativeDateTimeFormatter)23490 pub unsafe fn ureldatefmt_close(reldatefmt: *mut URelativeDateTimeFormatter) {
23491     #[cfg(windows)]
23492     {
23493         #[link(name = "windows")]
23494         extern "system" {
23495             fn ureldatefmt_close(reldatefmt: *mut URelativeDateTimeFormatter);
23496         }
23497         ::std::mem::transmute(ureldatefmt_close(::std::mem::transmute(reldatefmt)))
23498     }
23499     #[cfg(not(windows))]
23500     unimplemented!("Unsupported target OS");
23501 }
23502 #[inline]
ureldatefmt_closeResult(ufrdt: *mut UFormattedRelativeDateTime)23503 pub unsafe fn ureldatefmt_closeResult(ufrdt: *mut UFormattedRelativeDateTime) {
23504     #[cfg(windows)]
23505     {
23506         #[link(name = "windows")]
23507         extern "system" {
23508             fn ureldatefmt_closeResult(ufrdt: *mut UFormattedRelativeDateTime);
23509         }
23510         ::std::mem::transmute(ureldatefmt_closeResult(::std::mem::transmute(ufrdt)))
23511     }
23512     #[cfg(not(windows))]
23513     unimplemented!("Unsupported target OS");
23514 }
23515 #[inline]
ureldatefmt_combineDateAndTime(reldatefmt: *const URelativeDateTimeFormatter, relativedatestring: *const u16, relativedatestringlen: i32, timestring: *const u16, timestringlen: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i3223516 pub unsafe fn ureldatefmt_combineDateAndTime(reldatefmt: *const URelativeDateTimeFormatter, relativedatestring: *const u16, relativedatestringlen: i32, timestring: *const u16, timestringlen: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32 {
23517     #[cfg(windows)]
23518     {
23519         #[link(name = "windows")]
23520         extern "system" {
23521             fn ureldatefmt_combineDateAndTime(reldatefmt: *const URelativeDateTimeFormatter, relativedatestring: *const u16, relativedatestringlen: i32, timestring: *const u16, timestringlen: i32, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32;
23522         }
23523         ::std::mem::transmute(ureldatefmt_combineDateAndTime(
23524             ::std::mem::transmute(reldatefmt),
23525             ::std::mem::transmute(relativedatestring),
23526             ::std::mem::transmute(relativedatestringlen),
23527             ::std::mem::transmute(timestring),
23528             ::std::mem::transmute(timestringlen),
23529             ::std::mem::transmute(result),
23530             ::std::mem::transmute(resultcapacity),
23531             ::std::mem::transmute(status),
23532         ))
23533     }
23534     #[cfg(not(windows))]
23535     unimplemented!("Unsupported target OS");
23536 }
23537 #[inline]
ureldatefmt_format(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i3223538 pub unsafe fn ureldatefmt_format(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32 {
23539     #[cfg(windows)]
23540     {
23541         #[link(name = "windows")]
23542         extern "system" {
23543             fn ureldatefmt_format(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32;
23544         }
23545         ::std::mem::transmute(ureldatefmt_format(::std::mem::transmute(reldatefmt), ::std::mem::transmute(offset), ::std::mem::transmute(unit), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(status)))
23546     }
23547     #[cfg(not(windows))]
23548     unimplemented!("Unsupported target OS");
23549 }
23550 #[inline]
ureldatefmt_formatNumeric(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i3223551 pub unsafe fn ureldatefmt_formatNumeric(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32 {
23552     #[cfg(windows)]
23553     {
23554         #[link(name = "windows")]
23555         extern "system" {
23556             fn ureldatefmt_formatNumeric(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32;
23557         }
23558         ::std::mem::transmute(ureldatefmt_formatNumeric(::std::mem::transmute(reldatefmt), ::std::mem::transmute(offset), ::std::mem::transmute(unit), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(status)))
23559     }
23560     #[cfg(not(windows))]
23561     unimplemented!("Unsupported target OS");
23562 }
23563 #[inline]
ureldatefmt_formatNumericToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode)23564 pub unsafe fn ureldatefmt_formatNumericToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode) {
23565     #[cfg(windows)]
23566     {
23567         #[link(name = "windows")]
23568         extern "system" {
23569             fn ureldatefmt_formatNumericToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode);
23570         }
23571         ::std::mem::transmute(ureldatefmt_formatNumericToResult(::std::mem::transmute(reldatefmt), ::std::mem::transmute(offset), ::std::mem::transmute(unit), ::std::mem::transmute(result), ::std::mem::transmute(status)))
23572     }
23573     #[cfg(not(windows))]
23574     unimplemented!("Unsupported target OS");
23575 }
23576 #[inline]
ureldatefmt_formatToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode)23577 pub unsafe fn ureldatefmt_formatToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode) {
23578     #[cfg(windows)]
23579     {
23580         #[link(name = "windows")]
23581         extern "system" {
23582             fn ureldatefmt_formatToResult(reldatefmt: *const URelativeDateTimeFormatter, offset: f64, unit: URelativeDateTimeUnit, result: *mut UFormattedRelativeDateTime, status: *mut UErrorCode);
23583         }
23584         ::std::mem::transmute(ureldatefmt_formatToResult(::std::mem::transmute(reldatefmt), ::std::mem::transmute(offset), ::std::mem::transmute(unit), ::std::mem::transmute(result), ::std::mem::transmute(status)))
23585     }
23586     #[cfg(not(windows))]
23587     unimplemented!("Unsupported target OS");
23588 }
23589 #[cfg(feature = "Win32_Foundation")]
23590 #[inline]
ureldatefmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, nftoadopt: *mut *mut ::std::ffi::c_void, width: UDateRelativeDateTimeFormatterStyle, capitalizationcontext: UDisplayContext, status: *mut UErrorCode) -> *mut URelativeDateTimeFormatter23591 pub unsafe fn ureldatefmt_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(locale: Param0, nftoadopt: *mut *mut ::std::ffi::c_void, width: UDateRelativeDateTimeFormatterStyle, capitalizationcontext: UDisplayContext, status: *mut UErrorCode) -> *mut URelativeDateTimeFormatter {
23592     #[cfg(windows)]
23593     {
23594         #[link(name = "windows")]
23595         extern "system" {
23596             fn ureldatefmt_open(locale: super::Foundation::PSTR, nftoadopt: *mut *mut ::std::ffi::c_void, width: UDateRelativeDateTimeFormatterStyle, capitalizationcontext: UDisplayContext, status: *mut UErrorCode) -> *mut URelativeDateTimeFormatter;
23597         }
23598         ::std::mem::transmute(ureldatefmt_open(locale.into_param().abi(), ::std::mem::transmute(nftoadopt), ::std::mem::transmute(width), ::std::mem::transmute(capitalizationcontext), ::std::mem::transmute(status)))
23599     }
23600     #[cfg(not(windows))]
23601     unimplemented!("Unsupported target OS");
23602 }
23603 #[inline]
ureldatefmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedRelativeDateTime23604 pub unsafe fn ureldatefmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedRelativeDateTime {
23605     #[cfg(windows)]
23606     {
23607         #[link(name = "windows")]
23608         extern "system" {
23609             fn ureldatefmt_openResult(ec: *mut UErrorCode) -> *mut UFormattedRelativeDateTime;
23610         }
23611         ::std::mem::transmute(ureldatefmt_openResult(::std::mem::transmute(ec)))
23612     }
23613     #[cfg(not(windows))]
23614     unimplemented!("Unsupported target OS");
23615 }
23616 #[inline]
ureldatefmt_resultAsValue(ufrdt: *const UFormattedRelativeDateTime, ec: *mut UErrorCode) -> *mut UFormattedValue23617 pub unsafe fn ureldatefmt_resultAsValue(ufrdt: *const UFormattedRelativeDateTime, ec: *mut UErrorCode) -> *mut UFormattedValue {
23618     #[cfg(windows)]
23619     {
23620         #[link(name = "windows")]
23621         extern "system" {
23622             fn ureldatefmt_resultAsValue(ufrdt: *const UFormattedRelativeDateTime, ec: *mut UErrorCode) -> *mut UFormattedValue;
23623         }
23624         ::std::mem::transmute(ureldatefmt_resultAsValue(::std::mem::transmute(ufrdt), ::std::mem::transmute(ec)))
23625     }
23626     #[cfg(not(windows))]
23627     unimplemented!("Unsupported target OS");
23628 }
23629 #[inline]
ures_close(resourcebundle: *mut UResourceBundle)23630 pub unsafe fn ures_close(resourcebundle: *mut UResourceBundle) {
23631     #[cfg(windows)]
23632     {
23633         #[link(name = "windows")]
23634         extern "system" {
23635             fn ures_close(resourcebundle: *mut UResourceBundle);
23636         }
23637         ::std::mem::transmute(ures_close(::std::mem::transmute(resourcebundle)))
23638     }
23639     #[cfg(not(windows))]
23640     unimplemented!("Unsupported target OS");
23641 }
23642 #[inline]
ures_getBinary(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u823643 pub unsafe fn ures_getBinary(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u8 {
23644     #[cfg(windows)]
23645     {
23646         #[link(name = "windows")]
23647         extern "system" {
23648             fn ures_getBinary(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u8;
23649         }
23650         ::std::mem::transmute(ures_getBinary(::std::mem::transmute(resourcebundle), ::std::mem::transmute(len), ::std::mem::transmute(status)))
23651     }
23652     #[cfg(not(windows))]
23653     unimplemented!("Unsupported target OS");
23654 }
23655 #[inline]
ures_getByIndex(resourcebundle: *const UResourceBundle, indexr: i32, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle23656 pub unsafe fn ures_getByIndex(resourcebundle: *const UResourceBundle, indexr: i32, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle {
23657     #[cfg(windows)]
23658     {
23659         #[link(name = "windows")]
23660         extern "system" {
23661             fn ures_getByIndex(resourcebundle: *const UResourceBundle, indexr: i32, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle;
23662         }
23663         ::std::mem::transmute(ures_getByIndex(::std::mem::transmute(resourcebundle), ::std::mem::transmute(indexr), ::std::mem::transmute(fillin), ::std::mem::transmute(status)))
23664     }
23665     #[cfg(not(windows))]
23666     unimplemented!("Unsupported target OS");
23667 }
23668 #[cfg(feature = "Win32_Foundation")]
23669 #[inline]
ures_getByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resourcebundle: *const UResourceBundle, key: Param1, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle23670 pub unsafe fn ures_getByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resourcebundle: *const UResourceBundle, key: Param1, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle {
23671     #[cfg(windows)]
23672     {
23673         #[link(name = "windows")]
23674         extern "system" {
23675             fn ures_getByKey(resourcebundle: *const UResourceBundle, key: super::Foundation::PSTR, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle;
23676         }
23677         ::std::mem::transmute(ures_getByKey(::std::mem::transmute(resourcebundle), key.into_param().abi(), ::std::mem::transmute(fillin), ::std::mem::transmute(status)))
23678     }
23679     #[cfg(not(windows))]
23680     unimplemented!("Unsupported target OS");
23681 }
23682 #[inline]
ures_getInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> i3223683 pub unsafe fn ures_getInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> i32 {
23684     #[cfg(windows)]
23685     {
23686         #[link(name = "windows")]
23687         extern "system" {
23688             fn ures_getInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> i32;
23689         }
23690         ::std::mem::transmute(ures_getInt(::std::mem::transmute(resourcebundle), ::std::mem::transmute(status)))
23691     }
23692     #[cfg(not(windows))]
23693     unimplemented!("Unsupported target OS");
23694 }
23695 #[inline]
ures_getIntVector(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut i3223696 pub unsafe fn ures_getIntVector(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut i32 {
23697     #[cfg(windows)]
23698     {
23699         #[link(name = "windows")]
23700         extern "system" {
23701             fn ures_getIntVector(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut i32;
23702         }
23703         ::std::mem::transmute(ures_getIntVector(::std::mem::transmute(resourcebundle), ::std::mem::transmute(len), ::std::mem::transmute(status)))
23704     }
23705     #[cfg(not(windows))]
23706     unimplemented!("Unsupported target OS");
23707 }
23708 #[cfg(feature = "Win32_Foundation")]
23709 #[inline]
ures_getKey(resourcebundle: *const UResourceBundle) -> super::Foundation::PSTR23710 pub unsafe fn ures_getKey(resourcebundle: *const UResourceBundle) -> super::Foundation::PSTR {
23711     #[cfg(windows)]
23712     {
23713         #[link(name = "windows")]
23714         extern "system" {
23715             fn ures_getKey(resourcebundle: *const UResourceBundle) -> super::Foundation::PSTR;
23716         }
23717         ::std::mem::transmute(ures_getKey(::std::mem::transmute(resourcebundle)))
23718     }
23719     #[cfg(not(windows))]
23720     unimplemented!("Unsupported target OS");
23721 }
23722 #[cfg(feature = "Win32_Foundation")]
23723 #[inline]
ures_getLocaleByType(resourcebundle: *const UResourceBundle, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR23724 pub unsafe fn ures_getLocaleByType(resourcebundle: *const UResourceBundle, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR {
23725     #[cfg(windows)]
23726     {
23727         #[link(name = "windows")]
23728         extern "system" {
23729             fn ures_getLocaleByType(resourcebundle: *const UResourceBundle, r#type: ULocDataLocaleType, status: *mut UErrorCode) -> super::Foundation::PSTR;
23730         }
23731         ::std::mem::transmute(ures_getLocaleByType(::std::mem::transmute(resourcebundle), ::std::mem::transmute(r#type), ::std::mem::transmute(status)))
23732     }
23733     #[cfg(not(windows))]
23734     unimplemented!("Unsupported target OS");
23735 }
23736 #[inline]
ures_getNextResource(resourcebundle: *mut UResourceBundle, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle23737 pub unsafe fn ures_getNextResource(resourcebundle: *mut UResourceBundle, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle {
23738     #[cfg(windows)]
23739     {
23740         #[link(name = "windows")]
23741         extern "system" {
23742             fn ures_getNextResource(resourcebundle: *mut UResourceBundle, fillin: *mut UResourceBundle, status: *mut UErrorCode) -> *mut UResourceBundle;
23743         }
23744         ::std::mem::transmute(ures_getNextResource(::std::mem::transmute(resourcebundle), ::std::mem::transmute(fillin), ::std::mem::transmute(status)))
23745     }
23746     #[cfg(not(windows))]
23747     unimplemented!("Unsupported target OS");
23748 }
23749 #[inline]
ures_getNextString(resourcebundle: *mut UResourceBundle, len: *mut i32, key: *const *const i8, status: *mut UErrorCode) -> *mut u1623750 pub unsafe fn ures_getNextString(resourcebundle: *mut UResourceBundle, len: *mut i32, key: *const *const i8, status: *mut UErrorCode) -> *mut u16 {
23751     #[cfg(windows)]
23752     {
23753         #[link(name = "windows")]
23754         extern "system" {
23755             fn ures_getNextString(resourcebundle: *mut UResourceBundle, len: *mut i32, key: *const *const i8, status: *mut UErrorCode) -> *mut u16;
23756         }
23757         ::std::mem::transmute(ures_getNextString(::std::mem::transmute(resourcebundle), ::std::mem::transmute(len), ::std::mem::transmute(key), ::std::mem::transmute(status)))
23758     }
23759     #[cfg(not(windows))]
23760     unimplemented!("Unsupported target OS");
23761 }
23762 #[inline]
ures_getSize(resourcebundle: *const UResourceBundle) -> i3223763 pub unsafe fn ures_getSize(resourcebundle: *const UResourceBundle) -> i32 {
23764     #[cfg(windows)]
23765     {
23766         #[link(name = "windows")]
23767         extern "system" {
23768             fn ures_getSize(resourcebundle: *const UResourceBundle) -> i32;
23769         }
23770         ::std::mem::transmute(ures_getSize(::std::mem::transmute(resourcebundle)))
23771     }
23772     #[cfg(not(windows))]
23773     unimplemented!("Unsupported target OS");
23774 }
23775 #[inline]
ures_getString(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u1623776 pub unsafe fn ures_getString(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u16 {
23777     #[cfg(windows)]
23778     {
23779         #[link(name = "windows")]
23780         extern "system" {
23781             fn ures_getString(resourcebundle: *const UResourceBundle, len: *mut i32, status: *mut UErrorCode) -> *mut u16;
23782         }
23783         ::std::mem::transmute(ures_getString(::std::mem::transmute(resourcebundle), ::std::mem::transmute(len), ::std::mem::transmute(status)))
23784     }
23785     #[cfg(not(windows))]
23786     unimplemented!("Unsupported target OS");
23787 }
23788 #[inline]
ures_getStringByIndex(resourcebundle: *const UResourceBundle, indexs: i32, len: *mut i32, status: *mut UErrorCode) -> *mut u1623789 pub unsafe fn ures_getStringByIndex(resourcebundle: *const UResourceBundle, indexs: i32, len: *mut i32, status: *mut UErrorCode) -> *mut u16 {
23790     #[cfg(windows)]
23791     {
23792         #[link(name = "windows")]
23793         extern "system" {
23794             fn ures_getStringByIndex(resourcebundle: *const UResourceBundle, indexs: i32, len: *mut i32, status: *mut UErrorCode) -> *mut u16;
23795         }
23796         ::std::mem::transmute(ures_getStringByIndex(::std::mem::transmute(resourcebundle), ::std::mem::transmute(indexs), ::std::mem::transmute(len), ::std::mem::transmute(status)))
23797     }
23798     #[cfg(not(windows))]
23799     unimplemented!("Unsupported target OS");
23800 }
23801 #[cfg(feature = "Win32_Foundation")]
23802 #[inline]
ures_getStringByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, key: Param1, len: *mut i32, status: *mut UErrorCode) -> *mut u1623803 pub unsafe fn ures_getStringByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, key: Param1, len: *mut i32, status: *mut UErrorCode) -> *mut u16 {
23804     #[cfg(windows)]
23805     {
23806         #[link(name = "windows")]
23807         extern "system" {
23808             fn ures_getStringByKey(resb: *const UResourceBundle, key: super::Foundation::PSTR, len: *mut i32, status: *mut UErrorCode) -> *mut u16;
23809         }
23810         ::std::mem::transmute(ures_getStringByKey(::std::mem::transmute(resb), key.into_param().abi(), ::std::mem::transmute(len), ::std::mem::transmute(status)))
23811     }
23812     #[cfg(not(windows))]
23813     unimplemented!("Unsupported target OS");
23814 }
23815 #[inline]
ures_getType(resourcebundle: *const UResourceBundle) -> UResType23816 pub unsafe fn ures_getType(resourcebundle: *const UResourceBundle) -> UResType {
23817     #[cfg(windows)]
23818     {
23819         #[link(name = "windows")]
23820         extern "system" {
23821             fn ures_getType(resourcebundle: *const UResourceBundle) -> UResType;
23822         }
23823         ::std::mem::transmute(ures_getType(::std::mem::transmute(resourcebundle)))
23824     }
23825     #[cfg(not(windows))]
23826     unimplemented!("Unsupported target OS");
23827 }
23828 #[inline]
ures_getUInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> u3223829 pub unsafe fn ures_getUInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> u32 {
23830     #[cfg(windows)]
23831     {
23832         #[link(name = "windows")]
23833         extern "system" {
23834             fn ures_getUInt(resourcebundle: *const UResourceBundle, status: *mut UErrorCode) -> u32;
23835         }
23836         ::std::mem::transmute(ures_getUInt(::std::mem::transmute(resourcebundle), ::std::mem::transmute(status)))
23837     }
23838     #[cfg(not(windows))]
23839     unimplemented!("Unsupported target OS");
23840 }
23841 #[cfg(feature = "Win32_Foundation")]
23842 #[inline]
ures_getUTF8String<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, dest: Param1, length: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR23843 pub unsafe fn ures_getUTF8String<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, dest: Param1, length: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR {
23844     #[cfg(windows)]
23845     {
23846         #[link(name = "windows")]
23847         extern "system" {
23848             fn ures_getUTF8String(resb: *const UResourceBundle, dest: super::Foundation::PSTR, length: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR;
23849         }
23850         ::std::mem::transmute(ures_getUTF8String(::std::mem::transmute(resb), dest.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(forcecopy), ::std::mem::transmute(status)))
23851     }
23852     #[cfg(not(windows))]
23853     unimplemented!("Unsupported target OS");
23854 }
23855 #[cfg(feature = "Win32_Foundation")]
23856 #[inline]
ures_getUTF8StringByIndex<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, stringindex: i32, dest: Param2, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR23857 pub unsafe fn ures_getUTF8StringByIndex<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, stringindex: i32, dest: Param2, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR {
23858     #[cfg(windows)]
23859     {
23860         #[link(name = "windows")]
23861         extern "system" {
23862             fn ures_getUTF8StringByIndex(resb: *const UResourceBundle, stringindex: i32, dest: super::Foundation::PSTR, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR;
23863         }
23864         ::std::mem::transmute(ures_getUTF8StringByIndex(::std::mem::transmute(resb), ::std::mem::transmute(stringindex), dest.into_param().abi(), ::std::mem::transmute(plength), ::std::mem::transmute(forcecopy), ::std::mem::transmute(status)))
23865     }
23866     #[cfg(not(windows))]
23867     unimplemented!("Unsupported target OS");
23868 }
23869 #[cfg(feature = "Win32_Foundation")]
23870 #[inline]
ures_getUTF8StringByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, key: Param1, dest: Param2, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR23871 pub unsafe fn ures_getUTF8StringByKey<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(resb: *const UResourceBundle, key: Param1, dest: Param2, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR {
23872     #[cfg(windows)]
23873     {
23874         #[link(name = "windows")]
23875         extern "system" {
23876             fn ures_getUTF8StringByKey(resb: *const UResourceBundle, key: super::Foundation::PSTR, dest: super::Foundation::PSTR, plength: *mut i32, forcecopy: i8, status: *mut UErrorCode) -> super::Foundation::PSTR;
23877         }
23878         ::std::mem::transmute(ures_getUTF8StringByKey(::std::mem::transmute(resb), key.into_param().abi(), dest.into_param().abi(), ::std::mem::transmute(plength), ::std::mem::transmute(forcecopy), ::std::mem::transmute(status)))
23879     }
23880     #[cfg(not(windows))]
23881     unimplemented!("Unsupported target OS");
23882 }
23883 #[inline]
ures_getVersion(resb: *const UResourceBundle, versioninfo: *mut u8)23884 pub unsafe fn ures_getVersion(resb: *const UResourceBundle, versioninfo: *mut u8) {
23885     #[cfg(windows)]
23886     {
23887         #[link(name = "windows")]
23888         extern "system" {
23889             fn ures_getVersion(resb: *const UResourceBundle, versioninfo: *mut u8);
23890         }
23891         ::std::mem::transmute(ures_getVersion(::std::mem::transmute(resb), ::std::mem::transmute(versioninfo)))
23892     }
23893     #[cfg(not(windows))]
23894     unimplemented!("Unsupported target OS");
23895 }
23896 #[inline]
ures_hasNext(resourcebundle: *const UResourceBundle) -> i823897 pub unsafe fn ures_hasNext(resourcebundle: *const UResourceBundle) -> i8 {
23898     #[cfg(windows)]
23899     {
23900         #[link(name = "windows")]
23901         extern "system" {
23902             fn ures_hasNext(resourcebundle: *const UResourceBundle) -> i8;
23903         }
23904         ::std::mem::transmute(ures_hasNext(::std::mem::transmute(resourcebundle)))
23905     }
23906     #[cfg(not(windows))]
23907     unimplemented!("Unsupported target OS");
23908 }
23909 #[cfg(feature = "Win32_Foundation")]
23910 #[inline]
ures_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle23911 pub unsafe fn ures_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle {
23912     #[cfg(windows)]
23913     {
23914         #[link(name = "windows")]
23915         extern "system" {
23916             fn ures_open(packagename: super::Foundation::PSTR, locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UResourceBundle;
23917         }
23918         ::std::mem::transmute(ures_open(packagename.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(status)))
23919     }
23920     #[cfg(not(windows))]
23921     unimplemented!("Unsupported target OS");
23922 }
23923 #[cfg(feature = "Win32_Foundation")]
23924 #[inline]
ures_openAvailableLocales<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, status: *mut UErrorCode) -> *mut UEnumeration23925 pub unsafe fn ures_openAvailableLocales<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, status: *mut UErrorCode) -> *mut UEnumeration {
23926     #[cfg(windows)]
23927     {
23928         #[link(name = "windows")]
23929         extern "system" {
23930             fn ures_openAvailableLocales(packagename: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UEnumeration;
23931         }
23932         ::std::mem::transmute(ures_openAvailableLocales(packagename.into_param().abi(), ::std::mem::transmute(status)))
23933     }
23934     #[cfg(not(windows))]
23935     unimplemented!("Unsupported target OS");
23936 }
23937 #[cfg(feature = "Win32_Foundation")]
23938 #[inline]
ures_openDirect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle23939 pub unsafe fn ures_openDirect<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: Param0, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle {
23940     #[cfg(windows)]
23941     {
23942         #[link(name = "windows")]
23943         extern "system" {
23944             fn ures_openDirect(packagename: super::Foundation::PSTR, locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UResourceBundle;
23945         }
23946         ::std::mem::transmute(ures_openDirect(packagename.into_param().abi(), locale.into_param().abi(), ::std::mem::transmute(status)))
23947     }
23948     #[cfg(not(windows))]
23949     unimplemented!("Unsupported target OS");
23950 }
23951 #[cfg(feature = "Win32_Foundation")]
23952 #[inline]
ures_openU<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: *const u16, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle23953 pub unsafe fn ures_openU<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(packagename: *const u16, locale: Param1, status: *mut UErrorCode) -> *mut UResourceBundle {
23954     #[cfg(windows)]
23955     {
23956         #[link(name = "windows")]
23957         extern "system" {
23958             fn ures_openU(packagename: *const u16, locale: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UResourceBundle;
23959         }
23960         ::std::mem::transmute(ures_openU(::std::mem::transmute(packagename), locale.into_param().abi(), ::std::mem::transmute(status)))
23961     }
23962     #[cfg(not(windows))]
23963     unimplemented!("Unsupported target OS");
23964 }
23965 #[inline]
ures_resetIterator(resourcebundle: *mut UResourceBundle)23966 pub unsafe fn ures_resetIterator(resourcebundle: *mut UResourceBundle) {
23967     #[cfg(windows)]
23968     {
23969         #[link(name = "windows")]
23970         extern "system" {
23971             fn ures_resetIterator(resourcebundle: *mut UResourceBundle);
23972         }
23973         ::std::mem::transmute(ures_resetIterator(::std::mem::transmute(resourcebundle)))
23974     }
23975     #[cfg(not(windows))]
23976     unimplemented!("Unsupported target OS");
23977 }
23978 #[inline]
uscript_breaksBetweenLetters(script: UScriptCode) -> i823979 pub unsafe fn uscript_breaksBetweenLetters(script: UScriptCode) -> i8 {
23980     #[cfg(windows)]
23981     {
23982         #[link(name = "windows")]
23983         extern "system" {
23984             fn uscript_breaksBetweenLetters(script: UScriptCode) -> i8;
23985         }
23986         ::std::mem::transmute(uscript_breaksBetweenLetters(::std::mem::transmute(script)))
23987     }
23988     #[cfg(not(windows))]
23989     unimplemented!("Unsupported target OS");
23990 }
23991 #[cfg(feature = "Win32_Foundation")]
23992 #[inline]
uscript_getCode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(nameorabbrorlocale: Param0, fillin: *mut UScriptCode, capacity: i32, err: *mut UErrorCode) -> i3223993 pub unsafe fn uscript_getCode<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(nameorabbrorlocale: Param0, fillin: *mut UScriptCode, capacity: i32, err: *mut UErrorCode) -> i32 {
23994     #[cfg(windows)]
23995     {
23996         #[link(name = "windows")]
23997         extern "system" {
23998             fn uscript_getCode(nameorabbrorlocale: super::Foundation::PSTR, fillin: *mut UScriptCode, capacity: i32, err: *mut UErrorCode) -> i32;
23999         }
24000         ::std::mem::transmute(uscript_getCode(nameorabbrorlocale.into_param().abi(), ::std::mem::transmute(fillin), ::std::mem::transmute(capacity), ::std::mem::transmute(err)))
24001     }
24002     #[cfg(not(windows))]
24003     unimplemented!("Unsupported target OS");
24004 }
24005 #[cfg(feature = "Win32_Foundation")]
24006 #[inline]
uscript_getName(scriptcode: UScriptCode) -> super::Foundation::PSTR24007 pub unsafe fn uscript_getName(scriptcode: UScriptCode) -> super::Foundation::PSTR {
24008     #[cfg(windows)]
24009     {
24010         #[link(name = "windows")]
24011         extern "system" {
24012             fn uscript_getName(scriptcode: UScriptCode) -> super::Foundation::PSTR;
24013         }
24014         ::std::mem::transmute(uscript_getName(::std::mem::transmute(scriptcode)))
24015     }
24016     #[cfg(not(windows))]
24017     unimplemented!("Unsupported target OS");
24018 }
24019 #[inline]
uscript_getSampleString(script: UScriptCode, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i3224020 pub unsafe fn uscript_getSampleString(script: UScriptCode, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32 {
24021     #[cfg(windows)]
24022     {
24023         #[link(name = "windows")]
24024         extern "system" {
24025             fn uscript_getSampleString(script: UScriptCode, dest: *mut u16, capacity: i32, perrorcode: *mut UErrorCode) -> i32;
24026         }
24027         ::std::mem::transmute(uscript_getSampleString(::std::mem::transmute(script), ::std::mem::transmute(dest), ::std::mem::transmute(capacity), ::std::mem::transmute(perrorcode)))
24028     }
24029     #[cfg(not(windows))]
24030     unimplemented!("Unsupported target OS");
24031 }
24032 #[inline]
uscript_getScript(codepoint: i32, err: *mut UErrorCode) -> UScriptCode24033 pub unsafe fn uscript_getScript(codepoint: i32, err: *mut UErrorCode) -> UScriptCode {
24034     #[cfg(windows)]
24035     {
24036         #[link(name = "windows")]
24037         extern "system" {
24038             fn uscript_getScript(codepoint: i32, err: *mut UErrorCode) -> UScriptCode;
24039         }
24040         ::std::mem::transmute(uscript_getScript(::std::mem::transmute(codepoint), ::std::mem::transmute(err)))
24041     }
24042     #[cfg(not(windows))]
24043     unimplemented!("Unsupported target OS");
24044 }
24045 #[inline]
uscript_getScriptExtensions(c: i32, scripts: *mut UScriptCode, capacity: i32, errorcode: *mut UErrorCode) -> i3224046 pub unsafe fn uscript_getScriptExtensions(c: i32, scripts: *mut UScriptCode, capacity: i32, errorcode: *mut UErrorCode) -> i32 {
24047     #[cfg(windows)]
24048     {
24049         #[link(name = "windows")]
24050         extern "system" {
24051             fn uscript_getScriptExtensions(c: i32, scripts: *mut UScriptCode, capacity: i32, errorcode: *mut UErrorCode) -> i32;
24052         }
24053         ::std::mem::transmute(uscript_getScriptExtensions(::std::mem::transmute(c), ::std::mem::transmute(scripts), ::std::mem::transmute(capacity), ::std::mem::transmute(errorcode)))
24054     }
24055     #[cfg(not(windows))]
24056     unimplemented!("Unsupported target OS");
24057 }
24058 #[cfg(feature = "Win32_Foundation")]
24059 #[inline]
uscript_getShortName(scriptcode: UScriptCode) -> super::Foundation::PSTR24060 pub unsafe fn uscript_getShortName(scriptcode: UScriptCode) -> super::Foundation::PSTR {
24061     #[cfg(windows)]
24062     {
24063         #[link(name = "windows")]
24064         extern "system" {
24065             fn uscript_getShortName(scriptcode: UScriptCode) -> super::Foundation::PSTR;
24066         }
24067         ::std::mem::transmute(uscript_getShortName(::std::mem::transmute(scriptcode)))
24068     }
24069     #[cfg(not(windows))]
24070     unimplemented!("Unsupported target OS");
24071 }
24072 #[inline]
uscript_getUsage(script: UScriptCode) -> UScriptUsage24073 pub unsafe fn uscript_getUsage(script: UScriptCode) -> UScriptUsage {
24074     #[cfg(windows)]
24075     {
24076         #[link(name = "windows")]
24077         extern "system" {
24078             fn uscript_getUsage(script: UScriptCode) -> UScriptUsage;
24079         }
24080         ::std::mem::transmute(uscript_getUsage(::std::mem::transmute(script)))
24081     }
24082     #[cfg(not(windows))]
24083     unimplemented!("Unsupported target OS");
24084 }
24085 #[inline]
uscript_hasScript(c: i32, sc: UScriptCode) -> i824086 pub unsafe fn uscript_hasScript(c: i32, sc: UScriptCode) -> i8 {
24087     #[cfg(windows)]
24088     {
24089         #[link(name = "windows")]
24090         extern "system" {
24091             fn uscript_hasScript(c: i32, sc: UScriptCode) -> i8;
24092         }
24093         ::std::mem::transmute(uscript_hasScript(::std::mem::transmute(c), ::std::mem::transmute(sc)))
24094     }
24095     #[cfg(not(windows))]
24096     unimplemented!("Unsupported target OS");
24097 }
24098 #[inline]
uscript_isCased(script: UScriptCode) -> i824099 pub unsafe fn uscript_isCased(script: UScriptCode) -> i8 {
24100     #[cfg(windows)]
24101     {
24102         #[link(name = "windows")]
24103         extern "system" {
24104             fn uscript_isCased(script: UScriptCode) -> i8;
24105         }
24106         ::std::mem::transmute(uscript_isCased(::std::mem::transmute(script)))
24107     }
24108     #[cfg(not(windows))]
24109     unimplemented!("Unsupported target OS");
24110 }
24111 #[inline]
uscript_isRightToLeft(script: UScriptCode) -> i824112 pub unsafe fn uscript_isRightToLeft(script: UScriptCode) -> i8 {
24113     #[cfg(windows)]
24114     {
24115         #[link(name = "windows")]
24116         extern "system" {
24117             fn uscript_isRightToLeft(script: UScriptCode) -> i8;
24118         }
24119         ::std::mem::transmute(uscript_isRightToLeft(::std::mem::transmute(script)))
24120     }
24121     #[cfg(not(windows))]
24122     unimplemented!("Unsupported target OS");
24123 }
24124 #[inline]
usearch_close(searchiter: *mut UStringSearch)24125 pub unsafe fn usearch_close(searchiter: *mut UStringSearch) {
24126     #[cfg(windows)]
24127     {
24128         #[link(name = "windows")]
24129         extern "system" {
24130             fn usearch_close(searchiter: *mut UStringSearch);
24131         }
24132         ::std::mem::transmute(usearch_close(::std::mem::transmute(searchiter)))
24133     }
24134     #[cfg(not(windows))]
24135     unimplemented!("Unsupported target OS");
24136 }
24137 #[inline]
usearch_first(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i3224138 pub unsafe fn usearch_first(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32 {
24139     #[cfg(windows)]
24140     {
24141         #[link(name = "windows")]
24142         extern "system" {
24143             fn usearch_first(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32;
24144         }
24145         ::std::mem::transmute(usearch_first(::std::mem::transmute(strsrch), ::std::mem::transmute(status)))
24146     }
24147     #[cfg(not(windows))]
24148     unimplemented!("Unsupported target OS");
24149 }
24150 #[inline]
usearch_following(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i3224151 pub unsafe fn usearch_following(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i32 {
24152     #[cfg(windows)]
24153     {
24154         #[link(name = "windows")]
24155         extern "system" {
24156             fn usearch_following(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i32;
24157         }
24158         ::std::mem::transmute(usearch_following(::std::mem::transmute(strsrch), ::std::mem::transmute(position), ::std::mem::transmute(status)))
24159     }
24160     #[cfg(not(windows))]
24161     unimplemented!("Unsupported target OS");
24162 }
24163 #[inline]
usearch_getAttribute(strsrch: *const UStringSearch, attribute: USearchAttribute) -> USearchAttributeValue24164 pub unsafe fn usearch_getAttribute(strsrch: *const UStringSearch, attribute: USearchAttribute) -> USearchAttributeValue {
24165     #[cfg(windows)]
24166     {
24167         #[link(name = "windows")]
24168         extern "system" {
24169             fn usearch_getAttribute(strsrch: *const UStringSearch, attribute: USearchAttribute) -> USearchAttributeValue;
24170         }
24171         ::std::mem::transmute(usearch_getAttribute(::std::mem::transmute(strsrch), ::std::mem::transmute(attribute)))
24172     }
24173     #[cfg(not(windows))]
24174     unimplemented!("Unsupported target OS");
24175 }
24176 #[inline]
usearch_getBreakIterator(strsrch: *const UStringSearch) -> *mut UBreakIterator24177 pub unsafe fn usearch_getBreakIterator(strsrch: *const UStringSearch) -> *mut UBreakIterator {
24178     #[cfg(windows)]
24179     {
24180         #[link(name = "windows")]
24181         extern "system" {
24182             fn usearch_getBreakIterator(strsrch: *const UStringSearch) -> *mut UBreakIterator;
24183         }
24184         ::std::mem::transmute(usearch_getBreakIterator(::std::mem::transmute(strsrch)))
24185     }
24186     #[cfg(not(windows))]
24187     unimplemented!("Unsupported target OS");
24188 }
24189 #[inline]
usearch_getCollator(strsrch: *const UStringSearch) -> *mut UCollator24190 pub unsafe fn usearch_getCollator(strsrch: *const UStringSearch) -> *mut UCollator {
24191     #[cfg(windows)]
24192     {
24193         #[link(name = "windows")]
24194         extern "system" {
24195             fn usearch_getCollator(strsrch: *const UStringSearch) -> *mut UCollator;
24196         }
24197         ::std::mem::transmute(usearch_getCollator(::std::mem::transmute(strsrch)))
24198     }
24199     #[cfg(not(windows))]
24200     unimplemented!("Unsupported target OS");
24201 }
24202 #[inline]
usearch_getMatchedLength(strsrch: *const UStringSearch) -> i3224203 pub unsafe fn usearch_getMatchedLength(strsrch: *const UStringSearch) -> i32 {
24204     #[cfg(windows)]
24205     {
24206         #[link(name = "windows")]
24207         extern "system" {
24208             fn usearch_getMatchedLength(strsrch: *const UStringSearch) -> i32;
24209         }
24210         ::std::mem::transmute(usearch_getMatchedLength(::std::mem::transmute(strsrch)))
24211     }
24212     #[cfg(not(windows))]
24213     unimplemented!("Unsupported target OS");
24214 }
24215 #[inline]
usearch_getMatchedStart(strsrch: *const UStringSearch) -> i3224216 pub unsafe fn usearch_getMatchedStart(strsrch: *const UStringSearch) -> i32 {
24217     #[cfg(windows)]
24218     {
24219         #[link(name = "windows")]
24220         extern "system" {
24221             fn usearch_getMatchedStart(strsrch: *const UStringSearch) -> i32;
24222         }
24223         ::std::mem::transmute(usearch_getMatchedStart(::std::mem::transmute(strsrch)))
24224     }
24225     #[cfg(not(windows))]
24226     unimplemented!("Unsupported target OS");
24227 }
24228 #[inline]
usearch_getMatchedText(strsrch: *const UStringSearch, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i3224229 pub unsafe fn usearch_getMatchedText(strsrch: *const UStringSearch, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32 {
24230     #[cfg(windows)]
24231     {
24232         #[link(name = "windows")]
24233         extern "system" {
24234             fn usearch_getMatchedText(strsrch: *const UStringSearch, result: *mut u16, resultcapacity: i32, status: *mut UErrorCode) -> i32;
24235         }
24236         ::std::mem::transmute(usearch_getMatchedText(::std::mem::transmute(strsrch), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(status)))
24237     }
24238     #[cfg(not(windows))]
24239     unimplemented!("Unsupported target OS");
24240 }
24241 #[inline]
usearch_getOffset(strsrch: *const UStringSearch) -> i3224242 pub unsafe fn usearch_getOffset(strsrch: *const UStringSearch) -> i32 {
24243     #[cfg(windows)]
24244     {
24245         #[link(name = "windows")]
24246         extern "system" {
24247             fn usearch_getOffset(strsrch: *const UStringSearch) -> i32;
24248         }
24249         ::std::mem::transmute(usearch_getOffset(::std::mem::transmute(strsrch)))
24250     }
24251     #[cfg(not(windows))]
24252     unimplemented!("Unsupported target OS");
24253 }
24254 #[inline]
usearch_getPattern(strsrch: *const UStringSearch, length: *mut i32) -> *mut u1624255 pub unsafe fn usearch_getPattern(strsrch: *const UStringSearch, length: *mut i32) -> *mut u16 {
24256     #[cfg(windows)]
24257     {
24258         #[link(name = "windows")]
24259         extern "system" {
24260             fn usearch_getPattern(strsrch: *const UStringSearch, length: *mut i32) -> *mut u16;
24261         }
24262         ::std::mem::transmute(usearch_getPattern(::std::mem::transmute(strsrch), ::std::mem::transmute(length)))
24263     }
24264     #[cfg(not(windows))]
24265     unimplemented!("Unsupported target OS");
24266 }
24267 #[inline]
usearch_getText(strsrch: *const UStringSearch, length: *mut i32) -> *mut u1624268 pub unsafe fn usearch_getText(strsrch: *const UStringSearch, length: *mut i32) -> *mut u16 {
24269     #[cfg(windows)]
24270     {
24271         #[link(name = "windows")]
24272         extern "system" {
24273             fn usearch_getText(strsrch: *const UStringSearch, length: *mut i32) -> *mut u16;
24274         }
24275         ::std::mem::transmute(usearch_getText(::std::mem::transmute(strsrch), ::std::mem::transmute(length)))
24276     }
24277     #[cfg(not(windows))]
24278     unimplemented!("Unsupported target OS");
24279 }
24280 #[inline]
usearch_last(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i3224281 pub unsafe fn usearch_last(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32 {
24282     #[cfg(windows)]
24283     {
24284         #[link(name = "windows")]
24285         extern "system" {
24286             fn usearch_last(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32;
24287         }
24288         ::std::mem::transmute(usearch_last(::std::mem::transmute(strsrch), ::std::mem::transmute(status)))
24289     }
24290     #[cfg(not(windows))]
24291     unimplemented!("Unsupported target OS");
24292 }
24293 #[inline]
usearch_next(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i3224294 pub unsafe fn usearch_next(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32 {
24295     #[cfg(windows)]
24296     {
24297         #[link(name = "windows")]
24298         extern "system" {
24299             fn usearch_next(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32;
24300         }
24301         ::std::mem::transmute(usearch_next(::std::mem::transmute(strsrch), ::std::mem::transmute(status)))
24302     }
24303     #[cfg(not(windows))]
24304     unimplemented!("Unsupported target OS");
24305 }
24306 #[cfg(feature = "Win32_Foundation")]
24307 #[inline]
usearch_open<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, locale: Param4, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch24308 pub unsafe fn usearch_open<'a, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, locale: Param4, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch {
24309     #[cfg(windows)]
24310     {
24311         #[link(name = "windows")]
24312         extern "system" {
24313             fn usearch_open(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, locale: super::Foundation::PSTR, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch;
24314         }
24315         ::std::mem::transmute(usearch_open(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(text), ::std::mem::transmute(textlength), locale.into_param().abi(), ::std::mem::transmute(breakiter), ::std::mem::transmute(status)))
24316     }
24317     #[cfg(not(windows))]
24318     unimplemented!("Unsupported target OS");
24319 }
24320 #[inline]
usearch_openFromCollator(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, collator: *const UCollator, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch24321 pub unsafe fn usearch_openFromCollator(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, collator: *const UCollator, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch {
24322     #[cfg(windows)]
24323     {
24324         #[link(name = "windows")]
24325         extern "system" {
24326             fn usearch_openFromCollator(pattern: *const u16, patternlength: i32, text: *const u16, textlength: i32, collator: *const UCollator, breakiter: *mut UBreakIterator, status: *mut UErrorCode) -> *mut UStringSearch;
24327         }
24328         ::std::mem::transmute(usearch_openFromCollator(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(collator), ::std::mem::transmute(breakiter), ::std::mem::transmute(status)))
24329     }
24330     #[cfg(not(windows))]
24331     unimplemented!("Unsupported target OS");
24332 }
24333 #[inline]
usearch_preceding(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i3224334 pub unsafe fn usearch_preceding(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i32 {
24335     #[cfg(windows)]
24336     {
24337         #[link(name = "windows")]
24338         extern "system" {
24339             fn usearch_preceding(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) -> i32;
24340         }
24341         ::std::mem::transmute(usearch_preceding(::std::mem::transmute(strsrch), ::std::mem::transmute(position), ::std::mem::transmute(status)))
24342     }
24343     #[cfg(not(windows))]
24344     unimplemented!("Unsupported target OS");
24345 }
24346 #[inline]
usearch_previous(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i3224347 pub unsafe fn usearch_previous(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32 {
24348     #[cfg(windows)]
24349     {
24350         #[link(name = "windows")]
24351         extern "system" {
24352             fn usearch_previous(strsrch: *mut UStringSearch, status: *mut UErrorCode) -> i32;
24353         }
24354         ::std::mem::transmute(usearch_previous(::std::mem::transmute(strsrch), ::std::mem::transmute(status)))
24355     }
24356     #[cfg(not(windows))]
24357     unimplemented!("Unsupported target OS");
24358 }
24359 #[inline]
usearch_reset(strsrch: *mut UStringSearch)24360 pub unsafe fn usearch_reset(strsrch: *mut UStringSearch) {
24361     #[cfg(windows)]
24362     {
24363         #[link(name = "windows")]
24364         extern "system" {
24365             fn usearch_reset(strsrch: *mut UStringSearch);
24366         }
24367         ::std::mem::transmute(usearch_reset(::std::mem::transmute(strsrch)))
24368     }
24369     #[cfg(not(windows))]
24370     unimplemented!("Unsupported target OS");
24371 }
24372 #[inline]
usearch_setAttribute(strsrch: *mut UStringSearch, attribute: USearchAttribute, value: USearchAttributeValue, status: *mut UErrorCode)24373 pub unsafe fn usearch_setAttribute(strsrch: *mut UStringSearch, attribute: USearchAttribute, value: USearchAttributeValue, status: *mut UErrorCode) {
24374     #[cfg(windows)]
24375     {
24376         #[link(name = "windows")]
24377         extern "system" {
24378             fn usearch_setAttribute(strsrch: *mut UStringSearch, attribute: USearchAttribute, value: USearchAttributeValue, status: *mut UErrorCode);
24379         }
24380         ::std::mem::transmute(usearch_setAttribute(::std::mem::transmute(strsrch), ::std::mem::transmute(attribute), ::std::mem::transmute(value), ::std::mem::transmute(status)))
24381     }
24382     #[cfg(not(windows))]
24383     unimplemented!("Unsupported target OS");
24384 }
24385 #[inline]
usearch_setBreakIterator(strsrch: *mut UStringSearch, breakiter: *mut UBreakIterator, status: *mut UErrorCode)24386 pub unsafe fn usearch_setBreakIterator(strsrch: *mut UStringSearch, breakiter: *mut UBreakIterator, status: *mut UErrorCode) {
24387     #[cfg(windows)]
24388     {
24389         #[link(name = "windows")]
24390         extern "system" {
24391             fn usearch_setBreakIterator(strsrch: *mut UStringSearch, breakiter: *mut UBreakIterator, status: *mut UErrorCode);
24392         }
24393         ::std::mem::transmute(usearch_setBreakIterator(::std::mem::transmute(strsrch), ::std::mem::transmute(breakiter), ::std::mem::transmute(status)))
24394     }
24395     #[cfg(not(windows))]
24396     unimplemented!("Unsupported target OS");
24397 }
24398 #[inline]
usearch_setCollator(strsrch: *mut UStringSearch, collator: *const UCollator, status: *mut UErrorCode)24399 pub unsafe fn usearch_setCollator(strsrch: *mut UStringSearch, collator: *const UCollator, status: *mut UErrorCode) {
24400     #[cfg(windows)]
24401     {
24402         #[link(name = "windows")]
24403         extern "system" {
24404             fn usearch_setCollator(strsrch: *mut UStringSearch, collator: *const UCollator, status: *mut UErrorCode);
24405         }
24406         ::std::mem::transmute(usearch_setCollator(::std::mem::transmute(strsrch), ::std::mem::transmute(collator), ::std::mem::transmute(status)))
24407     }
24408     #[cfg(not(windows))]
24409     unimplemented!("Unsupported target OS");
24410 }
24411 #[inline]
usearch_setOffset(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode)24412 pub unsafe fn usearch_setOffset(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode) {
24413     #[cfg(windows)]
24414     {
24415         #[link(name = "windows")]
24416         extern "system" {
24417             fn usearch_setOffset(strsrch: *mut UStringSearch, position: i32, status: *mut UErrorCode);
24418         }
24419         ::std::mem::transmute(usearch_setOffset(::std::mem::transmute(strsrch), ::std::mem::transmute(position), ::std::mem::transmute(status)))
24420     }
24421     #[cfg(not(windows))]
24422     unimplemented!("Unsupported target OS");
24423 }
24424 #[inline]
usearch_setPattern(strsrch: *mut UStringSearch, pattern: *const u16, patternlength: i32, status: *mut UErrorCode)24425 pub unsafe fn usearch_setPattern(strsrch: *mut UStringSearch, pattern: *const u16, patternlength: i32, status: *mut UErrorCode) {
24426     #[cfg(windows)]
24427     {
24428         #[link(name = "windows")]
24429         extern "system" {
24430             fn usearch_setPattern(strsrch: *mut UStringSearch, pattern: *const u16, patternlength: i32, status: *mut UErrorCode);
24431         }
24432         ::std::mem::transmute(usearch_setPattern(::std::mem::transmute(strsrch), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(status)))
24433     }
24434     #[cfg(not(windows))]
24435     unimplemented!("Unsupported target OS");
24436 }
24437 #[inline]
usearch_setText(strsrch: *mut UStringSearch, text: *const u16, textlength: i32, status: *mut UErrorCode)24438 pub unsafe fn usearch_setText(strsrch: *mut UStringSearch, text: *const u16, textlength: i32, status: *mut UErrorCode) {
24439     #[cfg(windows)]
24440     {
24441         #[link(name = "windows")]
24442         extern "system" {
24443             fn usearch_setText(strsrch: *mut UStringSearch, text: *const u16, textlength: i32, status: *mut UErrorCode);
24444         }
24445         ::std::mem::transmute(usearch_setText(::std::mem::transmute(strsrch), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(status)))
24446     }
24447     #[cfg(not(windows))]
24448     unimplemented!("Unsupported target OS");
24449 }
24450 #[inline]
uset_add(set: *mut USet, c: i32)24451 pub unsafe fn uset_add(set: *mut USet, c: i32) {
24452     #[cfg(windows)]
24453     {
24454         #[link(name = "windows")]
24455         extern "system" {
24456             fn uset_add(set: *mut USet, c: i32);
24457         }
24458         ::std::mem::transmute(uset_add(::std::mem::transmute(set), ::std::mem::transmute(c)))
24459     }
24460     #[cfg(not(windows))]
24461     unimplemented!("Unsupported target OS");
24462 }
24463 #[inline]
uset_addAll(set: *mut USet, additionalset: *const USet)24464 pub unsafe fn uset_addAll(set: *mut USet, additionalset: *const USet) {
24465     #[cfg(windows)]
24466     {
24467         #[link(name = "windows")]
24468         extern "system" {
24469             fn uset_addAll(set: *mut USet, additionalset: *const USet);
24470         }
24471         ::std::mem::transmute(uset_addAll(::std::mem::transmute(set), ::std::mem::transmute(additionalset)))
24472     }
24473     #[cfg(not(windows))]
24474     unimplemented!("Unsupported target OS");
24475 }
24476 #[inline]
uset_addAllCodePoints(set: *mut USet, str: *const u16, strlen: i32)24477 pub unsafe fn uset_addAllCodePoints(set: *mut USet, str: *const u16, strlen: i32) {
24478     #[cfg(windows)]
24479     {
24480         #[link(name = "windows")]
24481         extern "system" {
24482             fn uset_addAllCodePoints(set: *mut USet, str: *const u16, strlen: i32);
24483         }
24484         ::std::mem::transmute(uset_addAllCodePoints(::std::mem::transmute(set), ::std::mem::transmute(str), ::std::mem::transmute(strlen)))
24485     }
24486     #[cfg(not(windows))]
24487     unimplemented!("Unsupported target OS");
24488 }
24489 #[inline]
uset_addRange(set: *mut USet, start: i32, end: i32)24490 pub unsafe fn uset_addRange(set: *mut USet, start: i32, end: i32) {
24491     #[cfg(windows)]
24492     {
24493         #[link(name = "windows")]
24494         extern "system" {
24495             fn uset_addRange(set: *mut USet, start: i32, end: i32);
24496         }
24497         ::std::mem::transmute(uset_addRange(::std::mem::transmute(set), ::std::mem::transmute(start), ::std::mem::transmute(end)))
24498     }
24499     #[cfg(not(windows))]
24500     unimplemented!("Unsupported target OS");
24501 }
24502 #[inline]
uset_addString(set: *mut USet, str: *const u16, strlen: i32)24503 pub unsafe fn uset_addString(set: *mut USet, str: *const u16, strlen: i32) {
24504     #[cfg(windows)]
24505     {
24506         #[link(name = "windows")]
24507         extern "system" {
24508             fn uset_addString(set: *mut USet, str: *const u16, strlen: i32);
24509         }
24510         ::std::mem::transmute(uset_addString(::std::mem::transmute(set), ::std::mem::transmute(str), ::std::mem::transmute(strlen)))
24511     }
24512     #[cfg(not(windows))]
24513     unimplemented!("Unsupported target OS");
24514 }
24515 #[inline]
uset_applyIntPropertyValue(set: *mut USet, prop: UProperty, value: i32, ec: *mut UErrorCode)24516 pub unsafe fn uset_applyIntPropertyValue(set: *mut USet, prop: UProperty, value: i32, ec: *mut UErrorCode) {
24517     #[cfg(windows)]
24518     {
24519         #[link(name = "windows")]
24520         extern "system" {
24521             fn uset_applyIntPropertyValue(set: *mut USet, prop: UProperty, value: i32, ec: *mut UErrorCode);
24522         }
24523         ::std::mem::transmute(uset_applyIntPropertyValue(::std::mem::transmute(set), ::std::mem::transmute(prop), ::std::mem::transmute(value), ::std::mem::transmute(ec)))
24524     }
24525     #[cfg(not(windows))]
24526     unimplemented!("Unsupported target OS");
24527 }
24528 #[inline]
uset_applyPattern(set: *mut USet, pattern: *const u16, patternlength: i32, options: u32, status: *mut UErrorCode) -> i3224529 pub unsafe fn uset_applyPattern(set: *mut USet, pattern: *const u16, patternlength: i32, options: u32, status: *mut UErrorCode) -> i32 {
24530     #[cfg(windows)]
24531     {
24532         #[link(name = "windows")]
24533         extern "system" {
24534             fn uset_applyPattern(set: *mut USet, pattern: *const u16, patternlength: i32, options: u32, status: *mut UErrorCode) -> i32;
24535         }
24536         ::std::mem::transmute(uset_applyPattern(::std::mem::transmute(set), ::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(options), ::std::mem::transmute(status)))
24537     }
24538     #[cfg(not(windows))]
24539     unimplemented!("Unsupported target OS");
24540 }
24541 #[inline]
uset_applyPropertyAlias(set: *mut USet, prop: *const u16, proplength: i32, value: *const u16, valuelength: i32, ec: *mut UErrorCode)24542 pub unsafe fn uset_applyPropertyAlias(set: *mut USet, prop: *const u16, proplength: i32, value: *const u16, valuelength: i32, ec: *mut UErrorCode) {
24543     #[cfg(windows)]
24544     {
24545         #[link(name = "windows")]
24546         extern "system" {
24547             fn uset_applyPropertyAlias(set: *mut USet, prop: *const u16, proplength: i32, value: *const u16, valuelength: i32, ec: *mut UErrorCode);
24548         }
24549         ::std::mem::transmute(uset_applyPropertyAlias(::std::mem::transmute(set), ::std::mem::transmute(prop), ::std::mem::transmute(proplength), ::std::mem::transmute(value), ::std::mem::transmute(valuelength), ::std::mem::transmute(ec)))
24550     }
24551     #[cfg(not(windows))]
24552     unimplemented!("Unsupported target OS");
24553 }
24554 #[inline]
uset_charAt(set: *const USet, charindex: i32) -> i3224555 pub unsafe fn uset_charAt(set: *const USet, charindex: i32) -> i32 {
24556     #[cfg(windows)]
24557     {
24558         #[link(name = "windows")]
24559         extern "system" {
24560             fn uset_charAt(set: *const USet, charindex: i32) -> i32;
24561         }
24562         ::std::mem::transmute(uset_charAt(::std::mem::transmute(set), ::std::mem::transmute(charindex)))
24563     }
24564     #[cfg(not(windows))]
24565     unimplemented!("Unsupported target OS");
24566 }
24567 #[inline]
uset_clear(set: *mut USet)24568 pub unsafe fn uset_clear(set: *mut USet) {
24569     #[cfg(windows)]
24570     {
24571         #[link(name = "windows")]
24572         extern "system" {
24573             fn uset_clear(set: *mut USet);
24574         }
24575         ::std::mem::transmute(uset_clear(::std::mem::transmute(set)))
24576     }
24577     #[cfg(not(windows))]
24578     unimplemented!("Unsupported target OS");
24579 }
24580 #[inline]
uset_clone(set: *const USet) -> *mut USet24581 pub unsafe fn uset_clone(set: *const USet) -> *mut USet {
24582     #[cfg(windows)]
24583     {
24584         #[link(name = "windows")]
24585         extern "system" {
24586             fn uset_clone(set: *const USet) -> *mut USet;
24587         }
24588         ::std::mem::transmute(uset_clone(::std::mem::transmute(set)))
24589     }
24590     #[cfg(not(windows))]
24591     unimplemented!("Unsupported target OS");
24592 }
24593 #[inline]
uset_cloneAsThawed(set: *const USet) -> *mut USet24594 pub unsafe fn uset_cloneAsThawed(set: *const USet) -> *mut USet {
24595     #[cfg(windows)]
24596     {
24597         #[link(name = "windows")]
24598         extern "system" {
24599             fn uset_cloneAsThawed(set: *const USet) -> *mut USet;
24600         }
24601         ::std::mem::transmute(uset_cloneAsThawed(::std::mem::transmute(set)))
24602     }
24603     #[cfg(not(windows))]
24604     unimplemented!("Unsupported target OS");
24605 }
24606 #[inline]
uset_close(set: *mut USet)24607 pub unsafe fn uset_close(set: *mut USet) {
24608     #[cfg(windows)]
24609     {
24610         #[link(name = "windows")]
24611         extern "system" {
24612             fn uset_close(set: *mut USet);
24613         }
24614         ::std::mem::transmute(uset_close(::std::mem::transmute(set)))
24615     }
24616     #[cfg(not(windows))]
24617     unimplemented!("Unsupported target OS");
24618 }
24619 #[inline]
uset_closeOver(set: *mut USet, attributes: i32)24620 pub unsafe fn uset_closeOver(set: *mut USet, attributes: i32) {
24621     #[cfg(windows)]
24622     {
24623         #[link(name = "windows")]
24624         extern "system" {
24625             fn uset_closeOver(set: *mut USet, attributes: i32);
24626         }
24627         ::std::mem::transmute(uset_closeOver(::std::mem::transmute(set), ::std::mem::transmute(attributes)))
24628     }
24629     #[cfg(not(windows))]
24630     unimplemented!("Unsupported target OS");
24631 }
24632 #[inline]
uset_compact(set: *mut USet)24633 pub unsafe fn uset_compact(set: *mut USet) {
24634     #[cfg(windows)]
24635     {
24636         #[link(name = "windows")]
24637         extern "system" {
24638             fn uset_compact(set: *mut USet);
24639         }
24640         ::std::mem::transmute(uset_compact(::std::mem::transmute(set)))
24641     }
24642     #[cfg(not(windows))]
24643     unimplemented!("Unsupported target OS");
24644 }
24645 #[inline]
uset_complement(set: *mut USet)24646 pub unsafe fn uset_complement(set: *mut USet) {
24647     #[cfg(windows)]
24648     {
24649         #[link(name = "windows")]
24650         extern "system" {
24651             fn uset_complement(set: *mut USet);
24652         }
24653         ::std::mem::transmute(uset_complement(::std::mem::transmute(set)))
24654     }
24655     #[cfg(not(windows))]
24656     unimplemented!("Unsupported target OS");
24657 }
24658 #[inline]
uset_complementAll(set: *mut USet, complement: *const USet)24659 pub unsafe fn uset_complementAll(set: *mut USet, complement: *const USet) {
24660     #[cfg(windows)]
24661     {
24662         #[link(name = "windows")]
24663         extern "system" {
24664             fn uset_complementAll(set: *mut USet, complement: *const USet);
24665         }
24666         ::std::mem::transmute(uset_complementAll(::std::mem::transmute(set), ::std::mem::transmute(complement)))
24667     }
24668     #[cfg(not(windows))]
24669     unimplemented!("Unsupported target OS");
24670 }
24671 #[inline]
uset_contains(set: *const USet, c: i32) -> i824672 pub unsafe fn uset_contains(set: *const USet, c: i32) -> i8 {
24673     #[cfg(windows)]
24674     {
24675         #[link(name = "windows")]
24676         extern "system" {
24677             fn uset_contains(set: *const USet, c: i32) -> i8;
24678         }
24679         ::std::mem::transmute(uset_contains(::std::mem::transmute(set), ::std::mem::transmute(c)))
24680     }
24681     #[cfg(not(windows))]
24682     unimplemented!("Unsupported target OS");
24683 }
24684 #[inline]
uset_containsAll(set1: *const USet, set2: *const USet) -> i824685 pub unsafe fn uset_containsAll(set1: *const USet, set2: *const USet) -> i8 {
24686     #[cfg(windows)]
24687     {
24688         #[link(name = "windows")]
24689         extern "system" {
24690             fn uset_containsAll(set1: *const USet, set2: *const USet) -> i8;
24691         }
24692         ::std::mem::transmute(uset_containsAll(::std::mem::transmute(set1), ::std::mem::transmute(set2)))
24693     }
24694     #[cfg(not(windows))]
24695     unimplemented!("Unsupported target OS");
24696 }
24697 #[inline]
uset_containsAllCodePoints(set: *const USet, str: *const u16, strlen: i32) -> i824698 pub unsafe fn uset_containsAllCodePoints(set: *const USet, str: *const u16, strlen: i32) -> i8 {
24699     #[cfg(windows)]
24700     {
24701         #[link(name = "windows")]
24702         extern "system" {
24703             fn uset_containsAllCodePoints(set: *const USet, str: *const u16, strlen: i32) -> i8;
24704         }
24705         ::std::mem::transmute(uset_containsAllCodePoints(::std::mem::transmute(set), ::std::mem::transmute(str), ::std::mem::transmute(strlen)))
24706     }
24707     #[cfg(not(windows))]
24708     unimplemented!("Unsupported target OS");
24709 }
24710 #[inline]
uset_containsNone(set1: *const USet, set2: *const USet) -> i824711 pub unsafe fn uset_containsNone(set1: *const USet, set2: *const USet) -> i8 {
24712     #[cfg(windows)]
24713     {
24714         #[link(name = "windows")]
24715         extern "system" {
24716             fn uset_containsNone(set1: *const USet, set2: *const USet) -> i8;
24717         }
24718         ::std::mem::transmute(uset_containsNone(::std::mem::transmute(set1), ::std::mem::transmute(set2)))
24719     }
24720     #[cfg(not(windows))]
24721     unimplemented!("Unsupported target OS");
24722 }
24723 #[inline]
uset_containsRange(set: *const USet, start: i32, end: i32) -> i824724 pub unsafe fn uset_containsRange(set: *const USet, start: i32, end: i32) -> i8 {
24725     #[cfg(windows)]
24726     {
24727         #[link(name = "windows")]
24728         extern "system" {
24729             fn uset_containsRange(set: *const USet, start: i32, end: i32) -> i8;
24730         }
24731         ::std::mem::transmute(uset_containsRange(::std::mem::transmute(set), ::std::mem::transmute(start), ::std::mem::transmute(end)))
24732     }
24733     #[cfg(not(windows))]
24734     unimplemented!("Unsupported target OS");
24735 }
24736 #[inline]
uset_containsSome(set1: *const USet, set2: *const USet) -> i824737 pub unsafe fn uset_containsSome(set1: *const USet, set2: *const USet) -> i8 {
24738     #[cfg(windows)]
24739     {
24740         #[link(name = "windows")]
24741         extern "system" {
24742             fn uset_containsSome(set1: *const USet, set2: *const USet) -> i8;
24743         }
24744         ::std::mem::transmute(uset_containsSome(::std::mem::transmute(set1), ::std::mem::transmute(set2)))
24745     }
24746     #[cfg(not(windows))]
24747     unimplemented!("Unsupported target OS");
24748 }
24749 #[inline]
uset_containsString(set: *const USet, str: *const u16, strlen: i32) -> i824750 pub unsafe fn uset_containsString(set: *const USet, str: *const u16, strlen: i32) -> i8 {
24751     #[cfg(windows)]
24752     {
24753         #[link(name = "windows")]
24754         extern "system" {
24755             fn uset_containsString(set: *const USet, str: *const u16, strlen: i32) -> i8;
24756         }
24757         ::std::mem::transmute(uset_containsString(::std::mem::transmute(set), ::std::mem::transmute(str), ::std::mem::transmute(strlen)))
24758     }
24759     #[cfg(not(windows))]
24760     unimplemented!("Unsupported target OS");
24761 }
24762 #[inline]
uset_equals(set1: *const USet, set2: *const USet) -> i824763 pub unsafe fn uset_equals(set1: *const USet, set2: *const USet) -> i8 {
24764     #[cfg(windows)]
24765     {
24766         #[link(name = "windows")]
24767         extern "system" {
24768             fn uset_equals(set1: *const USet, set2: *const USet) -> i8;
24769         }
24770         ::std::mem::transmute(uset_equals(::std::mem::transmute(set1), ::std::mem::transmute(set2)))
24771     }
24772     #[cfg(not(windows))]
24773     unimplemented!("Unsupported target OS");
24774 }
24775 #[inline]
uset_freeze(set: *mut USet)24776 pub unsafe fn uset_freeze(set: *mut USet) {
24777     #[cfg(windows)]
24778     {
24779         #[link(name = "windows")]
24780         extern "system" {
24781             fn uset_freeze(set: *mut USet);
24782         }
24783         ::std::mem::transmute(uset_freeze(::std::mem::transmute(set)))
24784     }
24785     #[cfg(not(windows))]
24786     unimplemented!("Unsupported target OS");
24787 }
24788 #[inline]
uset_getItem(set: *const USet, itemindex: i32, start: *mut i32, end: *mut i32, str: *mut u16, strcapacity: i32, ec: *mut UErrorCode) -> i3224789 pub unsafe fn uset_getItem(set: *const USet, itemindex: i32, start: *mut i32, end: *mut i32, str: *mut u16, strcapacity: i32, ec: *mut UErrorCode) -> i32 {
24790     #[cfg(windows)]
24791     {
24792         #[link(name = "windows")]
24793         extern "system" {
24794             fn uset_getItem(set: *const USet, itemindex: i32, start: *mut i32, end: *mut i32, str: *mut u16, strcapacity: i32, ec: *mut UErrorCode) -> i32;
24795         }
24796         ::std::mem::transmute(uset_getItem(::std::mem::transmute(set), ::std::mem::transmute(itemindex), ::std::mem::transmute(start), ::std::mem::transmute(end), ::std::mem::transmute(str), ::std::mem::transmute(strcapacity), ::std::mem::transmute(ec)))
24797     }
24798     #[cfg(not(windows))]
24799     unimplemented!("Unsupported target OS");
24800 }
24801 #[inline]
uset_getItemCount(set: *const USet) -> i3224802 pub unsafe fn uset_getItemCount(set: *const USet) -> i32 {
24803     #[cfg(windows)]
24804     {
24805         #[link(name = "windows")]
24806         extern "system" {
24807             fn uset_getItemCount(set: *const USet) -> i32;
24808         }
24809         ::std::mem::transmute(uset_getItemCount(::std::mem::transmute(set)))
24810     }
24811     #[cfg(not(windows))]
24812     unimplemented!("Unsupported target OS");
24813 }
24814 #[inline]
uset_getSerializedRange(set: *const USerializedSet, rangeindex: i32, pstart: *mut i32, pend: *mut i32) -> i824815 pub unsafe fn uset_getSerializedRange(set: *const USerializedSet, rangeindex: i32, pstart: *mut i32, pend: *mut i32) -> i8 {
24816     #[cfg(windows)]
24817     {
24818         #[link(name = "windows")]
24819         extern "system" {
24820             fn uset_getSerializedRange(set: *const USerializedSet, rangeindex: i32, pstart: *mut i32, pend: *mut i32) -> i8;
24821         }
24822         ::std::mem::transmute(uset_getSerializedRange(::std::mem::transmute(set), ::std::mem::transmute(rangeindex), ::std::mem::transmute(pstart), ::std::mem::transmute(pend)))
24823     }
24824     #[cfg(not(windows))]
24825     unimplemented!("Unsupported target OS");
24826 }
24827 #[inline]
uset_getSerializedRangeCount(set: *const USerializedSet) -> i3224828 pub unsafe fn uset_getSerializedRangeCount(set: *const USerializedSet) -> i32 {
24829     #[cfg(windows)]
24830     {
24831         #[link(name = "windows")]
24832         extern "system" {
24833             fn uset_getSerializedRangeCount(set: *const USerializedSet) -> i32;
24834         }
24835         ::std::mem::transmute(uset_getSerializedRangeCount(::std::mem::transmute(set)))
24836     }
24837     #[cfg(not(windows))]
24838     unimplemented!("Unsupported target OS");
24839 }
24840 #[inline]
uset_getSerializedSet(fillset: *mut USerializedSet, src: *const u16, srclength: i32) -> i824841 pub unsafe fn uset_getSerializedSet(fillset: *mut USerializedSet, src: *const u16, srclength: i32) -> i8 {
24842     #[cfg(windows)]
24843     {
24844         #[link(name = "windows")]
24845         extern "system" {
24846             fn uset_getSerializedSet(fillset: *mut USerializedSet, src: *const u16, srclength: i32) -> i8;
24847         }
24848         ::std::mem::transmute(uset_getSerializedSet(::std::mem::transmute(fillset), ::std::mem::transmute(src), ::std::mem::transmute(srclength)))
24849     }
24850     #[cfg(not(windows))]
24851     unimplemented!("Unsupported target OS");
24852 }
24853 #[inline]
uset_indexOf(set: *const USet, c: i32) -> i3224854 pub unsafe fn uset_indexOf(set: *const USet, c: i32) -> i32 {
24855     #[cfg(windows)]
24856     {
24857         #[link(name = "windows")]
24858         extern "system" {
24859             fn uset_indexOf(set: *const USet, c: i32) -> i32;
24860         }
24861         ::std::mem::transmute(uset_indexOf(::std::mem::transmute(set), ::std::mem::transmute(c)))
24862     }
24863     #[cfg(not(windows))]
24864     unimplemented!("Unsupported target OS");
24865 }
24866 #[inline]
uset_isEmpty(set: *const USet) -> i824867 pub unsafe fn uset_isEmpty(set: *const USet) -> i8 {
24868     #[cfg(windows)]
24869     {
24870         #[link(name = "windows")]
24871         extern "system" {
24872             fn uset_isEmpty(set: *const USet) -> i8;
24873         }
24874         ::std::mem::transmute(uset_isEmpty(::std::mem::transmute(set)))
24875     }
24876     #[cfg(not(windows))]
24877     unimplemented!("Unsupported target OS");
24878 }
24879 #[inline]
uset_isFrozen(set: *const USet) -> i824880 pub unsafe fn uset_isFrozen(set: *const USet) -> i8 {
24881     #[cfg(windows)]
24882     {
24883         #[link(name = "windows")]
24884         extern "system" {
24885             fn uset_isFrozen(set: *const USet) -> i8;
24886         }
24887         ::std::mem::transmute(uset_isFrozen(::std::mem::transmute(set)))
24888     }
24889     #[cfg(not(windows))]
24890     unimplemented!("Unsupported target OS");
24891 }
24892 #[inline]
uset_open(start: i32, end: i32) -> *mut USet24893 pub unsafe fn uset_open(start: i32, end: i32) -> *mut USet {
24894     #[cfg(windows)]
24895     {
24896         #[link(name = "windows")]
24897         extern "system" {
24898             fn uset_open(start: i32, end: i32) -> *mut USet;
24899         }
24900         ::std::mem::transmute(uset_open(::std::mem::transmute(start), ::std::mem::transmute(end)))
24901     }
24902     #[cfg(not(windows))]
24903     unimplemented!("Unsupported target OS");
24904 }
24905 #[inline]
uset_openEmpty() -> *mut USet24906 pub unsafe fn uset_openEmpty() -> *mut USet {
24907     #[cfg(windows)]
24908     {
24909         #[link(name = "windows")]
24910         extern "system" {
24911             fn uset_openEmpty() -> *mut USet;
24912         }
24913         ::std::mem::transmute(uset_openEmpty())
24914     }
24915     #[cfg(not(windows))]
24916     unimplemented!("Unsupported target OS");
24917 }
24918 #[inline]
uset_openPattern(pattern: *const u16, patternlength: i32, ec: *mut UErrorCode) -> *mut USet24919 pub unsafe fn uset_openPattern(pattern: *const u16, patternlength: i32, ec: *mut UErrorCode) -> *mut USet {
24920     #[cfg(windows)]
24921     {
24922         #[link(name = "windows")]
24923         extern "system" {
24924             fn uset_openPattern(pattern: *const u16, patternlength: i32, ec: *mut UErrorCode) -> *mut USet;
24925         }
24926         ::std::mem::transmute(uset_openPattern(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(ec)))
24927     }
24928     #[cfg(not(windows))]
24929     unimplemented!("Unsupported target OS");
24930 }
24931 #[inline]
uset_openPatternOptions(pattern: *const u16, patternlength: i32, options: u32, ec: *mut UErrorCode) -> *mut USet24932 pub unsafe fn uset_openPatternOptions(pattern: *const u16, patternlength: i32, options: u32, ec: *mut UErrorCode) -> *mut USet {
24933     #[cfg(windows)]
24934     {
24935         #[link(name = "windows")]
24936         extern "system" {
24937             fn uset_openPatternOptions(pattern: *const u16, patternlength: i32, options: u32, ec: *mut UErrorCode) -> *mut USet;
24938         }
24939         ::std::mem::transmute(uset_openPatternOptions(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(options), ::std::mem::transmute(ec)))
24940     }
24941     #[cfg(not(windows))]
24942     unimplemented!("Unsupported target OS");
24943 }
24944 #[inline]
uset_remove(set: *mut USet, c: i32)24945 pub unsafe fn uset_remove(set: *mut USet, c: i32) {
24946     #[cfg(windows)]
24947     {
24948         #[link(name = "windows")]
24949         extern "system" {
24950             fn uset_remove(set: *mut USet, c: i32);
24951         }
24952         ::std::mem::transmute(uset_remove(::std::mem::transmute(set), ::std::mem::transmute(c)))
24953     }
24954     #[cfg(not(windows))]
24955     unimplemented!("Unsupported target OS");
24956 }
24957 #[inline]
uset_removeAll(set: *mut USet, removeset: *const USet)24958 pub unsafe fn uset_removeAll(set: *mut USet, removeset: *const USet) {
24959     #[cfg(windows)]
24960     {
24961         #[link(name = "windows")]
24962         extern "system" {
24963             fn uset_removeAll(set: *mut USet, removeset: *const USet);
24964         }
24965         ::std::mem::transmute(uset_removeAll(::std::mem::transmute(set), ::std::mem::transmute(removeset)))
24966     }
24967     #[cfg(not(windows))]
24968     unimplemented!("Unsupported target OS");
24969 }
24970 #[inline]
uset_removeAllStrings(set: *mut USet)24971 pub unsafe fn uset_removeAllStrings(set: *mut USet) {
24972     #[cfg(windows)]
24973     {
24974         #[link(name = "windows")]
24975         extern "system" {
24976             fn uset_removeAllStrings(set: *mut USet);
24977         }
24978         ::std::mem::transmute(uset_removeAllStrings(::std::mem::transmute(set)))
24979     }
24980     #[cfg(not(windows))]
24981     unimplemented!("Unsupported target OS");
24982 }
24983 #[inline]
uset_removeRange(set: *mut USet, start: i32, end: i32)24984 pub unsafe fn uset_removeRange(set: *mut USet, start: i32, end: i32) {
24985     #[cfg(windows)]
24986     {
24987         #[link(name = "windows")]
24988         extern "system" {
24989             fn uset_removeRange(set: *mut USet, start: i32, end: i32);
24990         }
24991         ::std::mem::transmute(uset_removeRange(::std::mem::transmute(set), ::std::mem::transmute(start), ::std::mem::transmute(end)))
24992     }
24993     #[cfg(not(windows))]
24994     unimplemented!("Unsupported target OS");
24995 }
24996 #[inline]
uset_removeString(set: *mut USet, str: *const u16, strlen: i32)24997 pub unsafe fn uset_removeString(set: *mut USet, str: *const u16, strlen: i32) {
24998     #[cfg(windows)]
24999     {
25000         #[link(name = "windows")]
25001         extern "system" {
25002             fn uset_removeString(set: *mut USet, str: *const u16, strlen: i32);
25003         }
25004         ::std::mem::transmute(uset_removeString(::std::mem::transmute(set), ::std::mem::transmute(str), ::std::mem::transmute(strlen)))
25005     }
25006     #[cfg(not(windows))]
25007     unimplemented!("Unsupported target OS");
25008 }
25009 #[inline]
uset_resemblesPattern(pattern: *const u16, patternlength: i32, pos: i32) -> i825010 pub unsafe fn uset_resemblesPattern(pattern: *const u16, patternlength: i32, pos: i32) -> i8 {
25011     #[cfg(windows)]
25012     {
25013         #[link(name = "windows")]
25014         extern "system" {
25015             fn uset_resemblesPattern(pattern: *const u16, patternlength: i32, pos: i32) -> i8;
25016         }
25017         ::std::mem::transmute(uset_resemblesPattern(::std::mem::transmute(pattern), ::std::mem::transmute(patternlength), ::std::mem::transmute(pos)))
25018     }
25019     #[cfg(not(windows))]
25020     unimplemented!("Unsupported target OS");
25021 }
25022 #[inline]
uset_retain(set: *mut USet, start: i32, end: i32)25023 pub unsafe fn uset_retain(set: *mut USet, start: i32, end: i32) {
25024     #[cfg(windows)]
25025     {
25026         #[link(name = "windows")]
25027         extern "system" {
25028             fn uset_retain(set: *mut USet, start: i32, end: i32);
25029         }
25030         ::std::mem::transmute(uset_retain(::std::mem::transmute(set), ::std::mem::transmute(start), ::std::mem::transmute(end)))
25031     }
25032     #[cfg(not(windows))]
25033     unimplemented!("Unsupported target OS");
25034 }
25035 #[inline]
uset_retainAll(set: *mut USet, retain: *const USet)25036 pub unsafe fn uset_retainAll(set: *mut USet, retain: *const USet) {
25037     #[cfg(windows)]
25038     {
25039         #[link(name = "windows")]
25040         extern "system" {
25041             fn uset_retainAll(set: *mut USet, retain: *const USet);
25042         }
25043         ::std::mem::transmute(uset_retainAll(::std::mem::transmute(set), ::std::mem::transmute(retain)))
25044     }
25045     #[cfg(not(windows))]
25046     unimplemented!("Unsupported target OS");
25047 }
25048 #[inline]
uset_serialize(set: *const USet, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i3225049 pub unsafe fn uset_serialize(set: *const USet, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32 {
25050     #[cfg(windows)]
25051     {
25052         #[link(name = "windows")]
25053         extern "system" {
25054             fn uset_serialize(set: *const USet, dest: *mut u16, destcapacity: i32, perrorcode: *mut UErrorCode) -> i32;
25055         }
25056         ::std::mem::transmute(uset_serialize(::std::mem::transmute(set), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(perrorcode)))
25057     }
25058     #[cfg(not(windows))]
25059     unimplemented!("Unsupported target OS");
25060 }
25061 #[inline]
uset_serializedContains(set: *const USerializedSet, c: i32) -> i825062 pub unsafe fn uset_serializedContains(set: *const USerializedSet, c: i32) -> i8 {
25063     #[cfg(windows)]
25064     {
25065         #[link(name = "windows")]
25066         extern "system" {
25067             fn uset_serializedContains(set: *const USerializedSet, c: i32) -> i8;
25068         }
25069         ::std::mem::transmute(uset_serializedContains(::std::mem::transmute(set), ::std::mem::transmute(c)))
25070     }
25071     #[cfg(not(windows))]
25072     unimplemented!("Unsupported target OS");
25073 }
25074 #[inline]
uset_set(set: *mut USet, start: i32, end: i32)25075 pub unsafe fn uset_set(set: *mut USet, start: i32, end: i32) {
25076     #[cfg(windows)]
25077     {
25078         #[link(name = "windows")]
25079         extern "system" {
25080             fn uset_set(set: *mut USet, start: i32, end: i32);
25081         }
25082         ::std::mem::transmute(uset_set(::std::mem::transmute(set), ::std::mem::transmute(start), ::std::mem::transmute(end)))
25083     }
25084     #[cfg(not(windows))]
25085     unimplemented!("Unsupported target OS");
25086 }
25087 #[inline]
uset_setSerializedToOne(fillset: *mut USerializedSet, c: i32)25088 pub unsafe fn uset_setSerializedToOne(fillset: *mut USerializedSet, c: i32) {
25089     #[cfg(windows)]
25090     {
25091         #[link(name = "windows")]
25092         extern "system" {
25093             fn uset_setSerializedToOne(fillset: *mut USerializedSet, c: i32);
25094         }
25095         ::std::mem::transmute(uset_setSerializedToOne(::std::mem::transmute(fillset), ::std::mem::transmute(c)))
25096     }
25097     #[cfg(not(windows))]
25098     unimplemented!("Unsupported target OS");
25099 }
25100 #[inline]
uset_size(set: *const USet) -> i3225101 pub unsafe fn uset_size(set: *const USet) -> i32 {
25102     #[cfg(windows)]
25103     {
25104         #[link(name = "windows")]
25105         extern "system" {
25106             fn uset_size(set: *const USet) -> i32;
25107         }
25108         ::std::mem::transmute(uset_size(::std::mem::transmute(set)))
25109     }
25110     #[cfg(not(windows))]
25111     unimplemented!("Unsupported target OS");
25112 }
25113 #[inline]
uset_span(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i3225114 pub unsafe fn uset_span(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i32 {
25115     #[cfg(windows)]
25116     {
25117         #[link(name = "windows")]
25118         extern "system" {
25119             fn uset_span(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i32;
25120         }
25121         ::std::mem::transmute(uset_span(::std::mem::transmute(set), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(spancondition)))
25122     }
25123     #[cfg(not(windows))]
25124     unimplemented!("Unsupported target OS");
25125 }
25126 #[inline]
uset_spanBack(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i3225127 pub unsafe fn uset_spanBack(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i32 {
25128     #[cfg(windows)]
25129     {
25130         #[link(name = "windows")]
25131         extern "system" {
25132             fn uset_spanBack(set: *const USet, s: *const u16, length: i32, spancondition: USetSpanCondition) -> i32;
25133         }
25134         ::std::mem::transmute(uset_spanBack(::std::mem::transmute(set), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(spancondition)))
25135     }
25136     #[cfg(not(windows))]
25137     unimplemented!("Unsupported target OS");
25138 }
25139 #[cfg(feature = "Win32_Foundation")]
25140 #[inline]
uset_spanBackUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(set: *const USet, s: Param1, length: i32, spancondition: USetSpanCondition) -> i3225141 pub unsafe fn uset_spanBackUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(set: *const USet, s: Param1, length: i32, spancondition: USetSpanCondition) -> i32 {
25142     #[cfg(windows)]
25143     {
25144         #[link(name = "windows")]
25145         extern "system" {
25146             fn uset_spanBackUTF8(set: *const USet, s: super::Foundation::PSTR, length: i32, spancondition: USetSpanCondition) -> i32;
25147         }
25148         ::std::mem::transmute(uset_spanBackUTF8(::std::mem::transmute(set), s.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(spancondition)))
25149     }
25150     #[cfg(not(windows))]
25151     unimplemented!("Unsupported target OS");
25152 }
25153 #[cfg(feature = "Win32_Foundation")]
25154 #[inline]
uset_spanUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(set: *const USet, s: Param1, length: i32, spancondition: USetSpanCondition) -> i3225155 pub unsafe fn uset_spanUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(set: *const USet, s: Param1, length: i32, spancondition: USetSpanCondition) -> i32 {
25156     #[cfg(windows)]
25157     {
25158         #[link(name = "windows")]
25159         extern "system" {
25160             fn uset_spanUTF8(set: *const USet, s: super::Foundation::PSTR, length: i32, spancondition: USetSpanCondition) -> i32;
25161         }
25162         ::std::mem::transmute(uset_spanUTF8(::std::mem::transmute(set), s.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(spancondition)))
25163     }
25164     #[cfg(not(windows))]
25165     unimplemented!("Unsupported target OS");
25166 }
25167 #[inline]
uset_toPattern(set: *const USet, result: *mut u16, resultcapacity: i32, escapeunprintable: i8, ec: *mut UErrorCode) -> i3225168 pub unsafe fn uset_toPattern(set: *const USet, result: *mut u16, resultcapacity: i32, escapeunprintable: i8, ec: *mut UErrorCode) -> i32 {
25169     #[cfg(windows)]
25170     {
25171         #[link(name = "windows")]
25172         extern "system" {
25173             fn uset_toPattern(set: *const USet, result: *mut u16, resultcapacity: i32, escapeunprintable: i8, ec: *mut UErrorCode) -> i32;
25174         }
25175         ::std::mem::transmute(uset_toPattern(::std::mem::transmute(set), ::std::mem::transmute(result), ::std::mem::transmute(resultcapacity), ::std::mem::transmute(escapeunprintable), ::std::mem::transmute(ec)))
25176     }
25177     #[cfg(not(windows))]
25178     unimplemented!("Unsupported target OS");
25179 }
25180 #[inline]
uspoof_areConfusable(sc: *const USpoofChecker, id1: *const u16, length1: i32, id2: *const u16, length2: i32, status: *mut UErrorCode) -> i3225181 pub unsafe fn uspoof_areConfusable(sc: *const USpoofChecker, id1: *const u16, length1: i32, id2: *const u16, length2: i32, status: *mut UErrorCode) -> i32 {
25182     #[cfg(windows)]
25183     {
25184         #[link(name = "windows")]
25185         extern "system" {
25186             fn uspoof_areConfusable(sc: *const USpoofChecker, id1: *const u16, length1: i32, id2: *const u16, length2: i32, status: *mut UErrorCode) -> i32;
25187         }
25188         ::std::mem::transmute(uspoof_areConfusable(::std::mem::transmute(sc), ::std::mem::transmute(id1), ::std::mem::transmute(length1), ::std::mem::transmute(id2), ::std::mem::transmute(length2), ::std::mem::transmute(status)))
25189     }
25190     #[cfg(not(windows))]
25191     unimplemented!("Unsupported target OS");
25192 }
25193 #[cfg(feature = "Win32_Foundation")]
25194 #[inline]
uspoof_areConfusableUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id1: Param1, length1: i32, id2: Param3, length2: i32, status: *mut UErrorCode) -> i3225195 pub unsafe fn uspoof_areConfusableUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id1: Param1, length1: i32, id2: Param3, length2: i32, status: *mut UErrorCode) -> i32 {
25196     #[cfg(windows)]
25197     {
25198         #[link(name = "windows")]
25199         extern "system" {
25200             fn uspoof_areConfusableUTF8(sc: *const USpoofChecker, id1: super::Foundation::PSTR, length1: i32, id2: super::Foundation::PSTR, length2: i32, status: *mut UErrorCode) -> i32;
25201         }
25202         ::std::mem::transmute(uspoof_areConfusableUTF8(::std::mem::transmute(sc), id1.into_param().abi(), ::std::mem::transmute(length1), id2.into_param().abi(), ::std::mem::transmute(length2), ::std::mem::transmute(status)))
25203     }
25204     #[cfg(not(windows))]
25205     unimplemented!("Unsupported target OS");
25206 }
25207 #[inline]
uspoof_check(sc: *const USpoofChecker, id: *const u16, length: i32, position: *mut i32, status: *mut UErrorCode) -> i3225208 pub unsafe fn uspoof_check(sc: *const USpoofChecker, id: *const u16, length: i32, position: *mut i32, status: *mut UErrorCode) -> i32 {
25209     #[cfg(windows)]
25210     {
25211         #[link(name = "windows")]
25212         extern "system" {
25213             fn uspoof_check(sc: *const USpoofChecker, id: *const u16, length: i32, position: *mut i32, status: *mut UErrorCode) -> i32;
25214         }
25215         ::std::mem::transmute(uspoof_check(::std::mem::transmute(sc), ::std::mem::transmute(id), ::std::mem::transmute(length), ::std::mem::transmute(position), ::std::mem::transmute(status)))
25216     }
25217     #[cfg(not(windows))]
25218     unimplemented!("Unsupported target OS");
25219 }
25220 #[inline]
uspoof_check2(sc: *const USpoofChecker, id: *const u16, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i3225221 pub unsafe fn uspoof_check2(sc: *const USpoofChecker, id: *const u16, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i32 {
25222     #[cfg(windows)]
25223     {
25224         #[link(name = "windows")]
25225         extern "system" {
25226             fn uspoof_check2(sc: *const USpoofChecker, id: *const u16, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i32;
25227         }
25228         ::std::mem::transmute(uspoof_check2(::std::mem::transmute(sc), ::std::mem::transmute(id), ::std::mem::transmute(length), ::std::mem::transmute(checkresult), ::std::mem::transmute(status)))
25229     }
25230     #[cfg(not(windows))]
25231     unimplemented!("Unsupported target OS");
25232 }
25233 #[cfg(feature = "Win32_Foundation")]
25234 #[inline]
uspoof_check2UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id: Param1, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i3225235 pub unsafe fn uspoof_check2UTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id: Param1, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i32 {
25236     #[cfg(windows)]
25237     {
25238         #[link(name = "windows")]
25239         extern "system" {
25240             fn uspoof_check2UTF8(sc: *const USpoofChecker, id: super::Foundation::PSTR, length: i32, checkresult: *mut USpoofCheckResult, status: *mut UErrorCode) -> i32;
25241         }
25242         ::std::mem::transmute(uspoof_check2UTF8(::std::mem::transmute(sc), id.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(checkresult), ::std::mem::transmute(status)))
25243     }
25244     #[cfg(not(windows))]
25245     unimplemented!("Unsupported target OS");
25246 }
25247 #[cfg(feature = "Win32_Foundation")]
25248 #[inline]
uspoof_checkUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id: Param1, length: i32, position: *mut i32, status: *mut UErrorCode) -> i3225249 pub unsafe fn uspoof_checkUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, id: Param1, length: i32, position: *mut i32, status: *mut UErrorCode) -> i32 {
25250     #[cfg(windows)]
25251     {
25252         #[link(name = "windows")]
25253         extern "system" {
25254             fn uspoof_checkUTF8(sc: *const USpoofChecker, id: super::Foundation::PSTR, length: i32, position: *mut i32, status: *mut UErrorCode) -> i32;
25255         }
25256         ::std::mem::transmute(uspoof_checkUTF8(::std::mem::transmute(sc), id.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(position), ::std::mem::transmute(status)))
25257     }
25258     #[cfg(not(windows))]
25259     unimplemented!("Unsupported target OS");
25260 }
25261 #[inline]
uspoof_clone(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USpoofChecker25262 pub unsafe fn uspoof_clone(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USpoofChecker {
25263     #[cfg(windows)]
25264     {
25265         #[link(name = "windows")]
25266         extern "system" {
25267             fn uspoof_clone(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USpoofChecker;
25268         }
25269         ::std::mem::transmute(uspoof_clone(::std::mem::transmute(sc), ::std::mem::transmute(status)))
25270     }
25271     #[cfg(not(windows))]
25272     unimplemented!("Unsupported target OS");
25273 }
25274 #[inline]
uspoof_close(sc: *mut USpoofChecker)25275 pub unsafe fn uspoof_close(sc: *mut USpoofChecker) {
25276     #[cfg(windows)]
25277     {
25278         #[link(name = "windows")]
25279         extern "system" {
25280             fn uspoof_close(sc: *mut USpoofChecker);
25281         }
25282         ::std::mem::transmute(uspoof_close(::std::mem::transmute(sc)))
25283     }
25284     #[cfg(not(windows))]
25285     unimplemented!("Unsupported target OS");
25286 }
25287 #[inline]
uspoof_closeCheckResult(checkresult: *mut USpoofCheckResult)25288 pub unsafe fn uspoof_closeCheckResult(checkresult: *mut USpoofCheckResult) {
25289     #[cfg(windows)]
25290     {
25291         #[link(name = "windows")]
25292         extern "system" {
25293             fn uspoof_closeCheckResult(checkresult: *mut USpoofCheckResult);
25294         }
25295         ::std::mem::transmute(uspoof_closeCheckResult(::std::mem::transmute(checkresult)))
25296     }
25297     #[cfg(not(windows))]
25298     unimplemented!("Unsupported target OS");
25299 }
25300 #[inline]
uspoof_getAllowedChars(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USet25301 pub unsafe fn uspoof_getAllowedChars(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USet {
25302     #[cfg(windows)]
25303     {
25304         #[link(name = "windows")]
25305         extern "system" {
25306             fn uspoof_getAllowedChars(sc: *const USpoofChecker, status: *mut UErrorCode) -> *mut USet;
25307         }
25308         ::std::mem::transmute(uspoof_getAllowedChars(::std::mem::transmute(sc), ::std::mem::transmute(status)))
25309     }
25310     #[cfg(not(windows))]
25311     unimplemented!("Unsupported target OS");
25312 }
25313 #[cfg(feature = "Win32_Foundation")]
25314 #[inline]
uspoof_getAllowedLocales(sc: *mut USpoofChecker, status: *mut UErrorCode) -> super::Foundation::PSTR25315 pub unsafe fn uspoof_getAllowedLocales(sc: *mut USpoofChecker, status: *mut UErrorCode) -> super::Foundation::PSTR {
25316     #[cfg(windows)]
25317     {
25318         #[link(name = "windows")]
25319         extern "system" {
25320             fn uspoof_getAllowedLocales(sc: *mut USpoofChecker, status: *mut UErrorCode) -> super::Foundation::PSTR;
25321         }
25322         ::std::mem::transmute(uspoof_getAllowedLocales(::std::mem::transmute(sc), ::std::mem::transmute(status)))
25323     }
25324     #[cfg(not(windows))]
25325     unimplemented!("Unsupported target OS");
25326 }
25327 #[inline]
uspoof_getCheckResultChecks(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> i3225328 pub unsafe fn uspoof_getCheckResultChecks(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> i32 {
25329     #[cfg(windows)]
25330     {
25331         #[link(name = "windows")]
25332         extern "system" {
25333             fn uspoof_getCheckResultChecks(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> i32;
25334         }
25335         ::std::mem::transmute(uspoof_getCheckResultChecks(::std::mem::transmute(checkresult), ::std::mem::transmute(status)))
25336     }
25337     #[cfg(not(windows))]
25338     unimplemented!("Unsupported target OS");
25339 }
25340 #[inline]
uspoof_getCheckResultNumerics(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> *mut USet25341 pub unsafe fn uspoof_getCheckResultNumerics(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> *mut USet {
25342     #[cfg(windows)]
25343     {
25344         #[link(name = "windows")]
25345         extern "system" {
25346             fn uspoof_getCheckResultNumerics(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> *mut USet;
25347         }
25348         ::std::mem::transmute(uspoof_getCheckResultNumerics(::std::mem::transmute(checkresult), ::std::mem::transmute(status)))
25349     }
25350     #[cfg(not(windows))]
25351     unimplemented!("Unsupported target OS");
25352 }
25353 #[inline]
uspoof_getCheckResultRestrictionLevel(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> URestrictionLevel25354 pub unsafe fn uspoof_getCheckResultRestrictionLevel(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> URestrictionLevel {
25355     #[cfg(windows)]
25356     {
25357         #[link(name = "windows")]
25358         extern "system" {
25359             fn uspoof_getCheckResultRestrictionLevel(checkresult: *const USpoofCheckResult, status: *mut UErrorCode) -> URestrictionLevel;
25360         }
25361         ::std::mem::transmute(uspoof_getCheckResultRestrictionLevel(::std::mem::transmute(checkresult), ::std::mem::transmute(status)))
25362     }
25363     #[cfg(not(windows))]
25364     unimplemented!("Unsupported target OS");
25365 }
25366 #[inline]
uspoof_getChecks(sc: *const USpoofChecker, status: *mut UErrorCode) -> i3225367 pub unsafe fn uspoof_getChecks(sc: *const USpoofChecker, status: *mut UErrorCode) -> i32 {
25368     #[cfg(windows)]
25369     {
25370         #[link(name = "windows")]
25371         extern "system" {
25372             fn uspoof_getChecks(sc: *const USpoofChecker, status: *mut UErrorCode) -> i32;
25373         }
25374         ::std::mem::transmute(uspoof_getChecks(::std::mem::transmute(sc), ::std::mem::transmute(status)))
25375     }
25376     #[cfg(not(windows))]
25377     unimplemented!("Unsupported target OS");
25378 }
25379 #[inline]
uspoof_getInclusionSet(status: *mut UErrorCode) -> *mut USet25380 pub unsafe fn uspoof_getInclusionSet(status: *mut UErrorCode) -> *mut USet {
25381     #[cfg(windows)]
25382     {
25383         #[link(name = "windows")]
25384         extern "system" {
25385             fn uspoof_getInclusionSet(status: *mut UErrorCode) -> *mut USet;
25386         }
25387         ::std::mem::transmute(uspoof_getInclusionSet(::std::mem::transmute(status)))
25388     }
25389     #[cfg(not(windows))]
25390     unimplemented!("Unsupported target OS");
25391 }
25392 #[inline]
uspoof_getRecommendedSet(status: *mut UErrorCode) -> *mut USet25393 pub unsafe fn uspoof_getRecommendedSet(status: *mut UErrorCode) -> *mut USet {
25394     #[cfg(windows)]
25395     {
25396         #[link(name = "windows")]
25397         extern "system" {
25398             fn uspoof_getRecommendedSet(status: *mut UErrorCode) -> *mut USet;
25399         }
25400         ::std::mem::transmute(uspoof_getRecommendedSet(::std::mem::transmute(status)))
25401     }
25402     #[cfg(not(windows))]
25403     unimplemented!("Unsupported target OS");
25404 }
25405 #[inline]
uspoof_getRestrictionLevel(sc: *const USpoofChecker) -> URestrictionLevel25406 pub unsafe fn uspoof_getRestrictionLevel(sc: *const USpoofChecker) -> URestrictionLevel {
25407     #[cfg(windows)]
25408     {
25409         #[link(name = "windows")]
25410         extern "system" {
25411             fn uspoof_getRestrictionLevel(sc: *const USpoofChecker) -> URestrictionLevel;
25412         }
25413         ::std::mem::transmute(uspoof_getRestrictionLevel(::std::mem::transmute(sc)))
25414     }
25415     #[cfg(not(windows))]
25416     unimplemented!("Unsupported target OS");
25417 }
25418 #[inline]
uspoof_getSkeleton(sc: *const USpoofChecker, r#type: u32, id: *const u16, length: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3225419 pub unsafe fn uspoof_getSkeleton(sc: *const USpoofChecker, r#type: u32, id: *const u16, length: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
25420     #[cfg(windows)]
25421     {
25422         #[link(name = "windows")]
25423         extern "system" {
25424             fn uspoof_getSkeleton(sc: *const USpoofChecker, r#type: u32, id: *const u16, length: i32, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
25425         }
25426         ::std::mem::transmute(uspoof_getSkeleton(::std::mem::transmute(sc), ::std::mem::transmute(r#type), ::std::mem::transmute(id), ::std::mem::transmute(length), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
25427     }
25428     #[cfg(not(windows))]
25429     unimplemented!("Unsupported target OS");
25430 }
25431 #[cfg(feature = "Win32_Foundation")]
25432 #[inline]
uspoof_getSkeletonUTF8<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, r#type: u32, id: Param2, length: i32, dest: Param4, destcapacity: i32, status: *mut UErrorCode) -> i3225433 pub unsafe fn uspoof_getSkeletonUTF8<'a, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param4: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *const USpoofChecker, r#type: u32, id: Param2, length: i32, dest: Param4, destcapacity: i32, status: *mut UErrorCode) -> i32 {
25434     #[cfg(windows)]
25435     {
25436         #[link(name = "windows")]
25437         extern "system" {
25438             fn uspoof_getSkeletonUTF8(sc: *const USpoofChecker, r#type: u32, id: super::Foundation::PSTR, length: i32, dest: super::Foundation::PSTR, destcapacity: i32, status: *mut UErrorCode) -> i32;
25439         }
25440         ::std::mem::transmute(uspoof_getSkeletonUTF8(::std::mem::transmute(sc), ::std::mem::transmute(r#type), id.into_param().abi(), ::std::mem::transmute(length), dest.into_param().abi(), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
25441     }
25442     #[cfg(not(windows))]
25443     unimplemented!("Unsupported target OS");
25444 }
25445 #[inline]
uspoof_open(status: *mut UErrorCode) -> *mut USpoofChecker25446 pub unsafe fn uspoof_open(status: *mut UErrorCode) -> *mut USpoofChecker {
25447     #[cfg(windows)]
25448     {
25449         #[link(name = "windows")]
25450         extern "system" {
25451             fn uspoof_open(status: *mut UErrorCode) -> *mut USpoofChecker;
25452         }
25453         ::std::mem::transmute(uspoof_open(::std::mem::transmute(status)))
25454     }
25455     #[cfg(not(windows))]
25456     unimplemented!("Unsupported target OS");
25457 }
25458 #[inline]
uspoof_openCheckResult(status: *mut UErrorCode) -> *mut USpoofCheckResult25459 pub unsafe fn uspoof_openCheckResult(status: *mut UErrorCode) -> *mut USpoofCheckResult {
25460     #[cfg(windows)]
25461     {
25462         #[link(name = "windows")]
25463         extern "system" {
25464             fn uspoof_openCheckResult(status: *mut UErrorCode) -> *mut USpoofCheckResult;
25465         }
25466         ::std::mem::transmute(uspoof_openCheckResult(::std::mem::transmute(status)))
25467     }
25468     #[cfg(not(windows))]
25469     unimplemented!("Unsupported target OS");
25470 }
25471 #[inline]
uspoof_openFromSerialized(data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut USpoofChecker25472 pub unsafe fn uspoof_openFromSerialized(data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut USpoofChecker {
25473     #[cfg(windows)]
25474     {
25475         #[link(name = "windows")]
25476         extern "system" {
25477             fn uspoof_openFromSerialized(data: *const ::std::ffi::c_void, length: i32, pactuallength: *mut i32, perrorcode: *mut UErrorCode) -> *mut USpoofChecker;
25478         }
25479         ::std::mem::transmute(uspoof_openFromSerialized(::std::mem::transmute(data), ::std::mem::transmute(length), ::std::mem::transmute(pactuallength), ::std::mem::transmute(perrorcode)))
25480     }
25481     #[cfg(not(windows))]
25482     unimplemented!("Unsupported target OS");
25483 }
25484 #[cfg(feature = "Win32_Foundation")]
25485 #[inline]
uspoof_openFromSource<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(confusables: Param0, confusableslen: i32, confusableswholescript: Param2, confusableswholescriptlen: i32, errtype: *mut i32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut USpoofChecker25486 pub unsafe fn uspoof_openFromSource<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param2: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(confusables: Param0, confusableslen: i32, confusableswholescript: Param2, confusableswholescriptlen: i32, errtype: *mut i32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut USpoofChecker {
25487     #[cfg(windows)]
25488     {
25489         #[link(name = "windows")]
25490         extern "system" {
25491             fn uspoof_openFromSource(confusables: super::Foundation::PSTR, confusableslen: i32, confusableswholescript: super::Foundation::PSTR, confusableswholescriptlen: i32, errtype: *mut i32, pe: *mut UParseError, status: *mut UErrorCode) -> *mut USpoofChecker;
25492         }
25493         ::std::mem::transmute(uspoof_openFromSource(confusables.into_param().abi(), ::std::mem::transmute(confusableslen), confusableswholescript.into_param().abi(), ::std::mem::transmute(confusableswholescriptlen), ::std::mem::transmute(errtype), ::std::mem::transmute(pe), ::std::mem::transmute(status)))
25494     }
25495     #[cfg(not(windows))]
25496     unimplemented!("Unsupported target OS");
25497 }
25498 #[inline]
uspoof_serialize(sc: *mut USpoofChecker, data: *mut ::std::ffi::c_void, capacity: i32, status: *mut UErrorCode) -> i3225499 pub unsafe fn uspoof_serialize(sc: *mut USpoofChecker, data: *mut ::std::ffi::c_void, capacity: i32, status: *mut UErrorCode) -> i32 {
25500     #[cfg(windows)]
25501     {
25502         #[link(name = "windows")]
25503         extern "system" {
25504             fn uspoof_serialize(sc: *mut USpoofChecker, data: *mut ::std::ffi::c_void, capacity: i32, status: *mut UErrorCode) -> i32;
25505         }
25506         ::std::mem::transmute(uspoof_serialize(::std::mem::transmute(sc), ::std::mem::transmute(data), ::std::mem::transmute(capacity), ::std::mem::transmute(status)))
25507     }
25508     #[cfg(not(windows))]
25509     unimplemented!("Unsupported target OS");
25510 }
25511 #[inline]
uspoof_setAllowedChars(sc: *mut USpoofChecker, chars: *const USet, status: *mut UErrorCode)25512 pub unsafe fn uspoof_setAllowedChars(sc: *mut USpoofChecker, chars: *const USet, status: *mut UErrorCode) {
25513     #[cfg(windows)]
25514     {
25515         #[link(name = "windows")]
25516         extern "system" {
25517             fn uspoof_setAllowedChars(sc: *mut USpoofChecker, chars: *const USet, status: *mut UErrorCode);
25518         }
25519         ::std::mem::transmute(uspoof_setAllowedChars(::std::mem::transmute(sc), ::std::mem::transmute(chars), ::std::mem::transmute(status)))
25520     }
25521     #[cfg(not(windows))]
25522     unimplemented!("Unsupported target OS");
25523 }
25524 #[cfg(feature = "Win32_Foundation")]
25525 #[inline]
uspoof_setAllowedLocales<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *mut USpoofChecker, localeslist: Param1, status: *mut UErrorCode)25526 pub unsafe fn uspoof_setAllowedLocales<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(sc: *mut USpoofChecker, localeslist: Param1, status: *mut UErrorCode) {
25527     #[cfg(windows)]
25528     {
25529         #[link(name = "windows")]
25530         extern "system" {
25531             fn uspoof_setAllowedLocales(sc: *mut USpoofChecker, localeslist: super::Foundation::PSTR, status: *mut UErrorCode);
25532         }
25533         ::std::mem::transmute(uspoof_setAllowedLocales(::std::mem::transmute(sc), localeslist.into_param().abi(), ::std::mem::transmute(status)))
25534     }
25535     #[cfg(not(windows))]
25536     unimplemented!("Unsupported target OS");
25537 }
25538 #[inline]
uspoof_setChecks(sc: *mut USpoofChecker, checks: i32, status: *mut UErrorCode)25539 pub unsafe fn uspoof_setChecks(sc: *mut USpoofChecker, checks: i32, status: *mut UErrorCode) {
25540     #[cfg(windows)]
25541     {
25542         #[link(name = "windows")]
25543         extern "system" {
25544             fn uspoof_setChecks(sc: *mut USpoofChecker, checks: i32, status: *mut UErrorCode);
25545         }
25546         ::std::mem::transmute(uspoof_setChecks(::std::mem::transmute(sc), ::std::mem::transmute(checks), ::std::mem::transmute(status)))
25547     }
25548     #[cfg(not(windows))]
25549     unimplemented!("Unsupported target OS");
25550 }
25551 #[inline]
uspoof_setRestrictionLevel(sc: *mut USpoofChecker, restrictionlevel: URestrictionLevel)25552 pub unsafe fn uspoof_setRestrictionLevel(sc: *mut USpoofChecker, restrictionlevel: URestrictionLevel) {
25553     #[cfg(windows)]
25554     {
25555         #[link(name = "windows")]
25556         extern "system" {
25557             fn uspoof_setRestrictionLevel(sc: *mut USpoofChecker, restrictionlevel: URestrictionLevel);
25558         }
25559         ::std::mem::transmute(uspoof_setRestrictionLevel(::std::mem::transmute(sc), ::std::mem::transmute(restrictionlevel)))
25560     }
25561     #[cfg(not(windows))]
25562     unimplemented!("Unsupported target OS");
25563 }
25564 #[inline]
usprep_close(profile: *mut UStringPrepProfile)25565 pub unsafe fn usprep_close(profile: *mut UStringPrepProfile) {
25566     #[cfg(windows)]
25567     {
25568         #[link(name = "windows")]
25569         extern "system" {
25570             fn usprep_close(profile: *mut UStringPrepProfile);
25571         }
25572         ::std::mem::transmute(usprep_close(::std::mem::transmute(profile)))
25573     }
25574     #[cfg(not(windows))]
25575     unimplemented!("Unsupported target OS");
25576 }
25577 #[cfg(feature = "Win32_Foundation")]
25578 #[inline]
usprep_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(path: Param0, filename: Param1, status: *mut UErrorCode) -> *mut UStringPrepProfile25579 pub unsafe fn usprep_open<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(path: Param0, filename: Param1, status: *mut UErrorCode) -> *mut UStringPrepProfile {
25580     #[cfg(windows)]
25581     {
25582         #[link(name = "windows")]
25583         extern "system" {
25584             fn usprep_open(path: super::Foundation::PSTR, filename: super::Foundation::PSTR, status: *mut UErrorCode) -> *mut UStringPrepProfile;
25585         }
25586         ::std::mem::transmute(usprep_open(path.into_param().abi(), filename.into_param().abi(), ::std::mem::transmute(status)))
25587     }
25588     #[cfg(not(windows))]
25589     unimplemented!("Unsupported target OS");
25590 }
25591 #[inline]
usprep_openByType(r#type: UStringPrepProfileType, status: *mut UErrorCode) -> *mut UStringPrepProfile25592 pub unsafe fn usprep_openByType(r#type: UStringPrepProfileType, status: *mut UErrorCode) -> *mut UStringPrepProfile {
25593     #[cfg(windows)]
25594     {
25595         #[link(name = "windows")]
25596         extern "system" {
25597             fn usprep_openByType(r#type: UStringPrepProfileType, status: *mut UErrorCode) -> *mut UStringPrepProfile;
25598         }
25599         ::std::mem::transmute(usprep_openByType(::std::mem::transmute(r#type), ::std::mem::transmute(status)))
25600     }
25601     #[cfg(not(windows))]
25602     unimplemented!("Unsupported target OS");
25603 }
25604 #[inline]
usprep_prepare(prep: *const UStringPrepProfile, src: *const u16, srclength: i32, dest: *mut u16, destcapacity: i32, options: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i3225605 pub unsafe fn usprep_prepare(prep: *const UStringPrepProfile, src: *const u16, srclength: i32, dest: *mut u16, destcapacity: i32, options: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i32 {
25606     #[cfg(windows)]
25607     {
25608         #[link(name = "windows")]
25609         extern "system" {
25610             fn usprep_prepare(prep: *const UStringPrepProfile, src: *const u16, srclength: i32, dest: *mut u16, destcapacity: i32, options: i32, parseerror: *mut UParseError, status: *mut UErrorCode) -> i32;
25611         }
25612         ::std::mem::transmute(usprep_prepare(::std::mem::transmute(prep), ::std::mem::transmute(src), ::std::mem::transmute(srclength), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(options), ::std::mem::transmute(parseerror), ::std::mem::transmute(status)))
25613     }
25614     #[cfg(not(windows))]
25615     unimplemented!("Unsupported target OS");
25616 }
25617 #[inline]
utext_char32At(ut: *mut UText, nativeindex: i64) -> i3225618 pub unsafe fn utext_char32At(ut: *mut UText, nativeindex: i64) -> i32 {
25619     #[cfg(windows)]
25620     {
25621         #[link(name = "windows")]
25622         extern "system" {
25623             fn utext_char32At(ut: *mut UText, nativeindex: i64) -> i32;
25624         }
25625         ::std::mem::transmute(utext_char32At(::std::mem::transmute(ut), ::std::mem::transmute(nativeindex)))
25626     }
25627     #[cfg(not(windows))]
25628     unimplemented!("Unsupported target OS");
25629 }
25630 #[inline]
utext_clone(dest: *mut UText, src: *const UText, deep: i8, readonly: i8, status: *mut UErrorCode) -> *mut UText25631 pub unsafe fn utext_clone(dest: *mut UText, src: *const UText, deep: i8, readonly: i8, status: *mut UErrorCode) -> *mut UText {
25632     #[cfg(windows)]
25633     {
25634         #[link(name = "windows")]
25635         extern "system" {
25636             fn utext_clone(dest: *mut UText, src: *const UText, deep: i8, readonly: i8, status: *mut UErrorCode) -> *mut UText;
25637         }
25638         ::std::mem::transmute(utext_clone(::std::mem::transmute(dest), ::std::mem::transmute(src), ::std::mem::transmute(deep), ::std::mem::transmute(readonly), ::std::mem::transmute(status)))
25639     }
25640     #[cfg(not(windows))]
25641     unimplemented!("Unsupported target OS");
25642 }
25643 #[inline]
utext_close(ut: *mut UText) -> *mut UText25644 pub unsafe fn utext_close(ut: *mut UText) -> *mut UText {
25645     #[cfg(windows)]
25646     {
25647         #[link(name = "windows")]
25648         extern "system" {
25649             fn utext_close(ut: *mut UText) -> *mut UText;
25650         }
25651         ::std::mem::transmute(utext_close(::std::mem::transmute(ut)))
25652     }
25653     #[cfg(not(windows))]
25654     unimplemented!("Unsupported target OS");
25655 }
25656 #[inline]
utext_copy(ut: *mut UText, nativestart: i64, nativelimit: i64, destindex: i64, r#move: i8, status: *mut UErrorCode)25657 pub unsafe fn utext_copy(ut: *mut UText, nativestart: i64, nativelimit: i64, destindex: i64, r#move: i8, status: *mut UErrorCode) {
25658     #[cfg(windows)]
25659     {
25660         #[link(name = "windows")]
25661         extern "system" {
25662             fn utext_copy(ut: *mut UText, nativestart: i64, nativelimit: i64, destindex: i64, r#move: i8, status: *mut UErrorCode);
25663         }
25664         ::std::mem::transmute(utext_copy(::std::mem::transmute(ut), ::std::mem::transmute(nativestart), ::std::mem::transmute(nativelimit), ::std::mem::transmute(destindex), ::std::mem::transmute(r#move), ::std::mem::transmute(status)))
25665     }
25666     #[cfg(not(windows))]
25667     unimplemented!("Unsupported target OS");
25668 }
25669 #[inline]
utext_current32(ut: *mut UText) -> i3225670 pub unsafe fn utext_current32(ut: *mut UText) -> i32 {
25671     #[cfg(windows)]
25672     {
25673         #[link(name = "windows")]
25674         extern "system" {
25675             fn utext_current32(ut: *mut UText) -> i32;
25676         }
25677         ::std::mem::transmute(utext_current32(::std::mem::transmute(ut)))
25678     }
25679     #[cfg(not(windows))]
25680     unimplemented!("Unsupported target OS");
25681 }
25682 #[inline]
utext_equals(a: *const UText, b: *const UText) -> i825683 pub unsafe fn utext_equals(a: *const UText, b: *const UText) -> i8 {
25684     #[cfg(windows)]
25685     {
25686         #[link(name = "windows")]
25687         extern "system" {
25688             fn utext_equals(a: *const UText, b: *const UText) -> i8;
25689         }
25690         ::std::mem::transmute(utext_equals(::std::mem::transmute(a), ::std::mem::transmute(b)))
25691     }
25692     #[cfg(not(windows))]
25693     unimplemented!("Unsupported target OS");
25694 }
25695 #[inline]
utext_extract(ut: *mut UText, nativestart: i64, nativelimit: i64, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i3225696 pub unsafe fn utext_extract(ut: *mut UText, nativestart: i64, nativelimit: i64, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32 {
25697     #[cfg(windows)]
25698     {
25699         #[link(name = "windows")]
25700         extern "system" {
25701             fn utext_extract(ut: *mut UText, nativestart: i64, nativelimit: i64, dest: *mut u16, destcapacity: i32, status: *mut UErrorCode) -> i32;
25702         }
25703         ::std::mem::transmute(utext_extract(::std::mem::transmute(ut), ::std::mem::transmute(nativestart), ::std::mem::transmute(nativelimit), ::std::mem::transmute(dest), ::std::mem::transmute(destcapacity), ::std::mem::transmute(status)))
25704     }
25705     #[cfg(not(windows))]
25706     unimplemented!("Unsupported target OS");
25707 }
25708 #[inline]
utext_freeze(ut: *mut UText)25709 pub unsafe fn utext_freeze(ut: *mut UText) {
25710     #[cfg(windows)]
25711     {
25712         #[link(name = "windows")]
25713         extern "system" {
25714             fn utext_freeze(ut: *mut UText);
25715         }
25716         ::std::mem::transmute(utext_freeze(::std::mem::transmute(ut)))
25717     }
25718     #[cfg(not(windows))]
25719     unimplemented!("Unsupported target OS");
25720 }
25721 #[inline]
utext_getNativeIndex(ut: *const UText) -> i6425722 pub unsafe fn utext_getNativeIndex(ut: *const UText) -> i64 {
25723     #[cfg(windows)]
25724     {
25725         #[link(name = "windows")]
25726         extern "system" {
25727             fn utext_getNativeIndex(ut: *const UText) -> i64;
25728         }
25729         ::std::mem::transmute(utext_getNativeIndex(::std::mem::transmute(ut)))
25730     }
25731     #[cfg(not(windows))]
25732     unimplemented!("Unsupported target OS");
25733 }
25734 #[inline]
utext_getPreviousNativeIndex(ut: *mut UText) -> i6425735 pub unsafe fn utext_getPreviousNativeIndex(ut: *mut UText) -> i64 {
25736     #[cfg(windows)]
25737     {
25738         #[link(name = "windows")]
25739         extern "system" {
25740             fn utext_getPreviousNativeIndex(ut: *mut UText) -> i64;
25741         }
25742         ::std::mem::transmute(utext_getPreviousNativeIndex(::std::mem::transmute(ut)))
25743     }
25744     #[cfg(not(windows))]
25745     unimplemented!("Unsupported target OS");
25746 }
25747 #[inline]
utext_hasMetaData(ut: *const UText) -> i825748 pub unsafe fn utext_hasMetaData(ut: *const UText) -> i8 {
25749     #[cfg(windows)]
25750     {
25751         #[link(name = "windows")]
25752         extern "system" {
25753             fn utext_hasMetaData(ut: *const UText) -> i8;
25754         }
25755         ::std::mem::transmute(utext_hasMetaData(::std::mem::transmute(ut)))
25756     }
25757     #[cfg(not(windows))]
25758     unimplemented!("Unsupported target OS");
25759 }
25760 #[inline]
utext_isLengthExpensive(ut: *const UText) -> i825761 pub unsafe fn utext_isLengthExpensive(ut: *const UText) -> i8 {
25762     #[cfg(windows)]
25763     {
25764         #[link(name = "windows")]
25765         extern "system" {
25766             fn utext_isLengthExpensive(ut: *const UText) -> i8;
25767         }
25768         ::std::mem::transmute(utext_isLengthExpensive(::std::mem::transmute(ut)))
25769     }
25770     #[cfg(not(windows))]
25771     unimplemented!("Unsupported target OS");
25772 }
25773 #[inline]
utext_isWritable(ut: *const UText) -> i825774 pub unsafe fn utext_isWritable(ut: *const UText) -> i8 {
25775     #[cfg(windows)]
25776     {
25777         #[link(name = "windows")]
25778         extern "system" {
25779             fn utext_isWritable(ut: *const UText) -> i8;
25780         }
25781         ::std::mem::transmute(utext_isWritable(::std::mem::transmute(ut)))
25782     }
25783     #[cfg(not(windows))]
25784     unimplemented!("Unsupported target OS");
25785 }
25786 #[inline]
utext_moveIndex32(ut: *mut UText, delta: i32) -> i825787 pub unsafe fn utext_moveIndex32(ut: *mut UText, delta: i32) -> i8 {
25788     #[cfg(windows)]
25789     {
25790         #[link(name = "windows")]
25791         extern "system" {
25792             fn utext_moveIndex32(ut: *mut UText, delta: i32) -> i8;
25793         }
25794         ::std::mem::transmute(utext_moveIndex32(::std::mem::transmute(ut), ::std::mem::transmute(delta)))
25795     }
25796     #[cfg(not(windows))]
25797     unimplemented!("Unsupported target OS");
25798 }
25799 #[inline]
utext_nativeLength(ut: *mut UText) -> i6425800 pub unsafe fn utext_nativeLength(ut: *mut UText) -> i64 {
25801     #[cfg(windows)]
25802     {
25803         #[link(name = "windows")]
25804         extern "system" {
25805             fn utext_nativeLength(ut: *mut UText) -> i64;
25806         }
25807         ::std::mem::transmute(utext_nativeLength(::std::mem::transmute(ut)))
25808     }
25809     #[cfg(not(windows))]
25810     unimplemented!("Unsupported target OS");
25811 }
25812 #[inline]
utext_next32(ut: *mut UText) -> i3225813 pub unsafe fn utext_next32(ut: *mut UText) -> i32 {
25814     #[cfg(windows)]
25815     {
25816         #[link(name = "windows")]
25817         extern "system" {
25818             fn utext_next32(ut: *mut UText) -> i32;
25819         }
25820         ::std::mem::transmute(utext_next32(::std::mem::transmute(ut)))
25821     }
25822     #[cfg(not(windows))]
25823     unimplemented!("Unsupported target OS");
25824 }
25825 #[inline]
utext_next32From(ut: *mut UText, nativeindex: i64) -> i3225826 pub unsafe fn utext_next32From(ut: *mut UText, nativeindex: i64) -> i32 {
25827     #[cfg(windows)]
25828     {
25829         #[link(name = "windows")]
25830         extern "system" {
25831             fn utext_next32From(ut: *mut UText, nativeindex: i64) -> i32;
25832         }
25833         ::std::mem::transmute(utext_next32From(::std::mem::transmute(ut), ::std::mem::transmute(nativeindex)))
25834     }
25835     #[cfg(not(windows))]
25836     unimplemented!("Unsupported target OS");
25837 }
25838 #[inline]
utext_openUChars(ut: *mut UText, s: *const u16, length: i64, status: *mut UErrorCode) -> *mut UText25839 pub unsafe fn utext_openUChars(ut: *mut UText, s: *const u16, length: i64, status: *mut UErrorCode) -> *mut UText {
25840     #[cfg(windows)]
25841     {
25842         #[link(name = "windows")]
25843         extern "system" {
25844             fn utext_openUChars(ut: *mut UText, s: *const u16, length: i64, status: *mut UErrorCode) -> *mut UText;
25845         }
25846         ::std::mem::transmute(utext_openUChars(::std::mem::transmute(ut), ::std::mem::transmute(s), ::std::mem::transmute(length), ::std::mem::transmute(status)))
25847     }
25848     #[cfg(not(windows))]
25849     unimplemented!("Unsupported target OS");
25850 }
25851 #[cfg(feature = "Win32_Foundation")]
25852 #[inline]
utext_openUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ut: *mut UText, s: Param1, length: i64, status: *mut UErrorCode) -> *mut UText25853 pub unsafe fn utext_openUTF8<'a, Param1: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(ut: *mut UText, s: Param1, length: i64, status: *mut UErrorCode) -> *mut UText {
25854     #[cfg(windows)]
25855     {
25856         #[link(name = "windows")]
25857         extern "system" {
25858             fn utext_openUTF8(ut: *mut UText, s: super::Foundation::PSTR, length: i64, status: *mut UErrorCode) -> *mut UText;
25859         }
25860         ::std::mem::transmute(utext_openUTF8(::std::mem::transmute(ut), s.into_param().abi(), ::std::mem::transmute(length), ::std::mem::transmute(status)))
25861     }
25862     #[cfg(not(windows))]
25863     unimplemented!("Unsupported target OS");
25864 }
25865 #[inline]
utext_previous32(ut: *mut UText) -> i3225866 pub unsafe fn utext_previous32(ut: *mut UText) -> i32 {
25867     #[cfg(windows)]
25868     {
25869         #[link(name = "windows")]
25870         extern "system" {
25871             fn utext_previous32(ut: *mut UText) -> i32;
25872         }
25873         ::std::mem::transmute(utext_previous32(::std::mem::transmute(ut)))
25874     }
25875     #[cfg(not(windows))]
25876     unimplemented!("Unsupported target OS");
25877 }
25878 #[inline]
utext_previous32From(ut: *mut UText, nativeindex: i64) -> i3225879 pub unsafe fn utext_previous32From(ut: *mut UText, nativeindex: i64) -> i32 {
25880     #[cfg(windows)]
25881     {
25882         #[link(name = "windows")]
25883         extern "system" {
25884             fn utext_previous32From(ut: *mut UText, nativeindex: i64) -> i32;
25885         }
25886         ::std::mem::transmute(utext_previous32From(::std::mem::transmute(ut), ::std::mem::transmute(nativeindex)))
25887     }
25888     #[cfg(not(windows))]
25889     unimplemented!("Unsupported target OS");
25890 }
25891 #[inline]
utext_replace(ut: *mut UText, nativestart: i64, nativelimit: i64, replacementtext: *const u16, replacementlength: i32, status: *mut UErrorCode) -> i3225892 pub unsafe fn utext_replace(ut: *mut UText, nativestart: i64, nativelimit: i64, replacementtext: *const u16, replacementlength: i32, status: *mut UErrorCode) -> i32 {
25893     #[cfg(windows)]
25894     {
25895         #[link(name = "windows")]
25896         extern "system" {
25897             fn utext_replace(ut: *mut UText, nativestart: i64, nativelimit: i64, replacementtext: *const u16, replacementlength: i32, status: *mut UErrorCode) -> i32;
25898         }
25899         ::std::mem::transmute(utext_replace(::std::mem::transmute(ut), ::std::mem::transmute(nativestart), ::std::mem::transmute(nativelimit), ::std::mem::transmute(replacementtext), ::std::mem::transmute(replacementlength), ::std::mem::transmute(status)))
25900     }
25901     #[cfg(not(windows))]
25902     unimplemented!("Unsupported target OS");
25903 }
25904 #[inline]
utext_setNativeIndex(ut: *mut UText, nativeindex: i64)25905 pub unsafe fn utext_setNativeIndex(ut: *mut UText, nativeindex: i64) {
25906     #[cfg(windows)]
25907     {
25908         #[link(name = "windows")]
25909         extern "system" {
25910             fn utext_setNativeIndex(ut: *mut UText, nativeindex: i64);
25911         }
25912         ::std::mem::transmute(utext_setNativeIndex(::std::mem::transmute(ut), ::std::mem::transmute(nativeindex)))
25913     }
25914     #[cfg(not(windows))]
25915     unimplemented!("Unsupported target OS");
25916 }
25917 #[inline]
utext_setup(ut: *mut UText, extraspace: i32, status: *mut UErrorCode) -> *mut UText25918 pub unsafe fn utext_setup(ut: *mut UText, extraspace: i32, status: *mut UErrorCode) -> *mut UText {
25919     #[cfg(windows)]
25920     {
25921         #[link(name = "windows")]
25922         extern "system" {
25923             fn utext_setup(ut: *mut UText, extraspace: i32, status: *mut UErrorCode) -> *mut UText;
25924         }
25925         ::std::mem::transmute(utext_setup(::std::mem::transmute(ut), ::std::mem::transmute(extraspace), ::std::mem::transmute(status)))
25926     }
25927     #[cfg(not(windows))]
25928     unimplemented!("Unsupported target OS");
25929 }
25930 #[inline]
utf8_appendCharSafeBody(s: *mut u8, i: i32, length: i32, c: i32, piserror: *mut i8) -> i3225931 pub unsafe fn utf8_appendCharSafeBody(s: *mut u8, i: i32, length: i32, c: i32, piserror: *mut i8) -> i32 {
25932     #[cfg(windows)]
25933     {
25934         #[link(name = "windows")]
25935         extern "system" {
25936             fn utf8_appendCharSafeBody(s: *mut u8, i: i32, length: i32, c: i32, piserror: *mut i8) -> i32;
25937         }
25938         ::std::mem::transmute(utf8_appendCharSafeBody(::std::mem::transmute(s), ::std::mem::transmute(i), ::std::mem::transmute(length), ::std::mem::transmute(c), ::std::mem::transmute(piserror)))
25939     }
25940     #[cfg(not(windows))]
25941     unimplemented!("Unsupported target OS");
25942 }
25943 #[inline]
utf8_back1SafeBody(s: *const u8, start: i32, i: i32) -> i3225944 pub unsafe fn utf8_back1SafeBody(s: *const u8, start: i32, i: i32) -> i32 {
25945     #[cfg(windows)]
25946     {
25947         #[link(name = "windows")]
25948         extern "system" {
25949             fn utf8_back1SafeBody(s: *const u8, start: i32, i: i32) -> i32;
25950         }
25951         ::std::mem::transmute(utf8_back1SafeBody(::std::mem::transmute(s), ::std::mem::transmute(start), ::std::mem::transmute(i)))
25952     }
25953     #[cfg(not(windows))]
25954     unimplemented!("Unsupported target OS");
25955 }
25956 #[inline]
utf8_nextCharSafeBody(s: *const u8, pi: *mut i32, length: i32, c: i32, strict: i8) -> i3225957 pub unsafe fn utf8_nextCharSafeBody(s: *const u8, pi: *mut i32, length: i32, c: i32, strict: i8) -> i32 {
25958     #[cfg(windows)]
25959     {
25960         #[link(name = "windows")]
25961         extern "system" {
25962             fn utf8_nextCharSafeBody(s: *const u8, pi: *mut i32, length: i32, c: i32, strict: i8) -> i32;
25963         }
25964         ::std::mem::transmute(utf8_nextCharSafeBody(::std::mem::transmute(s), ::std::mem::transmute(pi), ::std::mem::transmute(length), ::std::mem::transmute(c), ::std::mem::transmute(strict)))
25965     }
25966     #[cfg(not(windows))]
25967     unimplemented!("Unsupported target OS");
25968 }
25969 #[inline]
utf8_prevCharSafeBody(s: *const u8, start: i32, pi: *mut i32, c: i32, strict: i8) -> i3225970 pub unsafe fn utf8_prevCharSafeBody(s: *const u8, start: i32, pi: *mut i32, c: i32, strict: i8) -> i32 {
25971     #[cfg(windows)]
25972     {
25973         #[link(name = "windows")]
25974         extern "system" {
25975             fn utf8_prevCharSafeBody(s: *const u8, start: i32, pi: *mut i32, c: i32, strict: i8) -> i32;
25976         }
25977         ::std::mem::transmute(utf8_prevCharSafeBody(::std::mem::transmute(s), ::std::mem::transmute(start), ::std::mem::transmute(pi), ::std::mem::transmute(c), ::std::mem::transmute(strict)))
25978     }
25979     #[cfg(not(windows))]
25980     unimplemented!("Unsupported target OS");
25981 }
25982 #[inline]
utmscale_fromInt64(othertime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i6425983 pub unsafe fn utmscale_fromInt64(othertime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i64 {
25984     #[cfg(windows)]
25985     {
25986         #[link(name = "windows")]
25987         extern "system" {
25988             fn utmscale_fromInt64(othertime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i64;
25989         }
25990         ::std::mem::transmute(utmscale_fromInt64(::std::mem::transmute(othertime), ::std::mem::transmute(timescale), ::std::mem::transmute(status)))
25991     }
25992     #[cfg(not(windows))]
25993     unimplemented!("Unsupported target OS");
25994 }
25995 #[inline]
utmscale_getTimeScaleValue(timescale: UDateTimeScale, value: UTimeScaleValue, status: *mut UErrorCode) -> i6425996 pub unsafe fn utmscale_getTimeScaleValue(timescale: UDateTimeScale, value: UTimeScaleValue, status: *mut UErrorCode) -> i64 {
25997     #[cfg(windows)]
25998     {
25999         #[link(name = "windows")]
26000         extern "system" {
26001             fn utmscale_getTimeScaleValue(timescale: UDateTimeScale, value: UTimeScaleValue, status: *mut UErrorCode) -> i64;
26002         }
26003         ::std::mem::transmute(utmscale_getTimeScaleValue(::std::mem::transmute(timescale), ::std::mem::transmute(value), ::std::mem::transmute(status)))
26004     }
26005     #[cfg(not(windows))]
26006     unimplemented!("Unsupported target OS");
26007 }
26008 #[inline]
utmscale_toInt64(universaltime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i6426009 pub unsafe fn utmscale_toInt64(universaltime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i64 {
26010     #[cfg(windows)]
26011     {
26012         #[link(name = "windows")]
26013         extern "system" {
26014             fn utmscale_toInt64(universaltime: i64, timescale: UDateTimeScale, status: *mut UErrorCode) -> i64;
26015         }
26016         ::std::mem::transmute(utmscale_toInt64(::std::mem::transmute(universaltime), ::std::mem::transmute(timescale), ::std::mem::transmute(status)))
26017     }
26018     #[cfg(not(windows))]
26019     unimplemented!("Unsupported target OS");
26020 }
26021 #[cfg(feature = "Win32_Foundation")]
26022 #[inline]
utrace_format<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(outbuf: Param0, capacity: i32, indent: i32, fmt: Param3) -> i3226023 pub unsafe fn utrace_format<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(outbuf: Param0, capacity: i32, indent: i32, fmt: Param3) -> i32 {
26024     #[cfg(windows)]
26025     {
26026         #[link(name = "windows")]
26027         extern "system" {
26028             fn utrace_format(outbuf: super::Foundation::PSTR, capacity: i32, indent: i32, fmt: super::Foundation::PSTR) -> i32;
26029         }
26030         ::std::mem::transmute(utrace_format(outbuf.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(indent), fmt.into_param().abi()))
26031     }
26032     #[cfg(not(windows))]
26033     unimplemented!("Unsupported target OS");
26034 }
26035 #[cfg(feature = "Win32_Foundation")]
26036 #[inline]
utrace_functionName(fnnumber: i32) -> super::Foundation::PSTR26037 pub unsafe fn utrace_functionName(fnnumber: i32) -> super::Foundation::PSTR {
26038     #[cfg(windows)]
26039     {
26040         #[link(name = "windows")]
26041         extern "system" {
26042             fn utrace_functionName(fnnumber: i32) -> super::Foundation::PSTR;
26043         }
26044         ::std::mem::transmute(utrace_functionName(::std::mem::transmute(fnnumber)))
26045     }
26046     #[cfg(not(windows))]
26047     unimplemented!("Unsupported target OS");
26048 }
26049 #[cfg(feature = "Win32_Foundation")]
26050 #[inline]
utrace_getFunctions(context: *const *const ::std::ffi::c_void, e: *mut ::std::option::Option<UTraceEntry>, x: *mut ::std::option::Option<UTraceExit>, d: *mut ::std::option::Option<UTraceData>)26051 pub unsafe fn utrace_getFunctions(context: *const *const ::std::ffi::c_void, e: *mut ::std::option::Option<UTraceEntry>, x: *mut ::std::option::Option<UTraceExit>, d: *mut ::std::option::Option<UTraceData>) {
26052     #[cfg(windows)]
26053     {
26054         #[link(name = "windows")]
26055         extern "system" {
26056             fn utrace_getFunctions(context: *const *const ::std::ffi::c_void, e: *mut ::windows::runtime::RawPtr, x: *mut ::windows::runtime::RawPtr, d: *mut ::windows::runtime::RawPtr);
26057         }
26058         ::std::mem::transmute(utrace_getFunctions(::std::mem::transmute(context), ::std::mem::transmute(e), ::std::mem::transmute(x), ::std::mem::transmute(d)))
26059     }
26060     #[cfg(not(windows))]
26061     unimplemented!("Unsupported target OS");
26062 }
26063 #[inline]
utrace_getLevel() -> i3226064 pub unsafe fn utrace_getLevel() -> i32 {
26065     #[cfg(windows)]
26066     {
26067         #[link(name = "windows")]
26068         extern "system" {
26069             fn utrace_getLevel() -> i32;
26070         }
26071         ::std::mem::transmute(utrace_getLevel())
26072     }
26073     #[cfg(not(windows))]
26074     unimplemented!("Unsupported target OS");
26075 }
26076 #[cfg(feature = "Win32_Foundation")]
26077 #[inline]
utrace_setFunctions(context: *const ::std::ffi::c_void, e: ::std::option::Option<UTraceEntry>, x: ::std::option::Option<UTraceExit>, d: ::std::option::Option<UTraceData>)26078 pub unsafe fn utrace_setFunctions(context: *const ::std::ffi::c_void, e: ::std::option::Option<UTraceEntry>, x: ::std::option::Option<UTraceExit>, d: ::std::option::Option<UTraceData>) {
26079     #[cfg(windows)]
26080     {
26081         #[link(name = "windows")]
26082         extern "system" {
26083             fn utrace_setFunctions(context: *const ::std::ffi::c_void, e: ::windows::runtime::RawPtr, x: ::windows::runtime::RawPtr, d: ::windows::runtime::RawPtr);
26084         }
26085         ::std::mem::transmute(utrace_setFunctions(::std::mem::transmute(context), ::std::mem::transmute(e), ::std::mem::transmute(x), ::std::mem::transmute(d)))
26086     }
26087     #[cfg(not(windows))]
26088     unimplemented!("Unsupported target OS");
26089 }
26090 #[inline]
utrace_setLevel(tracelevel: i32)26091 pub unsafe fn utrace_setLevel(tracelevel: i32) {
26092     #[cfg(windows)]
26093     {
26094         #[link(name = "windows")]
26095         extern "system" {
26096             fn utrace_setLevel(tracelevel: i32);
26097         }
26098         ::std::mem::transmute(utrace_setLevel(::std::mem::transmute(tracelevel)))
26099     }
26100     #[cfg(not(windows))]
26101     unimplemented!("Unsupported target OS");
26102 }
26103 #[cfg(feature = "Win32_Foundation")]
26104 #[inline]
utrace_vformat<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(outbuf: Param0, capacity: i32, indent: i32, fmt: Param3, args: *mut i8) -> i3226105 pub unsafe fn utrace_vformat<'a, Param0: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>, Param3: ::windows::runtime::IntoParam<'a, super::Foundation::PSTR>>(outbuf: Param0, capacity: i32, indent: i32, fmt: Param3, args: *mut i8) -> i32 {
26106     #[cfg(windows)]
26107     {
26108         #[link(name = "windows")]
26109         extern "system" {
26110             fn utrace_vformat(outbuf: super::Foundation::PSTR, capacity: i32, indent: i32, fmt: super::Foundation::PSTR, args: *mut i8) -> i32;
26111         }
26112         ::std::mem::transmute(utrace_vformat(outbuf.into_param().abi(), ::std::mem::transmute(capacity), ::std::mem::transmute(indent), fmt.into_param().abi(), ::std::mem::transmute(args)))
26113     }
26114     #[cfg(not(windows))]
26115     unimplemented!("Unsupported target OS");
26116 }
26117 #[inline]
utrans_clone(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void26118 pub unsafe fn utrans_clone(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
26119     #[cfg(windows)]
26120     {
26121         #[link(name = "windows")]
26122         extern "system" {
26123             fn utrans_clone(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
26124         }
26125         ::std::mem::transmute(utrans_clone(::std::mem::transmute(trans), ::std::mem::transmute(status)))
26126     }
26127     #[cfg(not(windows))]
26128     unimplemented!("Unsupported target OS");
26129 }
26130 #[inline]
utrans_close(trans: *mut *mut ::std::ffi::c_void)26131 pub unsafe fn utrans_close(trans: *mut *mut ::std::ffi::c_void) {
26132     #[cfg(windows)]
26133     {
26134         #[link(name = "windows")]
26135         extern "system" {
26136             fn utrans_close(trans: *mut *mut ::std::ffi::c_void);
26137         }
26138         ::std::mem::transmute(utrans_close(::std::mem::transmute(trans)))
26139     }
26140     #[cfg(not(windows))]
26141     unimplemented!("Unsupported target OS");
26142 }
26143 #[inline]
utrans_countAvailableIDs() -> i3226144 pub unsafe fn utrans_countAvailableIDs() -> i32 {
26145     #[cfg(windows)]
26146     {
26147         #[link(name = "windows")]
26148         extern "system" {
26149             fn utrans_countAvailableIDs() -> i32;
26150         }
26151         ::std::mem::transmute(utrans_countAvailableIDs())
26152     }
26153     #[cfg(not(windows))]
26154     unimplemented!("Unsupported target OS");
26155 }
26156 #[inline]
utrans_getSourceSet(trans: *const *const ::std::ffi::c_void, ignorefilter: i8, fillin: *mut USet, status: *mut UErrorCode) -> *mut USet26157 pub unsafe fn utrans_getSourceSet(trans: *const *const ::std::ffi::c_void, ignorefilter: i8, fillin: *mut USet, status: *mut UErrorCode) -> *mut USet {
26158     #[cfg(windows)]
26159     {
26160         #[link(name = "windows")]
26161         extern "system" {
26162             fn utrans_getSourceSet(trans: *const *const ::std::ffi::c_void, ignorefilter: i8, fillin: *mut USet, status: *mut UErrorCode) -> *mut USet;
26163         }
26164         ::std::mem::transmute(utrans_getSourceSet(::std::mem::transmute(trans), ::std::mem::transmute(ignorefilter), ::std::mem::transmute(fillin), ::std::mem::transmute(status)))
26165     }
26166     #[cfg(not(windows))]
26167     unimplemented!("Unsupported target OS");
26168 }
26169 #[inline]
utrans_getUnicodeID(trans: *const *const ::std::ffi::c_void, resultlength: *mut i32) -> *mut u1626170 pub unsafe fn utrans_getUnicodeID(trans: *const *const ::std::ffi::c_void, resultlength: *mut i32) -> *mut u16 {
26171     #[cfg(windows)]
26172     {
26173         #[link(name = "windows")]
26174         extern "system" {
26175             fn utrans_getUnicodeID(trans: *const *const ::std::ffi::c_void, resultlength: *mut i32) -> *mut u16;
26176         }
26177         ::std::mem::transmute(utrans_getUnicodeID(::std::mem::transmute(trans), ::std::mem::transmute(resultlength)))
26178     }
26179     #[cfg(not(windows))]
26180     unimplemented!("Unsupported target OS");
26181 }
26182 #[inline]
utrans_openIDs(perrorcode: *mut UErrorCode) -> *mut UEnumeration26183 pub unsafe fn utrans_openIDs(perrorcode: *mut UErrorCode) -> *mut UEnumeration {
26184     #[cfg(windows)]
26185     {
26186         #[link(name = "windows")]
26187         extern "system" {
26188             fn utrans_openIDs(perrorcode: *mut UErrorCode) -> *mut UEnumeration;
26189         }
26190         ::std::mem::transmute(utrans_openIDs(::std::mem::transmute(perrorcode)))
26191     }
26192     #[cfg(not(windows))]
26193     unimplemented!("Unsupported target OS");
26194 }
26195 #[inline]
utrans_openInverse(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void26196 pub unsafe fn utrans_openInverse(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
26197     #[cfg(windows)]
26198     {
26199         #[link(name = "windows")]
26200         extern "system" {
26201             fn utrans_openInverse(trans: *const *const ::std::ffi::c_void, status: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
26202         }
26203         ::std::mem::transmute(utrans_openInverse(::std::mem::transmute(trans), ::std::mem::transmute(status)))
26204     }
26205     #[cfg(not(windows))]
26206     unimplemented!("Unsupported target OS");
26207 }
26208 #[inline]
utrans_openU(id: *const u16, idlength: i32, dir: UTransDirection, rules: *const u16, ruleslength: i32, parseerror: *mut UParseError, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void26209 pub unsafe fn utrans_openU(id: *const u16, idlength: i32, dir: UTransDirection, rules: *const u16, ruleslength: i32, parseerror: *mut UParseError, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void {
26210     #[cfg(windows)]
26211     {
26212         #[link(name = "windows")]
26213         extern "system" {
26214             fn utrans_openU(id: *const u16, idlength: i32, dir: UTransDirection, rules: *const u16, ruleslength: i32, parseerror: *mut UParseError, perrorcode: *mut UErrorCode) -> *mut *mut ::std::ffi::c_void;
26215         }
26216         ::std::mem::transmute(utrans_openU(::std::mem::transmute(id), ::std::mem::transmute(idlength), ::std::mem::transmute(dir), ::std::mem::transmute(rules), ::std::mem::transmute(ruleslength), ::std::mem::transmute(parseerror), ::std::mem::transmute(perrorcode)))
26217     }
26218     #[cfg(not(windows))]
26219     unimplemented!("Unsupported target OS");
26220 }
26221 #[inline]
utrans_register(adoptedtrans: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode)26222 pub unsafe fn utrans_register(adoptedtrans: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode) {
26223     #[cfg(windows)]
26224     {
26225         #[link(name = "windows")]
26226         extern "system" {
26227             fn utrans_register(adoptedtrans: *mut *mut ::std::ffi::c_void, status: *mut UErrorCode);
26228         }
26229         ::std::mem::transmute(utrans_register(::std::mem::transmute(adoptedtrans), ::std::mem::transmute(status)))
26230     }
26231     #[cfg(not(windows))]
26232     unimplemented!("Unsupported target OS");
26233 }
26234 #[inline]
utrans_setFilter(trans: *mut *mut ::std::ffi::c_void, filterpattern: *const u16, filterpatternlen: i32, status: *mut UErrorCode)26235 pub unsafe fn utrans_setFilter(trans: *mut *mut ::std::ffi::c_void, filterpattern: *const u16, filterpatternlen: i32, status: *mut UErrorCode) {
26236     #[cfg(windows)]
26237     {
26238         #[link(name = "windows")]
26239         extern "system" {
26240             fn utrans_setFilter(trans: *mut *mut ::std::ffi::c_void, filterpattern: *const u16, filterpatternlen: i32, status: *mut UErrorCode);
26241         }
26242         ::std::mem::transmute(utrans_setFilter(::std::mem::transmute(trans), ::std::mem::transmute(filterpattern), ::std::mem::transmute(filterpatternlen), ::std::mem::transmute(status)))
26243     }
26244     #[cfg(not(windows))]
26245     unimplemented!("Unsupported target OS");
26246 }
26247 #[inline]
utrans_toRules(trans: *const *const ::std::ffi::c_void, escapeunprintable: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i3226248 pub unsafe fn utrans_toRules(trans: *const *const ::std::ffi::c_void, escapeunprintable: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32 {
26249     #[cfg(windows)]
26250     {
26251         #[link(name = "windows")]
26252         extern "system" {
26253             fn utrans_toRules(trans: *const *const ::std::ffi::c_void, escapeunprintable: i8, result: *mut u16, resultlength: i32, status: *mut UErrorCode) -> i32;
26254         }
26255         ::std::mem::transmute(utrans_toRules(::std::mem::transmute(trans), ::std::mem::transmute(escapeunprintable), ::std::mem::transmute(result), ::std::mem::transmute(resultlength), ::std::mem::transmute(status)))
26256     }
26257     #[cfg(not(windows))]
26258     unimplemented!("Unsupported target OS");
26259 }
26260 #[inline]
utrans_trans(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, start: i32, limit: *mut i32, status: *mut UErrorCode)26261 pub unsafe fn utrans_trans(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, start: i32, limit: *mut i32, status: *mut UErrorCode) {
26262     #[cfg(windows)]
26263     {
26264         #[link(name = "windows")]
26265         extern "system" {
26266             fn utrans_trans(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, start: i32, limit: *mut i32, status: *mut UErrorCode);
26267         }
26268         ::std::mem::transmute(utrans_trans(::std::mem::transmute(trans), ::std::mem::transmute(rep), ::std::mem::transmute(repfunc), ::std::mem::transmute(start), ::std::mem::transmute(limit), ::std::mem::transmute(status)))
26269     }
26270     #[cfg(not(windows))]
26271     unimplemented!("Unsupported target OS");
26272 }
26273 #[inline]
utrans_transIncremental(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, pos: *mut UTransPosition, status: *mut UErrorCode)26274 pub unsafe fn utrans_transIncremental(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, pos: *mut UTransPosition, status: *mut UErrorCode) {
26275     #[cfg(windows)]
26276     {
26277         #[link(name = "windows")]
26278         extern "system" {
26279             fn utrans_transIncremental(trans: *const *const ::std::ffi::c_void, rep: *mut *mut ::std::ffi::c_void, repfunc: *const UReplaceableCallbacks, pos: *mut UTransPosition, status: *mut UErrorCode);
26280         }
26281         ::std::mem::transmute(utrans_transIncremental(::std::mem::transmute(trans), ::std::mem::transmute(rep), ::std::mem::transmute(repfunc), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
26282     }
26283     #[cfg(not(windows))]
26284     unimplemented!("Unsupported target OS");
26285 }
26286 #[inline]
utrans_transIncrementalUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, pos: *mut UTransPosition, status: *mut UErrorCode)26287 pub unsafe fn utrans_transIncrementalUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, pos: *mut UTransPosition, status: *mut UErrorCode) {
26288     #[cfg(windows)]
26289     {
26290         #[link(name = "windows")]
26291         extern "system" {
26292             fn utrans_transIncrementalUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, pos: *mut UTransPosition, status: *mut UErrorCode);
26293         }
26294         ::std::mem::transmute(utrans_transIncrementalUChars(::std::mem::transmute(trans), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(textcapacity), ::std::mem::transmute(pos), ::std::mem::transmute(status)))
26295     }
26296     #[cfg(not(windows))]
26297     unimplemented!("Unsupported target OS");
26298 }
26299 #[inline]
utrans_transUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, start: i32, limit: *mut i32, status: *mut UErrorCode)26300 pub unsafe fn utrans_transUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, start: i32, limit: *mut i32, status: *mut UErrorCode) {
26301     #[cfg(windows)]
26302     {
26303         #[link(name = "windows")]
26304         extern "system" {
26305             fn utrans_transUChars(trans: *const *const ::std::ffi::c_void, text: *mut u16, textlength: *mut i32, textcapacity: i32, start: i32, limit: *mut i32, status: *mut UErrorCode);
26306         }
26307         ::std::mem::transmute(utrans_transUChars(::std::mem::transmute(trans), ::std::mem::transmute(text), ::std::mem::transmute(textlength), ::std::mem::transmute(textcapacity), ::std::mem::transmute(start), ::std::mem::transmute(limit), ::std::mem::transmute(status)))
26308     }
26309     #[cfg(not(windows))]
26310     unimplemented!("Unsupported target OS");
26311 }
26312 #[inline]
utrans_unregisterID(id: *const u16, idlength: i32)26313 pub unsafe fn utrans_unregisterID(id: *const u16, idlength: i32) {
26314     #[cfg(windows)]
26315     {
26316         #[link(name = "windows")]
26317         extern "system" {
26318             fn utrans_unregisterID(id: *const u16, idlength: i32);
26319         }
26320         ::std::mem::transmute(utrans_unregisterID(::std::mem::transmute(id), ::std::mem::transmute(idlength)))
26321     }
26322     #[cfg(not(windows))]
26323     unimplemented!("Unsupported target OS");
26324 }
26325