openthread_sys/
bindings.rs

1/* automatically generated by rust-bindgen 0.63.0 */
2
3// Copyright 2021 The Fuchsia Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style license that can be
5// found in the LICENSE file.
6
7#![allow(dead_code)]
8#![allow(non_camel_case_types)]
9#![allow(non_snake_case)]
10#![allow(non_upper_case_globals)]
11#![allow(clippy::missing_safety_doc)]
12
13#[repr(C)]
14#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct __BindgenBitfieldUnit<Storage> {
16    storage: Storage,
17}
18impl<Storage> __BindgenBitfieldUnit<Storage> {
19    #[inline]
20    pub const fn new(storage: Storage) -> Self {
21        Self { storage }
22    }
23}
24impl<Storage> __BindgenBitfieldUnit<Storage>
25where
26    Storage: AsRef<[u8]> + AsMut<[u8]>,
27{
28    #[inline]
29    pub fn get_bit(&self, index: usize) -> bool {
30        debug_assert!(index / 8 < self.storage.as_ref().len());
31        let byte_index = index / 8;
32        let byte = self.storage.as_ref()[byte_index];
33        let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
34        let mask = 1 << bit_index;
35        byte & mask == mask
36    }
37    #[inline]
38    pub fn set_bit(&mut self, index: usize, val: bool) {
39        debug_assert!(index / 8 < self.storage.as_ref().len());
40        let byte_index = index / 8;
41        let byte = &mut self.storage.as_mut()[byte_index];
42        let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
43        let mask = 1 << bit_index;
44        if val {
45            *byte |= mask;
46        } else {
47            *byte &= !mask;
48        }
49    }
50    #[inline]
51    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
52        debug_assert!(bit_width <= 64);
53        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
54        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
55        let mut val = 0;
56        for i in 0..(bit_width as usize) {
57            if self.get_bit(i + bit_offset) {
58                let index =
59                    if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
60                val |= 1 << index;
61            }
62        }
63        val
64    }
65    #[inline]
66    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
67        debug_assert!(bit_width <= 64);
68        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
69        debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
70        for i in 0..(bit_width as usize) {
71            let mask = 1 << i;
72            let val_bit_is_set = val & mask == mask;
73            let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
74            self.set_bit(index + bit_offset, val_bit_is_set);
75        }
76    }
77}
78pub const OT_LOG_LEVEL_NONE: u32 = 0;
79pub const OT_LOG_LEVEL_CRIT: u32 = 1;
80pub const OT_LOG_LEVEL_WARN: u32 = 2;
81pub const OT_LOG_LEVEL_NOTE: u32 = 3;
82pub const OT_LOG_LEVEL_INFO: u32 = 4;
83pub const OT_LOG_LEVEL_DEBG: u32 = 5;
84pub const OPENTHREAD_API_VERSION: u32 = 483;
85pub const OT_UPTIME_STRING_SIZE: u32 = 24;
86pub const OT_CHANGED_IP6_ADDRESS_ADDED: u32 = 1;
87pub const OT_CHANGED_IP6_ADDRESS_REMOVED: u32 = 2;
88pub const OT_CHANGED_THREAD_ROLE: u32 = 4;
89pub const OT_CHANGED_THREAD_LL_ADDR: u32 = 8;
90pub const OT_CHANGED_THREAD_ML_ADDR: u32 = 16;
91pub const OT_CHANGED_THREAD_RLOC_ADDED: u32 = 32;
92pub const OT_CHANGED_THREAD_RLOC_REMOVED: u32 = 64;
93pub const OT_CHANGED_THREAD_PARTITION_ID: u32 = 128;
94pub const OT_CHANGED_THREAD_KEY_SEQUENCE_COUNTER: u32 = 256;
95pub const OT_CHANGED_THREAD_NETDATA: u32 = 512;
96pub const OT_CHANGED_THREAD_CHILD_ADDED: u32 = 1024;
97pub const OT_CHANGED_THREAD_CHILD_REMOVED: u32 = 2048;
98pub const OT_CHANGED_IP6_MULTICAST_SUBSCRIBED: u32 = 4096;
99pub const OT_CHANGED_IP6_MULTICAST_UNSUBSCRIBED: u32 = 8192;
100pub const OT_CHANGED_THREAD_CHANNEL: u32 = 16384;
101pub const OT_CHANGED_THREAD_PANID: u32 = 32768;
102pub const OT_CHANGED_THREAD_NETWORK_NAME: u32 = 65536;
103pub const OT_CHANGED_THREAD_EXT_PANID: u32 = 131072;
104pub const OT_CHANGED_NETWORK_KEY: u32 = 262144;
105pub const OT_CHANGED_PSKC: u32 = 524288;
106pub const OT_CHANGED_SECURITY_POLICY: u32 = 1048576;
107pub const OT_CHANGED_CHANNEL_MANAGER_NEW_CHANNEL: u32 = 2097152;
108pub const OT_CHANGED_SUPPORTED_CHANNEL_MASK: u32 = 4194304;
109pub const OT_CHANGED_COMMISSIONER_STATE: u32 = 8388608;
110pub const OT_CHANGED_THREAD_NETIF_STATE: u32 = 16777216;
111pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_STATE: u32 = 33554432;
112pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_LOCAL: u32 = 67108864;
113pub const OT_CHANGED_JOINER_STATE: u32 = 134217728;
114pub const OT_CHANGED_ACTIVE_DATASET: u32 = 268435456;
115pub const OT_CHANGED_PENDING_DATASET: u32 = 536870912;
116pub const OT_CHANGED_NAT64_TRANSLATOR_STATE: u32 = 1073741824;
117pub const OT_CHANGED_PARENT_LINK_QUALITY: u32 = 2147483648;
118pub const OT_CRYPTO_SHA256_HASH_SIZE: u32 = 32;
119pub const OT_CRYPTO_ECDSA_MAX_DER_SIZE: u32 = 125;
120pub const OT_CRYPTO_ECDSA_PUBLIC_KEY_SIZE: u32 = 64;
121pub const OT_CRYPTO_ECDSA_SIGNATURE_SIZE: u32 = 64;
122pub const OT_CRYPTO_PBDKF2_MAX_SALT_SIZE: u32 = 30;
123pub const OT_PANID_BROADCAST: u32 = 65535;
124pub const OT_EXT_ADDRESS_SIZE: u32 = 8;
125pub const OT_MAC_KEY_SIZE: u32 = 16;
126pub const OT_IP6_PREFIX_SIZE: u32 = 8;
127pub const OT_IP6_PREFIX_BITSIZE: u32 = 64;
128pub const OT_IP6_IID_SIZE: u32 = 8;
129pub const OT_IP6_ADDRESS_SIZE: u32 = 16;
130pub const OT_IP6_ADDRESS_BITSIZE: u32 = 128;
131pub const OT_IP6_HEADER_SIZE: u32 = 40;
132pub const OT_IP6_HEADER_PROTO_OFFSET: u32 = 6;
133pub const OT_IP6_ADDRESS_STRING_SIZE: u32 = 40;
134pub const OT_IP6_SOCK_ADDR_STRING_SIZE: u32 = 48;
135pub const OT_IP6_PREFIX_STRING_SIZE: u32 = 45;
136pub const OT_IP6_MAX_MLR_ADDRESSES: u32 = 15;
137pub const OT_NETWORK_KEY_SIZE: u32 = 16;
138pub const OT_NETWORK_NAME_MAX_SIZE: u32 = 16;
139pub const OT_EXT_PAN_ID_SIZE: u32 = 8;
140pub const OT_MESH_LOCAL_PREFIX_SIZE: u32 = 8;
141pub const OT_PSKC_MAX_SIZE: u32 = 16;
142pub const OT_CHANNEL_1_MASK: u32 = 2;
143pub const OT_CHANNEL_2_MASK: u32 = 4;
144pub const OT_CHANNEL_3_MASK: u32 = 8;
145pub const OT_CHANNEL_4_MASK: u32 = 16;
146pub const OT_CHANNEL_5_MASK: u32 = 32;
147pub const OT_CHANNEL_6_MASK: u32 = 64;
148pub const OT_CHANNEL_7_MASK: u32 = 128;
149pub const OT_CHANNEL_8_MASK: u32 = 256;
150pub const OT_CHANNEL_9_MASK: u32 = 512;
151pub const OT_CHANNEL_10_MASK: u32 = 1024;
152pub const OT_CHANNEL_11_MASK: u32 = 2048;
153pub const OT_CHANNEL_12_MASK: u32 = 4096;
154pub const OT_CHANNEL_13_MASK: u32 = 8192;
155pub const OT_CHANNEL_14_MASK: u32 = 16384;
156pub const OT_CHANNEL_15_MASK: u32 = 32768;
157pub const OT_CHANNEL_16_MASK: u32 = 65536;
158pub const OT_CHANNEL_17_MASK: u32 = 131072;
159pub const OT_CHANNEL_18_MASK: u32 = 262144;
160pub const OT_CHANNEL_19_MASK: u32 = 524288;
161pub const OT_CHANNEL_20_MASK: u32 = 1048576;
162pub const OT_CHANNEL_21_MASK: u32 = 2097152;
163pub const OT_CHANNEL_22_MASK: u32 = 4194304;
164pub const OT_CHANNEL_23_MASK: u32 = 8388608;
165pub const OT_CHANNEL_24_MASK: u32 = 16777216;
166pub const OT_CHANNEL_25_MASK: u32 = 33554432;
167pub const OT_CHANNEL_26_MASK: u32 = 67108864;
168pub const OT_OPERATIONAL_DATASET_MAX_LENGTH: u32 = 254;
169pub const OT_JOINER_MAX_DISCERNER_LENGTH: u32 = 64;
170pub const OT_COMMISSIONING_PASSPHRASE_MIN_SIZE: u32 = 6;
171pub const OT_COMMISSIONING_PASSPHRASE_MAX_SIZE: u32 = 255;
172pub const OT_PROVISIONING_URL_MAX_SIZE: u32 = 64;
173pub const OT_STEERING_DATA_MAX_LENGTH: u32 = 16;
174pub const OT_JOINER_MAX_PSKD_LENGTH: u32 = 32;
175pub const OT_NETWORK_DATA_ITERATOR_INIT: u32 = 0;
176pub const OT_SERVICE_DATA_MAX_SIZE: u32 = 252;
177pub const OT_SERVER_DATA_MAX_SIZE: u32 = 248;
178pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT: u32 = 0;
179pub const OT_BORDER_AGENT_ID_LENGTH: u32 = 16;
180pub const OT_BORDER_AGENT_MESHCOP_SERVICE_TXT_DATA_MAX_LENGTH: u32 = 128;
181pub const OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH: u32 = 6;
182pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH: u32 = 32;
183pub const OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT: u32 = 120000;
184pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT: u32 = 600000;
185pub const OT_DEFAULT_COAP_PORT: u32 = 5683;
186pub const OT_COAP_DEFAULT_TOKEN_LENGTH: u32 = 2;
187pub const OT_COAP_MAX_TOKEN_LENGTH: u32 = 8;
188pub const OT_COAP_MAX_RETRANSMIT: u32 = 20;
189pub const OT_COAP_MIN_ACK_TIMEOUT: u32 = 1000;
190pub const OT_DEFAULT_COAP_SECURE_PORT: u32 = 5684;
191pub const OPENTHREAD_LIB_SPINEL_RX_FRAME_BUFFER_SIZE: u32 = 65535;
192pub const OPENTHREAD_POSIX_CONFIG_RCP_TIME_SYNC_INTERVAL: u32 = 60000000;
193pub const OPENTHREAD_SPINEL_CONFIG_ABORT_ON_UNEXPECTED_RCP_RESET_ENABLE: u32 = 1;
194pub const OT_DNS_MAX_NAME_SIZE: u32 = 255;
195pub const OT_DNS_MAX_LABEL_SIZE: u32 = 64;
196pub const OT_DNS_TXT_KEY_MIN_LENGTH: u32 = 1;
197pub const OT_DNS_TXT_KEY_MAX_LENGTH: u32 = 9;
198pub const OT_DNS_TXT_KEY_ITER_MAX_LENGTH: u32 = 64;
199pub const OT_ICMP6_HEADER_DATA_SIZE: u32 = 4;
200pub const OT_ICMP6_ROUTER_ADVERT_MIN_SIZE: u32 = 16;
201pub const OT_MAC_FILTER_FIXED_RSS_DISABLED: u32 = 127;
202pub const OT_MAC_FILTER_ITERATOR_INIT: u32 = 0;
203pub const OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC: u32 = 160;
204pub const OT_LOG_HEX_DUMP_LINE_SIZE: u32 = 73;
205pub const OT_IP4_ADDRESS_SIZE: u32 = 4;
206pub const OT_IP4_ADDRESS_STRING_SIZE: u32 = 17;
207pub const OT_IP4_CIDR_STRING_SIZE: u32 = 20;
208pub const OT_THREAD_VERSION_INVALID: u32 = 0;
209pub const OT_THREAD_VERSION_1_1: u32 = 2;
210pub const OT_THREAD_VERSION_1_2: u32 = 3;
211pub const OT_THREAD_VERSION_1_3: u32 = 4;
212pub const OT_THREAD_VERSION_1_3_1: u32 = 5;
213pub const OT_THREAD_VERSION_1_4: u32 = 5;
214pub const OT_NETWORK_BASE_TLV_MAX_LENGTH: u32 = 254;
215pub const OT_NETWORK_MAX_ROUTER_ID: u32 = 62;
216pub const OT_NEIGHBOR_INFO_ITERATOR_INIT: u32 = 0;
217pub const OT_JOINER_ADVDATA_MAX_LENGTH: u32 = 64;
218pub const OT_DURATION_STRING_SIZE: u32 = 21;
219pub const OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS: u32 = 0;
220pub const OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS: u32 = 1;
221pub const OT_NETWORK_DIAGNOSTIC_TLV_MODE: u32 = 2;
222pub const OT_NETWORK_DIAGNOSTIC_TLV_TIMEOUT: u32 = 3;
223pub const OT_NETWORK_DIAGNOSTIC_TLV_CONNECTIVITY: u32 = 4;
224pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTE: u32 = 5;
225pub const OT_NETWORK_DIAGNOSTIC_TLV_LEADER_DATA: u32 = 6;
226pub const OT_NETWORK_DIAGNOSTIC_TLV_NETWORK_DATA: u32 = 7;
227pub const OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST: u32 = 8;
228pub const OT_NETWORK_DIAGNOSTIC_TLV_MAC_COUNTERS: u32 = 9;
229pub const OT_NETWORK_DIAGNOSTIC_TLV_BATTERY_LEVEL: u32 = 14;
230pub const OT_NETWORK_DIAGNOSTIC_TLV_SUPPLY_VOLTAGE: u32 = 15;
231pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE: u32 = 16;
232pub const OT_NETWORK_DIAGNOSTIC_TLV_CHANNEL_PAGES: u32 = 17;
233pub const OT_NETWORK_DIAGNOSTIC_TLV_TYPE_LIST: u32 = 18;
234pub const OT_NETWORK_DIAGNOSTIC_TLV_MAX_CHILD_TIMEOUT: u32 = 19;
235pub const OT_NETWORK_DIAGNOSTIC_TLV_EUI64: u32 = 23;
236pub const OT_NETWORK_DIAGNOSTIC_TLV_VERSION: u32 = 24;
237pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_NAME: u32 = 25;
238pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_MODEL: u32 = 26;
239pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_SW_VERSION: u32 = 27;
240pub const OT_NETWORK_DIAGNOSTIC_TLV_THREAD_STACK_VERSION: u32 = 28;
241pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD: u32 = 29;
242pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_IP6_ADDR_LIST: u32 = 30;
243pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTER_NEIGHBOR: u32 = 31;
244pub const OT_NETWORK_DIAGNOSTIC_TLV_ANSWER: u32 = 32;
245pub const OT_NETWORK_DIAGNOSTIC_TLV_QUERY_ID: u32 = 33;
246pub const OT_NETWORK_DIAGNOSTIC_TLV_MLE_COUNTERS: u32 = 34;
247pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_APP_URL: u32 = 35;
248pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_NAME_TLV_LENGTH: u32 = 32;
249pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_MODEL_TLV_LENGTH: u32 = 32;
250pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_SW_VERSION_TLV_LENGTH: u32 = 16;
251pub const OT_NETWORK_DIAGNOSTIC_MAX_THREAD_STACK_VERSION_TLV_LENGTH: u32 = 64;
252pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_APP_URL_TLV_LENGTH: u32 = 96;
253pub const OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT: u32 = 0;
254pub const OT_TIME_SYNC_INVALID_SEQ: u32 = 0;
255pub const OT_PLAT_INFRA_IF_MAX_LINK_LAYER_ADDR_LENGTH: u32 = 16;
256pub const OT_MS_PER_S: u32 = 1000;
257pub const OT_US_PER_MS: u32 = 1000;
258pub const OT_US_PER_S: u32 = 1000000;
259pub const OT_NS_PER_US: u32 = 1000;
260pub const OT_SNTP_DEFAULT_SERVER_IP: &[u8; 19usize] = b"2001:4860:4806:8::\0";
261pub const OT_SNTP_DEFAULT_SERVER_PORT: u32 = 123;
262pub const OT_TCP_ENDPOINT_TCB_SIZE_BASE: u32 = 392;
263pub const OT_TCP_ENDPOINT_TCB_NUM_PTR: u32 = 36;
264pub const OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS: u32 = 2598;
265pub const OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS: u32 = 4157;
266pub const OT_TCP_LISTENER_TCB_SIZE_BASE: u32 = 16;
267pub const OT_TCP_LISTENER_TCB_NUM_PTR: u32 = 3;
268pub const OT_CHILD_IP6_ADDRESS_ITERATOR_INIT: u32 = 0;
269#[doc = " No error."]
270pub const OT_ERROR_NONE: otError = 0;
271#[doc = " Operational failed."]
272pub const OT_ERROR_FAILED: otError = 1;
273#[doc = " Message was dropped."]
274pub const OT_ERROR_DROP: otError = 2;
275#[doc = " Insufficient buffers."]
276pub const OT_ERROR_NO_BUFS: otError = 3;
277#[doc = " No route available."]
278pub const OT_ERROR_NO_ROUTE: otError = 4;
279#[doc = " Service is busy and could not service the operation."]
280pub const OT_ERROR_BUSY: otError = 5;
281#[doc = " Failed to parse message."]
282pub const OT_ERROR_PARSE: otError = 6;
283#[doc = " Input arguments are invalid."]
284pub const OT_ERROR_INVALID_ARGS: otError = 7;
285#[doc = " Security checks failed."]
286pub const OT_ERROR_SECURITY: otError = 8;
287#[doc = " Address resolution requires an address query operation."]
288pub const OT_ERROR_ADDRESS_QUERY: otError = 9;
289#[doc = " Address is not in the source match table."]
290pub const OT_ERROR_NO_ADDRESS: otError = 10;
291#[doc = " Operation was aborted."]
292pub const OT_ERROR_ABORT: otError = 11;
293#[doc = " Function or method is not implemented."]
294pub const OT_ERROR_NOT_IMPLEMENTED: otError = 12;
295#[doc = " Cannot complete due to invalid state."]
296pub const OT_ERROR_INVALID_STATE: otError = 13;
297#[doc = " No acknowledgment was received after macMaxFrameRetries (IEEE 802.15.4-2006)."]
298pub const OT_ERROR_NO_ACK: otError = 14;
299#[doc = " A transmission could not take place due to activity on the channel, i.e., the CSMA-CA mechanism has failed\n (IEEE 802.15.4-2006)."]
300pub const OT_ERROR_CHANNEL_ACCESS_FAILURE: otError = 15;
301#[doc = " Not currently attached to a Thread Partition."]
302pub const OT_ERROR_DETACHED: otError = 16;
303#[doc = " FCS check failure while receiving."]
304pub const OT_ERROR_FCS: otError = 17;
305#[doc = " No frame received."]
306pub const OT_ERROR_NO_FRAME_RECEIVED: otError = 18;
307#[doc = " Received a frame from an unknown neighbor."]
308pub const OT_ERROR_UNKNOWN_NEIGHBOR: otError = 19;
309#[doc = " Received a frame from an invalid source address."]
310pub const OT_ERROR_INVALID_SOURCE_ADDRESS: otError = 20;
311#[doc = " Received a frame filtered by the address filter (allowlisted or denylisted)."]
312pub const OT_ERROR_ADDRESS_FILTERED: otError = 21;
313#[doc = " Received a frame filtered by the destination address check."]
314pub const OT_ERROR_DESTINATION_ADDRESS_FILTERED: otError = 22;
315#[doc = " The requested item could not be found."]
316pub const OT_ERROR_NOT_FOUND: otError = 23;
317#[doc = " The operation is already in progress."]
318pub const OT_ERROR_ALREADY: otError = 24;
319#[doc = " The creation of IPv6 address failed."]
320pub const OT_ERROR_IP6_ADDRESS_CREATION_FAILURE: otError = 26;
321#[doc = " Operation prevented by mode flags"]
322pub const OT_ERROR_NOT_CAPABLE: otError = 27;
323#[doc = " Coap response or acknowledgment or DNS, SNTP response not received."]
324pub const OT_ERROR_RESPONSE_TIMEOUT: otError = 28;
325#[doc = " Received a duplicated frame."]
326pub const OT_ERROR_DUPLICATED: otError = 29;
327#[doc = " Message is being dropped from reassembly list due to timeout."]
328pub const OT_ERROR_REASSEMBLY_TIMEOUT: otError = 30;
329#[doc = " Message is not a TMF Message."]
330pub const OT_ERROR_NOT_TMF: otError = 31;
331#[doc = " Received a non-lowpan data frame."]
332pub const OT_ERROR_NOT_LOWPAN_DATA_FRAME: otError = 32;
333#[doc = " The link margin was too low."]
334pub const OT_ERROR_LINK_MARGIN_LOW: otError = 34;
335#[doc = " Input (CLI) command is invalid."]
336pub const OT_ERROR_INVALID_COMMAND: otError = 35;
337#[doc = " Special error code used to indicate success/error status is pending and not yet known."]
338pub const OT_ERROR_PENDING: otError = 36;
339#[doc = " Request rejected."]
340pub const OT_ERROR_REJECTED: otError = 37;
341#[doc = " The number of defined errors."]
342pub const OT_NUM_ERRORS: otError = 38;
343#[doc = " Generic error (should not use)."]
344pub const OT_ERROR_GENERIC: otError = 255;
345#[doc = " Represents error codes used throughout OpenThread."]
346pub type otError = ::std::os::raw::c_uint;
347extern "C" {
348    #[doc = " Converts an otError enum into a string.\n\n @param[in]  aError     An otError enum.\n\n @returns  A string representation of an otError."]
349    pub fn otThreadErrorToString(aError: otError) -> *const ::std::os::raw::c_char;
350}
351pub type va_list = __builtin_va_list;
352#[doc = " Represents the log level."]
353pub type otLogLevel = ::std::os::raw::c_int;
354#[doc = "< OpenThread API"]
355pub const OT_LOG_REGION_API: otLogRegion = 1;
356#[doc = "< MLE"]
357pub const OT_LOG_REGION_MLE: otLogRegion = 2;
358#[doc = "< EID-to-RLOC mapping."]
359pub const OT_LOG_REGION_ARP: otLogRegion = 3;
360#[doc = "< Network Data"]
361pub const OT_LOG_REGION_NET_DATA: otLogRegion = 4;
362#[doc = "< ICMPv6"]
363pub const OT_LOG_REGION_ICMP: otLogRegion = 5;
364#[doc = "< IPv6"]
365pub const OT_LOG_REGION_IP6: otLogRegion = 6;
366#[doc = "< TCP"]
367pub const OT_LOG_REGION_TCP: otLogRegion = 7;
368#[doc = "< IEEE 802.15.4 MAC"]
369pub const OT_LOG_REGION_MAC: otLogRegion = 8;
370#[doc = "< Memory"]
371pub const OT_LOG_REGION_MEM: otLogRegion = 9;
372#[doc = "< NCP"]
373pub const OT_LOG_REGION_NCP: otLogRegion = 10;
374#[doc = "< Mesh Commissioning Protocol"]
375pub const OT_LOG_REGION_MESH_COP: otLogRegion = 11;
376#[doc = "< Network Diagnostic"]
377pub const OT_LOG_REGION_NET_DIAG: otLogRegion = 12;
378#[doc = "< Platform"]
379pub const OT_LOG_REGION_PLATFORM: otLogRegion = 13;
380#[doc = "< CoAP"]
381pub const OT_LOG_REGION_COAP: otLogRegion = 14;
382#[doc = "< CLI"]
383pub const OT_LOG_REGION_CLI: otLogRegion = 15;
384#[doc = "< OpenThread Core"]
385pub const OT_LOG_REGION_CORE: otLogRegion = 16;
386#[doc = "< Utility module"]
387pub const OT_LOG_REGION_UTIL: otLogRegion = 17;
388#[doc = "< Backbone Router (available since Thread 1.2)"]
389pub const OT_LOG_REGION_BBR: otLogRegion = 18;
390#[doc = "< Multicast Listener Registration (available since Thread 1.2)"]
391pub const OT_LOG_REGION_MLR: otLogRegion = 19;
392#[doc = "< Domain Unicast Address (available since Thread 1.2)"]
393pub const OT_LOG_REGION_DUA: otLogRegion = 20;
394#[doc = "< Border Router"]
395pub const OT_LOG_REGION_BR: otLogRegion = 21;
396#[doc = "< Service Registration Protocol (SRP)"]
397pub const OT_LOG_REGION_SRP: otLogRegion = 22;
398#[doc = "< DNS"]
399pub const OT_LOG_REGION_DNS: otLogRegion = 23;
400#[doc = " Represents log regions.\n\n The support for log region is removed and instead each core module can define its own name to appended to the logs.\n However, the `otLogRegion` enumeration is still defined as before to help with platforms which we may be using it\n in their `otPlatLog()` implementation. The OT core will always emit all logs with `OT_LOG_REGION_CORE`."]
401pub type otLogRegion = ::std::os::raw::c_uint;
402extern "C" {
403    #[doc = " Outputs logs.\n\n Note that the support for log region is removed. The OT core will always emit all logs with `OT_LOG_REGION_CORE`\n as @p aLogRegion.\n\n @param[in]  aLogLevel   The log level.\n @param[in]  aLogRegion  The log region.\n @param[in]  aFormat     A pointer to the format string.\n @param[in]  ...         Arguments for the format specification."]
404    pub fn otPlatLog(
405        aLogLevel: otLogLevel,
406        aLogRegion: otLogRegion,
407        aFormat: *const ::std::os::raw::c_char,
408        ...
409    );
410}
411extern "C" {
412    #[doc = " This function handles OpenThread log level changes.\n\n This platform function is called whenever the OpenThread log level changes.\n This platform function is optional since an empty weak implementation has been provided.\n\n @note Only applicable when `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE=1`.\n\n @param[in]  aLogLevel  The new OpenThread log level."]
413    pub fn otPlatLogHandleLevelChanged(aLogLevel: otLogLevel);
414}
415#[repr(C)]
416#[derive(Debug, Default, Copy, Clone)]
417pub struct otInstance {
418    _unused: [u8; 0],
419}
420extern "C" {
421    #[doc = " Initializes the OpenThread library.\n\n Initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread.\n\n Is available and can only be used when support for multiple OpenThread instances is enabled.\n\n @param[in]     aInstanceBuffer      The buffer for OpenThread to use for allocating the otInstance structure.\n @param[in,out] aInstanceBufferSize  On input, the size of aInstanceBuffer. On output, if not enough space for\n                                     otInstance, the number of bytes required for otInstance.\n\n @returns  A pointer to the new OpenThread instance.\n\n @sa otInstanceFinalize"]
422    pub fn otInstanceInit(
423        aInstanceBuffer: *mut ::std::os::raw::c_void,
424        aInstanceBufferSize: *mut usize,
425    ) -> *mut otInstance;
426}
427extern "C" {
428    #[doc = " Initializes the static single instance of the OpenThread library.\n\n Initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread.\n\n Is available and can only be used when support for multiple OpenThread instances is disabled.\n\n @returns A pointer to the single OpenThread instance."]
429    pub fn otInstanceInitSingle() -> *mut otInstance;
430}
431extern "C" {
432    #[doc = " Initializes the OpenThread instance.\n\n This function initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread. This method utilizes static buffer to initialize the OpenThread\n instance.\n\n This function is available and can only be used when support for multiple OpenThread static instances is\n enabled (`OPENTHREAD_CONFIG_MULTIPLE_STATIC_INSTANCE_ENABLE`)\n\n @param[in] aIdx The index of the OpenThread instance to initialize.\n\n @returns  A pointer to the new OpenThread instance."]
433    pub fn otInstanceInitMultiple(aIdx: u8) -> *mut otInstance;
434}
435extern "C" {
436    #[doc = " Gets the instance identifier.\n\n The instance identifier is set to a random value when the instance is constructed, and then its value will not\n change after initialization.\n\n @returns The instance identifier."]
437    pub fn otInstanceGetId(aInstance: *mut otInstance) -> u32;
438}
439extern "C" {
440    #[doc = " Indicates whether or not the instance is valid/initialized.\n\n The instance is considered valid if it is acquired and initialized using either `otInstanceInitSingle()` (in single\n instance case) or `otInstanceInit()` (in multi instance case). A subsequent call to `otInstanceFinalize()` causes\n the instance to be considered as uninitialized.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if the given instance is valid/initialized, FALSE otherwise."]
441    pub fn otInstanceIsInitialized(aInstance: *mut otInstance) -> bool;
442}
443extern "C" {
444    #[doc = " Disables the OpenThread library.\n\n Call this function when OpenThread is no longer in use.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
445    pub fn otInstanceFinalize(aInstance: *mut otInstance);
446}
447extern "C" {
448    #[doc = " Returns the current instance uptime (in msec).\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The uptime is given as number of milliseconds since OpenThread instance was initialized.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The uptime (number of milliseconds)."]
449    pub fn otInstanceGetUptime(aInstance: *mut otInstance) -> u64;
450}
451extern "C" {
452    #[doc = " Returns the current instance uptime as a human-readable string.\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The string follows the format \"<hh>:<mm>:<ss>.<mmmm>\" for hours, minutes, seconds and millisecond (if uptime is\n shorter than one day) or \"<dd>d.<hh>:<mm>:<ss>.<mmmm>\" (if longer than a day).\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[out] aBuffer   A pointer to a char array to output the string.\n @param[in]  aSize     The size of @p aBuffer (in bytes). Recommended to use `OT_UPTIME_STRING_SIZE`."]
453    pub fn otInstanceGetUptimeAsString(
454        aInstance: *mut otInstance,
455        aBuffer: *mut ::std::os::raw::c_char,
456        aSize: u16,
457    );
458}
459#[doc = " Represents a bit-field indicating specific state/configuration that has changed. See `OT_CHANGED_*`\n definitions."]
460pub type otChangedFlags = u32;
461#[doc = " Pointer is called to notify certain configuration or state changes within OpenThread.\n\n @param[in]  aFlags    A bit-field indicating specific state that has changed.  See `OT_CHANGED_*` definitions.\n @param[in]  aContext  A pointer to application-specific context."]
462pub type otStateChangedCallback = ::std::option::Option<
463    unsafe extern "C" fn(aFlags: otChangedFlags, aContext: *mut ::std::os::raw::c_void),
464>;
465extern "C" {
466    #[doc = " Registers a callback to indicate when certain configuration or state changes within OpenThread.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aCallback  A pointer to a function that is called with certain configuration or state changes.\n @param[in]  aContext   A pointer to application-specific context.\n\n @retval OT_ERROR_NONE     Added the callback to the list of callbacks.\n @retval OT_ERROR_ALREADY  The callback was already registered.\n @retval OT_ERROR_NO_BUFS  Could not add the callback due to resource constraints."]
467    pub fn otSetStateChangedCallback(
468        aInstance: *mut otInstance,
469        aCallback: otStateChangedCallback,
470        aContext: *mut ::std::os::raw::c_void,
471    ) -> otError;
472}
473extern "C" {
474    #[doc = " Removes a callback to indicate when certain configuration or state changes within OpenThread.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aCallback   A pointer to a function that is called with certain configuration or state changes.\n @param[in]  aContext    A pointer to application-specific context."]
475    pub fn otRemoveStateChangeCallback(
476        aInstance: *mut otInstance,
477        aCallback: otStateChangedCallback,
478        aContext: *mut ::std::os::raw::c_void,
479    );
480}
481extern "C" {
482    #[doc = " Triggers a platform reset.\n\n The reset process ensures that all the OpenThread state/info (stored in volatile memory) is erased. Note that the\n `otPlatformReset` does not erase any persistent state/info saved in non-volatile memory.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
483    pub fn otInstanceReset(aInstance: *mut otInstance);
484}
485extern "C" {
486    #[doc = " Triggers a platform reset to bootloader mode, if supported.\n\n Requires `OPENTHREAD_CONFIG_PLATFORM_BOOTLOADER_MODE_ENABLE`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE         Reset to bootloader successfully.\n @retval OT_ERROR_BUSY         Failed due to another operation is ongoing.\n @retval OT_ERROR_NOT_CAPABLE  Not capable of resetting to bootloader."]
487    pub fn otInstanceResetToBootloader(aInstance: *mut otInstance) -> otError;
488}
489extern "C" {
490    #[doc = " Deletes all the settings stored on non-volatile memory, and then triggers a platform reset.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
491    pub fn otInstanceFactoryReset(aInstance: *mut otInstance);
492}
493extern "C" {
494    #[doc = " Resets the internal states of the OpenThread radio stack.\n\n Callbacks and configurations are preserved.\n\n This API is only available under radio builds (`OPENTHREAD_RADIO = 1`).\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
495    pub fn otInstanceResetRadioStack(aInstance: *mut otInstance);
496}
497extern "C" {
498    #[doc = " Erases all the OpenThread persistent info (network settings) stored on non-volatile memory.\n Erase is successful only if the device is in `disabled` state/role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           All persistent info/state was erased successfully.\n @retval OT_ERROR_INVALID_STATE  Device is not in `disabled` state/role."]
499    pub fn otInstanceErasePersistentInfo(aInstance: *mut otInstance) -> otError;
500}
501extern "C" {
502    #[doc = " Gets the OpenThread version string.\n\n @returns A pointer to the OpenThread version."]
503    pub fn otGetVersionString() -> *const ::std::os::raw::c_char;
504}
505extern "C" {
506    #[doc = " Gets the OpenThread radio version string.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the OpenThread radio version."]
507    pub fn otGetRadioVersionString(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
508}
509#[doc = " Represents Backbone Router configuration."]
510#[repr(C)]
511#[derive(Debug, Default, Copy, Clone)]
512pub struct otBackboneRouterConfig {
513    #[doc = "< Only used when get Primary Backbone Router information in the Thread Network"]
514    pub mServer16: u16,
515    #[doc = "< Reregistration Delay (in seconds)"]
516    pub mReregistrationDelay: u16,
517    #[doc = "< Multicast Listener Registration Timeout (in seconds)"]
518    pub mMlrTimeout: u32,
519    #[doc = "< Sequence Number"]
520    pub mSequenceNumber: u8,
521}
522extern "C" {
523    #[doc = " Gets the Primary Backbone Router information in the Thread Network.\n\n @param[in]   aInstance            A pointer to an OpenThread instance.\n @param[out]  aConfig              A pointer to where to put Primary Backbone Router information.\n\n @retval OT_ERROR_NONE              Successfully got Primary Backbone Router information.\n @retval OT_ERROR_NOT_FOUND         No Primary Backbone Router exists."]
524    pub fn otBackboneRouterGetPrimary(
525        aInstance: *mut otInstance,
526        aConfig: *mut otBackboneRouterConfig,
527    ) -> otError;
528}
529#[repr(C)]
530#[derive(Debug, Default, Copy, Clone)]
531pub struct otMessage {
532    _unused: [u8; 0],
533}
534#[doc = "< Low priority level."]
535pub const OT_MESSAGE_PRIORITY_LOW: otMessagePriority = 0;
536#[doc = "< Normal priority level."]
537pub const OT_MESSAGE_PRIORITY_NORMAL: otMessagePriority = 1;
538#[doc = "< High priority level."]
539pub const OT_MESSAGE_PRIORITY_HIGH: otMessagePriority = 2;
540#[doc = " Defines the OpenThread message priority levels."]
541pub type otMessagePriority = ::std::os::raw::c_uint;
542#[doc = "< Message from Thread Netif."]
543pub const OT_MESSAGE_ORIGIN_THREAD_NETIF: otMessageOrigin = 0;
544#[doc = "< Message from a trusted source on host."]
545pub const OT_MESSAGE_ORIGIN_HOST_TRUSTED: otMessageOrigin = 1;
546#[doc = "< Message from an untrusted source on host."]
547pub const OT_MESSAGE_ORIGIN_HOST_UNTRUSTED: otMessageOrigin = 2;
548#[doc = " Defines the OpenThread message origins."]
549pub type otMessageOrigin = ::std::os::raw::c_uint;
550#[doc = " Represents a message settings."]
551#[repr(C)]
552#[derive(Debug, Default, Copy, Clone)]
553pub struct otMessageSettings {
554    #[doc = "< TRUE if the message should be secured at Layer 2."]
555    pub mLinkSecurityEnabled: bool,
556    #[doc = "< Priority level (MUST be a `OT_MESSAGE_PRIORITY_*` from `otMessagePriority`)."]
557    pub mPriority: u8,
558}
559#[doc = " Represents link-specific information for messages received from the Thread radio."]
560#[repr(C)]
561#[derive(Debug, Default, Copy, Clone)]
562pub struct otThreadLinkInfo {
563    #[doc = "< Source PAN ID"]
564    pub mPanId: u16,
565    #[doc = "< 802.15.4 Channel"]
566    pub mChannel: u8,
567    #[doc = "< Received Signal Strength in dBm (averaged over fragments)"]
568    pub mRss: i8,
569    #[doc = "< Average Link Quality Indicator (averaged over fragments)"]
570    pub mLqi: u8,
571    pub _bitfield_align_1: [u8; 0],
572    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
573    #[doc = "< The time sync sequence."]
574    pub mTimeSyncSeq: u8,
575    #[doc = "< The time offset to the Thread network time, in microseconds."]
576    pub mNetworkTimeOffset: i64,
577    #[doc = "< Radio link type."]
578    pub mRadioType: u8,
579}
580impl otThreadLinkInfo {
581    #[inline]
582    pub fn mLinkSecurity(&self) -> bool {
583        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
584    }
585    #[inline]
586    pub fn set_mLinkSecurity(&mut self, val: bool) {
587        unsafe {
588            let val: u8 = ::std::mem::transmute(val);
589            self._bitfield_1.set(0usize, 1u8, val as u64)
590        }
591    }
592    #[inline]
593    pub fn mIsDstPanIdBroadcast(&self) -> bool {
594        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
595    }
596    #[inline]
597    pub fn set_mIsDstPanIdBroadcast(&mut self, val: bool) {
598        unsafe {
599            let val: u8 = ::std::mem::transmute(val);
600            self._bitfield_1.set(1usize, 1u8, val as u64)
601        }
602    }
603    #[inline]
604    pub fn new_bitfield_1(
605        mLinkSecurity: bool,
606        mIsDstPanIdBroadcast: bool,
607    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
608        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
609        __bindgen_bitfield_unit.set(0usize, 1u8, {
610            let mLinkSecurity: u8 = unsafe { ::std::mem::transmute(mLinkSecurity) };
611            mLinkSecurity as u64
612        });
613        __bindgen_bitfield_unit.set(1usize, 1u8, {
614            let mIsDstPanIdBroadcast: u8 = unsafe { ::std::mem::transmute(mIsDstPanIdBroadcast) };
615            mIsDstPanIdBroadcast as u64
616        });
617        __bindgen_bitfield_unit
618    }
619}
620extern "C" {
621    #[doc = " Free an allocated message buffer.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite"]
622    pub fn otMessageFree(aMessage: *mut otMessage);
623}
624extern "C" {
625    #[doc = " Get the message length in bytes.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @returns The message length in bytes.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n @sa otMessageSetLength"]
626    pub fn otMessageGetLength(aMessage: *const otMessage) -> u16;
627}
628extern "C" {
629    #[doc = " Set the message length in bytes.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aLength   A length in bytes.\n\n @retval OT_ERROR_NONE     Successfully set the message length.\n @retval OT_ERROR_NO_BUFS  No available buffers to grow the message.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite"]
630    pub fn otMessageSetLength(aMessage: *mut otMessage, aLength: u16) -> otError;
631}
632extern "C" {
633    #[doc = " Get the message offset in bytes.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @returns The message offset value.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite"]
634    pub fn otMessageGetOffset(aMessage: *const otMessage) -> u16;
635}
636extern "C" {
637    #[doc = " Set the message offset in bytes.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aOffset   An offset in bytes.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageRead\n @sa otMessageWrite"]
638    pub fn otMessageSetOffset(aMessage: *mut otMessage, aOffset: u16);
639}
640extern "C" {
641    #[doc = " Indicates whether or not link security is enabled for the message.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @retval TRUE   If link security is enabled.\n @retval FALSE  If link security is not enabled."]
642    pub fn otMessageIsLinkSecurityEnabled(aMessage: *const otMessage) -> bool;
643}
644extern "C" {
645    #[doc = " Indicates whether or not the message is allowed to be looped back to host.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @retval TRUE   If the message is allowed to be looped back to host.\n @retval FALSE  If the message is not allowed to be looped back to host."]
646    pub fn otMessageIsLoopbackToHostAllowed(aMessage: *const otMessage) -> bool;
647}
648extern "C" {
649    #[doc = " Sets whether or not the message is allowed to be looped back to host.\n\n @param[in]  aMessage              A pointer to a message buffer.\n @param[in]  aAllowLoopbackToHost  Whether to allow the message to be looped back to host."]
650    pub fn otMessageSetLoopbackToHostAllowed(aMessage: *mut otMessage, aAllowLoopbackToHost: bool);
651}
652extern "C" {
653    #[doc = " Indicates whether the given message may be looped back in a case of a multicast destination address.\n\n If @p aMessage is used along with an `otMessageInfo`, the `mMulticastLoop` field from `otMessageInfo` structure\n takes precedence and will be used instead of the the value set on @p aMessage.\n\n This API is mainly intended for use along with `otIp6Send()` which expects an already prepared IPv6 message.\n\n @param[in]  aMessage A pointer to the message."]
654    pub fn otMessageIsMulticastLoopEnabled(aMessage: *mut otMessage) -> bool;
655}
656extern "C" {
657    #[doc = " Controls whether the given message may be looped back in a case of a multicast destination address.\n\n @param[in]  aMessage  A pointer to the message.\n @param[in]  aEnabled  The configuration value."]
658    pub fn otMessageSetMulticastLoopEnabled(aMessage: *mut otMessage, aEnabled: bool);
659}
660extern "C" {
661    #[doc = " Gets the message origin.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @returns The message origin."]
662    pub fn otMessageGetOrigin(aMessage: *const otMessage) -> otMessageOrigin;
663}
664extern "C" {
665    #[doc = " Sets the message origin.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aOrigin   The message origin."]
666    pub fn otMessageSetOrigin(aMessage: *mut otMessage, aOrigin: otMessageOrigin);
667}
668extern "C" {
669    #[doc = " Sets/forces the message to be forwarded using direct transmission.\n Default setting for a new message is `false`.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aEnabled  If `true`, the message is forced to use direct transmission. If `false`, the message follows\n                       the normal procedure."]
670    pub fn otMessageSetDirectTransmission(aMessage: *mut otMessage, aEnabled: bool);
671}
672extern "C" {
673    #[doc = " Returns the average RSS (received signal strength) associated with the message.\n\n @param[in]  aMessage  A pointer to a message buffer.\n\n @returns The average RSS value (in dBm) or OT_RADIO_RSSI_INVALID if no average RSS is available."]
674    pub fn otMessageGetRss(aMessage: *const otMessage) -> i8;
675}
676extern "C" {
677    #[doc = " Retrieves the link-specific information for a message received over Thread radio.\n\n @param[in] aMessage    The message from which to retrieve `otThreadLinkInfo`.\n @pram[out] aLinkInfo   A pointer to an `otThreadLinkInfo` to populate.\n\n @retval OT_ERROR_NONE       Successfully retrieved the link info, @p `aLinkInfo` is updated.\n @retval OT_ERROR_NOT_FOUND  Message origin is not `OT_MESSAGE_ORIGIN_THREAD_NETIF`."]
678    pub fn otMessageGetThreadLinkInfo(
679        aMessage: *const otMessage,
680        aLinkInfo: *mut otThreadLinkInfo,
681    ) -> otError;
682}
683extern "C" {
684    #[doc = " Append bytes to a message.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aBuf      A pointer to the data to append.\n @param[in]  aLength   Number of bytes to append.\n\n @retval OT_ERROR_NONE     Successfully appended to the message\n @retval OT_ERROR_NO_BUFS  No available buffers to grow the message.\n\n @sa otMessageFree\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite"]
685    pub fn otMessageAppend(
686        aMessage: *mut otMessage,
687        aBuf: *const ::std::os::raw::c_void,
688        aLength: u16,
689    ) -> otError;
690}
691extern "C" {
692    #[doc = " Read bytes from a message.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aOffset   An offset in bytes.\n @param[in]  aBuf      A pointer to a buffer that message bytes are read to.\n @param[in]  aLength   Number of bytes to read.\n\n @returns The number of bytes read.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageWrite"]
693    pub fn otMessageRead(
694        aMessage: *const otMessage,
695        aOffset: u16,
696        aBuf: *mut ::std::os::raw::c_void,
697        aLength: u16,
698    ) -> u16;
699}
700extern "C" {
701    #[doc = " Write bytes to a message.\n\n @param[in]  aMessage  A pointer to a message buffer.\n @param[in]  aOffset   An offset in bytes.\n @param[in]  aBuf      A pointer to a buffer that message bytes are written from.\n @param[in]  aLength   Number of bytes to write.\n\n @returns The number of bytes written.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead"]
702    pub fn otMessageWrite(
703        aMessage: *mut otMessage,
704        aOffset: u16,
705        aBuf: *const ::std::os::raw::c_void,
706        aLength: u16,
707    ) -> ::std::os::raw::c_int;
708}
709#[doc = " Represents an OpenThread message queue."]
710#[repr(C)]
711#[derive(Debug, Copy, Clone)]
712pub struct otMessageQueue {
713    #[doc = "< Opaque data used by the implementation."]
714    pub mData: *mut ::std::os::raw::c_void,
715}
716impl Default for otMessageQueue {
717    fn default() -> Self {
718        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
719        unsafe {
720            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
721            s.assume_init()
722        }
723    }
724}
725#[doc = " Represents information about a message queue."]
726#[repr(C)]
727#[derive(Debug, Default, Copy, Clone)]
728pub struct otMessageQueueInfo {
729    #[doc = "< Number of messages in the queue."]
730    pub mNumMessages: u16,
731    #[doc = "< Number of data buffers used by messages in the queue."]
732    pub mNumBuffers: u16,
733    #[doc = "< Total number of bytes used by all messages in the queue."]
734    pub mTotalBytes: u32,
735}
736#[doc = " Represents the message buffer information for different queues used by OpenThread stack."]
737#[repr(C)]
738#[derive(Debug, Default, Copy, Clone)]
739pub struct otBufferInfo {
740    #[doc = "< The total number of buffers in the messages pool (0xffff if unknown)."]
741    pub mTotalBuffers: u16,
742    #[doc = "< The number of free buffers (0xffff if unknown)."]
743    pub mFreeBuffers: u16,
744    #[doc = " The maximum number of used buffers at the same time since OT stack initialization or last call to\n `otMessageResetBufferInfo()`."]
745    pub mMaxUsedBuffers: u16,
746    #[doc = "< Info about 6LoWPAN send queue."]
747    pub m6loSendQueue: otMessageQueueInfo,
748    #[doc = "< Info about 6LoWPAN reassembly queue."]
749    pub m6loReassemblyQueue: otMessageQueueInfo,
750    #[doc = "< Info about IPv6 send queue."]
751    pub mIp6Queue: otMessageQueueInfo,
752    #[doc = "< Info about MPL send queue."]
753    pub mMplQueue: otMessageQueueInfo,
754    #[doc = "< Info about MLE delayed message queue."]
755    pub mMleQueue: otMessageQueueInfo,
756    #[doc = "< Info about CoAP/TMF send queue."]
757    pub mCoapQueue: otMessageQueueInfo,
758    #[doc = "< Info about CoAP secure send queue."]
759    pub mCoapSecureQueue: otMessageQueueInfo,
760    #[doc = "< Info about application CoAP send queue."]
761    pub mApplicationCoapQueue: otMessageQueueInfo,
762}
763extern "C" {
764    #[doc = " Initialize the message queue.\n\n MUST be called once and only once for a `otMessageQueue` instance before any other `otMessageQueue`\n functions. The behavior is undefined if other queue APIs are used with an `otMessageQueue` before it being\n initialized or if it is initialized more than once.\n\n @param[in]  aQueue     A pointer to a message queue."]
765    pub fn otMessageQueueInit(aQueue: *mut otMessageQueue);
766}
767extern "C" {
768    #[doc = " Adds a message to the end of the given message queue.\n\n @param[in]  aQueue    A pointer to the message queue.\n @param[in]  aMessage  The message to add."]
769    pub fn otMessageQueueEnqueue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
770}
771extern "C" {
772    #[doc = " Adds a message at the head/front of the given message queue.\n\n @param[in]  aQueue    A pointer to the message queue.\n @param[in]  aMessage  The message to add."]
773    pub fn otMessageQueueEnqueueAtHead(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
774}
775extern "C" {
776    #[doc = " Removes a message from the given message queue.\n\n @param[in]  aQueue    A pointer to the message queue.\n @param[in]  aMessage  The message to remove."]
777    pub fn otMessageQueueDequeue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
778}
779extern "C" {
780    #[doc = " Returns a pointer to the message at the head of the queue.\n\n @param[in]  aQueue    A pointer to a message queue.\n\n @returns  A pointer to the message at the head of queue or NULL if queue is empty."]
781    pub fn otMessageQueueGetHead(aQueue: *mut otMessageQueue) -> *mut otMessage;
782}
783extern "C" {
784    #[doc = " Returns a pointer to the next message in the queue by iterating forward (from head to tail).\n\n @param[in]  aQueue    A pointer to a message queue.\n @param[in]  aMessage  A pointer to current message buffer.\n\n @returns  A pointer to the next message in the queue after `aMessage` or NULL if `aMessage is the tail of queue.\n           NULL is returned if `aMessage` is not in the queue `aQueue`."]
785    pub fn otMessageQueueGetNext(
786        aQueue: *mut otMessageQueue,
787        aMessage: *const otMessage,
788    ) -> *mut otMessage;
789}
790extern "C" {
791    #[doc = " Get the Message Buffer information.\n\n @param[in]   aInstance    A pointer to the OpenThread instance.\n @param[out]  aBufferInfo  A pointer where the message buffer information is written."]
792    pub fn otMessageGetBufferInfo(aInstance: *mut otInstance, aBufferInfo: *mut otBufferInfo);
793}
794extern "C" {
795    #[doc = " Reset the Message Buffer information counter tracking the maximum number buffers in use at the same time.\n\n This resets `mMaxUsedBuffers` in `otBufferInfo`.\n\n @param[in]   aInstance    A pointer to the OpenThread instance."]
796    pub fn otMessageResetBufferInfo(aInstance: *mut otInstance);
797}
798#[doc = "< Key Type: Raw Data."]
799pub const OT_CRYPTO_KEY_TYPE_RAW: otCryptoKeyType = 0;
800#[doc = "< Key Type: AES."]
801pub const OT_CRYPTO_KEY_TYPE_AES: otCryptoKeyType = 1;
802#[doc = "< Key Type: HMAC."]
803pub const OT_CRYPTO_KEY_TYPE_HMAC: otCryptoKeyType = 2;
804#[doc = "< Key Type: ECDSA."]
805pub const OT_CRYPTO_KEY_TYPE_ECDSA: otCryptoKeyType = 3;
806#[doc = " Defines the key types."]
807pub type otCryptoKeyType = ::std::os::raw::c_uint;
808#[doc = "< Key Algorithm: Vendor Defined."]
809pub const OT_CRYPTO_KEY_ALG_VENDOR: otCryptoKeyAlgorithm = 0;
810#[doc = "< Key Algorithm: AES ECB."]
811pub const OT_CRYPTO_KEY_ALG_AES_ECB: otCryptoKeyAlgorithm = 1;
812#[doc = "< Key Algorithm: HMAC SHA-256."]
813pub const OT_CRYPTO_KEY_ALG_HMAC_SHA_256: otCryptoKeyAlgorithm = 2;
814#[doc = "< Key Algorithm: ECDSA."]
815pub const OT_CRYPTO_KEY_ALG_ECDSA: otCryptoKeyAlgorithm = 3;
816#[doc = " Defines the key algorithms."]
817pub type otCryptoKeyAlgorithm = ::std::os::raw::c_uint;
818#[doc = "< Key Usage: Key Usage is empty."]
819pub const OT_CRYPTO_KEY_USAGE_NONE: _bindgen_ty_1 = 0;
820#[doc = "< Key Usage: Key can be exported."]
821pub const OT_CRYPTO_KEY_USAGE_EXPORT: _bindgen_ty_1 = 1;
822#[doc = "< Key Usage: Encryption (vendor defined)."]
823pub const OT_CRYPTO_KEY_USAGE_ENCRYPT: _bindgen_ty_1 = 2;
824#[doc = "< Key Usage: AES ECB."]
825pub const OT_CRYPTO_KEY_USAGE_DECRYPT: _bindgen_ty_1 = 4;
826#[doc = "< Key Usage: Sign Hash."]
827pub const OT_CRYPTO_KEY_USAGE_SIGN_HASH: _bindgen_ty_1 = 8;
828#[doc = "< Key Usage: Verify Hash."]
829pub const OT_CRYPTO_KEY_USAGE_VERIFY_HASH: _bindgen_ty_1 = 16;
830#[doc = " Defines the key usage flags."]
831pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
832#[doc = "< Key Persistence: Key is volatile."]
833pub const OT_CRYPTO_KEY_STORAGE_VOLATILE: otCryptoKeyStorage = 0;
834#[doc = "< Key Persistence: Key is persistent."]
835pub const OT_CRYPTO_KEY_STORAGE_PERSISTENT: otCryptoKeyStorage = 1;
836#[doc = " Defines the key storage types."]
837pub type otCryptoKeyStorage = ::std::os::raw::c_uint;
838#[doc = " This datatype represents the key reference."]
839pub type otCryptoKeyRef = u32;
840#[doc = " @struct otCryptoKey\n\n Represents the Key Material required for Crypto operations."]
841#[repr(C)]
842#[derive(Debug, Copy, Clone)]
843pub struct otCryptoKey {
844    #[doc = "< Pointer to the buffer containing key. NULL indicates to use `mKeyRef`."]
845    pub mKey: *const u8,
846    #[doc = "< The key length in bytes (applicable when `mKey` is not NULL)."]
847    pub mKeyLength: u16,
848    #[doc = "< The PSA key ref (requires `mKey` to be NULL)."]
849    pub mKeyRef: u32,
850}
851impl Default for otCryptoKey {
852    fn default() -> Self {
853        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
854        unsafe {
855            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
856            s.assume_init()
857        }
858    }
859}
860#[doc = " @struct otCryptoContext\n\n Stores the context object for platform APIs."]
861#[repr(C)]
862#[derive(Debug, Copy, Clone)]
863pub struct otCryptoContext {
864    #[doc = "< Pointer to the context."]
865    pub mContext: *mut ::std::os::raw::c_void,
866    #[doc = "< The length of the context in bytes."]
867    pub mContextSize: u16,
868}
869impl Default for otCryptoContext {
870    fn default() -> Self {
871        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
872        unsafe {
873            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
874            s.assume_init()
875        }
876    }
877}
878#[doc = " @struct otPlatCryptoSha256Hash\n\n Represents a SHA-256 hash."]
879#[repr(C, packed)]
880#[derive(Debug, Default, Copy, Clone)]
881pub struct otPlatCryptoSha256Hash {
882    #[doc = "< Hash bytes."]
883    pub m8: [u8; 32usize],
884}
885#[doc = " @struct otPlatCryptoEcdsaKeyPair\n\n Represents an ECDSA key pair (public and private keys).\n\n The key pair is stored using Distinguished Encoding Rules (DER) format (per RFC 5915)."]
886#[repr(C)]
887#[derive(Debug, Copy, Clone)]
888pub struct otPlatCryptoEcdsaKeyPair {
889    pub mDerBytes: [u8; 125usize],
890    pub mDerLength: u8,
891}
892impl Default for otPlatCryptoEcdsaKeyPair {
893    fn default() -> Self {
894        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
895        unsafe {
896            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
897            s.assume_init()
898        }
899    }
900}
901#[doc = " @struct otPlatCryptoEcdsaPublicKey\n\n Represents a ECDSA public key.\n\n The public key is stored as a byte sequence representation of an uncompressed curve point (RFC 6605 - sec 4)."]
902#[repr(C, packed)]
903#[derive(Debug, Copy, Clone)]
904pub struct otPlatCryptoEcdsaPublicKey {
905    pub m8: [u8; 64usize],
906}
907impl Default for otPlatCryptoEcdsaPublicKey {
908    fn default() -> Self {
909        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
910        unsafe {
911            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
912            s.assume_init()
913        }
914    }
915}
916#[doc = " @struct otPlatCryptoEcdsaSignature\n\n Represents an ECDSA signature.\n\n The signature is encoded as the concatenated binary representation of two MPIs `r` and `s` which are calculated\n during signing (RFC 6605 - section 4)."]
917#[repr(C, packed)]
918#[derive(Debug, Copy, Clone)]
919pub struct otPlatCryptoEcdsaSignature {
920    pub m8: [u8; 64usize],
921}
922impl Default for otPlatCryptoEcdsaSignature {
923    fn default() -> Self {
924        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
925        unsafe {
926            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
927            s.assume_init()
928        }
929    }
930}
931extern "C" {
932    #[doc = " Initialize the Crypto module."]
933    pub fn otPlatCryptoInit();
934}
935extern "C" {
936    #[doc = " Import a key into PSA ITS.\n\n @param[in,out] aKeyRef           Pointer to the key ref to be used for crypto operations.\n @param[in]     aKeyType          Key Type encoding for the key.\n @param[in]     aKeyAlgorithm     Key algorithm encoding for the key.\n @param[in]     aKeyUsage         Key Usage encoding for the key (combinations of `OT_CRYPTO_KEY_USAGE_*`).\n @param[in]     aKeyPersistence   Key Persistence for this key\n @param[in]     aKey              Actual key to be imported.\n @param[in]     aKeyLen           Length of the key to be imported.\n\n @retval OT_ERROR_NONE          Successfully imported the key.\n @retval OT_ERROR_FAILED        Failed to import the key.\n @retval OT_ERROR_INVALID_ARGS  @p aKey was set to NULL.\n\n @note If OT_CRYPTO_KEY_STORAGE_PERSISTENT is passed for aKeyPersistence then @p aKeyRef is input and platform\n       should use the given aKeyRef and MUST not change it.\n\n       If OT_CRYPTO_KEY_STORAGE_VOLATILE is passed for aKeyPersistence then @p aKeyRef is output, the initial\n       value does not matter and platform API MUST update it to return the new key ref.\n\n       This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
937    pub fn otPlatCryptoImportKey(
938        aKeyRef: *mut otCryptoKeyRef,
939        aKeyType: otCryptoKeyType,
940        aKeyAlgorithm: otCryptoKeyAlgorithm,
941        aKeyUsage: ::std::os::raw::c_int,
942        aKeyPersistence: otCryptoKeyStorage,
943        aKey: *const u8,
944        aKeyLen: usize,
945    ) -> otError;
946}
947extern "C" {
948    #[doc = " Export a key stored in PSA ITS.\n\n @param[in]   aKeyRef           The key ref to be used for crypto operations.\n @param[out]  aBuffer           Pointer to the buffer where key needs to be exported.\n @param[in]   aBufferLen        Length of the buffer passed to store the exported key.\n @param[out]  aKeyLen           Pointer to return the length of the exported key.\n\n @retval OT_ERROR_NONE          Successfully exported  @p aKeyRef.\n @retval OT_ERROR_FAILED        Failed to export @p aKeyRef.\n @retval OT_ERROR_INVALID_ARGS  @p aBuffer was NULL\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
949    pub fn otPlatCryptoExportKey(
950        aKeyRef: otCryptoKeyRef,
951        aBuffer: *mut u8,
952        aBufferLen: usize,
953        aKeyLen: *mut usize,
954    ) -> otError;
955}
956extern "C" {
957    #[doc = " Destroy a key stored in PSA ITS.\n\n @param[in]   aKeyRef          The key ref to be destroyed\n\n @retval OT_ERROR_NONE          Successfully destroyed the key.\n @retval OT_ERROR_FAILED        Failed to destroy the key.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
958    pub fn otPlatCryptoDestroyKey(aKeyRef: otCryptoKeyRef) -> otError;
959}
960extern "C" {
961    #[doc = " Check if the key ref passed has an associated key in PSA ITS.\n\n @param[in]  aKeyRef          The Key Ref to check.\n\n @retval TRUE                 There is an associated key with @p aKeyRef.\n @retval FALSE                There is no associated key with @p aKeyRef.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
962    pub fn otPlatCryptoHasKey(aKeyRef: otCryptoKeyRef) -> bool;
963}
964extern "C" {
965    #[doc = " Initialize the HMAC operation.\n\n @param[in]  aContext          Context for HMAC operation.\n\n @retval OT_ERROR_NONE          Successfully initialized HMAC operation.\n @retval OT_ERROR_FAILED        Failed to initialize HMAC operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL\n\n @note The platform driver shall point the context to the correct object such as psa_mac_operation_t or\n       mbedtls_md_context_t."]
966    pub fn otPlatCryptoHmacSha256Init(aContext: *mut otCryptoContext) -> otError;
967}
968extern "C" {
969    #[doc = " Uninitialize the HMAC operation.\n\n @param[in]  aContext          Context for HMAC operation.\n\n @retval OT_ERROR_NONE          Successfully uninitialized HMAC operation.\n @retval OT_ERROR_FAILED        Failed to uninitialized HMAC operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
970    pub fn otPlatCryptoHmacSha256Deinit(aContext: *mut otCryptoContext) -> otError;
971}
972extern "C" {
973    #[doc = " Start HMAC operation.\n\n @param[in]  aContext           Context for HMAC operation.\n @param[in]  aKey               Key material to be used for HMAC operation.\n\n @retval OT_ERROR_NONE          Successfully started HMAC operation.\n @retval OT_ERROR_FAILED        Failed to start HMAC operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aKey was NULL"]
974    pub fn otPlatCryptoHmacSha256Start(
975        aContext: *mut otCryptoContext,
976        aKey: *const otCryptoKey,
977    ) -> otError;
978}
979extern "C" {
980    #[doc = " Update the HMAC operation with new input.\n\n @param[in]  aContext           Context for HMAC operation.\n @param[in]  aBuf               A pointer to the input buffer.\n @param[in]  aBufLength         The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE          Successfully updated HMAC with new input operation.\n @retval OT_ERROR_FAILED        Failed to update HMAC operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aBuf was NULL"]
981    pub fn otPlatCryptoHmacSha256Update(
982        aContext: *mut otCryptoContext,
983        aBuf: *const ::std::os::raw::c_void,
984        aBufLength: u16,
985    ) -> otError;
986}
987extern "C" {
988    #[doc = " Complete the HMAC operation.\n\n @param[in]  aContext           Context for HMAC operation.\n @param[out] aBuf               A pointer to the output buffer.\n @param[in]  aBufLength         The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE          Successfully completed HMAC operation.\n @retval OT_ERROR_FAILED        Failed to complete HMAC operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aBuf was NULL"]
989    pub fn otPlatCryptoHmacSha256Finish(
990        aContext: *mut otCryptoContext,
991        aBuf: *mut u8,
992        aBufLength: usize,
993    ) -> otError;
994}
995extern "C" {
996    #[doc = " Initialise the AES operation.\n\n @param[in]  aContext           Context for AES operation.\n\n @retval OT_ERROR_NONE          Successfully Initialised AES operation.\n @retval OT_ERROR_FAILED        Failed to Initialise AES operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL\n @retval OT_ERROR_NO_BUFS       Cannot allocate the context.\n\n @note The platform driver shall point the context to the correct object such as psa_key_id\n       or mbedtls_aes_context_t."]
997    pub fn otPlatCryptoAesInit(aContext: *mut otCryptoContext) -> otError;
998}
999extern "C" {
1000    #[doc = " Set the key for AES operation.\n\n @param[in]  aContext           Context for AES operation.\n @param[out] aKey               Key to use for AES operation.\n\n @retval OT_ERROR_NONE          Successfully set the key for AES operation.\n @retval OT_ERROR_FAILED        Failed to set the key for AES operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aKey was NULL"]
1001    pub fn otPlatCryptoAesSetKey(
1002        aContext: *mut otCryptoContext,
1003        aKey: *const otCryptoKey,
1004    ) -> otError;
1005}
1006extern "C" {
1007    #[doc = " Encrypt the given data.\n\n @param[in]  aContext           Context for AES operation.\n @param[in]  aInput             Pointer to the input buffer.\n @param[in]  aOutput            Pointer to the output buffer.\n\n @retval OT_ERROR_NONE          Successfully encrypted @p aInput.\n @retval OT_ERROR_FAILED        Failed to encrypt @p aInput.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aKey or @p aOutput were NULL"]
1008    pub fn otPlatCryptoAesEncrypt(
1009        aContext: *mut otCryptoContext,
1010        aInput: *const u8,
1011        aOutput: *mut u8,
1012    ) -> otError;
1013}
1014extern "C" {
1015    #[doc = " Free the AES context.\n\n @param[in]  aContext           Context for AES operation.\n\n @retval OT_ERROR_NONE          Successfully freed AES context.\n @retval OT_ERROR_FAILED        Failed to free AES context.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
1016    pub fn otPlatCryptoAesFree(aContext: *mut otCryptoContext) -> otError;
1017}
1018extern "C" {
1019    #[doc = " Initialise the HKDF context.\n\n @param[in]  aContext           Context for HKDF operation.\n\n @retval OT_ERROR_NONE          Successfully Initialised AES operation.\n @retval OT_ERROR_FAILED        Failed to Initialise AES operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL\n\n @note The platform driver shall point the context to the correct object such as psa_key_derivation_operation_t\n       or HmacSha256::Hash"]
1020    pub fn otPlatCryptoHkdfInit(aContext: *mut otCryptoContext) -> otError;
1021}
1022extern "C" {
1023    #[doc = " Perform HKDF Expand step.\n\n @param[in]  aContext           Operation context for HKDF operation.\n @param[in]  aInfo              Pointer to the Info sequence.\n @param[in]  aInfoLength        Length of the Info sequence.\n @param[out] aOutputKey         Pointer to the output Key.\n @param[in]  aOutputKeyLength   Size of the output key buffer.\n\n @retval OT_ERROR_NONE          HKDF Expand was successful.\n @retval OT_ERROR_FAILED        HKDF Expand failed.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
1024    pub fn otPlatCryptoHkdfExpand(
1025        aContext: *mut otCryptoContext,
1026        aInfo: *const u8,
1027        aInfoLength: u16,
1028        aOutputKey: *mut u8,
1029        aOutputKeyLength: u16,
1030    ) -> otError;
1031}
1032extern "C" {
1033    #[doc = " Perform HKDF Extract step.\n\n @param[in]  aContext           Operation context for HKDF operation.\n @param[in]  aSalt              Pointer to the Salt for HKDF.\n @param[in]  aSaltLength        Length of Salt.\n @param[in]  aInputKey          Pointer to the input key.\n\n @retval OT_ERROR_NONE          HKDF Extract was successful.\n @retval OT_ERROR_FAILED        HKDF Extract failed."]
1034    pub fn otPlatCryptoHkdfExtract(
1035        aContext: *mut otCryptoContext,
1036        aSalt: *const u8,
1037        aSaltLength: u16,
1038        aInputKey: *const otCryptoKey,
1039    ) -> otError;
1040}
1041extern "C" {
1042    #[doc = " Uninitialize the HKDF context.\n\n @param[in]  aContext           Context for HKDF operation.\n\n @retval OT_ERROR_NONE          Successfully un-initialised HKDF operation.\n @retval OT_ERROR_FAILED        Failed to un-initialised HKDF operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
1043    pub fn otPlatCryptoHkdfDeinit(aContext: *mut otCryptoContext) -> otError;
1044}
1045extern "C" {
1046    #[doc = " Initialise the SHA-256 operation.\n\n @param[in]  aContext           Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE          Successfully initialised SHA-256 operation.\n @retval OT_ERROR_FAILED        Failed to initialise SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL\n\n\n @note The platform driver shall point the context to the correct object such as psa_hash_operation_t\n       or mbedtls_sha256_context."]
1047    pub fn otPlatCryptoSha256Init(aContext: *mut otCryptoContext) -> otError;
1048}
1049extern "C" {
1050    #[doc = " Uninitialize the SHA-256 operation.\n\n @param[in]  aContext           Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE          Successfully un-initialised SHA-256 operation.\n @retval OT_ERROR_FAILED        Failed to un-initialised SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
1051    pub fn otPlatCryptoSha256Deinit(aContext: *mut otCryptoContext) -> otError;
1052}
1053extern "C" {
1054    #[doc = " Start SHA-256 operation.\n\n @param[in]  aContext           Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE          Successfully started SHA-256 operation.\n @retval OT_ERROR_FAILED        Failed to start SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext was NULL"]
1055    pub fn otPlatCryptoSha256Start(aContext: *mut otCryptoContext) -> otError;
1056}
1057extern "C" {
1058    #[doc = " Update SHA-256 operation with new input.\n\n @param[in]  aContext           Context for SHA-256 operation.\n @param[in]  aBuf               A pointer to the input buffer.\n @param[in]  aBufLength         The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE          Successfully updated SHA-256 with new input operation.\n @retval OT_ERROR_FAILED        Failed to update SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aBuf was NULL"]
1059    pub fn otPlatCryptoSha256Update(
1060        aContext: *mut otCryptoContext,
1061        aBuf: *const ::std::os::raw::c_void,
1062        aBufLength: u16,
1063    ) -> otError;
1064}
1065extern "C" {
1066    #[doc = " Finish SHA-256 operation.\n\n @param[in]  aContext           Context for SHA-256 operation.\n @param[in]  aHash              A pointer to the output buffer, where hash needs to be stored.\n @param[in]  aHashSize          The length of @p aHash in bytes.\n\n @retval OT_ERROR_NONE          Successfully completed the SHA-256 operation.\n @retval OT_ERROR_FAILED        Failed to complete SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS  @p aContext or @p aHash was NULL"]
1067    pub fn otPlatCryptoSha256Finish(
1068        aContext: *mut otCryptoContext,
1069        aHash: *mut u8,
1070        aHashSize: u16,
1071    ) -> otError;
1072}
1073extern "C" {
1074    #[doc = " Initialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1075    pub fn otPlatCryptoRandomInit();
1076}
1077extern "C" {
1078    #[doc = " Deinitialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1079    pub fn otPlatCryptoRandomDeinit();
1080}
1081extern "C" {
1082    #[doc = " Fills a given buffer with cryptographically secure random bytes.\n\n @param[out] aBuffer            A pointer to a buffer to fill with the random bytes.\n @param[in]  aSize              Size of buffer (number of bytes to fill).\n\n @retval OT_ERROR_NONE          Successfully filled buffer with random values.\n @retval OT_ERROR_FAILED        Operation failed."]
1083    pub fn otPlatCryptoRandomGet(aBuffer: *mut u8, aSize: u16) -> otError;
1084}
1085extern "C" {
1086    #[doc = " Generate and populate the output buffer with a new ECDSA key-pair.\n\n @param[out] aKeyPair           A pointer to an ECDSA key-pair structure to store the generated key-pair.\n\n @retval OT_ERROR_NONE          A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE   Feature not supported.\n @retval OT_ERROR_FAILED        Failed to generate key-pair."]
1087    pub fn otPlatCryptoEcdsaGenerateKey(aKeyPair: *mut otPlatCryptoEcdsaKeyPair) -> otError;
1088}
1089extern "C" {
1090    #[doc = " Get the associated public key from the input context.\n\n @param[in]  aKeyPair           A pointer to an ECDSA key-pair structure where the key-pair is stored.\n @param[out] aPublicKey         A pointer to an ECDSA public key structure to store the public key.\n\n @retval OT_ERROR_NONE          Public key was retrieved successfully, and @p aBuffer is updated.\n @retval OT_ERROR_PARSE         The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_INVALID_ARGS  The @p aContext is NULL."]
1091    pub fn otPlatCryptoEcdsaGetPublicKey(
1092        aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1093        aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1094    ) -> otError;
1095}
1096extern "C" {
1097    #[doc = " Calculate the ECDSA signature for a hashed message using the private key from the input context.\n\n Uses the deterministic digital signature generation procedure from RFC 6979.\n\n @param[in]  aKeyPair           A pointer to an ECDSA key-pair structure where the key-pair is stored.\n @param[in]  aHash              A pointer to a SHA-256 hash structure where the hash value for signature calculation\n                                is stored.\n @param[out] aSignature         A pointer to an ECDSA signature structure to output the calculated signature.\n\n @retval OT_ERROR_NONE          The signature was calculated successfully, @p aSignature was updated.\n @retval OT_ERROR_PARSE         The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for signature calculation.\n @retval OT_ERROR_INVALID_ARGS  The @p aContext is NULL."]
1098    pub fn otPlatCryptoEcdsaSign(
1099        aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1100        aHash: *const otPlatCryptoSha256Hash,
1101        aSignature: *mut otPlatCryptoEcdsaSignature,
1102    ) -> otError;
1103}
1104extern "C" {
1105    #[doc = " Use the key from the input context to verify the ECDSA signature of a hashed message.\n\n @param[in]  aPublicKey         A pointer to an ECDSA public key structure where the public key for signature\n                                verification is stored.\n @param[in]  aHash              A pointer to a SHA-256 hash structure where the hash value for signature verification\n                                is stored.\n @param[in]  aSignature         A pointer to an ECDSA signature structure where the signature value to be verified is\n                                stored.\n\n @retval OT_ERROR_NONE          The signature was verified successfully.\n @retval OT_ERROR_SECURITY      The signature is invalid.\n @retval OT_ERROR_INVALID_ARGS  The key or hash is invalid.\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for signature verification."]
1106    pub fn otPlatCryptoEcdsaVerify(
1107        aPublicKey: *const otPlatCryptoEcdsaPublicKey,
1108        aHash: *const otPlatCryptoSha256Hash,
1109        aSignature: *const otPlatCryptoEcdsaSignature,
1110    ) -> otError;
1111}
1112extern "C" {
1113    #[doc = " Calculate the ECDSA signature for a hashed message using the Key reference passed.\n\n Uses the deterministic digital signature generation procedure from RFC 6979.\n\n @param[in]  aKeyRef            Key Reference to the slot where the key-pair is stored.\n @param[in]  aHash              A pointer to a SHA-256 hash structure where the hash value for signature calculation\n                                is stored.\n @param[out] aSignature         A pointer to an ECDSA signature structure to output the calculated signature.\n\n @retval OT_ERROR_NONE          The signature was calculated successfully, @p aSignature was updated.\n @retval OT_ERROR_PARSE         The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for signature calculation.\n @retval OT_ERROR_INVALID_ARGS  The @p aContext is NULL.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
1114    pub fn otPlatCryptoEcdsaSignUsingKeyRef(
1115        aKeyRef: otCryptoKeyRef,
1116        aHash: *const otPlatCryptoSha256Hash,
1117        aSignature: *mut otPlatCryptoEcdsaSignature,
1118    ) -> otError;
1119}
1120extern "C" {
1121    #[doc = " Get the associated public key from the key reference passed.\n\n The public key is stored differently depending on the crypto backend library being used\n (OPENTHREAD_CONFIG_CRYPTO_LIB).\n\n This API must make sure to return the public key as a byte sequence representation of an\n uncompressed curve point (RFC 6605 - sec 4)\n\n @param[in]  aKeyRef            Key Reference to the slot where the key-pair is stored.\n @param[out] aPublicKey         A pointer to an ECDSA public key structure to store the public key.\n\n @retval OT_ERROR_NONE          Public key was retrieved successfully, and @p aBuffer is updated.\n @retval OT_ERROR_PARSE         The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_INVALID_ARGS  The @p aContext is NULL.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
1122    pub fn otPlatCryptoEcdsaExportPublicKey(
1123        aKeyRef: otCryptoKeyRef,
1124        aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1125    ) -> otError;
1126}
1127extern "C" {
1128    #[doc = " Generate and import a new ECDSA key-pair at reference passed.\n\n @param[in]  aKeyRef            Key Reference to the slot where the key-pair is stored.\n\n @retval OT_ERROR_NONE          A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE   Feature not supported.\n @retval OT_ERROR_FAILED        Failed to generate key-pair.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
1129    pub fn otPlatCryptoEcdsaGenerateAndImportKey(aKeyRef: otCryptoKeyRef) -> otError;
1130}
1131extern "C" {
1132    #[doc = " Use the keyref to verify the ECDSA signature of a hashed message.\n\n @param[in]  aKeyRef            Key Reference to the slot where the key-pair is stored.\n @param[in]  aHash              A pointer to a SHA-256 hash structure where the hash value for signature verification\n                                is stored.\n @param[in]  aSignature         A pointer to an ECDSA signature structure where the signature value to be verified is\n                                stored.\n\n @retval OT_ERROR_NONE          The signature was verified successfully.\n @retval OT_ERROR_SECURITY      The signature is invalid.\n @retval OT_ERROR_INVALID_ARGS  The key or hash is invalid.\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for signature verification.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled."]
1133    pub fn otPlatCryptoEcdsaVerifyUsingKeyRef(
1134        aKeyRef: otCryptoKeyRef,
1135        aHash: *const otPlatCryptoSha256Hash,
1136        aSignature: *const otPlatCryptoEcdsaSignature,
1137    ) -> otError;
1138}
1139extern "C" {
1140    #[doc = " Perform PKCS#5 PBKDF2 using CMAC (AES-CMAC-PRF-128).\n\n @param[in]     aPassword          Password to use when generating key.\n @param[in]     aPasswordLen       Length of password.\n @param[in]     aSalt              Salt to use when generating key.\n @param[in]     aSaltLen           Length of salt.\n @param[in]     aIterationCounter  Iteration count.\n @param[in]     aKeyLen            Length of generated key in bytes.\n @param[out]    aKey               A pointer to the generated key.\n\n @retval OT_ERROR_NONE          A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS       Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE   Feature not supported.\n @retval OT_ERROR_FAILED        Failed to generate key."]
1141    pub fn otPlatCryptoPbkdf2GenerateKey(
1142        aPassword: *const u8,
1143        aPasswordLen: u16,
1144        aSalt: *const u8,
1145        aSaltLen: u16,
1146        aIterationCounter: u32,
1147        aKeyLen: u16,
1148        aKey: *mut u8,
1149    ) -> otError;
1150}
1151#[doc = "< aMaxPHYPacketSize (IEEE 802.15.4-2006)"]
1152pub const OT_RADIO_FRAME_MAX_SIZE: _bindgen_ty_2 = 127;
1153#[doc = "< Minimal size of frame FCS + CONTROL"]
1154pub const OT_RADIO_FRAME_MIN_SIZE: _bindgen_ty_2 = 3;
1155#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1156pub const OT_RADIO_SYMBOLS_PER_OCTET: _bindgen_ty_2 = 2;
1157#[doc = "< 2.4 GHz IEEE 802.15.4 (bits per second)"]
1158pub const OT_RADIO_BIT_RATE: _bindgen_ty_2 = 250000;
1159#[doc = "< Number of bits per octet"]
1160pub const OT_RADIO_BITS_PER_OCTET: _bindgen_ty_2 = 8;
1161#[doc = "< The O-QPSK PHY symbol rate when operating in the 780MHz, 915MHz, 2380MHz, 2450MHz"]
1162pub const OT_RADIO_SYMBOL_RATE: _bindgen_ty_2 = 62500;
1163#[doc = "< Symbol duration time in unit of microseconds"]
1164pub const OT_RADIO_SYMBOL_TIME: _bindgen_ty_2 = 16;
1165#[doc = "< Time for 10 symbols in unit of microseconds"]
1166pub const OT_RADIO_TEN_SYMBOLS_TIME: _bindgen_ty_2 = 160;
1167#[doc = "< LQI measurement not supported"]
1168pub const OT_RADIO_LQI_NONE: _bindgen_ty_2 = 0;
1169#[doc = "< Invalid or unknown RSSI value"]
1170pub const OT_RADIO_RSSI_INVALID: _bindgen_ty_2 = 127;
1171#[doc = "< Invalid or unknown power value"]
1172pub const OT_RADIO_POWER_INVALID: _bindgen_ty_2 = 127;
1173#[doc = "< Invalid short address."]
1174pub const OT_RADIO_INVALID_SHORT_ADDR: _bindgen_ty_2 = 65534;
1175#[doc = "< Broadcast short address."]
1176pub const OT_RADIO_BROADCAST_SHORT_ADDR: _bindgen_ty_2 = 65535;
1177#[doc = " @defgroup radio-types Radio Types\n\n @brief\n   This module includes the platform abstraction for a radio frame.\n\n @{"]
1178pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
1179#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1180pub const OT_RADIO_CHANNEL_PAGE_0: _bindgen_ty_3 = 0;
1181#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1182pub const OT_RADIO_CHANNEL_PAGE_0_MASK: _bindgen_ty_3 = 1;
1183#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1184pub const OT_RADIO_CHANNEL_PAGE_2: _bindgen_ty_3 = 2;
1185#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1186pub const OT_RADIO_CHANNEL_PAGE_2_MASK: _bindgen_ty_3 = 4;
1187#[doc = " Defines the channel page."]
1188pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
1189#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1190pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 1;
1191#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1192pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 10;
1193#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1194pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 2046;
1195#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1196pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 11;
1197#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1198pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 26;
1199#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1200pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 134215680;
1201#[doc = " Defines the frequency band channel range."]
1202pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
1203#[doc = " Represents radio capabilities.\n\n The value is a bit-field indicating the capabilities supported by the radio. See `OT_RADIO_CAPS_*` definitions."]
1204pub type otRadioCaps = u16;
1205#[doc = "< Radio supports no capability."]
1206pub const OT_RADIO_CAPS_NONE: _bindgen_ty_5 = 0;
1207#[doc = "< Radio supports AckTime event."]
1208pub const OT_RADIO_CAPS_ACK_TIMEOUT: _bindgen_ty_5 = 1;
1209#[doc = "< Radio supports Energy Scans."]
1210pub const OT_RADIO_CAPS_ENERGY_SCAN: _bindgen_ty_5 = 2;
1211#[doc = "< Radio supports tx retry logic with collision avoidance (CSMA)."]
1212pub const OT_RADIO_CAPS_TRANSMIT_RETRIES: _bindgen_ty_5 = 4;
1213#[doc = "< Radio supports CSMA backoff for frame tx (but no retry)."]
1214pub const OT_RADIO_CAPS_CSMA_BACKOFF: _bindgen_ty_5 = 8;
1215#[doc = "< Radio supports direct transition from sleep to TX with CSMA."]
1216pub const OT_RADIO_CAPS_SLEEP_TO_TX: _bindgen_ty_5 = 16;
1217#[doc = "< Radio supports tx security."]
1218pub const OT_RADIO_CAPS_TRANSMIT_SEC: _bindgen_ty_5 = 32;
1219#[doc = "< Radio supports tx at specific time."]
1220pub const OT_RADIO_CAPS_TRANSMIT_TIMING: _bindgen_ty_5 = 64;
1221#[doc = "< Radio supports rx at specific time."]
1222pub const OT_RADIO_CAPS_RECEIVE_TIMING: _bindgen_ty_5 = 128;
1223#[doc = "< Radio supports RxOnWhenIdle handling."]
1224pub const OT_RADIO_CAPS_RX_ON_WHEN_IDLE: _bindgen_ty_5 = 256;
1225#[doc = "< Radio supports setting per-frame transmit power."]
1226pub const OT_RADIO_CAPS_TRANSMIT_FRAME_POWER: _bindgen_ty_5 = 512;
1227#[doc = "< Radio supports setting alternate short address."]
1228pub const OT_RADIO_CAPS_ALT_SHORT_ADDR: _bindgen_ty_5 = 1024;
1229#[doc = " Defines constants that are used to indicate different radio capabilities. See `otRadioCaps`."]
1230pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
1231#[doc = " Represents the IEEE 802.15.4 PAN ID."]
1232pub type otPanId = u16;
1233#[doc = " Represents the IEEE 802.15.4 Short Address."]
1234pub type otShortAddress = u16;
1235#[doc = "< Size of IE header in bytes."]
1236pub const OT_IE_HEADER_SIZE: _bindgen_ty_6 = 2;
1237#[doc = "< Size of CSL IE content in bytes."]
1238pub const OT_CSL_IE_SIZE: _bindgen_ty_6 = 4;
1239#[doc = "< Max length for header IE in ACK."]
1240pub const OT_ACK_IE_MAX_SIZE: _bindgen_ty_6 = 16;
1241#[doc = "< Max length of Link Metrics data in Vendor-Specific IE."]
1242pub const OT_ENH_PROBING_IE_DATA_MAX_SIZE: _bindgen_ty_6 = 2;
1243#[doc = " Defines constants about size of header IE in ACK."]
1244pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
1245#[doc = " @struct otExtAddress\n\n Represents the IEEE 802.15.4 Extended Address."]
1246#[repr(C, packed)]
1247#[derive(Debug, Default, Copy, Clone)]
1248pub struct otExtAddress {
1249    #[doc = "< IEEE 802.15.4 Extended Address bytes"]
1250    pub m8: [u8; 8usize],
1251}
1252#[doc = " @struct otMacKey\n\n Represents a MAC Key."]
1253#[repr(C, packed)]
1254#[derive(Debug, Default, Copy, Clone)]
1255pub struct otMacKey {
1256    #[doc = "< MAC Key bytes."]
1257    pub m8: [u8; 16usize],
1258}
1259#[doc = " Represents a MAC Key Ref used by PSA."]
1260pub type otMacKeyRef = otCryptoKeyRef;
1261#[doc = " @struct otMacKeyMaterial\n\n Represents a MAC Key."]
1262#[repr(C)]
1263#[derive(Copy, Clone)]
1264pub struct otMacKeyMaterial {
1265    pub mKeyMaterial: otMacKeyMaterial__bindgen_ty_1,
1266}
1267#[repr(C)]
1268#[derive(Copy, Clone)]
1269pub union otMacKeyMaterial__bindgen_ty_1 {
1270    #[doc = "< Reference to the key stored."]
1271    pub mKeyRef: otMacKeyRef,
1272    #[doc = "< Key stored as literal."]
1273    pub mKey: otMacKey,
1274}
1275impl Default for otMacKeyMaterial__bindgen_ty_1 {
1276    fn default() -> Self {
1277        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1278        unsafe {
1279            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1280            s.assume_init()
1281        }
1282    }
1283}
1284impl Default for otMacKeyMaterial {
1285    fn default() -> Self {
1286        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1287        unsafe {
1288            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1289            s.assume_init()
1290        }
1291    }
1292}
1293#[doc = "< Use Literal Keys."]
1294pub const OT_KEY_TYPE_LITERAL_KEY: otRadioKeyType = 0;
1295#[doc = "< Use Reference to Key."]
1296pub const OT_KEY_TYPE_KEY_REF: otRadioKeyType = 1;
1297#[doc = " Defines constants about key types."]
1298pub type otRadioKeyType = ::std::os::raw::c_uint;
1299#[doc = " Represents the IEEE 802.15.4 Header IE (Information Element) related information of a radio frame."]
1300#[repr(C)]
1301#[derive(Debug, Default, Copy, Clone)]
1302pub struct otRadioIeInfo {
1303    #[doc = "< The time offset to the Thread network time."]
1304    pub mNetworkTimeOffset: i64,
1305    #[doc = "< The Time IE offset from the start of PSDU."]
1306    pub mTimeIeOffset: u8,
1307    #[doc = "< The Time sync sequence."]
1308    pub mTimeSyncSeq: u8,
1309}
1310#[doc = " Represents an IEEE 802.15.4 radio frame."]
1311#[repr(C)]
1312#[derive(Copy, Clone)]
1313pub struct otRadioFrame {
1314    #[doc = "< The PSDU."]
1315    pub mPsdu: *mut u8,
1316    #[doc = "< Length of the PSDU."]
1317    pub mLength: u16,
1318    #[doc = "< Channel used to transmit/receive the frame."]
1319    pub mChannel: u8,
1320    #[doc = "< Radio link type - should be ignored by radio driver."]
1321    pub mRadioType: u8,
1322    pub mInfo: otRadioFrame__bindgen_ty_1,
1323}
1324#[doc = " The union of transmit and receive information for a radio frame."]
1325#[repr(C)]
1326#[derive(Copy, Clone)]
1327pub union otRadioFrame__bindgen_ty_1 {
1328    pub mTxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_1,
1329    pub mRxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_2,
1330}
1331#[doc = " Structure representing radio frame transmit information."]
1332#[repr(C)]
1333#[derive(Debug, Copy, Clone)]
1334pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1335    #[doc = "< The key material used for AES-CCM frame security."]
1336    pub mAesKey: *const otMacKeyMaterial,
1337    #[doc = "< The pointer to the Header IE(s) related information."]
1338    pub mIeInfo: *mut otRadioIeInfo,
1339    #[doc = " The base time in microseconds for scheduled transmissions\n relative to the local radio clock, see `otPlatRadioGetNow` and\n `mTxDelay`.\n\n If this field is non-zero, `mMaxCsmaBackoffs` should be ignored.\n\n This field does not affect CCA behavior which is controlled by `mCsmaCaEnabled`."]
1340    pub mTxDelayBaseTime: u32,
1341    #[doc = " The delay time in microseconds for this transmission referenced\n to `mTxDelayBaseTime`.\n\n Note: `mTxDelayBaseTime` + `mTxDelay` SHALL point to the point in\n time when the end of the SFD will be present at the local\n antenna, relative to the local radio clock.\n\n If this field is non-zero, `mMaxCsmaBackoffs` should be ignored.\n\n This field does not affect CCA behavior which is controlled by `mCsmaCaEnabled`."]
1342    pub mTxDelay: u32,
1343    #[doc = " Maximum number of CSMA backoff attempts before declaring channel access failure.\n\n This is applicable and MUST be used when radio platform provides the `OT_RADIO_CAPS_CSMA_BACKOFF` and/or\n `OT_RADIO_CAPS_TRANSMIT_RETRIES`.\n\n This field MUST be ignored if `mCsmaCaEnabled` is set to `false` (CCA is disabled) or\n either `mTxDelayBaseTime` or `mTxDelay` is non-zero (frame transmission is expected at a specific time).\n\n It can be set to `0` to skip backoff mechanism (note that CCA MUST still be performed assuming\n `mCsmaCaEnabled` is `true`)."]
1344    pub mMaxCsmaBackoffs: u8,
1345    #[doc = "< Maximum number of retries allowed after a transmission failure."]
1346    pub mMaxFrameRetries: u8,
1347    #[doc = " The RX channel after frame TX is done (after all frame retries - ack received, or timeout, or abort).\n\n Radio platforms can choose to fully ignore this. OT stack will make sure to call `otPlatRadioReceive()`\n with the desired RX channel after a frame TX is done and signaled in `otPlatRadioTxDone()` callback.\n Radio platforms that don't provide `OT_RADIO_CAPS_TRANSMIT_RETRIES` must always ignore this.\n\n This is intended for situations where there may be delay in interactions between OT stack and radio, as\n an example this is used in RCP/host architecture to make sure RCP switches to PAN channel more quickly.\n In particular, this can help with CSL tx to a sleepy child, where the child may use a different channel\n for CSL than the PAN channel. After frame tx, we want the radio/RCP to go back to the PAN channel\n quickly to ensure that parent does not miss tx from child afterwards, e.g., child responding to the\n earlier CSL transmitted frame from parent using PAN channel while radio still staying on CSL channel.\n\n The switch to the RX channel MUST happen after the frame TX is fully done, i.e., after all retries and\n when ack is received (when \"Ack Request\" flag is set on the TX frame) or ack timeout. Note that ack is\n expected on the same channel that frame is sent on."]
1348    pub mRxChannelAfterTxDone: u8,
1349    #[doc = " The transmit power in dBm.\n\n If the platform layer does not provide `OT_RADIO_CAPS_TRANSMIT_FRAME_POWER` capability, it can ignore\n this value.\n\n If the value is OT_RADIO_POWER_INVALID, then the platform should ignore this value and transmit the frame\n with its default transmit power.\n\n Otherwise, the platform should transmit this frame with the maximum power no larger than minimal of the\n following values:\n     1. mTxPower,\n     2. The power limit set by otPlatRadioSetChannelTargetPower(),\n     3. The power limit set by otPlatRadioSetChannelMaxTransmitPower(),\n     4. The power limit set by otPlatRadioSetRegion()."]
1350    pub mTxPower: i8,
1351    pub _bitfield_align_1: [u8; 0],
1352    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1353    #[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna.\n\n The platform should update this field before otPlatRadioTxStarted() is fired for each transmit attempt."]
1354    pub mTimestamp: u64,
1355}
1356impl Default for otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1357    fn default() -> Self {
1358        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1359        unsafe {
1360            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1361            s.assume_init()
1362        }
1363    }
1364}
1365impl otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1366    #[inline]
1367    pub fn mIsHeaderUpdated(&self) -> bool {
1368        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1369    }
1370    #[inline]
1371    pub fn set_mIsHeaderUpdated(&mut self, val: bool) {
1372        unsafe {
1373            let val: u8 = ::std::mem::transmute(val);
1374            self._bitfield_1.set(0usize, 1u8, val as u64)
1375        }
1376    }
1377    #[inline]
1378    pub fn mIsARetx(&self) -> bool {
1379        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1380    }
1381    #[inline]
1382    pub fn set_mIsARetx(&mut self, val: bool) {
1383        unsafe {
1384            let val: u8 = ::std::mem::transmute(val);
1385            self._bitfield_1.set(1usize, 1u8, val as u64)
1386        }
1387    }
1388    #[inline]
1389    pub fn mCsmaCaEnabled(&self) -> bool {
1390        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1391    }
1392    #[inline]
1393    pub fn set_mCsmaCaEnabled(&mut self, val: bool) {
1394        unsafe {
1395            let val: u8 = ::std::mem::transmute(val);
1396            self._bitfield_1.set(2usize, 1u8, val as u64)
1397        }
1398    }
1399    #[inline]
1400    pub fn mCslPresent(&self) -> bool {
1401        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1402    }
1403    #[inline]
1404    pub fn set_mCslPresent(&mut self, val: bool) {
1405        unsafe {
1406            let val: u8 = ::std::mem::transmute(val);
1407            self._bitfield_1.set(3usize, 1u8, val as u64)
1408        }
1409    }
1410    #[inline]
1411    pub fn mIsSecurityProcessed(&self) -> bool {
1412        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1413    }
1414    #[inline]
1415    pub fn set_mIsSecurityProcessed(&mut self, val: bool) {
1416        unsafe {
1417            let val: u8 = ::std::mem::transmute(val);
1418            self._bitfield_1.set(4usize, 1u8, val as u64)
1419        }
1420    }
1421    #[inline]
1422    pub fn new_bitfield_1(
1423        mIsHeaderUpdated: bool,
1424        mIsARetx: bool,
1425        mCsmaCaEnabled: bool,
1426        mCslPresent: bool,
1427        mIsSecurityProcessed: bool,
1428    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1429        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1430        __bindgen_bitfield_unit.set(0usize, 1u8, {
1431            let mIsHeaderUpdated: u8 = unsafe { ::std::mem::transmute(mIsHeaderUpdated) };
1432            mIsHeaderUpdated as u64
1433        });
1434        __bindgen_bitfield_unit.set(1usize, 1u8, {
1435            let mIsARetx: u8 = unsafe { ::std::mem::transmute(mIsARetx) };
1436            mIsARetx as u64
1437        });
1438        __bindgen_bitfield_unit.set(2usize, 1u8, {
1439            let mCsmaCaEnabled: u8 = unsafe { ::std::mem::transmute(mCsmaCaEnabled) };
1440            mCsmaCaEnabled as u64
1441        });
1442        __bindgen_bitfield_unit.set(3usize, 1u8, {
1443            let mCslPresent: u8 = unsafe { ::std::mem::transmute(mCslPresent) };
1444            mCslPresent as u64
1445        });
1446        __bindgen_bitfield_unit.set(4usize, 1u8, {
1447            let mIsSecurityProcessed: u8 = unsafe { ::std::mem::transmute(mIsSecurityProcessed) };
1448            mIsSecurityProcessed as u64
1449        });
1450        __bindgen_bitfield_unit
1451    }
1452}
1453#[doc = " Structure representing radio frame receive information."]
1454#[repr(C)]
1455#[derive(Debug, Default, Copy, Clone)]
1456pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1457    #[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna."]
1458    pub mTimestamp: u64,
1459    #[doc = "< ACK security frame counter (applicable when `mAckedWithSecEnhAck` is set)."]
1460    pub mAckFrameCounter: u32,
1461    #[doc = "< ACK security key index (applicable when `mAckedWithSecEnhAck` is set)."]
1462    pub mAckKeyId: u8,
1463    #[doc = "< Received signal strength indicator in dBm for received frames."]
1464    pub mRssi: i8,
1465    #[doc = "< Link Quality Indicator for received frames."]
1466    pub mLqi: u8,
1467    pub _bitfield_align_1: [u8; 0],
1468    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1469}
1470impl otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1471    #[inline]
1472    pub fn mAckedWithFramePending(&self) -> bool {
1473        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1474    }
1475    #[inline]
1476    pub fn set_mAckedWithFramePending(&mut self, val: bool) {
1477        unsafe {
1478            let val: u8 = ::std::mem::transmute(val);
1479            self._bitfield_1.set(0usize, 1u8, val as u64)
1480        }
1481    }
1482    #[inline]
1483    pub fn mAckedWithSecEnhAck(&self) -> bool {
1484        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1485    }
1486    #[inline]
1487    pub fn set_mAckedWithSecEnhAck(&mut self, val: bool) {
1488        unsafe {
1489            let val: u8 = ::std::mem::transmute(val);
1490            self._bitfield_1.set(1usize, 1u8, val as u64)
1491        }
1492    }
1493    #[inline]
1494    pub fn new_bitfield_1(
1495        mAckedWithFramePending: bool,
1496        mAckedWithSecEnhAck: bool,
1497    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1498        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1499        __bindgen_bitfield_unit.set(0usize, 1u8, {
1500            let mAckedWithFramePending: u8 =
1501                unsafe { ::std::mem::transmute(mAckedWithFramePending) };
1502            mAckedWithFramePending as u64
1503        });
1504        __bindgen_bitfield_unit.set(1usize, 1u8, {
1505            let mAckedWithSecEnhAck: u8 = unsafe { ::std::mem::transmute(mAckedWithSecEnhAck) };
1506            mAckedWithSecEnhAck as u64
1507        });
1508        __bindgen_bitfield_unit
1509    }
1510}
1511impl Default for otRadioFrame__bindgen_ty_1 {
1512    fn default() -> Self {
1513        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1514        unsafe {
1515            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1516            s.assume_init()
1517        }
1518    }
1519}
1520impl Default for otRadioFrame {
1521    fn default() -> Self {
1522        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1523        unsafe {
1524            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1525            s.assume_init()
1526        }
1527    }
1528}
1529pub const OT_RADIO_STATE_DISABLED: otRadioState = 0;
1530pub const OT_RADIO_STATE_SLEEP: otRadioState = 1;
1531pub const OT_RADIO_STATE_RECEIVE: otRadioState = 2;
1532pub const OT_RADIO_STATE_TRANSMIT: otRadioState = 3;
1533pub const OT_RADIO_STATE_INVALID: otRadioState = 255;
1534#[doc = " Represents the state of a radio.\n Initially, a radio is in the Disabled state."]
1535pub type otRadioState = ::std::os::raw::c_uint;
1536#[doc = " Represents radio coexistence metrics."]
1537#[repr(C)]
1538#[derive(Debug, Default, Copy, Clone)]
1539pub struct otRadioCoexMetrics {
1540    #[doc = "< Number of grant glitches."]
1541    pub mNumGrantGlitch: u32,
1542    #[doc = "< Number of tx requests."]
1543    pub mNumTxRequest: u32,
1544    #[doc = "< Number of tx requests while grant was active."]
1545    pub mNumTxGrantImmediate: u32,
1546    #[doc = "< Number of tx requests while grant was inactive."]
1547    pub mNumTxGrantWait: u32,
1548    #[doc = "< Number of tx requests while grant was inactive that were ultimately granted."]
1549    pub mNumTxGrantWaitActivated: u32,
1550    #[doc = "< Number of tx requests while grant was inactive that timed out."]
1551    pub mNumTxGrantWaitTimeout: u32,
1552    #[doc = "< Number of tx that were in progress when grant was deactivated."]
1553    pub mNumTxGrantDeactivatedDuringRequest: u32,
1554    #[doc = "< Number of tx requests that were not granted within 50us."]
1555    pub mNumTxDelayedGrant: u32,
1556    #[doc = "< Average time in usec from tx request to grant."]
1557    pub mAvgTxRequestToGrantTime: u32,
1558    #[doc = "< Number of rx requests."]
1559    pub mNumRxRequest: u32,
1560    #[doc = "< Number of rx requests while grant was active."]
1561    pub mNumRxGrantImmediate: u32,
1562    #[doc = "< Number of rx requests while grant was inactive."]
1563    pub mNumRxGrantWait: u32,
1564    #[doc = "< Number of rx requests while grant was inactive that were ultimately granted."]
1565    pub mNumRxGrantWaitActivated: u32,
1566    #[doc = "< Number of rx requests while grant was inactive that timed out."]
1567    pub mNumRxGrantWaitTimeout: u32,
1568    #[doc = "< Number of rx that were in progress when grant was deactivated."]
1569    pub mNumRxGrantDeactivatedDuringRequest: u32,
1570    #[doc = "< Number of rx requests that were not granted within 50us."]
1571    pub mNumRxDelayedGrant: u32,
1572    #[doc = "< Average time in usec from rx request to grant."]
1573    pub mAvgRxRequestToGrantTime: u32,
1574    #[doc = "< Number of rx requests that completed without receiving grant."]
1575    pub mNumRxGrantNone: u32,
1576    #[doc = "< Stats collection stopped due to saturation."]
1577    pub mStopped: bool,
1578}
1579#[doc = " Represents what metrics are specified to query."]
1580#[repr(C, packed)]
1581#[derive(Debug, Default, Copy, Clone)]
1582pub struct otLinkMetrics {
1583    pub _bitfield_align_1: [u8; 0],
1584    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1585}
1586impl otLinkMetrics {
1587    #[inline]
1588    pub fn mPduCount(&self) -> bool {
1589        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1590    }
1591    #[inline]
1592    pub fn set_mPduCount(&mut self, val: bool) {
1593        unsafe {
1594            let val: u8 = ::std::mem::transmute(val);
1595            self._bitfield_1.set(0usize, 1u8, val as u64)
1596        }
1597    }
1598    #[inline]
1599    pub fn mLqi(&self) -> bool {
1600        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1601    }
1602    #[inline]
1603    pub fn set_mLqi(&mut self, val: bool) {
1604        unsafe {
1605            let val: u8 = ::std::mem::transmute(val);
1606            self._bitfield_1.set(1usize, 1u8, val as u64)
1607        }
1608    }
1609    #[inline]
1610    pub fn mLinkMargin(&self) -> bool {
1611        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1612    }
1613    #[inline]
1614    pub fn set_mLinkMargin(&mut self, val: bool) {
1615        unsafe {
1616            let val: u8 = ::std::mem::transmute(val);
1617            self._bitfield_1.set(2usize, 1u8, val as u64)
1618        }
1619    }
1620    #[inline]
1621    pub fn mRssi(&self) -> bool {
1622        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1623    }
1624    #[inline]
1625    pub fn set_mRssi(&mut self, val: bool) {
1626        unsafe {
1627            let val: u8 = ::std::mem::transmute(val);
1628            self._bitfield_1.set(3usize, 1u8, val as u64)
1629        }
1630    }
1631    #[inline]
1632    pub fn mReserved(&self) -> bool {
1633        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1634    }
1635    #[inline]
1636    pub fn set_mReserved(&mut self, val: bool) {
1637        unsafe {
1638            let val: u8 = ::std::mem::transmute(val);
1639            self._bitfield_1.set(4usize, 1u8, val as u64)
1640        }
1641    }
1642    #[inline]
1643    pub fn new_bitfield_1(
1644        mPduCount: bool,
1645        mLqi: bool,
1646        mLinkMargin: bool,
1647        mRssi: bool,
1648        mReserved: bool,
1649    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1650        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1651        __bindgen_bitfield_unit.set(0usize, 1u8, {
1652            let mPduCount: u8 = unsafe { ::std::mem::transmute(mPduCount) };
1653            mPduCount as u64
1654        });
1655        __bindgen_bitfield_unit.set(1usize, 1u8, {
1656            let mLqi: u8 = unsafe { ::std::mem::transmute(mLqi) };
1657            mLqi as u64
1658        });
1659        __bindgen_bitfield_unit.set(2usize, 1u8, {
1660            let mLinkMargin: u8 = unsafe { ::std::mem::transmute(mLinkMargin) };
1661            mLinkMargin as u64
1662        });
1663        __bindgen_bitfield_unit.set(3usize, 1u8, {
1664            let mRssi: u8 = unsafe { ::std::mem::transmute(mRssi) };
1665            mRssi as u64
1666        });
1667        __bindgen_bitfield_unit.set(4usize, 1u8, {
1668            let mReserved: u8 = unsafe { ::std::mem::transmute(mReserved) };
1669            mReserved as u64
1670        });
1671        __bindgen_bitfield_unit
1672    }
1673}
1674extern "C" {
1675    #[doc = " Get the radio capabilities.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The radio capability bit vector (see `OT_RADIO_CAP_*` definitions)."]
1676    pub fn otPlatRadioGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
1677}
1678extern "C" {
1679    #[doc = " Get the radio version string.\n\n This is an optional radio driver platform function. If not provided by platform radio driver, OpenThread uses\n the OpenThread version instead (@sa otGetVersionString()).\n\n @param[in]  aInstance   The OpenThread instance structure.\n\n @returns A pointer to the OpenThread radio version."]
1680    pub fn otPlatRadioGetVersionString(aInstance: *mut otInstance)
1681        -> *const ::std::os::raw::c_char;
1682}
1683extern "C" {
1684    #[doc = " Get the radio receive sensitivity value.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The radio receive sensitivity value in dBm."]
1685    pub fn otPlatRadioGetReceiveSensitivity(aInstance: *mut otInstance) -> i8;
1686}
1687extern "C" {
1688    #[doc = " Gets the factory-assigned IEEE EUI-64 for this interface.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[out] aIeeeEui64  A pointer to the factory-assigned IEEE EUI-64."]
1689    pub fn otPlatRadioGetIeeeEui64(aInstance: *mut otInstance, aIeeeEui64: *mut u8);
1690}
1691extern "C" {
1692    #[doc = " Set the PAN ID for address filtering.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aPanId     The IEEE 802.15.4 PAN ID."]
1693    pub fn otPlatRadioSetPanId(aInstance: *mut otInstance, aPanId: otPanId);
1694}
1695extern "C" {
1696    #[doc = " Set the Extended Address for address filtering.\n\n @param[in] aInstance    The OpenThread instance structure.\n @param[in] aExtAddress  A pointer to the IEEE 802.15.4 Extended Address stored in little-endian byte order."]
1697    pub fn otPlatRadioSetExtendedAddress(
1698        aInstance: *mut otInstance,
1699        aExtAddress: *const otExtAddress,
1700    );
1701}
1702extern "C" {
1703    #[doc = " Set the Short Address for address filtering.\n\n @param[in] aInstance      The OpenThread instance structure.\n @param[in] aShortAddress  The IEEE 802.15.4 Short Address."]
1704    pub fn otPlatRadioSetShortAddress(aInstance: *mut otInstance, aShortAddress: otShortAddress);
1705}
1706extern "C" {
1707    #[doc = " Set the alternate short address.\n\n This is an optional radio platform API. The radio platform MUST indicate support for this API by including the\n capability `OT_RADIO_CAPS_ALT_SHORT_ADDR` in `otPlatRadioGetCaps()`.\n\n When supported, the radio should accept received frames destined to the specified alternate short address in\n addition to the short address provided in `otPlatRadioSetShortAddress()`.\n\n The @p aShortAddress can be set to `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) to clear any previously set alternate\n short address.\n\n This function is used by OpenThread stack during child-to-router role transitions, allowing the device to continue\n receiving frames addressed to its previous short address for a short period.\n\n @param[in] aInstance      The OpenThread instance structure.\n @param[in] aShortAddress  The alternate IEEE 802.15.4 short address. `OT_RADIO_INVALID_SHORT_ADDR` to clear."]
1708    pub fn otPlatRadioSetAlternateShortAddress(
1709        aInstance: *mut otInstance,
1710        aShortAddress: otShortAddress,
1711    );
1712}
1713extern "C" {
1714    #[doc = " Get the radio's transmit power in dBm.\n\n @note The transmit power returned will be no larger than the power specified in the max power table for\n the current channel.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[out] aPower    The transmit power in dBm.\n\n @retval OT_ERROR_NONE             Successfully retrieved the transmit power.\n @retval OT_ERROR_INVALID_ARGS     @p aPower was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED  Transmit power configuration via dBm is not implemented."]
1715    pub fn otPlatRadioGetTransmitPower(aInstance: *mut otInstance, aPower: *mut i8) -> otError;
1716}
1717extern "C" {
1718    #[doc = " Set the radio's transmit power in dBm for all channels.\n\n @note The real transmit power will be no larger than the power specified in the max power table for\n the current channel that was configured by `otPlatRadioSetChannelMaxTransmitPower()`.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aPower     The transmit power in dBm.\n\n @retval OT_ERROR_NONE             Successfully set the transmit power.\n @retval OT_ERROR_NOT_IMPLEMENTED  Transmit power configuration via dBm is not implemented."]
1719    pub fn otPlatRadioSetTransmitPower(aInstance: *mut otInstance, aPower: i8) -> otError;
1720}
1721extern "C" {
1722    #[doc = " Get the radio's CCA ED threshold in dBm measured at antenna connector per IEEE 802.15.4 - 2015 section 10.1.4.\n\n @param[in] aInstance    The OpenThread instance structure.\n @param[out] aThreshold  The CCA ED threshold in dBm.\n\n @retval OT_ERROR_NONE             Successfully retrieved the CCA ED threshold.\n @retval OT_ERROR_INVALID_ARGS     @p aThreshold was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED  CCA ED threshold configuration via dBm is not implemented."]
1723    pub fn otPlatRadioGetCcaEnergyDetectThreshold(
1724        aInstance: *mut otInstance,
1725        aThreshold: *mut i8,
1726    ) -> otError;
1727}
1728extern "C" {
1729    #[doc = " Set the radio's CCA ED threshold in dBm measured at antenna connector per IEEE 802.15.4 - 2015 section 10.1.4.\n\n @param[in] aInstance   The OpenThread instance structure.\n @param[in] aThreshold  The CCA ED threshold in dBm.\n\n @retval OT_ERROR_NONE             Successfully set the transmit power.\n @retval OT_ERROR_INVALID_ARGS     Given threshold is out of range.\n @retval OT_ERROR_NOT_IMPLEMENTED  CCA ED threshold configuration via dBm is not implemented."]
1730    pub fn otPlatRadioSetCcaEnergyDetectThreshold(
1731        aInstance: *mut otInstance,
1732        aThreshold: i8,
1733    ) -> otError;
1734}
1735extern "C" {
1736    #[doc = " Gets the external FEM's Rx LNA gain in dBm.\n\n @param[in]  aInstance  The OpenThread instance structure.\n @param[out] aGain     The external FEM's Rx LNA gain in dBm.\n\n @retval OT_ERROR_NONE             Successfully retrieved the external FEM's LNA gain.\n @retval OT_ERROR_INVALID_ARGS     @p aGain was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED  External FEM's LNA setting is not implemented."]
1737    pub fn otPlatRadioGetFemLnaGain(aInstance: *mut otInstance, aGain: *mut i8) -> otError;
1738}
1739extern "C" {
1740    #[doc = " Sets the external FEM's Rx LNA gain in dBm.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aGain      The external FEM's Rx LNA gain in dBm.\n\n @retval OT_ERROR_NONE             Successfully set the external FEM's LNA gain.\n @retval OT_ERROR_NOT_IMPLEMENTED  External FEM's LNA gain setting is not implemented."]
1741    pub fn otPlatRadioSetFemLnaGain(aInstance: *mut otInstance, aGain: i8) -> otError;
1742}
1743extern "C" {
1744    #[doc = " Get the status of promiscuous mode.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @retval TRUE   Promiscuous mode is enabled.\n @retval FALSE  Promiscuous mode is disabled."]
1745    pub fn otPlatRadioGetPromiscuous(aInstance: *mut otInstance) -> bool;
1746}
1747extern "C" {
1748    #[doc = " Enable or disable promiscuous mode.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aEnable   TRUE to enable or FALSE to disable promiscuous mode."]
1749    pub fn otPlatRadioSetPromiscuous(aInstance: *mut otInstance, aEnable: bool);
1750}
1751extern "C" {
1752    #[doc = " Sets the rx-on-when-idle state to the radio platform.\n\n There are a few situations that the radio can enter sleep state if the device is in rx-off-when-idle state but\n it's hard and costly for the SubMac to identify these situations and instruct the radio to enter sleep:\n\n - Finalization of a regular frame reception task, provided that:\n   - The frame is received without errors and passes the filtering and it's not an spurious ACK.\n   - ACK is not requested or transmission of ACK is not possible due to internal conditions.\n - Finalization of a frame transmission or transmission of an ACK frame, when ACK is not requested in the transmitted\n   frame.\n - Finalization of the reception operation of a requested ACK due to:\n   - ACK timeout expiration.\n   - Reception of an invalid ACK or not an ACK frame.\n   - Reception of the proper ACK, unless the transmitted frame was a Data Request Command and the frame pending bit\n     on the received ACK is set to true. In this case the radio platform implementation SHOULD keep the receiver on\n     until a determined timeout which triggers an idle period start.`OPENTHREAD_CONFIG_MAC_DATA_POLL_TIMEOUT` can be\n     taken as a reference for this.\n - Finalization of a stand alone CCA task.\n - Finalization of a CCA operation with busy result during CSMA/CA procedure.\n - Finalization of an Energy Detection task.\n - Finalization of a radio reception window scheduled with `otPlatRadioReceiveAt`.\n\n If a platform supports `OT_RADIO_CAPS_RX_ON_WHEN_IDLE` it must also support `OT_RADIO_CAPS_CSMA_BACKOFF` and handle\n idle periods after CCA as described above.\n\n Upon the transition of the \"RxOnWhenIdle\" flag from TRUE to FALSE, the radio platform should enter sleep mode.\n If the radio is currently in receive mode, it should enter sleep mode immediately. Otherwise, it should enter sleep\n mode after the current operation is completed.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aEnable      TRUE to keep radio in Receive state, FALSE to put to Sleep state during idle periods."]
1753    pub fn otPlatRadioSetRxOnWhenIdle(aInstance: *mut otInstance, aEnable: bool);
1754}
1755extern "C" {
1756    #[doc = " Update MAC keys and key index\n\n Is used when radio provides OT_RADIO_CAPS_TRANSMIT_SEC capability.\n\n The radio platform should reset the current security MAC frame counter tracked by the radio on this call. While this\n is highly recommended, the OpenThread stack, as a safeguard, will also reset the frame counter using the\n `otPlatRadioSetMacFrameCounter()` before calling this API.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[in]   aKeyIdMode   The key ID mode.\n @param[in]   aKeyId       Current MAC key index.\n @param[in]   aPrevKey     A pointer to the previous MAC key.\n @param[in]   aCurrKey     A pointer to the current MAC key.\n @param[in]   aNextKey     A pointer to the next MAC key.\n @param[in]   aKeyType     Key Type used."]
1757    pub fn otPlatRadioSetMacKey(
1758        aInstance: *mut otInstance,
1759        aKeyIdMode: u8,
1760        aKeyId: u8,
1761        aPrevKey: *const otMacKeyMaterial,
1762        aCurrKey: *const otMacKeyMaterial,
1763        aNextKey: *const otMacKeyMaterial,
1764        aKeyType: otRadioKeyType,
1765    );
1766}
1767extern "C" {
1768    #[doc = " Sets the current MAC frame counter value.\n\n Is used when radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability.\n\n @param[in]   aInstance         A pointer to an OpenThread instance.\n @param[in]   aMacFrameCounter  The MAC frame counter value."]
1769    pub fn otPlatRadioSetMacFrameCounter(aInstance: *mut otInstance, aMacFrameCounter: u32);
1770}
1771extern "C" {
1772    #[doc = " Sets the current MAC frame counter value only if the new given value is larger than the current value.\n\n Is used when radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability.\n\n @param[in]   aInstance         A pointer to an OpenThread instance.\n @param[in]   aMacFrameCounter  The MAC frame counter value."]
1773    pub fn otPlatRadioSetMacFrameCounterIfLarger(aInstance: *mut otInstance, aMacFrameCounter: u32);
1774}
1775extern "C" {
1776    #[doc = " Get the current time in microseconds referenced to a continuous monotonic\n local radio clock (64 bits width).\n\n The radio clock SHALL NOT wrap during the device's uptime. Implementations\n SHALL therefore identify and compensate for internal counter overflows. The\n clock does not have a defined epoch and it SHALL NOT introduce any continuous\n or discontinuous adjustments (e.g. leap seconds). Implementations SHALL\n compensate for any sleep times of the device.\n\n Implementations MAY choose to discipline the radio clock and compensate for\n sleep times by any means (e.g. by combining a high precision/low power RTC\n with a high resolution counter) as long as the exposed combined clock\n provides continuous monotonic microsecond resolution ticks within the\n accuracy limits announced by @ref otPlatRadioGetCslAccuracy.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The current time in microseconds. UINT64_MAX when platform does not\n support or radio time is not ready."]
1777    pub fn otPlatRadioGetNow(aInstance: *mut otInstance) -> u64;
1778}
1779extern "C" {
1780    #[doc = " Get the bus speed in bits/second between the host and the radio chip.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The bus speed in bits/second between the host and the radio chip.\n          Return 0 when the MAC and above layer and Radio layer resides on the same chip."]
1781    pub fn otPlatRadioGetBusSpeed(aInstance: *mut otInstance) -> u32;
1782}
1783extern "C" {
1784    #[doc = " Get the bus latency in microseconds between the host and the radio chip.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The bus latency in microseconds between the host and the radio chip.\n          Return 0 when the MAC and above layer and Radio layer resides on the same chip."]
1785    pub fn otPlatRadioGetBusLatency(aInstance: *mut otInstance) -> u32;
1786}
1787extern "C" {
1788    #[doc = " Get current state of the radio.\n\n Is not required by OpenThread. It may be used for debugging and/or application-specific purposes.\n\n @note This function may be not implemented. It does not affect OpenThread.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @return  Current state of the radio."]
1789    pub fn otPlatRadioGetState(aInstance: *mut otInstance) -> otRadioState;
1790}
1791extern "C" {
1792    #[doc = " Enable the radio.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @retval OT_ERROR_NONE     Successfully enabled.\n @retval OT_ERROR_FAILED   The radio could not be enabled."]
1793    pub fn otPlatRadioEnable(aInstance: *mut otInstance) -> otError;
1794}
1795extern "C" {
1796    #[doc = " Disable the radio.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @retval OT_ERROR_NONE            Successfully transitioned to Disabled.\n @retval OT_ERROR_INVALID_STATE   The radio was not in sleep state."]
1797    pub fn otPlatRadioDisable(aInstance: *mut otInstance) -> otError;
1798}
1799extern "C" {
1800    #[doc = " Check whether radio is enabled or not.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns TRUE if the radio is enabled, FALSE otherwise."]
1801    pub fn otPlatRadioIsEnabled(aInstance: *mut otInstance) -> bool;
1802}
1803extern "C" {
1804    #[doc = " Transition the radio from Receive to Sleep (turn off the radio).\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @retval OT_ERROR_NONE          Successfully transitioned to Sleep.\n @retval OT_ERROR_BUSY          The radio was transmitting.\n @retval OT_ERROR_INVALID_STATE The radio was disabled."]
1805    pub fn otPlatRadioSleep(aInstance: *mut otInstance) -> otError;
1806}
1807extern "C" {
1808    #[doc = " Transition the radio from Sleep to Receive (turn on the radio).\n\n @param[in]  aInstance  The OpenThread instance structure.\n @param[in]  aChannel   The channel to use for receiving.\n\n @retval OT_ERROR_NONE          Successfully transitioned to Receive.\n @retval OT_ERROR_INVALID_STATE The radio was disabled or transmitting."]
1809    pub fn otPlatRadioReceive(aInstance: *mut otInstance, aChannel: u8) -> otError;
1810}
1811extern "C" {
1812    #[doc = " Schedule a radio reception window at a specific time and duration.\n\n After a radio reception is successfully scheduled for a future time and duration, a subsequent call to this\n function MUST be handled as follows:\n\n - If the start time of the previously scheduled reception window has not yet been reached, the new call to\n   `otPlatRadioReceiveAt()` MUST cancel the previous schedule, effectively replacing it.\n\n - If the start of the previous window has already passed, the previous receive schedule is already being executed\n   by the radio and MUST NOT be replaced or impacted. The new call to `otPlatRadioReceiveAt()` would then schedule\n   a new future receive window. In particular, if the new `otPlatRadioReceiveAt()` call occurs after the start\n   but while still within the previous reception window, the ongoing reception window MUST NOT be impacted.\n\n @param[in]  aChannel   The radio channel on which to receive.\n @param[in]  aStart     The receive window start time relative to the local\n                        radio clock, see `otPlatRadioGetNow`. The radio\n                        receiver SHALL be on and ready to receive the first\n                        symbol of a frame's SHR at the window start time.\n @param[in]  aDuration  The receive window duration, in microseconds, as\n                        measured by the local radio clock. The radio SHOULD be\n                        turned off (or switched to TX mode if an ACK frame\n                        needs to be sent) after that duration unless it is\n                        still actively receiving a frame. In the latter case\n                        the radio SHALL be kept in reception mode until frame\n                        reception has either succeeded or failed.\n\n @retval OT_ERROR_NONE    Successfully scheduled receive window.\n @retval OT_ERROR_FAILED  The receive window could not be scheduled. For example, if @p aStart is in the past."]
1813    pub fn otPlatRadioReceiveAt(
1814        aInstance: *mut otInstance,
1815        aChannel: u8,
1816        aStart: u32,
1817        aDuration: u32,
1818    ) -> otError;
1819}
1820extern "C" {
1821    #[doc = " The radio driver calls this method to notify OpenThread of a received frame.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aFrame    A pointer to the received frame or NULL if the receive operation failed.\n @param[in]  aError    OT_ERROR_NONE when successfully received a frame,\n                       OT_ERROR_ABORT when reception was aborted and a frame was not received,\n                       OT_ERROR_NO_BUFS when a frame could not be received due to lack of rx buffer space."]
1822    pub fn otPlatRadioReceiveDone(
1823        aInstance: *mut otInstance,
1824        aFrame: *mut otRadioFrame,
1825        aError: otError,
1826    );
1827}
1828extern "C" {
1829    #[doc = " The radio driver calls this method to notify OpenThread diagnostics module of a received frame.\n\n Is used when diagnostics is enabled.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aFrame    A pointer to the received frame or NULL if the receive operation failed.\n @param[in]  aError    OT_ERROR_NONE when successfully received a frame,\n                       OT_ERROR_ABORT when reception was aborted and a frame was not received,\n                       OT_ERROR_NO_BUFS when a frame could not be received due to lack of rx buffer space."]
1830    pub fn otPlatDiagRadioReceiveDone(
1831        aInstance: *mut otInstance,
1832        aFrame: *mut otRadioFrame,
1833        aError: otError,
1834    );
1835}
1836extern "C" {
1837    #[doc = " Get the radio transmit frame buffer.\n\n OpenThread forms the IEEE 802.15.4 frame in this buffer then calls `otPlatRadioTransmit()` to request transmission.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns A pointer to the transmit frame buffer."]
1838    pub fn otPlatRadioGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
1839}
1840extern "C" {
1841    #[doc = " Begin the transmit sequence on the radio.\n\n The caller must form the IEEE 802.15.4 frame in the buffer provided by `otPlatRadioGetTransmitBuffer()` before\n requesting transmission.  The channel and transmit power are also included in the otRadioFrame structure.\n\n The transmit sequence consists of:\n 1. Transitioning the radio to Transmit from one of the following states:\n    - Receive if RX is on when the device is idle or OT_RADIO_CAPS_SLEEP_TO_TX is not supported\n    - Sleep if RX is off when the device is idle and OT_RADIO_CAPS_SLEEP_TO_TX is supported.\n 2. Transmits the psdu on the given channel and at the given transmit power.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aFrame     A pointer to the frame to be transmitted.\n\n @retval OT_ERROR_NONE          Successfully transitioned to Transmit.\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state."]
1842    pub fn otPlatRadioTransmit(aInstance: *mut otInstance, aFrame: *mut otRadioFrame) -> otError;
1843}
1844extern "C" {
1845    #[doc = " The radio driver calls this method to notify OpenThread that the transmission has started.\n\n @note  This function should be called by the same thread that executes all of the other OpenThread code. It should\n        not be called by ISR or any other task.\n\n @param[in]  aInstance  A pointer to the OpenThread instance structure.\n @param[in]  aFrame     A pointer to the frame that is being transmitted."]
1846    pub fn otPlatRadioTxStarted(aInstance: *mut otInstance, aFrame: *mut otRadioFrame);
1847}
1848extern "C" {
1849    #[doc = " The radio driver calls this function to notify OpenThread that the transmit operation has completed,\n providing both the transmitted frame and, if applicable, the received ack frame.\n\n When radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability, radio platform layer updates @p aFrame\n with the security frame counter and key index values maintained by the radio.\n\n @param[in]  aInstance  The OpenThread instance structure.\n @param[in]  aFrame     A pointer to the frame that was transmitted.\n @param[in]  aAckFrame  A pointer to the ACK frame, NULL if no ACK was received.\n @param[in]  aError     OT_ERROR_NONE when the frame was transmitted,\n                        OT_ERROR_NO_ACK when the frame was transmitted but no ACK was received,\n                        OT_ERROR_CHANNEL_ACCESS_FAILURE tx could not take place due to activity on the channel,\n                        OT_ERROR_ABORT when transmission was aborted for other reasons."]
1850    pub fn otPlatRadioTxDone(
1851        aInstance: *mut otInstance,
1852        aFrame: *mut otRadioFrame,
1853        aAckFrame: *mut otRadioFrame,
1854        aError: otError,
1855    );
1856}
1857extern "C" {
1858    #[doc = " The radio driver calls this method to notify OpenThread diagnostics module that the transmission has completed.\n\n Is used when diagnostics is enabled.\n\n @param[in]  aInstance      The OpenThread instance structure.\n @param[in]  aFrame         A pointer to the frame that was transmitted.\n @param[in]  aError         OT_ERROR_NONE when the frame was transmitted,\n                            OT_ERROR_CHANNEL_ACCESS_FAILURE tx could not take place due to activity on the channel,\n                            OT_ERROR_ABORT when transmission was aborted for other reasons."]
1859    pub fn otPlatDiagRadioTransmitDone(
1860        aInstance: *mut otInstance,
1861        aFrame: *mut otRadioFrame,
1862        aError: otError,
1863    );
1864}
1865extern "C" {
1866    #[doc = " Get the most recent RSSI measurement.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The RSSI in dBm when it is valid.  127 when RSSI is invalid."]
1867    pub fn otPlatRadioGetRssi(aInstance: *mut otInstance) -> i8;
1868}
1869extern "C" {
1870    #[doc = " Begin the energy scan sequence on the radio.\n\n Is used when radio provides OT_RADIO_CAPS_ENERGY_SCAN capability.\n\n @param[in] aInstance      The OpenThread instance structure.\n @param[in] aScanChannel   The channel to perform the energy scan on.\n @param[in] aScanDuration  The duration, in milliseconds, for the channel to be scanned.\n\n @retval OT_ERROR_NONE             Successfully started scanning the channel.\n @retval OT_ERROR_BUSY             The radio is performing energy scanning.\n @retval OT_ERROR_NOT_IMPLEMENTED  The radio doesn't support energy scanning."]
1871    pub fn otPlatRadioEnergyScan(
1872        aInstance: *mut otInstance,
1873        aScanChannel: u8,
1874        aScanDuration: u16,
1875    ) -> otError;
1876}
1877extern "C" {
1878    #[doc = " The radio driver calls this method to notify OpenThread that the energy scan is complete.\n\n Is used when radio provides OT_RADIO_CAPS_ENERGY_SCAN capability.\n\n @param[in]  aInstance           The OpenThread instance structure.\n @param[in]  aEnergyScanMaxRssi  The maximum RSSI encountered on the scanned channel."]
1879    pub fn otPlatRadioEnergyScanDone(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8);
1880}
1881extern "C" {
1882    #[doc = " The radio driver calls this method to notify OpenThread that the spinel bus latency has been changed.\n\n @param[in]  aInstance  The OpenThread instance structure."]
1883    pub fn otPlatRadioBusLatencyChanged(aInstance: *mut otInstance);
1884}
1885extern "C" {
1886    #[doc = " Enable/Disable source address match feature.\n\n The source address match feature controls how the radio layer decides the \"frame pending\" bit for acks sent in\n response to data request commands from children.\n\n If disabled, the radio layer must set the \"frame pending\" on all acks to data request commands.\n\n If enabled, the radio layer uses the source address match table to determine whether to set or clear the \"frame\n pending\" bit in an ack to a data request command.\n\n The source address match table provides the list of children for which there is a pending frame. Either a short\n address or an extended/long address can be added to the source address match table.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aEnable     Enable/disable source address match feature."]
1887    pub fn otPlatRadioEnableSrcMatch(aInstance: *mut otInstance, aEnable: bool);
1888}
1889extern "C" {
1890    #[doc = " Add a short address to the source address match table.\n\n @param[in]  aInstance      The OpenThread instance structure.\n @param[in]  aShortAddress  The short address to be added.\n\n @retval OT_ERROR_NONE      Successfully added short address to the source match table.\n @retval OT_ERROR_NO_BUFS   No available entry in the source match table."]
1891    pub fn otPlatRadioAddSrcMatchShortEntry(
1892        aInstance: *mut otInstance,
1893        aShortAddress: otShortAddress,
1894    ) -> otError;
1895}
1896extern "C" {
1897    #[doc = " Add an extended address to the source address match table.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aExtAddress  The extended address to be added stored in little-endian byte order.\n\n @retval OT_ERROR_NONE      Successfully added extended address to the source match table.\n @retval OT_ERROR_NO_BUFS   No available entry in the source match table."]
1898    pub fn otPlatRadioAddSrcMatchExtEntry(
1899        aInstance: *mut otInstance,
1900        aExtAddress: *const otExtAddress,
1901    ) -> otError;
1902}
1903extern "C" {
1904    #[doc = " Remove a short address from the source address match table.\n\n @param[in]  aInstance      The OpenThread instance structure.\n @param[in]  aShortAddress  The short address to be removed.\n\n @retval OT_ERROR_NONE        Successfully removed short address from the source match table.\n @retval OT_ERROR_NO_ADDRESS  The short address is not in source address match table."]
1905    pub fn otPlatRadioClearSrcMatchShortEntry(
1906        aInstance: *mut otInstance,
1907        aShortAddress: otShortAddress,
1908    ) -> otError;
1909}
1910extern "C" {
1911    #[doc = " Remove an extended address from the source address match table.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aExtAddress  The extended address to be removed stored in little-endian byte order.\n\n @retval OT_ERROR_NONE        Successfully removed the extended address from the source match table.\n @retval OT_ERROR_NO_ADDRESS  The extended address is not in source address match table."]
1912    pub fn otPlatRadioClearSrcMatchExtEntry(
1913        aInstance: *mut otInstance,
1914        aExtAddress: *const otExtAddress,
1915    ) -> otError;
1916}
1917extern "C" {
1918    #[doc = " Clear all short addresses from the source address match table.\n\n @param[in]  aInstance   The OpenThread instance structure."]
1919    pub fn otPlatRadioClearSrcMatchShortEntries(aInstance: *mut otInstance);
1920}
1921extern "C" {
1922    #[doc = " Clear all the extended/long addresses from source address match table.\n\n @param[in]  aInstance   The OpenThread instance structure."]
1923    pub fn otPlatRadioClearSrcMatchExtEntries(aInstance: *mut otInstance);
1924}
1925extern "C" {
1926    #[doc = " Get the radio supported channel mask that the device is allowed to be on.\n\n @param[in]  aInstance   The OpenThread instance structure.\n\n @returns The radio supported channel mask."]
1927    pub fn otPlatRadioGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
1928}
1929extern "C" {
1930    #[doc = " Gets the radio preferred channel mask that the device prefers to form on.\n\n @param[in]  aInstance   The OpenThread instance structure.\n\n @returns The radio preferred channel mask."]
1931    pub fn otPlatRadioGetPreferredChannelMask(aInstance: *mut otInstance) -> u32;
1932}
1933extern "C" {
1934    #[doc = " Enable the radio coex.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aEnabled   TRUE to enable the radio coex, FALSE otherwise.\n\n @retval OT_ERROR_NONE     Successfully enabled.\n @retval OT_ERROR_FAILED   The radio coex could not be enabled."]
1935    pub fn otPlatRadioSetCoexEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
1936}
1937extern "C" {
1938    #[doc = " Check whether radio coex is enabled or not.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns TRUE if the radio coex is enabled, FALSE otherwise."]
1939    pub fn otPlatRadioIsCoexEnabled(aInstance: *mut otInstance) -> bool;
1940}
1941extern "C" {
1942    #[doc = " Get the radio coexistence metrics.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[out] aCoexMetrics  A pointer to the coexistence metrics structure.\n\n @retval OT_ERROR_NONE          Successfully retrieved the coex metrics.\n @retval OT_ERROR_INVALID_ARGS  @p aCoexMetrics was NULL."]
1943    pub fn otPlatRadioGetCoexMetrics(
1944        aInstance: *mut otInstance,
1945        aCoexMetrics: *mut otRadioCoexMetrics,
1946    ) -> otError;
1947}
1948extern "C" {
1949    #[doc = " Enable or disable CSL receiver.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[in]  aCslPeriod    CSL period, 0 for disabling CSL. CSL period is in unit of 10 symbols.\n @param[in]  aShortAddr    The short source address of CSL receiver's peer.\n @param[in]  aExtAddr      The extended source address of CSL receiver's peer.\n\n @note Platforms should use CSL peer addresses to include CSL IE when generating enhanced acks.\n\n @retval  OT_ERROR_NOT_IMPLEMENTED Radio driver doesn't support CSL.\n @retval  OT_ERROR_FAILED          Other platform specific errors.\n @retval  OT_ERROR_NONE            Successfully enabled or disabled CSL."]
1950    pub fn otPlatRadioEnableCsl(
1951        aInstance: *mut otInstance,
1952        aCslPeriod: u32,
1953        aShortAddr: otShortAddress,
1954        aExtAddr: *const otExtAddress,
1955    ) -> otError;
1956}
1957extern "C" {
1958    #[doc = " Reset CSL receiver in the platform.\n\n @note Defaults to `otPlatRadioEnableCsl(aInstance,0, Mac::kShortAddrInvalid, nullptr);`\n\n @param[in]  aInstance     The OpenThread instance structure.\n\n @retval  OT_ERROR_NOT_IMPLEMENTED Radio driver doesn't support CSL.\n @retval  OT_ERROR_FAILED          Other platform specific errors.\n @retval  OT_ERROR_NONE            Successfully disabled CSL."]
1959    pub fn otPlatRadioResetCsl(aInstance: *mut otInstance) -> otError;
1960}
1961extern "C" {
1962    #[doc = " Update CSL sample time in radio driver.\n\n Sample time is stored in radio driver as a copy to calculate phase when\n sending ACK with CSL IE. The CSL sample (window) of the CSL receiver extends\n before and after the sample time. The CSL sample time marks a timestamp in\n the CSL sample window when a frame should be received in \"ideal conditions\"\n if there would be no inaccuracy/clock-drift.\n\n @param[in]  aInstance         The OpenThread instance structure.\n @param[in]  aCslSampleTime    The next sample time, in microseconds. It is\n                               the time when the first symbol of the MHR of\n                               the frame is expected."]
1963    pub fn otPlatRadioUpdateCslSampleTime(aInstance: *mut otInstance, aCslSampleTime: u32);
1964}
1965extern "C" {
1966    #[doc = " Get the current estimated worst case accuracy (maximum ± deviation from the\n nominal frequency) of the local radio clock in units of PPM. This is the\n clock used to schedule CSL operations.\n\n @note Implementations MAY estimate this value based on current operating\n conditions (e.g. temperature).\n\n In case the implementation does not estimate the current value but returns a\n fixed value, this value MUST be the worst-case accuracy over all possible\n foreseen operating conditions (temperature, pressure, etc) of the\n implementation.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The current CSL rx/tx scheduling drift, in PPM."]
1967    pub fn otPlatRadioGetCslAccuracy(aInstance: *mut otInstance) -> u8;
1968}
1969extern "C" {
1970    #[doc = " The fixed uncertainty (i.e. random jitter) of the arrival time of CSL\n transmissions received by this device in units of 10 microseconds.\n\n This designates the worst case constant positive or negative deviation of\n the actual arrival time of a transmission from the transmission time\n calculated relative to the local radio clock independent of elapsed time. In\n addition to uncertainty accumulated over elapsed time, the CSL channel sample\n (\"RX window\") must be extended by twice this deviation such that an actual\n transmission is guaranteed to be detected by the local receiver in the\n presence of random arrival time jitter.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The CSL Uncertainty in units of 10 us."]
1971    pub fn otPlatRadioGetCslUncertainty(aInstance: *mut otInstance) -> u8;
1972}
1973extern "C" {
1974    #[doc = " Set the max transmit power for a specific channel.\n\n @note This function will be deprecated in October 2027. It is recommended to use the function\n       `otPlatRadioSetChannelTargetPower()`.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aChannel     The radio channel.\n @param[in]  aMaxPower    The max power in dBm, passing OT_RADIO_RSSI_INVALID will disable this channel.\n\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented\n @retval  OT_ERROR_INVALID_ARGS     The specified channel is not valid.\n @retval  OT_ERROR_FAILED           Other platform specific errors.\n @retval  OT_ERROR_NONE             Successfully set max transmit power."]
1975    pub fn otPlatRadioSetChannelMaxTransmitPower(
1976        aInstance: *mut otInstance,
1977        aChannel: u8,
1978        aMaxPower: i8,
1979    ) -> otError;
1980}
1981extern "C" {
1982    #[doc = " Set the region code.\n\n The radio region format is the 2-bytes ascii representation of the\n ISO 3166 alpha-2 code.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aRegionCode  The radio region code. The `aRegionCode >> 8` is first ascii char\n                          and the `aRegionCode & 0xff` is the second ascii char.\n\n @retval  OT_ERROR_FAILED           Other platform specific errors.\n @retval  OT_ERROR_NONE             Successfully set region code.\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented."]
1983    pub fn otPlatRadioSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
1984}
1985extern "C" {
1986    #[doc = " Get the region code.\n\n The radio region format is the 2-bytes ascii representation of the\n ISO 3166 alpha-2 code.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[out] aRegionCode  The radio region.\n\n @retval  OT_ERROR_INVALID_ARGS     @p aRegionCode is nullptr.\n @retval  OT_ERROR_FAILED           Other platform specific errors.\n @retval  OT_ERROR_NONE             Successfully got region code.\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented."]
1987    pub fn otPlatRadioGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
1988}
1989extern "C" {
1990    #[doc = " Enable/disable or update Enhanced-ACK Based Probing in radio for a specific Initiator.\n\n After Enhanced-ACK Based Probing is configured by a specific Probing Initiator, the Enhanced-ACK sent to that\n node should include Vendor-Specific IE containing Link Metrics data. This method informs the radio to start/stop to\n collect Link Metrics data and include Vendor-Specific IE that containing the data in Enhanced-ACK sent to that\n Probing Initiator.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[in]  aLinkMetrics  This parameter specifies what metrics to query. Per spec 4.11.3.4.4.6, at most 2 metrics\n                           can be specified. The probing would be disabled if @p `aLinkMetrics` is bitwise 0.\n @param[in]  aShortAddress The short address of the Probing Initiator.\n @param[in]  aExtAddress   The extended source address of the Probing Initiator. @p aExtAddr MUST NOT be `NULL`.\n\n @retval  OT_ERROR_NONE            Successfully configured the Enhanced-ACK Based Probing.\n @retval  OT_ERROR_INVALID_ARGS    @p aExtAddress is `NULL`.\n @retval  OT_ERROR_NOT_FOUND       The Initiator indicated by @p aShortAddress is not found when trying to clear.\n @retval  OT_ERROR_NO_BUFS         No more Initiator can be supported.\n @retval  OT_ERROR_NOT_IMPLEMENTED The feature is not implemented."]
1991    pub fn otPlatRadioConfigureEnhAckProbing(
1992        aInstance: *mut otInstance,
1993        aLinkMetrics: otLinkMetrics,
1994        aShortAddress: otShortAddress,
1995        aExtAddress: *const otExtAddress,
1996    ) -> otError;
1997}
1998extern "C" {
1999    #[doc = " Add a calibrated power of the specified channel to the power calibration table.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n\n The @p aActualPower is the actual measured output power when the parameters of the radio hardware modules\n are set to the @p aRawPowerSetting.\n\n The raw power setting is an opaque byte array. OpenThread doesn't define the format of the raw power setting.\n Its format is radio hardware related and it should be defined by the developers in the platform radio driver.\n For example, if the radio hardware contains both the radio chip and the FEM chip, the raw power setting can be\n a combination of the radio power register and the FEM gain value.\n\n @param[in] aInstance               The OpenThread instance structure.\n @param[in] aChannel                The radio channel.\n @param[in] aActualPower            The actual power in 0.01dBm.\n @param[in] aRawPowerSetting        A pointer to the raw power setting byte array.\n @param[in] aRawPowerSettingLength  The length of the @p aRawPowerSetting.\n\n @retval OT_ERROR_NONE             Successfully added the calibrated power to the power calibration table.\n @retval OT_ERROR_NO_BUFS          No available entry in the power calibration table.\n @retval OT_ERROR_INVALID_ARGS     The @p aChannel, @p aActualPower or @p aRawPowerSetting is invalid or the\n                                   @p aActualPower already exists in the power calibration table.\n @retval OT_ERROR_NOT_IMPLEMENTED  This feature is not implemented."]
2000    pub fn otPlatRadioAddCalibratedPower(
2001        aInstance: *mut otInstance,
2002        aChannel: u8,
2003        aActualPower: i16,
2004        aRawPowerSetting: *const u8,
2005        aRawPowerSettingLength: u16,
2006    ) -> otError;
2007}
2008extern "C" {
2009    #[doc = " Clear all calibrated powers from the power calibration table.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n\n @param[in]  aInstance   The OpenThread instance structure.\n\n @retval OT_ERROR_NONE             Successfully cleared all calibrated powers from the power calibration table.\n @retval OT_ERROR_NOT_IMPLEMENTED  This feature is not implemented."]
2010    pub fn otPlatRadioClearCalibratedPowers(aInstance: *mut otInstance) -> otError;
2011}
2012extern "C" {
2013    #[doc = " Set the target power for the given channel.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n       If this function and `otPlatRadioSetTransmitPower()` are implemented at the same time:\n       - If neither of these two functions is called, the radio outputs the platform-defined default power.\n       - If both functions are called, the last one to be called takes effect.\n\n The radio driver should set the actual output power to be less than or equal to the @p aTargetPower and as close\n as possible to the @p aTargetPower. If the @p aTargetPower is lower than the minimum output power supported\n by the platform, the output power should be set to the minimum output power supported by the platform.  If the\n @p aTargetPower is higher than the maximum output power supported by the platform, the output power should be\n set to the maximum output power supported by the platform. If the @p aTargetPower is set to `INT16_MAX`, the\n corresponding channel is disabled.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[in]  aChannel      The radio channel.\n @param[in]  aTargetPower  The target power in 0.01dBm.\n\n @retval  OT_ERROR_NONE             Successfully set the target power.\n @retval  OT_ERROR_INVALID_ARGS     The @p aChannel is invalid.\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented."]
2014    pub fn otPlatRadioSetChannelTargetPower(
2015        aInstance: *mut otInstance,
2016        aChannel: u8,
2017        aTargetPower: i16,
2018    ) -> otError;
2019}
2020extern "C" {
2021    #[doc = " Get the raw power setting for the given channel.\n\n @note OpenThread `src/core/utils` implements a default implementation of the API `otPlatRadioAddCalibratedPower()`,\n       `otPlatRadioClearCalibratedPowers()` and `otPlatRadioSetChannelTargetPower()`. This API is provided by\n       the default implementation to get the raw power setting for the given channel. If the platform doesn't\n       use the default implementation, it can ignore this API.\n\n Platform radio layer should parse the raw power setting based on the radio layer defined format and set the\n parameters of each radio hardware module.\n\n @param[in]      aInstance               The OpenThread instance structure.\n @param[in]      aChannel                The radio channel.\n @param[out]     aRawPowerSetting        A pointer to the raw power setting byte array.\n @param[in,out]  aRawPowerSettingLength  On input, a pointer to the size of @p aRawPowerSetting.\n                                         On output, a pointer to the length of the raw power setting data.\n\n @retval  OT_ERROR_NONE          Successfully got the target power.\n @retval  OT_ERROR_INVALID_ARGS  The @p aChannel is invalid, @p aRawPowerSetting or @p aRawPowerSettingLength is NULL\n                                 or @aRawPowerSettingLength is too short.\n @retval  OT_ERROR_NOT_FOUND     The raw power setting for the @p aChannel was not found."]
2022    pub fn otPlatRadioGetRawPowerSetting(
2023        aInstance: *mut otInstance,
2024        aChannel: u8,
2025        aRawPowerSetting: *mut u8,
2026        aRawPowerSettingLength: *mut u16,
2027    ) -> otError;
2028}
2029#[doc = " @struct otIp6InterfaceIdentifier\n\n Represents the Interface Identifier of an IPv6 address."]
2030#[repr(C, packed)]
2031#[derive(Copy, Clone)]
2032pub struct otIp6InterfaceIdentifier {
2033    #[doc = "< The Interface Identifier accessor fields"]
2034    pub mFields: otIp6InterfaceIdentifier__bindgen_ty_1,
2035}
2036#[repr(C, packed)]
2037#[derive(Copy, Clone)]
2038pub union otIp6InterfaceIdentifier__bindgen_ty_1 {
2039    #[doc = "< 8-bit fields"]
2040    pub m8: [u8; 8usize],
2041    #[doc = "< 16-bit fields"]
2042    pub m16: [u16; 4usize],
2043    #[doc = "< 32-bit fields"]
2044    pub m32: [u32; 2usize],
2045}
2046impl Default for otIp6InterfaceIdentifier__bindgen_ty_1 {
2047    fn default() -> Self {
2048        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2049        unsafe {
2050            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2051            s.assume_init()
2052        }
2053    }
2054}
2055impl Default for otIp6InterfaceIdentifier {
2056    fn default() -> Self {
2057        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2058        unsafe {
2059            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2060            s.assume_init()
2061        }
2062    }
2063}
2064#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2065#[repr(C, packed)]
2066#[derive(Debug, Default, Copy, Clone)]
2067pub struct otIp6NetworkPrefix {
2068    #[doc = "< The Network Prefix."]
2069    pub m8: [u8; 8usize],
2070}
2071#[doc = " @struct otIp6AddressComponents\n\n Represents the components of an IPv6 address."]
2072#[repr(C, packed)]
2073#[derive(Copy, Clone)]
2074pub struct otIp6AddressComponents {
2075    #[doc = "< The Network Prefix (most significant 64 bits of the address)"]
2076    pub mNetworkPrefix: otIp6NetworkPrefix,
2077    #[doc = "< The Interface Identifier (least significant 64 bits of the address)"]
2078    pub mIid: otIp6InterfaceIdentifier,
2079}
2080impl Default for otIp6AddressComponents {
2081    fn default() -> Self {
2082        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2083        unsafe {
2084            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2085            s.assume_init()
2086        }
2087    }
2088}
2089#[doc = " @struct otIp6Address\n\n Represents an IPv6 address."]
2090#[repr(C, packed)]
2091#[derive(Copy, Clone)]
2092pub struct otIp6Address {
2093    #[doc = "< IPv6 accessor fields"]
2094    pub mFields: otIp6Address__bindgen_ty_1,
2095}
2096#[repr(C, packed)]
2097#[derive(Copy, Clone)]
2098pub union otIp6Address__bindgen_ty_1 {
2099    #[doc = "< 8-bit fields"]
2100    pub m8: [u8; 16usize],
2101    #[doc = "< 16-bit fields"]
2102    pub m16: [u16; 8usize],
2103    #[doc = "< 32-bit fields"]
2104    pub m32: [u32; 4usize],
2105    #[doc = "< IPv6 address components"]
2106    pub mComponents: otIp6AddressComponents,
2107}
2108impl Default for otIp6Address__bindgen_ty_1 {
2109    fn default() -> Self {
2110        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2111        unsafe {
2112            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2113            s.assume_init()
2114        }
2115    }
2116}
2117impl Default for otIp6Address {
2118    fn default() -> Self {
2119        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2120        unsafe {
2121            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2122            s.assume_init()
2123        }
2124    }
2125}
2126#[doc = " @struct otIp6Prefix\n\n Represents an IPv6 prefix."]
2127#[repr(C, packed)]
2128#[derive(Copy, Clone)]
2129pub struct otIp6Prefix {
2130    #[doc = "< The IPv6 prefix."]
2131    pub mPrefix: otIp6Address,
2132    #[doc = "< The IPv6 prefix length (in bits)."]
2133    pub mLength: u8,
2134}
2135impl Default for otIp6Prefix {
2136    fn default() -> Self {
2137        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2138        unsafe {
2139            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2140            s.assume_init()
2141        }
2142    }
2143}
2144#[doc = "< Thread assigned address (ALOC, RLOC, MLEID, etc)"]
2145pub const OT_ADDRESS_ORIGIN_THREAD: _bindgen_ty_7 = 0;
2146#[doc = "< SLAAC assigned address"]
2147pub const OT_ADDRESS_ORIGIN_SLAAC: _bindgen_ty_7 = 1;
2148#[doc = "< DHCPv6 assigned address"]
2149pub const OT_ADDRESS_ORIGIN_DHCPV6: _bindgen_ty_7 = 2;
2150#[doc = "< Manually assigned address"]
2151pub const OT_ADDRESS_ORIGIN_MANUAL: _bindgen_ty_7 = 3;
2152#[doc = " IPv6 Address origins"]
2153pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
2154#[doc = " Represents an IPv6 network interface unicast address."]
2155#[repr(C)]
2156#[derive(Copy, Clone)]
2157pub struct otNetifAddress {
2158    #[doc = "< The IPv6 unicast address."]
2159    pub mAddress: otIp6Address,
2160    #[doc = "< The Prefix length (in bits)."]
2161    pub mPrefixLength: u8,
2162    #[doc = "< The IPv6 address origin."]
2163    pub mAddressOrigin: u8,
2164    pub _bitfield_align_1: [u8; 0],
2165    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2166    #[doc = "< A pointer to the next network interface address."]
2167    pub mNext: *const otNetifAddress,
2168}
2169impl Default for otNetifAddress {
2170    fn default() -> Self {
2171        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2172        unsafe {
2173            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2174            s.assume_init()
2175        }
2176    }
2177}
2178impl otNetifAddress {
2179    #[inline]
2180    pub fn mPreferred(&self) -> bool {
2181        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2182    }
2183    #[inline]
2184    pub fn set_mPreferred(&mut self, val: bool) {
2185        unsafe {
2186            let val: u8 = ::std::mem::transmute(val);
2187            self._bitfield_1.set(0usize, 1u8, val as u64)
2188        }
2189    }
2190    #[inline]
2191    pub fn mValid(&self) -> bool {
2192        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2193    }
2194    #[inline]
2195    pub fn set_mValid(&mut self, val: bool) {
2196        unsafe {
2197            let val: u8 = ::std::mem::transmute(val);
2198            self._bitfield_1.set(1usize, 1u8, val as u64)
2199        }
2200    }
2201    #[inline]
2202    pub fn mScopeOverrideValid(&self) -> bool {
2203        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2204    }
2205    #[inline]
2206    pub fn set_mScopeOverrideValid(&mut self, val: bool) {
2207        unsafe {
2208            let val: u8 = ::std::mem::transmute(val);
2209            self._bitfield_1.set(2usize, 1u8, val as u64)
2210        }
2211    }
2212    #[inline]
2213    pub fn mScopeOverride(&self) -> ::std::os::raw::c_uint {
2214        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 4u8) as u32) }
2215    }
2216    #[inline]
2217    pub fn set_mScopeOverride(&mut self, val: ::std::os::raw::c_uint) {
2218        unsafe {
2219            let val: u32 = ::std::mem::transmute(val);
2220            self._bitfield_1.set(3usize, 4u8, val as u64)
2221        }
2222    }
2223    #[inline]
2224    pub fn mRloc(&self) -> bool {
2225        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2226    }
2227    #[inline]
2228    pub fn set_mRloc(&mut self, val: bool) {
2229        unsafe {
2230            let val: u8 = ::std::mem::transmute(val);
2231            self._bitfield_1.set(7usize, 1u8, val as u64)
2232        }
2233    }
2234    #[inline]
2235    pub fn mMeshLocal(&self) -> bool {
2236        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2237    }
2238    #[inline]
2239    pub fn set_mMeshLocal(&mut self, val: bool) {
2240        unsafe {
2241            let val: u8 = ::std::mem::transmute(val);
2242            self._bitfield_1.set(8usize, 1u8, val as u64)
2243        }
2244    }
2245    #[inline]
2246    pub fn mSrpRegistered(&self) -> bool {
2247        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
2248    }
2249    #[inline]
2250    pub fn set_mSrpRegistered(&mut self, val: bool) {
2251        unsafe {
2252            let val: u8 = ::std::mem::transmute(val);
2253            self._bitfield_1.set(9usize, 1u8, val as u64)
2254        }
2255    }
2256    #[inline]
2257    pub fn new_bitfield_1(
2258        mPreferred: bool,
2259        mValid: bool,
2260        mScopeOverrideValid: bool,
2261        mScopeOverride: ::std::os::raw::c_uint,
2262        mRloc: bool,
2263        mMeshLocal: bool,
2264        mSrpRegistered: bool,
2265    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2266        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2267        __bindgen_bitfield_unit.set(0usize, 1u8, {
2268            let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2269            mPreferred as u64
2270        });
2271        __bindgen_bitfield_unit.set(1usize, 1u8, {
2272            let mValid: u8 = unsafe { ::std::mem::transmute(mValid) };
2273            mValid as u64
2274        });
2275        __bindgen_bitfield_unit.set(2usize, 1u8, {
2276            let mScopeOverrideValid: u8 = unsafe { ::std::mem::transmute(mScopeOverrideValid) };
2277            mScopeOverrideValid as u64
2278        });
2279        __bindgen_bitfield_unit.set(3usize, 4u8, {
2280            let mScopeOverride: u32 = unsafe { ::std::mem::transmute(mScopeOverride) };
2281            mScopeOverride as u64
2282        });
2283        __bindgen_bitfield_unit.set(7usize, 1u8, {
2284            let mRloc: u8 = unsafe { ::std::mem::transmute(mRloc) };
2285            mRloc as u64
2286        });
2287        __bindgen_bitfield_unit.set(8usize, 1u8, {
2288            let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2289            mMeshLocal as u64
2290        });
2291        __bindgen_bitfield_unit.set(9usize, 1u8, {
2292            let mSrpRegistered: u8 = unsafe { ::std::mem::transmute(mSrpRegistered) };
2293            mSrpRegistered as u64
2294        });
2295        __bindgen_bitfield_unit
2296    }
2297}
2298#[doc = " Represents an IPv6 network interface multicast address."]
2299#[repr(C)]
2300#[derive(Copy, Clone)]
2301pub struct otNetifMulticastAddress {
2302    #[doc = "< The IPv6 multicast address."]
2303    pub mAddress: otIp6Address,
2304    #[doc = "< A pointer to the next network interface multicast address."]
2305    pub mNext: *const otNetifMulticastAddress,
2306}
2307impl Default for otNetifMulticastAddress {
2308    fn default() -> Self {
2309        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2310        unsafe {
2311            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2312            s.assume_init()
2313        }
2314    }
2315}
2316#[doc = " Represents an IPv6 socket address."]
2317#[repr(C)]
2318#[derive(Copy, Clone)]
2319pub struct otSockAddr {
2320    #[doc = "< An IPv6 address."]
2321    pub mAddress: otIp6Address,
2322    #[doc = "< A transport-layer port."]
2323    pub mPort: u16,
2324}
2325impl Default for otSockAddr {
2326    fn default() -> Self {
2327        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2328        unsafe {
2329            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2330            s.assume_init()
2331        }
2332    }
2333}
2334#[doc = "< Non-ECT"]
2335pub const OT_ECN_NOT_CAPABLE: _bindgen_ty_8 = 0;
2336#[doc = "< ECT(0)"]
2337pub const OT_ECN_CAPABLE_0: _bindgen_ty_8 = 2;
2338#[doc = "< ECT(1)"]
2339pub const OT_ECN_CAPABLE_1: _bindgen_ty_8 = 1;
2340#[doc = "< Congestion encountered (CE)"]
2341pub const OT_ECN_MARKED: _bindgen_ty_8 = 3;
2342#[doc = " ECN statuses, represented as in the IP header."]
2343pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
2344#[doc = " Represents the local and peer IPv6 socket addresses."]
2345#[repr(C)]
2346#[derive(Copy, Clone)]
2347pub struct otMessageInfo {
2348    #[doc = "< The local IPv6 address."]
2349    pub mSockAddr: otIp6Address,
2350    #[doc = "< The peer IPv6 address."]
2351    pub mPeerAddr: otIp6Address,
2352    #[doc = "< The local transport-layer port."]
2353    pub mSockPort: u16,
2354    #[doc = "< The peer transport-layer port."]
2355    pub mPeerPort: u16,
2356    #[doc = "< The IPv6 Hop Limit value. Only applies if `mAllowZeroHopLimit` is FALSE.\n< If `0`, IPv6 Hop Limit is default value `OPENTHREAD_CONFIG_IP6_HOP_LIMIT_DEFAULT`.\n< Otherwise, specifies the IPv6 Hop Limit."]
2357    pub mHopLimit: u8,
2358    pub _bitfield_align_1: [u8; 0],
2359    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2360}
2361impl Default for otMessageInfo {
2362    fn default() -> Self {
2363        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2364        unsafe {
2365            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2366            s.assume_init()
2367        }
2368    }
2369}
2370impl otMessageInfo {
2371    #[inline]
2372    pub fn mEcn(&self) -> u8 {
2373        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
2374    }
2375    #[inline]
2376    pub fn set_mEcn(&mut self, val: u8) {
2377        unsafe {
2378            let val: u8 = ::std::mem::transmute(val);
2379            self._bitfield_1.set(0usize, 2u8, val as u64)
2380        }
2381    }
2382    #[inline]
2383    pub fn mIsHostInterface(&self) -> bool {
2384        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2385    }
2386    #[inline]
2387    pub fn set_mIsHostInterface(&mut self, val: bool) {
2388        unsafe {
2389            let val: u8 = ::std::mem::transmute(val);
2390            self._bitfield_1.set(2usize, 1u8, val as u64)
2391        }
2392    }
2393    #[inline]
2394    pub fn mAllowZeroHopLimit(&self) -> bool {
2395        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2396    }
2397    #[inline]
2398    pub fn set_mAllowZeroHopLimit(&mut self, val: bool) {
2399        unsafe {
2400            let val: u8 = ::std::mem::transmute(val);
2401            self._bitfield_1.set(3usize, 1u8, val as u64)
2402        }
2403    }
2404    #[inline]
2405    pub fn mMulticastLoop(&self) -> bool {
2406        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2407    }
2408    #[inline]
2409    pub fn set_mMulticastLoop(&mut self, val: bool) {
2410        unsafe {
2411            let val: u8 = ::std::mem::transmute(val);
2412            self._bitfield_1.set(4usize, 1u8, val as u64)
2413        }
2414    }
2415    #[inline]
2416    pub fn new_bitfield_1(
2417        mEcn: u8,
2418        mIsHostInterface: bool,
2419        mAllowZeroHopLimit: bool,
2420        mMulticastLoop: bool,
2421    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2422        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2423        __bindgen_bitfield_unit.set(0usize, 2u8, {
2424            let mEcn: u8 = unsafe { ::std::mem::transmute(mEcn) };
2425            mEcn as u64
2426        });
2427        __bindgen_bitfield_unit.set(2usize, 1u8, {
2428            let mIsHostInterface: u8 = unsafe { ::std::mem::transmute(mIsHostInterface) };
2429            mIsHostInterface as u64
2430        });
2431        __bindgen_bitfield_unit.set(3usize, 1u8, {
2432            let mAllowZeroHopLimit: u8 = unsafe { ::std::mem::transmute(mAllowZeroHopLimit) };
2433            mAllowZeroHopLimit as u64
2434        });
2435        __bindgen_bitfield_unit.set(4usize, 1u8, {
2436            let mMulticastLoop: u8 = unsafe { ::std::mem::transmute(mMulticastLoop) };
2437            mMulticastLoop as u64
2438        });
2439        __bindgen_bitfield_unit
2440    }
2441}
2442#[doc = "< IPv6 Hop-by-Hop Option"]
2443pub const OT_IP6_PROTO_HOP_OPTS: _bindgen_ty_9 = 0;
2444#[doc = "< Transmission Control Protocol"]
2445pub const OT_IP6_PROTO_TCP: _bindgen_ty_9 = 6;
2446#[doc = "< User Datagram"]
2447pub const OT_IP6_PROTO_UDP: _bindgen_ty_9 = 17;
2448#[doc = "< IPv6 encapsulation"]
2449pub const OT_IP6_PROTO_IP6: _bindgen_ty_9 = 41;
2450#[doc = "< Routing Header for IPv6"]
2451pub const OT_IP6_PROTO_ROUTING: _bindgen_ty_9 = 43;
2452#[doc = "< Fragment Header for IPv6"]
2453pub const OT_IP6_PROTO_FRAGMENT: _bindgen_ty_9 = 44;
2454#[doc = "< ICMP for IPv6"]
2455pub const OT_IP6_PROTO_ICMP6: _bindgen_ty_9 = 58;
2456#[doc = "< No Next Header for IPv6"]
2457pub const OT_IP6_PROTO_NONE: _bindgen_ty_9 = 59;
2458#[doc = "< Destination Options for IPv6"]
2459pub const OT_IP6_PROTO_DST_OPTS: _bindgen_ty_9 = 60;
2460#[doc = " Internet Protocol Numbers."]
2461pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
2462extern "C" {
2463    #[doc = " Brings the IPv6 interface up or down.\n\n Call this to enable or disable IPv6 communication.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled  TRUE to enable IPv6, FALSE otherwise.\n\n @retval OT_ERROR_NONE            Successfully brought the IPv6 interface up/down.\n @retval OT_ERROR_INVALID_STATE   IPv6 interface is not available since device is operating in raw-link mode\n                                  (applicable only when `OPENTHREAD_CONFIG_LINK_RAW_ENABLE` feature is enabled)."]
2464    pub fn otIp6SetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
2465}
2466extern "C" {
2467    #[doc = " Indicates whether or not the IPv6 interface is up.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   The IPv6 interface is enabled.\n @retval FALSE  The IPv6 interface is disabled."]
2468    pub fn otIp6IsEnabled(aInstance: *mut otInstance) -> bool;
2469}
2470extern "C" {
2471    #[doc = " Adds a Network Interface Address to the Thread interface.\n\n The passed-in instance @p aAddress is copied by the Thread interface. The Thread interface only\n supports a fixed number of externally added unicast addresses. See `OPENTHREAD_CONFIG_IP6_MAX_EXT_UCAST_ADDRS`.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aAddress  A pointer to a Network Interface Address.\n\n @retval OT_ERROR_NONE          Successfully added (or updated) the Network Interface Address.\n @retval OT_ERROR_INVALID_ARGS  The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NO_BUFS       The Network Interface is already storing the maximum allowed external addresses."]
2472    pub fn otIp6AddUnicastAddress(
2473        aInstance: *mut otInstance,
2474        aAddress: *const otNetifAddress,
2475    ) -> otError;
2476}
2477extern "C" {
2478    #[doc = " Removes a Network Interface Address from the Thread interface.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aAddress  A pointer to an IP Address.\n\n @retval OT_ERROR_NONE          Successfully removed the Network Interface Address.\n @retval OT_ERROR_INVALID_ARGS  The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NOT_FOUND     The IP Address indicated by @p aAddress was not found."]
2479    pub fn otIp6RemoveUnicastAddress(
2480        aInstance: *mut otInstance,
2481        aAddress: *const otIp6Address,
2482    ) -> otError;
2483}
2484extern "C" {
2485    #[doc = " Gets the list of IPv6 addresses assigned to the Thread interface.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the first Network Interface Address."]
2486    pub fn otIp6GetUnicastAddresses(aInstance: *mut otInstance) -> *const otNetifAddress;
2487}
2488extern "C" {
2489    #[doc = " Indicates whether or not a unicast IPv6 address is assigned to the Thread interface.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aAddress  A pointer to the unicast address.\n\n @retval TRUE   If @p aAddress is assigned to the Thread interface.\n @retval FALSE  If @p aAddress is not assigned to the Thread interface."]
2490    pub fn otIp6HasUnicastAddress(
2491        aInstance: *mut otInstance,
2492        aAddress: *const otIp6Address,
2493    ) -> bool;
2494}
2495extern "C" {
2496    #[doc = " Subscribes the Thread interface to a Network Interface Multicast Address.\n\n The passed in instance @p aAddress will be copied by the Thread interface. The Thread interface only\n supports a fixed number of externally added multicast addresses. See `OPENTHREAD_CONFIG_IP6_MAX_EXT_MCAST_ADDRS`.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aAddress  A pointer to an IP Address.\n\n @retval OT_ERROR_NONE           Successfully subscribed to the Network Interface Multicast Address.\n @retval OT_ERROR_ALREADY        The multicast address is already subscribed.\n @retval OT_ERROR_INVALID_ARGS   The IP Address indicated by @p aAddress is an invalid multicast address.\n @retval OT_ERROR_REJECTED       The IP Address indicated by @p aAddress is an internal multicast address.\n @retval OT_ERROR_NO_BUFS        The Network Interface is already storing the maximum allowed external multicast\n                                 addresses."]
2497    pub fn otIp6SubscribeMulticastAddress(
2498        aInstance: *mut otInstance,
2499        aAddress: *const otIp6Address,
2500    ) -> otError;
2501}
2502extern "C" {
2503    #[doc = " Unsubscribes the Thread interface to a Network Interface Multicast Address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aAddress  A pointer to an IP Address.\n\n @retval OT_ERROR_NONE          Successfully unsubscribed to the Network Interface Multicast Address.\n @retval OT_ERROR_REJECTED      The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NOT_FOUND     The IP Address indicated by @p aAddress was not found."]
2504    pub fn otIp6UnsubscribeMulticastAddress(
2505        aInstance: *mut otInstance,
2506        aAddress: *const otIp6Address,
2507    ) -> otError;
2508}
2509extern "C" {
2510    #[doc = " Gets the list of IPv6 multicast addresses subscribed to the Thread interface.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the first Network Interface Multicast Address."]
2511    pub fn otIp6GetMulticastAddresses(aInstance: *mut otInstance)
2512        -> *const otNetifMulticastAddress;
2513}
2514extern "C" {
2515    #[doc = " Allocate a new message buffer for sending an IPv6 message.\n\n @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSettings  A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.\n\n @sa otMessageFree"]
2516    pub fn otIp6NewMessage(
2517        aInstance: *mut otInstance,
2518        aSettings: *const otMessageSettings,
2519    ) -> *mut otMessage;
2520}
2521extern "C" {
2522    #[doc = " Allocate a new message buffer and write the IPv6 datagram to the message buffer for sending an IPv6 message.\n\n @note If @p aSettings is NULL, the link layer security is enabled and the message priority is obtained from IPv6\n       message itself.\n       If @p aSettings is not NULL, the @p aSetting->mPriority is ignored and obtained from IPv6 message itself.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aData        A pointer to the IPv6 datagram buffer.\n @param[in]  aDataLength  The size of the IPv6 datagram buffer pointed by @p aData.\n @param[in]  aSettings    A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message or NULL if malformed IPv6 header or insufficient message buffers are available.\n\n @sa otMessageFree"]
2523    pub fn otIp6NewMessageFromBuffer(
2524        aInstance: *mut otInstance,
2525        aData: *const u8,
2526        aDataLength: u16,
2527        aSettings: *const otMessageSettings,
2528    ) -> *mut otMessage;
2529}
2530#[doc = " Pointer is called when an IPv6 datagram is received.\n\n @param[in]  aMessage  A pointer to the message buffer containing the received IPv6 datagram. This function transfers\n                       the ownership of the @p aMessage to the receiver of the callback. The message should be\n                       freed by the receiver of the callback after it is processed (see otMessageFree()).\n @param[in]  aContext  A pointer to application-specific context."]
2531pub type otIp6ReceiveCallback = ::std::option::Option<
2532    unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
2533>;
2534extern "C" {
2535    #[doc = " Registers a callback to provide received IPv6 datagrams.\n\n By default, this callback does not pass Thread control traffic.  See otIp6SetReceiveFilterEnabled() to\n change the Thread control traffic filter setting.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aCallback         A pointer to a function that is called when an IPv6 datagram is received or\n                               NULL to disable the callback.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @sa otIp6IsReceiveFilterEnabled\n @sa otIp6SetReceiveFilterEnabled"]
2536    pub fn otIp6SetReceiveCallback(
2537        aInstance: *mut otInstance,
2538        aCallback: otIp6ReceiveCallback,
2539        aCallbackContext: *mut ::std::os::raw::c_void,
2540    );
2541}
2542#[doc = " Represents IPv6 address information."]
2543#[repr(C)]
2544#[derive(Debug, Copy, Clone)]
2545pub struct otIp6AddressInfo {
2546    #[doc = "< A pointer to the IPv6 address."]
2547    pub mAddress: *const otIp6Address,
2548    #[doc = "< The prefix length of mAddress if it is a unicast address."]
2549    pub mPrefixLength: u8,
2550    pub _bitfield_align_1: [u8; 0],
2551    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2552    pub __bindgen_padding_0: [u16; 3usize],
2553}
2554impl Default for otIp6AddressInfo {
2555    fn default() -> Self {
2556        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2557        unsafe {
2558            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2559            s.assume_init()
2560        }
2561    }
2562}
2563impl otIp6AddressInfo {
2564    #[inline]
2565    pub fn mScope(&self) -> u8 {
2566        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
2567    }
2568    #[inline]
2569    pub fn set_mScope(&mut self, val: u8) {
2570        unsafe {
2571            let val: u8 = ::std::mem::transmute(val);
2572            self._bitfield_1.set(0usize, 4u8, val as u64)
2573        }
2574    }
2575    #[inline]
2576    pub fn mPreferred(&self) -> bool {
2577        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2578    }
2579    #[inline]
2580    pub fn set_mPreferred(&mut self, val: bool) {
2581        unsafe {
2582            let val: u8 = ::std::mem::transmute(val);
2583            self._bitfield_1.set(4usize, 1u8, val as u64)
2584        }
2585    }
2586    #[inline]
2587    pub fn mMeshLocal(&self) -> bool {
2588        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2589    }
2590    #[inline]
2591    pub fn set_mMeshLocal(&mut self, val: bool) {
2592        unsafe {
2593            let val: u8 = ::std::mem::transmute(val);
2594            self._bitfield_1.set(5usize, 1u8, val as u64)
2595        }
2596    }
2597    #[inline]
2598    pub fn new_bitfield_1(
2599        mScope: u8,
2600        mPreferred: bool,
2601        mMeshLocal: bool,
2602    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2603        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2604        __bindgen_bitfield_unit.set(0usize, 4u8, {
2605            let mScope: u8 = unsafe { ::std::mem::transmute(mScope) };
2606            mScope as u64
2607        });
2608        __bindgen_bitfield_unit.set(4usize, 1u8, {
2609            let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2610            mPreferred as u64
2611        });
2612        __bindgen_bitfield_unit.set(5usize, 1u8, {
2613            let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2614            mMeshLocal as u64
2615        });
2616        __bindgen_bitfield_unit
2617    }
2618}
2619#[doc = " Pointer is called when an internal IPv6 address is added or removed.\n\n @param[in]   aAddressInfo        A pointer to the IPv6 address information.\n @param[in]   aIsAdded            TRUE if the @p aAddress was added, FALSE if @p aAddress was removed.\n @param[in]   aContext            A pointer to application-specific context."]
2620pub type otIp6AddressCallback = ::std::option::Option<
2621    unsafe extern "C" fn(
2622        aAddressInfo: *const otIp6AddressInfo,
2623        aIsAdded: bool,
2624        aContext: *mut ::std::os::raw::c_void,
2625    ),
2626>;
2627extern "C" {
2628    #[doc = " Registers a callback to notify internal IPv6 address changes.\n\n @param[in]   aInstance           A pointer to an OpenThread instance.\n @param[in]   aCallback           A pointer to a function that is called when an internal IPv6 address is added or\n                                  removed. NULL to disable the callback.\n @param[in]   aCallbackContext    A pointer to application-specific context."]
2629    pub fn otIp6SetAddressCallback(
2630        aInstance: *mut otInstance,
2631        aCallback: otIp6AddressCallback,
2632        aCallbackContext: *mut ::std::os::raw::c_void,
2633    );
2634}
2635extern "C" {
2636    #[doc = " Indicates whether or not Thread control traffic is filtered out when delivering IPv6 datagrams\n via the callback specified in otIp6SetReceiveCallback().\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns  TRUE if Thread control traffic is filtered out, FALSE otherwise.\n\n @sa otIp6SetReceiveCallback\n @sa otIp6SetReceiveFilterEnabled"]
2637    pub fn otIp6IsReceiveFilterEnabled(aInstance: *mut otInstance) -> bool;
2638}
2639extern "C" {
2640    #[doc = " Sets whether or not Thread control traffic is filtered out when delivering IPv6 datagrams\n via the callback specified in otIp6SetReceiveCallback().\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aEnabled  TRUE if Thread control traffic is filtered out, FALSE otherwise.\n\n @sa otIp6SetReceiveCallback\n @sa otIsReceiveIp6FilterEnabled"]
2641    pub fn otIp6SetReceiveFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
2642}
2643extern "C" {
2644    #[doc = " Sends an IPv6 datagram via the Thread interface.\n\n The caller transfers ownership of @p aMessage when making this call. OpenThread will free @p aMessage when\n processing is complete, including when a value other than `OT_ERROR_NONE` is returned.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aMessage  A pointer to the message buffer containing the IPv6 datagram.\n\n @retval OT_ERROR_NONE                    Successfully processed the message.\n @retval OT_ERROR_DROP                    Message was well-formed but not fully processed due to packet processing\n rules.\n @retval OT_ERROR_NO_BUFS                 Could not allocate necessary message buffers when processing the datagram.\n @retval OT_ERROR_NO_ROUTE                No route to host.\n @retval OT_ERROR_INVALID_SOURCE_ADDRESS  Source address is invalid, e.g. an anycast address or a multicast address.\n @retval OT_ERROR_PARSE                   Encountered a malformed header when processing the message.\n @retval OT_ERROR_INVALID_ARGS            The message's metadata is invalid, e.g. the message uses\n                                          `OT_MESSAGE_ORIGIN_THREAD_NETIF` as the origin."]
2645    pub fn otIp6Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
2646}
2647extern "C" {
2648    #[doc = " Adds a port to the allowed unsecured port list.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aPort     The port value.\n\n @retval OT_ERROR_NONE         The port was successfully added to the allowed unsecure port list.\n @retval OT_ERROR_INVALID_ARGS The port is invalid (value 0 is reserved for internal use).\n @retval OT_ERROR_NO_BUFS      The unsecure port list is full."]
2649    pub fn otIp6AddUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2650}
2651extern "C" {
2652    #[doc = " Removes a port from the allowed unsecure port list.\n\n @note This function removes @p aPort by overwriting @p aPort with the element after @p aPort in the internal port\n       list. Be careful when calling otIp6GetUnsecurePorts() followed by otIp6RemoveUnsecurePort() to remove unsecure\n       ports.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aPort     The port value.\n\n @retval OT_ERROR_NONE         The port was successfully removed from the allowed unsecure port list.\n @retval OT_ERROR_INVALID_ARGS The port is invalid (value 0 is reserved for internal use).\n @retval OT_ERROR_NOT_FOUND    The port was not found in the unsecure port list."]
2653    pub fn otIp6RemoveUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2654}
2655extern "C" {
2656    #[doc = " Removes all ports from the allowed unsecure port list.\n\n @param[in]  aInstance A pointer to an OpenThread instance."]
2657    pub fn otIp6RemoveAllUnsecurePorts(aInstance: *mut otInstance);
2658}
2659extern "C" {
2660    #[doc = " Returns a pointer to the unsecure port list.\n\n @note Port value 0 is used to indicate an invalid entry.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aNumEntries  The number of entries in the list.\n\n @returns A pointer to the unsecure port list."]
2661    pub fn otIp6GetUnsecurePorts(aInstance: *mut otInstance, aNumEntries: *mut u8) -> *const u16;
2662}
2663extern "C" {
2664    #[doc = " Test if two IPv6 addresses are the same.\n\n @param[in]  aFirst   A pointer to the first IPv6 address to compare.\n @param[in]  aSecond  A pointer to the second IPv6 address to compare.\n\n @retval TRUE   The two IPv6 addresses are the same.\n @retval FALSE  The two IPv6 addresses are not the same."]
2665    pub fn otIp6IsAddressEqual(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> bool;
2666}
2667extern "C" {
2668    #[doc = " Test if two IPv6 prefixes are the same.\n\n @param[in]  aFirst   A pointer to the first IPv6 prefix to compare.\n @param[in]  aSecond  A pointer to the second IPv6 prefix to compare.\n\n @retval TRUE   The two IPv6 prefixes are the same.\n @retval FALSE  The two IPv6 prefixes are not the same."]
2669    pub fn otIp6ArePrefixesEqual(aFirst: *const otIp6Prefix, aSecond: *const otIp6Prefix) -> bool;
2670}
2671extern "C" {
2672    #[doc = " Converts a human-readable IPv6 address string into a binary representation.\n\n @param[in]   aString   A pointer to a NULL-terminated string.\n @param[out]  aAddress  A pointer to an IPv6 address.\n\n @retval OT_ERROR_NONE   Successfully parsed @p aString and updated @p aAddress.\n @retval OT_ERROR_PARSE  Failed to parse @p aString as an IPv6 address."]
2673    pub fn otIp6AddressFromString(
2674        aString: *const ::std::os::raw::c_char,
2675        aAddress: *mut otIp6Address,
2676    ) -> otError;
2677}
2678extern "C" {
2679    #[doc = " Converts a human-readable IPv6 prefix string into a binary representation.\n\n The @p aString parameter should be a string in the format \"<address>/<plen>\", where `<address>` is an IPv6\n address and `<plen>` is a prefix length.\n\n @param[in]   aString  A pointer to a NULL-terminated string.\n @param[out]  aPrefix  A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE   Successfully parsed the string as an IPv6 prefix and updated @p aPrefix.\n @retval OT_ERROR_PARSE  Failed to parse @p aString as an IPv6 prefix."]
2680    pub fn otIp6PrefixFromString(
2681        aString: *const ::std::os::raw::c_char,
2682        aPrefix: *mut otIp6Prefix,
2683    ) -> otError;
2684}
2685extern "C" {
2686    #[doc = " Converts a given IPv6 address to a human-readable string.\n\n The IPv6 address string is formatted as 16 hex values separated by ':' (i.e., \"%x:%x:%x:...:%x\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in]  aAddress  A pointer to an IPv6 address (MUST NOT be NULL).\n @param[out] aBuffer   A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in]  aSize     The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_ADDRESS_STRING_SIZE`."]
2687    pub fn otIp6AddressToString(
2688        aAddress: *const otIp6Address,
2689        aBuffer: *mut ::std::os::raw::c_char,
2690        aSize: u16,
2691    );
2692}
2693extern "C" {
2694    #[doc = " Converts a given IPv6 socket address to a human-readable string.\n\n The IPv6 socket address string is formatted as [`address`]:`port` where `address` is shown\n as 16 hex values separated by `:` and `port` is the port number in decimal format,\n for example \"[%x:%x:...:%x]:%u\".\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in]  aSockAddr A pointer to an IPv6 socket address (MUST NOT be NULL).\n @param[out] aBuffer   A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in]  aSize     The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_SOCK_ADDR_STRING_SIZE`."]
2695    pub fn otIp6SockAddrToString(
2696        aSockAddr: *const otSockAddr,
2697        aBuffer: *mut ::std::os::raw::c_char,
2698        aSize: u16,
2699    );
2700}
2701extern "C" {
2702    #[doc = " Converts a given IPv6 prefix to a human-readable string.\n\n The IPv6 address string is formatted as \"%x:%x:%x:...[::]/plen\".\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in]  aPrefix   A pointer to an IPv6 prefix (MUST NOT be NULL).\n @param[out] aBuffer   A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in]  aSize     The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_PREFIX_STRING_SIZE`."]
2703    pub fn otIp6PrefixToString(
2704        aPrefix: *const otIp6Prefix,
2705        aBuffer: *mut ::std::os::raw::c_char,
2706        aSize: u16,
2707    );
2708}
2709extern "C" {
2710    #[doc = " Returns the prefix match length (bits) for two IPv6 addresses.\n\n @param[in]  aFirst   A pointer to the first IPv6 address.\n @param[in]  aSecond  A pointer to the second IPv6 address.\n\n @returns  The prefix match length in bits."]
2711    pub fn otIp6PrefixMatch(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> u8;
2712}
2713extern "C" {
2714    #[doc = " Gets a prefix with @p aLength from @p aAddress.\n\n @param[in]  aAddress   A pointer to an IPv6 address.\n @param[in]  aLength    The length of prefix in bits.\n @param[out] aPrefix    A pointer to output the IPv6 prefix."]
2715    pub fn otIp6GetPrefix(aAddress: *const otIp6Address, aLength: u8, aPrefix: *mut otIp6Prefix);
2716}
2717extern "C" {
2718    #[doc = " Indicates whether or not a given IPv6 address is the Unspecified Address.\n\n @param[in]  aAddress   A pointer to an IPv6 address.\n\n @retval TRUE   If the IPv6 address is the Unspecified Address.\n @retval FALSE  If the IPv6 address is not the Unspecified Address."]
2719    pub fn otIp6IsAddressUnspecified(aAddress: *const otIp6Address) -> bool;
2720}
2721extern "C" {
2722    #[doc = " Perform OpenThread source address selection.\n\n @param[in]      aInstance     A pointer to an OpenThread instance.\n @param[in,out]  aMessageInfo  A pointer to the message information.\n\n @retval  OT_ERROR_NONE       Found a source address and is filled into mSockAddr of @p aMessageInfo.\n @retval  OT_ERROR_NOT_FOUND  No source address was found and @p aMessageInfo is unchanged."]
2723    pub fn otIp6SelectSourceAddress(
2724        aInstance: *mut otInstance,
2725        aMessageInfo: *mut otMessageInfo,
2726    ) -> otError;
2727}
2728extern "C" {
2729    #[doc = " Indicates whether the SLAAC module is enabled or not.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n @retval TRUE    SLAAC module is enabled.\n @retval FALSE   SLAAC module is disabled."]
2730    pub fn otIp6IsSlaacEnabled(aInstance: *mut otInstance) -> bool;
2731}
2732extern "C" {
2733    #[doc = " Enables/disables the SLAAC module.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n When SLAAC module is enabled, SLAAC addresses (based on on-mesh prefixes in Network Data) are added to the interface.\n When SLAAC module is disabled any previously added SLAAC address is removed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled  TRUE to enable, FALSE to disable."]
2734    pub fn otIp6SetSlaacEnabled(aInstance: *mut otInstance, aEnabled: bool);
2735}
2736#[doc = " Pointer allows user to filter prefixes and not allow an SLAAC address based on a prefix to be added.\n\n `otIp6SetSlaacPrefixFilter()` can be used to set the filter handler. The filter handler is invoked by SLAAC module\n when it is about to add a SLAAC address based on a prefix. Its boolean return value determines whether the address\n is filtered (not added) or not.\n\n @param[in] aInstance   A pointer to an OpenThread instance.\n @param[in] aPrefix     A pointer to prefix for which SLAAC address is about to be added.\n\n @retval TRUE    Indicates that the SLAAC address based on the prefix should be filtered and NOT added.\n @retval FALSE   Indicates that the SLAAC address based on the prefix should be added."]
2737pub type otIp6SlaacPrefixFilter = ::std::option::Option<
2738    unsafe extern "C" fn(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix) -> bool,
2739>;
2740extern "C" {
2741    #[doc = " Sets the SLAAC module filter handler.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n The filter handler is called by SLAAC module when it is about to add a SLAAC address based on a prefix to decide\n whether the address should be added or not.\n\n A NULL filter handler disables filtering and allows all SLAAC addresses to be added.\n\n If this function is not called, the default filter used by SLAAC module will be NULL (filtering is disabled).\n\n @param[in] aInstance    A pointer to an OpenThread instance.\n @param[in] aFilter      A pointer to SLAAC prefix filter handler, or NULL to disable filtering."]
2742    pub fn otIp6SetSlaacPrefixFilter(aInstance: *mut otInstance, aFilter: otIp6SlaacPrefixFilter);
2743}
2744#[doc = " Pointer is called with results of `otIp6RegisterMulticastListeners`.\n\n @param[in]  aContext  A pointer to the user context.\n @param[in]  aError    OT_ERROR_NONE when successfully sent MLR.req and received MLR.rsp,\n                       OT_ERROR_RESPONSE_TIMEOUT when failed to receive MLR.rsp,\n                       OT_ERROR_PARSE when failed to parse MLR.rsp.\n @param[in]  aMlrStatus         The Multicast Listener Registration status when @p aError is OT_ERROR_NONE.\n @param[in]  aFailedAddresses   A pointer to the failed IPv6 addresses when @p aError is OT_ERROR_NONE.\n @param[in]  aFailedAddressNum  The number of failed IPv6 addresses when @p aError is OT_ERROR_NONE.\n\n @sa otIp6RegisterMulticastListeners"]
2745pub type otIp6RegisterMulticastListenersCallback = ::std::option::Option<
2746    unsafe extern "C" fn(
2747        aContext: *mut ::std::os::raw::c_void,
2748        aError: otError,
2749        aMlrStatus: u8,
2750        aFailedAddresses: *const otIp6Address,
2751        aFailedAddressNum: u8,
2752    ),
2753>;
2754extern "C" {
2755    #[doc = " Registers Multicast Listeners to Primary Backbone Router.\n\n `OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE` and `OPENTHREAD_CONFIG_COMMISSIONER_ENABLE`\n must be enabled.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aAddresses   A Multicast Address Array to register.\n @param[in]  aAddressNum  The number of Multicast Address to register (0 if @p aAddresses is NULL).\n @param[in]  aTimeout     A pointer to the timeout value (in seconds) to be included in MLR.req. A timeout value of 0\n                          removes the corresponding Multicast Listener. If NULL, MLR.req would have no Timeout Tlv by\n                          default.\n @param[in]  aCallback    A pointer to the callback function.\n @param[in]  aContext     A pointer to the user context.\n\n @retval OT_ERROR_NONE           Successfully sent MLR.req. The @p aCallback will be called iff this method\n                                 returns OT_ERROR_NONE.\n @retval OT_ERROR_BUSY           If a previous registration was ongoing.\n @retval OT_ERROR_INVALID_ARGS   If one or more arguments are invalid.\n @retval OT_ERROR_INVALID_STATE  If the device was not in a valid state to send MLR.req (e.g. Commissioner not\n                                 started, Primary Backbone Router not found).\n @retval OT_ERROR_NO_BUFS        If insufficient message buffers available.\n\n @sa otIp6RegisterMulticastListenersCallback"]
2756    pub fn otIp6RegisterMulticastListeners(
2757        aInstance: *mut otInstance,
2758        aAddresses: *const otIp6Address,
2759        aAddressNum: u8,
2760        aTimeout: *const u32,
2761        aCallback: otIp6RegisterMulticastListenersCallback,
2762        aContext: *mut ::std::os::raw::c_void,
2763    ) -> otError;
2764}
2765extern "C" {
2766    #[doc = " Sets the Mesh Local IID (for test purpose).\n\n Requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n @param[in]   aIid        A pointer to the Mesh Local IID to set.\n\n @retval  OT_ERROR_NONE           Successfully set the Mesh Local IID.\n @retval  OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
2767    pub fn otIp6SetMeshLocalIid(
2768        aInstance: *mut otInstance,
2769        aIid: *const otIp6InterfaceIdentifier,
2770    ) -> otError;
2771}
2772extern "C" {
2773    #[doc = " Converts a given IP protocol number to a human-readable string.\n\n @param[in] aIpProto   An IP protocol number (`OT_IP6_PROTO_*` enumeration).\n\n @returns A string representing @p aIpProto."]
2774    pub fn otIp6ProtoToString(aIpProto: u8) -> *const ::std::os::raw::c_char;
2775}
2776#[doc = " Represents the counters for packets and bytes."]
2777#[repr(C)]
2778#[derive(Debug, Default, Copy, Clone)]
2779pub struct otPacketsAndBytes {
2780    #[doc = "< The number of packets."]
2781    pub mPackets: u64,
2782    #[doc = "< The number of bytes."]
2783    pub mBytes: u64,
2784}
2785#[doc = " Represents the counters of packets forwarded via Border Routing."]
2786#[repr(C)]
2787#[derive(Debug, Default, Copy, Clone)]
2788pub struct otBorderRoutingCounters {
2789    #[doc = "< The counters for inbound unicast."]
2790    pub mInboundUnicast: otPacketsAndBytes,
2791    #[doc = "< The counters for inbound multicast."]
2792    pub mInboundMulticast: otPacketsAndBytes,
2793    #[doc = "< The counters for outbound unicast."]
2794    pub mOutboundUnicast: otPacketsAndBytes,
2795    #[doc = "< The counters for outbound multicast."]
2796    pub mOutboundMulticast: otPacketsAndBytes,
2797    #[doc = "< The counters for inbound Internet when DHCPv6 PD enabled."]
2798    pub mInboundInternet: otPacketsAndBytes,
2799    #[doc = "< The counters for outbound Internet when DHCPv6 PD enabled."]
2800    pub mOutboundInternet: otPacketsAndBytes,
2801    #[doc = "< The number of received RA packets."]
2802    pub mRaRx: u32,
2803    #[doc = "< The number of RA packets successfully transmitted."]
2804    pub mRaTxSuccess: u32,
2805    #[doc = "< The number of RA packets failed to transmit."]
2806    pub mRaTxFailure: u32,
2807    #[doc = "< The number of received RS packets."]
2808    pub mRsRx: u32,
2809    #[doc = "< The number of RS packets successfully transmitted."]
2810    pub mRsTxSuccess: u32,
2811    #[doc = "< The number of RS packets failed to transmit."]
2812    pub mRsTxFailure: u32,
2813}
2814extern "C" {
2815    #[doc = " Gets the Border Routing counters.\n\n `OPENTHREAD_CONFIG_IP6_BR_COUNTERS_ENABLE` build-time feature must be enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the Border Routing counters."]
2816    pub fn otIp6GetBorderRoutingCounters(
2817        aInstance: *mut otInstance,
2818    ) -> *const otBorderRoutingCounters;
2819}
2820extern "C" {
2821    #[doc = " Resets the Border Routing counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
2822    pub fn otIp6ResetBorderRoutingCounters(aInstance: *mut otInstance);
2823}
2824#[doc = " @struct otNetworkKey\n\n Represents a Thread Network Key."]
2825#[repr(C, packed)]
2826#[derive(Debug, Default, Copy, Clone)]
2827pub struct otNetworkKey {
2828    #[doc = "< Byte values"]
2829    pub m8: [u8; 16usize],
2830}
2831#[doc = " This datatype represents KeyRef to NetworkKey."]
2832pub type otNetworkKeyRef = otCryptoKeyRef;
2833#[doc = " Represents a Network Name.\n\n The `otNetworkName` is a null terminated C string (i.e., `m8` char array MUST end with null char `\\0`)."]
2834#[repr(C)]
2835#[derive(Debug, Default, Copy, Clone)]
2836pub struct otNetworkName {
2837    #[doc = "< Byte values. The `+ 1` is for null char."]
2838    pub m8: [::std::os::raw::c_char; 17usize],
2839}
2840#[doc = " Represents an Extended PAN ID."]
2841#[repr(C, packed)]
2842#[derive(Debug, Default, Copy, Clone)]
2843pub struct otExtendedPanId {
2844    #[doc = "< Byte values"]
2845    pub m8: [u8; 8usize],
2846}
2847#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2848pub type otMeshLocalPrefix = otIp6NetworkPrefix;
2849#[doc = " Represents PSKc."]
2850#[repr(C, packed)]
2851#[derive(Debug, Default, Copy, Clone)]
2852pub struct otPskc {
2853    #[doc = "< Byte values"]
2854    pub m8: [u8; 16usize],
2855}
2856#[doc = " This datatype represents KeyRef to PSKc."]
2857pub type otPskcRef = otCryptoKeyRef;
2858#[doc = " Represent Security Policy."]
2859#[repr(C)]
2860#[derive(Debug, Default, Copy, Clone)]
2861pub struct otSecurityPolicy {
2862    #[doc = "< The value for thrKeyRotation in units of hours."]
2863    pub mRotationTime: u16,
2864    pub _bitfield_align_1: [u8; 0],
2865    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2866}
2867impl otSecurityPolicy {
2868    #[inline]
2869    pub fn mObtainNetworkKeyEnabled(&self) -> bool {
2870        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2871    }
2872    #[inline]
2873    pub fn set_mObtainNetworkKeyEnabled(&mut self, val: bool) {
2874        unsafe {
2875            let val: u8 = ::std::mem::transmute(val);
2876            self._bitfield_1.set(0usize, 1u8, val as u64)
2877        }
2878    }
2879    #[inline]
2880    pub fn mNativeCommissioningEnabled(&self) -> bool {
2881        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2882    }
2883    #[inline]
2884    pub fn set_mNativeCommissioningEnabled(&mut self, val: bool) {
2885        unsafe {
2886            let val: u8 = ::std::mem::transmute(val);
2887            self._bitfield_1.set(1usize, 1u8, val as u64)
2888        }
2889    }
2890    #[inline]
2891    pub fn mRoutersEnabled(&self) -> bool {
2892        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2893    }
2894    #[inline]
2895    pub fn set_mRoutersEnabled(&mut self, val: bool) {
2896        unsafe {
2897            let val: u8 = ::std::mem::transmute(val);
2898            self._bitfield_1.set(2usize, 1u8, val as u64)
2899        }
2900    }
2901    #[inline]
2902    pub fn mExternalCommissioningEnabled(&self) -> bool {
2903        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2904    }
2905    #[inline]
2906    pub fn set_mExternalCommissioningEnabled(&mut self, val: bool) {
2907        unsafe {
2908            let val: u8 = ::std::mem::transmute(val);
2909            self._bitfield_1.set(3usize, 1u8, val as u64)
2910        }
2911    }
2912    #[inline]
2913    pub fn mCommercialCommissioningEnabled(&self) -> bool {
2914        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2915    }
2916    #[inline]
2917    pub fn set_mCommercialCommissioningEnabled(&mut self, val: bool) {
2918        unsafe {
2919            let val: u8 = ::std::mem::transmute(val);
2920            self._bitfield_1.set(4usize, 1u8, val as u64)
2921        }
2922    }
2923    #[inline]
2924    pub fn mAutonomousEnrollmentEnabled(&self) -> bool {
2925        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2926    }
2927    #[inline]
2928    pub fn set_mAutonomousEnrollmentEnabled(&mut self, val: bool) {
2929        unsafe {
2930            let val: u8 = ::std::mem::transmute(val);
2931            self._bitfield_1.set(5usize, 1u8, val as u64)
2932        }
2933    }
2934    #[inline]
2935    pub fn mNetworkKeyProvisioningEnabled(&self) -> bool {
2936        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
2937    }
2938    #[inline]
2939    pub fn set_mNetworkKeyProvisioningEnabled(&mut self, val: bool) {
2940        unsafe {
2941            let val: u8 = ::std::mem::transmute(val);
2942            self._bitfield_1.set(6usize, 1u8, val as u64)
2943        }
2944    }
2945    #[inline]
2946    pub fn mTobleLinkEnabled(&self) -> bool {
2947        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2948    }
2949    #[inline]
2950    pub fn set_mTobleLinkEnabled(&mut self, val: bool) {
2951        unsafe {
2952            let val: u8 = ::std::mem::transmute(val);
2953            self._bitfield_1.set(7usize, 1u8, val as u64)
2954        }
2955    }
2956    #[inline]
2957    pub fn mNonCcmRoutersEnabled(&self) -> bool {
2958        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2959    }
2960    #[inline]
2961    pub fn set_mNonCcmRoutersEnabled(&mut self, val: bool) {
2962        unsafe {
2963            let val: u8 = ::std::mem::transmute(val);
2964            self._bitfield_1.set(8usize, 1u8, val as u64)
2965        }
2966    }
2967    #[inline]
2968    pub fn mVersionThresholdForRouting(&self) -> u8 {
2969        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u8) }
2970    }
2971    #[inline]
2972    pub fn set_mVersionThresholdForRouting(&mut self, val: u8) {
2973        unsafe {
2974            let val: u8 = ::std::mem::transmute(val);
2975            self._bitfield_1.set(9usize, 3u8, val as u64)
2976        }
2977    }
2978    #[inline]
2979    pub fn new_bitfield_1(
2980        mObtainNetworkKeyEnabled: bool,
2981        mNativeCommissioningEnabled: bool,
2982        mRoutersEnabled: bool,
2983        mExternalCommissioningEnabled: bool,
2984        mCommercialCommissioningEnabled: bool,
2985        mAutonomousEnrollmentEnabled: bool,
2986        mNetworkKeyProvisioningEnabled: bool,
2987        mTobleLinkEnabled: bool,
2988        mNonCcmRoutersEnabled: bool,
2989        mVersionThresholdForRouting: u8,
2990    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2991        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2992        __bindgen_bitfield_unit.set(0usize, 1u8, {
2993            let mObtainNetworkKeyEnabled: u8 =
2994                unsafe { ::std::mem::transmute(mObtainNetworkKeyEnabled) };
2995            mObtainNetworkKeyEnabled as u64
2996        });
2997        __bindgen_bitfield_unit.set(1usize, 1u8, {
2998            let mNativeCommissioningEnabled: u8 =
2999                unsafe { ::std::mem::transmute(mNativeCommissioningEnabled) };
3000            mNativeCommissioningEnabled as u64
3001        });
3002        __bindgen_bitfield_unit.set(2usize, 1u8, {
3003            let mRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mRoutersEnabled) };
3004            mRoutersEnabled as u64
3005        });
3006        __bindgen_bitfield_unit.set(3usize, 1u8, {
3007            let mExternalCommissioningEnabled: u8 =
3008                unsafe { ::std::mem::transmute(mExternalCommissioningEnabled) };
3009            mExternalCommissioningEnabled as u64
3010        });
3011        __bindgen_bitfield_unit.set(4usize, 1u8, {
3012            let mCommercialCommissioningEnabled: u8 =
3013                unsafe { ::std::mem::transmute(mCommercialCommissioningEnabled) };
3014            mCommercialCommissioningEnabled as u64
3015        });
3016        __bindgen_bitfield_unit.set(5usize, 1u8, {
3017            let mAutonomousEnrollmentEnabled: u8 =
3018                unsafe { ::std::mem::transmute(mAutonomousEnrollmentEnabled) };
3019            mAutonomousEnrollmentEnabled as u64
3020        });
3021        __bindgen_bitfield_unit.set(6usize, 1u8, {
3022            let mNetworkKeyProvisioningEnabled: u8 =
3023                unsafe { ::std::mem::transmute(mNetworkKeyProvisioningEnabled) };
3024            mNetworkKeyProvisioningEnabled as u64
3025        });
3026        __bindgen_bitfield_unit.set(7usize, 1u8, {
3027            let mTobleLinkEnabled: u8 = unsafe { ::std::mem::transmute(mTobleLinkEnabled) };
3028            mTobleLinkEnabled as u64
3029        });
3030        __bindgen_bitfield_unit.set(8usize, 1u8, {
3031            let mNonCcmRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mNonCcmRoutersEnabled) };
3032            mNonCcmRoutersEnabled as u64
3033        });
3034        __bindgen_bitfield_unit.set(9usize, 3u8, {
3035            let mVersionThresholdForRouting: u8 =
3036                unsafe { ::std::mem::transmute(mVersionThresholdForRouting) };
3037            mVersionThresholdForRouting as u64
3038        });
3039        __bindgen_bitfield_unit
3040    }
3041}
3042#[doc = " Represents Channel Mask."]
3043pub type otChannelMask = u32;
3044#[doc = " Represents presence of different components in Active or Pending Operational Dataset."]
3045#[repr(C)]
3046#[derive(Debug, Default, Copy, Clone)]
3047pub struct otOperationalDatasetComponents {
3048    #[doc = "< TRUE if Active Timestamp is present, FALSE otherwise."]
3049    pub mIsActiveTimestampPresent: bool,
3050    #[doc = "< TRUE if Pending Timestamp is present, FALSE otherwise."]
3051    pub mIsPendingTimestampPresent: bool,
3052    #[doc = "< TRUE if Network Key is present, FALSE otherwise."]
3053    pub mIsNetworkKeyPresent: bool,
3054    #[doc = "< TRUE if Network Name is present, FALSE otherwise."]
3055    pub mIsNetworkNamePresent: bool,
3056    #[doc = "< TRUE if Extended PAN ID is present, FALSE otherwise."]
3057    pub mIsExtendedPanIdPresent: bool,
3058    #[doc = "< TRUE if Mesh Local Prefix is present, FALSE otherwise."]
3059    pub mIsMeshLocalPrefixPresent: bool,
3060    #[doc = "< TRUE if Delay Timer is present, FALSE otherwise."]
3061    pub mIsDelayPresent: bool,
3062    #[doc = "< TRUE if PAN ID is present, FALSE otherwise."]
3063    pub mIsPanIdPresent: bool,
3064    #[doc = "< TRUE if Channel is present, FALSE otherwise."]
3065    pub mIsChannelPresent: bool,
3066    #[doc = "< TRUE if PSKc is present, FALSE otherwise."]
3067    pub mIsPskcPresent: bool,
3068    #[doc = "< TRUE if Security Policy is present, FALSE otherwise."]
3069    pub mIsSecurityPolicyPresent: bool,
3070    #[doc = "< TRUE if Channel Mask is present, FALSE otherwise."]
3071    pub mIsChannelMaskPresent: bool,
3072    #[doc = "< TRUE if Wake-up Channel is present, FALSE otherwise."]
3073    pub mIsWakeupChannelPresent: bool,
3074}
3075#[doc = " Represents a Thread Dataset timestamp component."]
3076#[repr(C)]
3077#[derive(Debug, Default, Copy, Clone)]
3078pub struct otTimestamp {
3079    pub mSeconds: u64,
3080    pub mTicks: u16,
3081    pub mAuthoritative: bool,
3082}
3083#[doc = " Represents an Active or Pending Operational Dataset.\n\n Components in Dataset are optional. `mComponents` structure specifies which components are present in the Dataset."]
3084#[repr(C)]
3085#[derive(Debug, Default, Copy, Clone)]
3086pub struct otOperationalDataset {
3087    #[doc = "< Active Timestamp"]
3088    pub mActiveTimestamp: otTimestamp,
3089    #[doc = "< Pending Timestamp"]
3090    pub mPendingTimestamp: otTimestamp,
3091    #[doc = "< Network Key"]
3092    pub mNetworkKey: otNetworkKey,
3093    #[doc = "< Network Name"]
3094    pub mNetworkName: otNetworkName,
3095    #[doc = "< Extended PAN ID"]
3096    pub mExtendedPanId: otExtendedPanId,
3097    #[doc = "< Mesh Local Prefix"]
3098    pub mMeshLocalPrefix: otMeshLocalPrefix,
3099    #[doc = "< Delay Timer"]
3100    pub mDelay: u32,
3101    #[doc = "< PAN ID"]
3102    pub mPanId: otPanId,
3103    #[doc = "< Channel"]
3104    pub mChannel: u16,
3105    #[doc = "< Wake-up Channel"]
3106    pub mWakeupChannel: u16,
3107    #[doc = "< PSKc"]
3108    pub mPskc: otPskc,
3109    #[doc = "< Security Policy"]
3110    pub mSecurityPolicy: otSecurityPolicy,
3111    #[doc = "< Channel Mask"]
3112    pub mChannelMask: otChannelMask,
3113    #[doc = "< Specifies which components are set in the Dataset."]
3114    pub mComponents: otOperationalDatasetComponents,
3115}
3116#[doc = " Represents an Active or Pending Operational Dataset.\n\n The Operational Dataset is TLV encoded as specified by Thread."]
3117#[repr(C)]
3118#[derive(Debug, Copy, Clone)]
3119pub struct otOperationalDatasetTlvs {
3120    #[doc = "< Operational Dataset TLVs."]
3121    pub mTlvs: [u8; 254usize],
3122    #[doc = "< Size of Operational Dataset in bytes."]
3123    pub mLength: u8,
3124}
3125impl Default for otOperationalDatasetTlvs {
3126    fn default() -> Self {
3127        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3128        unsafe {
3129            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3130            s.assume_init()
3131        }
3132    }
3133}
3134#[doc = "< meshcop Channel TLV"]
3135pub const OT_MESHCOP_TLV_CHANNEL: otMeshcopTlvType = 0;
3136#[doc = "< meshcop Pan Id TLV"]
3137pub const OT_MESHCOP_TLV_PANID: otMeshcopTlvType = 1;
3138#[doc = "< meshcop Extended Pan Id TLV"]
3139pub const OT_MESHCOP_TLV_EXTPANID: otMeshcopTlvType = 2;
3140#[doc = "< meshcop Network Name TLV"]
3141pub const OT_MESHCOP_TLV_NETWORKNAME: otMeshcopTlvType = 3;
3142#[doc = "< meshcop PSKc TLV"]
3143pub const OT_MESHCOP_TLV_PSKC: otMeshcopTlvType = 4;
3144#[doc = "< meshcop Network Key TLV"]
3145pub const OT_MESHCOP_TLV_NETWORKKEY: otMeshcopTlvType = 5;
3146#[doc = "< meshcop Network Key Sequence TLV"]
3147pub const OT_MESHCOP_TLV_NETWORK_KEY_SEQUENCE: otMeshcopTlvType = 6;
3148#[doc = "< meshcop Mesh Local Prefix TLV"]
3149pub const OT_MESHCOP_TLV_MESHLOCALPREFIX: otMeshcopTlvType = 7;
3150#[doc = "< meshcop Steering Data TLV"]
3151pub const OT_MESHCOP_TLV_STEERING_DATA: otMeshcopTlvType = 8;
3152#[doc = "< meshcop Border Agent Locator TLV"]
3153pub const OT_MESHCOP_TLV_BORDER_AGENT_RLOC: otMeshcopTlvType = 9;
3154#[doc = "< meshcop Commissioner ID TLV"]
3155pub const OT_MESHCOP_TLV_COMMISSIONER_ID: otMeshcopTlvType = 10;
3156#[doc = "< meshcop Commissioner Session ID TLV"]
3157pub const OT_MESHCOP_TLV_COMM_SESSION_ID: otMeshcopTlvType = 11;
3158#[doc = "< meshcop Security Policy TLV"]
3159pub const OT_MESHCOP_TLV_SECURITYPOLICY: otMeshcopTlvType = 12;
3160#[doc = "< meshcop Get TLV"]
3161pub const OT_MESHCOP_TLV_GET: otMeshcopTlvType = 13;
3162#[doc = "< meshcop Active Timestamp TLV"]
3163pub const OT_MESHCOP_TLV_ACTIVETIMESTAMP: otMeshcopTlvType = 14;
3164#[doc = "< meshcop Commissioner UDP Port TLV"]
3165pub const OT_MESHCOP_TLV_COMMISSIONER_UDP_PORT: otMeshcopTlvType = 15;
3166#[doc = "< meshcop State TLV"]
3167pub const OT_MESHCOP_TLV_STATE: otMeshcopTlvType = 16;
3168#[doc = "< meshcop Joiner DTLS Encapsulation TLV"]
3169pub const OT_MESHCOP_TLV_JOINER_DTLS: otMeshcopTlvType = 17;
3170#[doc = "< meshcop Joiner UDP Port TLV"]
3171pub const OT_MESHCOP_TLV_JOINER_UDP_PORT: otMeshcopTlvType = 18;
3172#[doc = "< meshcop Joiner IID TLV"]
3173pub const OT_MESHCOP_TLV_JOINER_IID: otMeshcopTlvType = 19;
3174#[doc = "< meshcop Joiner Router Locator TLV"]
3175pub const OT_MESHCOP_TLV_JOINER_RLOC: otMeshcopTlvType = 20;
3176#[doc = "< meshcop Joiner Router KEK TLV"]
3177pub const OT_MESHCOP_TLV_JOINER_ROUTER_KEK: otMeshcopTlvType = 21;
3178#[doc = "< meshcop Provisioning URL TLV"]
3179pub const OT_MESHCOP_TLV_PROVISIONING_URL: otMeshcopTlvType = 32;
3180#[doc = "< meshcop Vendor Name TLV"]
3181pub const OT_MESHCOP_TLV_VENDOR_NAME_TLV: otMeshcopTlvType = 33;
3182#[doc = "< meshcop Vendor Model TLV"]
3183pub const OT_MESHCOP_TLV_VENDOR_MODEL_TLV: otMeshcopTlvType = 34;
3184#[doc = "< meshcop Vendor SW Version TLV"]
3185pub const OT_MESHCOP_TLV_VENDOR_SW_VERSION_TLV: otMeshcopTlvType = 35;
3186#[doc = "< meshcop Vendor Data TLV"]
3187pub const OT_MESHCOP_TLV_VENDOR_DATA_TLV: otMeshcopTlvType = 36;
3188#[doc = "< meshcop Vendor Stack Version TLV"]
3189pub const OT_MESHCOP_TLV_VENDOR_STACK_VERSION_TLV: otMeshcopTlvType = 37;
3190#[doc = "< meshcop UDP encapsulation TLV"]
3191pub const OT_MESHCOP_TLV_UDP_ENCAPSULATION_TLV: otMeshcopTlvType = 48;
3192#[doc = "< meshcop IPv6 address TLV"]
3193pub const OT_MESHCOP_TLV_IPV6_ADDRESS_TLV: otMeshcopTlvType = 49;
3194#[doc = "< meshcop Pending Timestamp TLV"]
3195pub const OT_MESHCOP_TLV_PENDINGTIMESTAMP: otMeshcopTlvType = 51;
3196#[doc = "< meshcop Delay Timer TLV"]
3197pub const OT_MESHCOP_TLV_DELAYTIMER: otMeshcopTlvType = 52;
3198#[doc = "< meshcop Channel Mask TLV"]
3199pub const OT_MESHCOP_TLV_CHANNELMASK: otMeshcopTlvType = 53;
3200#[doc = "< meshcop Count TLV"]
3201pub const OT_MESHCOP_TLV_COUNT: otMeshcopTlvType = 54;
3202#[doc = "< meshcop Period TLV"]
3203pub const OT_MESHCOP_TLV_PERIOD: otMeshcopTlvType = 55;
3204#[doc = "< meshcop Scan Duration TLV"]
3205pub const OT_MESHCOP_TLV_SCAN_DURATION: otMeshcopTlvType = 56;
3206#[doc = "< meshcop Energy List TLV"]
3207pub const OT_MESHCOP_TLV_ENERGY_LIST: otMeshcopTlvType = 57;
3208#[doc = "< meshcop Thread Domain Name TLV"]
3209pub const OT_MESHCOP_TLV_THREAD_DOMAIN_NAME: otMeshcopTlvType = 59;
3210#[doc = "< meshcop Wake-up Channel TLV"]
3211pub const OT_MESHCOP_TLV_WAKEUP_CHANNEL: otMeshcopTlvType = 74;
3212#[doc = "< meshcop Discovery Request TLV"]
3213pub const OT_MESHCOP_TLV_DISCOVERYREQUEST: otMeshcopTlvType = 128;
3214#[doc = "< meshcop Discovery Response TLV"]
3215pub const OT_MESHCOP_TLV_DISCOVERYRESPONSE: otMeshcopTlvType = 129;
3216#[doc = "< meshcop Joiner Advertisement TLV"]
3217pub const OT_MESHCOP_TLV_JOINERADVERTISEMENT: otMeshcopTlvType = 241;
3218#[doc = " Represents meshcop TLV types."]
3219pub type otMeshcopTlvType = ::std::os::raw::c_uint;
3220#[doc = " Pointer is called when a response to a MGMT_SET request is received or times out.\n\n @param[in]  aResult   A result of the operation.\n @param[in]  aContext  A pointer to application-specific context.\n\n @retval  OT_ERROR_NONE              The request was accepted by the leader.\n @retval  OT_ERROR_REJECTED          The request was rejected by the leader.\n @retval  OT_ERROR_PARSE             An error occurred during parsing the response.\n @retval  OT_ERROR_ABORT             The request was reset by peer.\n @retval  OT_ERROR_RESPONSE_TIMEOUT  No response or acknowledgment received during timeout period."]
3221pub type otDatasetMgmtSetCallback = ::std::option::Option<
3222    unsafe extern "C" fn(aResult: otError, aContext: *mut ::std::os::raw::c_void),
3223>;
3224extern "C" {
3225    #[doc = " Indicates whether a valid network is present in the Active Operational Dataset or not.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if a valid network is present in the Active Operational Dataset, FALSE otherwise."]
3226    pub fn otDatasetIsCommissioned(aInstance: *mut otInstance) -> bool;
3227}
3228extern "C" {
3229    #[doc = " Gets the Active Operational Dataset.\n\n @param[in]   aInstance A pointer to an OpenThread instance.\n @param[out]  aDataset  A pointer to where the Active Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the Active Operational Dataset.\n @retval OT_ERROR_NOT_FOUND     No corresponding value in the setting store."]
3230    pub fn otDatasetGetActive(
3231        aInstance: *mut otInstance,
3232        aDataset: *mut otOperationalDataset,
3233    ) -> otError;
3234}
3235extern "C" {
3236    #[doc = " Gets the Active Operational Dataset.\n\n @param[in]   aInstance A pointer to an OpenThread instance.\n @param[out]  aDataset  A pointer to where the Active Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the Active Operational Dataset.\n @retval OT_ERROR_NOT_FOUND     No corresponding value in the setting store."]
3237    pub fn otDatasetGetActiveTlvs(
3238        aInstance: *mut otInstance,
3239        aDataset: *mut otOperationalDatasetTlvs,
3240    ) -> otError;
3241}
3242extern "C" {
3243    #[doc = " Sets the Active Operational Dataset.\n\n If the dataset does not include an Active Timestamp, the dataset is only partially complete.\n\n If Thread is enabled on a device that has a partially complete Active Dataset, the device will attempt to attach to\n an existing Thread network using any existing information in the dataset. Only the Thread Network Key is needed to\n attach to a network.\n\n If channel is not included in the dataset, the device will send MLE Announce messages across different channels to\n find neighbors on other channels.\n\n If the device successfully attaches to a Thread network, the device will then retrieve the full Active Dataset from\n its Parent. Note that a router-capable device will not transition to the Router or Leader roles until it has a\n complete Active Dataset.\n\n This function consistently returns `OT_ERROR_NONE` and can effectively be treated as having a `void` return type.\n Previously, other errors (e.g., `OT_ERROR_NOT_IMPLEMENTED`) were allowed for legacy reasons. However, as\n non-volatile storage is now mandatory for Thread operation, any failure to save the dataset will trigger an\n assertion. The `otError` return type is retained for backward compatibility.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aDataset  A pointer to the Active Operational Dataset.\n\n @retval OT_ERROR_NONE    Successfully set the Active Operational Dataset."]
3244    pub fn otDatasetSetActive(
3245        aInstance: *mut otInstance,
3246        aDataset: *const otOperationalDataset,
3247    ) -> otError;
3248}
3249extern "C" {
3250    #[doc = " Sets the Active Operational Dataset.\n\n If the dataset does not include an Active Timestamp, the dataset is only partially complete.\n\n If Thread is enabled on a device that has a partially complete Active Dataset, the device will attempt to attach to\n an existing Thread network using any existing information in the dataset. Only the Thread Network Key is needed to\n attach to a network.\n\n If channel is not included in the dataset, the device will send MLE Announce messages across different channels to\n find neighbors on other channels.\n\n If the device successfully attaches to a Thread network, the device will then retrieve the full Active Dataset from\n its Parent. Note that a router-capable device will not transition to the Router or Leader roles until it has a\n complete Active Dataset.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aDataset  A pointer to the Active Operational Dataset.\n\n @retval OT_ERROR_NONE          Successfully set the Active Operational Dataset.\n @retval OT_ERROR_INVALID_ARGS  The @p aDataset is invalid. It is too long or contains incorrect TLV formatting."]
3251    pub fn otDatasetSetActiveTlvs(
3252        aInstance: *mut otInstance,
3253        aDataset: *const otOperationalDatasetTlvs,
3254    ) -> otError;
3255}
3256extern "C" {
3257    #[doc = " Gets the Pending Operational Dataset.\n\n @param[in]   aInstance A pointer to an OpenThread instance.\n @param[out]  aDataset  A pointer to where the Pending Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the Pending Operational Dataset.\n @retval OT_ERROR_NOT_FOUND     No corresponding value in the setting store."]
3258    pub fn otDatasetGetPending(
3259        aInstance: *mut otInstance,
3260        aDataset: *mut otOperationalDataset,
3261    ) -> otError;
3262}
3263extern "C" {
3264    #[doc = " Gets the Pending Operational Dataset.\n\n @param[in]   aInstance A pointer to an OpenThread instance.\n @param[out]  aDataset  A pointer to where the Pending Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the Pending Operational Dataset.\n @retval OT_ERROR_NOT_FOUND     No corresponding value in the setting store."]
3265    pub fn otDatasetGetPendingTlvs(
3266        aInstance: *mut otInstance,
3267        aDataset: *mut otOperationalDatasetTlvs,
3268    ) -> otError;
3269}
3270extern "C" {
3271    #[doc = " Sets the Pending Operational Dataset.\n\n This function consistently returns `OT_ERROR_NONE` and can effectively be treated as having a `void` return type.\n Previously, other errors (e.g., `OT_ERROR_NOT_IMPLEMENTED`) were allowed for legacy reasons. However, as\n non-volatile storage is now mandatory for Thread operation, any failure to save the dataset will trigger an\n assertion. The `otError` return type is retained for backward compatibility.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aDataset  A pointer to the Pending Operational Dataset.\n\n @retval OT_ERROR_NONE    Successfully set the Pending Operational Dataset."]
3272    pub fn otDatasetSetPending(
3273        aInstance: *mut otInstance,
3274        aDataset: *const otOperationalDataset,
3275    ) -> otError;
3276}
3277extern "C" {
3278    #[doc = " Sets the Pending Operational Dataset.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aDataset  A pointer to the Pending Operational Dataset.\n\n @retval OT_ERROR_NONE          Successfully set the Pending Operational Dataset.\n @retval OT_ERROR_INVALID_ARGS  The @p aDataset is invalid. It is too long or contains incorrect TLV formatting."]
3279    pub fn otDatasetSetPendingTlvs(
3280        aInstance: *mut otInstance,
3281        aDataset: *const otOperationalDatasetTlvs,
3282    ) -> otError;
3283}
3284extern "C" {
3285    #[doc = " Sends MGMT_ACTIVE_GET.\n\n @param[in]  aInstance           A pointer to an OpenThread instance.\n @param[in]  aDatasetComponents  A pointer to a Dataset Components structure specifying which components to request.\n @param[in]  aTlvTypes           A pointer to array containing additional raw TLV types to be requested.\n @param[in]  aLength             The length of @p aTlvTypes.\n @param[in]  aAddress            A pointer to the IPv6 destination, if it is NULL, will use Leader ALOC as default.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send."]
3286    pub fn otDatasetSendMgmtActiveGet(
3287        aInstance: *mut otInstance,
3288        aDatasetComponents: *const otOperationalDatasetComponents,
3289        aTlvTypes: *const u8,
3290        aLength: u8,
3291        aAddress: *const otIp6Address,
3292    ) -> otError;
3293}
3294extern "C" {
3295    #[doc = " Sends MGMT_ACTIVE_SET.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aDataset   A pointer to operational dataset.\n @param[in]  aTlvs      A pointer to TLVs.\n @param[in]  aLength    The length of TLVs.\n @param[in]  aCallback  A pointer to a function that is called on response reception or timeout.\n @param[in]  aContext   A pointer to application-specific context for @p aCallback.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send.\n @retval OT_ERROR_BUSY          A previous request is ongoing."]
3296    pub fn otDatasetSendMgmtActiveSet(
3297        aInstance: *mut otInstance,
3298        aDataset: *const otOperationalDataset,
3299        aTlvs: *const u8,
3300        aLength: u8,
3301        aCallback: otDatasetMgmtSetCallback,
3302        aContext: *mut ::std::os::raw::c_void,
3303    ) -> otError;
3304}
3305extern "C" {
3306    #[doc = " Sends MGMT_PENDING_GET.\n\n @param[in]  aInstance           A pointer to an OpenThread instance.\n @param[in]  aDatasetComponents  A pointer to a Dataset Components structure specifying which components to request.\n @param[in]  aTlvTypes           A pointer to array containing additional raw TLV types to be requested.\n @param[in]  aLength             The length of @p aTlvTypes.\n @param[in]  aAddress            A pointer to the IPv6 destination, if it is NULL, will use Leader ALOC as default.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send."]
3307    pub fn otDatasetSendMgmtPendingGet(
3308        aInstance: *mut otInstance,
3309        aDatasetComponents: *const otOperationalDatasetComponents,
3310        aTlvTypes: *const u8,
3311        aLength: u8,
3312        aAddress: *const otIp6Address,
3313    ) -> otError;
3314}
3315extern "C" {
3316    #[doc = " Sends MGMT_PENDING_SET.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aDataset   A pointer to operational dataset.\n @param[in]  aTlvs      A pointer to TLVs.\n @param[in]  aLength    The length of TLVs.\n @param[in]  aCallback  A pointer to a function that is called on response reception or timeout.\n @param[in]  aContext   A pointer to application-specific context for @p aCallback.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send.\n @retval OT_ERROR_BUSY          A previous request is ongoing."]
3317    pub fn otDatasetSendMgmtPendingSet(
3318        aInstance: *mut otInstance,
3319        aDataset: *const otOperationalDataset,
3320        aTlvs: *const u8,
3321        aLength: u8,
3322        aCallback: otDatasetMgmtSetCallback,
3323        aContext: *mut ::std::os::raw::c_void,
3324    ) -> otError;
3325}
3326extern "C" {
3327    #[doc = " Generates PSKc from a given pass-phrase, network name, and extended PAN ID.\n\n PSKc is used to establish the Commissioner Session.\n\n @param[in]  aPassPhrase   The commissioning pass-phrase.\n @param[in]  aNetworkName  The network name for PSKc computation.\n @param[in]  aExtPanId     The extended PAN ID for PSKc computation.\n @param[out] aPskc         A pointer to variable to output the generated PSKc.\n\n @retval OT_ERROR_NONE          Successfully generate PSKc.\n @retval OT_ERROR_INVALID_ARGS  If any of the input arguments is invalid."]
3328    pub fn otDatasetGeneratePskc(
3329        aPassPhrase: *const ::std::os::raw::c_char,
3330        aNetworkName: *const otNetworkName,
3331        aExtPanId: *const otExtendedPanId,
3332        aPskc: *mut otPskc,
3333    ) -> otError;
3334}
3335extern "C" {
3336    #[doc = " Sets an `otNetworkName` instance from a given null terminated C string.\n\n @p aNameString must follow UTF-8 encoding and the Network Name length must not be longer than\n `OT_NETWORK_NAME_MAX_SIZE`.\n\n @param[out] aNetworkName        A pointer to the `otNetworkName` to set.\n @param[in]  aNameString         A name C string.\n\n @retval OT_ERROR_NONE           Successfully set @p aNetworkName from @p aNameString.\n @retval OT_ERROR_INVALID_ARGS   @p aNameStrng is invalid (too long or does not follow UTF-8 encoding)."]
3337    pub fn otNetworkNameFromString(
3338        aNetworkName: *mut otNetworkName,
3339        aNameString: *const ::std::os::raw::c_char,
3340    ) -> otError;
3341}
3342extern "C" {
3343    #[doc = " Parses an Operational Dataset from a given `otOperationalDatasetTlvs`.\n\n @param[in]  aDatasetTlvs  A pointer to dataset TLVs.\n @param[out] aDataset      A pointer to where the dataset will be placed.\n\n @retval OT_ERROR_NONE          Successfully set @p aDataset from @p aDatasetTlvs.\n @retval OT_ERROR_INVALID_ARGS  @p aDatasetTlvs's length is longer than `OT_OPERATIONAL_DATASET_MAX_LENGTH`."]
3344    pub fn otDatasetParseTlvs(
3345        aDatasetTlvs: *const otOperationalDatasetTlvs,
3346        aDataset: *mut otOperationalDataset,
3347    ) -> otError;
3348}
3349extern "C" {
3350    #[doc = " Converts a given Operational Dataset to `otOperationalDatasetTlvs`.\n\n @param[in]  aDataset      An Operational dataset to convert to TLVs.\n @param[out] aDatasetTlvs  A pointer to dataset TLVs to return the result."]
3351    pub fn otDatasetConvertToTlvs(
3352        aDataset: *const otOperationalDataset,
3353        aDatasetTlvs: *mut otOperationalDatasetTlvs,
3354    );
3355}
3356extern "C" {
3357    #[doc = " Updates a given Operational Dataset.\n\n @p aDataset contains the fields to be updated and their new value.\n\n @param[in]     aDataset      Specifies the set of types and values to update.\n @param[in,out] aDatasetTlvs  A pointer to dataset TLVs to update.\n\n @retval OT_ERROR_NONE          Successfully updated @p aDatasetTlvs.\n @retval OT_ERROR_INVALID_ARGS  @p aDataset contains invalid values.\n @retval OT_ERROR_NO_BUFS       Not enough space space in @p aDatasetTlvs to apply the update."]
3358    pub fn otDatasetUpdateTlvs(
3359        aDataset: *const otOperationalDataset,
3360        aDatasetTlvs: *mut otOperationalDatasetTlvs,
3361    ) -> otError;
3362}
3363pub const OT_JOINER_STATE_IDLE: otJoinerState = 0;
3364pub const OT_JOINER_STATE_DISCOVER: otJoinerState = 1;
3365pub const OT_JOINER_STATE_CONNECT: otJoinerState = 2;
3366pub const OT_JOINER_STATE_CONNECTED: otJoinerState = 3;
3367pub const OT_JOINER_STATE_ENTRUST: otJoinerState = 4;
3368pub const OT_JOINER_STATE_JOINED: otJoinerState = 5;
3369#[doc = " Defines the Joiner State."]
3370pub type otJoinerState = ::std::os::raw::c_uint;
3371#[doc = " Represents a Joiner Discerner."]
3372#[repr(C)]
3373#[derive(Debug, Default, Copy, Clone)]
3374pub struct otJoinerDiscerner {
3375    #[doc = "< Discerner value (the lowest `mLength` bits specify the discerner)."]
3376    pub mValue: u64,
3377    #[doc = "< Length (number of bits) - must be non-zero and at most `OT_JOINER_MAX_DISCERNER_LENGTH`."]
3378    pub mLength: u8,
3379}
3380#[doc = " Pointer is called to notify the completion of a join operation.\n\n @param[in]  aError    OT_ERROR_NONE if the join process succeeded.\n                       OT_ERROR_SECURITY if the join process failed due to security credentials.\n                       OT_ERROR_NOT_FOUND if no joinable network was discovered.\n                       OT_ERROR_RESPONSE_TIMEOUT if a response timed out.\n @param[in]  aContext  A pointer to application-specific context."]
3381pub type otJoinerCallback = ::std::option::Option<
3382    unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
3383>;
3384extern "C" {
3385    #[doc = " Enables the Thread Joiner role.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aPskd             A pointer to the PSKd.\n @param[in]  aProvisioningUrl  A pointer to the Provisioning URL (may be NULL).\n @param[in]  aVendorName       A pointer to the Vendor Name (may be NULL).\n @param[in]  aVendorModel      A pointer to the Vendor Model (may be NULL).\n @param[in]  aVendorSwVersion  A pointer to the Vendor SW Version (may be NULL).\n @param[in]  aVendorData       A pointer to the Vendor Data (may be NULL).\n @param[in]  aCallback         A pointer to a function that is called when the join operation completes.\n @param[in]  aContext          A pointer to application-specific context.\n\n @retval OT_ERROR_NONE              Successfully started the Joiner role.\n @retval OT_ERROR_BUSY              The previous attempt is still on-going.\n @retval OT_ERROR_INVALID_ARGS      @p aPskd or @p aProvisioningUrl is invalid.\n @retval OT_ERROR_INVALID_STATE     The IPv6 stack is not enabled or Thread stack is fully enabled."]
3386    pub fn otJoinerStart(
3387        aInstance: *mut otInstance,
3388        aPskd: *const ::std::os::raw::c_char,
3389        aProvisioningUrl: *const ::std::os::raw::c_char,
3390        aVendorName: *const ::std::os::raw::c_char,
3391        aVendorModel: *const ::std::os::raw::c_char,
3392        aVendorSwVersion: *const ::std::os::raw::c_char,
3393        aVendorData: *const ::std::os::raw::c_char,
3394        aCallback: otJoinerCallback,
3395        aContext: *mut ::std::os::raw::c_void,
3396    ) -> otError;
3397}
3398extern "C" {
3399    #[doc = " Disables the Thread Joiner role.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
3400    pub fn otJoinerStop(aInstance: *mut otInstance);
3401}
3402extern "C" {
3403    #[doc = " Gets the Joiner State.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The joiner state."]
3404    pub fn otJoinerGetState(aInstance: *mut otInstance) -> otJoinerState;
3405}
3406extern "C" {
3407    #[doc = " Gets the Joiner ID.\n\n If a Joiner Discerner is not set, Joiner ID is the first 64 bits of the result of computing SHA-256 over\n factory-assigned IEEE EUI-64. Otherwise the Joiner ID is calculated from the Joiner Discerner value.\n\n The Joiner ID is also used as the device's IEEE 802.15.4 Extended Address during the commissioning process.\n\n @param[in]   aInstance  A pointer to the OpenThread instance.\n\n @returns A pointer to the Joiner ID."]
3408    pub fn otJoinerGetId(aInstance: *mut otInstance) -> *const otExtAddress;
3409}
3410extern "C" {
3411    #[doc = " Sets the Joiner Discerner.\n\n The Joiner Discerner is used to calculate the Joiner ID during the Thread Commissioning process. For more\n information, refer to #otJoinerGetId.\n @note The Joiner Discerner takes the place of the Joiner EUI-64 during the joiner session of Thread Commissioning.\n\n @param[in]   aInstance    A pointer to the OpenThread instance.\n @param[in]   aDiscerner   A pointer to a Joiner Discerner. If NULL clears any previously set discerner.\n\n @retval OT_ERROR_NONE           The Joiner Discerner updated successfully.\n @retval OT_ERROR_INVALID_ARGS   @p aDiscerner is not valid (specified length is not within valid range).\n @retval OT_ERROR_INVALID_STATE  There is an ongoing Joining process so Joiner Discerner could not be changed."]
3412    pub fn otJoinerSetDiscerner(
3413        aInstance: *mut otInstance,
3414        aDiscerner: *mut otJoinerDiscerner,
3415    ) -> otError;
3416}
3417extern "C" {
3418    #[doc = " Gets the Joiner Discerner. For more information, refer to #otJoinerSetDiscerner.\n\n @param[in]   aInstance       A pointer to the OpenThread instance.\n\n @returns A pointer to Joiner Discerner or NULL if none is set."]
3419    pub fn otJoinerGetDiscerner(aInstance: *mut otInstance) -> *const otJoinerDiscerner;
3420}
3421extern "C" {
3422    #[doc = " Converts a given joiner state enumeration value to a human-readable string.\n\n @param[in] aState   The joiner state.\n\n @returns A human-readable string representation of @p aState."]
3423    pub fn otJoinerStateToString(aState: otJoinerState) -> *const ::std::os::raw::c_char;
3424}
3425#[doc = "< Commissioner role is disabled."]
3426pub const OT_COMMISSIONER_STATE_DISABLED: otCommissionerState = 0;
3427#[doc = "< Currently petitioning to become a Commissioner."]
3428pub const OT_COMMISSIONER_STATE_PETITION: otCommissionerState = 1;
3429#[doc = "< Commissioner role is active."]
3430pub const OT_COMMISSIONER_STATE_ACTIVE: otCommissionerState = 2;
3431#[doc = " Defines the Commissioner State."]
3432pub type otCommissionerState = ::std::os::raw::c_uint;
3433pub const OT_COMMISSIONER_JOINER_START: otCommissionerJoinerEvent = 0;
3434pub const OT_COMMISSIONER_JOINER_CONNECTED: otCommissionerJoinerEvent = 1;
3435pub const OT_COMMISSIONER_JOINER_FINALIZE: otCommissionerJoinerEvent = 2;
3436pub const OT_COMMISSIONER_JOINER_END: otCommissionerJoinerEvent = 3;
3437pub const OT_COMMISSIONER_JOINER_REMOVED: otCommissionerJoinerEvent = 4;
3438#[doc = " Defines a Joiner Event on the Commissioner."]
3439pub type otCommissionerJoinerEvent = ::std::os::raw::c_uint;
3440#[doc = " Represents the steering data."]
3441#[repr(C)]
3442#[derive(Debug, Default, Copy, Clone)]
3443pub struct otSteeringData {
3444    #[doc = "< Length of steering data (bytes)"]
3445    pub mLength: u8,
3446    #[doc = "< Byte values"]
3447    pub m8: [u8; 16usize],
3448}
3449#[doc = " Represents a Commissioning Dataset."]
3450#[repr(C)]
3451#[derive(Debug, Default, Copy, Clone)]
3452pub struct otCommissioningDataset {
3453    #[doc = "< Border Router RLOC16"]
3454    pub mLocator: u16,
3455    #[doc = "< Commissioner Session Id"]
3456    pub mSessionId: u16,
3457    #[doc = "< Steering Data"]
3458    pub mSteeringData: otSteeringData,
3459    #[doc = "< Joiner UDP Port"]
3460    pub mJoinerUdpPort: u16,
3461    pub _bitfield_align_1: [u8; 0],
3462    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3463    pub __bindgen_padding_0: u8,
3464}
3465impl otCommissioningDataset {
3466    #[inline]
3467    pub fn mIsLocatorSet(&self) -> bool {
3468        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
3469    }
3470    #[inline]
3471    pub fn set_mIsLocatorSet(&mut self, val: bool) {
3472        unsafe {
3473            let val: u8 = ::std::mem::transmute(val);
3474            self._bitfield_1.set(0usize, 1u8, val as u64)
3475        }
3476    }
3477    #[inline]
3478    pub fn mIsSessionIdSet(&self) -> bool {
3479        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
3480    }
3481    #[inline]
3482    pub fn set_mIsSessionIdSet(&mut self, val: bool) {
3483        unsafe {
3484            let val: u8 = ::std::mem::transmute(val);
3485            self._bitfield_1.set(1usize, 1u8, val as u64)
3486        }
3487    }
3488    #[inline]
3489    pub fn mIsSteeringDataSet(&self) -> bool {
3490        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3491    }
3492    #[inline]
3493    pub fn set_mIsSteeringDataSet(&mut self, val: bool) {
3494        unsafe {
3495            let val: u8 = ::std::mem::transmute(val);
3496            self._bitfield_1.set(2usize, 1u8, val as u64)
3497        }
3498    }
3499    #[inline]
3500    pub fn mIsJoinerUdpPortSet(&self) -> bool {
3501        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3502    }
3503    #[inline]
3504    pub fn set_mIsJoinerUdpPortSet(&mut self, val: bool) {
3505        unsafe {
3506            let val: u8 = ::std::mem::transmute(val);
3507            self._bitfield_1.set(3usize, 1u8, val as u64)
3508        }
3509    }
3510    #[inline]
3511    pub fn mHasExtraTlv(&self) -> bool {
3512        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3513    }
3514    #[inline]
3515    pub fn set_mHasExtraTlv(&mut self, val: bool) {
3516        unsafe {
3517            let val: u8 = ::std::mem::transmute(val);
3518            self._bitfield_1.set(4usize, 1u8, val as u64)
3519        }
3520    }
3521    #[inline]
3522    pub fn new_bitfield_1(
3523        mIsLocatorSet: bool,
3524        mIsSessionIdSet: bool,
3525        mIsSteeringDataSet: bool,
3526        mIsJoinerUdpPortSet: bool,
3527        mHasExtraTlv: bool,
3528    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3529        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3530        __bindgen_bitfield_unit.set(0usize, 1u8, {
3531            let mIsLocatorSet: u8 = unsafe { ::std::mem::transmute(mIsLocatorSet) };
3532            mIsLocatorSet as u64
3533        });
3534        __bindgen_bitfield_unit.set(1usize, 1u8, {
3535            let mIsSessionIdSet: u8 = unsafe { ::std::mem::transmute(mIsSessionIdSet) };
3536            mIsSessionIdSet as u64
3537        });
3538        __bindgen_bitfield_unit.set(2usize, 1u8, {
3539            let mIsSteeringDataSet: u8 = unsafe { ::std::mem::transmute(mIsSteeringDataSet) };
3540            mIsSteeringDataSet as u64
3541        });
3542        __bindgen_bitfield_unit.set(3usize, 1u8, {
3543            let mIsJoinerUdpPortSet: u8 = unsafe { ::std::mem::transmute(mIsJoinerUdpPortSet) };
3544            mIsJoinerUdpPortSet as u64
3545        });
3546        __bindgen_bitfield_unit.set(4usize, 1u8, {
3547            let mHasExtraTlv: u8 = unsafe { ::std::mem::transmute(mHasExtraTlv) };
3548            mHasExtraTlv as u64
3549        });
3550        __bindgen_bitfield_unit
3551    }
3552}
3553#[doc = " Represents a Joiner PSKd."]
3554#[repr(C)]
3555#[derive(Debug, Copy, Clone)]
3556pub struct otJoinerPskd {
3557    #[doc = "< Char string array (must be null terminated - +1 is for null char)."]
3558    pub m8: [::std::os::raw::c_char; 33usize],
3559}
3560impl Default for otJoinerPskd {
3561    fn default() -> Self {
3562        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3563        unsafe {
3564            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3565            s.assume_init()
3566        }
3567    }
3568}
3569#[doc = "< Accept any Joiner (no EUI64 or Discerner is specified)."]
3570pub const OT_JOINER_INFO_TYPE_ANY: otJoinerInfoType = 0;
3571#[doc = "< Joiner EUI-64 is specified (`mSharedId.mEui64` in `otJoinerInfo`)."]
3572pub const OT_JOINER_INFO_TYPE_EUI64: otJoinerInfoType = 1;
3573#[doc = "< Joiner Discerner is specified (`mSharedId.mDiscerner` in `otJoinerInfo`)."]
3574pub const OT_JOINER_INFO_TYPE_DISCERNER: otJoinerInfoType = 2;
3575#[doc = " Defines a Joiner Info Type."]
3576pub type otJoinerInfoType = ::std::os::raw::c_uint;
3577#[doc = " Represents a Joiner Info."]
3578#[repr(C)]
3579#[derive(Copy, Clone)]
3580pub struct otJoinerInfo {
3581    #[doc = "< Joiner type."]
3582    pub mType: otJoinerInfoType,
3583    #[doc = "< Shared fields"]
3584    pub mSharedId: otJoinerInfo__bindgen_ty_1,
3585    #[doc = "< Joiner PSKd"]
3586    pub mPskd: otJoinerPskd,
3587    #[doc = "< Joiner expiration time in msec"]
3588    pub mExpirationTime: u32,
3589}
3590#[repr(C)]
3591#[derive(Copy, Clone)]
3592pub union otJoinerInfo__bindgen_ty_1 {
3593    #[doc = "< Joiner EUI64 (when `mType` is `OT_JOINER_INFO_TYPE_EUI64`)"]
3594    pub mEui64: otExtAddress,
3595    #[doc = "< Joiner Discerner (when `mType` is `OT_JOINER_INFO_TYPE_DISCERNER`)"]
3596    pub mDiscerner: otJoinerDiscerner,
3597}
3598impl Default for otJoinerInfo__bindgen_ty_1 {
3599    fn default() -> Self {
3600        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3601        unsafe {
3602            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3603            s.assume_init()
3604        }
3605    }
3606}
3607impl Default for otJoinerInfo {
3608    fn default() -> Self {
3609        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3610        unsafe {
3611            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3612            s.assume_init()
3613        }
3614    }
3615}
3616#[doc = " Pointer is called whenever the commissioner state changes.\n\n @param[in]  aState    The Commissioner state.\n @param[in]  aContext  A pointer to application-specific context."]
3617pub type otCommissionerStateCallback = ::std::option::Option<
3618    unsafe extern "C" fn(aState: otCommissionerState, aContext: *mut ::std::os::raw::c_void),
3619>;
3620#[doc = " Pointer is called whenever the joiner state changes.\n\n @param[in]  aEvent       The joiner event type.\n @param[in]  aJoinerInfo  A pointer to the Joiner Info.\n @param[in]  aJoinerId    A pointer to the Joiner ID (if not known, it will be NULL).\n @param[in]  aContext     A pointer to application-specific context."]
3621pub type otCommissionerJoinerCallback = ::std::option::Option<
3622    unsafe extern "C" fn(
3623        aEvent: otCommissionerJoinerEvent,
3624        aJoinerInfo: *const otJoinerInfo,
3625        aJoinerId: *const otExtAddress,
3626        aContext: *mut ::std::os::raw::c_void,
3627    ),
3628>;
3629extern "C" {
3630    #[doc = " Enables the Thread Commissioner role.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aStateCallback    A pointer to a function that is called when the commissioner state changes.\n @param[in]  aJoinerCallback   A pointer to a function that is called with a joiner event occurs.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @retval OT_ERROR_NONE           Successfully started the Commissioner service.\n @retval OT_ERROR_ALREADY        Commissioner is already started.\n @retval OT_ERROR_INVALID_STATE  Device is not currently attached to a network."]
3631    pub fn otCommissionerStart(
3632        aInstance: *mut otInstance,
3633        aStateCallback: otCommissionerStateCallback,
3634        aJoinerCallback: otCommissionerJoinerCallback,
3635        aCallbackContext: *mut ::std::os::raw::c_void,
3636    ) -> otError;
3637}
3638extern "C" {
3639    #[doc = " Disables the Thread Commissioner role.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE     Successfully stopped the Commissioner service.\n @retval OT_ERROR_ALREADY  Commissioner is already stopped."]
3640    pub fn otCommissionerStop(aInstance: *mut otInstance) -> otError;
3641}
3642extern "C" {
3643    #[doc = " Returns the Commissioner Id.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n\n @returns The Commissioner Id."]
3644    pub fn otCommissionerGetId(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
3645}
3646extern "C" {
3647    #[doc = " Sets the Commissioner Id.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aId           A pointer to a string character array. Must be null terminated.\n\n @retval OT_ERROR_NONE            Successfully set the Commissioner Id.\n @retval OT_ERROR_INVALID_ARGS    Given name is too long.\n @retval OT_ERROR_INVALID_STATE   The commissioner is active and id cannot be changed."]
3648    pub fn otCommissionerSetId(
3649        aInstance: *mut otInstance,
3650        aId: *const ::std::os::raw::c_char,
3651    ) -> otError;
3652}
3653extern "C" {
3654    #[doc = " Adds a Joiner entry.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aEui64             A pointer to the Joiner's IEEE EUI-64 or NULL for any Joiner.\n @param[in]  aPskd              A pointer to the PSKd.\n @param[in]  aTimeout           A time after which a Joiner is automatically removed, in seconds.\n\n @retval OT_ERROR_NONE          Successfully added the Joiner.\n @retval OT_ERROR_NO_BUFS       No buffers available to add the Joiner.\n @retval OT_ERROR_INVALID_ARGS  @p aEui64 or @p aPskd is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3655    pub fn otCommissionerAddJoiner(
3656        aInstance: *mut otInstance,
3657        aEui64: *const otExtAddress,
3658        aPskd: *const ::std::os::raw::c_char,
3659        aTimeout: u32,
3660    ) -> otError;
3661}
3662extern "C" {
3663    #[doc = " Adds a Joiner entry with a given Joiner Discerner value.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aDiscerner         A pointer to the Joiner Discerner.\n @param[in]  aPskd              A pointer to the PSKd.\n @param[in]  aTimeout           A time after which a Joiner is automatically removed, in seconds.\n\n @retval OT_ERROR_NONE          Successfully added the Joiner.\n @retval OT_ERROR_NO_BUFS       No buffers available to add the Joiner.\n @retval OT_ERROR_INVALID_ARGS  @p aDiscerner or @p aPskd is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3664    pub fn otCommissionerAddJoinerWithDiscerner(
3665        aInstance: *mut otInstance,
3666        aDiscerner: *const otJoinerDiscerner,
3667        aPskd: *const ::std::os::raw::c_char,
3668        aTimeout: u32,
3669    ) -> otError;
3670}
3671extern "C" {
3672    #[doc = " Get joiner info at aIterator position.\n\n @param[in]      aInstance   A pointer to instance.\n @param[in,out]  aIterator   A pointer to the Joiner Info iterator context.\n @param[out]     aJoiner     A reference to Joiner info.\n\n @retval OT_ERROR_NONE       Successfully get the Joiner info.\n @retval OT_ERROR_NOT_FOUND  Not found next Joiner."]
3673    pub fn otCommissionerGetNextJoinerInfo(
3674        aInstance: *mut otInstance,
3675        aIterator: *mut u16,
3676        aJoiner: *mut otJoinerInfo,
3677    ) -> otError;
3678}
3679extern "C" {
3680    #[doc = " Removes a Joiner entry.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aEui64             A pointer to the Joiner's IEEE EUI-64 or NULL for any Joiner.\n\n @retval OT_ERROR_NONE          Successfully removed the Joiner.\n @retval OT_ERROR_NOT_FOUND     The Joiner specified by @p aEui64 was not found.\n @retval OT_ERROR_INVALID_ARGS  @p aEui64 is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3681    pub fn otCommissionerRemoveJoiner(
3682        aInstance: *mut otInstance,
3683        aEui64: *const otExtAddress,
3684    ) -> otError;
3685}
3686extern "C" {
3687    #[doc = " Removes a Joiner entry.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aDiscerner         A pointer to the Joiner Discerner.\n\n @retval OT_ERROR_NONE          Successfully removed the Joiner.\n @retval OT_ERROR_NOT_FOUND     The Joiner specified by @p aEui64 was not found.\n @retval OT_ERROR_INVALID_ARGS  @p aDiscerner is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3688    pub fn otCommissionerRemoveJoinerWithDiscerner(
3689        aInstance: *mut otInstance,
3690        aDiscerner: *const otJoinerDiscerner,
3691    ) -> otError;
3692}
3693extern "C" {
3694    #[doc = " Gets the Provisioning URL.\n\n @param[in]    aInstance       A pointer to an OpenThread instance.\n\n @returns A pointer to the URL string."]
3695    pub fn otCommissionerGetProvisioningUrl(
3696        aInstance: *mut otInstance,
3697    ) -> *const ::std::os::raw::c_char;
3698}
3699extern "C" {
3700    #[doc = " Sets the Provisioning URL.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n @param[in]  aProvisioningUrl      A pointer to the Provisioning URL (may be NULL to set as empty string).\n\n @retval OT_ERROR_NONE          Successfully set the Provisioning URL.\n @retval OT_ERROR_INVALID_ARGS  @p aProvisioningUrl is invalid (too long)."]
3701    pub fn otCommissionerSetProvisioningUrl(
3702        aInstance: *mut otInstance,
3703        aProvisioningUrl: *const ::std::os::raw::c_char,
3704    ) -> otError;
3705}
3706extern "C" {
3707    #[doc = " Sends an Announce Begin message.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n @param[in]  aChannelMask          The channel mask value.\n @param[in]  aCount                The number of Announcement messages per channel.\n @param[in]  aPeriod               The time between two successive MLE Announce transmissions (in milliseconds).\n @param[in]  aAddress              A pointer to the IPv6 destination.\n\n @retval OT_ERROR_NONE          Successfully enqueued the Announce Begin message.\n @retval OT_ERROR_NO_BUFS       Insufficient buffers to generate an Announce Begin message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3708    pub fn otCommissionerAnnounceBegin(
3709        aInstance: *mut otInstance,
3710        aChannelMask: u32,
3711        aCount: u8,
3712        aPeriod: u16,
3713        aAddress: *const otIp6Address,
3714    ) -> otError;
3715}
3716#[doc = " Pointer is called when the Commissioner receives an Energy Report.\n\n @param[in]  aChannelMask       The channel mask value.\n @param[in]  aEnergyList        A pointer to the energy measurement list.\n @param[in]  aEnergyListLength  Number of entries in @p aEnergyListLength.\n @param[in]  aContext           A pointer to application-specific context."]
3717pub type otCommissionerEnergyReportCallback = ::std::option::Option<
3718    unsafe extern "C" fn(
3719        aChannelMask: u32,
3720        aEnergyList: *const u8,
3721        aEnergyListLength: u8,
3722        aContext: *mut ::std::os::raw::c_void,
3723    ),
3724>;
3725extern "C" {
3726    #[doc = " Sends an Energy Scan Query message.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n @param[in]  aChannelMask          The channel mask value.\n @param[in]  aCount                The number of energy measurements per channel.\n @param[in]  aPeriod               The time between energy measurements (milliseconds).\n @param[in]  aScanDuration         The scan duration for each energy measurement (milliseconds).\n @param[in]  aAddress              A pointer to the IPv6 destination.\n @param[in]  aCallback             A pointer to a function called on receiving an Energy Report message.\n @param[in]  aContext              A pointer to application-specific context.\n\n @retval OT_ERROR_NONE          Successfully enqueued the Energy Scan Query message.\n @retval OT_ERROR_NO_BUFS       Insufficient buffers to generate an Energy Scan Query message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3727    pub fn otCommissionerEnergyScan(
3728        aInstance: *mut otInstance,
3729        aChannelMask: u32,
3730        aCount: u8,
3731        aPeriod: u16,
3732        aScanDuration: u16,
3733        aAddress: *const otIp6Address,
3734        aCallback: otCommissionerEnergyReportCallback,
3735        aContext: *mut ::std::os::raw::c_void,
3736    ) -> otError;
3737}
3738#[doc = " Pointer is called when the Commissioner receives a PAN ID Conflict message.\n\n @param[in]  aPanId             The PAN ID value.\n @param[in]  aChannelMask       The channel mask value.\n @param[in]  aContext           A pointer to application-specific context."]
3739pub type otCommissionerPanIdConflictCallback = ::std::option::Option<
3740    unsafe extern "C" fn(aPanId: u16, aChannelMask: u32, aContext: *mut ::std::os::raw::c_void),
3741>;
3742extern "C" {
3743    #[doc = " Sends a PAN ID Query message.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n @param[in]  aPanId                The PAN ID to query.\n @param[in]  aChannelMask          The channel mask value.\n @param[in]  aAddress              A pointer to the IPv6 destination.\n @param[in]  aCallback             A pointer to a function called on receiving a PAN ID Conflict message.\n @param[in]  aContext              A pointer to application-specific context.\n\n @retval OT_ERROR_NONE          Successfully enqueued the PAN ID Query message.\n @retval OT_ERROR_NO_BUFS       Insufficient buffers to generate a PAN ID Query message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart()."]
3744    pub fn otCommissionerPanIdQuery(
3745        aInstance: *mut otInstance,
3746        aPanId: u16,
3747        aChannelMask: u32,
3748        aAddress: *const otIp6Address,
3749        aCallback: otCommissionerPanIdConflictCallback,
3750        aContext: *mut ::std::os::raw::c_void,
3751    ) -> otError;
3752}
3753extern "C" {
3754    #[doc = " Sends MGMT_COMMISSIONER_GET.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aTlvs      A pointer to TLVs.\n @param[in]  aLength    The length of TLVs.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active."]
3755    pub fn otCommissionerSendMgmtGet(
3756        aInstance: *mut otInstance,
3757        aTlvs: *const u8,
3758        aLength: u8,
3759    ) -> otError;
3760}
3761extern "C" {
3762    #[doc = " Sends MGMT_COMMISSIONER_SET.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aDataset   A pointer to commissioning dataset.\n @param[in]  aTlvs      A pointer to TLVs.\n @param[in]  aLength    The length of TLVs.\n\n @retval OT_ERROR_NONE          Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer space to send.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active."]
3763    pub fn otCommissionerSendMgmtSet(
3764        aInstance: *mut otInstance,
3765        aDataset: *const otCommissioningDataset,
3766        aTlvs: *const u8,
3767        aLength: u8,
3768    ) -> otError;
3769}
3770extern "C" {
3771    #[doc = " Returns the Commissioner Session ID.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The current commissioner session id."]
3772    pub fn otCommissionerGetSessionId(aInstance: *mut otInstance) -> u16;
3773}
3774extern "C" {
3775    #[doc = " Returns the Commissioner State.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval OT_COMMISSIONER_STATE_DISABLED  Commissioner disabled.\n @retval OT_COMMISSIONER_STATE_PETITION  Becoming the commissioner.\n @retval OT_COMMISSIONER_STATE_ACTIVE    Commissioner enabled."]
3776    pub fn otCommissionerGetState(aInstance: *mut otInstance) -> otCommissionerState;
3777}
3778pub type otNetworkDataIterator = u32;
3779#[doc = " Represents a Border Router configuration."]
3780#[repr(C)]
3781#[repr(align(4))]
3782#[derive(Copy, Clone)]
3783pub struct otBorderRouterConfig {
3784    #[doc = "< The IPv6 prefix."]
3785    pub mPrefix: otIp6Prefix,
3786    pub _bitfield_align_1: [u8; 0],
3787    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3788    #[doc = "< The border router's RLOC16 (value ignored on config add)."]
3789    pub mRloc16: u16,
3790}
3791impl Default for otBorderRouterConfig {
3792    fn default() -> Self {
3793        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3794        unsafe {
3795            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3796            s.assume_init()
3797        }
3798    }
3799}
3800impl otBorderRouterConfig {
3801    #[inline]
3802    pub fn mPreference(&self) -> ::std::os::raw::c_int {
3803        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
3804    }
3805    #[inline]
3806    pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
3807        unsafe {
3808            let val: u32 = ::std::mem::transmute(val);
3809            self._bitfield_1.set(0usize, 2u8, val as u64)
3810        }
3811    }
3812    #[inline]
3813    pub fn mPreferred(&self) -> bool {
3814        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3815    }
3816    #[inline]
3817    pub fn set_mPreferred(&mut self, val: bool) {
3818        unsafe {
3819            let val: u8 = ::std::mem::transmute(val);
3820            self._bitfield_1.set(2usize, 1u8, val as u64)
3821        }
3822    }
3823    #[inline]
3824    pub fn mSlaac(&self) -> bool {
3825        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3826    }
3827    #[inline]
3828    pub fn set_mSlaac(&mut self, val: bool) {
3829        unsafe {
3830            let val: u8 = ::std::mem::transmute(val);
3831            self._bitfield_1.set(3usize, 1u8, val as u64)
3832        }
3833    }
3834    #[inline]
3835    pub fn mDhcp(&self) -> bool {
3836        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3837    }
3838    #[inline]
3839    pub fn set_mDhcp(&mut self, val: bool) {
3840        unsafe {
3841            let val: u8 = ::std::mem::transmute(val);
3842            self._bitfield_1.set(4usize, 1u8, val as u64)
3843        }
3844    }
3845    #[inline]
3846    pub fn mConfigure(&self) -> bool {
3847        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
3848    }
3849    #[inline]
3850    pub fn set_mConfigure(&mut self, val: bool) {
3851        unsafe {
3852            let val: u8 = ::std::mem::transmute(val);
3853            self._bitfield_1.set(5usize, 1u8, val as u64)
3854        }
3855    }
3856    #[inline]
3857    pub fn mDefaultRoute(&self) -> bool {
3858        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
3859    }
3860    #[inline]
3861    pub fn set_mDefaultRoute(&mut self, val: bool) {
3862        unsafe {
3863            let val: u8 = ::std::mem::transmute(val);
3864            self._bitfield_1.set(6usize, 1u8, val as u64)
3865        }
3866    }
3867    #[inline]
3868    pub fn mOnMesh(&self) -> bool {
3869        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
3870    }
3871    #[inline]
3872    pub fn set_mOnMesh(&mut self, val: bool) {
3873        unsafe {
3874            let val: u8 = ::std::mem::transmute(val);
3875            self._bitfield_1.set(7usize, 1u8, val as u64)
3876        }
3877    }
3878    #[inline]
3879    pub fn mStable(&self) -> bool {
3880        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
3881    }
3882    #[inline]
3883    pub fn set_mStable(&mut self, val: bool) {
3884        unsafe {
3885            let val: u8 = ::std::mem::transmute(val);
3886            self._bitfield_1.set(8usize, 1u8, val as u64)
3887        }
3888    }
3889    #[inline]
3890    pub fn mNdDns(&self) -> bool {
3891        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
3892    }
3893    #[inline]
3894    pub fn set_mNdDns(&mut self, val: bool) {
3895        unsafe {
3896            let val: u8 = ::std::mem::transmute(val);
3897            self._bitfield_1.set(9usize, 1u8, val as u64)
3898        }
3899    }
3900    #[inline]
3901    pub fn mDp(&self) -> bool {
3902        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) }
3903    }
3904    #[inline]
3905    pub fn set_mDp(&mut self, val: bool) {
3906        unsafe {
3907            let val: u8 = ::std::mem::transmute(val);
3908            self._bitfield_1.set(10usize, 1u8, val as u64)
3909        }
3910    }
3911    #[inline]
3912    pub fn new_bitfield_1(
3913        mPreference: ::std::os::raw::c_int,
3914        mPreferred: bool,
3915        mSlaac: bool,
3916        mDhcp: bool,
3917        mConfigure: bool,
3918        mDefaultRoute: bool,
3919        mOnMesh: bool,
3920        mStable: bool,
3921        mNdDns: bool,
3922        mDp: bool,
3923    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3924        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3925        __bindgen_bitfield_unit.set(0usize, 2u8, {
3926            let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
3927            mPreference as u64
3928        });
3929        __bindgen_bitfield_unit.set(2usize, 1u8, {
3930            let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
3931            mPreferred as u64
3932        });
3933        __bindgen_bitfield_unit.set(3usize, 1u8, {
3934            let mSlaac: u8 = unsafe { ::std::mem::transmute(mSlaac) };
3935            mSlaac as u64
3936        });
3937        __bindgen_bitfield_unit.set(4usize, 1u8, {
3938            let mDhcp: u8 = unsafe { ::std::mem::transmute(mDhcp) };
3939            mDhcp as u64
3940        });
3941        __bindgen_bitfield_unit.set(5usize, 1u8, {
3942            let mConfigure: u8 = unsafe { ::std::mem::transmute(mConfigure) };
3943            mConfigure as u64
3944        });
3945        __bindgen_bitfield_unit.set(6usize, 1u8, {
3946            let mDefaultRoute: u8 = unsafe { ::std::mem::transmute(mDefaultRoute) };
3947            mDefaultRoute as u64
3948        });
3949        __bindgen_bitfield_unit.set(7usize, 1u8, {
3950            let mOnMesh: u8 = unsafe { ::std::mem::transmute(mOnMesh) };
3951            mOnMesh as u64
3952        });
3953        __bindgen_bitfield_unit.set(8usize, 1u8, {
3954            let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
3955            mStable as u64
3956        });
3957        __bindgen_bitfield_unit.set(9usize, 1u8, {
3958            let mNdDns: u8 = unsafe { ::std::mem::transmute(mNdDns) };
3959            mNdDns as u64
3960        });
3961        __bindgen_bitfield_unit.set(10usize, 1u8, {
3962            let mDp: u8 = unsafe { ::std::mem::transmute(mDp) };
3963            mDp as u64
3964        });
3965        __bindgen_bitfield_unit
3966    }
3967}
3968#[doc = " Represents 6LoWPAN Context ID information associated with a prefix in Network Data."]
3969#[repr(C)]
3970#[derive(Copy, Clone)]
3971pub struct otLowpanContextInfo {
3972    #[doc = "< The 6LoWPAN Context ID."]
3973    pub mContextId: u8,
3974    #[doc = "< The compress flag."]
3975    pub mCompressFlag: bool,
3976    #[doc = "< The associated IPv6 prefix."]
3977    pub mPrefix: otIp6Prefix,
3978}
3979impl Default for otLowpanContextInfo {
3980    fn default() -> Self {
3981        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3982        unsafe {
3983            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3984            s.assume_init()
3985        }
3986    }
3987}
3988#[doc = " Represents an External Route configuration."]
3989#[repr(C)]
3990#[repr(align(4))]
3991#[derive(Copy, Clone)]
3992pub struct otExternalRouteConfig {
3993    #[doc = "< The IPv6 prefix."]
3994    pub mPrefix: otIp6Prefix,
3995    #[doc = "< The border router's RLOC16 (value ignored on config add)."]
3996    pub mRloc16: u16,
3997    pub _bitfield_align_1: [u8; 0],
3998    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3999    pub __bindgen_padding_0: [u8; 3usize],
4000}
4001impl Default for otExternalRouteConfig {
4002    fn default() -> Self {
4003        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4004        unsafe {
4005            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4006            s.assume_init()
4007        }
4008    }
4009}
4010impl otExternalRouteConfig {
4011    #[inline]
4012    pub fn mPreference(&self) -> ::std::os::raw::c_int {
4013        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4014    }
4015    #[inline]
4016    pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
4017        unsafe {
4018            let val: u32 = ::std::mem::transmute(val);
4019            self._bitfield_1.set(0usize, 2u8, val as u64)
4020        }
4021    }
4022    #[inline]
4023    pub fn mNat64(&self) -> bool {
4024        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4025    }
4026    #[inline]
4027    pub fn set_mNat64(&mut self, val: bool) {
4028        unsafe {
4029            let val: u8 = ::std::mem::transmute(val);
4030            self._bitfield_1.set(2usize, 1u8, val as u64)
4031        }
4032    }
4033    #[inline]
4034    pub fn mStable(&self) -> bool {
4035        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4036    }
4037    #[inline]
4038    pub fn set_mStable(&mut self, val: bool) {
4039        unsafe {
4040            let val: u8 = ::std::mem::transmute(val);
4041            self._bitfield_1.set(3usize, 1u8, val as u64)
4042        }
4043    }
4044    #[inline]
4045    pub fn mNextHopIsThisDevice(&self) -> bool {
4046        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4047    }
4048    #[inline]
4049    pub fn set_mNextHopIsThisDevice(&mut self, val: bool) {
4050        unsafe {
4051            let val: u8 = ::std::mem::transmute(val);
4052            self._bitfield_1.set(4usize, 1u8, val as u64)
4053        }
4054    }
4055    #[inline]
4056    pub fn mAdvPio(&self) -> bool {
4057        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4058    }
4059    #[inline]
4060    pub fn set_mAdvPio(&mut self, val: bool) {
4061        unsafe {
4062            let val: u8 = ::std::mem::transmute(val);
4063            self._bitfield_1.set(5usize, 1u8, val as u64)
4064        }
4065    }
4066    #[inline]
4067    pub fn new_bitfield_1(
4068        mPreference: ::std::os::raw::c_int,
4069        mNat64: bool,
4070        mStable: bool,
4071        mNextHopIsThisDevice: bool,
4072        mAdvPio: bool,
4073    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4074        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4075        __bindgen_bitfield_unit.set(0usize, 2u8, {
4076            let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
4077            mPreference as u64
4078        });
4079        __bindgen_bitfield_unit.set(2usize, 1u8, {
4080            let mNat64: u8 = unsafe { ::std::mem::transmute(mNat64) };
4081            mNat64 as u64
4082        });
4083        __bindgen_bitfield_unit.set(3usize, 1u8, {
4084            let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4085            mStable as u64
4086        });
4087        __bindgen_bitfield_unit.set(4usize, 1u8, {
4088            let mNextHopIsThisDevice: u8 = unsafe { ::std::mem::transmute(mNextHopIsThisDevice) };
4089            mNextHopIsThisDevice as u64
4090        });
4091        __bindgen_bitfield_unit.set(5usize, 1u8, {
4092            let mAdvPio: u8 = unsafe { ::std::mem::transmute(mAdvPio) };
4093            mAdvPio as u64
4094        });
4095        __bindgen_bitfield_unit
4096    }
4097}
4098#[doc = "< Low route preference."]
4099pub const OT_ROUTE_PREFERENCE_LOW: otRoutePreference = -1;
4100#[doc = "< Medium route preference."]
4101pub const OT_ROUTE_PREFERENCE_MED: otRoutePreference = 0;
4102#[doc = "< High route preference."]
4103pub const OT_ROUTE_PREFERENCE_HIGH: otRoutePreference = 1;
4104#[doc = " Defines valid values for `mPreference` in `otExternalRouteConfig` and `otBorderRouterConfig`."]
4105pub type otRoutePreference = ::std::os::raw::c_int;
4106#[doc = " Represents a Server configuration."]
4107#[repr(C)]
4108#[derive(Debug, Copy, Clone)]
4109pub struct otServerConfig {
4110    pub _bitfield_align_1: [u8; 0],
4111    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4112    #[doc = "< Length of server data."]
4113    pub mServerDataLength: u8,
4114    #[doc = "< Server data bytes."]
4115    pub mServerData: [u8; 248usize],
4116    #[doc = "< The Server RLOC16."]
4117    pub mRloc16: u16,
4118}
4119impl Default for otServerConfig {
4120    fn default() -> Self {
4121        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4122        unsafe {
4123            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4124            s.assume_init()
4125        }
4126    }
4127}
4128impl otServerConfig {
4129    #[inline]
4130    pub fn mStable(&self) -> bool {
4131        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4132    }
4133    #[inline]
4134    pub fn set_mStable(&mut self, val: bool) {
4135        unsafe {
4136            let val: u8 = ::std::mem::transmute(val);
4137            self._bitfield_1.set(0usize, 1u8, val as u64)
4138        }
4139    }
4140    #[inline]
4141    pub fn new_bitfield_1(mStable: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4142        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4143        __bindgen_bitfield_unit.set(0usize, 1u8, {
4144            let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4145            mStable as u64
4146        });
4147        __bindgen_bitfield_unit
4148    }
4149}
4150#[doc = " Represents a Service configuration."]
4151#[repr(C)]
4152#[derive(Debug, Copy, Clone)]
4153pub struct otServiceConfig {
4154    #[doc = "< Service ID (when iterating over the  Network Data)."]
4155    pub mServiceId: u8,
4156    #[doc = "< IANA Enterprise Number."]
4157    pub mEnterpriseNumber: u32,
4158    #[doc = "< Length of service data."]
4159    pub mServiceDataLength: u8,
4160    #[doc = "< Service data bytes."]
4161    pub mServiceData: [u8; 252usize],
4162    #[doc = "< The Server configuration."]
4163    pub mServerConfig: otServerConfig,
4164}
4165impl Default for otServiceConfig {
4166    fn default() -> Self {
4167        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4168        unsafe {
4169            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4170            s.assume_init()
4171        }
4172    }
4173}
4174extern "C" {
4175    #[doc = " Provide full or stable copy of the Partition's Thread Network Data.\n\n @param[in]      aInstance    A pointer to an OpenThread instance.\n @param[in]      aStable      TRUE when copying the stable version, FALSE when copying the full version.\n @param[out]     aData        A pointer to the data buffer.\n @param[in,out]  aDataLength  On entry, size of the data buffer pointed to by @p aData.\n                              On exit, number of copied bytes.\n\n @retval OT_ERROR_NONE    Successfully copied the Thread Network Data into @p aData and updated @p aDataLength.\n @retval OT_ERROR_NO_BUFS Not enough space in @p aData to fully copy the Thread Network Data."]
4176    pub fn otNetDataGet(
4177        aInstance: *mut otInstance,
4178        aStable: bool,
4179        aData: *mut u8,
4180        aDataLength: *mut u8,
4181    ) -> otError;
4182}
4183extern "C" {
4184    #[doc = " Get the current length (number of bytes) of Partition's Thread Network Data.\n\n @param[in] aInstance    A pointer to an OpenThread instance.\n\n @return The length of the Network Data."]
4185    pub fn otNetDataGetLength(aInstance: *mut otInstance) -> u8;
4186}
4187extern "C" {
4188    #[doc = " Get the maximum observed length of the Thread Network Data since OT stack initialization or since the last call to\n `otNetDataResetMaxLength()`.\n\n @param[in] aInstance    A pointer to an OpenThread instance.\n\n @return The maximum length of the Network Data (high water mark for Network Data length)."]
4189    pub fn otNetDataGetMaxLength(aInstance: *mut otInstance) -> u8;
4190}
4191extern "C" {
4192    #[doc = " Reset the tracked maximum length of the Thread Network Data.\n\n @param[in] aInstance    A pointer to an OpenThread instance.\n\n @sa otNetDataGetMaxLength"]
4193    pub fn otNetDataResetMaxLength(aInstance: *mut otInstance);
4194}
4195extern "C" {
4196    #[doc = " Get the next On Mesh Prefix in the partition's Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first on-mesh entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to where the On Mesh Prefix information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next On Mesh prefix.\n @retval OT_ERROR_NOT_FOUND  No subsequent On Mesh prefix exists in the Thread Network Data."]
4197    pub fn otNetDataGetNextOnMeshPrefix(
4198        aInstance: *mut otInstance,
4199        aIterator: *mut otNetworkDataIterator,
4200        aConfig: *mut otBorderRouterConfig,
4201    ) -> otError;
4202}
4203extern "C" {
4204    #[doc = " Get the next external route in the partition's Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first external route entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to where the External Route information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next External Route.\n @retval OT_ERROR_NOT_FOUND  No subsequent external route entry exists in the Thread Network Data."]
4205    pub fn otNetDataGetNextRoute(
4206        aInstance: *mut otInstance,
4207        aIterator: *mut otNetworkDataIterator,
4208        aConfig: *mut otExternalRouteConfig,
4209    ) -> otError;
4210}
4211extern "C" {
4212    #[doc = " Get the next service in the partition's Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first service entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to where the service information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next service.\n @retval OT_ERROR_NOT_FOUND  No subsequent service exists in the partition's Network Data."]
4213    pub fn otNetDataGetNextService(
4214        aInstance: *mut otInstance,
4215        aIterator: *mut otNetworkDataIterator,
4216        aConfig: *mut otServiceConfig,
4217    ) -> otError;
4218}
4219extern "C" {
4220    #[doc = " Get the next 6LoWPAN Context ID info in the partition's Network Data.\n\n @param[in]      aInstance     A pointer to an OpenThread instance.\n @param[in,out]  aIterator     A pointer to the Network Data iterator. To get the first service entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aContextInfo  A pointer to where the retrieved 6LoWPAN Context ID information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next 6LoWPAN Context ID info.\n @retval OT_ERROR_NOT_FOUND  No subsequent 6LoWPAN Context info exists in the partition's Network Data."]
4221    pub fn otNetDataGetNextLowpanContextInfo(
4222        aInstance: *mut otInstance,
4223        aIterator: *mut otNetworkDataIterator,
4224        aContextInfo: *mut otLowpanContextInfo,
4225    ) -> otError;
4226}
4227extern "C" {
4228    #[doc = " Gets the Commissioning Dataset from the partition's Network Data.\n\n @param[in]  aInstance   A pointer to the OpenThread instance.\n @param[out] aDataset    A pointer to a `otCommissioningDataset` to populate."]
4229    pub fn otNetDataGetCommissioningDataset(
4230        aInstance: *mut otInstance,
4231        aDataset: *mut otCommissioningDataset,
4232    );
4233}
4234extern "C" {
4235    #[doc = " Get the Network Data Version.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Network Data Version."]
4236    pub fn otNetDataGetVersion(aInstance: *mut otInstance) -> u8;
4237}
4238extern "C" {
4239    #[doc = " Get the Stable Network Data Version.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Stable Network Data Version."]
4240    pub fn otNetDataGetStableVersion(aInstance: *mut otInstance) -> u8;
4241}
4242extern "C" {
4243    #[doc = " Check if the steering data includes a Joiner.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aEui64             A pointer to the Joiner's IEEE EUI-64.\n\n @retval OT_ERROR_NONE          @p aEui64 is included in the steering data.\n @retval OT_ERROR_INVALID_STATE No steering data present.\n @retval OT_ERROR_NOT_FOUND     @p aEui64 is not included in the steering data."]
4244    pub fn otNetDataSteeringDataCheckJoiner(
4245        aInstance: *mut otInstance,
4246        aEui64: *const otExtAddress,
4247    ) -> otError;
4248}
4249extern "C" {
4250    #[doc = " Check if the steering data includes a Joiner with a given discerner value.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aDiscerner         A pointer to the Joiner Discerner.\n\n @retval OT_ERROR_NONE          @p aDiscerner is included in the steering data.\n @retval OT_ERROR_INVALID_STATE No steering data present.\n @retval OT_ERROR_NOT_FOUND     @p aDiscerner is not included in the steering data."]
4251    pub fn otNetDataSteeringDataCheckJoinerWithDiscerner(
4252        aInstance: *mut otInstance,
4253        aDiscerner: *const otJoinerDiscerner,
4254    ) -> otError;
4255}
4256extern "C" {
4257    #[doc = " Check whether a given Prefix can act as a valid OMR prefix and also the Leader's Network Data contains this prefix.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aPrefix    A pointer to the IPv6 prefix.\n\n @returns  Whether @p aPrefix is a valid OMR prefix and Leader's Network Data contains the OMR prefix @p aPrefix.\n\n @note This API is only available when `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` is used."]
4258    pub fn otNetDataContainsOmrPrefix(
4259        aInstance: *mut otInstance,
4260        aPrefix: *const otIp6Prefix,
4261    ) -> bool;
4262}
4263#[doc = "< Backbone function is disabled."]
4264pub const OT_BACKBONE_ROUTER_STATE_DISABLED: otBackboneRouterState = 0;
4265#[doc = "< Secondary Backbone Router."]
4266pub const OT_BACKBONE_ROUTER_STATE_SECONDARY: otBackboneRouterState = 1;
4267#[doc = "< The Primary Backbone Router."]
4268pub const OT_BACKBONE_ROUTER_STATE_PRIMARY: otBackboneRouterState = 2;
4269#[doc = " Represents the Backbone Router Status."]
4270pub type otBackboneRouterState = ::std::os::raw::c_uint;
4271extern "C" {
4272    #[doc = " Enables or disables Backbone functionality.\n\n If enabled, a Server Data Request message `SRV_DATA.ntf` is triggered for the attached\n device if there is no Backbone Router Service in the Thread Network Data.\n\n If disabled, `SRV_DATA.ntf` is triggered if the Backbone Router is in the Primary state.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable   TRUE to enable Backbone functionality, FALSE otherwise.\n\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister"]
4273    pub fn otBackboneRouterSetEnabled(aInstance: *mut otInstance, aEnable: bool);
4274}
4275extern "C" {
4276    #[doc = " Gets the Backbone Router #otBackboneRouterState.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n\n @retval OT_BACKBONE_ROUTER_STATE_DISABLED   Backbone functionality is disabled.\n @retval OT_BACKBONE_ROUTER_STATE_SECONDARY  Secondary Backbone Router.\n @retval OT_BACKBONE_ROUTER_STATE_PRIMARY    The Primary Backbone Router.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister"]
4277    pub fn otBackboneRouterGetState(aInstance: *mut otInstance) -> otBackboneRouterState;
4278}
4279extern "C" {
4280    #[doc = " Gets the local Backbone Router configuration.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in]   aInstance            A pointer to an OpenThread instance.\n @param[out]  aConfig              A pointer where to put local Backbone Router configuration.\n\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister"]
4281    pub fn otBackboneRouterGetConfig(
4282        aInstance: *mut otInstance,
4283        aConfig: *mut otBackboneRouterConfig,
4284    );
4285}
4286extern "C" {
4287    #[doc = " Sets the local Backbone Router configuration #otBackboneRouterConfig.\n\n A Server Data Request message `SRV_DATA.ntf` is initiated automatically if BBR Dataset changes for Primary\n Backbone Router.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n @param[in]  aConfig               A pointer to the Backbone Router configuration to take effect.\n\n @retval OT_ERROR_NONE          Successfully updated configuration.\n @retval OT_ERROR_INVALID_ARGS  The configuration in @p aConfig is invalid.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterRegister"]
4288    pub fn otBackboneRouterSetConfig(
4289        aInstance: *mut otInstance,
4290        aConfig: *const otBackboneRouterConfig,
4291    ) -> otError;
4292}
4293extern "C" {
4294    #[doc = " Explicitly registers local Backbone Router configuration.\n\n A Server Data Request message `SRV_DATA.ntf` is triggered for the attached device.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in]  aInstance             A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NO_BUFS           Insufficient space to add the Backbone Router service.\n @retval OT_ERROR_NONE              Successfully queued a Server Data Request message for delivery.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig"]
4295    pub fn otBackboneRouterRegister(aInstance: *mut otInstance) -> otError;
4296}
4297extern "C" {
4298    #[doc = " Returns the Backbone Router registration jitter value.\n\n @returns The Backbone Router registration jitter value.\n\n @sa otBackboneRouterSetRegistrationJitter"]
4299    pub fn otBackboneRouterGetRegistrationJitter(aInstance: *mut otInstance) -> u8;
4300}
4301extern "C" {
4302    #[doc = " Sets the Backbone Router registration jitter value.\n\n @param[in]  aJitter the Backbone Router registration jitter value to set.\n\n @sa otBackboneRouterGetRegistrationJitter"]
4303    pub fn otBackboneRouterSetRegistrationJitter(aInstance: *mut otInstance, aJitter: u8);
4304}
4305extern "C" {
4306    #[doc = " Gets the local Domain Prefix configuration.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[out] aConfig   A pointer to the Domain Prefix configuration.\n\n @retval OT_ERROR_NONE       Successfully got the Domain Prefix configuration.\n @retval OT_ERROR_NOT_FOUND  No Domain Prefix was configured."]
4307    pub fn otBackboneRouterGetDomainPrefix(
4308        aInstance: *mut otInstance,
4309        aConfig: *mut otBorderRouterConfig,
4310    ) -> otError;
4311}
4312extern "C" {
4313    #[doc = " Configures response status for next DUA registration.\n\n Note: available only when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n       Only used for test and certification.\n\n TODO: (DUA) support coap error code and corresponding process for certification purpose.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMlIid    A pointer to the Mesh Local IID. If NULL, respond with @p aStatus for any\n                      coming DUA.req, otherwise only respond the one with matching @p aMlIid.\n @param[in] aStatus   The status to respond."]
4314    pub fn otBackboneRouterConfigNextDuaRegistrationResponse(
4315        aInstance: *mut otInstance,
4316        aMlIid: *const otIp6InterfaceIdentifier,
4317        aStatus: u8,
4318    );
4319}
4320extern "C" {
4321    #[doc = " Configures the response status for the next Multicast Listener Registration.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aStatus    The status to respond."]
4322    pub fn otBackboneRouterConfigNextMulticastListenerRegistrationResponse(
4323        aInstance: *mut otInstance,
4324        aStatus: u8,
4325    );
4326}
4327#[doc = "< Multicast Listener was added."]
4328pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ADDED: otBackboneRouterMulticastListenerEvent = 0;
4329#[doc = "< Multicast Listener was removed or expired."]
4330pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_REMOVED: otBackboneRouterMulticastListenerEvent = 1;
4331#[doc = " Represents the Multicast Listener events."]
4332pub type otBackboneRouterMulticastListenerEvent = ::std::os::raw::c_uint;
4333#[doc = " Pointer is called whenever the Multicast Listeners change.\n\n @param[in] aContext  The user context pointer.\n @param[in] aEvent    The Multicast Listener event.\n @param[in] aAddress  The IPv6 multicast address of the Multicast Listener."]
4334pub type otBackboneRouterMulticastListenerCallback = ::std::option::Option<
4335    unsafe extern "C" fn(
4336        aContext: *mut ::std::os::raw::c_void,
4337        aEvent: otBackboneRouterMulticastListenerEvent,
4338        aAddress: *const otIp6Address,
4339    ),
4340>;
4341extern "C" {
4342    #[doc = " Sets the Backbone Router Multicast Listener callback.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  A pointer to the Multicast Listener callback.\n @param[in] aContext   A user context pointer."]
4343    pub fn otBackboneRouterSetMulticastListenerCallback(
4344        aInstance: *mut otInstance,
4345        aCallback: otBackboneRouterMulticastListenerCallback,
4346        aContext: *mut ::std::os::raw::c_void,
4347    );
4348}
4349extern "C" {
4350    #[doc = " Clears the Multicast Listeners.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @sa otBackboneRouterMulticastListenerAdd\n @sa otBackboneRouterMulticastListenerGetNext"]
4351    pub fn otBackboneRouterMulticastListenerClear(aInstance: *mut otInstance);
4352}
4353extern "C" {
4354    #[doc = " Adds a Multicast Listener with a timeout value, in seconds.\n\n Pass `0` to use the default MLR timeout.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aAddress   The Multicast Listener address.\n @param[in] aTimeout   The timeout (in seconds) of the Multicast Listener, or 0 to use the default MLR timeout.\n\n @retval OT_ERROR_NONE          If the Multicast Listener was successfully added.\n @retval OT_ERROR_INVALID_ARGS  If the Multicast Listener address was invalid.\n @retval OT_ERROR_NO_BUFS       No space available to save the Multicast Listener.\n\n @sa otBackboneRouterMulticastListenerClear\n @sa otBackboneRouterMulticastListenerGetNext"]
4355    pub fn otBackboneRouterMulticastListenerAdd(
4356        aInstance: *mut otInstance,
4357        aAddress: *const otIp6Address,
4358        aTimeout: u32,
4359    ) -> otError;
4360}
4361pub type otBackboneRouterMulticastListenerIterator = u16;
4362#[doc = " Represents a Backbone Router Multicast Listener info."]
4363#[repr(C)]
4364#[derive(Copy, Clone)]
4365pub struct otBackboneRouterMulticastListenerInfo {
4366    pub mAddress: otIp6Address,
4367    pub mTimeout: u32,
4368}
4369impl Default for otBackboneRouterMulticastListenerInfo {
4370    fn default() -> Self {
4371        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4372        unsafe {
4373            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4374            s.assume_init()
4375        }
4376    }
4377}
4378extern "C" {
4379    #[doc = " Gets the next Multicast Listener info (using an iterator).\n\n @param[in]      aInstance      A pointer to an OpenThread instance.\n @param[in,out]  aIterator      A pointer to the iterator. On success the iterator will be updated to point to next\n                                Multicast Listener. To get the first entry the iterator should be set to\n                                OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT.\n @param[out]     aListenerInfo  A pointer to an `otBackboneRouterMulticastListenerInfo` where information of next\n                                Multicast Listener is placed (on success).\n\n @retval OT_ERROR_NONE       Successfully found the next Multicast Listener info (@p aListenerInfo was successfully\n                             updated).\n @retval OT_ERROR_NOT_FOUND  No subsequent Multicast Listener info was found.\n\n @sa otBackboneRouterMulticastListenerClear\n @sa otBackboneRouterMulticastListenerAdd"]
4380    pub fn otBackboneRouterMulticastListenerGetNext(
4381        aInstance: *mut otInstance,
4382        aIterator: *mut otBackboneRouterMulticastListenerIterator,
4383        aListenerInfo: *mut otBackboneRouterMulticastListenerInfo,
4384    ) -> otError;
4385}
4386#[doc = "< ND Proxy was added."]
4387pub const OT_BACKBONE_ROUTER_NDPROXY_ADDED: otBackboneRouterNdProxyEvent = 0;
4388#[doc = "< ND Proxy was removed."]
4389pub const OT_BACKBONE_ROUTER_NDPROXY_REMOVED: otBackboneRouterNdProxyEvent = 1;
4390#[doc = "< ND Proxy was renewed."]
4391pub const OT_BACKBONE_ROUTER_NDPROXY_RENEWED: otBackboneRouterNdProxyEvent = 2;
4392#[doc = "< All ND Proxies were cleared."]
4393pub const OT_BACKBONE_ROUTER_NDPROXY_CLEARED: otBackboneRouterNdProxyEvent = 3;
4394#[doc = " Represents the ND Proxy events."]
4395pub type otBackboneRouterNdProxyEvent = ::std::os::raw::c_uint;
4396#[doc = " Pointer is called whenever the Nd Proxy changed.\n\n @param[in] aContext  The user context pointer.\n @param[in] aEvent    The ND Proxy event.\n @param[in] aDua      The Domain Unicast Address of the ND Proxy, or `nullptr` if @p aEvent is\n                      `OT_BACKBONE_ROUTER_NDPROXY_CLEARED`."]
4397pub type otBackboneRouterNdProxyCallback = ::std::option::Option<
4398    unsafe extern "C" fn(
4399        aContext: *mut ::std::os::raw::c_void,
4400        aEvent: otBackboneRouterNdProxyEvent,
4401        aDua: *const otIp6Address,
4402    ),
4403>;
4404extern "C" {
4405    #[doc = " Sets the Backbone Router ND Proxy callback.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  A pointer to the ND Proxy callback.\n @param[in] aContext   A user context pointer."]
4406    pub fn otBackboneRouterSetNdProxyCallback(
4407        aInstance: *mut otInstance,
4408        aCallback: otBackboneRouterNdProxyCallback,
4409        aContext: *mut ::std::os::raw::c_void,
4410    );
4411}
4412#[doc = " Represents the Backbone Router ND Proxy info."]
4413#[repr(C)]
4414#[derive(Debug, Copy, Clone)]
4415pub struct otBackboneRouterNdProxyInfo {
4416    #[doc = "< Mesh-local IID"]
4417    pub mMeshLocalIid: *mut otIp6InterfaceIdentifier,
4418    #[doc = "< Time since last transaction (Seconds)"]
4419    pub mTimeSinceLastTransaction: u32,
4420    #[doc = "< RLOC16"]
4421    pub mRloc16: u16,
4422}
4423impl Default for otBackboneRouterNdProxyInfo {
4424    fn default() -> Self {
4425        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4426        unsafe {
4427            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4428            s.assume_init()
4429        }
4430    }
4431}
4432extern "C" {
4433    #[doc = " Gets the Backbone Router ND Proxy info.\n\n @param[in]   aInstance     A pointer to an OpenThread instance.\n @param[in]   aDua          The Domain Unicast Address.\n @param[out]  aNdProxyInfo  A pointer to the ND Proxy info.\n\n @retval OT_ERROR_NONE       Successfully got the ND Proxy info.\n @retval OT_ERROR_NOT_FOUND  Failed to find the Domain Unicast Address in the ND Proxy table."]
4434    pub fn otBackboneRouterGetNdProxyInfo(
4435        aInstance: *mut otInstance,
4436        aDua: *const otIp6Address,
4437        aNdProxyInfo: *mut otBackboneRouterNdProxyInfo,
4438    ) -> otError;
4439}
4440#[doc = "< Domain Prefix was added."]
4441pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_ADDED: otBackboneRouterDomainPrefixEvent = 0;
4442#[doc = "< Domain Prefix was removed."]
4443pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED: otBackboneRouterDomainPrefixEvent = 1;
4444#[doc = "< Domain Prefix was changed."]
4445pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_CHANGED: otBackboneRouterDomainPrefixEvent = 2;
4446#[doc = " Represents the Domain Prefix events."]
4447pub type otBackboneRouterDomainPrefixEvent = ::std::os::raw::c_uint;
4448#[doc = " Pointer is called whenever the Domain Prefix changed.\n\n @param[in] aContext       The user context pointer.\n @param[in] aEvent         The Domain Prefix event.\n @param[in] aDomainPrefix  The new Domain Prefix if added or changed, nullptr otherwise."]
4449pub type otBackboneRouterDomainPrefixCallback = ::std::option::Option<
4450    unsafe extern "C" fn(
4451        aContext: *mut ::std::os::raw::c_void,
4452        aEvent: otBackboneRouterDomainPrefixEvent,
4453        aDomainPrefix: *const otIp6Prefix,
4454    ),
4455>;
4456extern "C" {
4457    #[doc = " Sets the Backbone Router Domain Prefix callback.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  A pointer to the Domain Prefix callback.\n @param[in] aContext   A user context pointer."]
4458    pub fn otBackboneRouterSetDomainPrefixCallback(
4459        aInstance: *mut otInstance,
4460        aCallback: otBackboneRouterDomainPrefixCallback,
4461        aContext: *mut ::std::os::raw::c_void,
4462    );
4463}
4464#[doc = " Represents a Border Agent Identifier."]
4465#[repr(C)]
4466#[derive(Debug, Default, Copy, Clone)]
4467pub struct otBorderAgentId {
4468    #[doc = "< Border Agent ID bytes."]
4469    pub mId: [u8; 16usize],
4470}
4471#[doc = " Defines Border Agent counters.\n\n The `mEpskc` related counters require `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`."]
4472#[repr(C)]
4473#[derive(Debug, Default, Copy, Clone)]
4474pub struct otBorderAgentCounters {
4475    #[doc = "< The number of ePSKc activations"]
4476    pub mEpskcActivations: u32,
4477    #[doc = "< The number of ePSKc deactivations via API"]
4478    pub mEpskcDeactivationClears: u32,
4479    #[doc = "< The number of ePSKc deactivations due to timeout"]
4480    pub mEpskcDeactivationTimeouts: u32,
4481    #[doc = "< The number of ePSKc deactivations due to reached max attempts"]
4482    pub mEpskcDeactivationMaxAttempts: u32,
4483    #[doc = "< The number of ePSKc deactivations due to commissioner disconnected"]
4484    pub mEpskcDeactivationDisconnects: u32,
4485    #[doc = "< The number of invalid border agent state errors at ePSKc activation"]
4486    pub mEpskcInvalidBaStateErrors: u32,
4487    #[doc = "< The number of invalid args errors at ePSKc activation"]
4488    pub mEpskcInvalidArgsErrors: u32,
4489    #[doc = "< The number of start secure session errors at ePSKc activation"]
4490    pub mEpskcStartSecureSessionErrors: u32,
4491    #[doc = "< The number of established secure sessions with ePSKc"]
4492    pub mEpskcSecureSessionSuccesses: u32,
4493    #[doc = "< The number of failed secure sessions with ePSKc"]
4494    pub mEpskcSecureSessionFailures: u32,
4495    #[doc = "< The number of successful commissioner petitions with ePSKc"]
4496    pub mEpskcCommissionerPetitions: u32,
4497    #[doc = "< The number of established secure sessions with PSKc"]
4498    pub mPskcSecureSessionSuccesses: u32,
4499    #[doc = "< The number of failed secure sessions with PSKc"]
4500    pub mPskcSecureSessionFailures: u32,
4501    #[doc = "< The number of successful commissioner petitions with PSKc"]
4502    pub mPskcCommissionerPetitions: u32,
4503    #[doc = "< The number of MGMT_ACTIVE_GET.req sent over secure sessions"]
4504    pub mMgmtActiveGets: u32,
4505    #[doc = "< The number of MGMT_PENDING_GET.req sent over secure sessions"]
4506    pub mMgmtPendingGets: u32,
4507}
4508#[doc = " Represents information about a Border Agent session.\n\n This structure is populated by `otBorderAgentGetNextSessionInfo()` during iteration over the list of sessions using\n an `otBorderAgentSessionIterator`.\n\n To ensure consistent `mLifetime` calculations, the iterator's initialization time is stored within the iterator,\n and each session's `mLifetime` is calculated relative to this time."]
4509#[repr(C)]
4510#[derive(Copy, Clone)]
4511pub struct otBorderAgentSessionInfo {
4512    #[doc = "< Socket address (IPv6 address and port number) of session peer."]
4513    pub mPeerSockAddr: otSockAddr,
4514    #[doc = "< Indicates whether the session is connected."]
4515    pub mIsConnected: bool,
4516    #[doc = "< Indicates whether the session is accepted as full commissioner."]
4517    pub mIsCommissioner: bool,
4518    #[doc = "< Milliseconds since the session was first established."]
4519    pub mLifetime: u64,
4520}
4521impl Default for otBorderAgentSessionInfo {
4522    fn default() -> Self {
4523        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4524        unsafe {
4525            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4526            s.assume_init()
4527        }
4528    }
4529}
4530#[doc = " Represents an iterator for Border Agent sessions.\n\n The caller MUST NOT access or update the fields in this struct. It is intended for OpenThread internal use only."]
4531#[repr(C)]
4532#[derive(Debug, Copy, Clone)]
4533pub struct otBorderAgentSessionIterator {
4534    pub mPtr: *mut ::std::os::raw::c_void,
4535    pub mData: u64,
4536}
4537impl Default for otBorderAgentSessionIterator {
4538    fn default() -> Self {
4539        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4540        unsafe {
4541            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4542            s.assume_init()
4543        }
4544    }
4545}
4546#[doc = " Represents the Border Agent MeshCoP Service TXT data."]
4547#[repr(C)]
4548#[derive(Debug, Copy, Clone)]
4549pub struct otBorderAgentMeshCoPServiceTxtData {
4550    pub mData: [u8; 128usize],
4551    pub mLength: u16,
4552}
4553impl Default for otBorderAgentMeshCoPServiceTxtData {
4554    fn default() -> Self {
4555        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4556        unsafe {
4557            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4558            s.assume_init()
4559        }
4560    }
4561}
4562extern "C" {
4563    #[doc = " Indicates whether or not the Border Agent service is active and running.\n\n While the Border Agent is active, external commissioner candidates can try to connect to and establish secure DTLS\n sessions with the Border Agent using PSKc. A connected commissioner can then petition to become a full commissioner.\n\n If `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE` is enabled, independent and separate DTLS transport and\n sessions are used for the ephemeral key. Therefore, the ephemeral key and Border Agent service can be enabled and\n used in parallel.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE   The Border Agent is active.\n @retval FALSE  The Border Agent is not active."]
4564    pub fn otBorderAgentIsActive(aInstance: *mut otInstance) -> bool;
4565}
4566extern "C" {
4567    #[doc = " Gets the UDP port of the Thread Border Agent service.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns UDP port of the Border Agent."]
4568    pub fn otBorderAgentGetUdpPort(aInstance: *mut otInstance) -> u16;
4569}
4570#[doc = " This callback informs the application of the changes in the state of the MeshCoP service.\n\n In specific, the 'state' includes the MeshCoP TXT data originated from the Thread network and whether the\n Border Agent is Active (which can be obtained by `otBorderAgentIsActive`).\n\n @param[in] aContext  A pointer to application-specific context."]
4571pub type otBorderAgentMeshCoPServiceChangedCallback =
4572    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4573extern "C" {
4574    #[doc = " Sets the callback function used by the Border Agent to notify of any changes to the state of the MeshCoP service.\n\n The callback is invoked when the 'Is Active' state of the Border Agent or the MeshCoP service TXT data values\n change. For example, it is invoked when the network name or the extended PAN ID changes and passes the updated\n encoded TXT data to the application layer.\n\n This callback is invoked once right after this API is called to provide initial states of the MeshCoP service.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  The callback to be invoked when there are any changes of the MeshCoP service.\n @param[in] aContext   A pointer to application-specific context."]
4575    pub fn otBorderAgentSetMeshCoPServiceChangedCallback(
4576        aInstance: *mut otInstance,
4577        aCallback: otBorderAgentMeshCoPServiceChangedCallback,
4578        aContext: *mut ::std::os::raw::c_void,
4579    );
4580}
4581extern "C" {
4582    #[doc = " Gets the MeshCoP service TXT data.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[out] aTxtData   A pointer to a MeshCoP Service TXT data struct to get the data.\n\n @retval OT_ERROR_NONE      If successfully retrieved the Border Agent MeshCoP Service TXT data.\n @retval OT_ERROR_NO_BUFS   If the buffer in @p aTxtData doesn't have enough size."]
4583    pub fn otBorderAgentGetMeshCoPServiceTxtData(
4584        aInstance: *mut otInstance,
4585        aTxtData: *mut otBorderAgentMeshCoPServiceTxtData,
4586    ) -> otError;
4587}
4588extern "C" {
4589    #[doc = " Gets the randomly generated Border Agent ID.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_ID_ENABLE`.\n\n The ID is saved in persistent storage and survives reboots. The typical use case of the ID is to\n be published in the MeshCoP mDNS service as the `id` TXT value for the client to identify this\n Border Router/Agent device.\n\n @param[in]    aInstance  A pointer to an OpenThread instance.\n @param[out]   aId        A pointer to buffer to receive the ID.\n\n @retval OT_ERROR_NONE  If successfully retrieved the Border Agent ID.\n @retval ...            If failed to retrieve the Border Agent ID.\n\n @sa otBorderAgentSetId"]
4590    pub fn otBorderAgentGetId(aInstance: *mut otInstance, aId: *mut otBorderAgentId) -> otError;
4591}
4592extern "C" {
4593    #[doc = " Sets the Border Agent ID.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_ID_ENABLE`.\n\n The Border Agent ID will be saved in persistent storage and survive reboots. It's required to\n set the ID only once after factory reset. If the ID has never been set by calling this function,\n a random ID will be generated and returned when `otBorderAgentGetId` is called.\n\n @param[in]    aInstance  A pointer to an OpenThread instance.\n @param[out]   aId        A pointer to the Border Agent ID.\n\n @retval OT_ERROR_NONE  If successfully set the Border Agent ID.\n @retval ...            If failed to set the Border Agent ID.\n\n @sa otBorderAgentGetId"]
4594    pub fn otBorderAgentSetId(aInstance: *mut otInstance, aId: *const otBorderAgentId) -> otError;
4595}
4596extern "C" {
4597    #[doc = " Initializes a session iterator.\n\n An iterator MUST be initialized before being used in `otBorderAgentGetNextSessionInfo()`. A previously initialized\n iterator can be re-initialized to start from the beginning of the session list.\n\n @param[in] aInstance   A pointer to an OpenThread instance.\n @param[in] aIterator   The iterator to initialize."]
4598    pub fn otBorderAgentInitSessionIterator(
4599        aInstance: *mut otInstance,
4600        aIterator: *mut otBorderAgentSessionIterator,
4601    );
4602}
4603extern "C" {
4604    #[doc = " Retrieves the next Border Agent session information.\n\n @param[in]  aIterator      The iterator to use.\n @param[out] aSessionInfo   A pointer to an `otBorderAgentSessionInfo` to populate.\n\n @retval OT_ERROR_NONE        Successfully retrieved the next session info.\n @retval OT_ERROR_NOT_FOUND   No more sessions are available. The end of the list has been reached."]
4605    pub fn otBorderAgentGetNextSessionInfo(
4606        aIterator: *mut otBorderAgentSessionIterator,
4607        aSessionInfo: *mut otBorderAgentSessionInfo,
4608    ) -> otError;
4609}
4610extern "C" {
4611    #[doc = " Gets the counters of the Thread Border Agent.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the Border Agent counters."]
4612    pub fn otBorderAgentGetCounters(aInstance: *mut otInstance) -> *const otBorderAgentCounters;
4613}
4614#[doc = "< Ephemeral Key Manager is disabled."]
4615pub const OT_BORDER_AGENT_STATE_DISABLED: otBorderAgentEphemeralKeyState = 0;
4616#[doc = "< Enabled, but no ephemeral key is in use (not set or started)."]
4617pub const OT_BORDER_AGENT_STATE_STOPPED: otBorderAgentEphemeralKeyState = 1;
4618#[doc = "< Ephemeral key is set. Listening to accept secure connections."]
4619pub const OT_BORDER_AGENT_STATE_STARTED: otBorderAgentEphemeralKeyState = 2;
4620#[doc = "< Session is established with an external commissioner candidate."]
4621pub const OT_BORDER_AGENT_STATE_CONNECTED: otBorderAgentEphemeralKeyState = 3;
4622#[doc = "< Session is established and candidate is accepted as full commissioner."]
4623pub const OT_BORDER_AGENT_STATE_ACCEPTED: otBorderAgentEphemeralKeyState = 4;
4624#[doc = " Represents Border Agent's Ephemeral Key Manager state."]
4625pub type otBorderAgentEphemeralKeyState = ::std::os::raw::c_uint;
4626extern "C" {
4627    #[doc = " Gets the state of Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The current state of Ephemeral Key Manager."]
4628    pub fn otBorderAgentEphemeralKeyGetState(
4629        aInstance: *mut otInstance,
4630    ) -> otBorderAgentEphemeralKeyState;
4631}
4632extern "C" {
4633    #[doc = " Enables/disables the Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n If this function is called to disable, while an an ephemeral key is in use, the ephemeral key use will be stopped\n (as if `otBorderAgentEphemeralKeyStop()` is called).\n\n @param[in] aInstance    The OpenThread instance.\n @param[in] aEnabled     Whether to enable or disable the Ephemeral Key Manager."]
4634    pub fn otBorderAgentEphemeralKeySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
4635}
4636extern "C" {
4637    #[doc = " Starts using an ephemeral key for a given timeout duration.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n An ephemeral key can only be set when `otBorderAgentEphemeralKeyGetState()` is `OT_BORDER_AGENT_STATE_STOPPED`,\n i.e., enabled but not yet started. Otherwise, `OT_ERROR_INVALID_STATE` is returned. This means that setting the\n ephemeral key again while a previously set key is still in use will fail. Callers can stop the previous key by\n calling `otBorderAgentEphemeralKeyStop()` before starting with a new key.\n\n The Ephemeral Key Manager and the Border Agent service (which uses PSKc) can be enabled and used in parallel, as\n they use independent and separate DTLS transport and sessions.\n\n The given @p aKeyString is used directly as the ephemeral PSK (excluding the trailing null `\\0` character).\n Its length must be between `OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH` and `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH`,\n inclusive. Otherwise `OT_ERROR_INVALID_ARGS` is returned.\n\n When successfully set, the ephemeral key can be used only once by an external commissioner candidate to establish a\n secure session. After the commissioner candidate disconnects, the use of the ephemeral key is stopped. If the\n timeout expires, the use of the ephemeral key is stopped, and any connected session using the key is immediately\n disconnected.\n\n The Ephemeral Key Manager limits the number of failed DTLS connections to 10 attempts. After the 10th failed\n attempt, the use of the ephemeral key is automatically stopped (even if the timeout has not yet expired).\n\n @param[in] aInstance    The OpenThread instance.\n @param[in] aKeyString   The ephemeral key.\n @param[in] aTimeout     The timeout duration, in milliseconds, to use the ephemeral key.\n                         If zero, the default `OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT` value is used. If the\n                         timeout value is larger than `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT`, the maximum value\n                         is used instead.\n @param[in] aUdpPort     The UDP port to use with the ephemeral key. If the UDP port is zero, an ephemeral port will\n                         be used. `otBorderAgentEphemeralKeyGetUdpPort()` returns the current UDP port being used.\n\n @retval OT_ERROR_NONE            Successfully started using the ephemeral key.\n @retval OT_ERROR_INVALID_STATE   A previously set ephemeral key is still in use or the feature is disabled.\n @retval OT_ERROR_INVALID_ARGS    The given @p aKeyString is not valid.\n @retval OT_ERROR_FAILED          Failed to start (e.g., it could not bind to the given UDP port)."]
4638    pub fn otBorderAgentEphemeralKeyStart(
4639        aInstance: *mut otInstance,
4640        aKeyString: *const ::std::os::raw::c_char,
4641        aTimeout: u32,
4642        aUdpPort: u16,
4643    ) -> otError;
4644}
4645extern "C" {
4646    #[doc = " Stops the ephemeral key use and disconnects any session using it.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n If there is no ephemeral key in use, calling this function has no effect.\n\n @param[in] aInstance    The OpenThread instance."]
4647    pub fn otBorderAgentEphemeralKeyStop(aInstance: *mut otInstance);
4648}
4649extern "C" {
4650    #[doc = " Gets the UDP port used by Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n The port is applicable if an ephemeral key is in use, i.e., the state is not `OT_BORDER_AGENT_STATE_DISABLED` or\n `OT_BORDER_AGENT_STATE_STOPPED`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The UDP port being used by Border Agent's Ephemeral Key Manager (when active)."]
4651    pub fn otBorderAgentEphemeralKeyGetUdpPort(aInstance: *mut otInstance) -> u16;
4652}
4653#[doc = " Callback function pointer to signal state changes to the Border Agent's Ephemeral Key Manager.\n\n This callback is invoked whenever the `otBorderAgentEphemeralKeyGetState()` gets changed.\n\n Any OpenThread API, including `otBorderAgent` APIs, can be safely called from this callback.\n\n @param[in] aContext   A pointer to an arbitrary context (provided when callback is set)."]
4654pub type otBorderAgentEphemeralKeyCallback =
4655    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4656extern "C" {
4657    #[doc = " Sets the callback function to notify state changes of Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n A subsequent call to this function will replace any previously set callback.\n\n @param[in] aInstance    The OpenThread instance.\n @param[in] aCallback    The callback function pointer.\n @param[in] aContext     The arbitrary context to use with callback."]
4658    pub fn otBorderAgentEphemeralKeySetCallback(
4659        aInstance: *mut otInstance,
4660        aCallback: otBorderAgentEphemeralKeyCallback,
4661        aContext: *mut ::std::os::raw::c_void,
4662    );
4663}
4664extern "C" {
4665    #[doc = " Converts a given `otBorderAgentEphemeralKeyState` to a human-readable string.\n\n @param[in] aState   The state to convert.\n\n @returns Human-readable string corresponding to @p aState."]
4666    pub fn otBorderAgentEphemeralKeyStateToString(
4667        aState: otBorderAgentEphemeralKeyState,
4668    ) -> *const ::std::os::raw::c_char;
4669}
4670#[doc = " Represents an iterator to iterate through the Border Router's discovered prefix table.\n\n The fields in this type are opaque (intended for use by OpenThread core only) and therefore should not be\n accessed or used by caller.\n\n Before using an iterator, it MUST be initialized using `otBorderRoutingPrefixTableInitIterator()`."]
4671#[repr(C)]
4672#[derive(Debug, Copy, Clone)]
4673pub struct otBorderRoutingPrefixTableIterator {
4674    pub mPtr1: *const ::std::os::raw::c_void,
4675    pub mPtr2: *const ::std::os::raw::c_void,
4676    pub mData0: u32,
4677    pub mData1: u32,
4678    pub mData2: u8,
4679    pub mData3: u8,
4680}
4681impl Default for otBorderRoutingPrefixTableIterator {
4682    fn default() -> Self {
4683        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4684        unsafe {
4685            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4686            s.assume_init()
4687        }
4688    }
4689}
4690#[doc = " Represents a discovered router on the infrastructure link.\n\n The `mIsPeerBr` field requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`. Routing Manager\n determines whether the router is a peer BR (connected to the same Thread mesh network) by comparing its advertised\n PIO/RIO prefixes with the entries in the Thread Network Data. While this method is generally effective, it may not\n be 100% accurate in all scenarios, so the `mIsPeerBr` flag should be used with caution."]
4691#[repr(C)]
4692#[derive(Copy, Clone)]
4693pub struct otBorderRoutingRouterEntry {
4694    #[doc = "< IPv6 address of the router."]
4695    pub mAddress: otIp6Address,
4696    #[doc = "< Milliseconds since last update (any message rx) from this router."]
4697    pub mMsecSinceLastUpdate: u32,
4698    #[doc = "< The router's age in seconds (duration since its first discovery)."]
4699    pub mAge: u32,
4700    pub _bitfield_align_1: [u8; 0],
4701    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4702    pub __bindgen_padding_0: [u8; 3usize],
4703}
4704impl Default for otBorderRoutingRouterEntry {
4705    fn default() -> Self {
4706        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4707        unsafe {
4708            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4709            s.assume_init()
4710        }
4711    }
4712}
4713impl otBorderRoutingRouterEntry {
4714    #[inline]
4715    pub fn mManagedAddressConfigFlag(&self) -> bool {
4716        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4717    }
4718    #[inline]
4719    pub fn set_mManagedAddressConfigFlag(&mut self, val: bool) {
4720        unsafe {
4721            let val: u8 = ::std::mem::transmute(val);
4722            self._bitfield_1.set(0usize, 1u8, val as u64)
4723        }
4724    }
4725    #[inline]
4726    pub fn mOtherConfigFlag(&self) -> bool {
4727        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
4728    }
4729    #[inline]
4730    pub fn set_mOtherConfigFlag(&mut self, val: bool) {
4731        unsafe {
4732            let val: u8 = ::std::mem::transmute(val);
4733            self._bitfield_1.set(1usize, 1u8, val as u64)
4734        }
4735    }
4736    #[inline]
4737    pub fn mSnacRouterFlag(&self) -> bool {
4738        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4739    }
4740    #[inline]
4741    pub fn set_mSnacRouterFlag(&mut self, val: bool) {
4742        unsafe {
4743            let val: u8 = ::std::mem::transmute(val);
4744            self._bitfield_1.set(2usize, 1u8, val as u64)
4745        }
4746    }
4747    #[inline]
4748    pub fn mIsLocalDevice(&self) -> bool {
4749        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4750    }
4751    #[inline]
4752    pub fn set_mIsLocalDevice(&mut self, val: bool) {
4753        unsafe {
4754            let val: u8 = ::std::mem::transmute(val);
4755            self._bitfield_1.set(3usize, 1u8, val as u64)
4756        }
4757    }
4758    #[inline]
4759    pub fn mIsReachable(&self) -> bool {
4760        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4761    }
4762    #[inline]
4763    pub fn set_mIsReachable(&mut self, val: bool) {
4764        unsafe {
4765            let val: u8 = ::std::mem::transmute(val);
4766            self._bitfield_1.set(4usize, 1u8, val as u64)
4767        }
4768    }
4769    #[inline]
4770    pub fn mIsPeerBr(&self) -> bool {
4771        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4772    }
4773    #[inline]
4774    pub fn set_mIsPeerBr(&mut self, val: bool) {
4775        unsafe {
4776            let val: u8 = ::std::mem::transmute(val);
4777            self._bitfield_1.set(5usize, 1u8, val as u64)
4778        }
4779    }
4780    #[inline]
4781    pub fn new_bitfield_1(
4782        mManagedAddressConfigFlag: bool,
4783        mOtherConfigFlag: bool,
4784        mSnacRouterFlag: bool,
4785        mIsLocalDevice: bool,
4786        mIsReachable: bool,
4787        mIsPeerBr: bool,
4788    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4789        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4790        __bindgen_bitfield_unit.set(0usize, 1u8, {
4791            let mManagedAddressConfigFlag: u8 =
4792                unsafe { ::std::mem::transmute(mManagedAddressConfigFlag) };
4793            mManagedAddressConfigFlag as u64
4794        });
4795        __bindgen_bitfield_unit.set(1usize, 1u8, {
4796            let mOtherConfigFlag: u8 = unsafe { ::std::mem::transmute(mOtherConfigFlag) };
4797            mOtherConfigFlag as u64
4798        });
4799        __bindgen_bitfield_unit.set(2usize, 1u8, {
4800            let mSnacRouterFlag: u8 = unsafe { ::std::mem::transmute(mSnacRouterFlag) };
4801            mSnacRouterFlag as u64
4802        });
4803        __bindgen_bitfield_unit.set(3usize, 1u8, {
4804            let mIsLocalDevice: u8 = unsafe { ::std::mem::transmute(mIsLocalDevice) };
4805            mIsLocalDevice as u64
4806        });
4807        __bindgen_bitfield_unit.set(4usize, 1u8, {
4808            let mIsReachable: u8 = unsafe { ::std::mem::transmute(mIsReachable) };
4809            mIsReachable as u64
4810        });
4811        __bindgen_bitfield_unit.set(5usize, 1u8, {
4812            let mIsPeerBr: u8 = unsafe { ::std::mem::transmute(mIsPeerBr) };
4813            mIsPeerBr as u64
4814        });
4815        __bindgen_bitfield_unit
4816    }
4817}
4818#[doc = " Represents an entry from the discovered prefix table.\n\n The entries in the discovered table track the Prefix/Route Info Options in the received Router Advertisement messages\n from other routers on the infrastructure link."]
4819#[repr(C)]
4820#[derive(Copy, Clone)]
4821pub struct otBorderRoutingPrefixTableEntry {
4822    #[doc = "< Information about the router advertising this prefix."]
4823    pub mRouter: otBorderRoutingRouterEntry,
4824    #[doc = "< The discovered IPv6 prefix."]
4825    pub mPrefix: otIp6Prefix,
4826    #[doc = "< Indicates whether the prefix is on-link or route prefix."]
4827    pub mIsOnLink: bool,
4828    #[doc = "< Milliseconds since last update of this prefix."]
4829    pub mMsecSinceLastUpdate: u32,
4830    #[doc = "< Valid lifetime of the prefix (in seconds)."]
4831    pub mValidLifetime: u32,
4832    #[doc = "< Route preference when `mIsOnlink` is false."]
4833    pub mRoutePreference: otRoutePreference,
4834    #[doc = "< Preferred lifetime of the on-link prefix when `mIsOnLink`."]
4835    pub mPreferredLifetime: u32,
4836}
4837impl Default for otBorderRoutingPrefixTableEntry {
4838    fn default() -> Self {
4839        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4840        unsafe {
4841            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4842            s.assume_init()
4843        }
4844    }
4845}
4846#[doc = " Represents information about a peer Border Router found in the Network Data."]
4847#[repr(C)]
4848#[derive(Debug, Default, Copy, Clone)]
4849pub struct otBorderRoutingPeerBorderRouterEntry {
4850    #[doc = "< The RLOC16 of BR."]
4851    pub mRloc16: u16,
4852    #[doc = "< Seconds since the BR appeared in the Network Data."]
4853    pub mAge: u32,
4854}
4855#[doc = " Represents a group of data of platform-generated RA messages processed."]
4856#[repr(C)]
4857#[derive(Debug, Default, Copy, Clone)]
4858pub struct otPdProcessedRaInfo {
4859    #[doc = "< The number of platform generated RA handled by ProcessPlatformGeneratedRa."]
4860    pub mNumPlatformRaReceived: u32,
4861    #[doc = "< The number of PIO processed for adding OMR prefixes."]
4862    pub mNumPlatformPioProcessed: u32,
4863    #[doc = "< The timestamp of last processed RA message."]
4864    pub mLastPlatformRaMsec: u32,
4865}
4866#[doc = "< Routing Manager is uninitialized."]
4867pub const OT_BORDER_ROUTING_STATE_UNINITIALIZED: otBorderRoutingState = 0;
4868#[doc = "< Routing Manager is initialized but disabled."]
4869pub const OT_BORDER_ROUTING_STATE_DISABLED: otBorderRoutingState = 1;
4870#[doc = "< Routing Manager in initialized and enabled but currently stopped."]
4871pub const OT_BORDER_ROUTING_STATE_STOPPED: otBorderRoutingState = 2;
4872#[doc = "< Routing Manager is initialized, enabled, and running."]
4873pub const OT_BORDER_ROUTING_STATE_RUNNING: otBorderRoutingState = 3;
4874#[doc = " Represents the state of Border Routing Manager."]
4875pub type otBorderRoutingState = ::std::os::raw::c_uint;
4876#[doc = "< DHCPv6 PD is disabled on the border router."]
4877pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED: otBorderRoutingDhcp6PdState = 0;
4878#[doc = "< DHCPv6 PD in enabled but won't try to request and publish a prefix."]
4879pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED: otBorderRoutingDhcp6PdState = 1;
4880#[doc = "< DHCPv6 PD is enabled and will try to request and publish a prefix."]
4881pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING: otBorderRoutingDhcp6PdState = 2;
4882#[doc = "< DHCPv6 PD is idle; Higher-prf prefix published by other BRs."]
4883pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_IDLE: otBorderRoutingDhcp6PdState = 3;
4884#[doc = " This enumeration represents the state of DHCPv6 Prefix Delegation State."]
4885pub type otBorderRoutingDhcp6PdState = ::std::os::raw::c_uint;
4886extern "C" {
4887    #[doc = " Initializes the Border Routing Manager on given infrastructure interface.\n\n @note  This method MUST be called before any other otBorderRouting* APIs.\n @note  This method can be re-called to change the infrastructure interface, but the Border Routing Manager should be\n        disabled first, and re-enabled after.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aInfraIfIndex      The infrastructure interface index.\n @param[in]  aInfraIfIsRunning  A boolean that indicates whether the infrastructure\n                                interface is running.\n\n @retval  OT_ERROR_NONE           Successfully started the Border Routing Manager on given infrastructure.\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is in a state other than disabled or uninitialized.\n @retval  OT_ERROR_INVALID_ARGS   The index of the infrastructure interface is not valid.\n @retval  OT_ERROR_FAILED         Internal failure. Usually due to failure in generating random prefixes.\n\n @sa otPlatInfraIfStateChanged.\n @sa otBorderRoutingSetEnabled."]
4888    pub fn otBorderRoutingInit(
4889        aInstance: *mut otInstance,
4890        aInfraIfIndex: u32,
4891        aInfraIfIsRunning: bool,
4892    ) -> otError;
4893}
4894extern "C" {
4895    #[doc = " Enables or disables the Border Routing Manager.\n\n @note  The Border Routing Manager is disabled by default.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   A boolean to enable/disable the routing manager.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully enabled/disabled the Border Routing Manager."]
4896    pub fn otBorderRoutingSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
4897}
4898extern "C" {
4899    #[doc = " Gets the current state of Border Routing Manager.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The current state of Border Routing Manager."]
4900    pub fn otBorderRoutingGetState(aInstance: *mut otInstance) -> otBorderRoutingState;
4901}
4902extern "C" {
4903    #[doc = " Gets the current preference used when advertising Route Info Options (RIO) in Router Advertisement\n messages sent over the infrastructure link.\n\n The RIO preference is determined as follows:\n\n - If explicitly set by user by calling `otBorderRoutingSetRouteInfoOptionPreference()`, the given preference is\n   used.\n - Otherwise, it is determined based on device's current role: Medium preference when in router/leader role and\n   low preference when in child role.\n\n @returns The current Route Info Option preference."]
4904    pub fn otBorderRoutingGetRouteInfoOptionPreference(
4905        aInstance: *mut otInstance,
4906    ) -> otRoutePreference;
4907}
4908extern "C" {
4909    #[doc = " Explicitly sets the preference to use when advertising Route Info Options (RIO) in Router\n Advertisement messages sent over the infrastructure link.\n\n After a call to this function, BR will use the given preference for all its advertised RIOs. The preference can be\n cleared by calling `otBorderRoutingClearRouteInfoOptionPreference()`.\n\n @param[in] aInstance     A pointer to an OpenThread instance.\n @param[in] aPreference   The route preference to use."]
4910    pub fn otBorderRoutingSetRouteInfoOptionPreference(
4911        aInstance: *mut otInstance,
4912        aPreference: otRoutePreference,
4913    );
4914}
4915extern "C" {
4916    #[doc = " Clears a previously set preference value for advertised Route Info Options.\n\n After a call to this function, BR will use device's role to determine the RIO preference: Medium preference when\n in router/leader role and low preference when in child role.\n\n @param[in] aInstance     A pointer to an OpenThread instance."]
4917    pub fn otBorderRoutingClearRouteInfoOptionPreference(aInstance: *mut otInstance);
4918}
4919extern "C" {
4920    #[doc = " Sets additional options to append at the end of emitted Router Advertisement (RA) messages.\n\n The content of @p aOptions is copied internally, so it can be a temporary buffer (e.g., a stack allocated array).\n\n Subsequent calls to this function overwrite the previously set value.\n\n @param[in] aOptions   A pointer to the encoded options. Can be `NULL` to clear.\n @param[in] aLength    Number of bytes in @p aOptions.\n\n @retval OT_ERROR_NONE     Successfully set the extra option bytes.\n @retval OT_ERROR_NO_BUFS  Could not allocate buffer to save the buffer."]
4921    pub fn otBorderRoutingSetExtraRouterAdvertOptions(
4922        aInstance: *mut otInstance,
4923        aOptions: *const u8,
4924        aLength: u16,
4925    ) -> otError;
4926}
4927extern "C" {
4928    #[doc = " Gets the current preference used for published routes in Network Data.\n\n The preference is determined as follows:\n\n - If explicitly set by user by calling `otBorderRoutingSetRoutePreference()`, the given preference is used.\n - Otherwise, it is determined automatically by `RoutingManager` based on the device's role and link quality.\n\n @param[in] aInstance     A pointer to an OpenThread instance.\n\n @returns The current published route preference."]
4929    pub fn otBorderRoutingGetRoutePreference(aInstance: *mut otInstance) -> otRoutePreference;
4930}
4931extern "C" {
4932    #[doc = " Explicitly sets the preference of published routes in Network Data.\n\n After a call to this function, BR will use the given preference. The preference can be cleared by calling\n `otBorderRoutingClearRoutePreference()`.\n\n @param[in] aInstance     A pointer to an OpenThread instance.\n @param[in] aPreference   The route preference to use."]
4933    pub fn otBorderRoutingSetRoutePreference(
4934        aInstance: *mut otInstance,
4935        aPreference: otRoutePreference,
4936    );
4937}
4938extern "C" {
4939    #[doc = " Clears a previously set preference value for published routes in Network Data.\n\n After a call to this function, BR will determine the preference automatically based on the device's role and\n link quality (to the parent when acting as end-device).\n\n @param[in] aInstance     A pointer to an OpenThread instance."]
4940    pub fn otBorderRoutingClearRoutePreference(aInstance: *mut otInstance);
4941}
4942extern "C" {
4943    #[doc = " Gets the local Off-Mesh-Routable (OMR) Prefix, for example `fdfc:1ff5:1512:5622::/64`.\n\n An OMR Prefix is a randomly generated 64-bit prefix that's published in the\n Thread network if there isn't already an OMR prefix. This prefix can be reached\n from the local Wi-Fi or Ethernet network.\n\n Note: When DHCPv6 PD is enabled, the border router may publish the prefix from\n DHCPv6 PD.\n\n @param[in]   aInstance  A pointer to an OpenThread instance.\n @param[out]  aPrefix    A pointer to where the prefix will be output to.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the OMR prefix.\n\n @sa otBorderRoutingGetPdOmrPrefix"]
4944    pub fn otBorderRoutingGetOmrPrefix(
4945        aInstance: *mut otInstance,
4946        aPrefix: *mut otIp6Prefix,
4947    ) -> otError;
4948}
4949extern "C" {
4950    #[doc = " Gets the DHCPv6 Prefix Delegation (PD) provided off-mesh-routable (OMR) prefix.\n\n Only mPrefix, mValidLifetime and mPreferredLifetime fields are used in the returned prefix info.\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aPrefixInfo  A pointer to where the prefix info will be output to.\n\n @retval  OT_ERROR_NONE           Successfully retrieved the OMR prefix.\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NOT_FOUND      There are no valid PD prefix on this BR.\n\n @sa otBorderRoutingGetOmrPrefix\n @sa otPlatBorderRoutingProcessIcmp6Ra"]
4951    pub fn otBorderRoutingGetPdOmrPrefix(
4952        aInstance: *mut otInstance,
4953        aPrefixInfo: *mut otBorderRoutingPrefixTableEntry,
4954    ) -> otError;
4955}
4956extern "C" {
4957    #[doc = " Gets the data of platform generated RA message processed..\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aPrefixInfo  A pointer to where the prefix info will be output to.\n\n @retval  OT_ERROR_NONE           Successfully retrieved the Info.\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NOT_FOUND      There are no valid Info on this BR."]
4958    pub fn otBorderRoutingGetPdProcessedRaInfo(
4959        aInstance: *mut otInstance,
4960        aPdProcessedRaInfo: *mut otPdProcessedRaInfo,
4961    ) -> otError;
4962}
4963extern "C" {
4964    #[doc = " Gets the currently favored Off-Mesh-Routable (OMR) Prefix.\n\n The favored OMR prefix can be discovered from Network Data or can be this device's local OMR prefix.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aPrefix      A pointer to output the favored OMR prefix.\n @param[out]  aPreference  A pointer to output the preference associated the favored prefix.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not running yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the favored OMR prefix."]
4965    pub fn otBorderRoutingGetFavoredOmrPrefix(
4966        aInstance: *mut otInstance,
4967        aPrefix: *mut otIp6Prefix,
4968        aPreference: *mut otRoutePreference,
4969    ) -> otError;
4970}
4971extern "C" {
4972    #[doc = " Gets the local On-Link Prefix for the adjacent infrastructure link.\n\n The local On-Link Prefix is a 64-bit prefix that's advertised on the infrastructure link if there isn't already a\n usable on-link prefix being advertised on the link.\n\n @param[in]   aInstance  A pointer to an OpenThread instance.\n @param[out]  aPrefix    A pointer to where the prefix will be output to.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the local on-link prefix."]
4973    pub fn otBorderRoutingGetOnLinkPrefix(
4974        aInstance: *mut otInstance,
4975        aPrefix: *mut otIp6Prefix,
4976    ) -> otError;
4977}
4978extern "C" {
4979    #[doc = " Gets the currently favored On-Link Prefix.\n\n The favored prefix is either a discovered on-link prefix on the infrastructure link or the local on-link prefix.\n\n @param[in]   aInstance  A pointer to an OpenThread instance.\n @param[out]  aPrefix    A pointer to where the prefix will be output to.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the favored on-link prefix."]
4980    pub fn otBorderRoutingGetFavoredOnLinkPrefix(
4981        aInstance: *mut otInstance,
4982        aPrefix: *mut otIp6Prefix,
4983    ) -> otError;
4984}
4985extern "C" {
4986    #[doc = " Gets the local NAT64 Prefix of the Border Router.\n\n NAT64 Prefix might not be advertised in the Thread network.\n\n `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` must be enabled.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n @param[out]  aPrefix     A pointer to where the prefix will be output to.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the NAT64 prefix."]
4987    pub fn otBorderRoutingGetNat64Prefix(
4988        aInstance: *mut otInstance,
4989        aPrefix: *mut otIp6Prefix,
4990    ) -> otError;
4991}
4992extern "C" {
4993    #[doc = " Gets the currently favored NAT64 prefix.\n\n The favored NAT64 prefix can be discovered from infrastructure link or can be this device's local NAT64 prefix.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aPrefix      A pointer to output the favored NAT64 prefix.\n @param[out]  aPreference  A pointer to output the preference associated the favored prefix.\n\n @retval  OT_ERROR_INVALID_STATE  The Border Routing Manager is not initialized yet.\n @retval  OT_ERROR_NONE           Successfully retrieved the favored NAT64 prefix."]
4994    pub fn otBorderRoutingGetFavoredNat64Prefix(
4995        aInstance: *mut otInstance,
4996        aPrefix: *mut otIp6Prefix,
4997        aPreference: *mut otRoutePreference,
4998    ) -> otError;
4999}
5000extern "C" {
5001    #[doc = " Initializes an `otBorderRoutingPrefixTableIterator`.\n\n An iterator MUST be initialized before it is used.\n\n An iterator can be initialized again to restart from the beginning of the table.\n\n When iterating over entries in the table, to ensure the update times `mMsecSinceLastUpdate` of entries are\n consistent, they are given relative to the time the iterator was initialized.\n\n @param[in]  aInstance  The OpenThread instance.\n @param[out] aIterator  A pointer to the iterator to initialize."]
5002    pub fn otBorderRoutingPrefixTableInitIterator(
5003        aInstance: *mut otInstance,
5004        aIterator: *mut otBorderRoutingPrefixTableIterator,
5005    );
5006}
5007extern "C" {
5008    #[doc = " Iterates over the entries in the Border Router's discovered prefix table.\n\n Prefix entries associated with the same discovered router on an infrastructure link are guaranteed to be grouped\n together (retrieved back-to-back).\n\n @param[in]     aInstance    The OpenThread instance.\n @param[in,out] aIterator    A pointer to the iterator.\n @param[out]    aEntry       A pointer to the entry to populate.\n\n @retval OT_ERROR_NONE        Iterated to the next entry, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND   No more entries in the table."]
5009    pub fn otBorderRoutingGetNextPrefixTableEntry(
5010        aInstance: *mut otInstance,
5011        aIterator: *mut otBorderRoutingPrefixTableIterator,
5012        aEntry: *mut otBorderRoutingPrefixTableEntry,
5013    ) -> otError;
5014}
5015extern "C" {
5016    #[doc = " Iterates over the discovered router entries on the infrastructure link.\n\n @param[in]     aInstance    The OpenThread instance.\n @param[in,out] aIterator    A pointer to the iterator.\n @param[out]    aEntry       A pointer to the entry to populate.\n\n @retval OT_ERROR_NONE        Iterated to the next router, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND   No more router entries."]
5017    pub fn otBorderRoutingGetNextRouterEntry(
5018        aInstance: *mut otInstance,
5019        aIterator: *mut otBorderRoutingPrefixTableIterator,
5020        aEntry: *mut otBorderRoutingRouterEntry,
5021    ) -> otError;
5022}
5023extern "C" {
5024    #[doc = " Iterates over the peer BRs found in the Network Data.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`.\n\n Peer BRs are other devices within the Thread mesh that provide external IP connectivity. A device is considered\n to provide external IP connectivity if at least one of the following conditions is met regarding its Network Data\n entries:\n\n - It has added at least one external route entry.\n - It has added at least one prefix entry with both the default-route and on-mesh flags set.\n - It has added at least one domain prefix (with both the domain and on-mesh flags set).\n\n The list of peer BRs specifically excludes the current device, even if it is itself acting as a BR.\n\n @param[in]     aInstance    The OpenThread instance.\n @param[in,out] aIterator    A pointer to the iterator.\n @param[out]    aEntry       A pointer to the entry to populate.\n\n @retval OT_ERROR_NONE        Iterated to the next entry, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND   No more entries."]
5025    pub fn otBorderRoutingGetNextPeerBrEntry(
5026        aInstance: *mut otInstance,
5027        aIterator: *mut otBorderRoutingPrefixTableIterator,
5028        aEntry: *mut otBorderRoutingPeerBorderRouterEntry,
5029    ) -> otError;
5030}
5031extern "C" {
5032    #[doc = " Returns the number of peer BRs found in the Network Data.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`.\n\n Peer BRs are other devices within the Thread mesh that provide external IP connectivity. A device is considered\n to provide external IP connectivity if at least one of the following conditions is met regarding its Network Data\n entries:\n\n - It has added at least one external route entry.\n - It has added at least one prefix entry with both the default-route and on-mesh flags set.\n - It has added at least one domain prefix (with both the domain and on-mesh flags set).\n\n The list of peer BRs specifically excludes the current device, even if it is itself acting as a BR.\n\n @param[in]  aInstance    The OpenThread instance.\n @param[out] aMinAge      Pointer to an `uint32_t` to return the minimum age among all peer BRs.\n                          Can be NULL if the caller does not need this information.\n                          Age is represented as seconds since appearance of the BR entry in the Network Data.\n\n @returns The number of peer BRs."]
5033    pub fn otBorderRoutingCountPeerBrs(aInstance: *mut otInstance, aMinAge: *mut u32) -> u16;
5034}
5035extern "C" {
5036    #[doc = " Enables / Disables DHCPv6 Prefix Delegation.\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled  Whether to accept platform generated RA messages."]
5037    pub fn otBorderRoutingDhcp6PdSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
5038}
5039extern "C" {
5040    #[doc = " Gets the current state of DHCPv6 Prefix Delegation.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` to be enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The current state of DHCPv6 Prefix Delegation."]
5041    pub fn otBorderRoutingDhcp6PdGetState(
5042        aInstance: *mut otInstance,
5043    ) -> otBorderRoutingDhcp6PdState;
5044}
5045#[doc = " When the state of a DHCPv6 Prefix Delegation (PD) on the Thread interface changes, this callback notifies processes\n in the OS of this changed state.\n\n @param[in] aState    The state of DHCPv6 Prefix Delegation State.\n @param[in] aContext  A pointer to arbitrary context information."]
5046pub type otBorderRoutingRequestDhcp6PdCallback = ::std::option::Option<
5047    unsafe extern "C" fn(
5048        aState: otBorderRoutingDhcp6PdState,
5049        aContext: *mut ::std::os::raw::c_void,
5050    ),
5051>;
5052extern "C" {
5053    #[doc = " Sets the callback whenever the DHCPv6 PD state changes on the Thread interface.\n\n Subsequent calls to this function replace the previously set callback.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  A pointer to a function that is called whenever the DHCPv6 PD state changes.\n @param[in] aContext   A pointer to arbitrary context information."]
5054    pub fn otBorderRoutingDhcp6PdSetRequestCallback(
5055        aInstance: *mut otInstance,
5056        aCallback: otBorderRoutingRequestDhcp6PdCallback,
5057        aContext: *mut ::std::os::raw::c_void,
5058    );
5059}
5060extern "C" {
5061    #[doc = " Sets the local on-link prefix.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TESTING_API_ENABLE`.\n\n This is intended for testing only and using it will make the BR non-compliant with the Thread Specification.\n\n @param[in]  aPrefix      The on-link prefix to use."]
5062    pub fn otBorderRoutingSetOnLinkPrefix(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix);
5063}
5064extern "C" {
5065    #[doc = " Provides a full or stable copy of the local Thread Network Data.\n\n @param[in]      aInstance    A pointer to an OpenThread instance.\n @param[in]      aStable      TRUE when copying the stable version, FALSE when copying the full version.\n @param[out]     aData        A pointer to the data buffer.\n @param[in,out]  aDataLength  On entry, size of the data buffer pointed to by @p aData.\n                              On exit, number of copied bytes."]
5066    pub fn otBorderRouterGetNetData(
5067        aInstance: *mut otInstance,
5068        aStable: bool,
5069        aData: *mut u8,
5070        aDataLength: *mut u8,
5071    ) -> otError;
5072}
5073extern "C" {
5074    #[doc = " Add a border router configuration to the local network data.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aConfig   A pointer to the border router configuration.\n\n @retval OT_ERROR_NONE          Successfully added the configuration to the local network data.\n @retval OT_ERROR_INVALID_ARGS  One or more configuration parameters were invalid.\n @retval OT_ERROR_NO_BUFS       Not enough room is available to add the configuration to the local network data.\n\n @sa otBorderRouterRemoveOnMeshPrefix\n @sa otBorderRouterRegister"]
5075    pub fn otBorderRouterAddOnMeshPrefix(
5076        aInstance: *mut otInstance,
5077        aConfig: *const otBorderRouterConfig,
5078    ) -> otError;
5079}
5080extern "C" {
5081    #[doc = " Remove a border router configuration from the local network data.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aPrefix   A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE       Successfully removed the configuration from the local network data.\n @retval OT_ERROR_NOT_FOUND  Could not find the Border Router entry.\n\n @sa otBorderRouterAddOnMeshPrefix\n @sa otBorderRouterRegister"]
5082    pub fn otBorderRouterRemoveOnMeshPrefix(
5083        aInstance: *mut otInstance,
5084        aPrefix: *const otIp6Prefix,
5085    ) -> otError;
5086}
5087extern "C" {
5088    #[doc = " Gets the next On Mesh Prefix in the local Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first on-mesh entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to the On Mesh Prefix information.\n\n @retval OT_ERROR_NONE       Successfully found the next On Mesh prefix.\n @retval OT_ERROR_NOT_FOUND  No subsequent On Mesh prefix exists in the Thread Network Data."]
5089    pub fn otBorderRouterGetNextOnMeshPrefix(
5090        aInstance: *mut otInstance,
5091        aIterator: *mut otNetworkDataIterator,
5092        aConfig: *mut otBorderRouterConfig,
5093    ) -> otError;
5094}
5095extern "C" {
5096    #[doc = " Add an external route configuration to the local network data.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aConfig   A pointer to the external route configuration.\n\n @retval OT_ERROR_NONE          Successfully added the configuration to the local network data.\n @retval OT_ERROR_INVALID_ARGS  One or more configuration parameters were invalid.\n @retval OT_ERROR_NO_BUFS       Not enough room is available to add the configuration to the local network data.\n\n @sa otBorderRouterRemoveRoute\n @sa otBorderRouterRegister"]
5097    pub fn otBorderRouterAddRoute(
5098        aInstance: *mut otInstance,
5099        aConfig: *const otExternalRouteConfig,
5100    ) -> otError;
5101}
5102extern "C" {
5103    #[doc = " Remove an external route configuration from the local network data.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aPrefix   A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE       Successfully removed the configuration from the local network data.\n @retval OT_ERROR_NOT_FOUND  Could not find the Border Router entry.\n\n @sa otBorderRouterAddRoute\n @sa otBorderRouterRegister"]
5104    pub fn otBorderRouterRemoveRoute(
5105        aInstance: *mut otInstance,
5106        aPrefix: *const otIp6Prefix,
5107    ) -> otError;
5108}
5109extern "C" {
5110    #[doc = " Gets the next external route in the local Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first external route entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to the External Route information.\n\n @retval OT_ERROR_NONE       Successfully found the next External Route.\n @retval OT_ERROR_NOT_FOUND  No subsequent external route entry exists in the Thread Network Data."]
5111    pub fn otBorderRouterGetNextRoute(
5112        aInstance: *mut otInstance,
5113        aIterator: *mut otNetworkDataIterator,
5114        aConfig: *mut otExternalRouteConfig,
5115    ) -> otError;
5116}
5117extern "C" {
5118    #[doc = " Immediately register the local network data with the Leader.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE  Successfully queued a Server Data Request message for delivery.\n\n @sa otBorderRouterAddOnMeshPrefix\n @sa otBorderRouterRemoveOnMeshPrefix\n @sa otBorderRouterAddRoute\n @sa otBorderRouterRemoveRoute"]
5119    pub fn otBorderRouterRegister(aInstance: *mut otInstance) -> otError;
5120}
5121#[doc = " Function pointer callback which is invoked when Network Data (local or leader) gets full.\n\n @param[in] aContext A pointer to arbitrary context information."]
5122pub type otBorderRouterNetDataFullCallback =
5123    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5124extern "C" {
5125    #[doc = " Sets the callback to indicate when Network Data gets full.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTER_SIGNAL_NETWORK_DATA_FULL`.\n\n The callback is invoked whenever:\n - The device is acting as a leader and receives a Network Data registration from a Border Router (BR) that it cannot\n   add to Network Data (running out of space).\n - The device is acting as a BR and new entries cannot be added to its local Network Data.\n - The device is acting as a BR and tries to register its local Network Data entries with the leader, but determines\n    that its local entries will not fit.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aCallback    The callback.\n @param[in]  aContext     A pointer to arbitrary context information used with @p aCallback."]
5126    pub fn otBorderRouterSetNetDataFullCallback(
5127        aInstance: *mut otInstance,
5128        aCallback: otBorderRouterNetDataFullCallback,
5129        aContext: *mut ::std::os::raw::c_void,
5130    );
5131}
5132extern "C" {
5133    #[doc = " Requests a Thread network channel change.\n\n The network switches to the given channel after a specified delay (see #otChannelManagerSetDelay()). The channel\n change is performed by updating the Pending Operational Dataset.\n\n A subsequent call will cancel an ongoing previously requested channel change.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aChannel           The new channel for the Thread network."]
5134    pub fn otChannelManagerRequestChannelChange(aInstance: *mut otInstance, aChannel: u8);
5135}
5136extern "C" {
5137    #[doc = " Gets the channel from the last successful call to `otChannelManagerRequestChannelChange()`\n\n @returns The last requested channel or zero if there has been no channel change request yet."]
5138    pub fn otChannelManagerGetRequestedChannel(aInstance: *mut otInstance) -> u8;
5139}
5140extern "C" {
5141    #[doc = " Gets the delay (in seconds) used by Channel Manager for a network channel change.\n\n Only available on FTDs.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n\n @returns The delay (in seconds) for channel change."]
5142    pub fn otChannelManagerGetDelay(aInstance: *mut otInstance) -> u16;
5143}
5144extern "C" {
5145    #[doc = " Sets the delay (in seconds) used for a network channel change.\n\n Only available on FTDs. The delay should preferably be longer than the maximum data poll interval used by all\n Sleepy End Devices within the Thread network.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aDelay             Delay in seconds.\n\n @retval OT_ERROR_NONE          Delay was updated successfully.\n @retval OT_ERROR_INVALID_ARGS  The given delay @p aDelay is too short."]
5146    pub fn otChannelManagerSetDelay(aInstance: *mut otInstance, aDelay: u16) -> otError;
5147}
5148extern "C" {
5149    #[doc = " Requests that `ChannelManager` checks and selects a new channel and starts a channel change.\n\n Unlike the `otChannelManagerRequestChannelChange()` where the channel must be given as a parameter, this function\n asks the `ChannelManager` to select a channel by itself (based on collected channel quality info).\n\n Once called, the Channel Manager will perform the following 3 steps:\n\n 1) `ChannelManager` decides if the channel change would be helpful. This check can be skipped if\n    `aSkipQualityCheck` is set to true (forcing a channel selection to happen and skipping the quality check).\n    This step uses the collected link quality metrics on the device (such as CCA failure rate, frame and message\n    error rates per neighbor, etc.) to determine if the current channel quality is at the level that justifies\n    a channel change.\n\n 2) If the first step passes, then `ChannelManager` selects a potentially better channel. It uses the collected\n    channel quality data by `ChannelMonitor` module. The supported and favored channels are used at this step.\n    (see `otChannelManagerSetSupportedChannels()` and `otChannelManagerSetFavoredChannels()`).\n\n 3) If the newly selected channel is different from the current channel, `ChannelManager` requests/starts the\n    channel change process (internally invoking a `RequestChannelChange()`).\n\n @param[in] aInstance                A pointer to an OpenThread instance.\n @param[in] aSkipQualityCheck        Indicates whether the quality check (step 1) should be skipped.\n\n @retval OT_ERROR_NONE               Channel selection finished successfully.\n @retval OT_ERROR_NOT_FOUND          Supported channel mask is empty, therefore could not select a channel."]
5150    pub fn otChannelManagerRequestChannelSelect(
5151        aInstance: *mut otInstance,
5152        aSkipQualityCheck: bool,
5153    ) -> otError;
5154}
5155extern "C" {
5156    #[doc = " Requests that `ChannelManager` checks and selects a new CSL channel and starts a CSL channel change.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`. This function asks the `ChannelManager` to select a\n channel by itself (based on collected channel quality info).\n\n Once called, the Channel Manager will perform the following 3 steps:\n\n 1) `ChannelManager` decides if the CSL channel change would be helpful. This check can be skipped if\n    `aSkipQualityCheck` is set to true (forcing a CSL channel selection to happen and skipping the quality check).\n    This step uses the collected link quality metrics on the device (such as CCA failure rate, frame and message\n    error rates per neighbor, etc.) to determine if the current channel quality is at the level that justifies\n    a CSL channel change.\n\n 2) If the first step passes, then `ChannelManager` selects a potentially better CSL channel. It uses the collected\n    channel quality data by `ChannelMonitor` module. The supported and favored channels are used at this step.\n    (see `otChannelManagerSetSupportedChannels()` and `otChannelManagerSetFavoredChannels()`).\n\n 3) If the newly selected CSL channel is different from the current CSL channel, `ChannelManager` starts the\n    CSL channel change process.\n\n @param[in] aInstance                A pointer to an OpenThread instance.\n @param[in] aSkipQualityCheck        Indicates whether the quality check (step 1) should be skipped.\n\n @retval OT_ERROR_NONE               Channel selection finished successfully.\n @retval OT_ERROR_NOT_FOUND          Supported channel mask is empty, therefore could not select a channel."]
5157    pub fn otChannelManagerRequestCslChannelSelect(
5158        aInstance: *mut otInstance,
5159        aSkipQualityCheck: bool,
5160    ) -> otError;
5161}
5162extern "C" {
5163    #[doc = " Enables or disables the auto-channel-selection functionality for network channel.\n\n When enabled, `ChannelManager` will periodically invoke a `RequestChannelSelect(false)`. The period interval\n can be set by `otChannelManagerSetAutoChannelSelectionInterval()`.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aEnabled     Indicates whether to enable or disable this functionality."]
5164    pub fn otChannelManagerSetAutoChannelSelectionEnabled(
5165        aInstance: *mut otInstance,
5166        aEnabled: bool,
5167    );
5168}
5169extern "C" {
5170    #[doc = " Indicates whether the auto-channel-selection functionality for a network channel is enabled or not.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns TRUE if enabled, FALSE if disabled."]
5171    pub fn otChannelManagerGetAutoChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5172}
5173extern "C" {
5174    #[doc = " Enables or disables the auto-channel-selection functionality for a CSL channel.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`. When enabled, `ChannelManager` will periodically invoke\n a `otChannelManagerRequestCslChannelSelect()`. The period interval can be set by\n `otChannelManagerSetAutoChannelSelectionInterval()`.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aEnabled     Indicates whether to enable or disable this functionality."]
5175    pub fn otChannelManagerSetAutoCslChannelSelectionEnabled(
5176        aInstance: *mut otInstance,
5177        aEnabled: bool,
5178    );
5179}
5180extern "C" {
5181    #[doc = " Indicates whether the auto-csl-channel-selection functionality is enabled or not.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns TRUE if enabled, FALSE if disabled."]
5182    pub fn otChannelManagerGetAutoCslChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5183}
5184extern "C" {
5185    #[doc = " Sets the period interval (in seconds) used by auto-channel-selection functionality.\n\n @param[in] aInstance   A pointer to an OpenThread instance.\n @param[in] aInterval   The interval in seconds.\n\n @retval OT_ERROR_NONE           The interval was set successfully.\n @retval OT_ERROR_INVALID_ARGS   The @p aInterval is not valid (zero)."]
5186    pub fn otChannelManagerSetAutoChannelSelectionInterval(
5187        aInstance: *mut otInstance,
5188        aInterval: u32,
5189    ) -> otError;
5190}
5191extern "C" {
5192    #[doc = " Gets the period interval (in seconds) used by auto-channel-selection functionality.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns The interval in seconds."]
5193    pub fn otChannelManagerGetAutoChannelSelectionInterval(aInstance: *mut otInstance) -> u32;
5194}
5195extern "C" {
5196    #[doc = " Gets the supported channel mask.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The supported channels as a bit-mask."]
5197    pub fn otChannelManagerGetSupportedChannels(aInstance: *mut otInstance) -> u32;
5198}
5199extern "C" {
5200    #[doc = " Sets the supported channel mask.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aChannelMask  A channel mask."]
5201    pub fn otChannelManagerSetSupportedChannels(aInstance: *mut otInstance, aChannelMask: u32);
5202}
5203extern "C" {
5204    #[doc = " Gets the favored channel mask.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The favored channels as a bit-mask."]
5205    pub fn otChannelManagerGetFavoredChannels(aInstance: *mut otInstance) -> u32;
5206}
5207extern "C" {
5208    #[doc = " Sets the favored channel mask.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aChannelMask  A channel mask."]
5209    pub fn otChannelManagerSetFavoredChannels(aInstance: *mut otInstance, aChannelMask: u32);
5210}
5211extern "C" {
5212    #[doc = " Gets the CCA failure rate threshold.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n\n @returns  The CCA failure rate threshold. Value 0 maps to 0% and 0xffff maps to 100%."]
5213    pub fn otChannelManagerGetCcaFailureRateThreshold(aInstance: *mut otInstance) -> u16;
5214}
5215extern "C" {
5216    #[doc = " Sets the CCA failure rate threshold.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aThreshold    A CCA failure rate threshold. Value 0 maps to 0% and 0xffff maps to 100%."]
5217    pub fn otChannelManagerSetCcaFailureRateThreshold(aInstance: *mut otInstance, aThreshold: u16);
5218}
5219extern "C" {
5220    #[doc = " Enables or disables the Channel Monitoring operation.\n\n Once operation starts, any previously collected data is cleared. However, after operation is disabled, the previous\n collected data is still valid and can be read.\n\n @note OpenThread core internally enables or disables the Channel Monitoring operation when the IPv6 interface is\n brought up or down, for example in a call to `otIp6SetEnabled()`.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aEnabled        TRUE to enable/start Channel Monitoring operation, FALSE to disable/stop it.\n\n @retval OT_ERROR_NONE      Channel Monitoring state changed successfully\n @retval OT_ERROR_ALREADY   Channel Monitoring is already in the same state."]
5221    pub fn otChannelMonitorSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
5222}
5223extern "C" {
5224    #[doc = " Indicates whether the Channel Monitoring operation is enabled and running.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns TRUE if the Channel Monitoring operation is enabled, FALSE otherwise."]
5225    pub fn otChannelMonitorIsEnabled(aInstance: *mut otInstance) -> bool;
5226}
5227extern "C" {
5228    #[doc = " Get channel monitoring sample interval in milliseconds.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The channel monitor sample interval in milliseconds."]
5229    pub fn otChannelMonitorGetSampleInterval(aInstance: *mut otInstance) -> u32;
5230}
5231extern "C" {
5232    #[doc = " Get channel monitoring RSSI threshold in dBm.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The RSSI threshold in dBm."]
5233    pub fn otChannelMonitorGetRssiThreshold(aInstance: *mut otInstance) -> i8;
5234}
5235extern "C" {
5236    #[doc = " Get channel monitoring averaging sample window length (number of samples).\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The averaging sample window."]
5237    pub fn otChannelMonitorGetSampleWindow(aInstance: *mut otInstance) -> u32;
5238}
5239extern "C" {
5240    #[doc = " Get channel monitoring total number of RSSI samples (per channel).\n\n The count indicates total number samples per channel by channel monitoring module since its start (since Thread\n network interface was enabled).\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  Total number of RSSI samples (per channel) taken so far."]
5241    pub fn otChannelMonitorGetSampleCount(aInstance: *mut otInstance) -> u32;
5242}
5243extern "C" {
5244    #[doc = " Gets the current channel occupancy for a given channel.\n\n The channel occupancy value represents the average rate/percentage of RSSI samples that were above RSSI threshold\n (\"bad\" RSSI samples).\n\n For the first \"sample window\" samples, the average is maintained as the actual percentage (i.e., ratio of number\n of \"bad\" samples by total number of samples). After \"window\" samples, the averager uses an exponentially\n weighted moving average. Practically, this means the average is representative of up to `3 * window` last samples\n with highest weight given to the latest `kSampleWindow` samples.\n\n Max value of `0xffff` indicates all RSSI samples were above RSSI threshold (i.e. 100% of samples were \"bad\").\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aChannel        The channel for which to get the link occupancy.\n\n @returns The current channel occupancy for the given channel."]
5245    pub fn otChannelMonitorGetChannelOccupancy(aInstance: *mut otInstance, aChannel: u8) -> u16;
5246}
5247extern "C" {
5248    #[doc = " Gets the Child Supervision interval (in seconds) on a child.\n\n Child Supervision feature provides a mechanism for parent to ensure that a message is sent to each sleepy child\n within the supervision interval. If there is no transmission to the child within the supervision interval, OpenThread\n enqueues and sends a Child Supervision Message to the child.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The child supervision interval. Zero indicates that supervision is disabled."]
5249    pub fn otChildSupervisionGetInterval(aInstance: *mut otInstance) -> u16;
5250}
5251extern "C" {
5252    #[doc = " Sets the child supervision interval (in seconds) on the child.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aInterval       The supervision interval (in seconds). Zero to disable supervision."]
5253    pub fn otChildSupervisionSetInterval(aInstance: *mut otInstance, aInterval: u16);
5254}
5255extern "C" {
5256    #[doc = " Gets the supervision check timeout interval (in seconds) on the child.\n\n If the device is a sleepy child and it does not hear from its parent within the specified check timeout, it initiates\n the re-attach process (MLE Child Update Request/Response exchange with its parent).\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n\n @returns  The supervision check timeout. Zero indicates that supervision check on the child is disabled."]
5257    pub fn otChildSupervisionGetCheckTimeout(aInstance: *mut otInstance) -> u16;
5258}
5259extern "C" {
5260    #[doc = " Sets the supervision check timeout interval (in seconds) on the child.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aTimeout        The check timeout (in seconds). Zero to disable supervision check on the child."]
5261    pub fn otChildSupervisionSetCheckTimeout(aInstance: *mut otInstance, aTimeout: u16);
5262}
5263extern "C" {
5264    #[doc = " Get the value of supervision check timeout failure counter.\n\n The counter tracks the number of supervision check failures on the child. It is incremented when the child does\n not hear from its parent within the specified check timeout interval."]
5265    pub fn otChildSupervisionGetCheckFailureCounter(aInstance: *mut otInstance) -> u16;
5266}
5267extern "C" {
5268    #[doc = " Reset the supervision check timeout failure counter to zero."]
5269    pub fn otChildSupervisionResetCheckFailureCounter(aInstance: *mut otInstance);
5270}
5271#[doc = " Represents a CLI command."]
5272#[repr(C)]
5273#[derive(Debug, Copy, Clone)]
5274pub struct otCliCommand {
5275    #[doc = "< A pointer to the command string."]
5276    pub mName: *const ::std::os::raw::c_char,
5277    pub mCommand: ::std::option::Option<
5278        unsafe extern "C" fn(
5279            aContext: *mut ::std::os::raw::c_void,
5280            aArgsLength: u8,
5281            aArgs: *mut *mut ::std::os::raw::c_char,
5282        ) -> otError,
5283    >,
5284}
5285impl Default for otCliCommand {
5286    fn default() -> Self {
5287        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5288        unsafe {
5289            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5290            s.assume_init()
5291        }
5292    }
5293}
5294#[doc = " Pointer is called to notify about Console output.\n\n @param[out] aContext    A user context pointer.\n @param[in]  aFormat     The format string.\n @param[in]  aArguments  The format string arguments.\n\n @returns                Number of bytes written by the callback."]
5295pub type otCliOutputCallback = ::std::option::Option<
5296    unsafe extern "C" fn(
5297        aContext: *mut ::std::os::raw::c_void,
5298        aFormat: *const ::std::os::raw::c_char,
5299        aArguments: *mut __va_list_tag,
5300    ) -> ::std::os::raw::c_int,
5301>;
5302extern "C" {
5303    #[doc = " Initialize the CLI module.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aCallback   A callback method called to process CLI output.\n @param[in]  aContext    A user context pointer."]
5304    pub fn otCliInit(
5305        aInstance: *mut otInstance,
5306        aCallback: otCliOutputCallback,
5307        aContext: *mut ::std::os::raw::c_void,
5308    );
5309}
5310extern "C" {
5311    #[doc = " Is called to feed in a console input line.\n\n @param[in]  aBuf        A pointer to a null-terminated string."]
5312    pub fn otCliInputLine(aBuf: *mut ::std::os::raw::c_char);
5313}
5314extern "C" {
5315    #[doc = " Set a user command table.\n\n @param[in]  aUserCommands  A pointer to an array with user commands.\n @param[in]  aLength        @p aUserCommands length.\n @param[in]  aContext       @p The context passed to the handler.\n\n @retval OT_ERROR_NONE    Successfully updated command table with commands from @p aUserCommands.\n @retval OT_ERROR_FAILED  Maximum number of command entries have already been set."]
5316    pub fn otCliSetUserCommands(
5317        aUserCommands: *const otCliCommand,
5318        aLength: u8,
5319        aContext: *mut ::std::os::raw::c_void,
5320    ) -> otError;
5321}
5322extern "C" {
5323    #[doc = " Write a number of bytes to the CLI console as a hex string.\n\n @param[in]  aBytes   A pointer to data which should be printed.\n @param[in]  aLength  @p aBytes length."]
5324    pub fn otCliOutputBytes(aBytes: *const u8, aLength: u8);
5325}
5326extern "C" {
5327    #[doc = " Write formatted string to the CLI console\n\n @param[in]  aFmt   A pointer to the format string.\n @param[in]  ...    A matching list of arguments."]
5328    pub fn otCliOutputFormat(aFmt: *const ::std::os::raw::c_char, ...);
5329}
5330extern "C" {
5331    #[doc = " Write error code to the CLI console\n\n If the @p aError is `OT_ERROR_PENDING` nothing will be outputted.\n\n @param[in]  aError Error code value."]
5332    pub fn otCliAppendResult(aError: otError);
5333}
5334extern "C" {
5335    #[doc = " Callback to write the OpenThread Log to the CLI console\n\n @param[in]  aLogLevel   The log level.\n @param[in]  aLogRegion  The log region.\n @param[in]  aFormat     A pointer to the format string.\n @param[in]  aArgs       va_list matching aFormat."]
5336    pub fn otCliPlatLogv(
5337        aLogLevel: otLogLevel,
5338        aLogRegion: otLogRegion,
5339        aFormat: *const ::std::os::raw::c_char,
5340        aArgs: *mut __va_list_tag,
5341    );
5342}
5343extern "C" {
5344    #[doc = " Callback to allow vendor specific commands to be added to the user command table.\n\n Available when `OPENTHREAD_CONFIG_CLI_VENDOR_COMMANDS_ENABLE` is enabled and\n `OPENTHREAD_CONFIG_CLI_MAX_USER_CMD_ENTRIES` is greater than 1."]
5345    pub fn otCliVendorSetUserCommands();
5346}
5347#[doc = "< Confirmable"]
5348pub const OT_COAP_TYPE_CONFIRMABLE: otCoapType = 0;
5349#[doc = "< Non-confirmable"]
5350pub const OT_COAP_TYPE_NON_CONFIRMABLE: otCoapType = 1;
5351#[doc = "< Acknowledgment"]
5352pub const OT_COAP_TYPE_ACKNOWLEDGMENT: otCoapType = 2;
5353#[doc = "< Reset"]
5354pub const OT_COAP_TYPE_RESET: otCoapType = 3;
5355#[doc = " CoAP Type values (2 bit unsigned integer)."]
5356pub type otCoapType = ::std::os::raw::c_uint;
5357#[doc = "< Empty message code"]
5358pub const OT_COAP_CODE_EMPTY: otCoapCode = 0;
5359#[doc = "< Get"]
5360pub const OT_COAP_CODE_GET: otCoapCode = 1;
5361#[doc = "< Post"]
5362pub const OT_COAP_CODE_POST: otCoapCode = 2;
5363#[doc = "< Put"]
5364pub const OT_COAP_CODE_PUT: otCoapCode = 3;
5365#[doc = "< Delete"]
5366pub const OT_COAP_CODE_DELETE: otCoapCode = 4;
5367#[doc = "< 2.00"]
5368pub const OT_COAP_CODE_RESPONSE_MIN: otCoapCode = 64;
5369#[doc = "< Created"]
5370pub const OT_COAP_CODE_CREATED: otCoapCode = 65;
5371#[doc = "< Deleted"]
5372pub const OT_COAP_CODE_DELETED: otCoapCode = 66;
5373#[doc = "< Valid"]
5374pub const OT_COAP_CODE_VALID: otCoapCode = 67;
5375#[doc = "< Changed"]
5376pub const OT_COAP_CODE_CHANGED: otCoapCode = 68;
5377#[doc = "< Content"]
5378pub const OT_COAP_CODE_CONTENT: otCoapCode = 69;
5379#[doc = "< RFC7959 Continue"]
5380pub const OT_COAP_CODE_CONTINUE: otCoapCode = 95;
5381#[doc = "< Bad Request"]
5382pub const OT_COAP_CODE_BAD_REQUEST: otCoapCode = 128;
5383#[doc = "< Unauthorized"]
5384pub const OT_COAP_CODE_UNAUTHORIZED: otCoapCode = 129;
5385#[doc = "< Bad Option"]
5386pub const OT_COAP_CODE_BAD_OPTION: otCoapCode = 130;
5387#[doc = "< Forbidden"]
5388pub const OT_COAP_CODE_FORBIDDEN: otCoapCode = 131;
5389#[doc = "< Not Found"]
5390pub const OT_COAP_CODE_NOT_FOUND: otCoapCode = 132;
5391#[doc = "< Method Not Allowed"]
5392pub const OT_COAP_CODE_METHOD_NOT_ALLOWED: otCoapCode = 133;
5393#[doc = "< Not Acceptable"]
5394pub const OT_COAP_CODE_NOT_ACCEPTABLE: otCoapCode = 134;
5395#[doc = "< RFC7959 Request Entity Incomplete"]
5396pub const OT_COAP_CODE_REQUEST_INCOMPLETE: otCoapCode = 136;
5397#[doc = "< Precondition Failed"]
5398pub const OT_COAP_CODE_PRECONDITION_FAILED: otCoapCode = 140;
5399#[doc = "< Request Entity Too Large"]
5400pub const OT_COAP_CODE_REQUEST_TOO_LARGE: otCoapCode = 141;
5401#[doc = "< Unsupported Content-Format"]
5402pub const OT_COAP_CODE_UNSUPPORTED_FORMAT: otCoapCode = 143;
5403#[doc = "< Internal Server Error"]
5404pub const OT_COAP_CODE_INTERNAL_ERROR: otCoapCode = 160;
5405#[doc = "< Not Implemented"]
5406pub const OT_COAP_CODE_NOT_IMPLEMENTED: otCoapCode = 161;
5407#[doc = "< Bad Gateway"]
5408pub const OT_COAP_CODE_BAD_GATEWAY: otCoapCode = 162;
5409#[doc = "< Service Unavailable"]
5410pub const OT_COAP_CODE_SERVICE_UNAVAILABLE: otCoapCode = 163;
5411#[doc = "< Gateway Timeout"]
5412pub const OT_COAP_CODE_GATEWAY_TIMEOUT: otCoapCode = 164;
5413#[doc = "< Proxying Not Supported"]
5414pub const OT_COAP_CODE_PROXY_NOT_SUPPORTED: otCoapCode = 165;
5415#[doc = " CoAP Code values."]
5416pub type otCoapCode = ::std::os::raw::c_uint;
5417#[doc = "< If-Match"]
5418pub const OT_COAP_OPTION_IF_MATCH: otCoapOptionType = 1;
5419#[doc = "< Uri-Host"]
5420pub const OT_COAP_OPTION_URI_HOST: otCoapOptionType = 3;
5421#[doc = "< ETag"]
5422pub const OT_COAP_OPTION_E_TAG: otCoapOptionType = 4;
5423#[doc = "< If-None-Match"]
5424pub const OT_COAP_OPTION_IF_NONE_MATCH: otCoapOptionType = 5;
5425#[doc = "< Observe [RFC7641]"]
5426pub const OT_COAP_OPTION_OBSERVE: otCoapOptionType = 6;
5427#[doc = "< Uri-Port"]
5428pub const OT_COAP_OPTION_URI_PORT: otCoapOptionType = 7;
5429#[doc = "< Location-Path"]
5430pub const OT_COAP_OPTION_LOCATION_PATH: otCoapOptionType = 8;
5431#[doc = "< Uri-Path"]
5432pub const OT_COAP_OPTION_URI_PATH: otCoapOptionType = 11;
5433#[doc = "< Content-Format"]
5434pub const OT_COAP_OPTION_CONTENT_FORMAT: otCoapOptionType = 12;
5435#[doc = "< Max-Age"]
5436pub const OT_COAP_OPTION_MAX_AGE: otCoapOptionType = 14;
5437#[doc = "< Uri-Query"]
5438pub const OT_COAP_OPTION_URI_QUERY: otCoapOptionType = 15;
5439#[doc = "< Accept"]
5440pub const OT_COAP_OPTION_ACCEPT: otCoapOptionType = 17;
5441#[doc = "< Location-Query"]
5442pub const OT_COAP_OPTION_LOCATION_QUERY: otCoapOptionType = 20;
5443#[doc = "< Block2 (RFC7959)"]
5444pub const OT_COAP_OPTION_BLOCK2: otCoapOptionType = 23;
5445#[doc = "< Block1 (RFC7959)"]
5446pub const OT_COAP_OPTION_BLOCK1: otCoapOptionType = 27;
5447#[doc = "< Size2 (RFC7959)"]
5448pub const OT_COAP_OPTION_SIZE2: otCoapOptionType = 28;
5449#[doc = "< Proxy-Uri"]
5450pub const OT_COAP_OPTION_PROXY_URI: otCoapOptionType = 35;
5451#[doc = "< Proxy-Scheme"]
5452pub const OT_COAP_OPTION_PROXY_SCHEME: otCoapOptionType = 39;
5453#[doc = "< Size1"]
5454pub const OT_COAP_OPTION_SIZE1: otCoapOptionType = 60;
5455#[doc = " CoAP Option Numbers"]
5456pub type otCoapOptionType = ::std::os::raw::c_uint;
5457#[doc = " Represents a CoAP option."]
5458#[repr(C)]
5459#[derive(Debug, Default, Copy, Clone)]
5460pub struct otCoapOption {
5461    #[doc = "< Option Number"]
5462    pub mNumber: u16,
5463    #[doc = "< Option Length"]
5464    pub mLength: u16,
5465}
5466#[doc = " Acts as an iterator for CoAP options"]
5467#[repr(C)]
5468#[derive(Debug, Copy, Clone)]
5469pub struct otCoapOptionIterator {
5470    #[doc = "< CoAP message"]
5471    pub mMessage: *const otMessage,
5472    #[doc = "< CoAP message option"]
5473    pub mOption: otCoapOption,
5474    #[doc = "< Byte offset of next option"]
5475    pub mNextOptionOffset: u16,
5476}
5477impl Default for otCoapOptionIterator {
5478    fn default() -> Self {
5479        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5480        unsafe {
5481            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5482            s.assume_init()
5483        }
5484    }
5485}
5486#[doc = " text/plain; charset=utf-8: [RFC2046][RFC3676][RFC5147]"]
5487pub const OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN: otCoapOptionContentFormat = 0;
5488#[doc = " application/cose; cose-type=\"cose-encrypt0\": [RFC8152]"]
5489pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT0: otCoapOptionContentFormat = 16;
5490#[doc = " application/cose; cose-type=\"cose-mac0\": [RFC8152]"]
5491pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC0: otCoapOptionContentFormat = 17;
5492#[doc = " application/cose; cose-type=\"cose-sign1\": [RFC8152]"]
5493pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN1: otCoapOptionContentFormat = 18;
5494#[doc = " application/link-format: [RFC6690]"]
5495pub const OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT: otCoapOptionContentFormat = 40;
5496#[doc = " application/xml: [RFC3023]"]
5497pub const OT_COAP_OPTION_CONTENT_FORMAT_XML: otCoapOptionContentFormat = 41;
5498#[doc = " application/octet-stream: [RFC2045][RFC2046]"]
5499pub const OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM: otCoapOptionContentFormat = 42;
5500#[doc = " application/exi:\n [\"Efficient XML Interchange (EXI) Format 1.0 (Second Edition)\", February 2014]"]
5501pub const OT_COAP_OPTION_CONTENT_FORMAT_EXI: otCoapOptionContentFormat = 47;
5502#[doc = " application/json: [RFC7159]"]
5503pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON: otCoapOptionContentFormat = 50;
5504#[doc = " application/json-patch+json: [RFC6902]"]
5505pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON_PATCH_JSON: otCoapOptionContentFormat = 51;
5506#[doc = " application/merge-patch+json: [RFC7396]"]
5507pub const OT_COAP_OPTION_CONTENT_FORMAT_MERGE_PATCH_JSON: otCoapOptionContentFormat = 52;
5508#[doc = " application/cbor: [RFC7049]"]
5509pub const OT_COAP_OPTION_CONTENT_FORMAT_CBOR: otCoapOptionContentFormat = 60;
5510#[doc = " application/cwt: [RFC8392]"]
5511pub const OT_COAP_OPTION_CONTENT_FORMAT_CWT: otCoapOptionContentFormat = 61;
5512#[doc = " application/cose; cose-type=\"cose-encrypt\": [RFC8152]"]
5513pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT: otCoapOptionContentFormat = 96;
5514#[doc = " application/cose; cose-type=\"cose-mac\": [RFC8152]"]
5515pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC: otCoapOptionContentFormat = 97;
5516#[doc = " application/cose; cose-type=\"cose-sign\": [RFC8152]"]
5517pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN: otCoapOptionContentFormat = 98;
5518#[doc = " application/cose-key: [RFC8152]"]
5519pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY: otCoapOptionContentFormat = 101;
5520#[doc = " application/cose-key-set: [RFC8152]"]
5521pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY_SET: otCoapOptionContentFormat = 102;
5522#[doc = " application/senml+json: [RFC8428]"]
5523pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_JSON: otCoapOptionContentFormat = 110;
5524#[doc = " application/sensml+json: [RFC8428]"]
5525pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_JSON: otCoapOptionContentFormat = 111;
5526#[doc = " application/senml+cbor: [RFC8428]"]
5527pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_CBOR: otCoapOptionContentFormat = 112;
5528#[doc = " application/sensml+cbor: [RFC8428]"]
5529pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_CBOR: otCoapOptionContentFormat = 113;
5530#[doc = " application/senml-exi: [RFC8428]"]
5531pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_EXI: otCoapOptionContentFormat = 114;
5532#[doc = " application/sensml-exi: [RFC8428]"]
5533pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_EXI: otCoapOptionContentFormat = 115;
5534#[doc = " application/coap-group+json: [RFC7390]"]
5535pub const OT_COAP_OPTION_CONTENT_FORMAT_COAP_GROUP_JSON: otCoapOptionContentFormat = 256;
5536#[doc = " application/senml+xml: [RFC8428]"]
5537pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_XML: otCoapOptionContentFormat = 310;
5538#[doc = " application/sensml+xml: [RFC8428]"]
5539pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_XML: otCoapOptionContentFormat = 311;
5540#[doc = " CoAP Content Format codes.  The full list is documented at\n https://www.iana.org/assignments/core-parameters/core-parameters.xhtml#content-formats"]
5541pub type otCoapOptionContentFormat = ::std::os::raw::c_uint;
5542pub const OT_COAP_OPTION_BLOCK_SZX_16: otCoapBlockSzx = 0;
5543pub const OT_COAP_OPTION_BLOCK_SZX_32: otCoapBlockSzx = 1;
5544pub const OT_COAP_OPTION_BLOCK_SZX_64: otCoapBlockSzx = 2;
5545pub const OT_COAP_OPTION_BLOCK_SZX_128: otCoapBlockSzx = 3;
5546pub const OT_COAP_OPTION_BLOCK_SZX_256: otCoapBlockSzx = 4;
5547pub const OT_COAP_OPTION_BLOCK_SZX_512: otCoapBlockSzx = 5;
5548pub const OT_COAP_OPTION_BLOCK_SZX_1024: otCoapBlockSzx = 6;
5549#[doc = " CoAP Block Size Exponents"]
5550pub type otCoapBlockSzx = ::std::os::raw::c_uint;
5551#[doc = " Pointer is called when a CoAP response is received or on the request timeout.\n\n @param[in]  aContext      A pointer to application-specific context.\n @param[in]  aMessage      A pointer to the message buffer containing the response. NULL if no response was received.\n @param[in]  aMessageInfo  A pointer to the message info for @p aMessage. NULL if no response was received.\n @param[in]  aResult       A result of the CoAP transaction.\n\n @retval  OT_ERROR_NONE              A response was received successfully.\n @retval  OT_ERROR_ABORT             A CoAP transaction was reset by peer.\n @retval  OT_ERROR_RESPONSE_TIMEOUT  No response or acknowledgment received during timeout period."]
5552pub type otCoapResponseHandler = ::std::option::Option<
5553    unsafe extern "C" fn(
5554        aContext: *mut ::std::os::raw::c_void,
5555        aMessage: *mut otMessage,
5556        aMessageInfo: *const otMessageInfo,
5557        aResult: otError,
5558    ),
5559>;
5560#[doc = " Pointer is called when a CoAP request with a given Uri-Path is received.\n\n @param[in]  aContext      A pointer to arbitrary context information.\n @param[in]  aMessage      A pointer to the message.\n @param[in]  aMessageInfo  A pointer to the message info for @p aMessage."]
5561pub type otCoapRequestHandler = ::std::option::Option<
5562    unsafe extern "C" fn(
5563        aContext: *mut ::std::os::raw::c_void,
5564        aMessage: *mut otMessage,
5565        aMessageInfo: *const otMessageInfo,
5566    ),
5567>;
5568#[doc = " Pointer is called when a CoAP message with a block-wise transfer option is received.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in]  aContext     A pointer to application-specific context.\n @param[in]  aBlock       A pointer to the block segment.\n @param[in]  aPosition    The position of @p aBlock in a sequence in bytes.\n @param[in]  aBlockLength The length of the block segment in bytes.\n @param[in]  aMore        Flag if more block segments are following.\n @param[in]  aTotalLength The total length in bytes of the transferred information (indicated by a Size1 or Size2\n                          option).\n\n @retval  OT_ERROR_NONE               Block segment was stored successfully.\n @retval  OT_ERROR_NO_BUFS            No more memory to store blocks.\n @retval  OT_ERROR_NO_FRAME_RECEIVED  Block segment missing."]
5569pub type otCoapBlockwiseReceiveHook = ::std::option::Option<
5570    unsafe extern "C" fn(
5571        aContext: *mut ::std::os::raw::c_void,
5572        aBlock: *const u8,
5573        aPosition: u32,
5574        aBlockLength: u16,
5575        aMore: bool,
5576        aTotalLength: u32,
5577    ) -> otError,
5578>;
5579#[doc = " Pointer is called before the next block in a block-wise transfer is sent.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in]       aContext     A pointer to application-specific context.\n @param[in,out]   aBlock       A pointer to where the block segment can be written to.\n @param[in]       aPosition    The position in a sequence from which to obtain the block segment.\n @param[in,out]   aBlockLength On entry, the maximum block segment length in bytes.\n @param[out]      aMore        A pointer to the flag if more block segments will follow.\n\n @warning By changing the value of aBlockLength, the block size of the whole exchange is\n          renegotiated. It is recommended to do this after the first block has been received as\n          later changes could cause problems with other CoAP implementations.\n\n @retval  OT_ERROR_NONE           No error occurred.\n @retval  OT_ERROR_INVALID_ARGS   Block at @p aPosition does not exist."]
5580pub type otCoapBlockwiseTransmitHook = ::std::option::Option<
5581    unsafe extern "C" fn(
5582        aContext: *mut ::std::os::raw::c_void,
5583        aBlock: *mut u8,
5584        aPosition: u32,
5585        aBlockLength: *mut u16,
5586        aMore: *mut bool,
5587    ) -> otError,
5588>;
5589#[doc = " Represents a CoAP resource."]
5590#[repr(C)]
5591#[derive(Debug, Copy, Clone)]
5592pub struct otCoapResource {
5593    #[doc = "< The URI Path string"]
5594    pub mUriPath: *const ::std::os::raw::c_char,
5595    #[doc = "< The callback for handling a received request"]
5596    pub mHandler: otCoapRequestHandler,
5597    #[doc = "< Application-specific context"]
5598    pub mContext: *mut ::std::os::raw::c_void,
5599    #[doc = "< The next CoAP resource in the list"]
5600    pub mNext: *mut otCoapResource,
5601}
5602impl Default for otCoapResource {
5603    fn default() -> Self {
5604        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5605        unsafe {
5606            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5607            s.assume_init()
5608        }
5609    }
5610}
5611#[doc = " Represents a CoAP resource with block-wise transfer."]
5612#[repr(C)]
5613#[derive(Debug, Copy, Clone)]
5614pub struct otCoapBlockwiseResource {
5615    #[doc = "< The URI Path string"]
5616    pub mUriPath: *const ::std::os::raw::c_char,
5617    #[doc = "< The callback for handling a received request"]
5618    pub mHandler: otCoapRequestHandler,
5619    #[doc = " The callback for handling incoming block-wise transfer.\n  This callback is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE\n  configuration is enabled."]
5620    pub mReceiveHook: otCoapBlockwiseReceiveHook,
5621    #[doc = " The callback for handling outgoing block-wise transfer.\n  This callback is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE\n  configuration is enabled."]
5622    pub mTransmitHook: otCoapBlockwiseTransmitHook,
5623    #[doc = "< Application-specific context"]
5624    pub mContext: *mut ::std::os::raw::c_void,
5625    #[doc = "< The next CoAP resource in the list"]
5626    pub mNext: *mut otCoapBlockwiseResource,
5627}
5628impl Default for otCoapBlockwiseResource {
5629    fn default() -> Self {
5630        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5631        unsafe {
5632            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5633            s.assume_init()
5634        }
5635    }
5636}
5637#[doc = " Represents the CoAP transmission parameters.\n\n @note mAckTimeout * ((2 ** (mMaxRetransmit + 1)) - 1) * (mAckRandomFactorNumerator / mAckRandomFactorDenominator)\n       must not exceed what can be represented by a uint32_t (0xffffffff). This limitation allows OpenThread to\n       avoid 64-bit arithmetic."]
5638#[repr(C)]
5639#[derive(Debug, Default, Copy, Clone)]
5640pub struct otCoapTxParameters {
5641    #[doc = " Minimum spacing before first retransmission when ACK is not received, in milliseconds (RFC7252 default value is\n 2000ms)."]
5642    pub mAckTimeout: u32,
5643    #[doc = " Numerator of ACK_RANDOM_FACTOR used to calculate maximum spacing before first retransmission when ACK is not\n received (RFC7252 default value of ACK_RANDOM_FACTOR is 1.5; must not be decreased below 1)."]
5644    pub mAckRandomFactorNumerator: u8,
5645    #[doc = " Denominator of ACK_RANDOM_FACTOR used to calculate maximum spacing before first retransmission when ACK is not\n received (RFC7252 default value of ACK_RANDOM_FACTOR is 1.5; must not be decreased below 1)."]
5646    pub mAckRandomFactorDenominator: u8,
5647    #[doc = " Maximum number of retransmissions for CoAP Confirmable messages (RFC7252 default value is 4)."]
5648    pub mMaxRetransmit: u8,
5649}
5650extern "C" {
5651    #[doc = " Initializes the CoAP header.\n\n @param[in,out] aMessage   A pointer to the CoAP message to initialize.\n @param[in]     aType      CoAP message type.\n @param[in]     aCode      CoAP message code."]
5652    pub fn otCoapMessageInit(aMessage: *mut otMessage, aType: otCoapType, aCode: otCoapCode);
5653}
5654extern "C" {
5655    #[doc = " Initializes a response message.\n\n @note Both message ID and token are set according to @p aRequest.\n\n @param[in,out]  aResponse  A pointer to the CoAP response message.\n @param[in]      aRequest   A pointer to the CoAP request message.\n @param[in]      aType      CoAP message type.\n @param[in]      aCode      CoAP message code.\n\n @retval OT_ERROR_NONE     Successfully initialized the response message.\n @retval OT_ERROR_NO_BUFS  Insufficient message buffers available to initialize the response message."]
5656    pub fn otCoapMessageInitResponse(
5657        aResponse: *mut otMessage,
5658        aRequest: *const otMessage,
5659        aType: otCoapType,
5660        aCode: otCoapCode,
5661    ) -> otError;
5662}
5663extern "C" {
5664    #[doc = " Sets the Token value and length in a header.\n\n @param[in,out]  aMessage          A pointer to the CoAP message.\n @param[in]      aToken            A pointer to the Token value.\n @param[in]      aTokenLength      The Length of @p aToken.\n\n @retval OT_ERROR_NONE     Successfully set the Token value.\n @retval OT_ERROR_NO_BUFS  Insufficient buffers to set the Token value."]
5665    pub fn otCoapMessageSetToken(
5666        aMessage: *mut otMessage,
5667        aToken: *const u8,
5668        aTokenLength: u8,
5669    ) -> otError;
5670}
5671extern "C" {
5672    #[doc = " Sets the Token length and randomizes its value.\n\n @param[in,out]  aMessage      A pointer to the CoAP message.\n @param[in]      aTokenLength  The Length of a Token to set."]
5673    pub fn otCoapMessageGenerateToken(aMessage: *mut otMessage, aTokenLength: u8);
5674}
5675extern "C" {
5676    #[doc = " Appends the Content Format CoAP option as specified in\n https://tools.ietf.org/html/rfc7252#page-92.  This *must* be called before\n setting otCoapMessageSetPayloadMarker if a payload is to be included in the\n message.\n\n The function is a convenience wrapper around otCoapMessageAppendUintOption,\n and if the desired format type code isn't listed in otCoapOptionContentFormat,\n this base function should be used instead.\n\n @param[in,out]  aMessage          A pointer to the CoAP message.\n @param[in]      aContentFormat    One of the content formats listed in\n                                  otCoapOptionContentFormat above.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5677    pub fn otCoapMessageAppendContentFormatOption(
5678        aMessage: *mut otMessage,
5679        aContentFormat: otCoapOptionContentFormat,
5680    ) -> otError;
5681}
5682extern "C" {
5683    #[doc = " Appends a CoAP option in a header.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aNumber   The CoAP Option number.\n @param[in]      aLength   The CoAP Option length.\n @param[in]      aValue    A pointer to the CoAP value.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5684    pub fn otCoapMessageAppendOption(
5685        aMessage: *mut otMessage,
5686        aNumber: u16,
5687        aLength: u16,
5688        aValue: *const ::std::os::raw::c_void,
5689    ) -> otError;
5690}
5691extern "C" {
5692    #[doc = " Appends an unsigned integer CoAP option as specified in\n https://tools.ietf.org/html/rfc7252#section-3.2\n\n @param[in,out]  aMessage A pointer to the CoAP message.\n @param[in]      aNumber  The CoAP Option number.\n @param[in]      aValue   The CoAP Option unsigned integer value.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size.\n\n @see otCoapMessageGetOptionUintValue"]
5693    pub fn otCoapMessageAppendUintOption(
5694        aMessage: *mut otMessage,
5695        aNumber: u16,
5696        aValue: u32,
5697    ) -> otError;
5698}
5699extern "C" {
5700    #[doc = " Appends an Observe option.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aObserve  Observe field value.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5701    pub fn otCoapMessageAppendObserveOption(aMessage: *mut otMessage, aObserve: u32) -> otError;
5702}
5703extern "C" {
5704    #[doc = " Appends a Uri-Path option.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aUriPath  A pointer to a NULL-terminated string.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5705    pub fn otCoapMessageAppendUriPathOptions(
5706        aMessage: *mut otMessage,
5707        aUriPath: *const ::std::os::raw::c_char,
5708    ) -> otError;
5709}
5710extern "C" {
5711    #[doc = " Appends a Uri-Query option.\n\n @param[in,out]  aMessage   A pointer to the CoAP message.\n @param[in]      aUriQuery  A pointer to a NULL-terminated string.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5712    pub fn otCoapMessageAppendUriQueryOptions(
5713        aMessage: *mut otMessage,
5714        aUriQuery: *const ::std::os::raw::c_char,
5715    ) -> otError;
5716}
5717extern "C" {
5718    #[doc = " Converts a CoAP Block option SZX field to the actual block size\n\n @param[in]     aSize     Block size exponent.\n\n @returns The actual size exponent value."]
5719    pub fn otCoapBlockSizeFromExponent(aSize: otCoapBlockSzx) -> u16;
5720}
5721extern "C" {
5722    #[doc = " Appends a Block2 option\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aNum      Current block number.\n @param[in]      aMore     Boolean to indicate more blocks are to be sent.\n @param[in]      aSize     Block Size Exponent.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5723    pub fn otCoapMessageAppendBlock2Option(
5724        aMessage: *mut otMessage,
5725        aNum: u32,
5726        aMore: bool,
5727        aSize: otCoapBlockSzx,
5728    ) -> otError;
5729}
5730extern "C" {
5731    #[doc = " Appends a Block1 option\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aNum      Current block number.\n @param[in]      aMore     Boolean to indicate more blocks are to be sent.\n @param[in]      aSize     Block Size Exponent.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5732    pub fn otCoapMessageAppendBlock1Option(
5733        aMessage: *mut otMessage,
5734        aNum: u32,
5735        aMore: bool,
5736        aSize: otCoapBlockSzx,
5737    ) -> otError;
5738}
5739extern "C" {
5740    #[doc = " Appends a Proxy-Uri option.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aUriPath  A pointer to a NULL-terminated string.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5741    pub fn otCoapMessageAppendProxyUriOption(
5742        aMessage: *mut otMessage,
5743        aUriPath: *const ::std::os::raw::c_char,
5744    ) -> otError;
5745}
5746extern "C" {
5747    #[doc = " Appends a Max-Age option.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aMaxAge   The Max-Age value.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5748    pub fn otCoapMessageAppendMaxAgeOption(aMessage: *mut otMessage, aMaxAge: u32) -> otError;
5749}
5750extern "C" {
5751    #[doc = " Appends a single Uri-Query option.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n @param[in]      aUriQuery A pointer to NULL-terminated string, which should contain a single key=value pair.\n\n @retval OT_ERROR_NONE          Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS  The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS       The option length exceeds the buffer size."]
5752    pub fn otCoapMessageAppendUriQueryOption(
5753        aMessage: *mut otMessage,
5754        aUriQuery: *const ::std::os::raw::c_char,
5755    ) -> otError;
5756}
5757extern "C" {
5758    #[doc = " Adds Payload Marker indicating beginning of the payload to the CoAP header.\n\n @param[in,out]  aMessage  A pointer to the CoAP message.\n\n @retval OT_ERROR_NONE     Payload Marker successfully added.\n @retval OT_ERROR_NO_BUFS  Header Payload Marker exceeds the buffer size."]
5759    pub fn otCoapMessageSetPayloadMarker(aMessage: *mut otMessage) -> otError;
5760}
5761extern "C" {
5762    #[doc = " Returns the Type value.\n\n @param[in]  aMessage  A pointer to the CoAP message.\n\n @returns The Type value."]
5763    pub fn otCoapMessageGetType(aMessage: *const otMessage) -> otCoapType;
5764}
5765extern "C" {
5766    #[doc = " Returns the Code value.\n\n @param[in]  aMessage  A pointer to the CoAP message.\n\n @returns The Code value."]
5767    pub fn otCoapMessageGetCode(aMessage: *const otMessage) -> otCoapCode;
5768}
5769extern "C" {
5770    #[doc = " Sets the Code value.\n\n @param[in,out]  aMessage  A pointer to the CoAP message to initialize.\n @param[in]      aCode     CoAP message code."]
5771    pub fn otCoapMessageSetCode(aMessage: *mut otMessage, aCode: otCoapCode);
5772}
5773extern "C" {
5774    #[doc = " Returns the CoAP Code as human readable string.\n\n @param[in]   aMessage    A pointer to the CoAP message.\n\n @ returns The CoAP Code as string."]
5775    pub fn otCoapMessageCodeToString(aMessage: *const otMessage) -> *const ::std::os::raw::c_char;
5776}
5777extern "C" {
5778    #[doc = " Returns the Message ID value.\n\n @param[in]  aMessage  A pointer to the CoAP message.\n\n @returns The Message ID value."]
5779    pub fn otCoapMessageGetMessageId(aMessage: *const otMessage) -> u16;
5780}
5781extern "C" {
5782    #[doc = " Returns the Token length.\n\n @param[in]  aMessage  A pointer to the CoAP message.\n\n @returns The Token length."]
5783    pub fn otCoapMessageGetTokenLength(aMessage: *const otMessage) -> u8;
5784}
5785extern "C" {
5786    #[doc = " Returns a pointer to the Token value.\n\n @param[in]  aMessage  A pointer to the CoAP message.\n\n @returns A pointer to the Token value."]
5787    pub fn otCoapMessageGetToken(aMessage: *const otMessage) -> *const u8;
5788}
5789extern "C" {
5790    #[doc = " Initialises an iterator for the options in the given message.\n\n @param[in,out]  aIterator A pointer to the CoAP message option iterator.\n @param[in]      aMessage  A pointer to the CoAP message.\n\n @retval  OT_ERROR_NONE   Successfully initialised.\n @retval  OT_ERROR_PARSE  Message state is inconsistent."]
5791    pub fn otCoapOptionIteratorInit(
5792        aIterator: *mut otCoapOptionIterator,
5793        aMessage: *const otMessage,
5794    ) -> otError;
5795}
5796extern "C" {
5797    #[doc = " Returns a pointer to the first option matching the specified option number.\n\n @param[in]  aIterator A pointer to the CoAP message option iterator.\n @param[in]  aOption   The option number sought.\n\n @returns A pointer to the first matching option. If no matching option is present NULL pointer is returned."]
5798    pub fn otCoapOptionIteratorGetFirstOptionMatching(
5799        aIterator: *mut otCoapOptionIterator,
5800        aOption: u16,
5801    ) -> *const otCoapOption;
5802}
5803extern "C" {
5804    #[doc = " Returns a pointer to the first option.\n\n @param[in,out]  aIterator A pointer to the CoAP message option iterator.\n\n @returns A pointer to the first option. If no option is present NULL pointer is returned."]
5805    pub fn otCoapOptionIteratorGetFirstOption(
5806        aIterator: *mut otCoapOptionIterator,
5807    ) -> *const otCoapOption;
5808}
5809extern "C" {
5810    #[doc = " Returns a pointer to the next option matching the specified option number.\n\n @param[in]  aIterator A pointer to the CoAP message option iterator.\n @param[in]  aOption   The option number sought.\n\n @returns A pointer to the next matching option. If no further matching option is present NULL pointer is returned."]
5811    pub fn otCoapOptionIteratorGetNextOptionMatching(
5812        aIterator: *mut otCoapOptionIterator,
5813        aOption: u16,
5814    ) -> *const otCoapOption;
5815}
5816extern "C" {
5817    #[doc = " Returns a pointer to the next option.\n\n @param[in,out]  aIterator A pointer to the CoAP message option iterator.\n\n @returns A pointer to the next option. If no more options are present NULL pointer is returned."]
5818    pub fn otCoapOptionIteratorGetNextOption(
5819        aIterator: *mut otCoapOptionIterator,
5820    ) -> *const otCoapOption;
5821}
5822extern "C" {
5823    #[doc = " Fills current option value into @p aValue assuming the current value is an unsigned integer encoded\n according to https://tools.ietf.org/html/rfc7252#section-3.2\n\n @param[in,out]   aIterator   A pointer to the CoAP message option iterator.\n @param[out]      aValue      A pointer to an unsigned integer to receive the option value.\n\n @retval  OT_ERROR_NONE       Successfully filled value.\n @retval  OT_ERROR_NOT_FOUND  No current option.\n @retval  OT_ERROR_NO_BUFS    Value is too long to fit in a uint64_t.\n\n @see otCoapMessageAppendUintOption"]
5824    pub fn otCoapOptionIteratorGetOptionUintValue(
5825        aIterator: *mut otCoapOptionIterator,
5826        aValue: *mut u64,
5827    ) -> otError;
5828}
5829extern "C" {
5830    #[doc = " Fills current option value into @p aValue.\n\n @param[in,out]  aIterator A pointer to the CoAP message option iterator.\n @param[out]     aValue    A pointer to a buffer to receive the option value.\n\n @retval  OT_ERROR_NONE       Successfully filled value.\n @retval  OT_ERROR_NOT_FOUND  No current option."]
5831    pub fn otCoapOptionIteratorGetOptionValue(
5832        aIterator: *mut otCoapOptionIterator,
5833        aValue: *mut ::std::os::raw::c_void,
5834    ) -> otError;
5835}
5836extern "C" {
5837    #[doc = " Creates a new CoAP message.\n\n @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSettings  A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid."]
5838    pub fn otCoapNewMessage(
5839        aInstance: *mut otInstance,
5840        aSettings: *const otMessageSettings,
5841    ) -> *mut otMessage;
5842}
5843extern "C" {
5844    #[doc = " Sends a CoAP request with custom transmission parameters.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aMessage         A pointer to the message to send.\n @param[in]  aMessageInfo     A pointer to the message info associated with @p aMessage.\n @param[in]  aHandler         A function pointer that shall be called on response reception or timeout.\n @param[in]  aContext         A pointer to arbitrary context information. May be NULL if not used.\n @param[in]  aTxParameters    A pointer to transmission parameters for this request. Use NULL for defaults.\n                              Otherwise, parameters given must meet the following conditions:\n                              1. mMaxRetransmit is no more than OT_COAP_MAX_RETRANSMIT.\n                              2. mAckRandomFactorNumerator / mAckRandomFactorDenominator must not be below 1.0.\n                              3. The calculated exchange life time must not overflow uint32_t.\n\n @retval OT_ERROR_NONE            Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS         Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_ARGS    Invalid arguments are given."]
5845    pub fn otCoapSendRequestWithParameters(
5846        aInstance: *mut otInstance,
5847        aMessage: *mut otMessage,
5848        aMessageInfo: *const otMessageInfo,
5849        aHandler: otCoapResponseHandler,
5850        aContext: *mut ::std::os::raw::c_void,
5851        aTxParameters: *const otCoapTxParameters,
5852    ) -> otError;
5853}
5854extern "C" {
5855    #[doc = " Sends a CoAP request block-wise with custom transmission parameters.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n If a response for a request is expected, respective function and context information should be provided.\n If the response is expected to be block-wise, a respective hook function should be provided.\n If no response is expected, these arguments should be NULL pointers.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aMessage         A pointer to the message to send.\n @param[in]  aMessageInfo     A pointer to the message info associated with @p aMessage.\n @param[in]  aHandler         A function pointer that shall be called on response reception or timeout.\n @param[in]  aContext         A pointer to arbitrary context information. May be NULL if not used.\n @param[in]  aTxParameters    A pointer to transmission parameters for this request. Use NULL for defaults.\n @param[in]  aTransmitHook    A pointer to a hook function for outgoing block-wise transfer.\n @param[in]  aReceiveHook     A pointer to a hook function for incoming block-wise transfer.\n\n @retval OT_ERROR_NONE          Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS       Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_ARGS  Invalid arguments are given."]
5856    pub fn otCoapSendRequestBlockWiseWithParameters(
5857        aInstance: *mut otInstance,
5858        aMessage: *mut otMessage,
5859        aMessageInfo: *const otMessageInfo,
5860        aHandler: otCoapResponseHandler,
5861        aContext: *mut ::std::os::raw::c_void,
5862        aTxParameters: *const otCoapTxParameters,
5863        aTransmitHook: otCoapBlockwiseTransmitHook,
5864        aReceiveHook: otCoapBlockwiseReceiveHook,
5865    ) -> otError;
5866}
5867extern "C" {
5868    #[doc = " Starts the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aPort      The local UDP port to bind to.\n\n @retval OT_ERROR_NONE    Successfully started the CoAP server.\n @retval OT_ERROR_FAILED  Failed to start the CoAP server."]
5869    pub fn otCoapStart(aInstance: *mut otInstance, aPort: u16) -> otError;
5870}
5871extern "C" {
5872    #[doc = " Stops the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE  Successfully stopped the CoAP server."]
5873    pub fn otCoapStop(aInstance: *mut otInstance) -> otError;
5874}
5875extern "C" {
5876    #[doc = " Adds a resource to the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
5877    pub fn otCoapAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
5878}
5879extern "C" {
5880    #[doc = " Removes a resource from the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
5881    pub fn otCoapRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
5882}
5883extern "C" {
5884    #[doc = " Adds a block-wise resource to the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
5885    pub fn otCoapAddBlockWiseResource(
5886        aInstance: *mut otInstance,
5887        aResource: *mut otCoapBlockwiseResource,
5888    );
5889}
5890extern "C" {
5891    #[doc = " Removes a block-wise resource from the CoAP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
5892    pub fn otCoapRemoveBlockWiseResource(
5893        aInstance: *mut otInstance,
5894        aResource: *mut otCoapBlockwiseResource,
5895    );
5896}
5897extern "C" {
5898    #[doc = " Sets the default handler for unhandled CoAP requests.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aHandler   A function pointer that shall be called when an unhandled request arrives.\n @param[in]  aContext   A pointer to arbitrary context information. May be NULL if not used."]
5899    pub fn otCoapSetDefaultHandler(
5900        aInstance: *mut otInstance,
5901        aHandler: otCoapRequestHandler,
5902        aContext: *mut ::std::os::raw::c_void,
5903    );
5904}
5905extern "C" {
5906    #[doc = " Sends a CoAP response from the server with custom transmission parameters.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aMessage         A pointer to the CoAP response to send.\n @param[in]  aMessageInfo     A pointer to the message info associated with @p aMessage.\n @param[in]  aTxParameters    A pointer to transmission parameters for this response. Use NULL for defaults.\n\n @retval OT_ERROR_NONE          Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS       Insufficient buffers available to send the CoAP response.\n @retval OT_ERROR_INVALID_ARGS  Invalid arguments are given."]
5907    pub fn otCoapSendResponseWithParameters(
5908        aInstance: *mut otInstance,
5909        aMessage: *mut otMessage,
5910        aMessageInfo: *const otMessageInfo,
5911        aTxParameters: *const otCoapTxParameters,
5912    ) -> otError;
5913}
5914extern "C" {
5915    #[doc = " Sends a CoAP response block-wise from the server with custom transmission parameters.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aMessage         A pointer to the CoAP response to send.\n @param[in]  aMessageInfo     A pointer to the message info associated with @p aMessage.\n @param[in]  aTxParameters    A pointer to transmission parameters for this response. Use NULL for defaults.\n @param[in]  aContext         A pointer to arbitrary context information. May be NULL if not used.\n @param[in]  aTransmitHook    A pointer to a hook function for outgoing block-wise transfer.\n\n @retval OT_ERROR_NONE          Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS       Insufficient buffers available to send the CoAP response.\n @retval OT_ERROR_INVALID_ARGS  Invalid arguments are given."]
5916    pub fn otCoapSendResponseBlockWiseWithParameters(
5917        aInstance: *mut otInstance,
5918        aMessage: *mut otMessage,
5919        aMessageInfo: *const otMessageInfo,
5920        aTxParameters: *const otCoapTxParameters,
5921        aContext: *mut ::std::os::raw::c_void,
5922        aTransmitHook: otCoapBlockwiseTransmitHook,
5923    ) -> otError;
5924}
5925#[doc = "< Connection established"]
5926pub const OT_COAP_SECURE_CONNECTED: otCoapSecureConnectEvent = 0;
5927#[doc = "< Disconnected by peer"]
5928pub const OT_COAP_SECURE_DISCONNECTED_PEER_CLOSED: otCoapSecureConnectEvent = 1;
5929#[doc = "< Disconnected locally"]
5930pub const OT_COAP_SECURE_DISCONNECTED_LOCAL_CLOSED: otCoapSecureConnectEvent = 2;
5931#[doc = "< Disconnected due to reaching the max connection attempts"]
5932pub const OT_COAP_SECURE_DISCONNECTED_MAX_ATTEMPTS: otCoapSecureConnectEvent = 3;
5933#[doc = "< Disconnected due to an error"]
5934pub const OT_COAP_SECURE_DISCONNECTED_ERROR: otCoapSecureConnectEvent = 4;
5935#[doc = " CoAP secure connection event types."]
5936pub type otCoapSecureConnectEvent = ::std::os::raw::c_uint;
5937#[doc = " Pointer is called when the DTLS connection state changes.\n\n @param[in]  aEvent      The connection event.\n @param[in]  aContext    A pointer to arbitrary context information."]
5938pub type otHandleCoapSecureClientConnect = ::std::option::Option<
5939    unsafe extern "C" fn(aEvent: otCoapSecureConnectEvent, aContext: *mut ::std::os::raw::c_void),
5940>;
5941#[doc = " Callback function pointer to notify when the CoAP secure agent is automatically stopped due to reaching the maximum\n number of connection attempts.\n\n @param[in] aContext    A pointer to arbitrary context information."]
5942pub type otCoapSecureAutoStopCallback =
5943    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5944extern "C" {
5945    #[doc = " Starts the CoAP Secure service.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aPort      The local UDP port to bind to.\n\n @retval OT_ERROR_NONE  Successfully started the CoAP Secure server."]
5946    pub fn otCoapSecureStart(aInstance: *mut otInstance, aPort: u16) -> otError;
5947}
5948extern "C" {
5949    #[doc = " Starts the CoAP secure service and sets the maximum number of allowed connection attempts before stopping the\n agent automatically.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n @param[in] aPort           The local UDP port to bind to.\n @param[in] aMaxAttempts    Maximum number of allowed connection request attempts. Zero indicates no limit.\n @param[in] aCallback       Callback to notify if max number of attempts has reached and agent is stopped.\n @param[in] aContext        A pointer to arbitrary context to use with @p aCallback.\n\n @retval OT_ERROR_NONE        Successfully started the CoAP agent.\n @retval OT_ERROR_ALREADY     Already started."]
5950    pub fn otCoapSecureStartWithMaxConnAttempts(
5951        aInstance: *mut otInstance,
5952        aPort: u16,
5953        aMaxAttempts: u16,
5954        aCallback: otCoapSecureAutoStopCallback,
5955        aContext: *mut ::std::os::raw::c_void,
5956    ) -> otError;
5957}
5958extern "C" {
5959    #[doc = " Stops the CoAP Secure server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
5960    pub fn otCoapSecureStop(aInstance: *mut otInstance);
5961}
5962extern "C" {
5963    #[doc = " Sets the Pre-Shared Key (PSK) and cipher suite\n DTLS_PSK_WITH_AES_128_CCM_8.\n\n @note This function requires the build-time feature `MBEDTLS_KEY_EXCHANGE_PSK_ENABLED` to be enabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aPsk          A pointer to the PSK.\n @param[in]  aPskLength    The PSK length.\n @param[in]  aPskIdentity  The Identity Name for the PSK.\n @param[in]  aPskIdLength  The PSK Identity Length."]
5964    pub fn otCoapSecureSetPsk(
5965        aInstance: *mut otInstance,
5966        aPsk: *const u8,
5967        aPskLength: u16,
5968        aPskIdentity: *const u8,
5969        aPskIdLength: u16,
5970    );
5971}
5972extern "C" {
5973    #[doc = " Returns the peer x509 certificate base64 encoded.\n\n @note This function requires the build-time features `MBEDTLS_BASE64_C` and\n       `MBEDTLS_SSL_KEEP_PEER_CERTIFICATE` to be enabled.\n\n @param[in]   aInstance        A pointer to an OpenThread instance.\n @param[out]  aPeerCert        A pointer to the base64 encoded certificate buffer.\n @param[out]  aCertLength      The length of the base64 encoded peer certificate.\n @param[in]   aCertBufferSize  The buffer size of aPeerCert.\n\n @retval OT_ERROR_INVALID_STATE   Not connected yet.\n @retval OT_ERROR_NONE            Successfully get the peer certificate.\n @retval OT_ERROR_NO_BUFS         Can't allocate memory for certificate."]
5974    pub fn otCoapSecureGetPeerCertificateBase64(
5975        aInstance: *mut otInstance,
5976        aPeerCert: *mut ::std::os::raw::c_uchar,
5977        aCertLength: *mut usize,
5978        aCertBufferSize: usize,
5979    ) -> otError;
5980}
5981extern "C" {
5982    #[doc = " Sets the authentication mode for the coap secure connection.\n\n Disable or enable the verification of peer certificate.\n Must be called before start.\n\n @param[in]   aInstance               A pointer to an OpenThread instance.\n @param[in]   aVerifyPeerCertificate  true, to verify the peer certificate."]
5983    pub fn otCoapSecureSetSslAuthMode(aInstance: *mut otInstance, aVerifyPeerCertificate: bool);
5984}
5985extern "C" {
5986    #[doc = " Sets the local device's X509 certificate with corresponding private key for\n DTLS session with DTLS_ECDHE_ECDSA_WITH_AES_128_CCM_8.\n\n @note This function requires `MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED=1`.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aX509Cert          A pointer to the PEM formatted X509 certificate.\n @param[in]  aX509Length        The length of certificate.\n @param[in]  aPrivateKey        A pointer to the PEM formatted private key.\n @param[in]  aPrivateKeyLength  The length of the private key."]
5987    pub fn otCoapSecureSetCertificate(
5988        aInstance: *mut otInstance,
5989        aX509Cert: *const u8,
5990        aX509Length: u32,
5991        aPrivateKey: *const u8,
5992        aPrivateKeyLength: u32,
5993    );
5994}
5995extern "C" {
5996    #[doc = " Sets the trusted top level CAs. It is needed for validating the\n certificate of the peer.\n\n DTLS mode \"ECDHE ECDSA with AES 128 CCM 8\" for Application CoAPS.\n\n @note This function requires `MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED=1`.\n\n @param[in]  aInstance                A pointer to an OpenThread instance.\n @param[in]  aX509CaCertificateChain  A pointer to the PEM formatted X509 CA chain.\n @param[in]  aX509CaCertChainLength   The length of chain."]
5997    pub fn otCoapSecureSetCaCertificateChain(
5998        aInstance: *mut otInstance,
5999        aX509CaCertificateChain: *const u8,
6000        aX509CaCertChainLength: u32,
6001    );
6002}
6003extern "C" {
6004    #[doc = " Initializes DTLS session with a peer.\n\n @param[in]  aInstance               A pointer to an OpenThread instance.\n @param[in]  aSockAddr               A pointer to the remote socket address.\n @param[in]  aHandler                A pointer to a function that will be called when the DTLS connection\n                                     state changes.\n @param[in]  aContext                A pointer to arbitrary context information.\n\n @retval OT_ERROR_NONE  Successfully started DTLS connection."]
6005    pub fn otCoapSecureConnect(
6006        aInstance: *mut otInstance,
6007        aSockAddr: *const otSockAddr,
6008        aHandler: otHandleCoapSecureClientConnect,
6009        aContext: *mut ::std::os::raw::c_void,
6010    ) -> otError;
6011}
6012extern "C" {
6013    #[doc = " Stops the DTLS connection.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
6014    pub fn otCoapSecureDisconnect(aInstance: *mut otInstance);
6015}
6016extern "C" {
6017    #[doc = " Indicates whether or not the DTLS session is connected.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE   The DTLS session is connected.\n @retval FALSE  The DTLS session is not connected."]
6018    pub fn otCoapSecureIsConnected(aInstance: *mut otInstance) -> bool;
6019}
6020extern "C" {
6021    #[doc = " Indicates whether or not the DTLS session is active.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE  If DTLS session is active.\n @retval FALSE If DTLS session is not active."]
6022    pub fn otCoapSecureIsConnectionActive(aInstance: *mut otInstance) -> bool;
6023}
6024extern "C" {
6025    #[doc = " Indicates whether or not the DTLS session is closed.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE   The DTLS session is closed.\n @retval FALSE  The DTLS session is not closed."]
6026    pub fn otCoapSecureIsClosed(aInstance: *mut otInstance) -> bool;
6027}
6028extern "C" {
6029    #[doc = " Sends a CoAP request block-wise over secure DTLS connection.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n If Message Id was not set in the header (equal to 0), this function will assign unique Message Id to the message.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A reference to the message to send.\n @param[in]  aHandler      A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext      A pointer to arbitrary context information.\n @param[in]  aTransmitHook A function pointer that is called on Block1 response reception.\n @param[in]  aReceiveHook  A function pointer that is called on Block2 response reception.\n\n @retval OT_ERROR_NONE           Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS        Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_STATE  DTLS connection was not initialized."]
6030    pub fn otCoapSecureSendRequestBlockWise(
6031        aInstance: *mut otInstance,
6032        aMessage: *mut otMessage,
6033        aHandler: otCoapResponseHandler,
6034        aContext: *mut ::std::os::raw::c_void,
6035        aTransmitHook: otCoapBlockwiseTransmitHook,
6036        aReceiveHook: otCoapBlockwiseReceiveHook,
6037    ) -> otError;
6038}
6039extern "C" {
6040    #[doc = " Sends a CoAP request over secure DTLS connection.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n If Message Id was not set in the header (equal to 0), this function will assign unique Message Id to the message.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A reference to the message to send.\n @param[in]  aHandler      A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext      A pointer to arbitrary context information.\n\n @retval OT_ERROR_NONE           Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS        Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_STATE  DTLS connection was not initialized."]
6041    pub fn otCoapSecureSendRequest(
6042        aInstance: *mut otInstance,
6043        aMessage: *mut otMessage,
6044        aHandler: otCoapResponseHandler,
6045        aContext: *mut ::std::os::raw::c_void,
6046    ) -> otError;
6047}
6048extern "C" {
6049    #[doc = " Adds a resource to the CoAP Secure server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
6050    pub fn otCoapSecureAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6051}
6052extern "C" {
6053    #[doc = " Removes a resource from the CoAP Secure server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
6054    pub fn otCoapSecureRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6055}
6056extern "C" {
6057    #[doc = " Adds a block-wise resource to the CoAP Secure server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
6058    pub fn otCoapSecureAddBlockWiseResource(
6059        aInstance: *mut otInstance,
6060        aResource: *mut otCoapBlockwiseResource,
6061    );
6062}
6063extern "C" {
6064    #[doc = " Removes a block-wise resource from the CoAP Secure server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aResource  A pointer to the resource."]
6065    pub fn otCoapSecureRemoveBlockWiseResource(
6066        aInstance: *mut otInstance,
6067        aResource: *mut otCoapBlockwiseResource,
6068    );
6069}
6070extern "C" {
6071    #[doc = " Sets the default handler for unhandled CoAP Secure requests.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aHandler   A function pointer that shall be called when an unhandled request arrives.\n @param[in]  aContext   A pointer to arbitrary context information. May be NULL if not used."]
6072    pub fn otCoapSecureSetDefaultHandler(
6073        aInstance: *mut otInstance,
6074        aHandler: otCoapRequestHandler,
6075        aContext: *mut ::std::os::raw::c_void,
6076    );
6077}
6078extern "C" {
6079    #[doc = " Sets the connect event callback to indicate when\n a Client connection to the CoAP Secure server has changed.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aHandler      A pointer to a function that will be called once DTLS connection has changed.\n @param[in]  aContext      A pointer to arbitrary context information. May be NULL if not used."]
6080    pub fn otCoapSecureSetClientConnectEventCallback(
6081        aInstance: *mut otInstance,
6082        aHandler: otHandleCoapSecureClientConnect,
6083        aContext: *mut ::std::os::raw::c_void,
6084    );
6085}
6086extern "C" {
6087    #[doc = " Sends a CoAP response block-wise from the CoAP Secure server.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A pointer to the CoAP response to send.\n @param[in]  aMessageInfo  A pointer to the message info associated with @p aMessage.\n @param[in]  aContext      A pointer to arbitrary context information. May be NULL if not used.\n @param[in]  aTransmitHook A function pointer that is called on Block1 request reception.\n\n @retval OT_ERROR_NONE     Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS  Insufficient buffers available to send the CoAP response."]
6088    pub fn otCoapSecureSendResponseBlockWise(
6089        aInstance: *mut otInstance,
6090        aMessage: *mut otMessage,
6091        aMessageInfo: *const otMessageInfo,
6092        aContext: *mut ::std::os::raw::c_void,
6093        aTransmitHook: otCoapBlockwiseTransmitHook,
6094    ) -> otError;
6095}
6096extern "C" {
6097    #[doc = " Sends a CoAP response from the CoAP Secure server.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A pointer to the CoAP response to send.\n @param[in]  aMessageInfo  A pointer to the message info associated with @p aMessage.\n\n @retval OT_ERROR_NONE     Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS  Insufficient buffers available to send the CoAP response."]
6098    pub fn otCoapSecureSendResponse(
6099        aInstance: *mut otInstance,
6100        aMessage: *mut otMessage,
6101        aMessageInfo: *const otMessageInfo,
6102    ) -> otError;
6103}
6104extern "C" {
6105    #[doc = " For FTD only, creates a new Operational Dataset to use when forming a new network.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[out] aDataset   The Operational Dataset.\n\n @retval OT_ERROR_NONE    Successfully created a new Operational Dataset.\n @retval OT_ERROR_FAILED  Failed to generate random values for new parameters."]
6106    pub fn otDatasetCreateNewNetwork(
6107        aInstance: *mut otInstance,
6108        aDataset: *mut otOperationalDataset,
6109    ) -> otError;
6110}
6111extern "C" {
6112    #[doc = " For FTD only, gets a minimal delay timer.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval the value of minimal delay timer (in ms)."]
6113    pub fn otDatasetGetDelayTimerMinimal(aInstance: *mut otInstance) -> u32;
6114}
6115extern "C" {
6116    #[doc = " For FTD only, sets a minimal delay timer.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance           A pointer to an OpenThread instance.\n @param[in]  aDelayTimerMinimal  The value of minimal delay timer (in ms).\n\n @retval  OT_ERROR_NONE          Successfully set minimal delay timer.\n @retval  OT_ERROR_INVALID_ARGS  If @p aDelayTimerMinimal is not valid."]
6117    pub fn otDatasetSetDelayTimerMinimal(
6118        aInstance: *mut otInstance,
6119        aDelayTimerMinimal: u32,
6120    ) -> otError;
6121}
6122#[doc = " This callback function pointer is called when a Dataset update request finishes, reporting success or failure status\n of the Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in] aError   The error status.\n                     OT_ERROR_NONE            indicates successful Dataset update.\n                     OT_ERROR_INVALID_STATE   indicates failure due invalid state (MLE being disabled).\n                     OT_ERROR_ALREADY         indicates failure due to another device within network requesting\n                                              a conflicting Dataset update.\n\n @param[in] aContext A pointer to the arbitrary context (provided by user in `otDatasetUpdaterRequestUpdate()`)."]
6123pub type otDatasetUpdaterCallback = ::std::option::Option<
6124    unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
6125>;
6126extern "C" {
6127    #[doc = " Requests an update to Operational Dataset.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @p aDataset should contain the fields to be updated and their new value. It must not contain Active or Pending\n Timestamp fields. The Delay field is optional, if not provided a default value (1000 ms) would be used.\n\n @param[in]  aInstance               A pointer to an OpenThread instance.\n @param[in]  aDataset                A pointer to the Dataset containing the fields to change.\n @param[in]  aCallback               A callback to indicate when Dataset update request finishes.\n @param[in]  aContext                An arbitrary context passed to callback.\n\n @retval OT_ERROR_NONE           Dataset update started successfully (@p aCallback will be invoked on completion).\n @retval OT_ERROR_INVALID_STATE  Device is disabled or not fully configured (missing or incomplete Active Dataset).\n @retval OT_ERROR_ALREADY        The @p aDataset fields already match the existing Active Dataset.\n @retval OT_ERROR_INVALID_ARGS   The @p aDataset is not valid (contains Active or Pending Timestamp).\n @retval OT_ERROR_BUSY           Cannot start update, a previous one is ongoing.\n @retval OT_ERROR_NO_BUFS        Could not allocated buffer to save Dataset."]
6128    pub fn otDatasetUpdaterRequestUpdate(
6129        aInstance: *mut otInstance,
6130        aDataset: *const otOperationalDataset,
6131        aCallback: otDatasetUpdaterCallback,
6132        aContext: *mut ::std::os::raw::c_void,
6133    ) -> otError;
6134}
6135extern "C" {
6136    #[doc = " Cancels an ongoing (if any) Operational Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in]  aInstance         A pointer to an OpenThread instance."]
6137    pub fn otDatasetUpdaterCancelUpdate(aInstance: *mut otInstance);
6138}
6139extern "C" {
6140    #[doc = " Indicates whether there is an ongoing Operation Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n\n @retval TRUE    There is an ongoing update.\n @retval FALSE   There is no ongoing update."]
6141    pub fn otDatasetUpdaterIsUpdateOngoing(aInstance: *mut otInstance) -> bool;
6142}
6143#[doc = "< Input mode without pull resistor."]
6144pub const OT_GPIO_MODE_INPUT: otGpioMode = 0;
6145#[doc = "< Output mode."]
6146pub const OT_GPIO_MODE_OUTPUT: otGpioMode = 1;
6147#[doc = " Defines the gpio modes."]
6148pub type otGpioMode = ::std::os::raw::c_uint;
6149#[doc = " Pointer to callback to output platform diag messages.\n\n @param[in]  aFormat     The format string.\n @param[in]  aArguments  The format string arguments.\n @param[out] aContext    A pointer to the user context."]
6150pub type otPlatDiagOutputCallback = ::std::option::Option<
6151    unsafe extern "C" fn(
6152        aFormat: *const ::std::os::raw::c_char,
6153        aArguments: *mut __va_list_tag,
6154        aContext: *mut ::std::os::raw::c_void,
6155    ),
6156>;
6157extern "C" {
6158    #[doc = " Sets the platform diag output callback.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aCallback   A pointer to a function that is called on outputting diag messages.\n @param[in]  aContext    A pointer to the user context."]
6159    pub fn otPlatDiagSetOutputCallback(
6160        aInstance: *mut otInstance,
6161        aCallback: otPlatDiagOutputCallback,
6162        aContext: *mut ::std::os::raw::c_void,
6163    );
6164}
6165extern "C" {
6166    #[doc = " Processes a factory diagnostics command line.\n\n @param[in]   aInstance       The OpenThread instance for current request.\n @param[in]   aArgsLength     The number of arguments in @p aArgs.\n @param[in]   aArgs           The arguments of diagnostics command line.\n\n @retval  OT_ERROR_INVALID_ARGS       The command is supported but invalid arguments provided.\n @retval  OT_ERROR_NONE               The command is successfully process.\n @retval  OT_ERROR_INVALID_COMMAND    The command is not valid or not supported."]
6167    pub fn otPlatDiagProcess(
6168        aInstance: *mut otInstance,
6169        aArgsLength: u8,
6170        aArgs: *mut *mut ::std::os::raw::c_char,
6171    ) -> otError;
6172}
6173extern "C" {
6174    #[doc = " Enables/disables the factory diagnostics mode.\n\n @param[in]  aMode  TRUE to enable diagnostics mode, FALSE otherwise."]
6175    pub fn otPlatDiagModeSet(aMode: bool);
6176}
6177extern "C" {
6178    #[doc = " Indicates whether or not factory diagnostics mode is enabled.\n\n @returns TRUE if factory diagnostics mode is enabled, FALSE otherwise."]
6179    pub fn otPlatDiagModeGet() -> bool;
6180}
6181extern "C" {
6182    #[doc = " Sets the channel to use for factory diagnostics.\n\n @param[in]  aChannel  The channel value."]
6183    pub fn otPlatDiagChannelSet(aChannel: u8);
6184}
6185extern "C" {
6186    #[doc = " Sets the transmit power to use for factory diagnostics.\n\n @param[in]  aTxPower  The transmit power value."]
6187    pub fn otPlatDiagTxPowerSet(aTxPower: i8);
6188}
6189extern "C" {
6190    #[doc = " Processes the received radio frame.\n\n @param[in]   aInstance   The OpenThread instance for current request.\n @param[in]   aFrame      The received radio frame.\n @param[in]   aError      The received radio frame status."]
6191    pub fn otPlatDiagRadioReceived(
6192        aInstance: *mut otInstance,
6193        aFrame: *mut otRadioFrame,
6194        aError: otError,
6195    );
6196}
6197extern "C" {
6198    #[doc = " Processes the alarm event.\n\n @param[in]   aInstance   The OpenThread instance for current request."]
6199    pub fn otPlatDiagAlarmCallback(aInstance: *mut otInstance);
6200}
6201extern "C" {
6202    #[doc = " Sets the gpio value.\n\n @param[in]  aGpio   The gpio number.\n @param[in]  aValue  true to set the gpio to high level, or false otherwise.\n\n @retval OT_ERROR_NONE             Successfully set the gpio.\n @retval OT_ERROR_FAILED           A platform error occurred while setting the gpio.\n @retval OT_ERROR_INVALID_ARGS     @p aGpio is not supported.\n @retval OT_ERROR_INVALID_STATE    Diagnostic mode was not enabled or @p aGpio is not configured as output.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented or configured on the platform."]
6203    pub fn otPlatDiagGpioSet(aGpio: u32, aValue: bool) -> otError;
6204}
6205extern "C" {
6206    #[doc = " Gets the gpio value.\n\n @param[in]   aGpio   The gpio number.\n @param[out]  aValue  A pointer where to put gpio value.\n\n @retval OT_ERROR_NONE             Successfully got the gpio value.\n @retval OT_ERROR_FAILED           A platform error occurred while getting the gpio value.\n @retval OT_ERROR_INVALID_ARGS     @p aGpio is not supported or @p aValue is NULL.\n @retval OT_ERROR_INVALID_STATE    Diagnostic mode was not enabled or @p aGpio is not configured as input.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented or configured on the platform."]
6207    pub fn otPlatDiagGpioGet(aGpio: u32, aValue: *mut bool) -> otError;
6208}
6209extern "C" {
6210    #[doc = " Sets the gpio mode.\n\n @param[in]   aGpio   The gpio number.\n @param[out]  aMode   The gpio mode.\n\n @retval OT_ERROR_NONE             Successfully set the gpio mode.\n @retval OT_ERROR_FAILED           A platform error occurred while setting the gpio mode.\n @retval OT_ERROR_INVALID_ARGS     @p aGpio or @p aMode is not supported.\n @retval OT_ERROR_INVALID_STATE    Diagnostic mode was not enabled.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented or configured on the platform."]
6211    pub fn otPlatDiagGpioSetMode(aGpio: u32, aMode: otGpioMode) -> otError;
6212}
6213extern "C" {
6214    #[doc = " Gets the gpio mode.\n\n @param[in]   aGpio   The gpio number.\n @param[out]  aMode   A pointer where to put gpio mode.\n\n @retval OT_ERROR_NONE             Successfully got the gpio mode.\n @retval OT_ERROR_FAILED           Mode returned by the platform is not implemented in OpenThread or a platform error\n                                   occurred while getting the gpio mode.\n @retval OT_ERROR_INVALID_ARGS     @p aGpio is not supported or @p aMode is NULL.\n @retval OT_ERROR_INVALID_STATE    Diagnostic mode was not enabled.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented or configured on the platform."]
6215    pub fn otPlatDiagGpioGetMode(aGpio: u32, aMode: *mut otGpioMode) -> otError;
6216}
6217extern "C" {
6218    #[doc = " Set the radio raw power setting for diagnostics module.\n\n @param[in] aInstance               The OpenThread instance structure.\n @param[in] aRawPowerSetting        A pointer to the raw power setting byte array.\n @param[in] aRawPowerSettingLength  The length of the @p aRawPowerSetting.\n\n @retval OT_ERROR_NONE             Successfully set the raw power setting.\n @retval OT_ERROR_INVALID_ARGS     The @p aRawPowerSetting is NULL or the @p aRawPowerSettingLength is too long.\n @retval OT_ERROR_NOT_IMPLEMENTED  This method is not implemented."]
6219    pub fn otPlatDiagRadioSetRawPowerSetting(
6220        aInstance: *mut otInstance,
6221        aRawPowerSetting: *const u8,
6222        aRawPowerSettingLength: u16,
6223    ) -> otError;
6224}
6225extern "C" {
6226    #[doc = " Get the radio raw power setting for diagnostics module.\n\n @param[in]      aInstance               The OpenThread instance structure.\n @param[out]     aRawPowerSetting        A pointer to the raw power setting byte array.\n @param[in,out]  aRawPowerSettingLength  On input, a pointer to the size of @p aRawPowerSetting.\n                                         On output, a pointer to the length of the raw power setting data.\n\n @retval OT_ERROR_NONE             Successfully set the raw power setting.\n @retval OT_ERROR_INVALID_ARGS     The @p aRawPowerSetting or @p aRawPowerSettingLength is NULL or\n                                   @aRawPowerSettingLength is too short.\n @retval OT_ERROR_NOT_FOUND        The raw power setting is not set.\n @retval OT_ERROR_NOT_IMPLEMENTED  This method is not implemented."]
6227    pub fn otPlatDiagRadioGetRawPowerSetting(
6228        aInstance: *mut otInstance,
6229        aRawPowerSetting: *mut u8,
6230        aRawPowerSettingLength: *mut u16,
6231    ) -> otError;
6232}
6233extern "C" {
6234    #[doc = " Enable/disable the platform layer to use the raw power setting set by `otPlatDiagRadioSetRawPowerSetting()`.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aEnable   TRUE to enable or FALSE to disable the raw power setting.\n\n @retval OT_ERROR_NONE             Successfully enabled/disabled the raw power setting.\n @retval OT_ERROR_NOT_IMPLEMENTED  This method is not implemented."]
6235    pub fn otPlatDiagRadioRawPowerSettingEnable(
6236        aInstance: *mut otInstance,
6237        aEnable: bool,
6238    ) -> otError;
6239}
6240extern "C" {
6241    #[doc = " Start/stop the platform layer to transmit continuous carrier wave.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aEnable   TRUE to enable or FALSE to disable the platform layer to transmit continuous carrier wave.\n\n @retval OT_ERROR_NONE             Successfully enabled/disabled .\n @retval OT_ERROR_INVALID_STATE    The radio was not in the Receive state.\n @retval OT_ERROR_NOT_IMPLEMENTED  This method is not implemented."]
6242    pub fn otPlatDiagRadioTransmitCarrier(aInstance: *mut otInstance, aEnable: bool) -> otError;
6243}
6244extern "C" {
6245    #[doc = " Start/stop the platform layer to transmit stream of characters.\n\n @param[in]  aInstance The OpenThread instance structure.\n @param[in]  aEnable   TRUE to enable or FALSE to disable the platform layer to transmit stream.\n\n @retval OT_ERROR_NONE             Successfully enabled/disabled.\n @retval OT_ERROR_INVALID_STATE    The radio was not in the Receive state.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented."]
6246    pub fn otPlatDiagRadioTransmitStream(aInstance: *mut otInstance, aEnable: bool) -> otError;
6247}
6248extern "C" {
6249    #[doc = " Get the power settings for the given channel.\n\n @param[in]      aInstance               The OpenThread instance structure.\n @param[in]      aChannel                The radio channel.\n @param[out]     aTargetPower            The target power in 0.01 dBm.\n @param[out]     aActualPower            The actual power in 0.01 dBm.\n @param[out]     aRawPowerSetting        A pointer to the raw power setting byte array.\n @param[in,out]  aRawPowerSettingLength  On input, a pointer to the size of @p aRawPowerSetting.\n                                         On output, a pointer to the length of the raw power setting data.\n\n @retval  OT_ERROR_NONE             Successfully got the target power.\n @retval  OT_ERROR_INVALID_ARGS     The @p aChannel is invalid, @aTargetPower, @p aActualPower, @p aRawPowerSetting or\n                                    @p aRawPowerSettingLength is NULL or @aRawPowerSettingLength is too short.\n @retval  OT_ERROR_NOT_FOUND        The power settings for the @p aChannel was not found.\n @retval  OT_ERROR_NOT_IMPLEMENTED  This method is not implemented."]
6250    pub fn otPlatDiagRadioGetPowerSettings(
6251        aInstance: *mut otInstance,
6252        aChannel: u8,
6253        aTargetPower: *mut i16,
6254        aActualPower: *mut i16,
6255        aRawPowerSetting: *mut u8,
6256        aRawPowerSettingLength: *mut u16,
6257    ) -> otError;
6258}
6259#[doc = " @addtogroup api-factory-diagnostics\n\n @brief\n   This module includes functions that control the Thread stack's execution.\n\n @{"]
6260pub type otDiagOutputCallback = otPlatDiagOutputCallback;
6261extern "C" {
6262    #[doc = " Sets the diag output callback.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aCallback   A pointer to a function that is called on outputting diag messages.\n @param[in]  aContext    A pointer to the user context."]
6263    pub fn otDiagSetOutputCallback(
6264        aInstance: *mut otInstance,
6265        aCallback: otDiagOutputCallback,
6266        aContext: *mut ::std::os::raw::c_void,
6267    );
6268}
6269extern "C" {
6270    #[doc = " Processes a factory diagnostics command line.\n\n @param[in]   aInstance       A pointer to an OpenThread instance.\n @param[in]   aArgsLength     The number of elements in @p aArgs.\n @param[in]   aArgs           An array of arguments.\n\n @retval  OT_ERROR_INVALID_ARGS       The command is supported but invalid arguments provided.\n @retval  OT_ERROR_NONE               The command is successfully process.\n @retval  OT_ERROR_NOT_IMPLEMENTED    The command is not supported."]
6271    pub fn otDiagProcessCmd(
6272        aInstance: *mut otInstance,
6273        aArgsLength: u8,
6274        aArgs: *mut *mut ::std::os::raw::c_char,
6275    ) -> otError;
6276}
6277extern "C" {
6278    #[doc = " Processes a factory diagnostics command line.\n\n @param[in]   aInstance       A pointer to an OpenThread instance.\n @param[in]   aString         A NULL-terminated input string.\n\n @retval  OT_ERROR_NONE               The command is successfully process.\n @retval  OT_ERROR_INVALID_ARGS       The command is supported but invalid arguments provided.\n @retval  OT_ERROR_NOT_IMPLEMENTED    The command is not supported.\n @retval  OT_ERROR_NO_BUFS            The command string is too long."]
6279    pub fn otDiagProcessCmdLine(
6280        aInstance: *mut otInstance,
6281        aString: *const ::std::os::raw::c_char,
6282    ) -> otError;
6283}
6284extern "C" {
6285    #[doc = " Indicates whether or not the factory diagnostics mode is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE if factory diagnostics mode is enabled\n @retval FALSE if factory diagnostics mode is disabled."]
6286    pub fn otDiagIsEnabled(aInstance: *mut otInstance) -> bool;
6287}
6288#[doc = " Represents a TXT record entry representing a key/value pair (RFC 6763 - section 6.3).\n\n The string buffers pointed to by `mKey` and `mValue` MUST persist and remain unchanged after an instance of such\n structure is passed to OpenThread (as part of `otSrpClientService` instance).\n\n An array of `otDnsTxtEntry` entries are used in `otSrpClientService` to specify the full TXT record (a list of\n entries)."]
6289#[repr(C)]
6290#[derive(Debug, Copy, Clone)]
6291pub struct otDnsTxtEntry {
6292    #[doc = " The TXT record key string.\n\n If `mKey` is not NULL, then it MUST be a null-terminated C string. The entry is treated as key/value pair with\n `mValue` buffer providing the value.\n   - The entry is encoded as follows:\n        - A single string length byte followed by \"key=value\" format (without the quotation marks).\n- In this case, the overall encoded length must be 255 bytes or less.\n   - If `mValue` is NULL, then key is treated as a boolean attribute and encoded as \"key\" (with no `=`).\n   - If `mValue` is not NULL but `mValueLength` is zero, then it is treated as empty value and encoded as \"key=\".\n\n If `mKey` is NULL, then `mValue` buffer is treated as an already encoded TXT-DATA and is appended as is in the\n DNS message."]
6293    pub mKey: *const ::std::os::raw::c_char,
6294    #[doc = "< The TXT record value or already encoded TXT-DATA (depending on `mKey`)."]
6295    pub mValue: *const u8,
6296    #[doc = "< Number of bytes in `mValue` buffer."]
6297    pub mValueLength: u16,
6298}
6299impl Default for otDnsTxtEntry {
6300    fn default() -> Self {
6301        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6302        unsafe {
6303            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6304            s.assume_init()
6305        }
6306    }
6307}
6308#[doc = " Represents an iterator for TXT record entries (key/value pairs).\n\n The data fields in this structure are intended for use by OpenThread core and caller should not read or change them."]
6309#[repr(C)]
6310#[derive(Debug, Copy, Clone)]
6311pub struct otDnsTxtEntryIterator {
6312    pub mPtr: *const ::std::os::raw::c_void,
6313    pub mData: [u16; 2usize],
6314    pub mChar: [::std::os::raw::c_char; 65usize],
6315}
6316impl Default for otDnsTxtEntryIterator {
6317    fn default() -> Self {
6318        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6319        unsafe {
6320            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6321            s.assume_init()
6322        }
6323    }
6324}
6325extern "C" {
6326    #[doc = " Initializes a TXT record iterator.\n\n The buffer pointer @p aTxtData and its content MUST persist and remain unchanged while @p aIterator object\n is being used.\n\n @param[in] aIterator       A pointer to the iterator to initialize (MUST NOT be NULL).\n @param[in] aTxtData        A pointer to buffer containing the encoded TXT data.\n @param[in] aTxtDataLength  The length (number of bytes) of @p aTxtData."]
6327    pub fn otDnsInitTxtEntryIterator(
6328        aIterator: *mut otDnsTxtEntryIterator,
6329        aTxtData: *const u8,
6330        aTxtDataLength: u16,
6331    );
6332}
6333extern "C" {
6334    #[doc = " Parses the TXT data from an iterator and gets the next TXT record entry (key/value pair).\n\n The @p aIterator MUST be initialized using `otDnsInitTxtEntryIterator()` before calling this function and the TXT\n data buffer used to initialize the iterator MUST persist and remain unchanged. Otherwise the behavior of this\n function is undefined.\n\n If the parsed key string length is smaller than or equal to `OT_DNS_TXT_KEY_ITER_MAX_LENGTH` the key string is\n returned in `mKey` in @p aEntry. But if the key is longer, then `mKey` is set to NULL and the entire encoded TXT\n entry string is returned in `mValue` and `mValueLength`.\n\n @param[in]  aIterator   A pointer to the iterator (MUST NOT be NULL).\n @param[out] aEntry      A pointer to a `otDnsTxtEntry` structure to output the parsed/read entry (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE       The next entry was parsed successfully. @p aEntry is updated.\n @retval OT_ERROR_NOT_FOUND  No more entries in the TXT data.\n @retval OT_ERROR_PARSE      The TXT data from @p aIterator is not well-formed."]
6335    pub fn otDnsGetNextTxtEntry(
6336        aIterator: *mut otDnsTxtEntryIterator,
6337        aEntry: *mut otDnsTxtEntry,
6338    ) -> otError;
6339}
6340extern "C" {
6341    #[doc = " Encodes a given list of TXT record entries (key/value pairs) into TXT data (following format specified by RFC 6763).\n\n @param[in]      aTxtEntries      Pointer to an array of `otDnsTxtEntry`.\n @param[in]      aNumTxtEntries   Number of entries in @p aTxtEntries array.\n @param[out]     aTxtData         A pointer to a buffer to output the encoded TXT data.\n @param[in,out]  aTxtDataLength   On input, size of buffer @p aTxtData. On output, length of the encoded TXT data.\n\n @retval OT_ERROR_NONE          Encoded TXT data successfully, @p aTxtData and @p aTxtDataLength are updated.\n @retval OT_ERROR_INVALID_ARGS  The @p aTxtEntries is not valid.\n @retval OT_ERROR_NO_BUS        Could not fit the encoded data in @p aTxtData buffer with its @p aTxtDataLength."]
6342    pub fn otDnsEncodeTxtData(
6343        aTxtEntries: *const otDnsTxtEntry,
6344        aNumTxtEntries: u16,
6345        aTxtData: *mut u8,
6346        aTxtDataLength: *mut u16,
6347    ) -> otError;
6348}
6349extern "C" {
6350    #[doc = " Enables/disables the \"DNS name compression\" mode.\n\n By default DNS name compression is enabled. When disabled, DNS names are appended as full and never compressed. This\n is applicable to OpenThread's DNS and SRP client/server modules.\n\n This is intended for testing only and available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` config is enabled.\n\n Note that in the case `OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE` is used, this mode applies to all OpenThread\n instances (i.e., calling this function enables/disables the compression mode on all OpenThread instances).\n\n @param[in] aEnabled   TRUE to enable the \"DNS name compression\" mode, FALSE to disable."]
6351    pub fn otDnsSetNameCompressionEnabled(aEnabled: bool);
6352}
6353extern "C" {
6354    #[doc = " Indicates whether the \"DNS name compression\" mode is enabled or not.\n\n This is intended for testing only and available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` config is enabled.\n\n @returns TRUE if the \"DNS name compression\" mode is enabled, FALSE otherwise."]
6355    pub fn otDnsIsNameCompressionEnabled() -> bool;
6356}
6357#[doc = "< Indicates the flag is not specified."]
6358pub const OT_DNS_FLAG_UNSPECIFIED: otDnsRecursionFlag = 0;
6359#[doc = "< Indicates DNS name server can resolve the query recursively."]
6360pub const OT_DNS_FLAG_RECURSION_DESIRED: otDnsRecursionFlag = 1;
6361#[doc = "< Indicates DNS name server can not resolve the query recursively."]
6362pub const OT_DNS_FLAG_NO_RECURSION: otDnsRecursionFlag = 2;
6363#[doc = " Type represents the \"Recursion Desired\" (RD) flag in an `otDnsQueryConfig`."]
6364pub type otDnsRecursionFlag = ::std::os::raw::c_uint;
6365#[doc = "< NAT64 mode is not specified. Use default NAT64 mode."]
6366pub const OT_DNS_NAT64_UNSPECIFIED: otDnsNat64Mode = 0;
6367#[doc = "< Allow NAT64 address translation during DNS client address resolution."]
6368pub const OT_DNS_NAT64_ALLOW: otDnsNat64Mode = 1;
6369#[doc = "< Do not allow NAT64 address translation during DNS client address resolution."]
6370pub const OT_DNS_NAT64_DISALLOW: otDnsNat64Mode = 2;
6371#[doc = " Type represents the NAT64 mode in an `otDnsQueryConfig`.\n\n The NAT64 mode indicates whether to allow or disallow NAT64 address translation during DNS client address resolution.\n This mode is only used when `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` is enabled."]
6372pub type otDnsNat64Mode = ::std::os::raw::c_uint;
6373#[doc = "< Mode is not specified. Use default service mode."]
6374pub const OT_DNS_SERVICE_MODE_UNSPECIFIED: otDnsServiceMode = 0;
6375#[doc = "< Query for SRV record only."]
6376pub const OT_DNS_SERVICE_MODE_SRV: otDnsServiceMode = 1;
6377#[doc = "< Query for TXT record only."]
6378pub const OT_DNS_SERVICE_MODE_TXT: otDnsServiceMode = 2;
6379#[doc = "< Query for both SRV and TXT records in same message."]
6380pub const OT_DNS_SERVICE_MODE_SRV_TXT: otDnsServiceMode = 3;
6381#[doc = "< Query in parallel for SRV and TXT using separate messages."]
6382pub const OT_DNS_SERVICE_MODE_SRV_TXT_SEPARATE: otDnsServiceMode = 4;
6383#[doc = "< Query for TXT/SRV together first, if fails then query separately."]
6384pub const OT_DNS_SERVICE_MODE_SRV_TXT_OPTIMIZE: otDnsServiceMode = 5;
6385#[doc = " Type represents the service resolution mode in an `otDnsQueryConfig`.\n\n This is only used during DNS client service resolution `otDnsClientResolveService()`. It determines which\n record types to query."]
6386pub type otDnsServiceMode = ::std::os::raw::c_uint;
6387pub const OT_DNS_TRANSPORT_UNSPECIFIED: otDnsTransportProto = 0;
6388#[doc = " DNS transport is unspecified."]
6389pub const OT_DNS_TRANSPORT_UDP: otDnsTransportProto = 1;
6390#[doc = " DNS query should be sent via UDP."]
6391pub const OT_DNS_TRANSPORT_TCP: otDnsTransportProto = 2;
6392#[doc = " Type represents the DNS transport protocol in an `otDnsQueryConfig`.\n\n This `OT_DNS_TRANSPORT_TCP` is only supported when `OPENTHREAD_CONFIG_DNS_CLIENT_OVER_TCP_ENABLE` is enabled."]
6393pub type otDnsTransportProto = ::std::os::raw::c_uint;
6394#[doc = " Represents a DNS query configuration.\n\n Any of the fields in this structure can be set to zero to indicate that it is not specified. How the unspecified\n fields are treated is determined by the function which uses the instance of `otDnsQueryConfig`."]
6395#[repr(C)]
6396#[derive(Copy, Clone)]
6397pub struct otDnsQueryConfig {
6398    #[doc = "< Server address (IPv6 addr/port). All zero or zero port for unspecified."]
6399    pub mServerSockAddr: otSockAddr,
6400    #[doc = "< Wait time (in msec) to rx response. Zero indicates unspecified value."]
6401    pub mResponseTimeout: u32,
6402    #[doc = "< Maximum tx attempts before reporting failure. Zero for unspecified value."]
6403    pub mMaxTxAttempts: u8,
6404    #[doc = "< Indicates whether the server can resolve the query recursively or not."]
6405    pub mRecursionFlag: otDnsRecursionFlag,
6406    #[doc = "< Allow/Disallow NAT64 address translation during address resolution."]
6407    pub mNat64Mode: otDnsNat64Mode,
6408    #[doc = "< Determines which records to query during service resolution."]
6409    pub mServiceMode: otDnsServiceMode,
6410    #[doc = "< Select default transport protocol."]
6411    pub mTransportProto: otDnsTransportProto,
6412}
6413impl Default for otDnsQueryConfig {
6414    fn default() -> Self {
6415        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6416        unsafe {
6417            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6418            s.assume_init()
6419        }
6420    }
6421}
6422extern "C" {
6423    #[doc = " Gets the current default query config used by DNS client.\n\n When OpenThread stack starts, the default DNS query config is determined from a set of OT config options such as\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_SERVER_IP6_ADDRESS`, `_DEFAULT_SERVER_PORT`, `_DEFAULT_RESPONSE_TIMEOUT`, etc.\n (see `config/dns_client.h` for all related config options).\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n\n @returns A pointer to the current default config being used by DNS client."]
6424    pub fn otDnsClientGetDefaultConfig(aInstance: *mut otInstance) -> *const otDnsQueryConfig;
6425}
6426extern "C" {
6427    #[doc = " Sets the default query config on DNS client.\n\n @note Any ongoing query will continue to use the config from when it was started. The new default config will be\n used for any future DNS queries.\n\n The @p aConfig can be NULL. In this case the default config will be set to the defaults from OT config options\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_{}`. This resets the default query config back to to the config when the\n OpenThread stack starts.\n\n In a non-NULL @p aConfig, caller can choose to leave some of the fields in `otDnsQueryConfig` instance unspecified\n (value zero). The unspecified fields are replaced by the corresponding OT config option definitions\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_{}` to form the default query config.\n\n When `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_SERVER_ADDRESS_AUTO_SET_ENABLE` is enabled, the server's IPv6 address in\n the default config is automatically set and updated by DNS client. This is done only when user does not explicitly\n set or specify it. This behavior requires SRP client and its auto-start feature to be enabled. SRP client will then\n monitor the Thread Network Data for DNS/SRP Service entries to select an SRP server. The selected SRP server address\n is also set as the DNS server address in the default config.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aConfig     A pointer to the new query config to use as default."]
6428    pub fn otDnsClientSetDefaultConfig(
6429        aInstance: *mut otInstance,
6430        aConfig: *const otDnsQueryConfig,
6431    );
6432}
6433#[repr(C)]
6434#[derive(Debug, Copy, Clone)]
6435pub struct otDnsAddressResponse {
6436    _unused: [u8; 0],
6437}
6438#[doc = " Pointer is called when a DNS response is received for an address resolution query.\n\n Within this callback the user can use `otDnsAddressResponseGet{Item}()` functions along with the @p aResponse\n pointer to get more info about the response.\n\n The @p aResponse pointer can only be used within this callback and after returning from this function it will not\n stay valid, so the user MUST NOT retain the @p aResponse pointer for later use.\n\n @param[in]  aError     The result of the DNS transaction.\n @param[in]  aResponse  A pointer to the response (it is always non-NULL).\n @param[in]  aContext   A pointer to application-specific context.\n\n The @p aError can have the following:\n\n  - OT_ERROR_NONE              A response was received successfully.\n  - OT_ERROR_ABORT             A DNS transaction was aborted by stack.\n  - OT_ERROR_RESPONSE_TIMEOUT  No DNS response has been received within timeout.\n\n If the server rejects the address resolution request the error code from server is mapped as follow:\n\n  - (0)  NOERROR   Success (no error condition)                    -> OT_ERROR_NONE\n  - (1)  FORMERR   Server unable to interpret due to format error  -> OT_ERROR_PARSE\n  - (2)  SERVFAIL  Server encountered an internal failure          -> OT_ERROR_FAILED\n  - (3)  NXDOMAIN  Name that ought to exist, does not exist        -> OT_ERROR_NOT_FOUND\n  - (4)  NOTIMP    Server does not support the query type (OpCode) -> OT_ERROR_NOT_IMPLEMENTED\n  - (5)  REFUSED   Server refused for policy/security reasons      -> OT_ERROR_SECURITY\n  - (6)  YXDOMAIN  Some name that ought not to exist, does exist   -> OT_ERROR_DUPLICATED\n  - (7)  YXRRSET   Some RRset that ought not to exist, does exist  -> OT_ERROR_DUPLICATED\n  - (8)  NXRRSET   Some RRset that ought to exist, does not exist  -> OT_ERROR_NOT_FOUND\n  - (9)  NOTAUTH   Service is not authoritative for zone           -> OT_ERROR_SECURITY\n  - (10) NOTZONE   A name is not in the zone                       -> OT_ERROR_PARSE\n  - (20) BADNAME   Bad name                                        -> OT_ERROR_PARSE\n  - (21) BADALG    Bad algorithm                                   -> OT_ERROR_SECURITY\n  - (22) BADTRUN   Bad truncation                                  -> OT_ERROR_PARSE\n  - Other response codes                                           -> OT_ERROR_FAILED"]
6439pub type otDnsAddressCallback = ::std::option::Option<
6440    unsafe extern "C" fn(
6441        aError: otError,
6442        aResponse: *const otDnsAddressResponse,
6443        aContext: *mut ::std::os::raw::c_void,
6444    ),
6445>;
6446extern "C" {
6447    #[doc = " Sends an address resolution DNS query for AAAA (IPv6) record(s) for a given host name.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aHostName        The host name for which to query the address (MUST NOT be NULL).\n @param[in]  aCallback        A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext         A pointer to arbitrary context information.\n @param[in]  aConfig          A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE          Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS  The host name is not valid format.\n @retval OT_ERROR_INVALID_STATE Cannot send query since Thread interface is not up."]
6448    pub fn otDnsClientResolveAddress(
6449        aInstance: *mut otInstance,
6450        aHostName: *const ::std::os::raw::c_char,
6451        aCallback: otDnsAddressCallback,
6452        aContext: *mut ::std::os::raw::c_void,
6453        aConfig: *const otDnsQueryConfig,
6454    ) -> otError;
6455}
6456extern "C" {
6457    #[doc = " Sends an address resolution DNS query for A (IPv4) record(s) for a given host name.\n\n Requires and is available when `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` is enabled.\n\n When a successful response is received, the addresses are returned from @p aCallback as NAT64 IPv6 translated\n versions of the IPv4 addresses from the query response.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aHostName        The host name for which to query the address (MUST NOT be NULL).\n @param[in]  aCallback        A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext         A pointer to arbitrary context information.\n @param[in]  aConfig          A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE          Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS  The host name is not valid format or NAT64 is not enabled in config.\n @retval OT_ERROR_INVALID_STATE Cannot send query since Thread interface is not up."]
6458    pub fn otDnsClientResolveIp4Address(
6459        aInstance: *mut otInstance,
6460        aHostName: *const ::std::os::raw::c_char,
6461        aCallback: otDnsAddressCallback,
6462        aContext: *mut ::std::os::raw::c_void,
6463        aConfig: *const otDnsQueryConfig,
6464    ) -> otError;
6465}
6466extern "C" {
6467    #[doc = " Gets the full host name associated with an address resolution DNS response.\n\n MUST only be used from `otDnsAddressCallback`.\n\n @param[in]  aResponse         A pointer to the response.\n @param[out] aNameBuffer       A buffer to char array to output the full host name (MUST NOT be NULL).\n @param[in]  aNameBufferSize   The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE     The full host name was read successfully.\n @retval OT_ERROR_NO_BUFS  The name does not fit in @p aNameBuffer."]
6468    pub fn otDnsAddressResponseGetHostName(
6469        aResponse: *const otDnsAddressResponse,
6470        aNameBuffer: *mut ::std::os::raw::c_char,
6471        aNameBufferSize: u16,
6472    ) -> otError;
6473}
6474extern "C" {
6475    #[doc = " Gets an IPv6 address associated with an address resolution DNS response.\n\n MUST only be used from `otDnsAddressCallback`.\n\n The response may include multiple IPv6 address records. @p aIndex can be used to iterate through the list of\n addresses. Index zero gets the first address and so on. When we reach end of the list, `OT_ERROR_NOT_FOUND` is\n returned.\n\n @param[in]  aResponse     A pointer to the response.\n @param[in]  aIndex        The address record index to retrieve.\n @param[out] aAddress      A pointer to a IPv6 address to output the address (MUST NOT be NULL).\n @param[out] aTtl          A pointer to an `uint32_t` to output TTL for the address. It can be NULL if caller does not\n                           want to get the TTL.\n\n @retval OT_ERROR_NONE           The address was read successfully.\n @retval OT_ERROR_NOT_FOUND      No address record in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE          Could not parse the records in the @p aResponse.\n @retval OT_ERROR_INVALID_STATE  No NAT64 prefix (applicable only when NAT64 is allowed)."]
6476    pub fn otDnsAddressResponseGetAddress(
6477        aResponse: *const otDnsAddressResponse,
6478        aIndex: u16,
6479        aAddress: *mut otIp6Address,
6480        aTtl: *mut u32,
6481    ) -> otError;
6482}
6483#[repr(C)]
6484#[derive(Debug, Copy, Clone)]
6485pub struct otDnsBrowseResponse {
6486    _unused: [u8; 0],
6487}
6488#[doc = " Pointer is called when a DNS response is received for a browse (service instance enumeration) query.\n\n Within this callback the user can use `otDnsBrowseResponseGet{Item}()` functions along with the @p aResponse\n pointer to get more info about the response.\n\n The @p aResponse pointer can only be used within this callback and after returning from this function it will not\n stay valid, so the user MUST NOT retain the @p aResponse pointer for later use.\n\n @param[in]  aError     The result of the DNS transaction.\n @param[in]  aResponse  A pointer to the response (it is always non-NULL).\n @param[in]  aContext   A pointer to application-specific context.\n\n For the full list of possible values for @p aError, please see `otDnsAddressCallback()`."]
6489pub type otDnsBrowseCallback = ::std::option::Option<
6490    unsafe extern "C" fn(
6491        aError: otError,
6492        aResponse: *const otDnsBrowseResponse,
6493        aContext: *mut ::std::os::raw::c_void,
6494    ),
6495>;
6496#[doc = " Provides info for a DNS service instance."]
6497#[repr(C)]
6498#[derive(Copy, Clone)]
6499pub struct otDnsServiceInfo {
6500    #[doc = "< Service record TTL (in seconds)."]
6501    pub mTtl: u32,
6502    #[doc = "< Service port number."]
6503    pub mPort: u16,
6504    #[doc = "< Service priority."]
6505    pub mPriority: u16,
6506    #[doc = "< Service weight."]
6507    pub mWeight: u16,
6508    #[doc = "< Buffer to output the service host name (can be NULL if not needed)."]
6509    pub mHostNameBuffer: *mut ::std::os::raw::c_char,
6510    #[doc = "< Size of `mHostNameBuffer`."]
6511    pub mHostNameBufferSize: u16,
6512    #[doc = "< The host IPv6 address. Set to all zero if not available."]
6513    pub mHostAddress: otIp6Address,
6514    #[doc = "< The host address TTL."]
6515    pub mHostAddressTtl: u32,
6516    #[doc = "< Buffer to output TXT data (can be NULL if not needed)."]
6517    pub mTxtData: *mut u8,
6518    #[doc = "< On input, size of `mTxtData` buffer. On output number bytes written."]
6519    pub mTxtDataSize: u16,
6520    #[doc = "< Indicates if TXT data could not fit in `mTxtDataSize` and was truncated."]
6521    pub mTxtDataTruncated: bool,
6522    #[doc = "< The TXT data TTL."]
6523    pub mTxtDataTtl: u32,
6524}
6525impl Default for otDnsServiceInfo {
6526    fn default() -> Self {
6527        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6528        unsafe {
6529            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6530            s.assume_init()
6531        }
6532    }
6533}
6534extern "C" {
6535    #[doc = " Sends a DNS browse (service instance enumeration) query for a given service name.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aServiceName     The service name to query for (MUST NOT be NULL).\n @param[in]  aCallback        A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext         A pointer to arbitrary context information.\n @param[in]  aConfig          A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE        Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS     Insufficient buffer to prepare and send query."]
6536    pub fn otDnsClientBrowse(
6537        aInstance: *mut otInstance,
6538        aServiceName: *const ::std::os::raw::c_char,
6539        aCallback: otDnsBrowseCallback,
6540        aContext: *mut ::std::os::raw::c_void,
6541        aConfig: *const otDnsQueryConfig,
6542    ) -> otError;
6543}
6544extern "C" {
6545    #[doc = " Gets the service name associated with a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n @param[in]  aResponse         A pointer to the response.\n @param[out] aNameBuffer       A buffer to char array to output the service name (MUST NOT be NULL).\n @param[in]  aNameBufferSize   The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE     The service name was read successfully.\n @retval OT_ERROR_NO_BUFS  The name does not fit in @p aNameBuffer."]
6546    pub fn otDnsBrowseResponseGetServiceName(
6547        aResponse: *const otDnsBrowseResponse,
6548        aNameBuffer: *mut ::std::os::raw::c_char,
6549        aNameBufferSize: u16,
6550    ) -> otError;
6551}
6552extern "C" {
6553    #[doc = " Gets a service instance associated with a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n The response may include multiple service instance records. @p aIndex can be used to iterate through the list. Index\n zero gives the first record. When we reach end of the list, `OT_ERROR_NOT_FOUND` is returned.\n\n Note that this function gets the service instance label and not the full service instance name which is of the form\n `<Instance>.<Service>.<Domain>`.\n\n @param[in]  aResponse          A pointer to the response.\n @param[in]  aIndex             The service instance record index to retrieve.\n @param[out] aLabelBuffer       A buffer to char array to output the service instance label (MUST NOT be NULL).\n @param[in]  aLabelBufferSize   The size of @p aLabelBuffer.\n\n @retval OT_ERROR_NONE          The service instance was read successfully.\n @retval OT_ERROR_NO_BUFS       The name does not fit in @p aNameBuffer.\n @retval OT_ERROR_NOT_FOUND     No service instance record in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE         Could not parse the records in the @p aResponse."]
6554    pub fn otDnsBrowseResponseGetServiceInstance(
6555        aResponse: *const otDnsBrowseResponse,
6556        aIndex: u16,
6557        aLabelBuffer: *mut ::std::os::raw::c_char,
6558        aLabelBufferSize: u8,
6559    ) -> otError;
6560}
6561extern "C" {
6562    #[doc = " Gets info for a service instance from a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n A browse DNS response can include SRV, TXT, and AAAA records for the service instances that are enumerated. This is\n a SHOULD and not a MUST requirement, and servers/resolvers are not required to provide this. This function attempts\n to retrieve this info for a given service instance when available.\n\n - If no matching SRV record is found in @p aResponse, `OT_ERROR_NOT_FOUND` is returned. In this case, no additional\n   records (no TXT and/or AAAA) are read.\n - If a matching SRV record is found in @p aResponse, @p aServiceInfo is updated and `OT_ERROR_NONE` is returned.\n - If no matching TXT record is found in @p aResponse, `mTxtDataSize` in @p aServiceInfo is set to zero.\n - If TXT data length is greater than `mTxtDataSize`, it is read partially and `mTxtDataTruncated` is set to true.\n - If no matching AAAA record is found in @p aResponse, `mHostAddress is set to all zero or unspecified address.\n - If there are multiple AAAA records for the host name in @p aResponse, `mHostAddress` is set to the first one. The\n   other addresses can be retrieved using `otDnsBrowseResponseGetHostAddress()`.\n\n @param[in]  aResponse          A pointer to the response.\n @param[in]  aInstanceLabel     The service instance label (MUST NOT be NULL).\n @param[out] aServiceInfo       A `ServiceInfo` to output the service instance information (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE          The service instance info was read. @p aServiceInfo is updated.\n @retval OT_ERROR_NOT_FOUND     Could not find a matching SRV record for @p aInstanceLabel.\n @retval OT_ERROR_NO_BUFS       The host name and/or TXT data could not fit in the given buffers.\n @retval OT_ERROR_PARSE         Could not parse the records in the @p aResponse."]
6563    pub fn otDnsBrowseResponseGetServiceInfo(
6564        aResponse: *const otDnsBrowseResponse,
6565        aInstanceLabel: *const ::std::os::raw::c_char,
6566        aServiceInfo: *mut otDnsServiceInfo,
6567    ) -> otError;
6568}
6569extern "C" {
6570    #[doc = " Gets the host IPv6 address from a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n The response can include zero or more IPv6 address records. @p aIndex can be used to iterate through the list of\n addresses. Index zero gets the first address and so on. When we reach end of the list, `OT_ERROR_NOT_FOUND` is\n returned.\n\n @param[in]  aResponse     A pointer to the response.\n @param[in]  aHostName     The host name to get the address (MUST NOT be NULL).\n @param[in]  aIndex        The address record index to retrieve.\n @param[out] aAddress      A pointer to a IPv6 address to output the address (MUST NOT be NULL).\n @param[out] aTtl          A pointer to an `uint32_t` to output TTL for the address. It can be NULL if caller does\n                           not want to get the TTL.\n\n @retval OT_ERROR_NONE       The address was read successfully.\n @retval OT_ERROR_NOT_FOUND  No address record for @p aHostname in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE      Could not parse the records in the @p aResponse."]
6571    pub fn otDnsBrowseResponseGetHostAddress(
6572        aResponse: *const otDnsBrowseResponse,
6573        aHostName: *const ::std::os::raw::c_char,
6574        aIndex: u16,
6575        aAddress: *mut otIp6Address,
6576        aTtl: *mut u32,
6577    ) -> otError;
6578}
6579#[repr(C)]
6580#[derive(Debug, Copy, Clone)]
6581pub struct otDnsServiceResponse {
6582    _unused: [u8; 0],
6583}
6584#[doc = " Pointer is called when a DNS response is received for a service instance resolution query.\n\n Within this callback the user can use `otDnsServiceResponseGet{Item}()` functions along with the @p aResponse\n pointer to get more info about the response.\n\n The @p aResponse pointer can only be used within this callback and after returning from this function it will not\n stay valid, so the user MUST NOT retain the @p aResponse pointer for later use.\n\n @param[in]  aError     The result of the DNS transaction.\n @param[in]  aResponse  A pointer to the response (it is always non-NULL).\n @param[in]  aContext   A pointer to application-specific context.\n\n For the full list of possible values for @p aError, please see `otDnsAddressCallback()`."]
6585pub type otDnsServiceCallback = ::std::option::Option<
6586    unsafe extern "C" fn(
6587        aError: otError,
6588        aResponse: *const otDnsServiceResponse,
6589        aContext: *mut ::std::os::raw::c_void,
6590    ),
6591>;
6592extern "C" {
6593    #[doc = " Starts a DNS service instance resolution for a given service instance.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n The function sends queries for SRV and/or TXT records for the given service instance. The `mServiceMode` field in\n `otDnsQueryConfig` determines which records to query (SRV only, TXT only, or both SRV and TXT) and how to perform\n the query (together in the same message, separately in parallel, or in optimized mode where client will try in the\n same message first and then separately if it fails to get a response).\n\n The SRV record provides information about service port, priority, and weight along with the host name associated\n with the service instance. This function DOES NOT perform address resolution for the host name discovered from SRV\n record. The server/resolver may provide AAAA/A record(s) for the host name in the Additional Data section of the\n response to SRV/TXT query and this information can be retrieved using `otDnsServiceResponseGetServiceInfo()` in\n `otDnsServiceCallback`. Users of this API MUST NOT assume that host address will always be available from\n `otDnsServiceResponseGetServiceInfo()`.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aInstanceLabel     The service instance label.\n @param[in]  aServiceName       The service name (together with @p aInstanceLabel form full instance name).\n @param[in]  aCallback          A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext           A pointer to arbitrary context information.\n @param[in]  aConfig            A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE          Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS  @p aInstanceLabel is NULL."]
6594    pub fn otDnsClientResolveService(
6595        aInstance: *mut otInstance,
6596        aInstanceLabel: *const ::std::os::raw::c_char,
6597        aServiceName: *const ::std::os::raw::c_char,
6598        aCallback: otDnsServiceCallback,
6599        aContext: *mut ::std::os::raw::c_void,
6600        aConfig: *const otDnsQueryConfig,
6601    ) -> otError;
6602}
6603extern "C" {
6604    #[doc = " Starts a DNS service instance resolution for a given service instance, with a potential follow-up\n address resolution for the host name discovered for the service instance.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config. This function cannot be used with\n `mServiceMode` in DNS config set to `OT_DNS_SERVICE_MODE_TXT` (i.e., querying for TXT record only) and will return\n `OT_ERROR_INVALID_ARGS`.\n\n Behaves similarly to `otDnsClientResolveService()` sending queries for SRV and TXT records. However,\n if the server/resolver does not provide AAAA/A records for the host name in the response to SRV query (in the\n Additional Data section), it will perform host name resolution (sending an AAAA query) for the discovered host name\n from the SRV record. The callback @p aCallback is invoked when responses for all queries are received (i.e., both\n service and host address resolutions are finished).\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aInstanceLabel     The service instance label.\n @param[in]  aServiceName       The service name (together with @p aInstanceLabel form full instance name).\n @param[in]  aCallback          A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext           A pointer to arbitrary context information.\n @param[in]  aConfig            A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE          Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS       Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS  @p aInstanceLabel is NULL, or @p aConfig is invalid."]
6605    pub fn otDnsClientResolveServiceAndHostAddress(
6606        aInstance: *mut otInstance,
6607        aInstanceLabel: *const ::std::os::raw::c_char,
6608        aServiceName: *const ::std::os::raw::c_char,
6609        aCallback: otDnsServiceCallback,
6610        aContext: *mut ::std::os::raw::c_void,
6611        aConfig: *const otDnsQueryConfig,
6612    ) -> otError;
6613}
6614extern "C" {
6615    #[doc = " Gets the service instance name associated with a DNS service instance resolution response.\n\n MUST only be used from `otDnsServiceCallback`.\n\n @param[in]  aResponse         A pointer to the response.\n @param[out] aLabelBuffer      A buffer to char array to output the service instance label (MUST NOT be NULL).\n @param[in]  aLabelBufferSize  The size of @p aLabelBuffer.\n @param[out] aNameBuffer       A buffer to char array to output the rest of service name (can be NULL if user is\n                               not interested in getting the name.\n @param[in]  aNameBufferSize   The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE     The service name was read successfully.\n @retval OT_ERROR_NO_BUFS  Either the label or name does not fit in the given buffers."]
6616    pub fn otDnsServiceResponseGetServiceName(
6617        aResponse: *const otDnsServiceResponse,
6618        aLabelBuffer: *mut ::std::os::raw::c_char,
6619        aLabelBufferSize: u8,
6620        aNameBuffer: *mut ::std::os::raw::c_char,
6621        aNameBufferSize: u16,
6622    ) -> otError;
6623}
6624extern "C" {
6625    #[doc = " Gets info for a service instance from a DNS service instance resolution response.\n\n MUST only be used from a `otDnsServiceCallback` triggered from `otDnsClientResolveService()` or\n `otDnsClientResolveServiceAndHostAddress()`.\n\n When this is is used from a `otDnsClientResolveService()` callback, the DNS response from server/resolver may\n include AAAA records in its Additional Data section for the host name associated with the service instance that is\n resolved. This is a SHOULD and not a MUST requirement so servers/resolvers are not required to provide this. This\n function attempts to parse AAAA record(s) if included in the response. If it is not included `mHostAddress` is set\n to all zeros (unspecified address). To also resolve the host address, user can use the DNS client API function\n `otDnsClientResolveServiceAndHostAddress()` which will perform service resolution followed up by a host name\n address resolution query (when AAAA records are not provided by server/resolver in the SRV query response).\n\n - If a matching SRV record is found in @p aResponse, @p aServiceInfo is updated.\n - If no matching SRV record is found, `OT_ERROR_NOT_FOUND` is returned unless the query config for this query\n   used `OT_DNS_SERVICE_MODE_TXT` for `mServiceMode` (meaning the request was only for TXT record). In this case, we\n   still try to parse the SRV record from Additional Data Section of response (in case server provided the info).\n - If no matching TXT record is found in @p aResponse, `mTxtDataSize` in @p aServiceInfo is set to zero.\n - If TXT data length is greater than `mTxtDataSize`, it is read partially and `mTxtDataTruncated` is set to true.\n - If no matching AAAA record is found in @p aResponse, `mHostAddress is set to all zero or unspecified address.\n - If there are multiple AAAA records for the host name in @p aResponse, `mHostAddress` is set to the first one. The\n   other addresses can be retrieved using `otDnsServiceResponseGetHostAddress()`.\n\n @param[in]  aResponse          A pointer to the response.\n @param[out] aServiceInfo       A `ServiceInfo` to output the service instance information (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE          The service instance info was read. @p aServiceInfo is updated.\n @retval OT_ERROR_NOT_FOUND     Could not find a required record in @p aResponse.\n @retval OT_ERROR_NO_BUFS       The host name and/or TXT data could not fit in the given buffers.\n @retval OT_ERROR_PARSE         Could not parse the records in the @p aResponse."]
6626    pub fn otDnsServiceResponseGetServiceInfo(
6627        aResponse: *const otDnsServiceResponse,
6628        aServiceInfo: *mut otDnsServiceInfo,
6629    ) -> otError;
6630}
6631extern "C" {
6632    #[doc = " Gets the host IPv6 address from a DNS service instance resolution response.\n\n MUST only be used from `otDnsServiceCallback`.\n\n The response can include zero or more IPv6 address records. @p aIndex can be used to iterate through the list of\n addresses. Index zero gets the first address and so on. When we reach end of the list, `OT_ERROR_NOT_FOUND` is\n returned.\n\n @param[in]  aResponse     A pointer to the response.\n @param[in]  aHostName     The host name to get the address (MUST NOT be NULL).\n @param[in]  aIndex        The address record index to retrieve.\n @param[out] aAddress      A pointer to a IPv6 address to output the address (MUST NOT be NULL).\n @param[out] aTtl          A pointer to an `uint32_t` to output TTL for the address. It can be NULL if caller does\n                           not want to get the TTL.\n\n @retval OT_ERROR_NONE       The address was read successfully.\n @retval OT_ERROR_NOT_FOUND  No address record for @p aHostname in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE      Could not parse the records in the @p aResponse."]
6633    pub fn otDnsServiceResponseGetHostAddress(
6634        aResponse: *const otDnsServiceResponse,
6635        aHostName: *const ::std::os::raw::c_char,
6636        aIndex: u16,
6637        aAddress: *mut otIp6Address,
6638        aTtl: *mut u32,
6639    ) -> otError;
6640}
6641#[doc = " Is called when a DNS-SD query subscribes one of:\n      1. a service name.\n      2. a service instance name.\n      3. a host name.\n\n The DNS-SD query implementation is responsible for identifying what @p aFullName is.\n If @p aFullName is a service name or service instance name, the DNS-SD query implementation should discover\n corresponding service instance information and notify the DNS-SD server using\n `otDnssdQueryHandleDiscoveredServiceInstance`.\n If @p aFullName is a host name, the DNS-SD query implementation should\n discover the host information and notify the DNS-SD server using `otDnssdQueryHandleDiscoveredHost`.\n\n @note There can be multiple subscription to the same name. DNS-SD query implementation should record the number of\n active subscriptions and stop notifying when there is no active subscription for @p aFullName.\n\n @param[in] aContext      A pointer to the application-specific context.\n @param[in] aFullName     The null-terminated full service name (e.g. \"_ipps._tcp.default.service.arpa.\"),\n                          or full service instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\"),\n                          or full host name (e.g. \"ot-host.default.service.arpa.\").\n\n @sa otDnssdQueryHandleDiscoveredServiceInstance\n @sa otDnssdQueryHandleDiscoveredHost"]
6642pub type otDnssdQuerySubscribeCallback = ::std::option::Option<
6643    unsafe extern "C" fn(
6644        aContext: *mut ::std::os::raw::c_void,
6645        aFullName: *const ::std::os::raw::c_char,
6646    ),
6647>;
6648#[doc = " Is called when a DNS-SD query unsubscribes one of:\n      1. a service name.\n      2. a service instance name.\n      3. a host name.\n\n The DNS-SD query implementation is responsible for identifying what @p aFullName is.\n\n @note There can be multiple subscription to the same name. DNS-SD query implementation should record the number of\n active subscriptions and stop notifying when there is no active subscription for @p aFullName.\n\n @param[in] aContext      A pointer to the application-specific context.\n @param[in] aFullName     The null-terminated full service name (e.g. \"_ipps._tcp.default.service.arpa.\"), or\n                          full service instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\")."]
6649pub type otDnssdQueryUnsubscribeCallback = ::std::option::Option<
6650    unsafe extern "C" fn(
6651        aContext: *mut ::std::os::raw::c_void,
6652        aFullName: *const ::std::os::raw::c_char,
6653    ),
6654>;
6655#[doc = " This opaque type represents a DNS-SD query."]
6656pub type otDnssdQuery = ::std::os::raw::c_void;
6657#[doc = " Represents information of a discovered service instance for a DNS-SD query."]
6658#[repr(C)]
6659#[derive(Debug, Copy, Clone)]
6660pub struct otDnssdServiceInstanceInfo {
6661    #[doc = "< Full instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\")."]
6662    pub mFullName: *const ::std::os::raw::c_char,
6663    #[doc = "< Host name (e.g. \"ot-host.default.service.arpa.\")."]
6664    pub mHostName: *const ::std::os::raw::c_char,
6665    #[doc = "< Number of host IPv6 addresses."]
6666    pub mAddressNum: u8,
6667    #[doc = "< Host IPv6 addresses."]
6668    pub mAddresses: *const otIp6Address,
6669    #[doc = "< Service port."]
6670    pub mPort: u16,
6671    #[doc = "< Service priority."]
6672    pub mPriority: u16,
6673    #[doc = "< Service weight."]
6674    pub mWeight: u16,
6675    #[doc = "< Service TXT RDATA length."]
6676    pub mTxtLength: u16,
6677    #[doc = "< Service TXT RDATA."]
6678    pub mTxtData: *const u8,
6679    #[doc = "< Service TTL (in seconds)."]
6680    pub mTtl: u32,
6681}
6682impl Default for otDnssdServiceInstanceInfo {
6683    fn default() -> Self {
6684        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6685        unsafe {
6686            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6687            s.assume_init()
6688        }
6689    }
6690}
6691#[doc = " Represents information of a discovered host for a DNS-SD query."]
6692#[repr(C)]
6693#[derive(Debug, Copy, Clone)]
6694pub struct otDnssdHostInfo {
6695    #[doc = "< Number of host IPv6 addresses."]
6696    pub mAddressNum: u8,
6697    #[doc = "< Host IPv6 addresses."]
6698    pub mAddresses: *const otIp6Address,
6699    #[doc = "< Service TTL (in seconds)."]
6700    pub mTtl: u32,
6701}
6702impl Default for otDnssdHostInfo {
6703    fn default() -> Self {
6704        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6705        unsafe {
6706            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6707            s.assume_init()
6708        }
6709    }
6710}
6711#[doc = "< Service type unspecified."]
6712pub const OT_DNSSD_QUERY_TYPE_NONE: otDnssdQueryType = 0;
6713#[doc = "< Service type browse service."]
6714pub const OT_DNSSD_QUERY_TYPE_BROWSE: otDnssdQueryType = 1;
6715#[doc = "< Service type resolve service instance."]
6716pub const OT_DNSSD_QUERY_TYPE_RESOLVE: otDnssdQueryType = 2;
6717#[doc = "< Service type resolve hostname."]
6718pub const OT_DNSSD_QUERY_TYPE_RESOLVE_HOST: otDnssdQueryType = 3;
6719#[doc = " Specifies a DNS-SD query type."]
6720pub type otDnssdQueryType = ::std::os::raw::c_uint;
6721#[doc = " Represents the count of queries, responses, failures handled by upstream DNS server.\n\n Requires `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE`."]
6722#[repr(C)]
6723#[derive(Debug, Default, Copy, Clone)]
6724pub struct otUpstreamDnsCounters {
6725    #[doc = "< The number of queries forwarded."]
6726    pub mQueries: u32,
6727    #[doc = "< The number of responses forwarded."]
6728    pub mResponses: u32,
6729    #[doc = "< The number of upstream DNS failures."]
6730    pub mFailures: u32,
6731}
6732#[doc = " Contains the counters of DNS-SD server."]
6733#[repr(C)]
6734#[derive(Debug, Default, Copy, Clone)]
6735pub struct otDnssdCounters {
6736    #[doc = "< The number of successful responses."]
6737    pub mSuccessResponse: u32,
6738    #[doc = "< The number of server failure responses."]
6739    pub mServerFailureResponse: u32,
6740    #[doc = "< The number of format error responses."]
6741    pub mFormatErrorResponse: u32,
6742    #[doc = "< The number of name error responses."]
6743    pub mNameErrorResponse: u32,
6744    #[doc = "< The number of 'not implemented' responses."]
6745    pub mNotImplementedResponse: u32,
6746    #[doc = "< The number of other responses."]
6747    pub mOtherResponse: u32,
6748    #[doc = "< The number of queries resolved by the local SRP server."]
6749    pub mResolvedBySrp: u32,
6750    #[doc = "< The number of queries, responses,\n< failures handled by upstream DNS server."]
6751    pub mUpstreamDnsCounters: otUpstreamDnsCounters,
6752}
6753extern "C" {
6754    #[doc = " Sets DNS-SD server query callbacks.\n\n The DNS-SD server calls @p aSubscribe to subscribe to a service or service instance to resolve a DNS-SD query and @p\n aUnsubscribe to unsubscribe when the query is resolved or timeout.\n\n @note @p aSubscribe and @p aUnsubscribe must be both set or unset.\n\n @param[in] aInstance     The OpenThread instance structure.\n @param[in] aSubscribe    A pointer to the callback function to subscribe a service or service instance.\n @param[in] aUnsubscribe  A pointer to the callback function to unsubscribe a service or service instance.\n @param[in] aContext      A pointer to the application-specific context."]
6755    pub fn otDnssdQuerySetCallbacks(
6756        aInstance: *mut otInstance,
6757        aSubscribe: otDnssdQuerySubscribeCallback,
6758        aUnsubscribe: otDnssdQueryUnsubscribeCallback,
6759        aContext: *mut ::std::os::raw::c_void,
6760    );
6761}
6762extern "C" {
6763    #[doc = " Notifies a discovered service instance.\n\n The external query resolver (e.g. Discovery Proxy) should call this function to notify OpenThread core of the\n subscribed services or service instances.\n\n @note @p aInstanceInfo must not contain unspecified or link-local or loop-back or multicast IP addresses.\n\n @param[in] aInstance         The OpenThread instance structure.\n @param[in] aServiceFullName  The null-terminated full service name.\n @param[in] aInstanceInfo     A pointer to the discovered service instance information."]
6764    pub fn otDnssdQueryHandleDiscoveredServiceInstance(
6765        aInstance: *mut otInstance,
6766        aServiceFullName: *const ::std::os::raw::c_char,
6767        aInstanceInfo: *mut otDnssdServiceInstanceInfo,
6768    );
6769}
6770extern "C" {
6771    #[doc = " Notifies a discovered host.\n\n The external query resolver (e.g. Discovery Proxy) should call this function to notify OpenThread core of the\n subscribed hosts.\n\n @note @p aHostInfo must not contain unspecified or link-local or loop-back or multicast IP addresses.\n\n @param[in] aInstance         The OpenThread instance structure.\n @param[in] aHostFullName     The null-terminated full host name.\n @param[in] aHostInfo         A pointer to the discovered service instance information."]
6772    pub fn otDnssdQueryHandleDiscoveredHost(
6773        aInstance: *mut otInstance,
6774        aHostFullName: *const ::std::os::raw::c_char,
6775        aHostInfo: *mut otDnssdHostInfo,
6776    );
6777}
6778extern "C" {
6779    #[doc = " Acquires the next query in the DNS-SD server.\n\n @param[in] aInstance         The OpenThread instance structure.\n @param[in] aQuery            The query pointer. Pass NULL to get the first query.\n\n @returns  A pointer to the query or NULL if no more queries."]
6780    pub fn otDnssdGetNextQuery(
6781        aInstance: *mut otInstance,
6782        aQuery: *const otDnssdQuery,
6783    ) -> *const otDnssdQuery;
6784}
6785extern "C" {
6786    #[doc = " Acquires the DNS-SD query type and name for a specific query.\n\n @param[in]   aQuery            The query pointer acquired from `otDnssdGetNextQuery`.\n @param[out]  aNameOutput       The name output buffer, which should be `OT_DNS_MAX_NAME_SIZE` bytes long.\n\n @returns The DNS-SD query type."]
6787    pub fn otDnssdGetQueryTypeAndName(
6788        aQuery: *const otDnssdQuery,
6789        aNameOutput: *mut [::std::os::raw::c_char; 255usize],
6790    ) -> otDnssdQueryType;
6791}
6792extern "C" {
6793    #[doc = " Returns the counters of the DNS-SD server.\n\n @param[in]  aInstance  The OpenThread instance structure.\n\n @returns  A pointer to the counters of the DNS-SD server."]
6794    pub fn otDnssdGetCounters(aInstance: *mut otInstance) -> *const otDnssdCounters;
6795}
6796extern "C" {
6797    #[doc = " Enable or disable forwarding DNS queries to platform DNS upstream API.\n\n Available when `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE` is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   A boolean to enable/disable forwarding DNS queries to upstream.\n\n @sa otPlatDnsStartUpstreamQuery\n @sa otPlatDnsCancelUpstreamQuery\n @sa otPlatDnsUpstreamQueryDone"]
6798    pub fn otDnssdUpstreamQuerySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
6799}
6800extern "C" {
6801    #[doc = " Returns whether the DNSSD server will forward DNS queries to the platform DNS upstream API.\n\n Available when `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE` is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @retval     TRUE       If the DNSSD server will forward DNS queries.\n @retval     FALSE      If the DNSSD server will not forward DNS queries.\n\n @sa otDnssdUpstreamQuerySetEnabled"]
6802    pub fn otDnssdUpstreamQueryIsEnabled(aInstance: *mut otInstance) -> bool;
6803}
6804extern "C" {
6805    #[doc = " @note This API is deprecated and use of it is discouraged."]
6806    pub fn otHeapCAlloc(aCount: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
6807}
6808extern "C" {
6809    #[doc = " @note This API is deprecated and use of it is discouraged."]
6810    pub fn otHeapFree(aPointer: *mut ::std::os::raw::c_void);
6811}
6812#[doc = "< Destination Unreachable"]
6813pub const OT_ICMP6_TYPE_DST_UNREACH: otIcmp6Type = 1;
6814#[doc = "< Packet To Big"]
6815pub const OT_ICMP6_TYPE_PACKET_TO_BIG: otIcmp6Type = 2;
6816#[doc = "< Time Exceeded"]
6817pub const OT_ICMP6_TYPE_TIME_EXCEEDED: otIcmp6Type = 3;
6818#[doc = "< Parameter Problem"]
6819pub const OT_ICMP6_TYPE_PARAMETER_PROBLEM: otIcmp6Type = 4;
6820#[doc = "< Echo Request"]
6821pub const OT_ICMP6_TYPE_ECHO_REQUEST: otIcmp6Type = 128;
6822#[doc = "< Echo Reply"]
6823pub const OT_ICMP6_TYPE_ECHO_REPLY: otIcmp6Type = 129;
6824#[doc = "< Router Solicitation"]
6825pub const OT_ICMP6_TYPE_ROUTER_SOLICIT: otIcmp6Type = 133;
6826#[doc = "< Router Advertisement"]
6827pub const OT_ICMP6_TYPE_ROUTER_ADVERT: otIcmp6Type = 134;
6828#[doc = "< Neighbor Solicitation"]
6829pub const OT_ICMP6_TYPE_NEIGHBOR_SOLICIT: otIcmp6Type = 135;
6830#[doc = "< Neighbor Advertisement"]
6831pub const OT_ICMP6_TYPE_NEIGHBOR_ADVERT: otIcmp6Type = 136;
6832#[doc = " ICMPv6 Message Types"]
6833pub type otIcmp6Type = ::std::os::raw::c_uint;
6834#[doc = "< Destination Unreachable (Type 1) - No Route"]
6835pub const OT_ICMP6_CODE_DST_UNREACH_NO_ROUTE: otIcmp6Code = 0;
6836#[doc = "< Destination Unreachable (Type 1) - Administratively Prohibited"]
6837pub const OT_ICMP6_CODE_DST_UNREACH_PROHIBITED: otIcmp6Code = 1;
6838#[doc = "< Time Exceeded (Type 3) - Fragment Reassembly"]
6839pub const OT_ICMP6_CODE_FRAGM_REAS_TIME_EX: otIcmp6Code = 1;
6840#[doc = " ICMPv6 Message Codes"]
6841pub type otIcmp6Code = ::std::os::raw::c_uint;
6842#[doc = " @struct otIcmp6Header\n\n Represents an ICMPv6 header."]
6843#[repr(C, packed)]
6844#[derive(Copy, Clone)]
6845pub struct otIcmp6Header {
6846    #[doc = "< Type"]
6847    pub mType: u8,
6848    #[doc = "< Code"]
6849    pub mCode: u8,
6850    #[doc = "< Checksum"]
6851    pub mChecksum: u16,
6852    #[doc = "< Message-specific data"]
6853    pub mData: otIcmp6Header__bindgen_ty_1,
6854}
6855#[repr(C, packed)]
6856#[derive(Copy, Clone)]
6857pub union otIcmp6Header__bindgen_ty_1 {
6858    pub m8: [u8; 4usize],
6859    pub m16: [u16; 2usize],
6860    pub m32: [u32; 1usize],
6861}
6862impl Default for otIcmp6Header__bindgen_ty_1 {
6863    fn default() -> Self {
6864        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6865        unsafe {
6866            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6867            s.assume_init()
6868        }
6869    }
6870}
6871impl Default for otIcmp6Header {
6872    fn default() -> Self {
6873        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6874        unsafe {
6875            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6876            s.assume_init()
6877        }
6878    }
6879}
6880#[doc = " This callback allows OpenThread to inform the application of a received ICMPv6 message.\n\n @param[in]  aContext      A pointer to arbitrary context information.\n @param[in]  aMessage      A pointer to the received message.\n @param[in]  aMessageInfo  A pointer to message information associated with @p aMessage.\n @param[in]  aIcmpHeader   A pointer to the received ICMPv6 header."]
6881pub type otIcmp6ReceiveCallback = ::std::option::Option<
6882    unsafe extern "C" fn(
6883        aContext: *mut ::std::os::raw::c_void,
6884        aMessage: *mut otMessage,
6885        aMessageInfo: *const otMessageInfo,
6886        aIcmpHeader: *const otIcmp6Header,
6887    ),
6888>;
6889#[doc = " Implements ICMPv6 message handler."]
6890#[repr(C)]
6891#[derive(Debug, Copy, Clone)]
6892pub struct otIcmp6Handler {
6893    #[doc = "< The ICMPv6 received callback"]
6894    pub mReceiveCallback: otIcmp6ReceiveCallback,
6895    #[doc = "< A pointer to arbitrary context information."]
6896    pub mContext: *mut ::std::os::raw::c_void,
6897    #[doc = "< A pointer to the next handler in the list."]
6898    pub mNext: *mut otIcmp6Handler,
6899}
6900impl Default for otIcmp6Handler {
6901    fn default() -> Self {
6902        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6903        unsafe {
6904            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6905            s.assume_init()
6906        }
6907    }
6908}
6909#[doc = "< ICMPv6 Echo processing disabled"]
6910pub const OT_ICMP6_ECHO_HANDLER_DISABLED: otIcmp6EchoMode = 0;
6911#[doc = "< ICMPv6 Echo processing enabled only for unicast requests only"]
6912pub const OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY: otIcmp6EchoMode = 1;
6913#[doc = "< ICMPv6 Echo processing enabled only for multicast requests only"]
6914pub const OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY: otIcmp6EchoMode = 2;
6915#[doc = "< ICMPv6 Echo processing enabled for unicast and multicast requests"]
6916pub const OT_ICMP6_ECHO_HANDLER_ALL: otIcmp6EchoMode = 3;
6917#[doc = "< ICMPv6 Echo processing enabled for RLOC/ALOC destinations only"]
6918pub const OT_ICMP6_ECHO_HANDLER_RLOC_ALOC_ONLY: otIcmp6EchoMode = 4;
6919#[doc = " ICMPv6 Echo Reply Modes"]
6920pub type otIcmp6EchoMode = ::std::os::raw::c_uint;
6921extern "C" {
6922    #[doc = " Indicates whether or not ICMPv6 Echo processing is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ICMP6_ECHO_HANDLER_DISABLED        ICMPv6 Echo processing is disabled.\n @retval OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY    ICMPv6 Echo processing enabled for unicast requests only\n @retval OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY  ICMPv6 Echo processing enabled for multicast requests only\n @retval OT_ICMP6_ECHO_HANDLER_ALL             ICMPv6 Echo processing enabled for unicast and multicast requests"]
6923    pub fn otIcmp6GetEchoMode(aInstance: *mut otInstance) -> otIcmp6EchoMode;
6924}
6925extern "C" {
6926    #[doc = " Sets whether or not ICMPv6 Echo processing is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aMode     The ICMPv6 Echo processing mode."]
6927    pub fn otIcmp6SetEchoMode(aInstance: *mut otInstance, aMode: otIcmp6EchoMode);
6928}
6929extern "C" {
6930    #[doc = " Registers a handler to provide received ICMPv6 messages.\n\n @note A handler structure @p aHandler has to be stored in persistent (static) memory.\n       OpenThread does not make a copy of handler structure.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aHandler  A pointer to a handler containing callback that is called when\n                       an ICMPv6 message is received."]
6931    pub fn otIcmp6RegisterHandler(
6932        aInstance: *mut otInstance,
6933        aHandler: *mut otIcmp6Handler,
6934    ) -> otError;
6935}
6936extern "C" {
6937    #[doc = " Sends an ICMPv6 Echo Request via the Thread interface.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A pointer to the message buffer containing the ICMPv6 payload.\n @param[in]  aMessageInfo  A reference to message information associated with @p aMessage.\n @param[in]  aIdentifier   An identifier to aid in matching Echo Replies to this Echo Request.\n                           May be zero."]
6938    pub fn otIcmp6SendEchoRequest(
6939        aInstance: *mut otInstance,
6940        aMessage: *mut otMessage,
6941        aMessageInfo: *const otMessageInfo,
6942        aIdentifier: u16,
6943    ) -> otError;
6944}
6945#[doc = " Pointer is called if signal jam detection is enabled and a jam is detected.\n\n @param[in]  aJamState Current jam state (`true` if jam is detected, `false` otherwise).\n @param[in]  aContext  A pointer to application-specific context."]
6946pub type otJamDetectionCallback = ::std::option::Option<
6947    unsafe extern "C" fn(aJamState: bool, aContext: *mut ::std::os::raw::c_void),
6948>;
6949extern "C" {
6950    #[doc = " Set the Jam Detection RSSI Threshold (in dBm).\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aRssiThreshold  The RSSI threshold.\n\n @retval OT_ERROR_NONE    Successfully set the threshold."]
6951    pub fn otJamDetectionSetRssiThreshold(
6952        aInstance: *mut otInstance,
6953        aRssiThreshold: i8,
6954    ) -> otError;
6955}
6956extern "C" {
6957    #[doc = " Get the Jam Detection RSSI Threshold (in dBm).\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection RSSI Threshold."]
6958    pub fn otJamDetectionGetRssiThreshold(aInstance: *mut otInstance) -> i8;
6959}
6960extern "C" {
6961    #[doc = " Set the Jam Detection Detection Window (in seconds).\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aWindow              The Jam Detection window (valid range is 1 to 63)\n\n @retval OT_ERROR_NONE          Successfully set the window.\n @retval OT_ERROR_INVALID_ARGS  The given input parameter not within valid range (1-63)"]
6962    pub fn otJamDetectionSetWindow(aInstance: *mut otInstance, aWindow: u8) -> otError;
6963}
6964extern "C" {
6965    #[doc = " Get the Jam Detection Detection Window (in seconds).\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @returns The Jam Detection Window."]
6966    pub fn otJamDetectionGetWindow(aInstance: *mut otInstance) -> u8;
6967}
6968extern "C" {
6969    #[doc = " Set the Jam Detection Busy Period (in seconds).\n\n The number of aggregate seconds within the detection window where the RSSI must be above\n threshold to trigger detection.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aBusyPeriod          The Jam Detection busy period (should be non-zero and\nless than or equal to Jam Detection Window)\n\n @retval OT_ERROR_NONE          Successfully set the window.\n @retval OT_ERROR_INVALID_ARGS  The given input is not within the valid range."]
6970    pub fn otJamDetectionSetBusyPeriod(aInstance: *mut otInstance, aBusyPeriod: u8) -> otError;
6971}
6972extern "C" {
6973    #[doc = " Get the Jam Detection Busy Period (in seconds)\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @returns The Jam Detection Busy Period."]
6974    pub fn otJamDetectionGetBusyPeriod(aInstance: *mut otInstance) -> u8;
6975}
6976extern "C" {
6977    #[doc = " Start the jamming detection.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aCallback            A pointer to a function called to notify of jamming state change.\n @param[in]  aContext             A pointer to application-specific context.\n\n @retval OT_ERROR_NONE         Successfully started the jamming detection.\n @retval OT_ERROR_ALREADY      Jam detection has been started before."]
6978    pub fn otJamDetectionStart(
6979        aInstance: *mut otInstance,
6980        aCallback: otJamDetectionCallback,
6981        aContext: *mut ::std::os::raw::c_void,
6982    ) -> otError;
6983}
6984extern "C" {
6985    #[doc = " Stop the jamming detection.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE         Successfully stopped the jamming detection.\n @retval OT_ERROR_ALREADY      Jam detection is already stopped."]
6986    pub fn otJamDetectionStop(aInstance: *mut otInstance) -> otError;
6987}
6988extern "C" {
6989    #[doc = " Get the Jam Detection Status (enabled/disabled)\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @returns The Jam Detection status (true if enabled, false otherwise)."]
6990    pub fn otJamDetectionIsEnabled(aInstance: *mut otInstance) -> bool;
6991}
6992extern "C" {
6993    #[doc = " Get the Jam Detection State\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @returns The Jam Detection state (`true` jam is detected, `false' otherwise)."]
6994    pub fn otJamDetectionGetState(aInstance: *mut otInstance) -> bool;
6995}
6996extern "C" {
6997    #[doc = " Get the current history bitmap.\n\n This value provides information about current state of jamming detection\n module for monitoring/debugging purpose. It returns a 64-bit value where\n each bit corresponds to one second interval starting with bit 0 for the\n most recent interval and bit 63 for the oldest intervals (63 sec earlier).\n The bit is set to 1 if the jamming detection module observed/detected\n high signal level during the corresponding one second interval.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n\n @returns The current history bitmap."]
6998    pub fn otJamDetectionGetHistoryBitmap(aInstance: *mut otInstance) -> u64;
6999}
7000pub type otMacFilterIterator = u8;
7001#[doc = "< Address filter is disabled."]
7002pub const OT_MAC_FILTER_ADDRESS_MODE_DISABLED: otMacFilterAddressMode = 0;
7003#[doc = "< Allowlist address filter mode is enabled."]
7004pub const OT_MAC_FILTER_ADDRESS_MODE_ALLOWLIST: otMacFilterAddressMode = 1;
7005#[doc = "< Denylist address filter mode is enabled."]
7006pub const OT_MAC_FILTER_ADDRESS_MODE_DENYLIST: otMacFilterAddressMode = 2;
7007#[doc = " Defines address mode of the mac filter."]
7008pub type otMacFilterAddressMode = ::std::os::raw::c_uint;
7009#[doc = " Represents a Mac Filter entry."]
7010#[repr(C)]
7011#[derive(Debug, Default, Copy, Clone)]
7012pub struct otMacFilterEntry {
7013    #[doc = "< IEEE 802.15.4 Extended Address"]
7014    pub mExtAddress: otExtAddress,
7015    #[doc = "< Received signal strength"]
7016    pub mRssIn: i8,
7017}
7018#[doc = " Represents the MAC layer counters."]
7019#[repr(C)]
7020#[derive(Debug, Default, Copy, Clone)]
7021pub struct otMacCounters {
7022    #[doc = " The total number of unique MAC frame transmission requests.\n\n Note that this counter is incremented for each MAC transmission request only by one,\n regardless of the amount of CCA failures, CSMA-CA attempts, or retransmissions.\n\n This increment rule applies to the following counters:\n   - @p mTxUnicast\n   - @p mTxBroadcast\n   - @p mTxAckRequested\n   - @p mTxNoAckRequested\n   - @p mTxData\n   - @p mTxDataPoll\n   - @p mTxBeacon\n   - @p mTxBeaconRequest\n   - @p mTxOther\n   - @p mTxErrAbort\n   - @p mTxErrBusyChannel\n\n The following equations are valid:\n   - @p mTxTotal = @p mTxUnicast + @p mTxBroadcast\n   - @p mTxTotal = @p mTxAckRequested + @p mTxNoAckRequested\n   - @p mTxTotal = @p mTxData + @p mTxDataPoll + @p mTxBeacon + @p mTxBeaconRequest + @p mTxOther"]
7023    pub mTxTotal: u32,
7024    #[doc = " The total number of unique unicast MAC frame transmission requests."]
7025    pub mTxUnicast: u32,
7026    #[doc = " The total number of unique broadcast MAC frame transmission requests."]
7027    pub mTxBroadcast: u32,
7028    #[doc = " The total number of unique MAC frame transmission requests with requested acknowledgment."]
7029    pub mTxAckRequested: u32,
7030    #[doc = " The total number of unique MAC frame transmission requests that were acked."]
7031    pub mTxAcked: u32,
7032    #[doc = " The total number of unique MAC frame transmission requests without requested acknowledgment."]
7033    pub mTxNoAckRequested: u32,
7034    #[doc = " The total number of unique MAC Data frame transmission requests."]
7035    pub mTxData: u32,
7036    #[doc = " The total number of unique MAC Data Poll frame transmission requests."]
7037    pub mTxDataPoll: u32,
7038    #[doc = " The total number of unique MAC Beacon frame transmission requests."]
7039    pub mTxBeacon: u32,
7040    #[doc = " The total number of unique MAC Beacon Request frame transmission requests."]
7041    pub mTxBeaconRequest: u32,
7042    #[doc = " The total number of unique other MAC frame transmission requests.\n\n This counter is currently used for counting out-of-band frames."]
7043    pub mTxOther: u32,
7044    #[doc = " The total number of MAC retransmission attempts.\n\n Note that this counter is incremented by one for each retransmission attempt that may be\n triggered by lack of acknowledgement, CSMA/CA failure, or other type of transmission error.\n The @p mTxRetry counter is incremented both for unicast and broadcast MAC frames.\n\n Modify the following configuration parameters to control the amount of retransmissions in the system:\n\n - OPENTHREAD_CONFIG_MAC_DEFAULT_MAX_FRAME_RETRIES_DIRECT\n - OPENTHREAD_CONFIG_MAC_DEFAULT_MAX_FRAME_RETRIES_INDIRECT\n - OPENTHREAD_CONFIG_MAC_TX_NUM_BCAST\n - OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_DIRECT\n - OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_INDIRECT\n\n Currently, this counter is invalid if the platform's radio driver capability includes\n @ref OT_RADIO_CAPS_TRANSMIT_RETRIES."]
7045    pub mTxRetry: u32,
7046    #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for direct packets."]
7047    pub mTxDirectMaxRetryExpiry: u32,
7048    #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for indirect packets."]
7049    pub mTxIndirectMaxRetryExpiry: u32,
7050    #[doc = " The total number of CCA failures.\n\n The meaning of this counter can be different and it depends on the platform's radio driver capabilities.\n\n If @ref OT_RADIO_CAPS_CSMA_BACKOFF is enabled, this counter represents the total number of full CSMA/CA\n failed attempts and it is incremented by one also for each retransmission (in case of a CSMA/CA fail).\n\n If @ref OT_RADIO_CAPS_TRANSMIT_RETRIES is enabled, this counter represents the total number of full CSMA/CA\n failed attempts and it is incremented by one for each individual data frame request (regardless of the\n amount of retransmissions)."]
7051    pub mTxErrCca: u32,
7052    #[doc = " The total number of unique MAC transmission request failures cause by an abort error."]
7053    pub mTxErrAbort: u32,
7054    #[doc = " The total number of unique MAC transmission requests failures caused by a busy channel (a CSMA/CA fail)."]
7055    pub mTxErrBusyChannel: u32,
7056    #[doc = " The total number of received frames.\n\n This counter counts all frames reported by the platform's radio driver, including frames\n that were dropped, for example because of an FCS error."]
7057    pub mRxTotal: u32,
7058    #[doc = " The total number of unicast frames received."]
7059    pub mRxUnicast: u32,
7060    #[doc = " The total number of broadcast frames received."]
7061    pub mRxBroadcast: u32,
7062    #[doc = " The total number of MAC Data frames received."]
7063    pub mRxData: u32,
7064    #[doc = " The total number of MAC Data Poll frames received."]
7065    pub mRxDataPoll: u32,
7066    #[doc = " The total number of MAC Beacon frames received."]
7067    pub mRxBeacon: u32,
7068    #[doc = " The total number of MAC Beacon Request frames received."]
7069    pub mRxBeaconRequest: u32,
7070    #[doc = " The total number of other types of frames received."]
7071    pub mRxOther: u32,
7072    #[doc = " The total number of frames dropped by MAC Filter module, for example received from denylisted node."]
7073    pub mRxAddressFiltered: u32,
7074    #[doc = " The total number of frames dropped by destination address check, for example received frame for other node."]
7075    pub mRxDestAddrFiltered: u32,
7076    #[doc = " The total number of frames dropped due to duplication, that is when the frame has been already received.\n\n This counter may be incremented, for example when ACK frame generated by the receiver hasn't reached\n transmitter node which performed retransmission."]
7077    pub mRxDuplicated: u32,
7078    #[doc = " The total number of frames dropped because of missing or malformed content."]
7079    pub mRxErrNoFrame: u32,
7080    #[doc = " The total number of frames dropped due to unknown neighbor."]
7081    pub mRxErrUnknownNeighbor: u32,
7082    #[doc = " The total number of frames dropped due to invalid source address."]
7083    pub mRxErrInvalidSrcAddr: u32,
7084    #[doc = " The total number of frames dropped due to security error.\n\n This counter may be incremented, for example when lower than expected Frame Counter is used\n to encrypt the frame."]
7085    pub mRxErrSec: u32,
7086    #[doc = " The total number of frames dropped due to invalid FCS."]
7087    pub mRxErrFcs: u32,
7088    #[doc = " The total number of frames dropped due to other error."]
7089    pub mRxErrOther: u32,
7090}
7091#[doc = " Represents a received IEEE 802.15.4 Beacon."]
7092#[repr(C)]
7093#[repr(align(4))]
7094#[derive(Debug, Default, Copy, Clone)]
7095pub struct otActiveScanResult {
7096    #[doc = "< IEEE 802.15.4 Extended Address"]
7097    pub mExtAddress: otExtAddress,
7098    #[doc = "< Thread Network Name"]
7099    pub mNetworkName: otNetworkName,
7100    #[doc = "< Thread Extended PAN ID"]
7101    pub mExtendedPanId: otExtendedPanId,
7102    #[doc = "< Steering Data"]
7103    pub mSteeringData: otSteeringData,
7104    #[doc = "< IEEE 802.15.4 PAN ID"]
7105    pub mPanId: u16,
7106    #[doc = "< Joiner UDP Port"]
7107    pub mJoinerUdpPort: u16,
7108    #[doc = "< IEEE 802.15.4 Channel"]
7109    pub mChannel: u8,
7110    #[doc = "< RSSI (dBm)"]
7111    pub mRssi: i8,
7112    #[doc = "< LQI"]
7113    pub mLqi: u8,
7114    pub _bitfield_align_1: [u8; 0],
7115    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7116    pub __bindgen_padding_0: u16,
7117}
7118impl otActiveScanResult {
7119    #[inline]
7120    pub fn mVersion(&self) -> ::std::os::raw::c_uint {
7121        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
7122    }
7123    #[inline]
7124    pub fn set_mVersion(&mut self, val: ::std::os::raw::c_uint) {
7125        unsafe {
7126            let val: u32 = ::std::mem::transmute(val);
7127            self._bitfield_1.set(0usize, 4u8, val as u64)
7128        }
7129    }
7130    #[inline]
7131    pub fn mIsNative(&self) -> bool {
7132        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
7133    }
7134    #[inline]
7135    pub fn set_mIsNative(&mut self, val: bool) {
7136        unsafe {
7137            let val: u8 = ::std::mem::transmute(val);
7138            self._bitfield_1.set(4usize, 1u8, val as u64)
7139        }
7140    }
7141    #[inline]
7142    pub fn mDiscover(&self) -> bool {
7143        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
7144    }
7145    #[inline]
7146    pub fn set_mDiscover(&mut self, val: bool) {
7147        unsafe {
7148            let val: u8 = ::std::mem::transmute(val);
7149            self._bitfield_1.set(5usize, 1u8, val as u64)
7150        }
7151    }
7152    #[inline]
7153    pub fn mIsJoinable(&self) -> bool {
7154        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
7155    }
7156    #[inline]
7157    pub fn set_mIsJoinable(&mut self, val: bool) {
7158        unsafe {
7159            let val: u8 = ::std::mem::transmute(val);
7160            self._bitfield_1.set(6usize, 1u8, val as u64)
7161        }
7162    }
7163    #[inline]
7164    pub fn new_bitfield_1(
7165        mVersion: ::std::os::raw::c_uint,
7166        mIsNative: bool,
7167        mDiscover: bool,
7168        mIsJoinable: bool,
7169    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7170        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7171        __bindgen_bitfield_unit.set(0usize, 4u8, {
7172            let mVersion: u32 = unsafe { ::std::mem::transmute(mVersion) };
7173            mVersion as u64
7174        });
7175        __bindgen_bitfield_unit.set(4usize, 1u8, {
7176            let mIsNative: u8 = unsafe { ::std::mem::transmute(mIsNative) };
7177            mIsNative as u64
7178        });
7179        __bindgen_bitfield_unit.set(5usize, 1u8, {
7180            let mDiscover: u8 = unsafe { ::std::mem::transmute(mDiscover) };
7181            mDiscover as u64
7182        });
7183        __bindgen_bitfield_unit.set(6usize, 1u8, {
7184            let mIsJoinable: u8 = unsafe { ::std::mem::transmute(mIsJoinable) };
7185            mIsJoinable as u64
7186        });
7187        __bindgen_bitfield_unit
7188    }
7189}
7190#[doc = " Represents an energy scan result."]
7191#[repr(C)]
7192#[derive(Debug, Default, Copy, Clone)]
7193pub struct otEnergyScanResult {
7194    #[doc = "< IEEE 802.15.4 Channel"]
7195    pub mChannel: u8,
7196    #[doc = "< The max RSSI (dBm)"]
7197    pub mMaxRssi: i8,
7198}
7199#[doc = " Pointer is called during an IEEE 802.15.4 Active Scan when an IEEE 802.15.4 Beacon is received or\n the scan completes.\n\n @param[in]  aResult   A valid pointer to the beacon information or NULL when the active scan completes.\n @param[in]  aContext  A pointer to application-specific context."]
7200pub type otHandleActiveScanResult = ::std::option::Option<
7201    unsafe extern "C" fn(aResult: *mut otActiveScanResult, aContext: *mut ::std::os::raw::c_void),
7202>;
7203extern "C" {
7204    #[doc = " Starts an IEEE 802.15.4 Active Scan\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aScanChannels     A bit vector indicating which channels to scan (e.g. OT_CHANNEL_11_MASK).\n @param[in]  aScanDuration     The time in milliseconds to spend scanning each channel.\n @param[in]  aCallback         A pointer to a function called on receiving a beacon or scan completes.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @retval OT_ERROR_NONE  Accepted the Active Scan request.\n @retval OT_ERROR_BUSY  Already performing an Active Scan."]
7205    pub fn otLinkActiveScan(
7206        aInstance: *mut otInstance,
7207        aScanChannels: u32,
7208        aScanDuration: u16,
7209        aCallback: otHandleActiveScanResult,
7210        aCallbackContext: *mut ::std::os::raw::c_void,
7211    ) -> otError;
7212}
7213extern "C" {
7214    #[doc = " Indicates whether or not an IEEE 802.15.4 Active Scan is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 Active Scan is in progress, false otherwise."]
7215    pub fn otLinkIsActiveScanInProgress(aInstance: *mut otInstance) -> bool;
7216}
7217#[doc = " Pointer is called during an IEEE 802.15.4 Energy Scan when the result for a channel is ready or the\n scan completes.\n\n @param[in]  aResult   A valid pointer to the energy scan result information or NULL when the energy scan completes.\n @param[in]  aContext  A pointer to application-specific context."]
7218pub type otHandleEnergyScanResult = ::std::option::Option<
7219    unsafe extern "C" fn(aResult: *mut otEnergyScanResult, aContext: *mut ::std::os::raw::c_void),
7220>;
7221extern "C" {
7222    #[doc = " Starts an IEEE 802.15.4 Energy Scan\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aScanChannels     A bit vector indicating on which channels to perform energy scan.\n @param[in]  aScanDuration     The time in milliseconds to spend scanning each channel.\n @param[in]  aCallback         A pointer to a function called to pass on scan result on indicate scan completion.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @retval OT_ERROR_NONE  Accepted the Energy Scan request.\n @retval OT_ERROR_BUSY  Could not start the energy scan."]
7223    pub fn otLinkEnergyScan(
7224        aInstance: *mut otInstance,
7225        aScanChannels: u32,
7226        aScanDuration: u16,
7227        aCallback: otHandleEnergyScanResult,
7228        aCallbackContext: *mut ::std::os::raw::c_void,
7229    ) -> otError;
7230}
7231extern "C" {
7232    #[doc = " Indicates whether or not an IEEE 802.15.4 Energy Scan is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 Energy Scan is in progress, false otherwise."]
7233    pub fn otLinkIsEnergyScanInProgress(aInstance: *mut otInstance) -> bool;
7234}
7235extern "C" {
7236    #[doc = " Enqueues an IEEE 802.15.4 Data Request message for transmission.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully enqueued an IEEE 802.15.4 Data Request message.\n @retval OT_ERROR_INVALID_STATE  Device is not in rx-off-when-idle mode.\n @retval OT_ERROR_NO_BUFS        Insufficient message buffers available."]
7237    pub fn otLinkSendDataRequest(aInstance: *mut otInstance) -> otError;
7238}
7239extern "C" {
7240    #[doc = " Indicates whether or not an IEEE 802.15.4 MAC is in the transmit state.\n\n MAC module is in the transmit state during CSMA/CA procedure, CCA, Data, Beacon or Data Request frame transmission\n and receiving an ACK of a transmitted frame. MAC module is not in the transmit state during transmission of an ACK\n frame or a Beacon Request frame.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 MAC is in the transmit state, false otherwise."]
7241    pub fn otLinkIsInTransmitState(aInstance: *mut otInstance) -> bool;
7242}
7243extern "C" {
7244    #[doc = " Get the IEEE 802.15.4 channel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 channel.\n\n @sa otLinkSetChannel"]
7245    pub fn otLinkGetChannel(aInstance: *mut otInstance) -> u8;
7246}
7247extern "C" {
7248    #[doc = " Set the IEEE 802.15.4 channel\n\n Succeeds only when Thread protocols are disabled.  A successful call to this function invalidates the\n Active and Pending Operational Datasets in non-volatile memory.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aChannel    The IEEE 802.15.4 channel.\n\n @retval  OT_ERROR_NONE           Successfully set the channel.\n @retval  OT_ERROR_INVALID_ARGS   If @p aChannel is not in the range [11, 26] or is not in the supported channel mask.\n @retval  OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otLinkGetChannel"]
7249    pub fn otLinkSetChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7250}
7251extern "C" {
7252    #[doc = " Get the supported channel mask of MAC layer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The supported channel mask as `uint32_t` with bit 0 (lsb) mapping to channel 0, bit 1 to channel 1, so on."]
7253    pub fn otLinkGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
7254}
7255extern "C" {
7256    #[doc = " Set the supported channel mask of MAC layer.\n\n Succeeds only when Thread protocols are disabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aChannelMask  The supported channel mask (bit 0 or lsb mapping to channel 0, and so on).\n\n @retval  OT_ERROR_NONE           Successfully set the supported channel mask.\n @retval  OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
7257    pub fn otLinkSetSupportedChannelMask(aInstance: *mut otInstance, aChannelMask: u32) -> otError;
7258}
7259extern "C" {
7260    #[doc = " Gets the IEEE 802.15.4 Extended Address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the IEEE 802.15.4 Extended Address."]
7261    pub fn otLinkGetExtendedAddress(aInstance: *mut otInstance) -> *const otExtAddress;
7262}
7263extern "C" {
7264    #[doc = " Sets the IEEE 802.15.4 Extended Address.\n\n @note Only succeeds when Thread protocols are disabled.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aExtAddress  A pointer to the IEEE 802.15.4 Extended Address.\n\n @retval OT_ERROR_NONE           Successfully set the IEEE 802.15.4 Extended Address.\n @retval OT_ERROR_INVALID_ARGS   @p aExtAddress was NULL.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
7265    pub fn otLinkSetExtendedAddress(
7266        aInstance: *mut otInstance,
7267        aExtAddress: *const otExtAddress,
7268    ) -> otError;
7269}
7270extern "C" {
7271    #[doc = " Get the factory-assigned IEEE EUI-64.\n\n @param[in]   aInstance  A pointer to the OpenThread instance.\n @param[out]  aEui64     A pointer to where the factory-assigned IEEE EUI-64 is placed."]
7272    pub fn otLinkGetFactoryAssignedIeeeEui64(aInstance: *mut otInstance, aEui64: *mut otExtAddress);
7273}
7274extern "C" {
7275    #[doc = " Get the IEEE 802.15.4 PAN ID.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 PAN ID.\n\n @sa otLinkSetPanId"]
7276    pub fn otLinkGetPanId(aInstance: *mut otInstance) -> otPanId;
7277}
7278extern "C" {
7279    #[doc = " Set the IEEE 802.15.4 PAN ID.\n\n Succeeds only when Thread protocols are disabled.  A successful call to this function also invalidates\n the Active and Pending Operational Datasets in non-volatile memory.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aPanId       The IEEE 802.15.4 PAN ID.\n\n @retval OT_ERROR_NONE           Successfully set the PAN ID.\n @retval OT_ERROR_INVALID_ARGS   If aPanId is not in the range [0, 65534].\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otLinkGetPanId"]
7280    pub fn otLinkSetPanId(aInstance: *mut otInstance, aPanId: otPanId) -> otError;
7281}
7282extern "C" {
7283    #[doc = " Get the data poll period of sleepy end device.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns  The data poll period of sleepy end device in milliseconds.\n\n @sa otLinkSetPollPeriod"]
7284    pub fn otLinkGetPollPeriod(aInstance: *mut otInstance) -> u32;
7285}
7286extern "C" {
7287    #[doc = " Set/clear user-specified/external data poll period for sleepy end device.\n\n @note This function updates only poll period of sleepy end device. To update child timeout the function\n       `otThreadSetChildTimeout()` shall be called.\n\n @note Minimal non-zero value should be `OPENTHREAD_CONFIG_MAC_MINIMUM_POLL_PERIOD` (10ms).\n       Or zero to clear user-specified poll period.\n\n @note User-specified value should be no more than the maximal value 0x3FFFFFF ((1 << 26) - 1) allowed,\n otherwise it would be clipped by the maximal value.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aPollPeriod  data poll period in milliseconds.\n\n @retval OT_ERROR_NONE           Successfully set/cleared user-specified poll period.\n @retval OT_ERROR_INVALID_ARGS   If aPollPeriod is invalid.\n\n @sa otLinkGetPollPeriod"]
7288    pub fn otLinkSetPollPeriod(aInstance: *mut otInstance, aPollPeriod: u32) -> otError;
7289}
7290extern "C" {
7291    #[doc = " Get the IEEE 802.15.4 Short Address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 Short Address."]
7292    pub fn otLinkGetShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7293}
7294extern "C" {
7295    #[doc = " Get the IEEE 802.15.4 alternate short address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The alternate short address, or `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) if there is no alternate address."]
7296    pub fn otLinkGetAlternateShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7297}
7298extern "C" {
7299    #[doc = " Returns the maximum number of frame retries during direct transmission.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of retries during direct transmission."]
7300    pub fn otLinkGetMaxFrameRetriesDirect(aInstance: *mut otInstance) -> u8;
7301}
7302extern "C" {
7303    #[doc = " Sets the maximum number of frame retries during direct transmission.\n\n @param[in]  aInstance               A pointer to an OpenThread instance.\n @param[in]  aMaxFrameRetriesDirect  The maximum number of retries during direct transmission."]
7304    pub fn otLinkSetMaxFrameRetriesDirect(aInstance: *mut otInstance, aMaxFrameRetriesDirect: u8);
7305}
7306extern "C" {
7307    #[doc = " Returns the maximum number of frame retries during indirect transmission.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of retries during indirect transmission."]
7308    pub fn otLinkGetMaxFrameRetriesIndirect(aInstance: *mut otInstance) -> u8;
7309}
7310extern "C" {
7311    #[doc = " Sets the maximum number of frame retries during indirect transmission.\n\n @param[in]  aInstance                 A pointer to an OpenThread instance.\n @param[in]  aMaxFrameRetriesIndirect  The maximum number of retries during indirect transmission."]
7312    pub fn otLinkSetMaxFrameRetriesIndirect(
7313        aInstance: *mut otInstance,
7314        aMaxFrameRetriesIndirect: u8,
7315    );
7316}
7317extern "C" {
7318    #[doc = " Gets the current MAC frame counter value.\n\n @param[in] aInstance    A pointer to the OpenThread instance.\n\n @returns The current MAC frame counter value."]
7319    pub fn otLinkGetFrameCounter(aInstance: *mut otInstance) -> u32;
7320}
7321extern "C" {
7322    #[doc = " Gets the address mode of MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns  the address mode."]
7323    pub fn otLinkFilterGetAddressMode(aInstance: *mut otInstance) -> otMacFilterAddressMode;
7324}
7325extern "C" {
7326    #[doc = " Sets the address mode of MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aMode      The address mode to set."]
7327    pub fn otLinkFilterSetAddressMode(aInstance: *mut otInstance, aMode: otMacFilterAddressMode);
7328}
7329extern "C" {
7330    #[doc = " Adds an Extended Address to MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aExtAddress  A pointer to the Extended Address (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE           Successfully added @p aExtAddress to MAC filter.\n @retval OT_ERROR_NO_BUFS        No available entry exists."]
7331    pub fn otLinkFilterAddAddress(
7332        aInstance: *mut otInstance,
7333        aExtAddress: *const otExtAddress,
7334    ) -> otError;
7335}
7336extern "C" {
7337    #[doc = " Removes an Extended Address from MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n No action is performed if there is no existing entry in Filter matching the given Extended Address.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aExtAddress  A pointer to the Extended Address (MUST NOT be NULL)."]
7338    pub fn otLinkFilterRemoveAddress(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7339}
7340extern "C" {
7341    #[doc = " Clears all the Extended Addresses from MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
7342    pub fn otLinkFilterClearAddresses(aInstance: *mut otInstance);
7343}
7344extern "C" {
7345    #[doc = " Gets an in-use address filter entry.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the MAC filter iterator context. To get the first in-use address filter\n                            entry, it should be set to OT_MAC_FILTER_ITERATOR_INIT. MUST NOT be NULL.\n @param[out]     aEntry     A pointer to where the information is placed. MUST NOT be NULL.\n\n @retval OT_ERROR_NONE          Successfully retrieved an in-use address filter entry.\n @retval OT_ERROR_NOT_FOUND     No subsequent entry exists."]
7346    pub fn otLinkFilterGetNextAddress(
7347        aInstance: *mut otInstance,
7348        aIterator: *mut otMacFilterIterator,
7349        aEntry: *mut otMacFilterEntry,
7350    ) -> otError;
7351}
7352extern "C" {
7353    #[doc = " Adds the specified Extended Address to the `RssIn` list (or modifies an existing\n address in the `RssIn` list) and sets the received signal strength (in dBm) entry\n for messages from that address. The Extended Address does not necessarily have\n to be in the `address allowlist/denylist` filter to set the `rss`.\n @note The `RssIn` list contains Extended Addresses whose `rss` or link quality indicator (`lqi`)\n values have been set to be different from the defaults.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aExtAddress  A pointer to the IEEE 802.15.4 Extended Address. MUST NOT be NULL.\n @param[in]  aRss         A received signal strength (in dBm).\n\n @retval OT_ERROR_NONE           Successfully added an entry for @p aExtAddress and @p aRss.\n @retval OT_ERROR_NO_BUFS        No available entry exists."]
7354    pub fn otLinkFilterAddRssIn(
7355        aInstance: *mut otInstance,
7356        aExtAddress: *const otExtAddress,
7357        aRss: i8,
7358    ) -> otError;
7359}
7360extern "C" {
7361    #[doc = " Removes the specified Extended Address from the `RssIn` list. Once removed\n from the `RssIn` list, this MAC address will instead use the default `rss`\n and `lqi` settings, assuming defaults have been set.\n (If no defaults have been set, the over-air signal is used.)\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n No action is performed if there is no existing entry in the `RssIn` list matching the specified Extended Address.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aExtAddress  A pointer to the IEEE 802.15.4 Extended Address. MUST NOT be NULL."]
7362    pub fn otLinkFilterRemoveRssIn(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7363}
7364extern "C" {
7365    #[doc = " Sets the default received signal strength (in dBm) on MAC Filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n The default RSS value is used for all received frames from addresses for which there is no explicit RSS-IN entry\n in the Filter list (added using `otLinkFilterAddRssIn()`).\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aRss         The default received signal strength (in dBm) to set."]
7366    pub fn otLinkFilterSetDefaultRssIn(aInstance: *mut otInstance, aRss: i8);
7367}
7368extern "C" {
7369    #[doc = " Clears any previously set default received signal strength (in dBm) on MAC Filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance    A pointer to an OpenThread instance."]
7370    pub fn otLinkFilterClearDefaultRssIn(aInstance: *mut otInstance);
7371}
7372extern "C" {
7373    #[doc = " Clears all the received signal strength (`rss`) and link quality\n indicator (`lqi`) entries (including defaults) from the `RssIn` list.\n Performing this action means that all Extended Addresses will use the on-air signal.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance."]
7374    pub fn otLinkFilterClearAllRssIn(aInstance: *mut otInstance);
7375}
7376extern "C" {
7377    #[doc = " Gets an in-use RssIn filter entry.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the MAC filter iterator context. MUST NOT be NULL.\n                            To get the first entry, it should be set to OT_MAC_FILTER_ITERATOR_INIT.\n @param[out]     aEntry     A pointer to where the information is placed. The last entry would have the extended\n                            address as all 0xff to indicate the default received signal strength if it was set.\n@p aEntry MUST NOT be NULL.\n\n @retval OT_ERROR_NONE          Successfully retrieved the next entry.\n @retval OT_ERROR_NOT_FOUND     No subsequent entry exists."]
7378    pub fn otLinkFilterGetNextRssIn(
7379        aInstance: *mut otInstance,
7380        aIterator: *mut otMacFilterIterator,
7381        aEntry: *mut otMacFilterEntry,
7382    ) -> otError;
7383}
7384extern "C" {
7385    #[doc = " Enables/disables IEEE 802.15.4 radio filter mode.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n The radio filter is mainly intended for testing. It can be used to temporarily block all tx/rx on the 802.15.4 radio.\n When radio filter is enabled, radio is put to sleep instead of receive (to ensure device does not receive any frame\n and/or potentially send ack). Also the frame transmission requests return immediately without sending the frame over\n the air (return \"no ack\" error if ack is requested, otherwise return success).\n\n @param[in] aInstance         A pointer to an OpenThread instance.\n @param[in] aFilterEnabled    TRUE to enable radio filter, FALSE to disable"]
7386    pub fn otLinkSetRadioFilterEnabled(aInstance: *mut otInstance, aFilterEnabled: bool);
7387}
7388extern "C" {
7389    #[doc = " Indicates whether the IEEE 802.15.4 radio filter is enabled or not.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @retval TRUE   If the radio filter is enabled.\n @retval FALSE  If the radio filter is disabled."]
7390    pub fn otLinkIsRadioFilterEnabled(aInstance: *mut otInstance) -> bool;
7391}
7392extern "C" {
7393    #[doc = " Converts received signal strength to link quality.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aRss       The received signal strength value to be converted.\n\n @return Link quality value mapping to @p aRss."]
7394    pub fn otLinkConvertRssToLinkQuality(aInstance: *mut otInstance, aRss: i8) -> u8;
7395}
7396extern "C" {
7397    #[doc = " Converts link quality to typical received signal strength.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aLinkQuality  LinkQuality value, should be in range [0,3].\n\n @return Typical platform received signal strength mapping to @p aLinkQuality."]
7398    pub fn otLinkConvertLinkQualityToRss(aInstance: *mut otInstance, aLinkQuality: u8) -> i8;
7399}
7400extern "C" {
7401    #[doc = " Gets histogram of retries for a single direct packet until success.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in]   aInstance          A pointer to an OpenThread instance.\n @param[out]  aNumberOfEntries   A pointer to where the size of returned histogram array is placed.\n\n @returns     A pointer to the histogram of retries (in a form of an array).\n              The n-th element indicates that the packet has been sent with n-th retry."]
7402    pub fn otLinkGetTxDirectRetrySuccessHistogram(
7403        aInstance: *mut otInstance,
7404        aNumberOfEntries: *mut u8,
7405    ) -> *const u32;
7406}
7407extern "C" {
7408    #[doc = " Gets histogram of retries for a single indirect packet until success.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in]   aInstance          A pointer to an OpenThread instance.\n @param[out]  aNumberOfEntries   A pointer to where the size of returned histogram array is placed.\n\n @returns     A pointer to the histogram of retries (in a form of an array).\n              The n-th element indicates that the packet has been sent with n-th retry."]
7409    pub fn otLinkGetTxIndirectRetrySuccessHistogram(
7410        aInstance: *mut otInstance,
7411        aNumberOfEntries: *mut u8,
7412    ) -> *const u32;
7413}
7414extern "C" {
7415    #[doc = " Clears histogram statistics for direct and indirect transmissions.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in]   aInstance          A pointer to an OpenThread instance."]
7416    pub fn otLinkResetTxRetrySuccessHistogram(aInstance: *mut otInstance);
7417}
7418extern "C" {
7419    #[doc = " Get the MAC layer counters.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the MAC layer counters."]
7420    pub fn otLinkGetCounters(aInstance: *mut otInstance) -> *const otMacCounters;
7421}
7422extern "C" {
7423    #[doc = " Resets the MAC layer counters.\n\n @param[in]  aInstance A pointer to an OpenThread instance."]
7424    pub fn otLinkResetCounters(aInstance: *mut otInstance);
7425}
7426#[doc = " Pointer is called when an IEEE 802.15.4 frame is received.\n\n @note This callback is called after FCS processing and @p aFrame may not contain the actual FCS that was received.\n\n @note This callback is called before IEEE 802.15.4 security processing.\n\n @param[in]  aFrame    A pointer to the received IEEE 802.15.4 frame.\n @param[in]  aIsTx     Whether this frame is transmitted, not received.\n @param[in]  aContext  A pointer to application-specific context."]
7427pub type otLinkPcapCallback = ::std::option::Option<
7428    unsafe extern "C" fn(
7429        aFrame: *const otRadioFrame,
7430        aIsTx: bool,
7431        aContext: *mut ::std::os::raw::c_void,
7432    ),
7433>;
7434extern "C" {
7435    #[doc = " Registers a callback to provide received raw IEEE 802.15.4 frames.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aPcapCallback     A pointer to a function that is called when receiving an IEEE 802.15.4 link frame or\n                               NULL to disable the callback.\n @param[in]  aCallbackContext  A pointer to application-specific context."]
7436    pub fn otLinkSetPcapCallback(
7437        aInstance: *mut otInstance,
7438        aPcapCallback: otLinkPcapCallback,
7439        aCallbackContext: *mut ::std::os::raw::c_void,
7440    );
7441}
7442extern "C" {
7443    #[doc = " Indicates whether or not promiscuous mode is enabled at the link layer.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   Promiscuous mode is enabled.\n @retval FALSE  Promiscuous mode is not enabled."]
7444    pub fn otLinkIsPromiscuous(aInstance: *mut otInstance) -> bool;
7445}
7446extern "C" {
7447    #[doc = " Enables or disables the link layer promiscuous mode.\n\n @note Promiscuous mode may only be enabled when the Thread interface is disabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aPromiscuous  true to enable promiscuous mode, or false otherwise.\n\n @retval OT_ERROR_NONE           Successfully enabled promiscuous mode.\n @retval OT_ERROR_INVALID_STATE  Could not enable promiscuous mode because\n                                 the Thread interface is enabled."]
7448    pub fn otLinkSetPromiscuous(aInstance: *mut otInstance, aPromiscuous: bool) -> otError;
7449}
7450extern "C" {
7451    #[doc = " Gets the CSL channel.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The CSL channel."]
7452    pub fn otLinkGetCslChannel(aInstance: *mut otInstance) -> u8;
7453}
7454extern "C" {
7455    #[doc = " Sets the CSL channel.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aChannel       The CSL sample channel. Channel value should be `0` (Set CSL Channel unspecified) or\n                            within the range [1, 10] (if 915-MHz supported) and [11, 26] (if 2.4 GHz supported).\n\n @retval OT_ERROR_NONE           Successfully set the CSL parameters.\n @retval OT_ERROR_INVALID_ARGS   Invalid @p aChannel."]
7456    pub fn otLinkSetCslChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7457}
7458extern "C" {
7459    #[doc = " Gets the CSL period in microseconds\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The CSL period in microseconds."]
7460    pub fn otLinkGetCslPeriod(aInstance: *mut otInstance) -> u32;
7461}
7462extern "C" {
7463    #[doc = " Sets the CSL period in microseconds. Disable CSL by setting this parameter to `0`.\n\n The CSL period MUST be a multiple of `OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC`, otherwise `OT_ERROR_INVALID_ARGS`\n is returned.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aPeriod        The CSL period in microseconds.\n\n @retval OT_ERROR_NONE           Successfully set the CSL period.\n @retval OT_ERROR_INVALID_ARGS   Invalid CSL period"]
7464    pub fn otLinkSetCslPeriod(aInstance: *mut otInstance, aPeriod: u32) -> otError;
7465}
7466extern "C" {
7467    #[doc = " Gets the CSL timeout.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The CSL timeout in seconds."]
7468    pub fn otLinkGetCslTimeout(aInstance: *mut otInstance) -> u32;
7469}
7470extern "C" {
7471    #[doc = " Sets the CSL timeout in seconds.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aTimeout       The CSL timeout in seconds.\n\n @retval OT_ERROR_NONE           Successfully set the CSL timeout.\n @retval OT_ERROR_INVALID_ARGS   Invalid CSL timeout."]
7472    pub fn otLinkSetCslTimeout(aInstance: *mut otInstance, aTimeout: u32) -> otError;
7473}
7474extern "C" {
7475    #[doc = " Returns the current CCA (Clear Channel Assessment) failure rate.\n\n The rate is maintained over a window of (roughly) last `OPENTHREAD_CONFIG_CCA_FAILURE_RATE_AVERAGING_WINDOW`\n frame transmissions.\n\n @returns The CCA failure rate with maximum value `0xffff` corresponding to 100% failure rate."]
7476    pub fn otLinkGetCcaFailureRate(aInstance: *mut otInstance) -> u16;
7477}
7478extern "C" {
7479    #[doc = " Enables or disables the link layer.\n\n @note The link layer may only be enabled / disabled when the Thread Interface is disabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aEnable       true to enable the link layer, or false otherwise.\n\n @retval OT_ERROR_NONE          Successfully enabled / disabled the link layer.\n @retval OT_ERROR_INVALID_STATE Could not disable the link layer because\n                                the Thread interface is enabled."]
7480    pub fn otLinkSetEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7481}
7482extern "C" {
7483    #[doc = " Indicates whether or not the link layer is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   Link layer is enabled.\n @retval FALSE  Link layer is not enabled."]
7484    pub fn otLinkIsEnabled(aInstance: *mut otInstance) -> bool;
7485}
7486extern "C" {
7487    #[doc = " Indicates whether or not CSL is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   Link layer is CSL enabled.\n @retval FALSE  Link layer is not CSL enabled."]
7488    pub fn otLinkIsCslEnabled(aInstance: *mut otInstance) -> bool;
7489}
7490extern "C" {
7491    #[doc = " Indicates whether the device is connected to a parent which supports CSL.\n\n @retval TRUE   If parent supports CSL.\n @retval FALSE  If parent does not support CSL."]
7492    pub fn otLinkIsCslSupported(aInstance: *mut otInstance) -> bool;
7493}
7494extern "C" {
7495    #[doc = " Instructs the device to send an empty IEEE 802.15.4 data frame.\n\n Is only supported on an Rx-Off-When-Idle device to send an empty data frame to its parent.\n Note: available only when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully enqueued an empty message.\n @retval OT_ERROR_INVALID_STATE  Device is not in Rx-Off-When-Idle mode.\n @retval OT_ERROR_NO_BUFS        Insufficient message buffers available."]
7496    pub fn otLinkSendEmptyData(aInstance: *mut otInstance) -> otError;
7497}
7498extern "C" {
7499    #[doc = " Sets the region code.\n\n The radio region format is the 2-bytes ascii representation of the ISO 3166 alpha-2 code.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[in]  aRegionCode  The radio region code. The `aRegionCode >> 8` is first ascii char\n                          and the `aRegionCode & 0xff` is the second ascii char.\n\n @retval  OT_ERROR_FAILED           Other platform specific errors.\n @retval  OT_ERROR_NONE             Successfully set region code.\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented."]
7500    pub fn otLinkSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
7501}
7502extern "C" {
7503    #[doc = " Get the region code.\n\n The radio region format is the 2-bytes ascii representation of the ISO 3166 alpha-2 code.\n\n @param[in]  aInstance    The OpenThread instance structure.\n @param[out] aRegionCode  The radio region code. The `aRegionCode >> 8` is first ascii char\n                          and the `aRegionCode & 0xff` is the second ascii char.\n\n @retval  OT_ERROR_INVALID_ARGS     @p aRegionCode is nullptr.\n @retval  OT_ERROR_FAILED           Other platform specific errors.\n @retval  OT_ERROR_NONE             Successfully got region code.\n @retval  OT_ERROR_NOT_IMPLEMENTED  The feature is not implemented."]
7504    pub fn otLinkGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
7505}
7506extern "C" {
7507    #[doc = " Gets the Wake-up channel.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` or `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The Wake-up channel."]
7508    pub fn otLinkGetWakeupChannel(aInstance: *mut otInstance) -> u8;
7509}
7510extern "C" {
7511    #[doc = " Sets the Wake-up channel.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` or `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aChannel   The Wake-up sample channel. Channel value should be `0` (Set Wake-up Channel unspecified,\n                        which means the device will use the PAN channel) or within the range [1, 10] (if 915-MHz\n                        supported) and [11, 26] (if 2.4 GHz supported).\n\n @retval OT_ERROR_NONE           Successfully set the Wake-up channel.\n @retval OT_ERROR_INVALID_ARGS   Invalid @p aChannel."]
7512    pub fn otLinkSetWakeupChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7513}
7514extern "C" {
7515    #[doc = " Enables or disables listening for wake-up frames.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aEnable       true to enable listening for wake-up frames, or false otherwise.\n\n @retval OT_ERROR_NONE          Successfully enabled / disabled the listening for wake-up frames.\n @retval OT_ERROR_INVALID_ARGS  The listen duration is greater than the listen interval.\n @retval OT_ERROR_INVALID_STATE Could not enable listening for wake-up frames due to bad configuration."]
7516    pub fn otLinkSetWakeUpListenEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7517}
7518extern "C" {
7519    #[doc = " Returns whether listening for wake-up frames is enabled.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n\n @retval TRUE   If listening for wake-up frames is enabled.\n @retval FALSE  If listening for wake-up frames is not enabled."]
7520    pub fn otLinkIsWakeupListenEnabled(aInstance: *mut otInstance) -> bool;
7521}
7522extern "C" {
7523    #[doc = " Get the wake-up listen parameters.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[out] aInterval   A pointer to return the wake-up listen interval in microseconds.\n @param[out] aDuration   A pointer to return the wake-up listen duration in microseconds."]
7524    pub fn otLinkGetWakeupListenParameters(
7525        aInstance: *mut otInstance,
7526        aInterval: *mut u32,
7527        aDuration: *mut u32,
7528    );
7529}
7530extern "C" {
7531    #[doc = " Set the wake-up listen parameters.\n\n The listen interval must be greater than the listen duration.\n The listen duration must be greater or equal than the minimum supported.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aInterval   The wake-up listen interval in microseconds.\n @param[in]  aDuration   The wake-up listen duration in microseconds.\n\n @retval OT_ERROR_NONE           Successfully set the wake-up listen parameters.\n @retval OT_ERROR_INVALID_ARGS   Invalid wake-up listen parameters."]
7532    pub fn otLinkSetWakeupListenParameters(
7533        aInstance: *mut otInstance,
7534        aInterval: u32,
7535        aDuration: u32,
7536    ) -> otError;
7537}
7538extern "C" {
7539    #[doc = " Sets the rx-on-when-idle state.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aRxOnWhenIdle  TRUE to keep radio in Receive state, FALSE to put to Sleep state during idle periods.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7540    pub fn otLinkSetRxOnWhenIdle(aInstance: *mut otInstance, aRxOnWhenIdle: bool) -> otError;
7541}
7542#[doc = " Represents the result (value) for a Link Metrics query."]
7543#[repr(C)]
7544#[derive(Debug, Default, Copy, Clone)]
7545pub struct otLinkMetricsValues {
7546    #[doc = "< Specifies which metrics values are present/included."]
7547    pub mMetrics: otLinkMetrics,
7548    #[doc = "< The value of Pdu Count."]
7549    pub mPduCountValue: u32,
7550    #[doc = "< The value LQI."]
7551    pub mLqiValue: u8,
7552    #[doc = "< The value of Link Margin."]
7553    pub mLinkMarginValue: u8,
7554    #[doc = "< The value of Rssi."]
7555    pub mRssiValue: i8,
7556}
7557#[doc = " Represents which frames are accounted in a Forward Tracking Series."]
7558#[repr(C, packed)]
7559#[derive(Debug, Default, Copy, Clone)]
7560pub struct otLinkMetricsSeriesFlags {
7561    pub _bitfield_align_1: [u8; 0],
7562    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7563}
7564impl otLinkMetricsSeriesFlags {
7565    #[inline]
7566    pub fn mLinkProbe(&self) -> bool {
7567        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
7568    }
7569    #[inline]
7570    pub fn set_mLinkProbe(&mut self, val: bool) {
7571        unsafe {
7572            let val: u8 = ::std::mem::transmute(val);
7573            self._bitfield_1.set(0usize, 1u8, val as u64)
7574        }
7575    }
7576    #[inline]
7577    pub fn mMacData(&self) -> bool {
7578        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
7579    }
7580    #[inline]
7581    pub fn set_mMacData(&mut self, val: bool) {
7582        unsafe {
7583            let val: u8 = ::std::mem::transmute(val);
7584            self._bitfield_1.set(1usize, 1u8, val as u64)
7585        }
7586    }
7587    #[inline]
7588    pub fn mMacDataRequest(&self) -> bool {
7589        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
7590    }
7591    #[inline]
7592    pub fn set_mMacDataRequest(&mut self, val: bool) {
7593        unsafe {
7594            let val: u8 = ::std::mem::transmute(val);
7595            self._bitfield_1.set(2usize, 1u8, val as u64)
7596        }
7597    }
7598    #[inline]
7599    pub fn mMacAck(&self) -> bool {
7600        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
7601    }
7602    #[inline]
7603    pub fn set_mMacAck(&mut self, val: bool) {
7604        unsafe {
7605            let val: u8 = ::std::mem::transmute(val);
7606            self._bitfield_1.set(3usize, 1u8, val as u64)
7607        }
7608    }
7609    #[inline]
7610    pub fn new_bitfield_1(
7611        mLinkProbe: bool,
7612        mMacData: bool,
7613        mMacDataRequest: bool,
7614        mMacAck: bool,
7615    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7616        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7617        __bindgen_bitfield_unit.set(0usize, 1u8, {
7618            let mLinkProbe: u8 = unsafe { ::std::mem::transmute(mLinkProbe) };
7619            mLinkProbe as u64
7620        });
7621        __bindgen_bitfield_unit.set(1usize, 1u8, {
7622            let mMacData: u8 = unsafe { ::std::mem::transmute(mMacData) };
7623            mMacData as u64
7624        });
7625        __bindgen_bitfield_unit.set(2usize, 1u8, {
7626            let mMacDataRequest: u8 = unsafe { ::std::mem::transmute(mMacDataRequest) };
7627            mMacDataRequest as u64
7628        });
7629        __bindgen_bitfield_unit.set(3usize, 1u8, {
7630            let mMacAck: u8 = unsafe { ::std::mem::transmute(mMacAck) };
7631            mMacAck as u64
7632        });
7633        __bindgen_bitfield_unit
7634    }
7635}
7636#[doc = "< Clear."]
7637pub const OT_LINK_METRICS_ENH_ACK_CLEAR: otLinkMetricsEnhAckFlags = 0;
7638#[doc = "< Register."]
7639pub const OT_LINK_METRICS_ENH_ACK_REGISTER: otLinkMetricsEnhAckFlags = 1;
7640#[doc = " Enhanced-ACK Flags.\n\n These are used in Enhanced-ACK Based Probing to indicate whether to register or clear the probing."]
7641pub type otLinkMetricsEnhAckFlags = ::std::os::raw::c_uint;
7642pub const OT_LINK_METRICS_STATUS_SUCCESS: otLinkMetricsStatus = 0;
7643pub const OT_LINK_METRICS_STATUS_CANNOT_SUPPORT_NEW_SERIES: otLinkMetricsStatus = 1;
7644pub const OT_LINK_METRICS_STATUS_SERIESID_ALREADY_REGISTERED: otLinkMetricsStatus = 2;
7645pub const OT_LINK_METRICS_STATUS_SERIESID_NOT_RECOGNIZED: otLinkMetricsStatus = 3;
7646pub const OT_LINK_METRICS_STATUS_NO_MATCHING_FRAMES_RECEIVED: otLinkMetricsStatus = 4;
7647pub const OT_LINK_METRICS_STATUS_OTHER_ERROR: otLinkMetricsStatus = 254;
7648#[doc = " Link Metrics Status values."]
7649pub type otLinkMetricsStatus = ::std::os::raw::c_uint;
7650#[doc = " Pointer is called when a Link Metrics report is received.\n\n @param[in]  aSource         A pointer to the source address.\n @param[in]  aMetricsValues  A pointer to the Link Metrics values (the query result).\n @param[in]  aStatus         The status code in the report (only useful when @p aMetricsValues is NULL).\n @param[in]  aContext        A pointer to application-specific context."]
7651pub type otLinkMetricsReportCallback = ::std::option::Option<
7652    unsafe extern "C" fn(
7653        aSource: *const otIp6Address,
7654        aMetricsValues: *const otLinkMetricsValues,
7655        aStatus: otLinkMetricsStatus,
7656        aContext: *mut ::std::os::raw::c_void,
7657    ),
7658>;
7659#[doc = " Pointer is called when a Link Metrics Management Response is received.\n\n @param[in]  aSource         A pointer to the source address.\n @param[in]  aStatus         The status code in the response.\n @param[in]  aContext        A pointer to application-specific context."]
7660pub type otLinkMetricsMgmtResponseCallback = ::std::option::Option<
7661    unsafe extern "C" fn(
7662        aSource: *const otIp6Address,
7663        aStatus: otLinkMetricsStatus,
7664        aContext: *mut ::std::os::raw::c_void,
7665    ),
7666>;
7667#[doc = " Pointer is called when Enh-ACK Probing IE is received.\n\n @param[in] aShortAddress     The Mac short address of the Probing Subject.\n @param[in] aExtAddress       A pointer to the Mac extended address of the Probing Subject.\n @param[in] aMetricsValues    A pointer to the Link Metrics values obtained from the IE.\n @param[in] aContext          A pointer to application-specific context."]
7668pub type otLinkMetricsEnhAckProbingIeReportCallback = ::std::option::Option<
7669    unsafe extern "C" fn(
7670        aShortAddress: otShortAddress,
7671        aExtAddress: *const otExtAddress,
7672        aMetricsValues: *const otLinkMetricsValues,
7673        aContext: *mut ::std::os::raw::c_void,
7674    ),
7675>;
7676extern "C" {
7677    #[doc = " Sends an MLE Data Request to query Link Metrics.\n\n It could be either Single Probe or Forward Tracking Series.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aDestination         A pointer to the destination address.\n @param[in]  aSeriesId            The Series ID to query about, 0 for Single Probe.\n @param[in]  aLinkMetricsFlags    A pointer to flags specifying what metrics to query.\n @param[in]  aCallback            A pointer to a function that is called when Link Metrics report is received.\n @param[in]  aCallbackContext     A pointer to application-specific context.\n\n @retval OT_ERROR_NONE              Successfully sent a Link Metrics query message.\n @retval OT_ERROR_NO_BUFS           Insufficient buffers to generate the MLE Data Request message.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR  @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE       The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7678    pub fn otLinkMetricsQuery(
7679        aInstance: *mut otInstance,
7680        aDestination: *const otIp6Address,
7681        aSeriesId: u8,
7682        aLinkMetricsFlags: *const otLinkMetrics,
7683        aCallback: otLinkMetricsReportCallback,
7684        aCallbackContext: *mut ::std::os::raw::c_void,
7685    ) -> otError;
7686}
7687extern "C" {
7688    #[doc = " Sends an MLE Link Metrics Management Request to configure or clear a Forward Tracking Series.\n\n @param[in] aInstance          A pointer to an OpenThread instance.\n @param[in] aDestination       A pointer to the destination address.\n @param[in] aSeriesId          The Series ID to operate with.\n @param[in] aSeriesFlags       The Series Flags that specifies which frames are to be accounted.\n @param[in] aLinkMetricsFlags  A pointer to flags specifying what metrics to query. Should be `NULL` when\n                               `aSeriesFlags` is `0`.\n @param[in]  aCallback         A pointer to a function that is called when Link Metrics Management Response is\n                               received.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @retval OT_ERROR_NONE              Successfully sent a Link Metrics Management Request message.\n @retval OT_ERROR_NO_BUFS           Insufficient buffers to generate the MLE Link Metrics Management Request message.\n @retval OT_ERROR_INVALID_ARGS      @p aSeriesId is not within the valid range.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR  @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE       The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7689    pub fn otLinkMetricsConfigForwardTrackingSeries(
7690        aInstance: *mut otInstance,
7691        aDestination: *const otIp6Address,
7692        aSeriesId: u8,
7693        aSeriesFlags: otLinkMetricsSeriesFlags,
7694        aLinkMetricsFlags: *const otLinkMetrics,
7695        aCallback: otLinkMetricsMgmtResponseCallback,
7696        aCallbackContext: *mut ::std::os::raw::c_void,
7697    ) -> otError;
7698}
7699extern "C" {
7700    #[doc = " Sends an MLE Link Metrics Management Request to configure/clear an Enhanced-ACK Based Probing.\n This functionality requires OT_LINK_METRICS_INITIATOR feature enabled.\n\n @param[in] aInstance          A pointer to an OpenThread instance.\n @param[in] aDestination       A pointer to the destination address.\n @param[in] aEnhAckFlags       Enh-ACK Flags to indicate whether to register or clear the probing. `0` to clear and\n                               `1` to register. Other values are reserved.\n @param[in] aLinkMetricsFlags  A pointer to flags specifying what metrics to query. Should be `NULL` when\n                               `aEnhAckFlags` is `0`.\n @param[in] aCallback          A pointer to a function that is called when an Enhanced Ack with Link Metrics is\n                               received.\n @param[in] aCallbackContext   A pointer to application-specific context.\n\n @retval OT_ERROR_NONE              Successfully sent a Link Metrics Management Request message.\n @retval OT_ERROR_NO_BUFS           Insufficient buffers to generate the MLE Link Metrics Management Request message.\n @retval OT_ERROR_INVALID_ARGS      @p aEnhAckFlags is not a valid value or @p aLinkMetricsFlags isn't correct.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR  @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE       The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7701    pub fn otLinkMetricsConfigEnhAckProbing(
7702        aInstance: *mut otInstance,
7703        aDestination: *const otIp6Address,
7704        aEnhAckFlags: otLinkMetricsEnhAckFlags,
7705        aLinkMetricsFlags: *const otLinkMetrics,
7706        aCallback: otLinkMetricsMgmtResponseCallback,
7707        aCallbackContext: *mut ::std::os::raw::c_void,
7708        aEnhAckCallback: otLinkMetricsEnhAckProbingIeReportCallback,
7709        aEnhAckCallbackContext: *mut ::std::os::raw::c_void,
7710    ) -> otError;
7711}
7712extern "C" {
7713    #[doc = " Sends an MLE Link Probe message.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n @param[in] aDestination    A pointer to the destination address.\n @param[in] aSeriesId       The Series ID [1, 254] which the Probe message aims at.\n @param[in] aLength         The length of the data payload in Link Probe TLV, [0, 64] (per Thread 1.2 spec, 4.4.37).\n\n @retval OT_ERROR_NONE              Successfully sent a Link Probe message.\n @retval OT_ERROR_NO_BUFS           Insufficient buffers to generate the MLE Link Probe message.\n @retval OT_ERROR_INVALID_ARGS      @p aSeriesId or @p aLength is not within the valid range.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR  @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE       The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7714    pub fn otLinkMetricsSendLinkProbe(
7715        aInstance: *mut otInstance,
7716        aDestination: *const otIp6Address,
7717        aSeriesId: u8,
7718        aLength: u8,
7719    ) -> otError;
7720}
7721extern "C" {
7722    #[doc = " If Link Metrics Manager is enabled.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n\n @retval TRUE   Link Metrics Manager is enabled.\n @retval FALSE  Link Metrics Manager is not enabled."]
7723    pub fn otLinkMetricsManagerIsEnabled(aInstance: *mut otInstance) -> bool;
7724}
7725extern "C" {
7726    #[doc = " Enable or disable Link Metrics Manager.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n @param[in] aEnable         A boolean indicating to enable or disable."]
7727    pub fn otLinkMetricsManagerSetEnabled(aInstance: *mut otInstance, aEnable: bool);
7728}
7729extern "C" {
7730    #[doc = " Get Link Metrics data of a neighbor by its extended address.\n\n @param[in]  aInstance           A pointer to an OpenThread instance.\n @param[in]  aExtAddress         A pointer to the Mac extended address of the Probing Subject.\n @param[out] aLinkMetricsValues  A pointer to the Link Metrics values of the subject.\n\n @retval OT_ERROR_NONE              Successfully got the Link Metrics data.\n @retval OT_ERROR_INVALID_ARGS      The arguments are invalid.\n @retval OT_ERROR_NOT_FOUND         No neighbor with the given extended address is found."]
7731    pub fn otLinkMetricsManagerGetMetricsValueByExtAddr(
7732        aInstance: *mut otInstance,
7733        aExtAddress: *const otExtAddress,
7734        aLinkMetricsValues: *mut otLinkMetricsValues,
7735    ) -> otError;
7736}
7737#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aFrame       A pointer to the received frame or NULL if the receive operation was aborted.\n @param[in]  aError       OT_ERROR_NONE when successfully received a frame.\n                          OT_ERROR_ABORT when reception was aborted and a frame was not received."]
7738pub type otLinkRawReceiveDone = ::std::option::Option<
7739    unsafe extern "C" fn(aInstance: *mut otInstance, aFrame: *mut otRadioFrame, aError: otError),
7740>;
7741extern "C" {
7742    #[doc = " Enables/disables the raw link-layer.\n\n @param[in] aInstance     A pointer to an OpenThread instance.\n @param[in] aCallback     A pointer to a function called on receipt of a IEEE 802.15.4 frame. NULL to disable the\n raw-link layer.\n\n @retval OT_ERROR_FAILED          The radio could not be enabled/disabled.\n @retval OT_ERROR_INVALID_STATE   If the OpenThread IPv6 interface is already enabled.\n @retval OT_ERROR_NONE            If the enable state was successfully set."]
7743    pub fn otLinkRawSetReceiveDone(
7744        aInstance: *mut otInstance,
7745        aCallback: otLinkRawReceiveDone,
7746    ) -> otError;
7747}
7748extern "C" {
7749    #[doc = " Indicates whether or not the raw link-layer is enabled.\n\n @param[in] aInstance     A pointer to an OpenThread instance.\n\n @retval true     The raw link-layer is enabled.\n @retval false    The raw link-layer is disabled."]
7750    pub fn otLinkRawIsEnabled(aInstance: *mut otInstance) -> bool;
7751}
7752extern "C" {
7753    #[doc = " Gets the status of promiscuous mode.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @retval true     Promiscuous mode is enabled.\n @retval false    Promiscuous mode is disabled."]
7754    pub fn otLinkRawGetPromiscuous(aInstance: *mut otInstance) -> bool;
7755}
7756extern "C" {
7757    #[doc = " Enables or disables promiscuous mode.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aEnable      A value to enable or disable promiscuous mode.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7758    pub fn otLinkRawSetPromiscuous(aInstance: *mut otInstance, aEnable: bool) -> otError;
7759}
7760extern "C" {
7761    #[doc = " Set the Short Address for address filtering.\n\n @param[in] aInstance      A pointer to an OpenThread instance.\n @param[in] aShortAddress  The IEEE 802.15.4 Short Address.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7762    pub fn otLinkRawSetShortAddress(aInstance: *mut otInstance, aShortAddress: u16) -> otError;
7763}
7764extern "C" {
7765    #[doc = " Set the alternate short address.\n\n This is an optional API. Support for this is indicated by including the capability `OT_RADIO_CAPS_ALT_SHORT_ADDR` in\n `otLinkRawGetCaps()`.\n\n When supported, the radio will accept received frames destined to the specified alternate short address in addition\n to the short address provided in `otLinkRawSetShortAddress()`.\n\n The @p aShortAddress can be set to `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) to clear any previously set alternate\n short address.\n\n @param[in] aInstance      The OpenThread instance structure.\n @param[in] aShortAddress  The alternate short address. `OT_RADIO_INVALID_SHORT_ADDR` to clear.\n\n @retval OT_ERROR_NONE             Successfully set the alternate short address.\n @retval OT_ERROR_INVALID_STATE    The raw link-layer is not enabled."]
7766    pub fn otLinkRawSetAlternateShortAddress(
7767        aInstance: *mut otInstance,
7768        aShortAddress: otShortAddress,
7769    ) -> otError;
7770}
7771extern "C" {
7772    #[doc = " Transition the radio from Receive to Sleep.\n Turn off the radio.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE             Successfully transitioned to Sleep.\n @retval OT_ERROR_BUSY             The radio was transmitting\n @retval OT_ERROR_INVALID_STATE    The radio was disabled"]
7773    pub fn otLinkRawSleep(aInstance: *mut otInstance) -> otError;
7774}
7775extern "C" {
7776    #[doc = " Transitioning the radio from Sleep to Receive.\n Turn on the radio.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE             Successfully transitioned to Receive.\n @retval OT_ERROR_INVALID_STATE    The radio was disabled or transmitting."]
7777    pub fn otLinkRawReceive(aInstance: *mut otInstance) -> otError;
7778}
7779extern "C" {
7780    #[doc = " The radio transitions from Transmit to Receive.\n Returns a pointer to the transmit buffer.\n\n The caller forms the IEEE 802.15.4 frame in this buffer then calls otLinkRawTransmit()\n to request transmission.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns A pointer to the transmit buffer or NULL if the raw link-layer isn't enabled."]
7781    pub fn otLinkRawGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
7782}
7783#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aFrame           A pointer to the frame that was transmitted.\n @param[in]  aAckFrame        A pointer to the ACK frame.\n @param[in]  aError           OT_ERROR_NONE when the frame was transmitted.\n                              OT_ERROR_NO_ACK when the frame was transmitted but no ACK was received\n                              OT_ERROR_CHANNEL_ACCESS_FAILURE when the transmission could not take place\ndue to activity on the channel.\n                              OT_ERROR_ABORT when transmission was aborted for other reasons."]
7784pub type otLinkRawTransmitDone = ::std::option::Option<
7785    unsafe extern "C" fn(
7786        aInstance: *mut otInstance,
7787        aFrame: *mut otRadioFrame,
7788        aAckFrame: *mut otRadioFrame,
7789        aError: otError,
7790    ),
7791>;
7792extern "C" {
7793    #[doc = " Begins the transmit sequence on the radio.\n\n The caller must form the IEEE 802.15.4 frame in the buffer provided by otLinkRawGetTransmitBuffer() before\n requesting transmission.  The channel and transmit power are also included in the otRadioFrame structure.\n\n The transmit sequence consists of:\n 1. Transitioning the radio to Transmit from Receive.\n 2. Transmits the PSDU on the given channel and at the given transmit power.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aCallback    A pointer to a function called on completion of the transmission.\n\n @retval OT_ERROR_NONE          Successfully transitioned to Transmit.\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state."]
7794    pub fn otLinkRawTransmit(
7795        aInstance: *mut otInstance,
7796        aCallback: otLinkRawTransmitDone,
7797    ) -> otError;
7798}
7799extern "C" {
7800    #[doc = " Get the most recent RSSI measurement.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns The RSSI in dBm when it is valid. 127 when RSSI is invalid."]
7801    pub fn otLinkRawGetRssi(aInstance: *mut otInstance) -> i8;
7802}
7803extern "C" {
7804    #[doc = " Get the radio capabilities.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns The radio capability bit vector. The stack enables or disables some functions based on this value."]
7805    pub fn otLinkRawGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
7806}
7807#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aEnergyScanMaxRssi   The maximum RSSI encountered on the scanned channel."]
7808pub type otLinkRawEnergyScanDone =
7809    ::std::option::Option<unsafe extern "C" fn(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8)>;
7810extern "C" {
7811    #[doc = " Begins the energy scan sequence on the radio.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aScanChannel     The channel to perform the energy scan on.\n @param[in]  aScanDuration    The duration, in milliseconds, for the channel to be scanned.\n @param[in]  aCallback        A pointer to a function called on completion of a scanned channel.\n\n @retval OT_ERROR_NONE             Successfully started scanning the channel.\n @retval OT_ERROR_BUSY             The radio is performing energy scanning.\n @retval OT_ERROR_NOT_IMPLEMENTED  The radio doesn't support energy scanning.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7812    pub fn otLinkRawEnergyScan(
7813        aInstance: *mut otInstance,
7814        aScanChannel: u8,
7815        aScanDuration: u16,
7816        aCallback: otLinkRawEnergyScanDone,
7817    ) -> otError;
7818}
7819extern "C" {
7820    #[doc = " Enable/Disable source match for frame pending.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aEnable      Enable/disable source match for frame pending.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7821    pub fn otLinkRawSrcMatchEnable(aInstance: *mut otInstance, aEnable: bool) -> otError;
7822}
7823extern "C" {
7824    #[doc = " Adding short address to the source match table.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aShortAddress    The short address to be added.\n\n @retval OT_ERROR_NONE             Successfully added short address to the source match table.\n @retval OT_ERROR_NO_BUFS          No available entry in the source match table.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7825    pub fn otLinkRawSrcMatchAddShortEntry(
7826        aInstance: *mut otInstance,
7827        aShortAddress: u16,
7828    ) -> otError;
7829}
7830extern "C" {
7831    #[doc = " Adding extended address to the source match table.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aExtAddress      The extended address to be added.\n\n @retval OT_ERROR_NONE             Successfully added extended address to the source match table.\n @retval OT_ERROR_NO_BUFS          No available entry in the source match table.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7832    pub fn otLinkRawSrcMatchAddExtEntry(
7833        aInstance: *mut otInstance,
7834        aExtAddress: *const otExtAddress,
7835    ) -> otError;
7836}
7837extern "C" {
7838    #[doc = " Removing short address to the source match table.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aShortAddress    The short address to be removed.\n\n @retval OT_ERROR_NONE             Successfully removed short address from the source match table.\n @retval OT_ERROR_NO_ADDRESS       The short address is not in source match table.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7839    pub fn otLinkRawSrcMatchClearShortEntry(
7840        aInstance: *mut otInstance,
7841        aShortAddress: u16,
7842    ) -> otError;
7843}
7844extern "C" {
7845    #[doc = " Removing extended address to the source match table of the radio.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aExtAddress      The extended address to be removed.\n\n @retval OT_ERROR_NONE             Successfully removed the extended address from the source match table.\n @retval OT_ERROR_NO_ADDRESS       The extended address is not in source match table.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7846    pub fn otLinkRawSrcMatchClearExtEntry(
7847        aInstance: *mut otInstance,
7848        aExtAddress: *const otExtAddress,
7849    ) -> otError;
7850}
7851extern "C" {
7852    #[doc = " Removing all the short addresses from the source match table.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7853    pub fn otLinkRawSrcMatchClearShortEntries(aInstance: *mut otInstance) -> otError;
7854}
7855extern "C" {
7856    #[doc = " Removing all the extended addresses from the source match table.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7857    pub fn otLinkRawSrcMatchClearExtEntries(aInstance: *mut otInstance) -> otError;
7858}
7859extern "C" {
7860    #[doc = " Update MAC keys and key index.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[in]   aKeyIdMode   The key ID mode.\n @param[in]   aKeyId       The key index.\n @param[in]   aPrevKey     The previous MAC key.\n @param[in]   aCurrKey     The current MAC key.\n @param[in]   aNextKey     The next MAC key.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7861    pub fn otLinkRawSetMacKey(
7862        aInstance: *mut otInstance,
7863        aKeyIdMode: u8,
7864        aKeyId: u8,
7865        aPrevKey: *const otMacKey,
7866        aCurrKey: *const otMacKey,
7867        aNextKey: *const otMacKey,
7868    ) -> otError;
7869}
7870extern "C" {
7871    #[doc = " Sets the current MAC frame counter value.\n\n Always sets the MAC counter to the new given value @p aMacFrameCounter independent of the current\n value.\n\n @param[in]   aInstance         A pointer to an OpenThread instance.\n @param[in]   aMacFrameCounter  The MAC frame counter value.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7872    pub fn otLinkRawSetMacFrameCounter(
7873        aInstance: *mut otInstance,
7874        aMacFrameCounter: u32,
7875    ) -> otError;
7876}
7877extern "C" {
7878    #[doc = " Sets the current MAC frame counter value only if the new value is larger than the current one.\n\n @param[in]   aInstance         A pointer to an OpenThread instance.\n @param[in]   aMacFrameCounter  The MAC frame counter value.\n\n @retval OT_ERROR_NONE             If successful.\n @retval OT_ERROR_INVALID_STATE    If the raw link-layer isn't enabled."]
7879    pub fn otLinkRawSetMacFrameCounterIfLarger(
7880        aInstance: *mut otInstance,
7881        aMacFrameCounter: u32,
7882    ) -> otError;
7883}
7884extern "C" {
7885    #[doc = " Get current platform time (64bits width) of the radio chip.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns The current radio time in microseconds."]
7886    pub fn otLinkRawGetRadioTime(aInstance: *mut otInstance) -> u64;
7887}
7888extern "C" {
7889    #[doc = " Returns the current log level.\n\n If dynamic log level feature `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE` is enabled, this function returns the\n currently set dynamic log level. Otherwise, this function returns the build-time configured log level.\n\n @returns The log level."]
7890    pub fn otLoggingGetLevel() -> otLogLevel;
7891}
7892extern "C" {
7893    #[doc = " Sets the log level.\n\n @note This function requires `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE=1`.\n\n @param[in]  aLogLevel               The log level.\n\n @retval OT_ERROR_NONE            Successfully updated log level.\n @retval OT_ERROR_INVALID_ARGS    Log level value is invalid."]
7894    pub fn otLoggingSetLevel(aLogLevel: otLogLevel) -> otError;
7895}
7896extern "C" {
7897    #[doc = " Emits a log message at critical log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below critical, this function does not emit any log message.\n\n @param[in]  aFormat  The format string.\n @param[in]  ...      Arguments for the format specification."]
7898    pub fn otLogCritPlat(aFormat: *const ::std::os::raw::c_char, ...);
7899}
7900extern "C" {
7901    #[doc = " Emits a log message at warning log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below warning, this function does not emit any log message.\n\n @param[in]  aFormat  The format string.\n @param[in]  ...      Arguments for the format specification."]
7902    pub fn otLogWarnPlat(aFormat: *const ::std::os::raw::c_char, ...);
7903}
7904extern "C" {
7905    #[doc = " Emits a log message at note log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below note, this function does not emit any log message.\n\n @param[in]  aFormat  The format string.\n @param[in]  ...      Arguments for the format specification."]
7906    pub fn otLogNotePlat(aFormat: *const ::std::os::raw::c_char, ...);
7907}
7908extern "C" {
7909    #[doc = " Emits a log message at info log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below info, this function does not emit any log message.\n\n @param[in]  aFormat  The format string.\n @param[in]  ...      Arguments for the format specification."]
7910    pub fn otLogInfoPlat(aFormat: *const ::std::os::raw::c_char, ...);
7911}
7912extern "C" {
7913    #[doc = " Emits a log message at debug log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below debug, this function does not emit any log message.\n\n @param[in]  aFormat  The format string.\n @param[in]  ...      Arguments for the format specification."]
7914    pub fn otLogDebgPlat(aFormat: *const ::std::os::raw::c_char, ...);
7915}
7916extern "C" {
7917    #[doc = " Generates a memory dump at critical log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n critical this function does not emit any log message.\n\n @param[in]  aText         A string that is printed before the bytes.\n @param[in]  aData         A pointer to the data buffer.\n @param[in]  aDataLength   Number of bytes in @p aData."]
7918    pub fn otDumpCritPlat(
7919        aText: *const ::std::os::raw::c_char,
7920        aData: *const ::std::os::raw::c_void,
7921        aDataLength: u16,
7922    );
7923}
7924extern "C" {
7925    #[doc = " Generates a memory dump at warning log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n warning this function does not emit any log message.\n\n @param[in]  aText         A string that is printed before the bytes.\n @param[in]  aData         A pointer to the data buffer.\n @param[in]  aDataLength   Number of bytes in @p aData."]
7926    pub fn otDumpWarnPlat(
7927        aText: *const ::std::os::raw::c_char,
7928        aData: *const ::std::os::raw::c_void,
7929        aDataLength: u16,
7930    );
7931}
7932extern "C" {
7933    #[doc = " Generates a memory dump at note log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n note this function does not emit any log message.\n\n @param[in]  aText         A string that is printed before the bytes.\n @param[in]  aData         A pointer to the data buffer.\n @param[in]  aDataLength   Number of bytes in @p aData."]
7934    pub fn otDumpNotePlat(
7935        aText: *const ::std::os::raw::c_char,
7936        aData: *const ::std::os::raw::c_void,
7937        aDataLength: u16,
7938    );
7939}
7940extern "C" {
7941    #[doc = " Generates a memory dump at info log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n info this function does not emit any log message.\n\n @param[in]  aText         A string that is printed before the bytes.\n @param[in]  aData         A pointer to the data buffer.\n @param[in]  aDataLength   Number of bytes in @p aData."]
7942    pub fn otDumpInfoPlat(
7943        aText: *const ::std::os::raw::c_char,
7944        aData: *const ::std::os::raw::c_void,
7945        aDataLength: u16,
7946    );
7947}
7948extern "C" {
7949    #[doc = " Generates a memory dump at debug log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n debug this function does not emit any log message.\n\n @param[in]  aText         A string that is printed before the bytes.\n @param[in]  aData         A pointer to the data buffer.\n @param[in]  aDataLength   Number of bytes in @p aData."]
7950    pub fn otDumpDebgPlat(
7951        aText: *const ::std::os::raw::c_char,
7952        aData: *const ::std::os::raw::c_void,
7953        aDataLength: u16,
7954    );
7955}
7956extern "C" {
7957    #[doc = " Emits a log message at given log level using a platform module name.\n\n This is is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below @p aLogLevel , this function does not emit any log message.\n\n The @p aPlatModuleName name is used to determine the log module name in the emitted log message, following the\n `P-{PlatModuleName}---` format. This means that the prefix string \"P-\" is added to indicate that this is a platform\n sub-module, followed by the next 12 characters of the @p PlatModuleName string, with padded hyphens `-` at the end\n to ensure that the region name is 14 characters long.\n\n @param[in] aLogLevel         The log level.\n @param[in] aPlatModuleName   The platform sub-module name.\n @param[in] aFormat           The format string.\n @param[in] ...               Arguments for the format specification."]
7958    pub fn otLogPlat(
7959        aLogLevel: otLogLevel,
7960        aPlatModuleName: *const ::std::os::raw::c_char,
7961        aFormat: *const ::std::os::raw::c_char,
7962        ...
7963    );
7964}
7965extern "C" {
7966    #[doc = " Emits a log message at given log level using a platform module name.\n\n This is is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below @p aLogLevel , this function does not emit any log message.\n\n The @p aPlatModuleName name is used to determine the log module name in the emitted log message, following the\n `P-{PlatModuleName}---` format. This means that the prefix string \"P-\" is added to indicate that this is a platform\n sub-module, followed by the next 12 characters of the @p PlatModuleName string, with padded hyphens `-` at the end\n to ensure that the region name is 14 characters long.\n\n @param[in] aLogLevel         The log level.\n @param[in] aPlatModuleName   The platform sub-module name.\n @param[in] aFormat           The format string.\n @param[in] aArgs             Arguments for the format specification."]
7967    pub fn otLogPlatArgs(
7968        aLogLevel: otLogLevel,
7969        aPlatModuleName: *const ::std::os::raw::c_char,
7970        aFormat: *const ::std::os::raw::c_char,
7971        aArgs: *mut __va_list_tag,
7972    );
7973}
7974extern "C" {
7975    #[doc = " Emits a log message at a given log level.\n\n Is intended for use by CLI only. If `OPENTHREAD_CONFIG_LOG_CLI` is not set or the current log\n level is below the given log level, this function does not emit any log message.\n\n @param[in]  aLogLevel The log level.\n @param[in]  aFormat   The format string.\n @param[in]  ...       Arguments for the format specification."]
7976    pub fn otLogCli(aLogLevel: otLogLevel, aFormat: *const ::std::os::raw::c_char, ...);
7977}
7978#[doc = " Represents information used for generating hex dump output."]
7979#[repr(C)]
7980#[derive(Debug, Copy, Clone)]
7981pub struct otLogHexDumpInfo {
7982    #[doc = "< The data byes."]
7983    pub mDataBytes: *const u8,
7984    #[doc = "< The data length (number of bytes in @p mDataBytes)"]
7985    pub mDataLength: u16,
7986    #[doc = "< Title string to add table header (MUST NOT be `NULL`)."]
7987    pub mTitle: *const ::std::os::raw::c_char,
7988    #[doc = "< Buffer to output one line of generated hex dump."]
7989    pub mLine: [::std::os::raw::c_char; 73usize],
7990    #[doc = "< Iterator used by OT stack. MUST be initialized to zero."]
7991    pub mIterator: u16,
7992}
7993impl Default for otLogHexDumpInfo {
7994    fn default() -> Self {
7995        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7996        unsafe {
7997            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7998            s.assume_init()
7999        }
8000    }
8001}
8002extern "C" {
8003    #[doc = " Generates the next hex dump line.\n\n Can call this method back-to-back to generate the hex dump output line by line. On the first call the `mIterator`\n field in @p aInfo MUST be set to zero.\n\n Here is an example of the generated hex dump output:\n\n  \"==========================[{mTitle} len=070]============================\"\n  \"| 41 D8 87 34 12 FF FF 25 | 4C 57 DA F2 FB 2F 62 7F | A..4...%LW.../b. |\"\n  \"| 3B 01 F0 4D 4C 4D 4C 54 | 4F 00 15 15 00 00 00 00 | ;..MLMLTO....... |\"\n  \"| 00 00 00 01 80 DB 60 82 | 7E 33 72 3B CC B3 A1 84 | ......`.~3r;.... |\"\n  \"| 3B E6 AD B2 0B 45 E7 45 | C5 B9 00 1A CB 2D 6D 1C | ;....E.E.....-m. |\"\n  \"| 10 3E 3C F5 D3 70       |                         | .><..p           |\"\n  \"------------------------------------------------------------------------\"\n\n @param[in,out] aInfo        A pointer to `otLogHexDumpInfo` to use to generate hex dump.\n\n @retval OT_ERROR_NONE       Successfully generated the next line, `mLine` field in @p aInfo is updated.\n @retval OT_ERROR_NOT_FOUND  Reached the end and no more line to generate."]
8004    pub fn otLogGenerateNextHexDumpLine(aInfo: *mut otLogHexDumpInfo) -> otError;
8005}
8006#[doc = " Represents information associated with a radio link."]
8007#[repr(C)]
8008#[derive(Debug, Default, Copy, Clone)]
8009pub struct otRadioLinkInfo {
8010    #[doc = "< Preference level of radio link"]
8011    pub mPreference: u8,
8012}
8013#[doc = " Represents multi radio link information associated with a neighbor."]
8014#[repr(C)]
8015#[derive(Debug, Default, Copy, Clone)]
8016pub struct otMultiRadioNeighborInfo {
8017    pub _bitfield_align_1: [u8; 0],
8018    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8019    #[doc = "< Additional info for 15.4 radio link (applicable when supported)."]
8020    pub mIeee802154Info: otRadioLinkInfo,
8021    #[doc = "< Additional info for TREL radio link (applicable when supported)."]
8022    pub mTrelUdp6Info: otRadioLinkInfo,
8023}
8024impl otMultiRadioNeighborInfo {
8025    #[inline]
8026    pub fn mSupportsIeee802154(&self) -> bool {
8027        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8028    }
8029    #[inline]
8030    pub fn set_mSupportsIeee802154(&mut self, val: bool) {
8031        unsafe {
8032            let val: u8 = ::std::mem::transmute(val);
8033            self._bitfield_1.set(0usize, 1u8, val as u64)
8034        }
8035    }
8036    #[inline]
8037    pub fn mSupportsTrelUdp6(&self) -> bool {
8038        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8039    }
8040    #[inline]
8041    pub fn set_mSupportsTrelUdp6(&mut self, val: bool) {
8042        unsafe {
8043            let val: u8 = ::std::mem::transmute(val);
8044            self._bitfield_1.set(1usize, 1u8, val as u64)
8045        }
8046    }
8047    #[inline]
8048    pub fn new_bitfield_1(
8049        mSupportsIeee802154: bool,
8050        mSupportsTrelUdp6: bool,
8051    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8052        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8053        __bindgen_bitfield_unit.set(0usize, 1u8, {
8054            let mSupportsIeee802154: u8 = unsafe { ::std::mem::transmute(mSupportsIeee802154) };
8055            mSupportsIeee802154 as u64
8056        });
8057        __bindgen_bitfield_unit.set(1usize, 1u8, {
8058            let mSupportsTrelUdp6: u8 = unsafe { ::std::mem::transmute(mSupportsTrelUdp6) };
8059            mSupportsTrelUdp6 as u64
8060        });
8061        __bindgen_bitfield_unit
8062    }
8063}
8064extern "C" {
8065    #[doc = " Gets the multi radio link information associated with a neighbor with a given Extended Address.\n\n `OPENTHREAD_CONFIG_MULTI_RADIO` must be enabled.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aExtAddress    The Extended Address of neighbor.\n @param[out] aNeighborInfo  A pointer to `otMultiRadioNeighborInfo` to output the neighbor info (on success).\n\n @retval OT_ERROR_NONE        Neighbor was found and @p aNeighborInfo was updated successfully.\n @retval OT_ERROR_NOT_FOUND   Could not find a neighbor with @p aExtAddress."]
8066    pub fn otMultiRadioGetNeighborInfo(
8067        aInstance: *mut otInstance,
8068        aExtAddress: *const otExtAddress,
8069        aNeighborInfo: *mut otMultiRadioNeighborInfo,
8070    ) -> otError;
8071}
8072#[doc = " @struct otIp4Address\n\n Represents an IPv4 address."]
8073#[repr(C, packed)]
8074#[derive(Copy, Clone)]
8075pub struct otIp4Address {
8076    pub mFields: otIp4Address__bindgen_ty_1,
8077}
8078#[repr(C, packed)]
8079#[derive(Copy, Clone)]
8080pub union otIp4Address__bindgen_ty_1 {
8081    #[doc = "< 8-bit fields"]
8082    pub m8: [u8; 4usize],
8083    #[doc = "< 32-bit representation"]
8084    pub m32: u32,
8085}
8086impl Default for otIp4Address__bindgen_ty_1 {
8087    fn default() -> Self {
8088        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8089        unsafe {
8090            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8091            s.assume_init()
8092        }
8093    }
8094}
8095impl Default for otIp4Address {
8096    fn default() -> Self {
8097        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8098        unsafe {
8099            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8100            s.assume_init()
8101        }
8102    }
8103}
8104#[doc = " @struct otIp4Cidr\n\n Represents an IPv4 CIDR block."]
8105#[repr(C)]
8106#[derive(Copy, Clone)]
8107pub struct otIp4Cidr {
8108    pub mAddress: otIp4Address,
8109    pub mLength: u8,
8110}
8111impl Default for otIp4Cidr {
8112    fn default() -> Self {
8113        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8114        unsafe {
8115            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8116            s.assume_init()
8117        }
8118    }
8119}
8120#[doc = " Represents the counters for NAT64."]
8121#[repr(C)]
8122#[derive(Debug, Default, Copy, Clone)]
8123pub struct otNat64Counters {
8124    #[doc = "< Number of packets translated from IPv4 to IPv6."]
8125    pub m4To6Packets: u64,
8126    #[doc = "< Sum of size of packets translated from IPv4 to IPv6."]
8127    pub m4To6Bytes: u64,
8128    #[doc = "< Number of packets translated from IPv6 to IPv4."]
8129    pub m6To4Packets: u64,
8130    #[doc = "< Sum of size of packets translated from IPv6 to IPv4."]
8131    pub m6To4Bytes: u64,
8132}
8133#[doc = " Represents the counters for the protocols supported by NAT64."]
8134#[repr(C)]
8135#[derive(Debug, Default, Copy, Clone)]
8136pub struct otNat64ProtocolCounters {
8137    #[doc = "< Counters for sum of all protocols."]
8138    pub mTotal: otNat64Counters,
8139    #[doc = "< Counters for ICMP and ICMPv6."]
8140    pub mIcmp: otNat64Counters,
8141    #[doc = "< Counters for UDP."]
8142    pub mUdp: otNat64Counters,
8143    #[doc = "< Counters for TCP."]
8144    pub mTcp: otNat64Counters,
8145}
8146#[doc = "< Packet drop for unknown reasons."]
8147pub const OT_NAT64_DROP_REASON_UNKNOWN: otNat64DropReason = 0;
8148#[doc = "< Packet drop due to failed to parse the datagram."]
8149pub const OT_NAT64_DROP_REASON_ILLEGAL_PACKET: otNat64DropReason = 1;
8150#[doc = "< Packet drop due to unsupported IP protocol."]
8151pub const OT_NAT64_DROP_REASON_UNSUPPORTED_PROTO: otNat64DropReason = 2;
8152#[doc = "< Packet drop due to no mappings found or mapping pool exhausted."]
8153pub const OT_NAT64_DROP_REASON_NO_MAPPING: otNat64DropReason = 3;
8154pub const OT_NAT64_DROP_REASON_COUNT: otNat64DropReason = 4;
8155#[doc = " Packet drop reasons."]
8156pub type otNat64DropReason = ::std::os::raw::c_uint;
8157#[doc = " Represents the counters of dropped packets due to errors when handling NAT64 packets."]
8158#[repr(C)]
8159#[derive(Debug, Default, Copy, Clone)]
8160pub struct otNat64ErrorCounters {
8161    #[doc = "< Errors translating IPv4 packets."]
8162    pub mCount4To6: [u64; 4usize],
8163    #[doc = "< Errors translating IPv6 packets."]
8164    pub mCount6To4: [u64; 4usize],
8165}
8166extern "C" {
8167    #[doc = " Gets NAT64 translator counters.\n\n The counter is counted since the instance initialized.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[out] aCounters A pointer to an `otNat64Counters` where the counters of NAT64 translator will be placed."]
8168    pub fn otNat64GetCounters(aInstance: *mut otInstance, aCounters: *mut otNat64ProtocolCounters);
8169}
8170extern "C" {
8171    #[doc = " Gets the NAT64 translator error counters.\n\n The counters are initialized to zero when the OpenThread instance is initialized.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[out] aCounters A pointer to an `otNat64Counters` where the counters of NAT64 translator will be placed."]
8172    pub fn otNat64GetErrorCounters(
8173        aInstance: *mut otInstance,
8174        aCounters: *mut otNat64ErrorCounters,
8175    );
8176}
8177#[doc = " Represents an address mapping record for NAT64.\n\n @note The counters will be reset for each mapping session even for the same address pair. Applications can use `mId`\n to identify different sessions to calculate the packets correctly."]
8178#[repr(C)]
8179#[derive(Copy, Clone)]
8180pub struct otNat64AddressMapping {
8181    #[doc = "< The unique id for a mapping session."]
8182    pub mId: u64,
8183    #[doc = "< The IPv4 address of the mapping."]
8184    pub mIp4: otIp4Address,
8185    #[doc = "< The IPv6 address of the mapping."]
8186    pub mIp6: otIp6Address,
8187    #[doc = " The source port or ICMP ID of the mapping. Used when\n  OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8188    pub mSrcPortOrId: u16,
8189    #[doc = " The translated port or ICMP ID of the mapping. Used when\n  OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8190    pub mTranslatedPortOrId: u16,
8191    #[doc = "< Remaining time before expiry in milliseconds."]
8192    pub mRemainingTimeMs: u32,
8193    pub mCounters: otNat64ProtocolCounters,
8194}
8195impl Default for otNat64AddressMapping {
8196    fn default() -> Self {
8197        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8198        unsafe {
8199            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8200            s.assume_init()
8201        }
8202    }
8203}
8204#[doc = " Used to iterate through NAT64 address mappings.\n\n The fields in this type are opaque (intended for use by OpenThread core only) and therefore should not be\n accessed or used by caller.\n\n Before using an iterator, it MUST be initialized using `otNat64AddressMappingIteratorInit()`."]
8205#[repr(C)]
8206#[derive(Debug, Copy, Clone)]
8207pub struct otNat64AddressMappingIterator {
8208    pub mPtr: *mut ::std::os::raw::c_void,
8209}
8210impl Default for otNat64AddressMappingIterator {
8211    fn default() -> Self {
8212        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8213        unsafe {
8214            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8215            s.assume_init()
8216        }
8217    }
8218}
8219extern "C" {
8220    #[doc = " Initializes an `otNat64AddressMappingIterator`.\n\n An iterator MUST be initialized before it is used.\n\n An iterator can be initialized again to restart from the beginning of the mapping info.\n\n @param[in]  aInstance  The OpenThread instance.\n @param[out] aIterator  A pointer to the iterator to initialize."]
8221    pub fn otNat64InitAddressMappingIterator(
8222        aInstance: *mut otInstance,
8223        aIterator: *mut otNat64AddressMappingIterator,
8224    );
8225}
8226extern "C" {
8227    #[doc = " Gets the next AddressMapping info (using an iterator).\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in]      aInstance      A pointer to an OpenThread instance.\n @param[in,out]  aIterator      A pointer to the iterator. On success the iterator will be updated to point to next\n                                NAT64 address mapping record. To get the first entry the iterator should be set to\n                                OT_NAT64_ADDRESS_MAPPING_ITERATOR_INIT.\n @param[out]     aMapping       A pointer to an `otNat64AddressMapping` where information of next NAT64 address\n                                mapping record is placed (on success).\n\n @retval OT_ERROR_NONE       Successfully found the next NAT64 address mapping info (@p aMapping was successfully\n                             updated).\n @retval OT_ERROR_NOT_FOUND  No subsequent NAT64 address mapping info was found."]
8228    pub fn otNat64GetNextAddressMapping(
8229        aInstance: *mut otInstance,
8230        aIterator: *mut otNat64AddressMappingIterator,
8231        aMapping: *mut otNat64AddressMapping,
8232    ) -> otError;
8233}
8234#[doc = "< NAT64 is disabled."]
8235pub const OT_NAT64_STATE_DISABLED: otNat64State = 0;
8236#[doc = "< NAT64 is enabled, but one or more dependencies of NAT64 are not running."]
8237pub const OT_NAT64_STATE_NOT_RUNNING: otNat64State = 1;
8238#[doc = "< NAT64 is enabled, but this BR is not an active NAT64 BR."]
8239pub const OT_NAT64_STATE_IDLE: otNat64State = 2;
8240#[doc = "< The BR is publishing a NAT64 prefix and/or translating packets."]
8241pub const OT_NAT64_STATE_ACTIVE: otNat64State = 3;
8242#[doc = " States of NAT64."]
8243pub type otNat64State = ::std::os::raw::c_uint;
8244extern "C" {
8245    #[doc = " Gets the state of NAT64 translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n\n @retval OT_NAT64_STATE_DISABLED    NAT64 translator is disabled.\n @retval OT_NAT64_STATE_NOT_RUNNING NAT64 translator is enabled, but the translator is not configured with a valid\n                                    NAT64 prefix and a CIDR.\n @retval OT_NAT64_STATE_ACTIVE      NAT64 translator is enabled, and is translating packets."]
8246    pub fn otNat64GetTranslatorState(aInstance: *mut otInstance) -> otNat64State;
8247}
8248extern "C" {
8249    #[doc = " Gets the state of NAT64 prefix manager.\n\n Available when `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is enabled.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n\n @retval OT_NAT64_STATE_DISABLED    NAT64 prefix manager is disabled.\n @retval OT_NAT64_STATE_NOT_RUNNING NAT64 prefix manager is enabled, but is not running (because the routing manager\n                                    is not running).\n @retval OT_NAT64_STATE_IDLE        NAT64 prefix manager is enabled, but is not publishing a NAT64 prefix. Usually\n                                    when there is another border router publishing a NAT64 prefix with higher\n                                    priority.\n @retval OT_NAT64_STATE_ACTIVE      NAT64 prefix manager is enabled, and is publishing NAT64 prefix to the Thread\n                                    network."]
8250    pub fn otNat64GetPrefixManagerState(aInstance: *mut otInstance) -> otNat64State;
8251}
8252extern "C" {
8253    #[doc = " Enable or disable NAT64 functions.\n\n Note: This includes the NAT64 Translator (when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled) and the NAT64\n Prefix Manager (when `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is enabled).\n\n When `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled, setting disabled to true resets the\n mapping table in the translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` or `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is\n enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   A boolean to enable/disable the NAT64 functions\n\n @sa otNat64GetTranslatorState\n @sa otNat64GetPrefixManagerState"]
8254    pub fn otNat64SetEnabled(aInstance: *mut otInstance, aEnabled: bool);
8255}
8256extern "C" {
8257    #[doc = " Allocate a new message buffer for sending an IPv4 message to the NAT64 translator.\n\n Message buffers allocated by this function will have 20 bytes (difference between the size of IPv6 headers\n and IPv4 header sizes) reserved.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @note If @p aSettings is `NULL`, the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSettings  A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.\n\n @sa otNat64Send"]
8258    pub fn otIp4NewMessage(
8259        aInstance: *mut otInstance,
8260        aSettings: *const otMessageSettings,
8261    ) -> *mut otMessage;
8262}
8263extern "C" {
8264    #[doc = " Sets the CIDR used when setting the source address of the outgoing translated IPv4 packets.\n\n Is available only when OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE is enabled.\n\n @note A valid CIDR must have a non-zero prefix length. The actual addresses pool is limited by the size of the\n mapping pool and the number of addresses available in the CIDR block.\n\n @note This function can be called at any time, but the NAT64 translator will be reset and all existing sessions will\n be expired when updating the configured CIDR.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCidr      A pointer to an otIp4Cidr for the IPv4 CIDR block for NAT64.\n\n @retval  OT_ERROR_INVALID_ARGS   The given CIDR is not a valid IPv4 CIDR for NAT64.\n @retval  OT_ERROR_NONE           Successfully set the CIDR for NAT64.\n\n @sa otNat64Send\n @sa otNat64SetReceiveIp4Callback"]
8265    pub fn otNat64SetIp4Cidr(aInstance: *mut otInstance, aCidr: *const otIp4Cidr) -> otError;
8266}
8267extern "C" {
8268    #[doc = " Clears the CIDR used when setting the source address of the outgoing translated IPv4 packets.\n\n Is available only when OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE is enabled.\n\n @note This function can be called at any time, but the NAT64 translator will be reset and all existing sessions\n will be expired when clearing the configured CIDR.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @sa otNat64SetIp4Cidr"]
8269    pub fn otNat64ClearIp4Cidr(aInstance: *mut otInstance);
8270}
8271extern "C" {
8272    #[doc = " Translates an IPv4 datagram to an IPv6 datagram and sends via the Thread interface.\n\n The caller transfers ownership of @p aMessage when making this call. OpenThread will free @p aMessage when\n processing is complete, including when a value other than `OT_ERROR_NONE` is returned.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aMessage  A pointer to the message buffer containing the IPv4 datagram.\n\n @retval OT_ERROR_NONE                    Successfully processed the message.\n @retval OT_ERROR_DROP                    Message was well-formed but not fully processed due to packet processing\n                                          rules.\n @retval OT_ERROR_NO_BUFS                 Could not allocate necessary message buffers when processing the datagram.\n @retval OT_ERROR_NO_ROUTE                No route to host.\n @retval OT_ERROR_INVALID_SOURCE_ADDRESS  Source address is invalid, e.g. an anycast address or a multicast address.\n @retval OT_ERROR_PARSE                   Encountered a malformed header when processing the message."]
8273    pub fn otNat64Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
8274}
8275#[doc = " Pointer is called when an IPv4 datagram (translated by NAT64 translator) is received.\n\n @param[in]  aMessage  A pointer to the message buffer containing the received IPv6 datagram. This function transfers\n                       the ownership of the @p aMessage to the receiver of the callback. The message should be\n                       freed by the receiver of the callback after it is processed.\n @param[in]  aContext  A pointer to application-specific context."]
8276pub type otNat64ReceiveIp4Callback = ::std::option::Option<
8277    unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
8278>;
8279extern "C" {
8280    #[doc = " Registers a callback to provide received IPv4 datagrams.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aCallback         A pointer to a function that is called when an IPv4 datagram is received or\n                               NULL to disable the callback.\n @param[in]  aContext          A pointer to application-specific context."]
8281    pub fn otNat64SetReceiveIp4Callback(
8282        aInstance: *mut otInstance,
8283        aCallback: otNat64ReceiveIp4Callback,
8284        aContext: *mut ::std::os::raw::c_void,
8285    );
8286}
8287extern "C" {
8288    #[doc = " Gets the IPv4 CIDR configured in the NAT64 translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[out] aCidr             A pointer to an otIp4Cidr. Where the CIDR will be filled."]
8289    pub fn otNat64GetCidr(aInstance: *mut otInstance, aCidr: *mut otIp4Cidr) -> otError;
8290}
8291extern "C" {
8292    #[doc = " Test if two IPv4 addresses are the same.\n\n @param[in]  aFirst   A pointer to the first IPv4 address to compare.\n @param[in]  aSecond  A pointer to the second IPv4 address to compare.\n\n @retval TRUE   The two IPv4 addresses are the same.\n @retval FALSE  The two IPv4 addresses are not the same."]
8293    pub fn otIp4IsAddressEqual(aFirst: *const otIp4Address, aSecond: *const otIp4Address) -> bool;
8294}
8295extern "C" {
8296    #[doc = " Set @p aIp4Address by performing NAT64 address translation from @p aIp6Address as specified\n in RFC 6052.\n\n The NAT64 @p aPrefixLength MUST be one of the following values: 32, 40, 48, 56, 64, or 96, otherwise the behavior\n of this method is undefined.\n\n @param[in]  aPrefixLength  The prefix length to use for IPv4/IPv6 translation.\n @param[in]  aIp6Address    A pointer to an IPv6 address.\n @param[out] aIp4Address    A pointer to output the IPv4 address."]
8297    pub fn otIp4ExtractFromIp6Address(
8298        aPrefixLength: u8,
8299        aIp6Address: *const otIp6Address,
8300        aIp4Address: *mut otIp4Address,
8301    );
8302}
8303extern "C" {
8304    #[doc = " Extracts the IPv4 address from a given IPv4-mapped IPv6 address.\n\n An IPv4-mapped IPv6 address consists of an 80-bit prefix of zeros, the next 16 bits set to ones, and the remaining,\n least-significant 32 bits contain the IPv4 address, e.g., `::ffff:192.0.2.128` representing `192.0.2.128`.\n\n @param[in]  aIp6Address  An IPv6 address to extract IPv4 from.\n @param[out] aIp4Address  An IPv4 address to output the extracted address.\n\n @retval OT_ERROR_NONE   Extracted the IPv4 address successfully. @p aIp4Address is updated.\n @retval OT_ERROR_PARSE  The @p aIp6Address does not follow the IPv4-mapped IPv6 address format."]
8305    pub fn otIp4FromIp4MappedIp6Address(
8306        aIp6Address: *const otIp6Address,
8307        aIp4Address: *mut otIp4Address,
8308    ) -> otError;
8309}
8310extern "C" {
8311    #[doc = " Converts a given IP4 address to an IPv6 address following the IPv4-mapped IPv6 address format.\n\n @param[in]  aIp4Address  An IPv4 address to convert.\n @param[out] aIp6Address  An IPv6 address to set."]
8312    pub fn otIp4ToIp4MappedIp6Address(
8313        aIp4Address: *const otIp4Address,
8314        aIp6Address: *mut otIp6Address,
8315    );
8316}
8317extern "C" {
8318    #[doc = " Converts the address to a string.\n\n The string format uses quad-dotted notation of four bytes in the address (e.g., \"127.0.0.1\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be\n truncated but the outputted string is always null-terminated.\n\n @param[in]  aAddress  A pointer to an IPv4 address (MUST NOT be NULL).\n @param[out] aBuffer   A pointer to a char array to output the string (MUST NOT be `nullptr`).\n @param[in]  aSize     The size of @p aBuffer (in bytes)."]
8319    pub fn otIp4AddressToString(
8320        aAddress: *const otIp4Address,
8321        aBuffer: *mut ::std::os::raw::c_char,
8322        aSize: u16,
8323    );
8324}
8325extern "C" {
8326    #[doc = " Converts a human-readable IPv4 CIDR string into a binary representation.\n\n @param[in]   aString   A pointer to a NULL-terminated string.\n @param[out]  aCidr     A pointer to an IPv4 CIDR.\n\n @retval OT_ERROR_NONE          Successfully parsed the string.\n @retval OT_ERROR_INVALID_ARGS  Failed to parse the string."]
8327    pub fn otIp4CidrFromString(
8328        aString: *const ::std::os::raw::c_char,
8329        aCidr: *mut otIp4Cidr,
8330    ) -> otError;
8331}
8332extern "C" {
8333    #[doc = " Converts the IPv4 CIDR to a string.\n\n The string format uses quad-dotted notation of four bytes in the address with the length of prefix (e.g.,\n \"127.0.0.1/32\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be\n truncated but the outputted string is always null-terminated.\n\n @param[in]  aCidr     A pointer to an IPv4 CIDR (MUST NOT be NULL).\n @param[out] aBuffer   A pointer to a char array to output the string (MUST NOT be `nullptr`).\n @param[in]  aSize     The size of @p aBuffer (in bytes)."]
8334    pub fn otIp4CidrToString(
8335        aCidr: *const otIp4Cidr,
8336        aBuffer: *mut ::std::os::raw::c_char,
8337        aSize: u16,
8338    );
8339}
8340extern "C" {
8341    #[doc = " Converts a human-readable IPv4 address string into a binary representation.\n\n @param[in]   aString   A pointer to a NULL-terminated string.\n @param[out]  aAddress  A pointer to an IPv4 address.\n\n @retval OT_ERROR_NONE          Successfully parsed the string.\n @retval OT_ERROR_INVALID_ARGS  Failed to parse the string."]
8342    pub fn otIp4AddressFromString(
8343        aString: *const ::std::os::raw::c_char,
8344        aAddress: *mut otIp4Address,
8345    ) -> otError;
8346}
8347extern "C" {
8348    #[doc = " Sets the IPv6 address by performing NAT64 address translation from the preferred NAT64 prefix and the given IPv4\n address as specified in RFC 6052.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[in]   aIp4Address  A pointer to the IPv4 address to translate to IPv6.\n @param[out]  aIp6Address  A pointer to the synthesized IPv6 address.\n\n @returns  OT_ERROR_NONE           Successfully synthesized the IPv6 address from NAT64 prefix and IPv4 address.\n @returns  OT_ERROR_INVALID_STATE  No valid NAT64 prefix in the network data."]
8349    pub fn otNat64SynthesizeIp6Address(
8350        aInstance: *mut otInstance,
8351        aIp4Address: *const otIp4Address,
8352        aIp6Address: *mut otIp6Address,
8353    ) -> otError;
8354}
8355#[doc = " Pointer is called to send HDLC encoded NCP data.\n\n @param[in]  aBuf        A pointer to a buffer with an output.\n @param[in]  aBufLength  A length of the output data stored in the buffer.\n\n @returns                Number of bytes processed by the callback."]
8356pub type otNcpHdlcSendCallback = ::std::option::Option<
8357    unsafe extern "C" fn(aBuf: *const u8, aBufLength: u16) -> ::std::os::raw::c_int,
8358>;
8359extern "C" {
8360    #[doc = " Is called after NCP send finished."]
8361    pub fn otNcpHdlcSendDone();
8362}
8363extern "C" {
8364    #[doc = " Is called after HDLC encoded NCP data received.\n\n @param[in]  aBuf        A pointer to a buffer.\n @param[in]  aBufLength  The length of the data stored in the buffer."]
8365    pub fn otNcpHdlcReceive(aBuf: *const u8, aBufLength: u16);
8366}
8367extern "C" {
8368    #[doc = " Initialize the NCP based on HDLC framing.\n\n @param[in]  aInstance        The OpenThread instance structure.\n @param[in]  aSendCallback    The function pointer used to send NCP data."]
8369    pub fn otNcpHdlcInit(aInstance: *mut otInstance, aSendCallback: otNcpHdlcSendCallback);
8370}
8371extern "C" {
8372    #[doc = " Initialize the NCP based on HDLC framing.\n\n @param[in]  aInstances       The OpenThread instance pointers array.\n @param[in]  aCount           Number of elements in the array.\n @param[in]  aSendCallback    The function pointer used to send NCP data."]
8373    pub fn otNcpHdlcInitMulti(
8374        aInstance: *mut *mut otInstance,
8375        aCount: u8,
8376        aSendCallback: otNcpHdlcSendCallback,
8377    );
8378}
8379extern "C" {
8380    #[doc = " Initialize the NCP based on SPI framing.\n\n @param[in]  aInstance  The OpenThread instance structure."]
8381    pub fn otNcpSpiInit(aInstance: *mut otInstance);
8382}
8383extern "C" {
8384    #[doc = " @brief Send data to the host via a specific stream.\n\n Attempts to send the given data to the host\n using the given aStreamId. This is useful for reporting\n error messages, implementing debug/diagnostic consoles,\n and potentially other types of datastreams.\n\n The write either is accepted in its entirety or rejected.\n Partial writes are not attempted.\n\n @param[in]  aStreamId  A numeric identifier for the stream to write to.\n                        If set to '0', will default to the debug stream.\n @param[in]  aDataPtr   A pointer to the data to send on the stream.\n                        If aDataLen is non-zero, this param MUST NOT be NULL.\n @param[in]  aDataLen   The number of bytes of data from aDataPtr to send.\n\n @retval OT_ERROR_NONE         The data was queued for delivery to the host.\n @retval OT_ERROR_BUSY         There are not enough resources to complete this\n                               request. This is usually a temporary condition.\n @retval OT_ERROR_INVALID_ARGS The given aStreamId was invalid."]
8385    pub fn otNcpStreamWrite(
8386        aStreamId: ::std::os::raw::c_int,
8387        aDataPtr: *const u8,
8388        aDataLen: ::std::os::raw::c_int,
8389    ) -> otError;
8390}
8391extern "C" {
8392    #[doc = " Writes OpenThread Log using `otNcpStreamWrite`.\n\n @param[in]  aLogLevel   The log level.\n @param[in]  aLogRegion  The log region.\n @param[in]  aFormat     A pointer to the format string.\n @param[in]  aArgs       va_list matching aFormat."]
8393    pub fn otNcpPlatLogv(
8394        aLogLevel: otLogLevel,
8395        aLogRegion: otLogRegion,
8396        aFormat: *const ::std::os::raw::c_char,
8397        aArgs: *mut __va_list_tag,
8398    );
8399}
8400#[doc = " Defines delegate (function pointer) type to control behavior of peek/poke operation.\n\n This delegate function is called to decide whether to allow peek or poke of a specific memory region. It is used\n if NCP support for peek/poke commands is enabled.\n\n @param[in] aAddress    Start address of memory region.\n @param[in] aCount      Number of bytes to peek or poke.\n\n @returns  TRUE to allow peek/poke of the given memory region, FALSE otherwise."]
8401pub type otNcpDelegateAllowPeekPoke =
8402    ::std::option::Option<unsafe extern "C" fn(aAddress: u32, aCount: u16) -> bool>;
8403extern "C" {
8404    #[doc = " Registers peek/poke delegate functions with NCP module.\n\n The delegate functions are called by NCP module to decide whether to allow peek or poke of a specific memory region.\n If the delegate pointer is set to NULL, it allows peek/poke operation for any address.\n\n @param[in] aAllowPeekDelegate      Delegate function pointer for peek operation.\n @param[in] aAllowPokeDelegate      Delegate function pointer for poke operation."]
8405    pub fn otNcpRegisterPeekPokeDelegates(
8406        aAllowPeekDelegate: otNcpDelegateAllowPeekPoke,
8407        aAllowPokeDelegate: otNcpDelegateAllowPeekPoke,
8408    );
8409}
8410#[doc = "< The Thread stack is disabled."]
8411pub const OT_DEVICE_ROLE_DISABLED: otDeviceRole = 0;
8412#[doc = "< Not currently participating in a Thread network/partition."]
8413pub const OT_DEVICE_ROLE_DETACHED: otDeviceRole = 1;
8414#[doc = "< The Thread Child role."]
8415pub const OT_DEVICE_ROLE_CHILD: otDeviceRole = 2;
8416#[doc = "< The Thread Router role."]
8417pub const OT_DEVICE_ROLE_ROUTER: otDeviceRole = 3;
8418#[doc = "< The Thread Leader role."]
8419pub const OT_DEVICE_ROLE_LEADER: otDeviceRole = 4;
8420#[doc = " Represents a Thread device role."]
8421pub type otDeviceRole = ::std::os::raw::c_uint;
8422#[doc = " Represents an MLE Link Mode configuration."]
8423#[repr(C, packed)]
8424#[derive(Debug, Default, Copy, Clone)]
8425pub struct otLinkModeConfig {
8426    pub _bitfield_align_1: [u8; 0],
8427    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8428}
8429impl otLinkModeConfig {
8430    #[inline]
8431    pub fn mRxOnWhenIdle(&self) -> bool {
8432        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8433    }
8434    #[inline]
8435    pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8436        unsafe {
8437            let val: u8 = ::std::mem::transmute(val);
8438            self._bitfield_1.set(0usize, 1u8, val as u64)
8439        }
8440    }
8441    #[inline]
8442    pub fn mDeviceType(&self) -> bool {
8443        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8444    }
8445    #[inline]
8446    pub fn set_mDeviceType(&mut self, val: bool) {
8447        unsafe {
8448            let val: u8 = ::std::mem::transmute(val);
8449            self._bitfield_1.set(1usize, 1u8, val as u64)
8450        }
8451    }
8452    #[inline]
8453    pub fn mNetworkData(&self) -> bool {
8454        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8455    }
8456    #[inline]
8457    pub fn set_mNetworkData(&mut self, val: bool) {
8458        unsafe {
8459            let val: u8 = ::std::mem::transmute(val);
8460            self._bitfield_1.set(2usize, 1u8, val as u64)
8461        }
8462    }
8463    #[inline]
8464    pub fn new_bitfield_1(
8465        mRxOnWhenIdle: bool,
8466        mDeviceType: bool,
8467        mNetworkData: bool,
8468    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8469        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8470        __bindgen_bitfield_unit.set(0usize, 1u8, {
8471            let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8472            mRxOnWhenIdle as u64
8473        });
8474        __bindgen_bitfield_unit.set(1usize, 1u8, {
8475            let mDeviceType: u8 = unsafe { ::std::mem::transmute(mDeviceType) };
8476            mDeviceType as u64
8477        });
8478        __bindgen_bitfield_unit.set(2usize, 1u8, {
8479            let mNetworkData: u8 = unsafe { ::std::mem::transmute(mNetworkData) };
8480            mNetworkData as u64
8481        });
8482        __bindgen_bitfield_unit
8483    }
8484}
8485#[doc = " Holds diagnostic information for a neighboring Thread node"]
8486#[repr(C)]
8487#[derive(Debug, Default, Copy, Clone)]
8488pub struct otNeighborInfo {
8489    #[doc = "< IEEE 802.15.4 Extended Address"]
8490    pub mExtAddress: otExtAddress,
8491    #[doc = "< Seconds since last heard"]
8492    pub mAge: u32,
8493    #[doc = "< Seconds since link establishment (requires `CONFIG_UPTIME_ENABLE`)"]
8494    pub mConnectionTime: u32,
8495    #[doc = "< RLOC16"]
8496    pub mRloc16: u16,
8497    #[doc = "< Link Frame Counter"]
8498    pub mLinkFrameCounter: u32,
8499    #[doc = "< MLE Frame Counter"]
8500    pub mMleFrameCounter: u32,
8501    #[doc = "< Link Quality In"]
8502    pub mLinkQualityIn: u8,
8503    #[doc = "< Average RSSI"]
8504    pub mAverageRssi: i8,
8505    #[doc = "< Last observed RSSI"]
8506    pub mLastRssi: i8,
8507    #[doc = "< Link Margin"]
8508    pub mLinkMargin: u8,
8509    #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
8510    pub mFrameErrorRate: u16,
8511    #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
8512    pub mMessageErrorRate: u16,
8513    #[doc = "< Thread version of the neighbor"]
8514    pub mVersion: u16,
8515    pub _bitfield_align_1: [u8; 0],
8516    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8517    pub __bindgen_padding_0: u8,
8518}
8519impl otNeighborInfo {
8520    #[inline]
8521    pub fn mRxOnWhenIdle(&self) -> bool {
8522        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8523    }
8524    #[inline]
8525    pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8526        unsafe {
8527            let val: u8 = ::std::mem::transmute(val);
8528            self._bitfield_1.set(0usize, 1u8, val as u64)
8529        }
8530    }
8531    #[inline]
8532    pub fn mFullThreadDevice(&self) -> bool {
8533        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8534    }
8535    #[inline]
8536    pub fn set_mFullThreadDevice(&mut self, val: bool) {
8537        unsafe {
8538            let val: u8 = ::std::mem::transmute(val);
8539            self._bitfield_1.set(1usize, 1u8, val as u64)
8540        }
8541    }
8542    #[inline]
8543    pub fn mFullNetworkData(&self) -> bool {
8544        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8545    }
8546    #[inline]
8547    pub fn set_mFullNetworkData(&mut self, val: bool) {
8548        unsafe {
8549            let val: u8 = ::std::mem::transmute(val);
8550            self._bitfield_1.set(2usize, 1u8, val as u64)
8551        }
8552    }
8553    #[inline]
8554    pub fn mIsChild(&self) -> bool {
8555        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
8556    }
8557    #[inline]
8558    pub fn set_mIsChild(&mut self, val: bool) {
8559        unsafe {
8560            let val: u8 = ::std::mem::transmute(val);
8561            self._bitfield_1.set(3usize, 1u8, val as u64)
8562        }
8563    }
8564    #[inline]
8565    pub fn new_bitfield_1(
8566        mRxOnWhenIdle: bool,
8567        mFullThreadDevice: bool,
8568        mFullNetworkData: bool,
8569        mIsChild: bool,
8570    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8571        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8572        __bindgen_bitfield_unit.set(0usize, 1u8, {
8573            let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8574            mRxOnWhenIdle as u64
8575        });
8576        __bindgen_bitfield_unit.set(1usize, 1u8, {
8577            let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
8578            mFullThreadDevice as u64
8579        });
8580        __bindgen_bitfield_unit.set(2usize, 1u8, {
8581            let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
8582            mFullNetworkData as u64
8583        });
8584        __bindgen_bitfield_unit.set(3usize, 1u8, {
8585            let mIsChild: u8 = unsafe { ::std::mem::transmute(mIsChild) };
8586            mIsChild as u64
8587        });
8588        __bindgen_bitfield_unit
8589    }
8590}
8591pub type otNeighborInfoIterator = i16;
8592#[doc = " Represents the Thread Leader Data."]
8593#[repr(C)]
8594#[derive(Debug, Default, Copy, Clone)]
8595pub struct otLeaderData {
8596    #[doc = "< Partition ID"]
8597    pub mPartitionId: u32,
8598    #[doc = "< Leader Weight"]
8599    pub mWeighting: u8,
8600    #[doc = "< Full Network Data Version"]
8601    pub mDataVersion: u8,
8602    #[doc = "< Stable Network Data Version"]
8603    pub mStableDataVersion: u8,
8604    #[doc = "< Leader Router ID"]
8605    pub mLeaderRouterId: u8,
8606}
8607#[doc = " Holds diagnostic information for a Thread Router"]
8608#[repr(C)]
8609#[derive(Debug, Default, Copy, Clone)]
8610pub struct otRouterInfo {
8611    #[doc = "< IEEE 802.15.4 Extended Address"]
8612    pub mExtAddress: otExtAddress,
8613    #[doc = "< RLOC16"]
8614    pub mRloc16: u16,
8615    #[doc = "< Router ID"]
8616    pub mRouterId: u8,
8617    #[doc = "< Next hop to router"]
8618    pub mNextHop: u8,
8619    #[doc = "< Path cost to router"]
8620    pub mPathCost: u8,
8621    #[doc = "< Link Quality In"]
8622    pub mLinkQualityIn: u8,
8623    #[doc = "< Link Quality Out"]
8624    pub mLinkQualityOut: u8,
8625    #[doc = "< Time last heard"]
8626    pub mAge: u8,
8627    pub _bitfield_align_1: [u8; 0],
8628    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8629    #[doc = "< Thread version"]
8630    pub mVersion: u8,
8631    #[doc = "< CSL clock accuracy, in ± ppm"]
8632    pub mCslClockAccuracy: u8,
8633    #[doc = "< CSL uncertainty, in ±10 us"]
8634    pub mCslUncertainty: u8,
8635}
8636impl otRouterInfo {
8637    #[inline]
8638    pub fn mAllocated(&self) -> bool {
8639        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8640    }
8641    #[inline]
8642    pub fn set_mAllocated(&mut self, val: bool) {
8643        unsafe {
8644            let val: u8 = ::std::mem::transmute(val);
8645            self._bitfield_1.set(0usize, 1u8, val as u64)
8646        }
8647    }
8648    #[inline]
8649    pub fn mLinkEstablished(&self) -> bool {
8650        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8651    }
8652    #[inline]
8653    pub fn set_mLinkEstablished(&mut self, val: bool) {
8654        unsafe {
8655            let val: u8 = ::std::mem::transmute(val);
8656            self._bitfield_1.set(1usize, 1u8, val as u64)
8657        }
8658    }
8659    #[inline]
8660    pub fn new_bitfield_1(
8661        mAllocated: bool,
8662        mLinkEstablished: bool,
8663    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8664        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8665        __bindgen_bitfield_unit.set(0usize, 1u8, {
8666            let mAllocated: u8 = unsafe { ::std::mem::transmute(mAllocated) };
8667            mAllocated as u64
8668        });
8669        __bindgen_bitfield_unit.set(1usize, 1u8, {
8670            let mLinkEstablished: u8 = unsafe { ::std::mem::transmute(mLinkEstablished) };
8671            mLinkEstablished as u64
8672        });
8673        __bindgen_bitfield_unit
8674    }
8675}
8676#[doc = " Represents the IP level counters."]
8677#[repr(C)]
8678#[derive(Debug, Default, Copy, Clone)]
8679pub struct otIpCounters {
8680    #[doc = "< The number of IPv6 packets successfully transmitted."]
8681    pub mTxSuccess: u32,
8682    #[doc = "< The number of IPv6 packets successfully received."]
8683    pub mRxSuccess: u32,
8684    #[doc = "< The number of IPv6 packets failed to transmit."]
8685    pub mTxFailure: u32,
8686    #[doc = "< The number of IPv6 packets failed to receive."]
8687    pub mRxFailure: u32,
8688}
8689#[doc = " Represents the Thread MLE counters."]
8690#[repr(C)]
8691#[derive(Debug, Default, Copy, Clone)]
8692pub struct otMleCounters {
8693    #[doc = "< Number of times device entered OT_DEVICE_ROLE_DISABLED role."]
8694    pub mDisabledRole: u16,
8695    #[doc = "< Number of times device entered OT_DEVICE_ROLE_DETACHED role."]
8696    pub mDetachedRole: u16,
8697    #[doc = "< Number of times device entered OT_DEVICE_ROLE_CHILD role."]
8698    pub mChildRole: u16,
8699    #[doc = "< Number of times device entered OT_DEVICE_ROLE_ROUTER role."]
8700    pub mRouterRole: u16,
8701    #[doc = "< Number of times device entered OT_DEVICE_ROLE_LEADER role."]
8702    pub mLeaderRole: u16,
8703    #[doc = "< Number of attach attempts while device was detached."]
8704    pub mAttachAttempts: u16,
8705    #[doc = "< Number of changes to partition ID."]
8706    pub mPartitionIdChanges: u16,
8707    #[doc = "< Number of attempts to attach to a better partition."]
8708    pub mBetterPartitionAttachAttempts: u16,
8709    #[doc = "< Number of attempts to attach to find a better parent (parent search)."]
8710    pub mBetterParentAttachAttempts: u16,
8711    #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DISABLED role."]
8712    pub mDisabledTime: u64,
8713    #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DETACHED role."]
8714    pub mDetachedTime: u64,
8715    #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_CHILD role."]
8716    pub mChildTime: u64,
8717    #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_ROUTER role."]
8718    pub mRouterTime: u64,
8719    #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_LEADER role."]
8720    pub mLeaderTime: u64,
8721    #[doc = "< Number of milliseconds tracked by previous counters."]
8722    pub mTrackedTime: u64,
8723    #[doc = " Number of times device changed its parent.\n\n A parent change can happen if device detaches from its current parent and attaches to a different one, or even\n while device is attached when the periodic parent search feature is enabled  (please see option\n OPENTHREAD_CONFIG_PARENT_SEARCH_ENABLE)."]
8724    pub mParentChanges: u16,
8725}
8726#[doc = " Represents the MLE Parent Response data."]
8727#[repr(C)]
8728#[derive(Debug, Default, Copy, Clone)]
8729pub struct otThreadParentResponseInfo {
8730    #[doc = "< IEEE 802.15.4 Extended Address of the Parent"]
8731    pub mExtAddr: otExtAddress,
8732    #[doc = "< Short address of the Parent"]
8733    pub mRloc16: u16,
8734    #[doc = "< Rssi of the Parent"]
8735    pub mRssi: i8,
8736    #[doc = "< Parent priority"]
8737    pub mPriority: i8,
8738    #[doc = "< Parent Link Quality 3"]
8739    pub mLinkQuality3: u8,
8740    #[doc = "< Parent Link Quality 2"]
8741    pub mLinkQuality2: u8,
8742    #[doc = "< Parent Link Quality 1"]
8743    pub mLinkQuality1: u8,
8744    #[doc = "< Is the node receiving parent response attached"]
8745    pub mIsAttached: bool,
8746}
8747#[doc = " This callback informs the application that the detaching process has finished.\n\n @param[in] aContext A pointer to application-specific context."]
8748pub type otDetachGracefullyCallback =
8749    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
8750#[doc = " Informs the application about the result of waking a Wake-up End Device.\n\n @param[in] aError   OT_ERROR_NONE    Indicates that the Wake-up End Device has been added as a neighbor.\n                     OT_ERROR_FAILED  Indicates that the Wake-up End Device has not received a wake-up frame, or it\n                                      has failed the MLE procedure.\n @param[in] aContext A pointer to application-specific context."]
8751pub type otWakeupCallback = ::std::option::Option<
8752    unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
8753>;
8754extern "C" {
8755    #[doc = " Starts Thread protocol operation.\n\n The interface must be up when calling this function.\n\n Calling this function with @p aEnabled set to FALSE stops any ongoing processes of detaching started by\n otThreadDetachGracefully(). Its callback will be called.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled  TRUE if Thread is enabled, FALSE otherwise.\n\n @retval OT_ERROR_NONE           Successfully started Thread protocol operation.\n @retval OT_ERROR_INVALID_STATE  The network interface was not up."]
8756    pub fn otThreadSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
8757}
8758extern "C" {
8759    #[doc = " Gets the Thread protocol version.\n\n The constants `OT_THREAD_VERSION_*` define the numerical version values.\n\n @returns the Thread protocol version."]
8760    pub fn otThreadGetVersion() -> u16;
8761}
8762extern "C" {
8763    #[doc = " Indicates whether a node is the only router on the network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   It is the only router in the network.\n @retval FALSE  It is a child or is not a single router in the network."]
8764    pub fn otThreadIsSingleton(aInstance: *mut otInstance) -> bool;
8765}
8766extern "C" {
8767    #[doc = " Starts a Thread Discovery scan.\n\n @note A successful call to this function enables the rx-on-when-idle mode for the entire scan procedure.\n\n @param[in]  aInstance              A pointer to an OpenThread instance.\n @param[in]  aScanChannels          A bit vector indicating which channels to scan (e.g. OT_CHANNEL_11_MASK).\n @param[in]  aPanId                 The PAN ID filter (set to Broadcast PAN to disable filter).\n @param[in]  aJoiner                Value of the Joiner Flag in the Discovery Request TLV.\n @param[in]  aEnableEui64Filtering  TRUE to filter responses on EUI-64, FALSE otherwise.\n @param[in]  aCallback              A pointer to a function called on receiving an MLE Discovery Response or\n                                    scan completes.\n @param[in]  aCallbackContext       A pointer to application-specific context.\n\n @retval OT_ERROR_NONE           Successfully started a Thread Discovery Scan.\n @retval OT_ERROR_INVALID_STATE  The IPv6 interface is not enabled (netif is not up).\n @retval OT_ERROR_NO_BUFS        Could not allocate message for Discovery Request.\n @retval OT_ERROR_BUSY           Thread Discovery Scan is already in progress."]
8768    pub fn otThreadDiscover(
8769        aInstance: *mut otInstance,
8770        aScanChannels: u32,
8771        aPanId: u16,
8772        aJoiner: bool,
8773        aEnableEui64Filtering: bool,
8774        aCallback: otHandleActiveScanResult,
8775        aCallbackContext: *mut ::std::os::raw::c_void,
8776    ) -> otError;
8777}
8778extern "C" {
8779    #[doc = " Determines if an MLE Thread Discovery is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
8780    pub fn otThreadIsDiscoverInProgress(aInstance: *mut otInstance) -> bool;
8781}
8782extern "C" {
8783    #[doc = " Sets the Thread Joiner Advertisement when discovering Thread network.\n\n Thread Joiner Advertisement is used to allow a Joiner to advertise its own application-specific information\n (such as Vendor ID, Product ID, Discriminator, etc.) via a newly-proposed Joiner Advertisement TLV,\n and to make this information available to Commissioners or Commissioner Candidates without human interaction.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aOui             The Vendor IEEE OUI value that will be included in the Joiner Advertisement. Only the\n                              least significant 3 bytes will be used, and the most significant byte will be ignored.\n @param[in]  aAdvData         A pointer to the AdvData that will be included in the Joiner Advertisement.\n @param[in]  aAdvDataLength   The length of AdvData in bytes.\n\n @retval OT_ERROR_NONE         Successfully set Joiner Advertisement.\n @retval OT_ERROR_INVALID_ARGS Invalid AdvData."]
8784    pub fn otThreadSetJoinerAdvertisement(
8785        aInstance: *mut otInstance,
8786        aOui: u32,
8787        aAdvData: *const u8,
8788        aAdvDataLength: u8,
8789    ) -> otError;
8790}
8791extern "C" {
8792    #[doc = " Gets the Thread Child Timeout (in seconds) used when operating in the Child role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Child Timeout value in seconds.\n\n @sa otThreadSetChildTimeout"]
8793    pub fn otThreadGetChildTimeout(aInstance: *mut otInstance) -> u32;
8794}
8795extern "C" {
8796    #[doc = " Sets the Thread Child Timeout (in seconds) used when operating in the Child role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aTimeout  The timeout value in seconds.\n\n @sa otThreadGetChildTimeout"]
8797    pub fn otThreadSetChildTimeout(aInstance: *mut otInstance, aTimeout: u32);
8798}
8799extern "C" {
8800    #[doc = " Gets the IEEE 802.15.4 Extended PAN ID.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the IEEE 802.15.4 Extended PAN ID.\n\n @sa otThreadSetExtendedPanId"]
8801    pub fn otThreadGetExtendedPanId(aInstance: *mut otInstance) -> *const otExtendedPanId;
8802}
8803extern "C" {
8804    #[doc = " Sets the IEEE 802.15.4 Extended PAN ID.\n\n @note Can only be called while Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aExtendedPanId  A pointer to the IEEE 802.15.4 Extended PAN ID.\n\n @retval OT_ERROR_NONE           Successfully set the Extended PAN ID.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetExtendedPanId"]
8805    pub fn otThreadSetExtendedPanId(
8806        aInstance: *mut otInstance,
8807        aExtendedPanId: *const otExtendedPanId,
8808    ) -> otError;
8809}
8810extern "C" {
8811    #[doc = " Returns a pointer to the Leader's RLOC.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aLeaderRloc  A pointer to the Leader's RLOC.\n\n @retval OT_ERROR_NONE          The Leader's RLOC was successfully written to @p aLeaderRloc.\n @retval OT_ERROR_INVALID_ARGS  @p aLeaderRloc was NULL.\n @retval OT_ERROR_DETACHED      Not currently attached to a Thread Partition."]
8812    pub fn otThreadGetLeaderRloc(
8813        aInstance: *mut otInstance,
8814        aLeaderRloc: *mut otIp6Address,
8815    ) -> otError;
8816}
8817extern "C" {
8818    #[doc = " Get the MLE Link Mode configuration.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The MLE Link Mode configuration.\n\n @sa otThreadSetLinkMode"]
8819    pub fn otThreadGetLinkMode(aInstance: *mut otInstance) -> otLinkModeConfig;
8820}
8821extern "C" {
8822    #[doc = " Set the MLE Link Mode configuration.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aConfig   A pointer to the Link Mode configuration.\n\n @retval OT_ERROR_NONE  Successfully set the MLE Link Mode configuration.\n\n @sa otThreadGetLinkMode"]
8823    pub fn otThreadSetLinkMode(aInstance: *mut otInstance, aConfig: otLinkModeConfig) -> otError;
8824}
8825extern "C" {
8826    #[doc = " Get the Thread Network Key.\n\n @param[in]   aInstance     A pointer to an OpenThread instance.\n @param[out]  aNetworkKey   A pointer to an `otNetworkKey` to return the Thread Network Key.\n\n @sa otThreadSetNetworkKey"]
8827    pub fn otThreadGetNetworkKey(aInstance: *mut otInstance, aNetworkKey: *mut otNetworkKey);
8828}
8829extern "C" {
8830    #[doc = " Get the `otNetworkKeyRef` for Thread Network Key.\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n\n @returns Reference to the Thread Network Key stored in memory.\n\n @sa otThreadSetNetworkKeyRef"]
8831    pub fn otThreadGetNetworkKeyRef(aInstance: *mut otInstance) -> otNetworkKeyRef;
8832}
8833extern "C" {
8834    #[doc = " Set the Thread Network Key.\n\n Succeeds only when Thread protocols are disabled.  A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aKey        A pointer to a buffer containing the Thread Network Key.\n\n @retval OT_ERROR_NONE            Successfully set the Thread Network Key.\n @retval OT_ERROR_INVALID_STATE   Thread protocols are enabled.\n\n @sa otThreadGetNetworkKey"]
8835    pub fn otThreadSetNetworkKey(aInstance: *mut otInstance, aKey: *const otNetworkKey) -> otError;
8836}
8837extern "C" {
8838    #[doc = " Set the Thread Network Key as a `otNetworkKeyRef`.\n\n Succeeds only when Thread protocols are disabled.  A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aKeyRef     Reference to the Thread Network Key.\n\n @retval OT_ERROR_NONE            Successfully set the Thread Network Key.\n @retval OT_ERROR_INVALID_STATE   Thread protocols are enabled.\n\n @sa otThreadGetNetworkKeyRef"]
8839    pub fn otThreadSetNetworkKeyRef(
8840        aInstance: *mut otInstance,
8841        aKeyRef: otNetworkKeyRef,
8842    ) -> otError;
8843}
8844extern "C" {
8845    #[doc = " Gets the Thread Routing Locator (RLOC) address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Routing Locator (RLOC) address."]
8846    pub fn otThreadGetRloc(aInstance: *mut otInstance) -> *const otIp6Address;
8847}
8848extern "C" {
8849    #[doc = " Gets the Mesh Local EID address.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Mesh Local EID address."]
8850    pub fn otThreadGetMeshLocalEid(aInstance: *mut otInstance) -> *const otIp6Address;
8851}
8852extern "C" {
8853    #[doc = " Returns a pointer to the Mesh Local Prefix.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Mesh Local Prefix."]
8854    pub fn otThreadGetMeshLocalPrefix(aInstance: *mut otInstance) -> *const otMeshLocalPrefix;
8855}
8856extern "C" {
8857    #[doc = " Sets the Mesh Local Prefix.\n\n Succeeds only when Thread protocols are disabled.  A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aMeshLocalPrefix  A pointer to the Mesh Local Prefix.\n\n @retval OT_ERROR_NONE           Successfully set the Mesh Local Prefix.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
8858    pub fn otThreadSetMeshLocalPrefix(
8859        aInstance: *mut otInstance,
8860        aMeshLocalPrefix: *const otMeshLocalPrefix,
8861    ) -> otError;
8862}
8863extern "C" {
8864    #[doc = " Gets the Thread link-local IPv6 address.\n\n The Thread link local address is derived using IEEE802.15.4 Extended Address as Interface Identifier.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread link-local IPv6 address."]
8865    pub fn otThreadGetLinkLocalIp6Address(aInstance: *mut otInstance) -> *const otIp6Address;
8866}
8867extern "C" {
8868    #[doc = " Gets the Thread Link-Local All Thread Nodes multicast address.\n\n The address is a link-local Unicast Prefix-Based Multicast Address [RFC 3306], with:\n   - flgs set to 3 (P = 1 and T = 1)\n   - scop set to 2\n   - plen set to 64\n   - network prefix set to the Mesh Local Prefix\n   - group ID set to 1\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread Link-Local All Thread Nodes multicast address."]
8869    pub fn otThreadGetLinkLocalAllThreadNodesMulticastAddress(
8870        aInstance: *mut otInstance,
8871    ) -> *const otIp6Address;
8872}
8873extern "C" {
8874    #[doc = " Gets the Thread Realm-Local All Thread Nodes multicast address.\n\n The address is a realm-local Unicast Prefix-Based Multicast Address [RFC 3306], with:\n   - flgs set to 3 (P = 1 and T = 1)\n   - scop set to 3\n   - plen set to 64\n   - network prefix set to the Mesh Local Prefix\n   - group ID set to 1\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread Realm-Local All Thread Nodes multicast address."]
8875    pub fn otThreadGetRealmLocalAllThreadNodesMulticastAddress(
8876        aInstance: *mut otInstance,
8877    ) -> *const otIp6Address;
8878}
8879extern "C" {
8880    #[doc = " Retrieves the Service ALOC for given Service ID.\n\n @param[in]   aInstance     A pointer to an OpenThread instance.\n @param[in]   aServiceId    Service ID to get ALOC for.\n @param[out]  aServiceAloc  A pointer to output the Service ALOC. MUST NOT BE NULL.\n\n @retval OT_ERROR_NONE      Successfully retrieved the Service ALOC.\n @retval OT_ERROR_DETACHED  The Thread interface is not currently attached to a Thread Partition."]
8881    pub fn otThreadGetServiceAloc(
8882        aInstance: *mut otInstance,
8883        aServiceId: u8,
8884        aServiceAloc: *mut otIp6Address,
8885    ) -> otError;
8886}
8887extern "C" {
8888    #[doc = " Get the Thread Network Name.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Network Name.\n\n @sa otThreadSetNetworkName"]
8889    pub fn otThreadGetNetworkName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
8890}
8891extern "C" {
8892    #[doc = " Set the Thread Network Name.\n\n Succeeds only when Thread protocols are disabled.  A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aNetworkName  A pointer to the Thread Network Name.\n\n @retval OT_ERROR_NONE           Successfully set the Thread Network Name.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetNetworkName"]
8893    pub fn otThreadSetNetworkName(
8894        aInstance: *mut otInstance,
8895        aNetworkName: *const ::std::os::raw::c_char,
8896    ) -> otError;
8897}
8898extern "C" {
8899    #[doc = " Gets the Thread Domain Name.\n\n @note Available since Thread 1.2.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Domain Name.\n\n @sa otThreadSetDomainName"]
8900    pub fn otThreadGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
8901}
8902extern "C" {
8903    #[doc = " Sets the Thread Domain Name. Only succeeds when Thread protocols are disabled.\n\n @note Available since Thread 1.2.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aDomainName   A pointer to the Thread Domain Name.\n\n @retval OT_ERROR_NONE           Successfully set the Thread Domain Name.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetDomainName"]
8904    pub fn otThreadSetDomainName(
8905        aInstance: *mut otInstance,
8906        aDomainName: *const ::std::os::raw::c_char,
8907    ) -> otError;
8908}
8909extern "C" {
8910    #[doc = " Sets or clears the Interface Identifier manually specified for the Thread Domain Unicast Address.\n\n Available when `OPENTHREAD_CONFIG_DUA_ENABLE` is enabled.\n\n @note Only available since Thread 1.2.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aIid        A pointer to the Interface Identifier to set or NULL to clear.\n\n @retval OT_ERROR_NONE           Successfully set/cleared the Interface Identifier.\n @retval OT_ERROR_INVALID_ARGS   The specified Interface Identifier is reserved.\n\n @sa otThreadGetFixedDuaInterfaceIdentifier"]
8911    pub fn otThreadSetFixedDuaInterfaceIdentifier(
8912        aInstance: *mut otInstance,
8913        aIid: *const otIp6InterfaceIdentifier,
8914    ) -> otError;
8915}
8916extern "C" {
8917    #[doc = " Gets the Interface Identifier manually specified for the Thread Domain Unicast Address.\n\n Available when `OPENTHREAD_CONFIG_DUA_ENABLE` is enabled.\n\n @note Only available since Thread 1.2.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Interface Identifier which was set manually, or NULL if none was set.\n\n @sa otThreadSetFixedDuaInterfaceIdentifier"]
8918    pub fn otThreadGetFixedDuaInterfaceIdentifier(
8919        aInstance: *mut otInstance,
8920    ) -> *const otIp6InterfaceIdentifier;
8921}
8922extern "C" {
8923    #[doc = " Gets the thrKeySequenceCounter.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The thrKeySequenceCounter value.\n\n @sa otThreadSetKeySequenceCounter"]
8924    pub fn otThreadGetKeySequenceCounter(aInstance: *mut otInstance) -> u32;
8925}
8926extern "C" {
8927    #[doc = " Sets the thrKeySequenceCounter.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aKeySequenceCounter  The thrKeySequenceCounter value.\n\n @sa otThreadGetKeySequenceCounter"]
8928    pub fn otThreadSetKeySequenceCounter(aInstance: *mut otInstance, aKeySequenceCounter: u32);
8929}
8930extern "C" {
8931    #[doc = " Gets the thrKeySwitchGuardTime (in hours).\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The thrKeySwitchGuardTime value (in hours).\n\n @sa otThreadSetKeySwitchGuardTime"]
8932    pub fn otThreadGetKeySwitchGuardTime(aInstance: *mut otInstance) -> u16;
8933}
8934extern "C" {
8935    #[doc = " Sets the thrKeySwitchGuardTime (in hours).\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aKeySwitchGuardTime  The thrKeySwitchGuardTime value (in hours).\n\n @sa otThreadGetKeySwitchGuardTime"]
8936    pub fn otThreadSetKeySwitchGuardTime(aInstance: *mut otInstance, aKeySwitchGuardTime: u16);
8937}
8938extern "C" {
8939    #[doc = " Detach from the Thread network.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully detached from the Thread network.\n @retval OT_ERROR_INVALID_STATE  Thread is disabled."]
8940    pub fn otThreadBecomeDetached(aInstance: *mut otInstance) -> otError;
8941}
8942extern "C" {
8943    #[doc = " Attempt to reattach as a child.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully begin attempt to become a child.\n @retval OT_ERROR_INVALID_STATE  Thread is disabled."]
8944    pub fn otThreadBecomeChild(aInstance: *mut otInstance) -> otError;
8945}
8946extern "C" {
8947    #[doc = " Gets the next neighbor information. It is used to go through the entries of\n the neighbor table.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the iterator context. To get the first neighbor entry\nit should be set to OT_NEIGHBOR_INFO_ITERATOR_INIT.\n @param[out]     aInfo      A pointer to the neighbor information.\n\n @retval OT_ERROR_NONE         Successfully found the next neighbor entry in table.\n @retval OT_ERROR_NOT_FOUND     No subsequent neighbor entry exists in the table.\n @retval OT_ERROR_INVALID_ARGS  @p aIterator or @p aInfo was NULL."]
8948    pub fn otThreadGetNextNeighborInfo(
8949        aInstance: *mut otInstance,
8950        aIterator: *mut otNeighborInfoIterator,
8951        aInfo: *mut otNeighborInfo,
8952    ) -> otError;
8953}
8954extern "C" {
8955    #[doc = " Get the device role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_DEVICE_ROLE_DISABLED  The Thread stack is disabled.\n @retval OT_DEVICE_ROLE_DETACHED  The device is not currently participating in a Thread network/partition.\n @retval OT_DEVICE_ROLE_CHILD     The device is currently operating as a Thread Child.\n @retval OT_DEVICE_ROLE_ROUTER    The device is currently operating as a Thread Router.\n @retval OT_DEVICE_ROLE_LEADER    The device is currently operating as a Thread Leader."]
8956    pub fn otThreadGetDeviceRole(aInstance: *mut otInstance) -> otDeviceRole;
8957}
8958extern "C" {
8959    #[doc = " Convert the device role to human-readable string.\n\n @param[in] aRole   The device role to convert.\n\n @returns A string representing @p aRole."]
8960    pub fn otThreadDeviceRoleToString(aRole: otDeviceRole) -> *const ::std::os::raw::c_char;
8961}
8962extern "C" {
8963    #[doc = " Get the Thread Leader Data.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aLeaderData  A pointer to where the leader data is placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the leader data.\n @retval OT_ERROR_DETACHED      Not currently attached."]
8964    pub fn otThreadGetLeaderData(
8965        aInstance: *mut otInstance,
8966        aLeaderData: *mut otLeaderData,
8967    ) -> otError;
8968}
8969extern "C" {
8970    #[doc = " Get the Leader's Router ID.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Leader's Router ID."]
8971    pub fn otThreadGetLeaderRouterId(aInstance: *mut otInstance) -> u8;
8972}
8973extern "C" {
8974    #[doc = " Get the Leader's Weight.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Leader's Weight."]
8975    pub fn otThreadGetLeaderWeight(aInstance: *mut otInstance) -> u8;
8976}
8977extern "C" {
8978    #[doc = " Get the Partition ID.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Partition ID."]
8979    pub fn otThreadGetPartitionId(aInstance: *mut otInstance) -> u32;
8980}
8981extern "C" {
8982    #[doc = " Get the RLOC16.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The RLOC16."]
8983    pub fn otThreadGetRloc16(aInstance: *mut otInstance) -> u16;
8984}
8985extern "C" {
8986    #[doc = " The function retrieves diagnostic information for a Thread Router as parent.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aParentInfo  A pointer to where the parent router information is placed."]
8987    pub fn otThreadGetParentInfo(
8988        aInstance: *mut otInstance,
8989        aParentInfo: *mut otRouterInfo,
8990    ) -> otError;
8991}
8992extern "C" {
8993    #[doc = " The function retrieves the average RSSI for the Thread Parent.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aParentRssi  A pointer to where the parent RSSI should be placed."]
8994    pub fn otThreadGetParentAverageRssi(
8995        aInstance: *mut otInstance,
8996        aParentRssi: *mut i8,
8997    ) -> otError;
8998}
8999extern "C" {
9000    #[doc = " The function retrieves the RSSI of the last packet from the Thread Parent.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[out]  aLastRssi    A pointer to where the last RSSI should be placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the RSSI data.\n @retval OT_ERROR_FAILED        Unable to get RSSI data.\n @retval OT_ERROR_INVALID_ARGS  @p aLastRssi is NULL."]
9001    pub fn otThreadGetParentLastRssi(aInstance: *mut otInstance, aLastRssi: *mut i8) -> otError;
9002}
9003extern "C" {
9004    #[doc = " Starts the process for child to search for a better parent while staying attached to its current parent.\n\n Must be used when device is attached as a child.\n\n @retval OT_ERROR_NONE           Successfully started the process to search for a better parent.\n @retval OT_ERROR_INVALID_STATE  Device role is not child."]
9005    pub fn otThreadSearchForBetterParent(aInstance: *mut otInstance) -> otError;
9006}
9007extern "C" {
9008    #[doc = " Gets the IPv6 counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the IPv6 counters."]
9009    pub fn otThreadGetIp6Counters(aInstance: *mut otInstance) -> *const otIpCounters;
9010}
9011extern "C" {
9012    #[doc = " Resets the IPv6 counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
9013    pub fn otThreadResetIp6Counters(aInstance: *mut otInstance);
9014}
9015extern "C" {
9016    #[doc = " Gets the time-in-queue histogram for messages in the TX queue.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n Histogram of the time-in-queue of messages in the transmit queue is collected. The time-in-queue is tracked for\n direct transmissions only and is measured as the duration from when a message is added to the transmit queue until\n it is passed to the MAC layer for transmission or dropped.\n\n The histogram is returned as an array of `uint32_t` values with `aNumBins` entries. The first entry in the array\n (at index 0) represents the number of messages with a time-in-queue less than `aBinInterval`. The second entry\n represents the number of messages with a time-in-queue greater than or equal to `aBinInterval`, but less than\n `2 * aBinInterval`. And so on. The last entry represents the number of messages with time-in-queue  greater than or\n equal to `(aNumBins - 1) * aBinInterval`.\n\n The collected statistics can be reset by calling `otThreadResetTimeInQueueStat()`. The histogram information is\n collected since the OpenThread instance was initialized or since the last time statistics collection was reset by\n calling the `otThreadResetTimeInQueueStat()`.\n\n Pointers @p aNumBins and @p aBinInterval MUST NOT be NULL.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[out] aNumBins       Pointer to return the number of bins in histogram (array length).\n @param[out] aBinInterval   Pointer to return the histogram bin interval length in milliseconds.\n\n @returns A pointer to an array of @p aNumBins entries representing the collected histogram info."]
9017    pub fn otThreadGetTimeInQueueHistogram(
9018        aInstance: *mut otInstance,
9019        aNumBins: *mut u16,
9020        aBinInterval: *mut u32,
9021    ) -> *const u32;
9022}
9023extern "C" {
9024    #[doc = " Gets the maximum time-in-queue for messages in the TX queue.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n The time-in-queue is tracked for direct transmissions only and is measured as the duration from when a message is\n added to the transmit queue until it is passed to the MAC layer for transmission or dropped.\n\n The collected statistics can be reset by calling `otThreadResetTimeInQueueStat()`.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The maximum time-in-queue in milliseconds for all messages in the TX queue (so far)."]
9025    pub fn otThreadGetMaxTimeInQueue(aInstance: *mut otInstance) -> u32;
9026}
9027extern "C" {
9028    #[doc = " Resets the TX queue time-in-queue statistics.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n @param[in]  aInstance      A pointer to an OpenThread instance."]
9029    pub fn otThreadResetTimeInQueueStat(aInstance: *mut otInstance);
9030}
9031extern "C" {
9032    #[doc = " Gets the Thread MLE counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread MLE counters."]
9033    pub fn otThreadGetMleCounters(aInstance: *mut otInstance) -> *const otMleCounters;
9034}
9035extern "C" {
9036    #[doc = " Resets the Thread MLE counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
9037    pub fn otThreadResetMleCounters(aInstance: *mut otInstance);
9038}
9039extern "C" {
9040    #[doc = " Gets the current attach duration (number of seconds since the device last attached).\n\n Requires the `OPENTHREAD_CONFIG_UPTIME_ENABLE` feature.\n\n If the device is not currently attached, zero will be returned.\n\n Unlike the role-tracking variables in `otMleCounters`, which track the cumulative time the device is in each role,\n this function tracks the time since the last successful attachment, indicating how long the device has been\n connected to the Thread mesh (regardless of its role, whether acting as a child, router, or leader).\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @returns The number of seconds since last attached."]
9041    pub fn otThreadGetCurrentAttachDuration(aInstance: *mut otInstance) -> u32;
9042}
9043#[doc = " Pointer is called every time an MLE Parent Response message is received.\n\n This is used in `otThreadRegisterParentResponseCallback()`.\n\n @param[in]  aInfo     A pointer to a location on stack holding the stats data.\n @param[in]  aContext  A pointer to callback client-specific context."]
9044pub type otThreadParentResponseCallback = ::std::option::Option<
9045    unsafe extern "C" fn(
9046        aInfo: *mut otThreadParentResponseInfo,
9047        aContext: *mut ::std::os::raw::c_void,
9048    ),
9049>;
9050extern "C" {
9051    #[doc = " Registers a callback to receive MLE Parent Response data.\n\n Requires `OPENTHREAD_CONFIG_MLE_PARENT_RESPONSE_CALLBACK_API_ENABLE`.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aCallback  A pointer to a function that is called upon receiving an MLE Parent Response message.\n @param[in]  aContext   A pointer to callback client-specific context."]
9052    pub fn otThreadRegisterParentResponseCallback(
9053        aInstance: *mut otInstance,
9054        aCallback: otThreadParentResponseCallback,
9055        aContext: *mut ::std::os::raw::c_void,
9056    );
9057}
9058#[doc = " Represents the Thread Discovery Request data."]
9059#[repr(C)]
9060#[derive(Debug, Default, Copy, Clone)]
9061pub struct otThreadDiscoveryRequestInfo {
9062    #[doc = "< IEEE 802.15.4 Extended Address of the requester"]
9063    pub mExtAddress: otExtAddress,
9064    pub _bitfield_align_1: [u8; 0],
9065    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9066}
9067impl otThreadDiscoveryRequestInfo {
9068    #[inline]
9069    pub fn mVersion(&self) -> u8 {
9070        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
9071    }
9072    #[inline]
9073    pub fn set_mVersion(&mut self, val: u8) {
9074        unsafe {
9075            let val: u8 = ::std::mem::transmute(val);
9076            self._bitfield_1.set(0usize, 4u8, val as u64)
9077        }
9078    }
9079    #[inline]
9080    pub fn mIsJoiner(&self) -> bool {
9081        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
9082    }
9083    #[inline]
9084    pub fn set_mIsJoiner(&mut self, val: bool) {
9085        unsafe {
9086            let val: u8 = ::std::mem::transmute(val);
9087            self._bitfield_1.set(4usize, 1u8, val as u64)
9088        }
9089    }
9090    #[inline]
9091    pub fn new_bitfield_1(mVersion: u8, mIsJoiner: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9092        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9093        __bindgen_bitfield_unit.set(0usize, 4u8, {
9094            let mVersion: u8 = unsafe { ::std::mem::transmute(mVersion) };
9095            mVersion as u64
9096        });
9097        __bindgen_bitfield_unit.set(4usize, 1u8, {
9098            let mIsJoiner: u8 = unsafe { ::std::mem::transmute(mIsJoiner) };
9099            mIsJoiner as u64
9100        });
9101        __bindgen_bitfield_unit
9102    }
9103}
9104#[doc = " Pointer is called every time an MLE Discovery Request message is received.\n\n @param[in]  aInfo     A pointer to the Discovery Request info data.\n @param[in]  aContext  A pointer to callback application-specific context."]
9105pub type otThreadDiscoveryRequestCallback = ::std::option::Option<
9106    unsafe extern "C" fn(
9107        aInfo: *const otThreadDiscoveryRequestInfo,
9108        aContext: *mut ::std::os::raw::c_void,
9109    ),
9110>;
9111extern "C" {
9112    #[doc = " Sets a callback to receive MLE Discovery Request data.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aCallback  A pointer to a function that is called upon receiving an MLE Discovery Request message.\n @param[in]  aContext   A pointer to callback application-specific context."]
9113    pub fn otThreadSetDiscoveryRequestCallback(
9114        aInstance: *mut otInstance,
9115        aCallback: otThreadDiscoveryRequestCallback,
9116        aContext: *mut ::std::os::raw::c_void,
9117    );
9118}
9119#[doc = " Pointer type defines the callback to notify the outcome of a `otThreadLocateAnycastDestination()`\n request.\n\n @param[in] aContext            A pointer to an arbitrary context (provided when callback is registered).\n @param[in] aError              The error when handling the request. OT_ERROR_NONE indicates success.\n                                OT_ERROR_RESPONSE_TIMEOUT indicates a destination could not be found.\n                                OT_ERROR_ABORT indicates the request was aborted.\n @param[in] aMeshLocalAddress   A pointer to the mesh-local EID of the closest destination of the anycast address\n                                when @p aError is OT_ERROR_NONE, NULL otherwise.\n @param[in] aRloc16             The RLOC16 of the destination if found, otherwise invalid RLOC16 (0xfffe)."]
9120pub type otThreadAnycastLocatorCallback = ::std::option::Option<
9121    unsafe extern "C" fn(
9122        aContext: *mut ::std::os::raw::c_void,
9123        aError: otError,
9124        aMeshLocalAddress: *const otIp6Address,
9125        aRloc16: u16,
9126    ),
9127>;
9128extern "C" {
9129    #[doc = " Requests the closest destination of a given anycast address to be located.\n\n Is only available when `OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE` is enabled.\n\n If a previous request is ongoing, a subsequent call to this function will cancel and replace the earlier request.\n\n @param[in] aInstance         A pointer to an OpenThread instance.\n @param[in] aAnycastAddress   The anycast address to locate. MUST NOT be NULL.\n @param[in] aCallback         The callback function to report the result.\n @param[in] aContext          An arbitrary context used with @p aCallback.\n\n @retval OT_ERROR_NONE          The request started successfully. @p aCallback will be invoked to report the result.\n @retval OT_ERROR_INVALID_ARGS  The @p aAnycastAddress is not a valid anycast address or @p aCallback is NULL.\n @retval OT_ERROR_NO_BUFS       Out of buffer to prepare and send the request message."]
9130    pub fn otThreadLocateAnycastDestination(
9131        aInstance: *mut otInstance,
9132        aAnycastAddress: *const otIp6Address,
9133        aCallback: otThreadAnycastLocatorCallback,
9134        aContext: *mut ::std::os::raw::c_void,
9135    ) -> otError;
9136}
9137extern "C" {
9138    #[doc = " Indicates whether an anycast locate request is currently in progress.\n\n Is only available when `OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if an anycast locate request is currently in progress, FALSE otherwise."]
9139    pub fn otThreadIsAnycastLocateInProgress(aInstance: *mut otInstance) -> bool;
9140}
9141extern "C" {
9142    #[doc = " Sends a Proactive Address Notification (ADDR_NTF.ntf) message.\n\n Is only available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aDestination  The destination to send the ADDR_NTF.ntf message.\n @param[in]  aTarget       The target address of the ADDR_NTF.ntf message.\n @param[in]  aMlIid        The ML-IID of the ADDR_NTF.ntf message."]
9143    pub fn otThreadSendAddressNotification(
9144        aInstance: *mut otInstance,
9145        aDestination: *mut otIp6Address,
9146        aTarget: *mut otIp6Address,
9147        aMlIid: *mut otIp6InterfaceIdentifier,
9148    );
9149}
9150extern "C" {
9151    #[doc = " Sends a Proactive Backbone Notification (PRO_BB.ntf) message on the Backbone link.\n\n Is only available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in]  aInstance                    A pointer to an OpenThread instance.\n @param[in]  aTarget                      The target address of the PRO_BB.ntf message.\n @param[in]  aMlIid                       The ML-IID of the PRO_BB.ntf message.\n @param[in]  aTimeSinceLastTransaction    Time since last transaction (in seconds).\n\n @retval OT_ERROR_NONE           Successfully sent PRO_BB.ntf on backbone link.\n @retval OT_ERROR_NO_BUFS        If insufficient message buffers available."]
9152    pub fn otThreadSendProactiveBackboneNotification(
9153        aInstance: *mut otInstance,
9154        aTarget: *mut otIp6Address,
9155        aMlIid: *mut otIp6InterfaceIdentifier,
9156        aTimeSinceLastTransaction: u32,
9157    ) -> otError;
9158}
9159extern "C" {
9160    #[doc = " Notifies other nodes in the network (if any) and then stops Thread protocol operation.\n\n It sends an Address Release if it's a router, or sets its child timeout to 0 if it's a child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called upon finishing detaching.\n @param[in] aContext  A pointer to callback application-specific context.\n\n @retval OT_ERROR_NONE Successfully started detaching.\n @retval OT_ERROR_BUSY Detaching is already in progress."]
9161    pub fn otThreadDetachGracefully(
9162        aInstance: *mut otInstance,
9163        aCallback: otDetachGracefullyCallback,
9164        aContext: *mut ::std::os::raw::c_void,
9165    ) -> otError;
9166}
9167extern "C" {
9168    #[doc = " Converts an `uint32_t` duration (in seconds) to a human-readable string.\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The string follows the format \"<hh>:<mm>:<ss>\" for hours, minutes, seconds (if duration is shorter than one day) or\n \"<dd>d.<hh>:<mm>:<ss>\" (if longer than a day).\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n Is intended for use with `mAge` or `mConnectionTime` in `otNeighborInfo` or `otChildInfo` structures.\n\n @param[in]  aDuration A duration interval in seconds.\n @param[out] aBuffer   A pointer to a char array to output the string.\n @param[in]  aSize     The size of @p aBuffer (in bytes). Recommended to use `OT_DURATION_STRING_SIZE`."]
9169    pub fn otConvertDurationInSecondsToString(
9170        aDuration: u32,
9171        aBuffer: *mut ::std::os::raw::c_char,
9172        aSize: u16,
9173    );
9174}
9175extern "C" {
9176    #[doc = " Sets the store frame counter ahead.\n\n Requires `OPENTHREAD_CONFIG_DYNAMIC_STORE_FRAME_AHEAD_COUNTER_ENABLE` to be enabled.\n\n The OpenThread stack stores the MLE and MAC security frame counter values in non-volatile storage,\n ensuring they persist across device resets. These saved values are set to be ahead of their current\n values by the \"frame counter ahead\" value.\n\n @param[in] aInstance                  A pointer to an OpenThread instance.\n @param[in] aStoreFrameCounterAhead    The store frame counter ahead to set."]
9177    pub fn otThreadSetStoreFrameCounterAhead(
9178        aInstance: *mut otInstance,
9179        aStoreFrameCounterAhead: u32,
9180    );
9181}
9182extern "C" {
9183    #[doc = " Gets the store frame counter ahead.\n\n Requires `OPENTHREAD_CONFIG_DYNAMIC_STORE_FRAME_AHEAD_COUNTER_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current store frame counter ahead."]
9184    pub fn otThreadGetStoreFrameCounterAhead(aInstance: *mut otInstance) -> u32;
9185}
9186extern "C" {
9187    #[doc = " Attempts to wake a Wake-up End Device.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` to be enabled.\n\n The wake-up starts with transmitting a wake-up frame sequence to the Wake-up End Device.\n During the wake-up sequence, and for a short time after the last wake-up frame is sent, the Wake-up Coordinator keeps\n its receiver on to be able to receive an initial mesh link establishment message from the WED.\n\n @warning The functionality implemented by this function is still in the design phase.\n          Consequently, the prototype and semantics of this function are subject to change.\n\n @param[in] aInstance         A pointer to an OpenThread instance.\n @param[in] aWedAddress       The extended address of the Wake-up End Device.\n @param[in] aWakeupIntervalUs An interval between consecutive wake-up frames (in microseconds).\n @param[in] aWakeupDurationMs Duration of the wake-up sequence (in milliseconds).\n @param[in] aCallback         A pointer to function that is called when the wake-up succeeds or fails.\n @param[in] aCallbackContext  A pointer to callback application-specific context.\n\n @retval OT_ERROR_NONE          Successfully started the wake-up.\n @retval OT_ERROR_INVALID_STATE Another attachment request is still in progress.\n @retval OT_ERROR_INVALID_ARGS  The wake-up interval or duration are invalid."]
9188    pub fn otThreadWakeup(
9189        aInstance: *mut otInstance,
9190        aWedAddress: *const otExtAddress,
9191        aWakeupIntervalUs: u16,
9192        aWakeupDurationMs: u16,
9193        aCallback: otWakeupCallback,
9194        aCallbackContext: *mut ::std::os::raw::c_void,
9195    ) -> otError;
9196}
9197pub type otNetworkDiagIterator = u16;
9198#[doc = " Represents a Network Diagnostic Connectivity value."]
9199#[repr(C)]
9200#[derive(Debug, Default, Copy, Clone)]
9201pub struct otNetworkDiagConnectivity {
9202    #[doc = "< The priority of the sender as a parent."]
9203    pub mParentPriority: i8,
9204    #[doc = "< Number of neighbors with link of quality 3."]
9205    pub mLinkQuality3: u8,
9206    #[doc = "< Number of neighbors with link of quality 2."]
9207    pub mLinkQuality2: u8,
9208    #[doc = "< Number of neighbors with link of quality 1."]
9209    pub mLinkQuality1: u8,
9210    #[doc = "< Cost to the Leader."]
9211    pub mLeaderCost: u8,
9212    #[doc = "< Most recent received ID seq number."]
9213    pub mIdSequence: u8,
9214    #[doc = "< Number of active routers."]
9215    pub mActiveRouters: u8,
9216    #[doc = "< Buffer capacity in bytes for SEDs. Optional."]
9217    pub mSedBufferSize: u16,
9218    #[doc = "< Queue capacity (number of IPv6 datagrams) per SED. Optional."]
9219    pub mSedDatagramCount: u8,
9220}
9221#[doc = " Represents a Network Diagnostic Route data."]
9222#[repr(C)]
9223#[derive(Debug, Default, Copy, Clone)]
9224pub struct otNetworkDiagRouteData {
9225    #[doc = "< The Assigned Router ID."]
9226    pub mRouterId: u8,
9227    pub _bitfield_align_1: [u8; 0],
9228    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9229}
9230impl otNetworkDiagRouteData {
9231    #[inline]
9232    pub fn mLinkQualityOut(&self) -> u8 {
9233        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
9234    }
9235    #[inline]
9236    pub fn set_mLinkQualityOut(&mut self, val: u8) {
9237        unsafe {
9238            let val: u8 = ::std::mem::transmute(val);
9239            self._bitfield_1.set(0usize, 2u8, val as u64)
9240        }
9241    }
9242    #[inline]
9243    pub fn mLinkQualityIn(&self) -> u8 {
9244        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
9245    }
9246    #[inline]
9247    pub fn set_mLinkQualityIn(&mut self, val: u8) {
9248        unsafe {
9249            let val: u8 = ::std::mem::transmute(val);
9250            self._bitfield_1.set(2usize, 2u8, val as u64)
9251        }
9252    }
9253    #[inline]
9254    pub fn mRouteCost(&self) -> u8 {
9255        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
9256    }
9257    #[inline]
9258    pub fn set_mRouteCost(&mut self, val: u8) {
9259        unsafe {
9260            let val: u8 = ::std::mem::transmute(val);
9261            self._bitfield_1.set(4usize, 4u8, val as u64)
9262        }
9263    }
9264    #[inline]
9265    pub fn new_bitfield_1(
9266        mLinkQualityOut: u8,
9267        mLinkQualityIn: u8,
9268        mRouteCost: u8,
9269    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9270        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9271        __bindgen_bitfield_unit.set(0usize, 2u8, {
9272            let mLinkQualityOut: u8 = unsafe { ::std::mem::transmute(mLinkQualityOut) };
9273            mLinkQualityOut as u64
9274        });
9275        __bindgen_bitfield_unit.set(2usize, 2u8, {
9276            let mLinkQualityIn: u8 = unsafe { ::std::mem::transmute(mLinkQualityIn) };
9277            mLinkQualityIn as u64
9278        });
9279        __bindgen_bitfield_unit.set(4usize, 4u8, {
9280            let mRouteCost: u8 = unsafe { ::std::mem::transmute(mRouteCost) };
9281            mRouteCost as u64
9282        });
9283        __bindgen_bitfield_unit
9284    }
9285}
9286#[doc = " Represents a Network Diagnostic Route64 TLV value."]
9287#[repr(C)]
9288#[derive(Debug, Copy, Clone)]
9289pub struct otNetworkDiagRoute {
9290    #[doc = "< Sequence number for Router ID assignments."]
9291    pub mIdSequence: u8,
9292    #[doc = "< Number of routes."]
9293    pub mRouteCount: u8,
9294    #[doc = "< Link Quality and Routing Cost data."]
9295    pub mRouteData: [otNetworkDiagRouteData; 63usize],
9296}
9297impl Default for otNetworkDiagRoute {
9298    fn default() -> Self {
9299        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9300        unsafe {
9301            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9302            s.assume_init()
9303        }
9304    }
9305}
9306#[doc = " Represents a Network Diagnostic Mac Counters value.\n\n See <a href=\"https://www.ietf.org/rfc/rfc2863\">RFC 2863</a> for definitions of member fields."]
9307#[repr(C)]
9308#[derive(Debug, Default, Copy, Clone)]
9309pub struct otNetworkDiagMacCounters {
9310    pub mIfInUnknownProtos: u32,
9311    pub mIfInErrors: u32,
9312    pub mIfOutErrors: u32,
9313    pub mIfInUcastPkts: u32,
9314    pub mIfInBroadcastPkts: u32,
9315    pub mIfInDiscards: u32,
9316    pub mIfOutUcastPkts: u32,
9317    pub mIfOutBroadcastPkts: u32,
9318    pub mIfOutDiscards: u32,
9319}
9320#[doc = " Represents a Network Diagnostics MLE Counters value."]
9321#[repr(C)]
9322#[derive(Debug, Default, Copy, Clone)]
9323pub struct otNetworkDiagMleCounters {
9324    #[doc = "< Number of times device entered disabled role."]
9325    pub mDisabledRole: u16,
9326    #[doc = "< Number of times device entered detached role."]
9327    pub mDetachedRole: u16,
9328    #[doc = "< Number of times device entered child role."]
9329    pub mChildRole: u16,
9330    #[doc = "< Number of times device entered router role."]
9331    pub mRouterRole: u16,
9332    #[doc = "< Number of times device entered leader role."]
9333    pub mLeaderRole: u16,
9334    #[doc = "< Number of attach attempts while device was detached."]
9335    pub mAttachAttempts: u16,
9336    #[doc = "< Number of changes to partition ID."]
9337    pub mPartitionIdChanges: u16,
9338    #[doc = "< Number of attempts to attach to a better partition."]
9339    pub mBetterPartitionAttachAttempts: u16,
9340    #[doc = "< Number of time device changed its parent."]
9341    pub mParentChanges: u16,
9342    #[doc = "< Milliseconds tracked by next counters (zero if not supported)."]
9343    pub mTrackedTime: u64,
9344    #[doc = "< Milliseconds device has been in disabled role."]
9345    pub mDisabledTime: u64,
9346    #[doc = "< Milliseconds device has been in detached role."]
9347    pub mDetachedTime: u64,
9348    #[doc = "< Milliseconds device has been in child role."]
9349    pub mChildTime: u64,
9350    #[doc = "< Milliseconds device has been in router role."]
9351    pub mRouterTime: u64,
9352    #[doc = "< Milliseconds device has been in leader role."]
9353    pub mLeaderTime: u64,
9354}
9355#[doc = " Represents a Network Diagnostic Child Table Entry."]
9356#[repr(C)]
9357#[repr(align(2))]
9358#[derive(Debug, Default, Copy, Clone)]
9359pub struct otNetworkDiagChildEntry {
9360    pub _bitfield_align_1: [u16; 0],
9361    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
9362    #[doc = "< Link mode."]
9363    pub mMode: otLinkModeConfig,
9364}
9365impl otNetworkDiagChildEntry {
9366    #[inline]
9367    pub fn mTimeout(&self) -> u16 {
9368        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u16) }
9369    }
9370    #[inline]
9371    pub fn set_mTimeout(&mut self, val: u16) {
9372        unsafe {
9373            let val: u16 = ::std::mem::transmute(val);
9374            self._bitfield_1.set(0usize, 5u8, val as u64)
9375        }
9376    }
9377    #[inline]
9378    pub fn mLinkQuality(&self) -> u8 {
9379        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
9380    }
9381    #[inline]
9382    pub fn set_mLinkQuality(&mut self, val: u8) {
9383        unsafe {
9384            let val: u8 = ::std::mem::transmute(val);
9385            self._bitfield_1.set(5usize, 2u8, val as u64)
9386        }
9387    }
9388    #[inline]
9389    pub fn mChildId(&self) -> u16 {
9390        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u16) }
9391    }
9392    #[inline]
9393    pub fn set_mChildId(&mut self, val: u16) {
9394        unsafe {
9395            let val: u16 = ::std::mem::transmute(val);
9396            self._bitfield_1.set(7usize, 9u8, val as u64)
9397        }
9398    }
9399    #[inline]
9400    pub fn new_bitfield_1(
9401        mTimeout: u16,
9402        mLinkQuality: u8,
9403        mChildId: u16,
9404    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
9405        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
9406        __bindgen_bitfield_unit.set(0usize, 5u8, {
9407            let mTimeout: u16 = unsafe { ::std::mem::transmute(mTimeout) };
9408            mTimeout as u64
9409        });
9410        __bindgen_bitfield_unit.set(5usize, 2u8, {
9411            let mLinkQuality: u8 = unsafe { ::std::mem::transmute(mLinkQuality) };
9412            mLinkQuality as u64
9413        });
9414        __bindgen_bitfield_unit.set(7usize, 9u8, {
9415            let mChildId: u16 = unsafe { ::std::mem::transmute(mChildId) };
9416            mChildId as u64
9417        });
9418        __bindgen_bitfield_unit
9419    }
9420}
9421#[doc = " Represents a Network Diagnostic TLV."]
9422#[repr(C)]
9423#[derive(Copy, Clone)]
9424pub struct otNetworkDiagTlv {
9425    #[doc = "< The Network Diagnostic TLV type."]
9426    pub mType: u8,
9427    pub mData: otNetworkDiagTlv__bindgen_ty_1,
9428}
9429#[repr(C)]
9430#[derive(Copy, Clone)]
9431pub union otNetworkDiagTlv__bindgen_ty_1 {
9432    pub mExtAddress: otExtAddress,
9433    pub mEui64: otExtAddress,
9434    pub mAddr16: u16,
9435    pub mMode: otLinkModeConfig,
9436    pub mTimeout: u32,
9437    pub mConnectivity: otNetworkDiagConnectivity,
9438    pub mRoute: otNetworkDiagRoute,
9439    pub mLeaderData: otLeaderData,
9440    pub mMacCounters: otNetworkDiagMacCounters,
9441    pub mMleCounters: otNetworkDiagMleCounters,
9442    pub mBatteryLevel: u8,
9443    pub mSupplyVoltage: u16,
9444    pub mMaxChildTimeout: u32,
9445    pub mVersion: u16,
9446    pub mVendorName: [::std::os::raw::c_char; 33usize],
9447    pub mVendorModel: [::std::os::raw::c_char; 33usize],
9448    pub mVendorSwVersion: [::std::os::raw::c_char; 17usize],
9449    pub mThreadStackVersion: [::std::os::raw::c_char; 65usize],
9450    pub mVendorAppUrl: [::std::os::raw::c_char; 97usize],
9451    pub mNetworkData: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1,
9452    pub mIp6AddrList: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2,
9453    pub mChildTable: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3,
9454    pub mChannelPages: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4,
9455}
9456#[repr(C)]
9457#[derive(Debug, Copy, Clone)]
9458pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9459    pub mCount: u8,
9460    pub m8: [u8; 254usize],
9461}
9462impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9463    fn default() -> Self {
9464        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9465        unsafe {
9466            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9467            s.assume_init()
9468        }
9469    }
9470}
9471#[repr(C)]
9472#[derive(Copy, Clone)]
9473pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9474    pub mCount: u8,
9475    pub mList: [otIp6Address; 15usize],
9476}
9477impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9478    fn default() -> Self {
9479        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9480        unsafe {
9481            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9482            s.assume_init()
9483        }
9484    }
9485}
9486#[repr(C)]
9487#[derive(Debug, Copy, Clone)]
9488pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9489    pub mCount: u8,
9490    pub mTable: [otNetworkDiagChildEntry; 63usize],
9491}
9492impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9493    fn default() -> Self {
9494        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9495        unsafe {
9496            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9497            s.assume_init()
9498        }
9499    }
9500}
9501#[repr(C)]
9502#[derive(Debug, Copy, Clone)]
9503pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9504    pub mCount: u8,
9505    pub m8: [u8; 254usize],
9506}
9507impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9508    fn default() -> Self {
9509        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9510        unsafe {
9511            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9512            s.assume_init()
9513        }
9514    }
9515}
9516impl Default for otNetworkDiagTlv__bindgen_ty_1 {
9517    fn default() -> Self {
9518        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9519        unsafe {
9520            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9521            s.assume_init()
9522        }
9523    }
9524}
9525impl Default for otNetworkDiagTlv {
9526    fn default() -> Self {
9527        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9528        unsafe {
9529            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9530            s.assume_init()
9531        }
9532    }
9533}
9534extern "C" {
9535    #[doc = " Gets the next Network Diagnostic TLV in the message.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in]      aMessage         A pointer to a message.\n @param[in,out]  aIterator        A pointer to the Network Diagnostic iterator context. To get the first\n                                  Network Diagnostic TLV it should be set to OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT.\n @param[out]     aNetworkDiagTlv  A pointer to where the Network Diagnostic TLV information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next Network Diagnostic TLV.\n @retval OT_ERROR_NOT_FOUND  No subsequent Network Diagnostic TLV exists in the message.\n @retval OT_ERROR_PARSE      Parsing the next Network Diagnostic failed.\n\n @Note A subsequent call to this function is allowed only when current return value is OT_ERROR_NONE."]
9536    pub fn otThreadGetNextDiagnosticTlv(
9537        aMessage: *const otMessage,
9538        aIterator: *mut otNetworkDiagIterator,
9539        aNetworkDiagTlv: *mut otNetworkDiagTlv,
9540    ) -> otError;
9541}
9542#[doc = " Pointer is called when Network Diagnostic Get response is received.\n\n @param[in]  aError        The error when failed to get the response.\n @param[in]  aMessage      A pointer to the message buffer containing the received Network Diagnostic\n                           Get response payload. Available only when @p aError is `OT_ERROR_NONE`.\n @param[in]  aMessageInfo  A pointer to the message info for @p aMessage. Available only when\n                           @p aError is `OT_ERROR_NONE`.\n @param[in]  aContext      A pointer to application-specific context."]
9543pub type otReceiveDiagnosticGetCallback = ::std::option::Option<
9544    unsafe extern "C" fn(
9545        aError: otError,
9546        aMessage: *mut otMessage,
9547        aMessageInfo: *const otMessageInfo,
9548        aContext: *mut ::std::os::raw::c_void,
9549    ),
9550>;
9551extern "C" {
9552    #[doc = " Send a Network Diagnostic Get request.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aDestination      A pointer to destination address.\n @param[in]  aTlvTypes         An array of Network Diagnostic TLV types.\n @param[in]  aCount            Number of types in aTlvTypes.\n @param[in]  aCallback         A pointer to a function that is called when Network Diagnostic Get response\n                               is received or NULL to disable the callback.\n @param[in]  aCallbackContext  A pointer to application-specific context.\n\n @retval OT_ERROR_NONE    Successfully queued the DIAG_GET.req.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available to send DIAG_GET.req."]
9553    pub fn otThreadSendDiagnosticGet(
9554        aInstance: *mut otInstance,
9555        aDestination: *const otIp6Address,
9556        aTlvTypes: *const u8,
9557        aCount: u8,
9558        aCallback: otReceiveDiagnosticGetCallback,
9559        aCallbackContext: *mut ::std::os::raw::c_void,
9560    ) -> otError;
9561}
9562extern "C" {
9563    #[doc = " Send a Network Diagnostic Reset request.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aDestination   A pointer to destination address.\n @param[in]  aTlvTypes      An array of Network Diagnostic TLV types. Currently only Type 9 is allowed.\n @param[in]  aCount         Number of types in aTlvTypes\n\n @retval OT_ERROR_NONE    Successfully queued the DIAG_RST.ntf.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available to send DIAG_RST.ntf."]
9564    pub fn otThreadSendDiagnosticReset(
9565        aInstance: *mut otInstance,
9566        aDestination: *const otIp6Address,
9567        aTlvTypes: *const u8,
9568        aCount: u8,
9569    ) -> otError;
9570}
9571extern "C" {
9572    #[doc = " Get the vendor name string.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The vendor name string."]
9573    pub fn otThreadGetVendorName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9574}
9575extern "C" {
9576    #[doc = " Get the vendor model string.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The vendor model string."]
9577    pub fn otThreadGetVendorModel(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9578}
9579extern "C" {
9580    #[doc = " Get the vendor software version string.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The vendor software version string."]
9581    pub fn otThreadGetVendorSwVersion(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9582}
9583extern "C" {
9584    #[doc = " Get the vendor app URL string.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n\n @returns The vendor app URL string."]
9585    pub fn otThreadGetVendorAppUrl(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9586}
9587extern "C" {
9588    #[doc = " Set the vendor name string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorName should be UTF8 with max length of 32 chars (`MAX_VENDOR_NAME_TLV_LENGTH`). Maximum length does not\n include the null `\\0` character.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n @param[in] aVendorName     The vendor name string.\n\n @retval OT_ERROR_NONE          Successfully set the vendor name.\n @retval OT_ERROR_INVALID_ARGS  @p aVendorName is not valid (too long or not UTF8)."]
9589    pub fn otThreadSetVendorName(
9590        aInstance: *mut otInstance,
9591        aVendorName: *const ::std::os::raw::c_char,
9592    ) -> otError;
9593}
9594extern "C" {
9595    #[doc = " Set the vendor model string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorModel should be UTF8 with max length of 32 chars (`MAX_VENDOR_MODEL_TLV_LENGTH`). Maximum length does not\n include the null `\\0` character.\n\n @param[in] aInstance       A pointer to an OpenThread instance.\n @param[in] aVendorModel    The vendor model string.\n\n @retval OT_ERROR_NONE          Successfully set the vendor model.\n @retval OT_ERROR_INVALID_ARGS  @p aVendorModel is not valid (too long or not UTF8)."]
9596    pub fn otThreadSetVendorModel(
9597        aInstance: *mut otInstance,
9598        aVendorModel: *const ::std::os::raw::c_char,
9599    ) -> otError;
9600}
9601extern "C" {
9602    #[doc = " Set the vendor software version string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorSwVersion should be UTF8 with max length of 16 chars(`MAX_VENDOR_SW_VERSION_TLV_LENGTH`). Maximum length\n does not include the null `\\0` character.\n\n @param[in] aInstance          A pointer to an OpenThread instance.\n @param[in] aVendorSwVersion   The vendor software version string.\n\n @retval OT_ERROR_NONE          Successfully set the vendor software version.\n @retval OT_ERROR_INVALID_ARGS  @p aVendorSwVersion is not valid (too long or not UTF8)."]
9603    pub fn otThreadSetVendorSwVersion(
9604        aInstance: *mut otInstance,
9605        aVendorSwVersion: *const ::std::os::raw::c_char,
9606    ) -> otError;
9607}
9608extern "C" {
9609    #[doc = " Set the vendor app URL string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorAppUrl should be UTF8 with max length of 64 chars (`MAX_VENDOR_APPL_URL_TLV_LENGTH`). Maximum length\n does not include the null `\\0` character.\n\n @param[in] aInstance          A pointer to an OpenThread instance.\n @param[in] aVendorAppUrl      The vendor app URL string.\n\n @retval OT_ERROR_NONE          Successfully set the vendor app URL string.\n @retval OT_ERROR_INVALID_ARGS  @p aVendorAppUrl is not valid (too long or not UTF8)."]
9610    pub fn otThreadSetVendorAppUrl(
9611        aInstance: *mut otInstance,
9612        aVendorAppUrl: *const ::std::os::raw::c_char,
9613    ) -> otError;
9614}
9615#[doc = "< The device hasn't attached to a network."]
9616pub const OT_NETWORK_TIME_UNSYNCHRONIZED: otNetworkTimeStatus = -1;
9617#[doc = "< The device hasn’t received time sync for more than two periods time."]
9618pub const OT_NETWORK_TIME_RESYNC_NEEDED: otNetworkTimeStatus = 0;
9619#[doc = "< The device network time is synchronized."]
9620pub const OT_NETWORK_TIME_SYNCHRONIZED: otNetworkTimeStatus = 1;
9621#[doc = " Represents OpenThread time synchronization status."]
9622pub type otNetworkTimeStatus = ::std::os::raw::c_int;
9623#[doc = " Pointer is called when a network time sync or status change occurs."]
9624pub type otNetworkTimeSyncCallbackFn =
9625    ::std::option::Option<unsafe extern "C" fn(aCallbackContext: *mut ::std::os::raw::c_void)>;
9626extern "C" {
9627    #[doc = " Get the Thread network time.\n\n @param[in]     aInstance     The OpenThread instance structure.\n @param[in,out] aNetworkTime  The Thread network time in microseconds.\n\n @returns The time synchronization status."]
9628    pub fn otNetworkTimeGet(
9629        aInstance: *mut otInstance,
9630        aNetworkTime: *mut u64,
9631    ) -> otNetworkTimeStatus;
9632}
9633extern "C" {
9634    #[doc = " Set the time synchronization period.\n\n Can only be called while Thread protocols are disabled.\n\n @param[in] aInstance         The OpenThread instance structure.\n @param[in] aTimeSyncPeriod   The time synchronization period, in seconds.\n\n @retval OT_ERROR_NONE           Successfully set the time sync period.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
9635    pub fn otNetworkTimeSetSyncPeriod(aInstance: *mut otInstance, aTimeSyncPeriod: u16) -> otError;
9636}
9637extern "C" {
9638    #[doc = " Get the time synchronization period.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The time synchronization period."]
9639    pub fn otNetworkTimeGetSyncPeriod(aInstance: *mut otInstance) -> u16;
9640}
9641extern "C" {
9642    #[doc = " Set the time synchronization XTAL accuracy threshold for Router-Capable device.\n\n Can only be called while Thread protocols are disabled.\n\n @param[in] aInstance        The OpenThread instance structure.\n @param[in] aXTALThreshold   The XTAL accuracy threshold for Router, in PPM.\n\n @retval OT_ERROR_NONE           Successfully set the time sync period.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled."]
9643    pub fn otNetworkTimeSetXtalThreshold(
9644        aInstance: *mut otInstance,
9645        aXTALThreshold: u16,
9646    ) -> otError;
9647}
9648extern "C" {
9649    #[doc = " Get the time synchronization XTAL accuracy threshold for Router.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The XTAL accuracy threshold for Router, in PPM."]
9650    pub fn otNetworkTimeGetXtalThreshold(aInstance: *mut otInstance) -> u16;
9651}
9652extern "C" {
9653    #[doc = " Set a callback to be called when a network time sync or status change occurs\n\n This callback shall be called only when the network time offset jumps by\n OPENTHREAD_CONFIG_TIME_SYNC_JUMP_NOTIF_MIN_US or when the status changes.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCallbackFn The callback function to be called\n @param[in] aCallbackContext The context to be passed to the callback function upon invocation"]
9654    pub fn otNetworkTimeSyncSetCallback(
9655        aInstance: *mut otInstance,
9656        aCallbackFn: otNetworkTimeSyncCallbackFn,
9657        aCallbackContext: *mut ::std::os::raw::c_void,
9658    );
9659}
9660#[doc = " Represents a ping reply."]
9661#[repr(C)]
9662#[derive(Copy, Clone)]
9663pub struct otPingSenderReply {
9664    #[doc = "< Sender IPv6 address (address from which ping reply was received)."]
9665    pub mSenderAddress: otIp6Address,
9666    #[doc = "< Round trip time in msec."]
9667    pub mRoundTripTime: u16,
9668    #[doc = "< Data size (number of bytes) in reply (excluding IPv6 and ICMP6 headers)."]
9669    pub mSize: u16,
9670    #[doc = "< Sequence number."]
9671    pub mSequenceNumber: u16,
9672    #[doc = "< Hop limit."]
9673    pub mHopLimit: u8,
9674}
9675impl Default for otPingSenderReply {
9676    fn default() -> Self {
9677        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9678        unsafe {
9679            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9680            s.assume_init()
9681        }
9682    }
9683}
9684#[doc = " Represents statistics of a ping request."]
9685#[repr(C)]
9686#[derive(Debug, Default, Copy, Clone)]
9687pub struct otPingSenderStatistics {
9688    #[doc = "< The number of ping requests already sent."]
9689    pub mSentCount: u16,
9690    #[doc = "< The number of ping replies received."]
9691    pub mReceivedCount: u16,
9692    #[doc = "< The total round trip time of ping requests."]
9693    pub mTotalRoundTripTime: u32,
9694    #[doc = "< The min round trip time among ping requests."]
9695    pub mMinRoundTripTime: u16,
9696    #[doc = "< The max round trip time among ping requests."]
9697    pub mMaxRoundTripTime: u16,
9698    #[doc = "< Whether this is a multicast ping request."]
9699    pub mIsMulticast: bool,
9700}
9701#[doc = " Pointer type specifies the callback to notify receipt of a ping reply.\n\n @param[in] aReply      A pointer to a `otPingSenderReply` containing info about the received ping reply.\n @param[in] aContext    A pointer to application-specific context."]
9702pub type otPingSenderReplyCallback = ::std::option::Option<
9703    unsafe extern "C" fn(aReply: *const otPingSenderReply, aContext: *mut ::std::os::raw::c_void),
9704>;
9705#[doc = " Pointer type specifies the callback to report the ping statistics.\n\n @param[in] aStatistics      A pointer to a `otPingSenderStatistics` containing info about the received ping\n                             statistics.\n @param[in] aContext         A pointer to application-specific context."]
9706pub type otPingSenderStatisticsCallback = ::std::option::Option<
9707    unsafe extern "C" fn(
9708        aStatistics: *const otPingSenderStatistics,
9709        aContext: *mut ::std::os::raw::c_void,
9710    ),
9711>;
9712#[doc = " Represents a ping request configuration."]
9713#[repr(C)]
9714#[derive(Copy, Clone)]
9715pub struct otPingSenderConfig {
9716    #[doc = "< Source address of the ping."]
9717    pub mSource: otIp6Address,
9718    #[doc = "< Destination address to ping."]
9719    pub mDestination: otIp6Address,
9720    #[doc = "< Callback function to report replies (can be NULL if not needed)."]
9721    pub mReplyCallback: otPingSenderReplyCallback,
9722    #[doc = "< Callback function to report statistics (can be NULL if not needed)."]
9723    pub mStatisticsCallback: otPingSenderStatisticsCallback,
9724    #[doc = "< A pointer to the callback application-specific context."]
9725    pub mCallbackContext: *mut ::std::os::raw::c_void,
9726    #[doc = "< Data size (# of bytes) excludes IPv6/ICMPv6 header. Zero for default."]
9727    pub mSize: u16,
9728    #[doc = "< Number of ping messages to send. Zero to use default."]
9729    pub mCount: u16,
9730    #[doc = "< Ping tx interval in milliseconds. Zero to use default."]
9731    pub mInterval: u32,
9732    #[doc = "< Time in milliseconds to wait for final reply after sending final request.\n< Zero to use default."]
9733    pub mTimeout: u16,
9734    #[doc = "< Hop limit (used if `mAllowZeroHopLimit` is false). Zero for default."]
9735    pub mHopLimit: u8,
9736    #[doc = "< Indicates whether hop limit is zero."]
9737    pub mAllowZeroHopLimit: bool,
9738    #[doc = "< Allow looping back pings to multicast address that device is subscribed to."]
9739    pub mMulticastLoop: bool,
9740}
9741impl Default for otPingSenderConfig {
9742    fn default() -> Self {
9743        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9744        unsafe {
9745            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9746            s.assume_init()
9747        }
9748    }
9749}
9750extern "C" {
9751    #[doc = " Starts a ping.\n\n @param[in] aInstance            A pointer to an OpenThread instance.\n @param[in] aConfig              The ping config to use.\n\n @retval OT_ERROR_NONE           The ping started successfully.\n @retval OT_ERROR_BUSY           Could not start since busy with a previous ongoing ping request.\n @retval OT_ERROR_INVALID_ARGS   The @p aConfig contains invalid parameters (e.g., ping interval is too long).\n"]
9752    pub fn otPingSenderPing(
9753        aInstance: *mut otInstance,
9754        aConfig: *const otPingSenderConfig,
9755    ) -> otError;
9756}
9757extern "C" {
9758    #[doc = " Stops an ongoing ping.\n\n @param[in] aInstance            A pointer to an OpenThread instance."]
9759    pub fn otPingSenderStop(aInstance: *mut otInstance);
9760}
9761extern "C" {
9762    #[doc = " Set the alarm to fire at @p aDt microseconds after @p aT0.\n\n For @p aT0, the platform MUST support all values in [0, 2^32-1].\n For @p aDt, the platform MUST support all values in [0, 2^31-1].\n\n @param[in]  aInstance  The OpenThread instance structure.\n @param[in]  aT0        The reference time.\n @param[in]  aDt        The time delay in microseconds from @p aT0."]
9763    pub fn otPlatAlarmMicroStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
9764}
9765extern "C" {
9766    #[doc = " Stop the alarm.\n\n @param[in] aInstance  The OpenThread instance structure."]
9767    pub fn otPlatAlarmMicroStop(aInstance: *mut otInstance);
9768}
9769extern "C" {
9770    #[doc = " Get the current time.\n\n The current time MUST represent a free-running timer. When maintaining current time, the time value MUST utilize the\n entire range [0, 2^32-1] and MUST NOT wrap before 2^32.\n\n @returns  The current time in microseconds."]
9771    pub fn otPlatAlarmMicroGetNow() -> u32;
9772}
9773extern "C" {
9774    #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance  The OpenThread instance structure."]
9775    pub fn otPlatAlarmMicroFired(aInstance: *mut otInstance);
9776}
9777extern "C" {
9778    #[doc = " Set the alarm to fire at @p aDt milliseconds after @p aT0.\n\n For @p aT0 the platform MUST support all values in [0, 2^32-1].\n For @p aDt, the platform MUST support all values in [0, 2^31-1].\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aT0        The reference time.\n @param[in] aDt        The time delay in milliseconds from @p aT0."]
9779    pub fn otPlatAlarmMilliStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
9780}
9781extern "C" {
9782    #[doc = " Stop the alarm.\n\n @param[in] aInstance  The OpenThread instance structure."]
9783    pub fn otPlatAlarmMilliStop(aInstance: *mut otInstance);
9784}
9785extern "C" {
9786    #[doc = " Get the current time.\n\n The current time MUST represent a free-running timer. When maintaining current time, the time value MUST utilize the\n entire range [0, 2^32-1] and MUST NOT wrap before 2^32.\n\n @returns The current time in milliseconds."]
9787    pub fn otPlatAlarmMilliGetNow() -> u32;
9788}
9789extern "C" {
9790    #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance  The OpenThread instance structure."]
9791    pub fn otPlatAlarmMilliFired(aInstance: *mut otInstance);
9792}
9793extern "C" {
9794    #[doc = " Signal diagnostics module that the alarm has fired.\n\n @param[in] aInstance  The OpenThread instance structure."]
9795    pub fn otPlatDiagAlarmFired(aInstance: *mut otInstance);
9796}
9797extern "C" {
9798    #[doc = " Handles ICMP6 RA messages received on the Thread interface on the platform.\n\n The `aMessage` should point to a buffer of a valid ICMPv6 message (without IP headers) with router advertisement as\n the value of type field of the message.\n\n When DHCPv6 PD is disabled, the message will be dropped silently.\n\n Note: RA messages will not be forwarded into Thread networks, while for many platforms, RA messages is the way of\n distributing a prefix and other infomations to the downstream network. The typical usecase of this function is to\n handle the router advertisement messages sent by the platform as a result of DHCPv6 Prefix Delegation.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage  A pointer to an ICMPv6 RouterAdvertisement message.\n @param[in] aLength   The length of ICMPv6 RouterAdvertisement message."]
9799    pub fn otPlatBorderRoutingProcessIcmp6Ra(
9800        aInstance: *mut otInstance,
9801        aMessage: *const u8,
9802        aLength: u16,
9803    );
9804}
9805extern "C" {
9806    #[doc = " Process a prefix received from the DHCPv6 PD Server. The prefix is received on\n the DHCPv6 PD client callback and provided to the Routing Manager via this\n API.\n\n The prefix lifetime can be updated by calling the function again with updated time values.\n If the preferred lifetime of the prefix is set to 0, the prefix becomes deprecated.\n When this function is called multiple times, the smallest prefix is preferred as this rule allows\n choosing a GUA instead of a ULA.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE`.\n\n @param[in] aInstance   A pointer to an OpenThread instance.\n @param[in] aPrefixInfo A pointer to the prefix information structure"]
9807    pub fn otPlatBorderRoutingProcessDhcp6PdPrefix(
9808        aInstance: *mut otInstance,
9809        aPrefixInfo: *const otBorderRoutingPrefixTableEntry,
9810    );
9811}
9812extern "C" {
9813    #[doc = " Standard printf() to the debug uart with no log decoration.\n\n @param[in]   fmt   printf formatter text\n\n This is a debug convenience function that is not intended to be\n used in anything other then \"debug scenarios\" by a developer.\n\n lf -> cr/lf mapping is automatically handled via otPlatDebugUart_putchar()\n\n @sa otPlatDebugUart_vprintf() for limitations\n\n This is a WEAK symbol that can easily be overridden as needed."]
9814    pub fn otPlatDebugUart_printf(fmt: *const ::std::os::raw::c_char, ...);
9815}
9816extern "C" {
9817    #[doc = " Standard vprintf() to the debug uart, with no log decoration.\n\n @param[in]   fmt   printf formatter text\n @param[in]   ap    va_list value for print parameters.\n\n Implementation limitation: this formats the text into\n a purposely small text buffer on the stack, thus long\n messages may be truncated.\n\n This is a WEAK symbol that can easily be overridden as needed.\n\n For example, some platforms might override this via a non-WEAK\n symbol because the platform provides a UART_vprintf() like\n function that can handle an arbitrary length output."]
9818    pub fn otPlatDebugUart_vprintf(fmt: *const ::std::os::raw::c_char, ap: *mut __va_list_tag);
9819}
9820extern "C" {
9821    #[doc = " Platform specific write single byte to Debug Uart\n This should not perform CR/LF mapping.\n\n MUST be implemented by the platform\n\n @param[in] c   what to transmit"]
9822    pub fn otPlatDebugUart_putchar_raw(c: ::std::os::raw::c_int);
9823}
9824extern "C" {
9825    #[doc = " Poll/test debug uart if a key has been pressed.\n It would be common to a stub function that returns 0.\n\n MUST be implemented by the platform\n\n @retval zero - nothing ready\n @retval nonzero - otPlatDebugUart_getc() will succeed."]
9826    pub fn otPlatDebugUart_kbhit() -> ::std::os::raw::c_int;
9827}
9828extern "C" {
9829    #[doc = " Poll/Read a byte from the debug uart\n\n MUST be implemented by the platform\n\n @retval (negative) no data available, see otPlatDebugUart_kbhit()\n @retval (0x00..0x0ff) data byte value"]
9830    pub fn otPlatDebugUart_getc() -> ::std::os::raw::c_int;
9831}
9832extern "C" {
9833    #[doc = " Write byte to the uart, expand cr/lf as need.\n\n A WEAK default implementation is provided\n that can be overridden as needed.\n\n @param[in] c   the byte to transmit"]
9834    pub fn otPlatDebugUart_putchar(c: ::std::os::raw::c_int);
9835}
9836extern "C" {
9837    #[doc = " identical to \"man 3 puts\" - terminates with lf\n Which is then mapped to cr/lf as required\n\n A WEAK default implementation is provided\n that can be overridden as needed.\n\n @param[in]   s   the string to print with a lf at the end"]
9838    pub fn otPlatDebugUart_puts(s: *const ::std::os::raw::c_char);
9839}
9840extern "C" {
9841    #[doc = " Write N bytes to the UART, mapping cr/lf\n\n @param[in]  pBytes   pointer to bytes to transmit.\n @param[in]  nBytes   how many bytes to transmit."]
9842    pub fn otPlatDebugUart_write_bytes(pBytes: *const u8, nBytes: ::std::os::raw::c_int);
9843}
9844extern "C" {
9845    #[doc = " puts() without a terminal newline.\n see: \"man 3 puts\", without a adding a terminal lf\n\n @param[in]  s       the string to print without a lf at the end\n\n Note, the terminal \"lf\" mapped to cr/lf via\n the function otPlatDebugUart_putchar()"]
9846    pub fn otPlatDebugUart_puts_no_nl(s: *const ::std::os::raw::c_char);
9847}
9848extern "C" {
9849    #[doc = " Some platforms (simulation) can log to a file.\n\n @returns OT_ERROR_NONE\n @returns OT_ERROR_FAILED\n\n Platforms that desire this MUST provide an implementation."]
9850    pub fn otPlatDebugUart_logfile(filename: *const ::std::os::raw::c_char) -> otError;
9851}
9852#[repr(C)]
9853#[derive(Debug, Copy, Clone)]
9854pub struct otPlatDnsUpstreamQuery {
9855    _unused: [u8; 0],
9856}
9857extern "C" {
9858    #[doc = " Starts an upstream query transaction.\n\n - In success case (and errors represented by DNS protocol messages), the platform is expected to call\n   `otPlatDnsUpstreamQueryDone`.\n - The OpenThread core may cancel a (possibly timeout) query transaction by calling\n   `otPlatDnsCancelUpstreamQuery`, the platform must not call `otPlatDnsUpstreamQueryDone` on a\n   cancelled transaction.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aTxn       A pointer to the opaque DNS query transaction object.\n @param[in] aQuery     A message buffer of the DNS payload that should be sent to upstream DNS server."]
9859    pub fn otPlatDnsStartUpstreamQuery(
9860        aInstance: *mut otInstance,
9861        aTxn: *mut otPlatDnsUpstreamQuery,
9862        aQuery: *const otMessage,
9863    );
9864}
9865extern "C" {
9866    #[doc = " Cancels a transaction of upstream query.\n\n The platform must call `otPlatDnsUpstreamQueryDone` to release the resources.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aTxn       A pointer to the opaque DNS query transaction object."]
9867    pub fn otPlatDnsCancelUpstreamQuery(
9868        aInstance: *mut otInstance,
9869        aTxn: *mut otPlatDnsUpstreamQuery,
9870    );
9871}
9872extern "C" {
9873    #[doc = " The platform calls this function to finish DNS query.\n\n The transaction will be released, so the platform must not call on the same transaction twice. This function passes\n the ownership of `aResponse` to OpenThread stack.\n\n Platform can pass a nullptr to close a transaction without a response.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aTxn       A pointer to the opaque DNS query transaction object.\n @param[in] aResponse  A message buffer of the DNS response payload or `nullptr` to close a transaction without a\n                       response."]
9874    pub fn otPlatDnsUpstreamQueryDone(
9875        aInstance: *mut otInstance,
9876        aTxn: *mut otPlatDnsUpstreamQuery,
9877        aResponse: *mut otMessage,
9878    );
9879}
9880extern "C" {
9881    #[doc = " Fill buffer with entropy.\n\n MUST be implemented using a true random number generator (TRNG).\n\n @param[out]  aOutput              A pointer to where the true random values are placed.  Must not be NULL.\n @param[in]   aOutputLength        Size of @p aBuffer.\n\n @retval OT_ERROR_NONE          Successfully filled @p aBuffer with true random values.\n @retval OT_ERROR_FAILED        Failed to fill @p aBuffer with true random values.\n @retval OT_ERROR_INVALID_ARGS  @p aBuffer was set to NULL."]
9882    pub fn otPlatEntropyGet(aOutput: *mut u8, aOutputLength: u16) -> otError;
9883}
9884extern "C" {
9885    #[doc = " Initializes the flash driver.\n\n @param[in] aInstance  The OpenThread instance structure."]
9886    pub fn otPlatFlashInit(aInstance: *mut otInstance);
9887}
9888extern "C" {
9889    #[doc = " Gets the size of the swap space.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @returns The size of the swap space in bytes."]
9890    pub fn otPlatFlashGetSwapSize(aInstance: *mut otInstance) -> u32;
9891}
9892extern "C" {
9893    #[doc = " Erases the swap space indicated by @p aSwapIndex.\n\n @param[in] aInstance   The OpenThread instance structure.\n @param[in] aSwapIndex  A value in [0, 1] that indicates the swap space."]
9894    pub fn otPlatFlashErase(aInstance: *mut otInstance, aSwapIndex: u8);
9895}
9896extern "C" {
9897    #[doc = " Reads @p aSize bytes into @p aData.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aSwapIndex  A value in [0, 1] that indicates the swap space.\n @param[in]  aOffset     A byte offset within the swap space.\n @param[out] aData       A pointer to the data buffer for reading.\n @param[in]  aSize       Number of bytes to read."]
9898    pub fn otPlatFlashRead(
9899        aInstance: *mut otInstance,
9900        aSwapIndex: u8,
9901        aOffset: u32,
9902        aData: *mut ::std::os::raw::c_void,
9903        aSize: u32,
9904    );
9905}
9906extern "C" {
9907    #[doc = " Writes @p aSize bytes from @p aData.\n\n @param[in]  aInstance   The OpenThread instance structure.\n @param[in]  aSwapIndex  A value in [0, 1] that indicates the swap space.\n @param[in]  aOffset     A byte offset within the swap space.\n @param[out] aData       A pointer to the data to write.\n @param[in]  aSize       Number of bytes to write."]
9908    pub fn otPlatFlashWrite(
9909        aInstance: *mut otInstance,
9910        aSwapIndex: u8,
9911        aOffset: u32,
9912        aData: *const ::std::os::raw::c_void,
9913        aSize: u32,
9914    );
9915}
9916#[doc = " Represents an InfraIf Link-Layer Address."]
9917#[repr(C)]
9918#[derive(Debug, Default, Copy, Clone)]
9919pub struct otPlatInfraIfLinkLayerAddress {
9920    #[doc = "< The link-layer address bytes."]
9921    pub mAddress: [u8; 16usize],
9922    #[doc = "< The address length (number of bytes)."]
9923    pub mLength: u8,
9924}
9925extern "C" {
9926    #[doc = " Tells whether an infra interface has the given IPv6 address assigned.\n\n @param[in]  aInfraIfIndex  The index of the infra interface.\n @param[in]  aAddress       The IPv6 address.\n\n @returns  TRUE if the infra interface has given IPv6 address assigned, FALSE otherwise."]
9927    pub fn otPlatInfraIfHasAddress(aInfraIfIndex: u32, aAddress: *const otIp6Address) -> bool;
9928}
9929extern "C" {
9930    #[doc = " Sends an ICMPv6 Neighbor Discovery message on given infrastructure interface.\n\n See RFC 4861: https://tools.ietf.org/html/rfc4861.\n\n @param[in]  aInfraIfIndex  The index of the infrastructure interface this message is sent to.\n @param[in]  aDestAddress   The destination address this message is sent to.\n @param[in]  aBuffer        The ICMPv6 message buffer. The ICMPv6 checksum is left zero and the\n                            platform should do the checksum calculate.\n @param[in]  aBufferLength  The length of the message buffer.\n\n @note  Per RFC 4861, the implementation should send the message with IPv6 link-local source address\n        of interface @p aInfraIfIndex and IP Hop Limit 255.\n\n @retval OT_ERROR_NONE    Successfully sent the ICMPv6 message.\n @retval OT_ERROR_FAILED  Failed to send the ICMPv6 message."]
9931    pub fn otPlatInfraIfSendIcmp6Nd(
9932        aInfraIfIndex: u32,
9933        aDestAddress: *const otIp6Address,
9934        aBuffer: *const u8,
9935        aBufferLength: u16,
9936    ) -> otError;
9937}
9938extern "C" {
9939    #[doc = " The infra interface driver calls this method to notify OpenThread\n that an ICMPv6 Neighbor Discovery message is received.\n\n See RFC 4861: https://tools.ietf.org/html/rfc4861.\n\n @param[in]  aInstance      The OpenThread instance structure.\n @param[in]  aInfraIfIndex  The index of the infrastructure interface on which the ICMPv6 message is received.\n @param[in]  aSrcAddress    The source address this message is received from.\n @param[in]  aBuffer        The ICMPv6 message buffer.\n @param[in]  aBufferLength  The length of the ICMPv6 message buffer.\n\n @note  Per RFC 4861, the caller should enforce that the source address MUST be a IPv6 link-local\n        address and the IP Hop Limit MUST be 255."]
9940    pub fn otPlatInfraIfRecvIcmp6Nd(
9941        aInstance: *mut otInstance,
9942        aInfraIfIndex: u32,
9943        aSrcAddress: *const otIp6Address,
9944        aBuffer: *const u8,
9945        aBufferLength: u16,
9946    );
9947}
9948extern "C" {
9949    #[doc = " The infra interface driver calls this method to notify OpenThread\n of the interface state changes.\n\n It is fine for the platform to call to method even when the running state\n of the interface hasn't changed. In this case, the Routing Manager state is\n not affected.\n\n @param[in]  aInstance          The OpenThread instance structure.\n @param[in]  aInfraIfIndex      The index of the infrastructure interface.\n @param[in]  aIsRunning         A boolean that indicates whether the infrastructure\n                                interface is running.\n\n @retval  OT_ERROR_NONE           Successfully updated the infra interface status.\n @retval  OT_ERROR_INVALID_STATE  The Routing Manager is not initialized.\n @retval  OT_ERROR_INVALID_ARGS   The @p aInfraIfIndex doesn't match the infra interface the\n                                  Routing Manager are initialized with."]
9950    pub fn otPlatInfraIfStateChanged(
9951        aInstance: *mut otInstance,
9952        aInfraIfIndex: u32,
9953        aIsRunning: bool,
9954    ) -> otError;
9955}
9956extern "C" {
9957    #[doc = " Send a request to discover the NAT64 prefix on the infrastructure interface with @p aInfraIfIndex.\n\n OpenThread will call this method periodically to monitor the presence or change of NAT64 prefix.\n\n @param[in]  aInfraIfIndex  The index of the infrastructure interface to discover the NAT64 prefix.\n\n @retval  OT_ERROR_NONE    Successfully request NAT64 prefix discovery.\n @retval  OT_ERROR_FAILED  Failed to request NAT64 prefix discovery."]
9958    pub fn otPlatInfraIfDiscoverNat64Prefix(aInfraIfIndex: u32) -> otError;
9959}
9960extern "C" {
9961    #[doc = " The infra interface driver calls this method to notify OpenThread that\n the discovery of NAT64 prefix is done.\n\n Is expected to be invoked after calling otPlatInfraIfDiscoverNat64Prefix.\n If no NAT64 prefix is discovered, @p aIp6Prefix shall point to an empty prefix with zero length.\n\n @param[in]  aInstance      The OpenThread instance structure.\n @param[in]  aInfraIfIndex  The index of the infrastructure interface on which the NAT64 prefix is discovered.\n @param[in]  aIp6Prefix     A pointer to NAT64 prefix."]
9962    pub fn otPlatInfraIfDiscoverNat64PrefixDone(
9963        aInstance: *mut otInstance,
9964        aInfraIfIndex: u32,
9965        aIp6Prefix: *const otIp6Prefix,
9966    );
9967}
9968extern "C" {
9969    #[doc = " Get the link-layer address of the infrastructure interface.\n\n OpenThread invokes this method when the address is required, for example: when generating an ND6 message\n which includes a source link-layer address option.\n\n @param[in]  aInstance                    The OpenThread instance structure.\n @param[in]  aInfraIfIndex                The index of the infrastructure interface.\n @param[out] aInfraIfLinkLayerAddress     A pointer to infrastructure interface link-layer address.\n\n @retval  OT_ERROR_NONE    Successfully get the infrastructure interface link-layer address.\n @retval  OT_ERROR_FAILED  Failed to get the infrastructure interface link-layer address."]
9970    pub fn otPlatGetInfraIfLinkLayerAddress(
9971        aInstance: *mut otInstance,
9972        aIfIndex: u32,
9973        aInfraIfLinkLayerAddress: *mut otPlatInfraIfLinkLayerAddress,
9974    ) -> otError;
9975}
9976extern "C" {
9977    #[doc = " Dynamically allocates new memory. On platforms that support it, should just redirect to calloc. For\n those that don't support calloc, should support the same functionality:\n\n   \"The calloc() function contiguously allocates enough space for count objects that are size bytes of\n   memory each and returns a pointer to the allocated memory. The allocated memory is filled with bytes\n   of value zero.\"\n\n Is required for OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE.\n\n @param[in] aNum   The number of blocks to allocate\n @param[in] aSize  The size of each block to allocate\n\n @retval void*  The pointer to the front of the memory allocated\n @retval NULL   Failed to allocate the memory requested."]
9978    pub fn otPlatCAlloc(aNum: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
9979}
9980extern "C" {
9981    #[doc = " Frees memory that was dynamically allocated.\n\n Is required for OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE.\n\n @param[in] aPtr  A pointer the memory blocks to free. The pointer may be NULL."]
9982    pub fn otPlatFree(aPtr: *mut ::std::os::raw::c_void);
9983}
9984#[doc = " Represents an OpenThread message buffer."]
9985#[repr(C)]
9986#[derive(Debug, Copy, Clone)]
9987pub struct otMessageBuffer {
9988    #[doc = "< Pointer to the next buffer."]
9989    pub mNext: *mut otMessageBuffer,
9990}
9991impl Default for otMessageBuffer {
9992    fn default() -> Self {
9993        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9994        unsafe {
9995            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9996            s.assume_init()
9997        }
9998    }
9999}
10000extern "C" {
10001    #[doc = " Initialize the platform implemented message pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in] aInstance            A pointer to the OpenThread instance.\n @param[in] aMinNumFreeBuffers   An uint16 containing the minimum number of free buffers desired by OpenThread.\n @param[in] aBufferSize          The size in bytes of a buffer object."]
10002    pub fn otPlatMessagePoolInit(
10003        aInstance: *mut otInstance,
10004        aMinNumFreeBuffers: u16,
10005        aBufferSize: usize,
10006    );
10007}
10008extern "C" {
10009    #[doc = " Allocate a buffer from the platform managed buffer pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n The returned buffer instance MUST have at least `aBufferSize` bytes (as specified in `otPlatMessagePoolInit()`).\n\n @param[in] aInstance            A pointer to the OpenThread instance.\n\n @returns A pointer to the buffer or NULL if no buffers are available."]
10010    pub fn otPlatMessagePoolNew(aInstance: *mut otInstance) -> *mut otMessageBuffer;
10011}
10012extern "C" {
10013    #[doc = " Is used to free a buffer back to the platform managed buffer pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in]  aInstance  A pointer to the OpenThread instance.\n @param[in]  aBuffer    The buffer to free."]
10014    pub fn otPlatMessagePoolFree(aInstance: *mut otInstance, aBuffer: *mut otMessageBuffer);
10015}
10016extern "C" {
10017    #[doc = " Get the number of free buffers.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in]  aInstance  A pointer to the OpenThread instance.\n\n @returns The number of buffers currently free and available to OpenThread."]
10018    pub fn otPlatMessagePoolNumFreeBuffers(aInstance: *mut otInstance) -> u16;
10019}
10020extern "C" {
10021    #[doc = " Performs a software reset on the platform, if supported.\n\n @param[in] aInstance  The OpenThread instance structure."]
10022    pub fn otPlatReset(aInstance: *mut otInstance);
10023}
10024extern "C" {
10025    #[doc = " Performs a hardware reset on the platform to launch bootloader mode, if supported.\n\n Used when `OPENTHREAD_CONFIG_PLATFORM_BOOTLOADER_MODE_ENABLE` is enabled.\n\n @param[in] aInstance  The OpenThread instance structure.\n\n @retval OT_ERROR_NONE         Reset to bootloader successfully.\n @retval OT_ERROR_BUSY         Failed due to another operation is ongoing.\n @retval OT_ERROR_NOT_CAPABLE  Not capable of resetting to bootloader."]
10026    pub fn otPlatResetToBootloader(aInstance: *mut otInstance) -> otError;
10027}
10028pub const OT_PLAT_RESET_REASON_POWER_ON: otPlatResetReason = 0;
10029pub const OT_PLAT_RESET_REASON_EXTERNAL: otPlatResetReason = 1;
10030pub const OT_PLAT_RESET_REASON_SOFTWARE: otPlatResetReason = 2;
10031pub const OT_PLAT_RESET_REASON_FAULT: otPlatResetReason = 3;
10032pub const OT_PLAT_RESET_REASON_CRASH: otPlatResetReason = 4;
10033pub const OT_PLAT_RESET_REASON_ASSERT: otPlatResetReason = 5;
10034pub const OT_PLAT_RESET_REASON_OTHER: otPlatResetReason = 6;
10035pub const OT_PLAT_RESET_REASON_UNKNOWN: otPlatResetReason = 7;
10036pub const OT_PLAT_RESET_REASON_WATCHDOG: otPlatResetReason = 8;
10037pub const OT_PLAT_RESET_REASON_COUNT: otPlatResetReason = 9;
10038#[doc = " Enumeration of possible reset reason codes.\n\n These are in the same order as the Spinel reset reason codes."]
10039pub type otPlatResetReason = ::std::os::raw::c_uint;
10040extern "C" {
10041    #[doc = " Returns the reason for the last platform reset.\n\n @param[in] aInstance  The OpenThread instance structure."]
10042    pub fn otPlatGetResetReason(aInstance: *mut otInstance) -> otPlatResetReason;
10043}
10044extern "C" {
10045    #[doc = " Provides a platform specific implementation for assert.\n\n @param[in] aFilename    The name of the file where the assert occurred.\n @param[in] aLineNumber  The line number in the file where the assert occurred."]
10046    pub fn otPlatAssertFail(
10047        aFilename: *const ::std::os::raw::c_char,
10048        aLineNumber: ::std::os::raw::c_int,
10049    );
10050}
10051extern "C" {
10052    #[doc = " Performs a platform specific operation to wake the host MCU.\n This is used only for NCP configurations."]
10053    pub fn otPlatWakeHost();
10054}
10055#[doc = " NCP's MCU stays on and active all the time.\n\n When the NCP's desired power state is set to `ON`, host can send messages to NCP without requiring any \"poke\" or\n external triggers.\n\n @note The `ON` power state only determines the MCU's power mode and is not related to radio's state."]
10056pub const OT_PLAT_MCU_POWER_STATE_ON: otPlatMcuPowerState = 0;
10057#[doc = " NCP's MCU can enter low-power (energy-saving) state.\n\n When the NCP's desired power state is set to `LOW_POWER`, host is expected to \"poke\" the NCP (e.g., an external\n trigger like an interrupt) before it can communicate with the NCP (send a message to the NCP). The \"poke\"\n mechanism is determined by the platform code (based on NCP's interface to the host).\n\n While power state is set to `LOW_POWER`, NCP can still (at any time) send messages to host. Note that receiving\n a message from the NCP does NOT indicate that the NCP's power state has changed, i.e., host is expected to\n continue to \"poke\" when it wants to talk to the NCP until the power state is explicitly changed (by a successful\n call to `otPlatSetMcuPowerState()` changing the state to `ON`).\n\n @note The `LOW_POWER` power state only determines the MCU's power mode and is not related to radio's state\n (radio is managed by OpenThread core and device role, e.g., device being sleepy or not."]
10058pub const OT_PLAT_MCU_POWER_STATE_LOW_POWER: otPlatMcuPowerState = 1;
10059#[doc = " NCP is fully off.\n\n An NCP hardware reset (via a RESET pin) is required to bring the NCP back to `SPINEL_MCU_POWER_STATE_ON`.\n RAM is not retained after reset."]
10060pub const OT_PLAT_MCU_POWER_STATE_OFF: otPlatMcuPowerState = 2;
10061#[doc = " Enumeration of micro-controller's power states.\n\n These values are used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL` is enabled.\n\n The power state specifies the desired power state of NCP's micro-controller (MCU) when the underlying platform's\n operating system enters idle mode (i.e., all active tasks/events are processed and the MCU can potentially enter a\n energy-saving power state).\n\n The power state primarily determines how the host should interact with the NCP and whether the host needs an\n external trigger (a \"poke\") to NCP before it can communicate with the NCP or not.\n\n After a reset, the MCU power state MUST be `OT_PLAT_POWER_STATE_ON`."]
10062pub type otPlatMcuPowerState = ::std::os::raw::c_uint;
10063extern "C" {
10064    #[doc = " Sets the desired MCU power state.\n\n This is only applicable and used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL`\n is enabled.\n\n @param[in] aInstance      A pointer to OpenThread instance.\n @param[in] aState         The new MCU power state.\n\n @retval OT_ERROR_NONE     The power state updated successfully.\n @retval OT_ERROR_FAILED   The given MCU power state is not supported by the platform."]
10065    pub fn otPlatSetMcuPowerState(
10066        aInstance: *mut otInstance,
10067        aState: otPlatMcuPowerState,
10068    ) -> otError;
10069}
10070extern "C" {
10071    #[doc = " Gets the current desired MCU power state.\n\n This is only applicable and used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL`\n is enabled.\n\n After a reset, the power state MUST return `OT_PLAT_POWER_STATE_ON`. During operation, power state SHOULD only\n change through an explicit successful call to `otPlatSetMcuPowerState()`.\n\n @param[in] aInstance  A pointer to OpenThread instance.\n\n @returns The current power state."]
10072    pub fn otPlatGetMcuPowerState(aInstance: *mut otInstance) -> otPlatMcuPowerState;
10073}
10074extern "C" {
10075    #[doc = " Logs a crash dump using OpenThread logging APIs\n\n @note This API is an optional logging platform API. It's up to the platform layer to implement it.\n\n @retval OT_ERROR_NONE            Crash dump was logged successfully\n @retval OT_ERROR_NOT_CAPABLE     Platform is not capable of logging a crash dump"]
10076    pub fn otPlatLogCrashDump() -> otError;
10077}
10078extern "C" {
10079    #[doc = " Exports status information to OTNS.\n\n The status information is represented by a null-terminated string with format recognizable by OTNS.\n Each call to `otPlatOtnsStatus` can send multiple statuses, separated by ';', e.x. \"parid=577fbc37;lrid=5\".\n Each status contains key and value separated by '='.\n Status value can be further separated into multiple fields using ',',\n e.x. \"ping_request=fdde:ad00:beef:0:459e:d7b4:b65e:5480,4,112000\".\n\n New statuses should follow these conventions.\n\n Currently, OTNS only supports virtual time simulation.\n\n @param[in]  aStatus  The status string."]
10080    pub fn otPlatOtnsStatus(aStatus: *const ::std::os::raw::c_char);
10081}
10082#[doc = "< Active Operational Dataset."]
10083pub const OT_SETTINGS_KEY_ACTIVE_DATASET: _bindgen_ty_10 = 1;
10084#[doc = "< Pending Operational Dataset."]
10085pub const OT_SETTINGS_KEY_PENDING_DATASET: _bindgen_ty_10 = 2;
10086#[doc = "< Thread network information."]
10087pub const OT_SETTINGS_KEY_NETWORK_INFO: _bindgen_ty_10 = 3;
10088#[doc = "< Parent information."]
10089pub const OT_SETTINGS_KEY_PARENT_INFO: _bindgen_ty_10 = 4;
10090#[doc = "< Child information."]
10091pub const OT_SETTINGS_KEY_CHILD_INFO: _bindgen_ty_10 = 5;
10092#[doc = "< SLAAC key to generate semantically opaque IID."]
10093pub const OT_SETTINGS_KEY_SLAAC_IID_SECRET_KEY: _bindgen_ty_10 = 7;
10094#[doc = "< Duplicate Address Detection (DAD) information."]
10095pub const OT_SETTINGS_KEY_DAD_INFO: _bindgen_ty_10 = 8;
10096#[doc = "< SRP client ECDSA public/private key pair."]
10097pub const OT_SETTINGS_KEY_SRP_ECDSA_KEY: _bindgen_ty_10 = 11;
10098#[doc = "< The SRP client info (selected SRP server address)."]
10099pub const OT_SETTINGS_KEY_SRP_CLIENT_INFO: _bindgen_ty_10 = 12;
10100#[doc = "< The SRP server info (UDP port)."]
10101pub const OT_SETTINGS_KEY_SRP_SERVER_INFO: _bindgen_ty_10 = 13;
10102#[doc = "< BR ULA prefix."]
10103pub const OT_SETTINGS_KEY_BR_ULA_PREFIX: _bindgen_ty_10 = 15;
10104#[doc = "< BR local on-link prefixes."]
10105pub const OT_SETTINGS_KEY_BR_ON_LINK_PREFIXES: _bindgen_ty_10 = 16;
10106#[doc = "< Unique Border Agent/Router ID."]
10107pub const OT_SETTINGS_KEY_BORDER_AGENT_ID: _bindgen_ty_10 = 17;
10108#[doc = "< TCAT Commissioner certificate"]
10109pub const OT_SETTINGS_KEY_TCAT_COMMR_CERT: _bindgen_ty_10 = 18;
10110pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MIN: _bindgen_ty_10 = 32768;
10111pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MAX: _bindgen_ty_10 = 65535;
10112#[doc = " Defines the keys of settings.\n\n Note: When adding a new settings key, if the settings corresponding to the key contains security sensitive\n       information, the developer MUST add the key to the array `aSensitiveKeys` which is passed in\n       `otPlatSettingsInit()`."]
10113pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
10114extern "C" {
10115    #[doc = " Performs any initialization for the settings subsystem, if necessary.\n\n Also sets the sensitive keys that should be stored in the secure area.\n\n Note that the memory pointed by @p aSensitiveKeys MUST not be released before @p aInstance is destroyed.\n\n @param[in]  aInstance             The OpenThread instance structure.\n @param[in]  aSensitiveKeys        A pointer to an array containing the list of sensitive keys. May be NULL only if\n                                   @p aSensitiveKeysLength is 0, which means that there is no sensitive keys.\n @param[in]  aSensitiveKeysLength  The number of entries in the @p aSensitiveKeys array."]
10116    pub fn otPlatSettingsInit(
10117        aInstance: *mut otInstance,
10118        aSensitiveKeys: *const u16,
10119        aSensitiveKeysLength: u16,
10120    );
10121}
10122extern "C" {
10123    #[doc = " Performs any de-initialization for the settings subsystem, if necessary.\n\n @param[in]  aInstance The OpenThread instance structure."]
10124    pub fn otPlatSettingsDeinit(aInstance: *mut otInstance);
10125}
10126extern "C" {
10127    #[doc = " Fetches the value of a setting.\n\n Fetches the value of the setting identified\n by @p aKey and write it to the memory pointed to by aValue.\n It then writes the length to the integer pointed to by\n @p aValueLength. The initial value of @p aValueLength is the\n maximum number of bytes to be written to @p aValue.\n\n Can be used to check for the existence of\n a key without fetching the value by setting @p aValue and\n @p aValueLength to NULL. You can also check the length of\n the setting without fetching it by setting only aValue\n to NULL.\n\n Note that the underlying storage implementation is not\n required to maintain the order of settings with multiple\n values. The order of such values MAY change after ANY\n write operation to the store.\n\n @param[in]      aInstance     The OpenThread instance structure.\n @param[in]      aKey          The key associated with the requested setting.\n @param[in]      aIndex        The index of the specific item to get.\n @param[out]     aValue        A pointer to where the value of the setting should be written. May be set to NULL if\n                               just testing for the presence or length of a setting.\n @param[in,out]  aValueLength  A pointer to the length of the value. When called, this pointer should point to an\n                               integer containing the maximum value size that can be written to @p aValue. At return,\n                               the actual length of the setting is written. This may be set to NULL if performing\n                               a presence check.\n\n @retval OT_ERROR_NONE             The given setting was found and fetched successfully.\n @retval OT_ERROR_NOT_FOUND        The given setting was not found in the setting store.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented on this platform."]
10128    pub fn otPlatSettingsGet(
10129        aInstance: *mut otInstance,
10130        aKey: u16,
10131        aIndex: ::std::os::raw::c_int,
10132        aValue: *mut u8,
10133        aValueLength: *mut u16,
10134    ) -> otError;
10135}
10136extern "C" {
10137    #[doc = " Sets or replaces the value of a setting.\n\n Sets or replaces the value of a setting\n identified by @p aKey.\n\n Calling this function successfully may cause unrelated\n settings with multiple values to be reordered.\n\n OpenThread stack guarantees to use `otPlatSettingsSet()`\n method for a @p aKey that was either previously set using\n `otPlatSettingsSet()` (i.e., contains a single value) or\n is empty and/or fully deleted (contains no value).\n\n Platform layer can rely and use this fact for optimizing\n its implementation.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[in]  aKey          The key associated with the setting to change.\n @param[in]  aValue        A pointer to where the new value of the setting should be read from. MUST NOT be NULL if\n                           @p aValueLength is non-zero.\n @param[in]  aValueLength  The length of the data pointed to by aValue. May be zero.\n\n @retval OT_ERROR_NONE             The given setting was changed or staged.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented on this platform.\n @retval OT_ERROR_NO_BUFS          No space remaining to store the given setting."]
10138    pub fn otPlatSettingsSet(
10139        aInstance: *mut otInstance,
10140        aKey: u16,
10141        aValue: *const u8,
10142        aValueLength: u16,
10143    ) -> otError;
10144}
10145extern "C" {
10146    #[doc = " Adds a value to a setting.\n\n Adds the value to a setting\n identified by @p aKey, without replacing any existing\n values.\n\n Note that the underlying implementation is not required\n to maintain the order of the items associated with a\n specific key. The added value may be added to the end,\n the beginning, or even somewhere in the middle. The order\n of any pre-existing values may also change.\n\n Calling this function successfully may cause unrelated\n settings with multiple values to be reordered.\n\n OpenThread stack guarantees to use `otPlatSettingsAdd()`\n method for a @p aKey that was either previously managed by\n `otPlatSettingsAdd()` (i.e., contains one or more items) or\n is empty and/or fully deleted (contains no value).\n\n Platform layer can rely and use this fact for optimizing\n its implementation.\n\n @param[in]  aInstance     The OpenThread instance structure.\n @param[in]  aKey          The key associated with the setting to change.\n @param[in]  aValue        A pointer to where the new value of the setting should be read from. MUST NOT be NULL\n                           if @p aValueLength is non-zero.\n @param[in]  aValueLength  The length of the data pointed to by @p aValue. May be zero.\n\n @retval OT_ERROR_NONE             The given setting was added or staged to be added.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented on this platform.\n @retval OT_ERROR_NO_BUFS          No space remaining to store the given setting."]
10147    pub fn otPlatSettingsAdd(
10148        aInstance: *mut otInstance,
10149        aKey: u16,
10150        aValue: *const u8,
10151        aValueLength: u16,
10152    ) -> otError;
10153}
10154extern "C" {
10155    #[doc = " Removes a setting from the setting store.\n\n Deletes a specific value from the\n setting identified by aKey from the settings store.\n\n Note that the underlying implementation is not required\n to maintain the order of the items associated with a\n specific key.\n\n @param[in] aInstance  The OpenThread instance structure.\n @param[in] aKey       The key associated with the requested setting.\n @param[in] aIndex     The index of the value to be removed. If set to -1, all values for this @p aKey will be\n                       removed.\n\n @retval OT_ERROR_NONE             The given key and index was found and removed successfully.\n @retval OT_ERROR_NOT_FOUND        The given key or index was not found in the setting store.\n @retval OT_ERROR_NOT_IMPLEMENTED  This function is not implemented on this platform."]
10156    pub fn otPlatSettingsDelete(
10157        aInstance: *mut otInstance,
10158        aKey: u16,
10159        aIndex: ::std::os::raw::c_int,
10160    ) -> otError;
10161}
10162extern "C" {
10163    #[doc = " Removes all settings from the setting store.\n\n Deletes all settings from the settings\n store, resetting it to its initial factory state.\n\n @param[in] aInstance  The OpenThread instance structure."]
10164    pub fn otPlatSettingsWipe(aInstance: *mut otInstance);
10165}
10166#[doc = " Indicates that a SPI transaction has completed with the given length. The data written to the slave has been written\n to the pointer indicated by the `aInputBuf` argument to the previous call to `otPlatSpiSlavePrepareTransaction()`.\n\n Once this function is called, `otPlatSpiSlavePrepareTransaction()` is invalid and must be called again for the next\n transaction to be valid.\n\n Note that this function is always called at the end of a transaction, even if `otPlatSpiSlavePrepareTransaction()`\n has not yet been called. In such cases, `aOutputBufLen` and `aInputBufLen` will be zero.\n\n This callback can be called from ISR context. The return value from this function indicates if any further\n processing is required. If `TRUE` is returned the platform spi-slave driver implementation must invoke the\n transaction process callback (`aProcessCallback` set in `otPlatSpiSlaveEnable()`) which unlike this callback must be\n called from the same OS context that any other OpenThread API/callback is called.\n\n @param[in] aContext           Context pointer passed into `otPlatSpiSlaveEnable()`.\n @param[in] aOutputBuf         Value of `aOutputBuf` from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aOutputBufLen      Value of `aOutputBufLen` from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aInputBuf          Value of aInputBuf from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aInputBufLen       Value of aInputBufLen from last call to `otPlatSpiSlavePrepareTransaction()`\n @param[in] aTransactionLength Length of the completed transaction, in bytes.\n\n @returns  TRUE if after this call returns the platform should invoke the process callback `aProcessCallback`,\n           FALSE if there is nothing to process and no need to invoke the process callback."]
10167pub type otPlatSpiSlaveTransactionCompleteCallback = ::std::option::Option<
10168    unsafe extern "C" fn(
10169        aContext: *mut ::std::os::raw::c_void,
10170        aOutputBuf: *mut u8,
10171        aOutputBufLen: u16,
10172        aInputBuf: *mut u8,
10173        aInputBufLen: u16,
10174        aTransactionLength: u16,
10175    ) -> bool,
10176>;
10177#[doc = " Invoked after a transaction complete callback is called and returns `TRUE` to do any further processing required.\n Unlike `otPlatSpiSlaveTransactionCompleteCallback` which can be called from any OS context (e.g., ISR), this\n callback MUST be called from the same OS context as any other OpenThread API/callback.\n\n @param[in] aContext           Context pointer passed into `otPlatSpiSlaveEnable()`."]
10178pub type otPlatSpiSlaveTransactionProcessCallback =
10179    ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
10180extern "C" {
10181    #[doc = " Initialize the SPI slave interface.\n\n Note that SPI slave is not fully ready until a transaction is prepared using `otPlatSPISlavePrepareTransaction()`.\n\n If `otPlatSPISlavePrepareTransaction() is not called before the master begins a transaction, the resulting SPI\n transaction will send all `0xFF` bytes and discard all received bytes.\n\n @param[in] aCompleteCallback  Pointer to transaction complete callback.\n @param[in] aProcessCallback   Pointer to process callback.\n @param[in] aContext           Context pointer to be passed to callbacks.\n\n @retval OT_ERROR_NONE     Successfully enabled the SPI Slave interface.\n @retval OT_ERROR_ALREADY  SPI Slave interface is already enabled.\n @retval OT_ERROR_FAILED   Failed to enable the SPI Slave interface."]
10182    pub fn otPlatSpiSlaveEnable(
10183        aCompleteCallback: otPlatSpiSlaveTransactionCompleteCallback,
10184        aProcessCallback: otPlatSpiSlaveTransactionProcessCallback,
10185        aContext: *mut ::std::os::raw::c_void,
10186    ) -> otError;
10187}
10188extern "C" {
10189    #[doc = " Shutdown and disable the SPI slave interface."]
10190    pub fn otPlatSpiSlaveDisable();
10191}
10192extern "C" {
10193    #[doc = " Prepare data for the next SPI transaction. Data pointers MUST remain valid until the transaction complete callback\n is called by the SPI slave driver, or until after the next call to `otPlatSpiSlavePrepareTransaction()`.\n\n May be called more than once before the SPI master initiates the transaction. Each *successful* call\n to this function will cause the previous values from earlier calls to be discarded.\n\n Not calling this function after a completed transaction is the same as if this function was previously called with\n both buffer lengths set to zero and `aRequestTransactionFlag` set to `false`.\n\n Once `aOutputBufLen` bytes of `aOutputBuf` has been clocked out, the MISO pin shall be set high until the master\n finishes the SPI transaction. This is the functional equivalent of padding the end of `aOutputBuf` with `0xFF` bytes\n out to the length of the transaction.\n\n Once `aInputBufLen` bytes of aInputBuf have been clocked in from MOSI, all subsequent values from the MOSI pin are\n ignored until the SPI master finishes the transaction.\n\n Note that even if `aInputBufLen` or `aOutputBufLen` (or both) are exhausted before the SPI master finishes a\n transaction, the ongoing size of the transaction must still be kept track of to be passed to the transaction\n complete callback. For example, if `aInputBufLen` is equal to 10 and `aOutputBufLen` equal to 20 and the SPI master\n clocks out 30 bytes, the value 30 is passed to the transaction complete callback.\n\n If a `NULL` pointer is passed in as `aOutputBuf` or `aInputBuf` it means that that buffer pointer should not change\n from its previous/current value. In this case, the corresponding length argument should be ignored. For example,\n `otPlatSpiSlavePrepareTransaction(NULL, 0, aInputBuf, aInputLen, false)` changes the input buffer pointer and its\n length but keeps the output buffer pointer same as before.\n\n Any call to this function while a transaction is in progress will cause all of the arguments to be ignored and the\n return value to be `OT_ERROR_BUSY`.\n\n @param[in] aOutputBuf              Data to be written to MISO pin\n @param[in] aOutputBufLen           Size of the output buffer, in bytes\n @param[in] aInputBuf               Data to be read from MOSI pin\n @param[in] aInputBufLen            Size of the input buffer, in bytes\n @param[in] aRequestTransactionFlag Set to true if host interrupt should be set\n\n @retval OT_ERROR_NONE           Transaction was successfully prepared.\n @retval OT_ERROR_BUSY           A transaction is currently in progress.\n @retval OT_ERROR_INVALID_STATE  otPlatSpiSlaveEnable() hasn't been called."]
10194    pub fn otPlatSpiSlavePrepareTransaction(
10195        aOutputBuf: *mut u8,
10196        aOutputBufLen: u16,
10197        aInputBuf: *mut u8,
10198        aInputBufLen: u16,
10199        aRequestTransactionFlag: bool,
10200    ) -> otError;
10201}
10202extern "C" {
10203    #[doc = " Get the current platform time in microseconds referenced to a continuous\n monotonic local clock (64 bits width).\n\n The clock SHALL NOT wrap during the device's uptime. Implementations SHALL\n therefore identify and compensate for internal counter overflows. The clock\n does not have a defined epoch and it SHALL NOT introduce any continuous or\n discontinuous adjustments (e.g. leap seconds). Implementations SHALL\n compensate for any sleep times of the device.\n\n Implementations MAY choose to discipline the platform clock and compensate\n for sleep times by any means (e.g. by combining a high precision/low power\n RTC with a high resolution counter) as long as the exposed combined clock\n provides continuous monotonic microsecond resolution ticks within the\n accuracy limits announced by @ref otPlatTimeGetXtalAccuracy.\n\n @returns The current time in microseconds."]
10204    pub fn otPlatTimeGet() -> u64;
10205}
10206extern "C" {
10207    #[doc = " Get the current estimated worst case accuracy (maximum ± deviation from the\n nominal frequency) of the local platform clock in units of PPM.\n\n @note Implementations MAY estimate this value based on current operating\n conditions (e.g. temperature).\n\n In case the implementation does not estimate the current value but returns a\n fixed value, this value MUST be the worst-case accuracy over all possible\n foreseen operating conditions (temperature, pressure, etc) of the\n implementation.\n\n @returns The current platform clock accuracy, in PPM."]
10208    pub fn otPlatTimeGetXtalAccuracy() -> u16;
10209}
10210extern "C" {
10211    #[doc = " Initializes and enables TREL platform layer.\n\n Upon this call, the platform layer MUST perform the following:\n\n 1) TREL platform layer MUST open a UDP socket to listen for and receive TREL messages from peers. The socket is\n bound to an ephemeral port number chosen by the platform layer. The port number MUST be returned in @p aUdpPort.\n The socket is also bound to network interface(s) on which TREL is to be supported. The socket and the chosen port\n should stay valid while TREL is enabled.\n\n 2) Platform layer MUST initiate an ongoing DNS-SD browse on the service name \"_trel._udp\" within the local browsing\n domain to discover other devices supporting TREL. The ongoing browse will produce two different types of events:\n \"add\" events and \"remove\" events.  When the browse is started, it should produce an \"add\" event for every TREL peer\n currently present on the network.  Whenever a TREL peer goes offline, a \"remove\" event should be produced. \"remove\"\n events are not guaranteed, however. When a TREL service instance is discovered, a new ongoing DNS-SD query for an\n AAAA record should be started on the hostname indicated in the SRV record of the discovered instance. If multiple\n host IPv6 addressees are discovered for a peer, one with highest scope among all addresses MUST be reported (if\n there are multiple address at same scope, one must be selected randomly).\n\n TREL platform MUST signal back the discovered peer info using `otPlatTrelHandleDiscoveredPeerInfo()` callback. This\n callback MUST be invoked when a new peer is discovered, when there is a change in an existing entry (e.g., new\n TXT record or new port number or new IPv6 address), or when the peer is removed.\n\n @param[in]  aInstance  The OpenThread instance.\n @param[out] aUdpPort   A pointer to return the selected port number by platform layer."]
10212    pub fn otPlatTrelEnable(aInstance: *mut otInstance, aUdpPort: *mut u16);
10213}
10214extern "C" {
10215    #[doc = " Disables TREL platform layer.\n\n After this call, the platform layer MUST stop DNS-SD browse on the service name \"_trel._udp\", stop advertising the\n TREL DNS-SD service (from `otPlatTrelRegisterService()`) and MUST close the UDP socket used to receive TREL messages.\n\n @pram[in]  aInstance  The OpenThread instance."]
10216    pub fn otPlatTrelDisable(aInstance: *mut otInstance);
10217}
10218#[doc = " Represents a TREL peer info discovered using DNS-SD browse on the service name \"_trel._udp\"."]
10219#[repr(C)]
10220#[derive(Copy, Clone)]
10221pub struct otPlatTrelPeerInfo {
10222    #[doc = " This boolean flag indicates whether the entry is being removed or added.\n\n - TRUE indicates that peer is removed.\n - FALSE indicates that it is a new entry or an update to an existing entry."]
10223    pub mRemoved: bool,
10224    #[doc = " The TXT record data (encoded as specified by DNS-SD) from the SRV record of the discovered TREL peer service\n instance."]
10225    pub mTxtData: *const u8,
10226    #[doc = "< Number of bytes in @p mTxtData buffer."]
10227    pub mTxtLength: u16,
10228    #[doc = " The TREL peer socket address (IPv6 address and port number).\n\n The port number is determined from the SRV record of the discovered TREL peer service instance. The IPv6 address\n is determined from the DNS-SD query for AAAA records on the hostname indicated in the SRV record of the\n discovered service instance. If multiple host IPv6 addressees are discovered, one with highest scope is used."]
10229    pub mSockAddr: otSockAddr,
10230}
10231impl Default for otPlatTrelPeerInfo {
10232    fn default() -> Self {
10233        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10234        unsafe {
10235            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10236            s.assume_init()
10237        }
10238    }
10239}
10240extern "C" {
10241    #[doc = " This is a callback function from platform layer to report a discovered TREL peer info.\n\n @note The @p aInfo structure and its content (e.g., the `mTxtData` buffer) does not need to persist after returning\n from this call. OpenThread code will make a copy of all the info it needs.\n\n @param[in] aInstance   The OpenThread instance.\n @param[in] aInfo       A pointer to the TREL peer info."]
10242    pub fn otPlatTrelHandleDiscoveredPeerInfo(
10243        aInstance: *mut otInstance,
10244        aInfo: *const otPlatTrelPeerInfo,
10245    );
10246}
10247extern "C" {
10248    #[doc = " Notifies platform that a TREL packet is received from a peer using a different socket address than the one reported\n earlier from `otPlatTrelHandleDiscoveredPeerInfo()`.\n\n Ideally the platform underlying DNS-SD should detect changes to advertised port and addresses by peers, however,\n there are situations where this is not detected reliably. This function signals to the platform layer than we\n received a packet from a peer with it using a different port or address. This can be used by the playroom layer to\n restart/confirm the DNS-SD service/address resolution for the peer service and/or take any other relevant actions.\n\n @param[in] aInstance      The OpenThread instance.\n @param[in] aPeerSockAddr  The address of the peer, reported from `otPlatTrelHandleDiscoveredPeerInfo()` call.\n @param[in] aRxSockAddr    The address of received packet from the same peer (differs from @p aPeerSockAddr)."]
10249    pub fn otPlatTrelNotifyPeerSocketAddressDifference(
10250        aInstance: *mut otInstance,
10251        aPeerSockAddr: *const otSockAddr,
10252        aRxSockAddr: *const otSockAddr,
10253    );
10254}
10255extern "C" {
10256    #[doc = " Registers a new service to be advertised using DNS-SD [RFC6763].\n\n The service name is \"_trel._udp\". The platform should use its own hostname, which when combined with the service\n name and the local DNS-SD domain name will produce the full service instance name, for example\n \"example-host._trel._udp.local.\".\n\n The domain under which the service instance name appears will be 'local' for mDNS, and will be whatever domain is\n used for service registration in the case of a non-mDNS local DNS-SD service.\n\n A subsequent call to this function updates the previous service. It is used to update the TXT record data and/or the\n port number.\n\n The @p aTxtData buffer is not persisted after the return from this function. The platform layer MUST NOT keep the\n pointer and instead copy the content if needed.\n\n @param[in] aInstance   The OpenThread instance.\n @param[in] aPort       The port number to include in the SRV record of the advertised service.\n @param[in] aTxtData    A pointer to the TXT record data (encoded) to be include in the advertised service.\n @param[in] aTxtLength  The length of @p aTxtData (number of bytes)."]
10257    pub fn otPlatTrelRegisterService(
10258        aInstance: *mut otInstance,
10259        aPort: u16,
10260        aTxtData: *const u8,
10261        aTxtLength: u8,
10262    );
10263}
10264extern "C" {
10265    #[doc = " Requests a TREL UDP packet to be sent to a given destination.\n\n @param[in] aInstance        The OpenThread instance structure.\n @param[in] aUdpPayload      A pointer to UDP payload.\n @param[in] aUdpPayloadLen   The payload length (number of bytes).\n @param[in] aDestSockAddr    The destination socket address."]
10266    pub fn otPlatTrelSend(
10267        aInstance: *mut otInstance,
10268        aUdpPayload: *const u8,
10269        aUdpPayloadLen: u16,
10270        aDestSockAddr: *const otSockAddr,
10271    );
10272}
10273extern "C" {
10274    #[doc = " Is a callback from platform to notify of a received TREL UDP packet.\n\n @note The buffer content (up to its specified length) may get changed during processing by OpenThread core (e.g.,\n decrypted in place), so the platform implementation should expect that after returning from this function the\n @p aBuffer content may have been altered.\n\n @param[in] aInstance        The OpenThread instance structure.\n @param[in] aBuffer          A buffer containing the received UDP payload.\n @param[in] aLength          UDP payload length (number of bytes).\n @param[in] aSockAddr        The sender address."]
10275    pub fn otPlatTrelHandleReceived(
10276        aInstance: *mut otInstance,
10277        aBuffer: *mut u8,
10278        aLength: u16,
10279        aSenderAddr: *const otSockAddr,
10280    );
10281}
10282#[doc = " Represents a group of TREL related counters in the platform layer."]
10283#[repr(C)]
10284#[derive(Debug, Default, Copy, Clone)]
10285pub struct otPlatTrelCounters {
10286    #[doc = "< Number of packets successfully transmitted through TREL."]
10287    pub mTxPackets: u64,
10288    #[doc = "< Sum of size of packets successfully transmitted through TREL."]
10289    pub mTxBytes: u64,
10290    #[doc = "< Number of packet transmission failures through TREL."]
10291    pub mTxFailure: u64,
10292    #[doc = "< Number of packets received through TREL."]
10293    pub mRxPackets: u64,
10294    #[doc = "< Sum of size of packets received through TREL."]
10295    pub mRxBytes: u64,
10296}
10297extern "C" {
10298    #[doc = " Gets the pointer to the TREL counters in the platform layer.\n\n @param[in] aInstance        The OpenThread instance structure."]
10299    pub fn otPlatTrelGetCounters(aInstance: *mut otInstance) -> *const otPlatTrelCounters;
10300}
10301extern "C" {
10302    #[doc = " Resets the TREL counters in the platform layer.\n\n @param[in] aInstance        The OpenThread instance structure."]
10303    pub fn otPlatTrelResetCounters(aInstance: *mut otInstance);
10304}
10305#[doc = " This callback allows OpenThread to provide specific handlers for certain UDP messages.\n\n @retval  true    The message is handled by this receiver and should not be further processed.\n @retval  false   The message is not handled by this receiver."]
10306pub type otUdpHandler = ::std::option::Option<
10307    unsafe extern "C" fn(
10308        aContext: *mut ::std::os::raw::c_void,
10309        aMessage: *const otMessage,
10310        aMessageInfo: *const otMessageInfo,
10311    ) -> bool,
10312>;
10313#[doc = " Represents a UDP receiver."]
10314#[repr(C)]
10315#[derive(Debug, Copy, Clone)]
10316pub struct otUdpReceiver {
10317    #[doc = "< A pointer to the next UDP receiver (internal use only)."]
10318    pub mNext: *mut otUdpReceiver,
10319    #[doc = "< A function pointer to the receiver callback."]
10320    pub mHandler: otUdpHandler,
10321    #[doc = "< A pointer to application-specific context."]
10322    pub mContext: *mut ::std::os::raw::c_void,
10323}
10324impl Default for otUdpReceiver {
10325    fn default() -> Self {
10326        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10327        unsafe {
10328            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10329            s.assume_init()
10330        }
10331    }
10332}
10333extern "C" {
10334    #[doc = " Adds a UDP receiver.\n\n @param[in]   aInstance       A pointer to an OpenThread instance.\n @param[in]   aUdpReceiver    A pointer to the UDP receiver.\n\n @retval  OT_ERROR_NONE       The receiver is successfully added.\n @retval  OT_ERROR_ALREADY    The UDP receiver was already added."]
10335    pub fn otUdpAddReceiver(
10336        aInstance: *mut otInstance,
10337        aUdpReceiver: *mut otUdpReceiver,
10338    ) -> otError;
10339}
10340extern "C" {
10341    #[doc = " Removes a UDP receiver.\n\n @param[in]   aInstance       A pointer to an OpenThread instance.\n @param[in]   aUdpReceiver    A pointer to the UDP receiver.\n\n @retval  OT_ERROR_NONE       The receiver is successfully removed.\n @retval  OT_ERROR_NOT_FOUND  The UDP receiver was not added."]
10342    pub fn otUdpRemoveReceiver(
10343        aInstance: *mut otInstance,
10344        aUdpReceiver: *mut otUdpReceiver,
10345    ) -> otError;
10346}
10347extern "C" {
10348    #[doc = " Sends a UDP message without socket.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMessage      A pointer to a message without UDP header.\n @param[in]  aMessageInfo  A pointer to a message info associated with @p aMessage.\n\n @retval OT_ERROR_NONE          Successfully enqueued the message into an output interface.\n @retval OT_ERROR_NO_BUFS       Insufficient available buffer to add the IPv6 headers.\n @retval OT_ERROR_INVALID_ARGS  Invalid arguments are given."]
10349    pub fn otUdpSendDatagram(
10350        aInstance: *mut otInstance,
10351        aMessage: *mut otMessage,
10352        aMessageInfo: *mut otMessageInfo,
10353    ) -> otError;
10354}
10355#[doc = " This callback allows OpenThread to inform the application of a received UDP message."]
10356pub type otUdpReceive = ::std::option::Option<
10357    unsafe extern "C" fn(
10358        aContext: *mut ::std::os::raw::c_void,
10359        aMessage: *mut otMessage,
10360        aMessageInfo: *const otMessageInfo,
10361    ),
10362>;
10363#[doc = "< Unspecified network interface."]
10364pub const OT_NETIF_UNSPECIFIED: otNetifIdentifier = 0;
10365#[doc = "< The host Thread interface - allow use of platform UDP."]
10366pub const OT_NETIF_THREAD_HOST: otNetifIdentifier = 1;
10367#[doc = "< The internal Thread interface (within OpenThread) - do not use platform UDP."]
10368pub const OT_NETIF_THREAD_INTERNAL: otNetifIdentifier = 2;
10369#[doc = "< The Backbone interface."]
10370pub const OT_NETIF_BACKBONE: otNetifIdentifier = 3;
10371#[doc = " Defines the OpenThread network interface identifiers."]
10372pub type otNetifIdentifier = ::std::os::raw::c_uint;
10373#[doc = " Represents a UDP socket."]
10374#[repr(C)]
10375#[derive(Copy, Clone)]
10376pub struct otUdpSocket {
10377    #[doc = "< The local IPv6 socket address."]
10378    pub mSockName: otSockAddr,
10379    #[doc = "< The peer IPv6 socket address."]
10380    pub mPeerName: otSockAddr,
10381    #[doc = "< A function pointer to the application callback."]
10382    pub mHandler: otUdpReceive,
10383    #[doc = "< A pointer to application-specific context."]
10384    pub mContext: *mut ::std::os::raw::c_void,
10385    #[doc = "< A handle to platform's UDP."]
10386    pub mHandle: *mut ::std::os::raw::c_void,
10387    #[doc = "< A pointer to the next UDP socket (internal use only)."]
10388    pub mNext: *mut otUdpSocket,
10389    #[doc = "< The network interface identifier."]
10390    pub mNetifId: otNetifIdentifier,
10391}
10392impl Default for otUdpSocket {
10393    fn default() -> Self {
10394        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10395        unsafe {
10396            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10397            s.assume_init()
10398        }
10399    }
10400}
10401extern "C" {
10402    #[doc = " Allocate a new message buffer for sending a UDP message.\n\n @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSettings  A pointer to the message settings or NULL to use default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.\n\n @sa otMessageFree"]
10403    pub fn otUdpNewMessage(
10404        aInstance: *mut otInstance,
10405        aSettings: *const otMessageSettings,
10406    ) -> *mut otMessage;
10407}
10408extern "C" {
10409    #[doc = " Open a UDP/IPv6 socket.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSocket    A pointer to a UDP socket structure.\n @param[in]  aCallback  A pointer to the application callback function.\n @param[in]  aContext   A pointer to application-specific context.\n\n @retval OT_ERROR_NONE    Successfully opened the socket.\n @retval OT_ERROR_FAILED  Failed to open the socket."]
10410    pub fn otUdpOpen(
10411        aInstance: *mut otInstance,
10412        aSocket: *mut otUdpSocket,
10413        aCallback: otUdpReceive,
10414        aContext: *mut ::std::os::raw::c_void,
10415    ) -> otError;
10416}
10417extern "C" {
10418    #[doc = " Check if a UDP socket is open.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSocket    A pointer to a UDP socket structure.\n\n @returns Whether the UDP socket is open."]
10419    pub fn otUdpIsOpen(aInstance: *mut otInstance, aSocket: *const otUdpSocket) -> bool;
10420}
10421extern "C" {
10422    #[doc = " Close a UDP/IPv6 socket.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSocket    A pointer to a UDP socket structure.\n\n @retval OT_ERROR_NONE   Successfully closed the socket.\n @retval OT_ERROR_FAILED Failed to close UDP Socket."]
10423    pub fn otUdpClose(aInstance: *mut otInstance, aSocket: *mut otUdpSocket) -> otError;
10424}
10425extern "C" {
10426    #[doc = " Bind a UDP/IPv6 socket.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSocket    A pointer to a UDP socket structure.\n @param[in]  aSockName  A pointer to an IPv6 socket address structure.\n @param[in]  aNetif     The network interface to bind.\n\n @retval OT_ERROR_NONE   Bind operation was successful.\n @retval OT_ERROR_FAILED Failed to bind UDP socket."]
10427    pub fn otUdpBind(
10428        aInstance: *mut otInstance,
10429        aSocket: *mut otUdpSocket,
10430        aSockName: *const otSockAddr,
10431        aNetif: otNetifIdentifier,
10432    ) -> otError;
10433}
10434extern "C" {
10435    #[doc = " Connect a UDP/IPv6 socket.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aSocket    A pointer to a UDP socket structure.\n @param[in]  aSockName  A pointer to an IPv6 socket address structure.\n\n @retval OT_ERROR_NONE   Connect operation was successful.\n @retval OT_ERROR_FAILED Failed to connect UDP socket."]
10436    pub fn otUdpConnect(
10437        aInstance: *mut otInstance,
10438        aSocket: *mut otUdpSocket,
10439        aSockName: *const otSockAddr,
10440    ) -> otError;
10441}
10442extern "C" {
10443    #[doc = " Send a UDP/IPv6 message.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aSocket       A pointer to a UDP socket structure.\n @param[in]  aMessage      A pointer to a message buffer.\n @param[in]  aMessageInfo  A pointer to a message info structure.\n\n If the return value is OT_ERROR_NONE, OpenThread takes ownership of @p aMessage, and the caller should no longer\n reference @p aMessage. If the return value is not OT_ERROR_NONE, the caller retains ownership of @p aMessage,\n including freeing @p aMessage if the message buffer is no longer needed.\n\n @retval OT_ERROR_NONE           The message is successfully scheduled for sending.\n @retval OT_ERROR_INVALID_ARGS   Invalid arguments are given.\n @retval OT_ERROR_NO_BUFS        Insufficient available buffer to add the UDP and IPv6 headers."]
10444    pub fn otUdpSend(
10445        aInstance: *mut otInstance,
10446        aSocket: *mut otUdpSocket,
10447        aMessage: *mut otMessage,
10448        aMessageInfo: *const otMessageInfo,
10449    ) -> otError;
10450}
10451extern "C" {
10452    #[doc = " Gets the head of linked list of UDP Sockets.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the head of UDP Socket linked list."]
10453    pub fn otUdpGetSockets(aInstance: *mut otInstance) -> *mut otUdpSocket;
10454}
10455#[doc = " Pointer delivers the UDP packet to host and host should send the packet through its own network stack.\n\n @param[in]  aMessage   A pointer to the UDP Message.\n @param[in]  aPeerPort  The destination UDP port.\n @param[in]  aPeerAddr  A pointer to the destination IPv6 address.\n @param[in]  aSockPort  The source UDP port.\n @param[in]  aContext   A pointer to application-specific context."]
10456pub type otUdpForwarder = ::std::option::Option<
10457    unsafe extern "C" fn(
10458        aMessage: *mut otMessage,
10459        aPeerPort: u16,
10460        aPeerAddr: *mut otIp6Address,
10461        aSockPort: u16,
10462        aContext: *mut ::std::os::raw::c_void,
10463    ),
10464>;
10465extern "C" {
10466    #[doc = " Set UDP forward callback to deliver UDP packets to host.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aForwarder           A pointer to a function called to forward UDP packet to host.\n @param[in]  aContext             A pointer to application-specific context."]
10467    pub fn otUdpForwardSetForwarder(
10468        aInstance: *mut otInstance,
10469        aForwarder: otUdpForwarder,
10470        aContext: *mut ::std::os::raw::c_void,
10471    );
10472}
10473extern "C" {
10474    #[doc = " Handle a UDP packet received from host.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  aMessage             A pointer to the UDP Message.\n @param[in]  aPeerPort            The source UDP port.\n @param[in]  aPeerAddr            A pointer to the source address.\n @param[in]  aSockPort            The destination UDP port.\n\n @warning No matter the call success or fail, the message is freed."]
10475    pub fn otUdpForwardReceive(
10476        aInstance: *mut otInstance,
10477        aMessage: *mut otMessage,
10478        aPeerPort: u16,
10479        aPeerAddr: *const otIp6Address,
10480        aSockPort: u16,
10481    );
10482}
10483extern "C" {
10484    #[doc = " Determines if the given UDP port is exclusively opened by OpenThread API.\n\n @param[in]  aInstance            A pointer to an OpenThread instance.\n @param[in]  port                 UDP port number to verify.\n\n @retval true    The port is being used exclusively by OpenThread.\n @retval false   The port is not used by any of the OpenThread API or is shared (e.g. is Backbone socket)."]
10485    pub fn otUdpIsPortInUse(aInstance: *mut otInstance, port: u16) -> bool;
10486}
10487extern "C" {
10488    #[doc = " Initializes the UDP socket by platform.\n\n @param[in]   aUdpSocket  A pointer to the UDP socket.\n\n @retval  OT_ERROR_NONE   Successfully initialized UDP socket by platform.\n @retval  OT_ERROR_FAILED Failed to initialize UDP Socket."]
10489    pub fn otPlatUdpSocket(aUdpSocket: *mut otUdpSocket) -> otError;
10490}
10491extern "C" {
10492    #[doc = " Closes the UDP socket by platform.\n\n @param[in]   aUdpSocket  A pointer to the UDP socket.\n\n @retval  OT_ERROR_NONE   Successfully closed UDP socket by platform.\n @retval  OT_ERROR_FAILED Failed to close UDP Socket."]
10493    pub fn otPlatUdpClose(aUdpSocket: *mut otUdpSocket) -> otError;
10494}
10495extern "C" {
10496    #[doc = " Binds the UDP socket by platform.\n\n @param[in]   aUdpSocket  A pointer to the UDP socket.\n\n @retval  OT_ERROR_NONE   Successfully bound UDP socket by platform.\n @retval  OT_ERROR_FAILED Failed to bind UDP socket."]
10497    pub fn otPlatUdpBind(aUdpSocket: *mut otUdpSocket) -> otError;
10498}
10499extern "C" {
10500    #[doc = " Binds the UDP socket to a platform network interface.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in]   aUdpSocket          A pointer to the UDP socket.\n @param[in]   aNetifIdentifier    The network interface identifier.\n\n @retval  OT_ERROR_NONE   Successfully bound UDP socket.\n @retval  OT_ERROR_FAILED Failed to bind UDP."]
10501    pub fn otPlatUdpBindToNetif(
10502        aUdpSocket: *mut otUdpSocket,
10503        aNetifIdentifier: otNetifIdentifier,
10504    ) -> otError;
10505}
10506extern "C" {
10507    #[doc = " Connects UDP socket by platform.\n\n @param[in]   aUdpSocket  A pointer to the UDP socket.\n\n @retval  OT_ERROR_NONE   Successfully connected by platform.\n @retval  OT_ERROR_FAILED Failed to connect UDP socket."]
10508    pub fn otPlatUdpConnect(aUdpSocket: *mut otUdpSocket) -> otError;
10509}
10510extern "C" {
10511    #[doc = " Sends UDP payload by platform.\n\n @param[in]   aUdpSocket      A pointer to the UDP socket.\n @param[in]   aMessage        A pointer to the message to send.\n @param[in]   aMessageInfo    A pointer to the message info associated with @p aMessage.\n\n @retval  OT_ERROR_NONE   Successfully sent by platform, and @p aMessage is freed.\n @retval  OT_ERROR_FAILED Failed to bind UDP socket."]
10512    pub fn otPlatUdpSend(
10513        aUdpSocket: *mut otUdpSocket,
10514        aMessage: *mut otMessage,
10515        aMessageInfo: *const otMessageInfo,
10516    ) -> otError;
10517}
10518extern "C" {
10519    #[doc = " Configures the UDP socket to join a UDP multicast group.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in]   aUdpSocket          A pointer to the UDP socket.\n @param[in]   aNetifIdentifier    The network interface identifier.\n @param[in]   aAddress            The UDP multicast group address.\n\n @retval  OT_ERROR_NONE   Successfully joined the multicast group.\n @retval  OT_ERROR_FAILED Failed to join the multicast group."]
10520    pub fn otPlatUdpJoinMulticastGroup(
10521        aUdpSocket: *mut otUdpSocket,
10522        aNetifIdentifier: otNetifIdentifier,
10523        aAddress: *const otIp6Address,
10524    ) -> otError;
10525}
10526extern "C" {
10527    #[doc = " Configures the UDP socket to leave a UDP multicast group.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in]   aUdpSocket          A pointer to the UDP socket.\n @param[in]   aNetifIdentifier    The network interface identifier.\n @param[in]   aAddress            The UDP multicast group address.\n\n @retval  OT_ERROR_NONE   Successfully left the multicast group.\n @retval  OT_ERROR_FAILED Failed to leave the multicast group."]
10528    pub fn otPlatUdpLeaveMulticastGroup(
10529        aUdpSocket: *mut otUdpSocket,
10530        aNetifIdentifier: otNetifIdentifier,
10531        aAddress: *const otIp6Address,
10532    ) -> otError;
10533}
10534extern "C" {
10535    #[doc = " Generates and returns a random `uint32_t` value.\n\n @returns    A random `uint32_t` value."]
10536    pub fn otRandomNonCryptoGetUint32() -> u32;
10537}
10538extern "C" {
10539    #[doc = " Generates and returns a random byte.\n\n @returns A random `uint8_t` value."]
10540    pub fn otRandomNonCryptoGetUint8() -> u8;
10541}
10542extern "C" {
10543    #[doc = " Generates and returns a random `uint16_t` value.\n\n @returns A random `uint16_t` value."]
10544    pub fn otRandomNonCryptoGetUint16() -> u16;
10545}
10546extern "C" {
10547    #[doc = " Generates and returns a random `uint8_t` value within a given range `[aMin, aMax)`.\n\n @param[in]  aMin  A minimum value (this value can be included in returned random result).\n @param[in]  aMax  A maximum value (this value is excluded from returned random result).\n\n @returns    A random `uint8_t` value in the given range (i.e., aMin <= random value < aMax)."]
10548    pub fn otRandomNonCryptoGetUint8InRange(aMin: u8, aMax: u8) -> u8;
10549}
10550extern "C" {
10551    #[doc = " Generates and returns a random `uint16_t` value within a given range `[aMin, aMax)`.\n\n @note The returned random value can include the @p aMin value but excludes the @p aMax.\n\n @param[in]  aMin  A minimum value (this value can be included in returned random result).\n @param[in]  aMax  A maximum value (this value is excluded from returned random result).\n\n @returns    A random `uint16_t` value in the given range (i.e., aMin <= random value < aMax)."]
10552    pub fn otRandomNonCryptoGetUint16InRange(aMin: u16, aMax: u16) -> u16;
10553}
10554extern "C" {
10555    #[doc = " Generates and returns a random `uint32_t` value within a given range `[aMin, aMax)`.\n\n @note The returned random value can include the @p aMin value but excludes the @p aMax.\n\n @param[in]  aMin  A minimum value (this value can be included in returned random result).\n @param[in]  aMax  A maximum value (this value is excluded from returned random result).\n\n @returns    A random `uint32_t` value in the given range (i.e., aMin <= random value < aMax)."]
10556    pub fn otRandomNonCryptoGetUint32InRange(aMin: u32, aMax: u32) -> u32;
10557}
10558extern "C" {
10559    #[doc = " Fills a given buffer with random bytes.\n\n @param[out] aBuffer  A pointer to a buffer to fill with the random bytes.\n @param[in]  aSize    Size of buffer (number of bytes to fill)."]
10560    pub fn otRandomNonCryptoFillBuffer(aBuffer: *mut u8, aSize: u16);
10561}
10562extern "C" {
10563    #[doc = " Adds a random jitter within a given range to a given value.\n\n @param[in]  aValue     A value to which the random jitter is added.\n @param[in]  aJitter    Maximum jitter. Random jitter is selected from the range `[-aJitter, aJitter]`.\n\n @returns    The given value with an added random jitter."]
10564    pub fn otRandomNonCryptoAddJitter(aValue: u32, aJitter: u16) -> u32;
10565}
10566extern "C" {
10567    #[doc = " Provides a full or stable copy of the local Thread Network Data.\n\n @param[in]      aInstance    A pointer to an OpenThread instance.\n @param[in]      aStable      TRUE when copying the stable version, FALSE when copying the full version.\n @param[out]     aData        A pointer to the data buffer.\n @param[in,out]  aDataLength  On entry, size of the data buffer pointed to by @p aData.\n                              On exit, number of copied bytes."]
10568    pub fn otServerGetNetDataLocal(
10569        aInstance: *mut otInstance,
10570        aStable: bool,
10571        aData: *mut u8,
10572        aDataLength: *mut u8,
10573    ) -> otError;
10574}
10575extern "C" {
10576    #[doc = " Add a service configuration to the local network data.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aConfig   A pointer to the service configuration.\n\n @retval OT_ERROR_NONE          Successfully added the configuration to the local network data.\n @retval OT_ERROR_INVALID_ARGS  One or more configuration parameters were invalid.\n @retval OT_ERROR_NO_BUFS       Not enough room is available to add the configuration to the local network data.\n\n @sa otServerRemoveService\n @sa otServerRegister"]
10577    pub fn otServerAddService(
10578        aInstance: *mut otInstance,
10579        aConfig: *const otServiceConfig,
10580    ) -> otError;
10581}
10582extern "C" {
10583    #[doc = " Remove a service configuration from the local network data.\n\n @param[in]  aInstance          A pointer to an OpenThread instance.\n @param[in]  aEnterpriseNumber  Enterprise Number of the service entry to be deleted.\n @param[in]  aServiceData       A pointer to an Service Data to look for during deletion.\n @param[in]  aServiceDataLength The length of @p aServiceData in bytes.\n\n @retval OT_ERROR_NONE       Successfully removed the configuration from the local network data.\n @retval OT_ERROR_NOT_FOUND  Could not find the Border Router entry.\n\n @sa otServerAddService\n @sa otServerRegister"]
10584    pub fn otServerRemoveService(
10585        aInstance: *mut otInstance,
10586        aEnterpriseNumber: u32,
10587        aServiceData: *const u8,
10588        aServiceDataLength: u8,
10589    ) -> otError;
10590}
10591extern "C" {
10592    #[doc = " Gets the next service in the local Network Data.\n\n @param[in]      aInstance  A pointer to an OpenThread instance.\n @param[in,out]  aIterator  A pointer to the Network Data iterator context. To get the first service entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out]     aConfig    A pointer to where the service information will be placed.\n\n @retval OT_ERROR_NONE       Successfully found the next service.\n @retval OT_ERROR_NOT_FOUND  No subsequent service exists in the Thread Network Data."]
10593    pub fn otServerGetNextService(
10594        aInstance: *mut otInstance,
10595        aIterator: *mut otNetworkDataIterator,
10596        aConfig: *mut otServiceConfig,
10597    ) -> otError;
10598}
10599extern "C" {
10600    #[doc = " Immediately register the local network data with the Leader.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE  Successfully queued a Server Data Request message for delivery.\n\n @sa otServerAddService\n @sa otServerRemoveService"]
10601    pub fn otServerRegister(aInstance: *mut otInstance) -> otError;
10602}
10603#[doc = " Implements SNTP Query parameters."]
10604#[repr(C)]
10605#[derive(Debug, Copy, Clone)]
10606pub struct otSntpQuery {
10607    #[doc = "< A reference to the message info related with SNTP Server."]
10608    pub mMessageInfo: *const otMessageInfo,
10609}
10610impl Default for otSntpQuery {
10611    fn default() -> Self {
10612        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10613        unsafe {
10614            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10615            s.assume_init()
10616        }
10617    }
10618}
10619#[doc = " Pointer is called when a SNTP response is received.\n\n @param[in]  aContext   A pointer to application-specific context.\n @param[in]  aTime      Specifies the time at the server when the response left for the client, in UNIX time.\n @param[in]  aResult    A result of the SNTP transaction.\n\n @retval  OT_ERROR_NONE              A response was received successfully and time is provided\n                                     in @p aTime.\n @retval  OT_ERROR_ABORT             A SNTP transaction was aborted by stack.\n @retval  OT_ERROR_BUSY              The Kiss-o'-death packet has been received.\n @retval  OT_ERROR_RESPONSE_TIMEOUT  No SNTP response has been received within timeout.\n @retval  OT_ERROR_FAILED            A response was received but contains incorrect data."]
10620pub type otSntpResponseHandler = ::std::option::Option<
10621    unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void, aTime: u64, aResult: otError),
10622>;
10623extern "C" {
10624    #[doc = " Sends a SNTP query.\n\n Is available only if feature `OPENTHREAD_CONFIG_SNTP_CLIENT_ENABLE` is enabled.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aQuery      A pointer to specify SNTP query parameters.\n @param[in]  aHandler    A function pointer that shall be called on response reception or time-out.\n @param[in]  aContext    A pointer to arbitrary context information."]
10625    pub fn otSntpClientQuery(
10626        aInstance: *mut otInstance,
10627        aQuery: *const otSntpQuery,
10628        aHandler: otSntpResponseHandler,
10629        aContext: *mut ::std::os::raw::c_void,
10630    ) -> otError;
10631}
10632extern "C" {
10633    #[doc = " Sets the unix era number.\n\n The default value of unix era is set to 0. The subsequent eras start after year 2106.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aUnixEra    Unix era number."]
10634    pub fn otSntpClientSetUnixEra(aInstance: *mut otInstance, aUnixEra: u32);
10635}
10636#[doc = "< Item to be added/registered."]
10637pub const OT_SRP_CLIENT_ITEM_STATE_TO_ADD: otSrpClientItemState = 0;
10638#[doc = "< Item is being added/registered."]
10639pub const OT_SRP_CLIENT_ITEM_STATE_ADDING: otSrpClientItemState = 1;
10640#[doc = "< Item to be refreshed (re-register to renew lease)."]
10641pub const OT_SRP_CLIENT_ITEM_STATE_TO_REFRESH: otSrpClientItemState = 2;
10642#[doc = "< Item is being refreshed."]
10643pub const OT_SRP_CLIENT_ITEM_STATE_REFRESHING: otSrpClientItemState = 3;
10644#[doc = "< Item to be removed."]
10645pub const OT_SRP_CLIENT_ITEM_STATE_TO_REMOVE: otSrpClientItemState = 4;
10646#[doc = "< Item is being removed."]
10647pub const OT_SRP_CLIENT_ITEM_STATE_REMOVING: otSrpClientItemState = 5;
10648#[doc = "< Item is registered with server."]
10649pub const OT_SRP_CLIENT_ITEM_STATE_REGISTERED: otSrpClientItemState = 6;
10650#[doc = "< Item is removed."]
10651pub const OT_SRP_CLIENT_ITEM_STATE_REMOVED: otSrpClientItemState = 7;
10652#[doc = " Specifies an SRP client item (service or host info) state."]
10653pub type otSrpClientItemState = ::std::os::raw::c_uint;
10654#[doc = " Represents an SRP client host info."]
10655#[repr(C)]
10656#[derive(Debug, Copy, Clone)]
10657pub struct otSrpClientHostInfo {
10658    #[doc = "< Host name (label) string (NULL if not yet set)."]
10659    pub mName: *const ::std::os::raw::c_char,
10660    #[doc = "< Array of host IPv6 addresses (NULL if not set or auto address is enabled)."]
10661    pub mAddresses: *const otIp6Address,
10662    #[doc = "< Number of IPv6 addresses in `mAddresses` array."]
10663    pub mNumAddresses: u8,
10664    #[doc = "< Indicates whether auto address mode is enabled or not."]
10665    pub mAutoAddress: bool,
10666    #[doc = "< Host info state."]
10667    pub mState: otSrpClientItemState,
10668}
10669impl Default for otSrpClientHostInfo {
10670    fn default() -> Self {
10671        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10672        unsafe {
10673            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10674            s.assume_init()
10675        }
10676    }
10677}
10678#[doc = " Represents an SRP client service.\n\n The values in this structure, including the string buffers for the names and the TXT record entries, MUST persist\n and stay constant after an instance of this structure is passed to OpenThread from `otSrpClientAddService()` or\n `otSrpClientRemoveService()`.\n\n The `mState`, `mData`, `mNext` fields are used/managed by OT core only. Their value is ignored when an instance of\n `otSrpClientService` is passed in `otSrpClientAddService()` or `otSrpClientRemoveService()` or other functions. The\n caller does not need to set these fields.\n\n The `mLease` and `mKeyLease` fields specify the desired lease and key lease intervals for this service. Zero value\n indicates that the interval is unspecified and then the default lease or key lease intervals from\n `otSrpClientGetLeaseInterval()` and `otSrpClientGetKeyLeaseInterval()` are used for this service. If the key lease\n interval (whether set explicitly or determined from the default) is shorter than the lease interval for a service,\n SRP client will re-use the lease interval value for key lease interval as well. For example, if in service `mLease`\n is explicitly set to 2 days and `mKeyLease` is set to zero and default key lease is set to 1 day, then when\n registering this service, the requested key lease for this service is also set to 2 days."]
10679#[repr(C)]
10680#[derive(Debug, Copy, Clone)]
10681pub struct otSrpClientService {
10682    #[doc = "< The service labels (e.g., \"_mt._udp\", not the full domain name)."]
10683    pub mName: *const ::std::os::raw::c_char,
10684    #[doc = "< The service instance name label (not the full name)."]
10685    pub mInstanceName: *const ::std::os::raw::c_char,
10686    #[doc = "< Array of sub-type labels (must end with `NULL` or can be `NULL`)."]
10687    pub mSubTypeLabels: *const *const ::std::os::raw::c_char,
10688    #[doc = "< Array of TXT entries (`mNumTxtEntries` gives num of entries)."]
10689    pub mTxtEntries: *const otDnsTxtEntry,
10690    #[doc = "< The service port number."]
10691    pub mPort: u16,
10692    #[doc = "< The service priority."]
10693    pub mPriority: u16,
10694    #[doc = "< The service weight."]
10695    pub mWeight: u16,
10696    #[doc = "< Number of entries in the `mTxtEntries` array."]
10697    pub mNumTxtEntries: u8,
10698    #[doc = "< Service state (managed by OT core)."]
10699    pub mState: otSrpClientItemState,
10700    #[doc = "< Internal data (used by OT core)."]
10701    pub mData: u32,
10702    #[doc = "< Pointer to next entry in a linked-list (managed by OT core)."]
10703    pub mNext: *mut otSrpClientService,
10704    #[doc = "< Desired lease interval in sec - zero to use default."]
10705    pub mLease: u32,
10706    #[doc = "< Desired key lease interval in sec - zero to use default."]
10707    pub mKeyLease: u32,
10708}
10709impl Default for otSrpClientService {
10710    fn default() -> Self {
10711        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10712        unsafe {
10713            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10714            s.assume_init()
10715        }
10716    }
10717}
10718#[doc = " Pointer type defines the callback used by SRP client to notify user of changes/events/errors.\n\n This callback is invoked on a successful registration of an update (i.e., add/remove of host-info and/or some\n service(s)) with the SRP server, or if there is a failure or error (e.g., server rejects a update request or client\n times out waiting for response, etc).\n\n In case of a successful reregistration of an update, `aError` parameter would be `OT_ERROR_NONE` and the host info\n and the full list of services is provided as input parameters to the callback. Note that host info and services each\n track its own state in the corresponding `mState` member variable of the related data structure (the state\n indicating whether the host-info/service is registered or removed or still being added/removed, etc).\n\n The list of removed services is passed as its own linked-list `aRemovedServices` in the callback. Note that when the\n callback is invoked, the SRP client (OpenThread implementation) is done with the removed service instances listed in\n `aRemovedServices` and no longer tracks/stores them (i.e., if from the callback we call `otSrpClientGetServices()`\n the removed services will not be present in the returned list). Providing a separate list of removed services in\n the callback helps indicate to user which items are now removed and allow user to re-claim/reuse the instances.\n\n If the server rejects an SRP update request, the DNS response code (RFC 2136) is mapped to the following errors:\n\n  - (0)  NOERROR   Success (no error condition)                    -> OT_ERROR_NONE\n  - (1)  FORMERR   Server unable to interpret due to format error  -> OT_ERROR_PARSE\n  - (2)  SERVFAIL  Server encountered an internal failure          -> OT_ERROR_FAILED\n  - (3)  NXDOMAIN  Name that ought to exist, does not exist        -> OT_ERROR_NOT_FOUND\n  - (4)  NOTIMP    Server does not support the query type (OpCode) -> OT_ERROR_NOT_IMPLEMENTED\n  - (5)  REFUSED   Server refused for policy/security reasons      -> OT_ERROR_SECURITY\n  - (6)  YXDOMAIN  Some name that ought not to exist, does exist   -> OT_ERROR_DUPLICATED\n  - (7)  YXRRSET   Some RRset that ought not to exist, does exist  -> OT_ERROR_DUPLICATED\n  - (8)  NXRRSET   Some RRset that ought to exist, does not exist  -> OT_ERROR_NOT_FOUND\n  - (9)  NOTAUTH   Service is not authoritative for zone           -> OT_ERROR_SECURITY\n  - (10) NOTZONE   A name is not in the zone                       -> OT_ERROR_PARSE\n  - (20) BADNAME   Bad name                                        -> OT_ERROR_PARSE\n  - (21) BADALG    Bad algorithm                                   -> OT_ERROR_SECURITY\n  - (22) BADTRUN   Bad truncation                                  -> OT_ERROR_PARSE\n  - Other response codes                                           -> OT_ERROR_FAILED\n\n The following errors are also possible:\n\n  - OT_ERROR_RESPONSE_TIMEOUT : Timed out waiting for response from server (client would continue to retry).\n  - OT_ERROR_INVALID_ARGS     : The provided service structure is invalid (e.g., bad service name or `otDnsTxtEntry`).\n  - OT_ERROR_NO_BUFS          : Insufficient buffer to prepare or send the update message.\n\n Note that in case of any failure, the client continues the operation, i.e. it prepares and (re)transmits the SRP\n update message to the server, after some wait interval. The retry wait interval starts from the minimum value and\n is increased by the growth factor every failure up to the max value (please see configuration parameter\n `OPENTHREAD_CONFIG_SRP_CLIENT_MIN_RETRY_WAIT_INTERVAL` and the related ones for more details).\n\n @param[in] aError            The error (see above).\n @param[in] aHostInfo         A pointer to host info.\n @param[in] aServices         The head of linked-list containing all services (excluding the ones removed). NULL if\n                              the list is empty.\n @param[in] aRemovedServices  The head of linked-list containing all removed services. NULL if the list is empty.\n @param[in] aContext          A pointer to an arbitrary context (provided when callback was registered)."]
10719pub type otSrpClientCallback = ::std::option::Option<
10720    unsafe extern "C" fn(
10721        aError: otError,
10722        aHostInfo: *const otSrpClientHostInfo,
10723        aServices: *const otSrpClientService,
10724        aRemovedServices: *const otSrpClientService,
10725        aContext: *mut ::std::os::raw::c_void,
10726    ),
10727>;
10728#[doc = " Pointer type defines the callback used by SRP client to notify user when it is auto-started or stopped.\n\n This is only used when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n This callback is invoked when auto-start mode is enabled and the SRP client is either automatically started or\n stopped.\n\n @param[in] aServerSockAddr   A non-NULL pointer indicates SRP server was started and pointer will give the\n                              selected server socket address. A NULL pointer indicates SRP server was stopped.\n @param[in] aContext          A pointer to an arbitrary context (provided when callback was registered)."]
10729pub type otSrpClientAutoStartCallback = ::std::option::Option<
10730    unsafe extern "C" fn(aServerSockAddr: *const otSockAddr, aContext: *mut ::std::os::raw::c_void),
10731>;
10732extern "C" {
10733    #[doc = " Starts the SRP client operation.\n\n SRP client will prepare and send \"SRP Update\" message to the SRP server once all the following conditions are met:\n\n  - The SRP client is started - `otSrpClientStart()` is called.\n  - Host name is set - `otSrpClientSetHostName()` is called.\n  - At least one host IPv6 address is set - `otSrpClientSetHostAddresses()` is called.\n  - At least one service is added - `otSrpClientAddService()` is called.\n\n It does not matter in which order these functions are called. When all conditions are met, the SRP client will\n wait for a short delay before preparing an \"SRP Update\" message and sending it to server. This delay allows for user\n to add multiple services and/or IPv6 addresses before the first SRP Update message is sent (ensuring a single SRP\n Update is sent containing all the info). The config `OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_DELAY` specifies the\n delay interval.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n @param[in] aServerSockAddr  The socket address (IPv6 address and port number) of the SRP server.\n\n @retval OT_ERROR_NONE       SRP client operation started successfully or it is already running with same server\n                             socket address and callback.\n @retval OT_ERROR_BUSY       SRP client is busy running with a different socket address.\n @retval OT_ERROR_FAILED     Failed to open/connect the client's UDP socket."]
10734    pub fn otSrpClientStart(
10735        aInstance: *mut otInstance,
10736        aServerSockAddr: *const otSockAddr,
10737    ) -> otError;
10738}
10739extern "C" {
10740    #[doc = " Stops the SRP client operation.\n\n Stops any further interactions with the SRP server. Note that it does not remove or clear host info\n and/or list of services. It marks all services to be added/removed again once the client is (re)started.\n\n @param[in] aInstance       A pointer to the OpenThread instance."]
10741    pub fn otSrpClientStop(aInstance: *mut otInstance);
10742}
10743extern "C" {
10744    #[doc = " Indicates whether the SRP client is running or not.\n\n @param[in] aInstance       A pointer to the OpenThread instance.\n\n @returns TRUE if the SRP client is running, FALSE otherwise."]
10745    pub fn otSrpClientIsRunning(aInstance: *mut otInstance) -> bool;
10746}
10747extern "C" {
10748    #[doc = " Gets the socket address (IPv6 address and port number) of the SRP server which is being used by SRP\n client.\n\n If the client is not running, the address is unspecified (all zero) with zero port number.\n\n @param[in] aInstance       A pointer to the OpenThread instance.\n\n @returns A pointer to the SRP server's socket address (is always non-NULL)."]
10749    pub fn otSrpClientGetServerAddress(aInstance: *mut otInstance) -> *const otSockAddr;
10750}
10751extern "C" {
10752    #[doc = " Sets the callback to notify caller of events/changes from SRP client.\n\n The SRP client allows a single callback to be registered. So consecutive calls to this function will overwrite any\n previously set callback functions.\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aCallback   The callback to notify of events and changes. Can be NULL if not needed.\n @param[in] aContext    An arbitrary context used with @p aCallback."]
10753    pub fn otSrpClientSetCallback(
10754        aInstance: *mut otInstance,
10755        aCallback: otSrpClientCallback,
10756        aContext: *mut ::std::os::raw::c_void,
10757    );
10758}
10759extern "C" {
10760    #[doc = " Enables the auto-start mode.\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n Config option `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_DEFAULT_MODE` specifies the default auto-start mode (whether\n it is enabled or disabled at the start of OT stack).\n\n When auto-start is enabled, the SRP client will monitor the Thread Network Data to discover SRP servers and select\n the preferred server and automatically start and stop the client when an SRP server is detected.\n\n There are three categories of Network Data entries indicating presence of SRP sever. They are preferred in the\n following order:\n\n   1) Preferred unicast entries where server address is included in the service data. If there are multiple options,\n      the one with numerically lowest IPv6 address is preferred.\n\n   2) Anycast entries each having a seq number. A larger sequence number in the sense specified by Serial Number\n      Arithmetic logic in RFC-1982 is considered more recent and therefore preferred. The largest seq number using\n      serial number arithmetic is preferred if it is well-defined (i.e., the seq number is larger than all other\n      seq numbers). If it is not well-defined, then the numerically largest seq number is preferred.\n\n   3) Unicast entries where the server address info is included in server data. If there are multiple options, the\n      one with numerically lowest IPv6 address is preferred.\n\n When there is a change in the Network Data entries, client will check that the currently selected server is still\n present in the Network Data and is still the preferred one. Otherwise the client will switch to the new preferred\n server or stop if there is none.\n\n When the SRP client is explicitly started through a successful call to `otSrpClientStart()`, the given SRP server\n address in `otSrpClientStart()` will continue to be used regardless of the state of auto-start mode and whether the\n same SRP server address is discovered or not in the Thread Network Data. In this case, only an explicit\n `otSrpClientStop()` call will stop the client.\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aCallback   A callback to notify when client is auto-started/stopped. Can be NULL if not needed.\n @param[in] aContext    A context to be passed when invoking @p aCallback."]
10761    pub fn otSrpClientEnableAutoStartMode(
10762        aInstance: *mut otInstance,
10763        aCallback: otSrpClientAutoStartCallback,
10764        aContext: *mut ::std::os::raw::c_void,
10765    );
10766}
10767extern "C" {
10768    #[doc = " Disables the auto-start mode.\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n Disabling the auto-start mode will not stop the client if it is already running but the client stops monitoring\n the Thread Network Data to verify that the selected SRP server is still present in it.\n\n Note that a call to `otSrpClientStop()` will also disable the auto-start mode.\n\n @param[in] aInstance   A pointer to the OpenThread instance."]
10769    pub fn otSrpClientDisableAutoStartMode(aInstance: *mut otInstance);
10770}
10771extern "C" {
10772    #[doc = " Indicates the current state of auto-start mode (enabled or disabled).\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n\n @returns TRUE if the auto-start mode is enabled, FALSE otherwise."]
10773    pub fn otSrpClientIsAutoStartModeEnabled(aInstance: *mut otInstance) -> bool;
10774}
10775extern "C" {
10776    #[doc = " Gets the TTL value in every record included in SRP update requests.\n\n Note that this is the TTL requested by the SRP client. The server may choose to accept a different TTL.\n\n By default, the TTL will equal the lease interval. Passing 0 or a value larger than the lease interval via\n `otSrpClientSetTtl()` will also cause the TTL to equal the lease interval.\n\n @param[in] aInstance  A pointer to the OpenThread instance.\n\n @returns The TTL (in seconds)."]
10777    pub fn otSrpClientGetTtl(aInstance: *mut otInstance) -> u32;
10778}
10779extern "C" {
10780    #[doc = " Sets the TTL value in every record included in SRP update requests.\n\n Changing the TTL does not impact the TTL of already registered services/host-info.\n It only affects future SRP update messages (i.e., adding new services and/or refreshes of the existing services).\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aTtl        The TTL (in seconds). If value is zero or greater than lease interval, the TTL is set to the\n                        lease interval."]
10781    pub fn otSrpClientSetTtl(aInstance: *mut otInstance, aTtl: u32);
10782}
10783extern "C" {
10784    #[doc = " Gets the default lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mLease` set to zero.\n\n Note that this is the lease duration requested by the SRP client. The server may choose to accept a different lease\n interval.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n\n @returns The lease interval (in seconds)."]
10785    pub fn otSrpClientGetLeaseInterval(aInstance: *mut otInstance) -> u32;
10786}
10787extern "C" {
10788    #[doc = " Sets the default lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mLease` set to zero.\n\n Changing the lease interval does not impact the accepted lease interval of already registered services/host-info.\n It only affects any future SRP update messages (i.e., adding new services and/or refreshes of the existing services).\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aInterval   The lease interval (in seconds). If zero, the default value specified by\n                        `OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_LEASE` would be used."]
10789    pub fn otSrpClientSetLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
10790}
10791extern "C" {
10792    #[doc = " Gets the default key lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mKeyLease` set to zero.\n\n Note that this is the lease duration requested by the SRP client. The server may choose to accept a different lease\n interval.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n\n @returns The key lease interval (in seconds)."]
10793    pub fn otSrpClientGetKeyLeaseInterval(aInstance: *mut otInstance) -> u32;
10794}
10795extern "C" {
10796    #[doc = " Sets the default key lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mKeyLease` set to zero.\n\n Changing the lease interval does not impact the accepted lease interval of already registered services/host-info.\n It only affects any future SRP update messages (i.e., adding new services and/or refreshes of existing services).\n\n @param[in] aInstance    A pointer to the OpenThread instance.\n @param[in] aInterval    The key lease interval (in seconds). If zero, the default value specified by\n                         `OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_KEY_LEASE` would be used."]
10797    pub fn otSrpClientSetKeyLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
10798}
10799extern "C" {
10800    #[doc = " Gets the host info.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n\n @returns A pointer to host info structure."]
10801    pub fn otSrpClientGetHostInfo(aInstance: *mut otInstance) -> *const otSrpClientHostInfo;
10802}
10803extern "C" {
10804    #[doc = " Sets the host name label.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of host info\n registration with SRP server.\n\n The name string buffer pointed to by @p aName MUST persist and stay unchanged after returning from this function.\n OpenThread will keep the pointer to the string.\n\n The host name can be set before client is started or after start but before host info is registered with server\n (host info should be in either `STATE_TO_ADD` or `STATE_REMOVED`).\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aName       A pointer to host name label string (MUST NOT be NULL). Pointer to the string buffer MUST\n                        persist and remain valid and constant after return from this function.\n\n @retval OT_ERROR_NONE            The host name label was set successfully.\n @retval OT_ERROR_INVALID_ARGS    The @p aName is NULL.\n @retval OT_ERROR_INVALID_STATE   The host name is already set and registered with the server."]
10805    pub fn otSrpClientSetHostName(
10806        aInstance: *mut otInstance,
10807        aName: *const ::std::os::raw::c_char,
10808    ) -> otError;
10809}
10810extern "C" {
10811    #[doc = " Enables auto host address mode.\n\n When enabled host IPv6 addresses are automatically set by SRP client using all the preferred unicast addresses on\n Thread netif excluding all link-local and mesh-local addresses. If there is no preferred address, then Mesh Local\n EID address is added. The SRP client will automatically re-register when/if addresses on Thread netif are updated\n (new addresses are added or existing addresses are removed or marked as non-preferred).\n\n The auto host address mode can be enabled before start or during operation of SRP client except when the host info\n is being removed (client is busy handling a remove request from an call to `otSrpClientRemoveHostAndServices()` and\n host info still being in  either `STATE_TO_REMOVE` or `STATE_REMOVING` states).\n\n After auto host address mode is enabled, it can be disabled by a call to `otSrpClientSetHostAddresses()` which\n then explicitly sets the host addresses.\n\n @retval OT_ERROR_NONE            Successfully enabled auto host address mode.\n @retval OT_ERROR_INVALID_STATE   Host is being removed and therefore cannot enable auto host address mode."]
10812    pub fn otSrpClientEnableAutoHostAddress(aInstance: *mut otInstance) -> otError;
10813}
10814extern "C" {
10815    #[doc = " Sets/updates the list of host IPv6 address.\n\n Host IPv6 addresses can be set/changed before start or during operation of SRP client (e.g. to add/remove or change\n a previously registered host address), except when the host info is being removed (client is busy handling a remove\n request from an earlier call to `otSrpClientRemoveHostAndServices()` and host info still being in  either\n `STATE_TO_REMOVE` or `STATE_REMOVING` states).\n\n The host IPv6 address array pointed to by @p aIp6Addresses MUST persist and remain unchanged after returning from\n this function (with `OT_ERROR_NONE`). OpenThread will save the pointer to the array.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of the address\n registration with SRP server.\n\n Calling this function disables auto host address mode if it was previously enabled from a successful call to\n `otSrpClientEnableAutoHostAddress()`.\n\n @param[in] aInstance           A pointer to the OpenThread instance.\n @param[in] aIp6Addresses       A pointer to the an array containing the host IPv6 addresses.\n @param[in] aNumAddresses       The number of addresses in the @p aIp6Addresses array.\n\n @retval OT_ERROR_NONE            The host IPv6 address list change started successfully. The `otSrpClientCallback`\n                                  will be called to report the status of registering addresses with server.\n @retval OT_ERROR_INVALID_ARGS    The address list is invalid (e.g., must contain at least one address).\n @retval OT_ERROR_INVALID_STATE   Host is being removed and therefore cannot change host address."]
10816    pub fn otSrpClientSetHostAddresses(
10817        aInstance: *mut otInstance,
10818        aIp6Addresses: *const otIp6Address,
10819        aNumAddresses: u8,
10820    ) -> otError;
10821}
10822extern "C" {
10823    #[doc = " Adds a service to be registered with server.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of the service\n addition/registration with SRP server.\n\n The `otSrpClientService` instance being pointed to by @p aService MUST persist and remain unchanged after returning\n from this function (with `OT_ERROR_NONE`). OpenThread will save the pointer to the service instance.\n\n The `otSrpClientService` instance is not longer tracked by OpenThread and can be reclaimed only when\n\n  -  It is removed explicitly by a call to `otSrpClientRemoveService()` or removed along with other services by a\n     call to `otSrpClientRemoveHostAndServices() and only after the `otSrpClientCallback` is called indicating the\n     service was removed. Or,\n  -  A call to `otSrpClientClearHostAndServices()` which removes the host and all related services immediately.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n @param[in] aService         A pointer to a `otSrpClientService` instance to add.\n\n @retval OT_ERROR_NONE          The addition of service started successfully. The `otSrpClientCallback` will be\n                                called to report the status.\n @retval OT_ERROR_ALREADY       A service with the same service and instance names is already in the list.\n @retval OT_ERROR_INVALID_ARGS  The service structure is invalid (e.g., bad service name or `otDnsTxtEntry`)."]
10824    pub fn otSrpClientAddService(
10825        aInstance: *mut otInstance,
10826        aService: *mut otSrpClientService,
10827    ) -> otError;
10828}
10829extern "C" {
10830    #[doc = " Requests a service to be unregistered with server.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of remove\n request with SRP server.\n\n The `otSrpClientService` instance being pointed to by @p aService MUST persist and remain unchanged after returning\n from this function (with `OT_ERROR_NONE`). OpenThread will keep the service instance during the remove process.\n Only after the `otSrpClientCallback` is called indicating the service instance is removed from SRP client\n service list and can be be freed/reused.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n @param[in] aService         A pointer to a `otSrpClientService` instance to remove.\n\n @retval OT_ERROR_NONE       The removal of service started successfully. The `otSrpClientCallback` will be called to\n                             report the status.\n @retval OT_ERROR_NOT_FOUND  The service could not be found in the list."]
10831    pub fn otSrpClientRemoveService(
10832        aInstance: *mut otInstance,
10833        aService: *mut otSrpClientService,
10834    ) -> otError;
10835}
10836extern "C" {
10837    #[doc = " Clears a service, immediately removing it from the client service list.\n\n Unlike `otSrpClientRemoveService()` which sends an update message to the server to remove the service, this function\n clears the service from the client's service list without any interaction with the server. On a successful call to\n this function, the `otSrpClientCallback` will NOT be called and the @p aService entry can be reclaimed and re-used\n by the caller immediately.\n\n Can be used along with a subsequent call to `otSrpClientAddService()` (potentially reusing the same @p\n aService entry with the same service and instance names) to update some of the parameters in an existing service.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n @param[in] aService         A pointer to a `otSrpClientService` instance to delete.\n\n @retval OT_ERROR_NONE       The @p aService is deleted successfully. It can be reclaimed and re-used immediately.\n @retval OT_ERROR_NOT_FOUND  The service could not be found in the list."]
10838    pub fn otSrpClientClearService(
10839        aInstance: *mut otInstance,
10840        aService: *mut otSrpClientService,
10841    ) -> otError;
10842}
10843extern "C" {
10844    #[doc = " Gets the list of services being managed by client.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n\n @returns A pointer to the head of linked-list of all services or NULL if the list is empty."]
10845    pub fn otSrpClientGetServices(aInstance: *mut otInstance) -> *const otSrpClientService;
10846}
10847extern "C" {
10848    #[doc = " Starts the remove process of the host info and all services.\n\n After returning from this function, `otSrpClientCallback` will be called to report the status of remove request with\n SRP server.\n\n If the host info is to be permanently removed from server, @p aRemoveKeyLease should be set to `true` which removes\n the key lease associated with host on server. Otherwise, the key lease record is kept as before, which ensures\n that the server holds the host name in reserve for when the client is once again able to provide and register its\n service(s).\n\n The @p aSendUnregToServer determines the behavior when the host info is not yet registered with the server. If\n @p aSendUnregToServer is set to `false` (which is the default/expected value) then the SRP client will immediately\n remove the host info and services without sending an update message to server (no need to update the server if\n nothing is yet registered with it). If @p aSendUnregToServer is set to `true` then the SRP client will send an\n update message to the server. Note that if the host info is registered then the value of @p aSendUnregToServer does\n not matter and the SRP client will always send an update message to server requesting removal of all info.\n\n One situation where @p aSendUnregToServer can be useful is on a device reset/reboot, caller may want to remove any\n previously registered services with the server. In this case, caller can `otSrpClientSetHostName()` and then request\n `otSrpClientRemoveHostAndServices()` with `aSendUnregToServer` as `true`.\n\n @param[in] aInstance          A pointer to the OpenThread instance.\n @param[in] aRemoveKeyLease    A boolean indicating whether or not the host key lease should also be removed.\n @param[in] aSendUnregToServer A boolean indicating whether to send update to server when host info is not registered.\n\n @retval OT_ERROR_NONE       The removal of host info and services started successfully. The `otSrpClientCallback`\n                             will be called to report the status.\n @retval OT_ERROR_ALREADY    The host info is already removed."]
10849    pub fn otSrpClientRemoveHostAndServices(
10850        aInstance: *mut otInstance,
10851        aRemoveKeyLease: bool,
10852        aSendUnregToServer: bool,
10853    ) -> otError;
10854}
10855extern "C" {
10856    #[doc = " Clears all host info and all the services.\n\n Unlike `otSrpClientRemoveHostAndServices()` which sends an update message to the server to remove all the info, this\n function clears all the info immediately without any interaction with the server.\n\n @param[in] aInstance        A pointer to the OpenThread instance."]
10857    pub fn otSrpClientClearHostAndServices(aInstance: *mut otInstance);
10858}
10859extern "C" {
10860    #[doc = " Gets the domain name being used by SRP client.\n\n Requires `OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE` to be enabled.\n\n If domain name is not set, \"default.service.arpa\" will be used.\n\n @param[in] aInstance        A pointer to the OpenThread instance.\n\n @returns The domain name string."]
10861    pub fn otSrpClientGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
10862}
10863extern "C" {
10864    #[doc = " Sets the domain name to be used by SRP client.\n\n Requires `OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE` to be enabled.\n\n If not set \"default.service.arpa\" will be used.\n\n The name string buffer pointed to by @p aName MUST persist and stay unchanged after returning from this function.\n OpenThread will keep the pointer to the string.\n\n The domain name can be set before client is started or after start but before host info is registered with server\n (host info should be in either `STATE_TO_ADD` or `STATE_TO_REMOVE`).\n\n @param[in] aInstance     A pointer to the OpenThread instance.\n @param[in] aName         A pointer to the domain name string. If NULL sets it to default \"default.service.arpa\".\n\n @retval OT_ERROR_NONE            The domain name label was set successfully.\n @retval OT_ERROR_INVALID_STATE   The host info is already registered with server."]
10865    pub fn otSrpClientSetDomainName(
10866        aInstance: *mut otInstance,
10867        aName: *const ::std::os::raw::c_char,
10868    ) -> otError;
10869}
10870extern "C" {
10871    #[doc = " Converts a `otSrpClientItemState` to a string.\n\n @param[in] aItemState  An item state.\n\n @returns A string representation of @p aItemState."]
10872    pub fn otSrpClientItemStateToString(
10873        aItemState: otSrpClientItemState,
10874    ) -> *const ::std::os::raw::c_char;
10875}
10876extern "C" {
10877    #[doc = " Enables/disables \"service key record inclusion\" mode.\n\n When enabled, SRP client will include KEY record in Service Description Instructions in the SRP update messages\n that it sends.\n\n Is available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` configuration is enabled.\n\n @note KEY record is optional in Service Description Instruction (it is required and always included in the Host\n Description Instruction). The default behavior of SRP client is to not include it. This function is intended to\n override the default behavior for testing only.\n\n @param[in] aInstance  A pointer to the OpenThread instance.\n @param[in] aEnabled   TRUE to enable, FALSE to disable the \"service key record inclusion\" mode."]
10878    pub fn otSrpClientSetServiceKeyRecordEnabled(aInstance: *mut otInstance, aEnabled: bool);
10879}
10880extern "C" {
10881    #[doc = " Indicates whether the \"service key record inclusion\" mode is enabled or disabled.\n\n Is available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` configuration is enabled.\n\n @param[in] aInstance     A pointer to the OpenThread instance.\n\n @returns TRUE if \"service key record inclusion\" mode is enabled, FALSE otherwise."]
10882    pub fn otSrpClientIsServiceKeyRecordEnabled(aInstance: *mut otInstance) -> bool;
10883}
10884#[doc = " Represents a SRP client service pool entry."]
10885#[repr(C)]
10886#[derive(Debug, Copy, Clone)]
10887pub struct otSrpClientBuffersServiceEntry {
10888    #[doc = "< The SRP client service structure."]
10889    pub mService: otSrpClientService,
10890    #[doc = "< The SRP client TXT entry."]
10891    pub mTxtEntry: otDnsTxtEntry,
10892}
10893impl Default for otSrpClientBuffersServiceEntry {
10894    fn default() -> Self {
10895        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10896        unsafe {
10897            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10898            s.assume_init()
10899        }
10900    }
10901}
10902extern "C" {
10903    #[doc = " Gets the string buffer to use for SRP client host name.\n\n @param[in]  aInstance  A pointer to the OpenThread instance.\n @param[out] aSize      Pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n                        NULL).\n\n @returns A pointer to char buffer to use for SRP client host name."]
10904    pub fn otSrpClientBuffersGetHostNameString(
10905        aInstance: *mut otInstance,
10906        aSize: *mut u16,
10907    ) -> *mut ::std::os::raw::c_char;
10908}
10909extern "C" {
10910    #[doc = " Gets the array of IPv6 address entries to use as SRP client host address list.\n\n @param[in]  aInstance     A pointer to the OpenThread instance.\n @param[out] aArrayLength  Pointer to a variable to return the array length i.e., number of IPv6 address entries in\n                           the array (MUST NOT be NULL).\n\n @returns A pointer to an array of `otIp6Address` entries (number of entries is returned in @p aArrayLength)."]
10911    pub fn otSrpClientBuffersGetHostAddressesArray(
10912        aInstance: *mut otInstance,
10913        aArrayLength: *mut u8,
10914    ) -> *mut otIp6Address;
10915}
10916extern "C" {
10917    #[doc = " Allocates a new service entry from the pool.\n\n The returned service entry instance will be initialized as follows:\n\n  - `mService.mName` will point to an allocated string buffer which can be retrieved using the function\n    `otSrpClientBuffersGetServiceEntryServiceNameString()`.\n  - `mService.mInstanceName` will point to an allocated string buffer which can be retrieved using the function\n    `otSrpClientBuffersGetServiceEntryInstanceNameString()`.\n  - `mService.mSubTypeLabels` points to an array that is returned from `otSrpClientBuffersGetSubTypeLabelsArray()`.\n  - `mService.mTxtEntries` will point to `mTxtEntry`.\n  - `mService.mNumTxtEntries` will be set to one.\n  - Other `mService` fields (port, priority, weight) are set to zero.\n  - `mTxtEntry.mKey` is set to NULL (value is treated as already encoded).\n  - `mTxtEntry.mValue` will point to an allocated buffer which can be retrieved using the function\n    `otSrpClientBuffersGetServiceEntryTxtBuffer()`.\n  - `mTxtEntry.mValueLength` is set to zero.\n  - All related data/string buffers and arrays are cleared to all zero.\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n\n @returns A pointer to the newly allocated service entry or NULL if not more entry available in the pool."]
10918    pub fn otSrpClientBuffersAllocateService(
10919        aInstance: *mut otInstance,
10920    ) -> *mut otSrpClientBuffersServiceEntry;
10921}
10922extern "C" {
10923    #[doc = " Frees a previously allocated service entry.\n\n The @p aService MUST be previously allocated using `otSrpClientBuffersAllocateService()` and not yet freed. Otherwise\n the behavior of this function is undefined.\n\n @param[in] aInstance   A pointer to the OpenThread instance.\n @param[in] aService    A pointer to the service entry to free (MUST NOT be NULL)."]
10924    pub fn otSrpClientBuffersFreeService(
10925        aInstance: *mut otInstance,
10926        aService: *mut otSrpClientBuffersServiceEntry,
10927    );
10928}
10929extern "C" {
10930    #[doc = " Frees all previously allocated service entries.\n\n @param[in] aInstance   A pointer to the OpenThread instance."]
10931    pub fn otSrpClientBuffersFreeAllServices(aInstance: *mut otInstance);
10932}
10933extern "C" {
10934    #[doc = " Gets the string buffer for service name from a service entry.\n\n @param[in]  aEntry   A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize    A pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n                      NULL).\n\n @returns A pointer to the string buffer."]
10935    pub fn otSrpClientBuffersGetServiceEntryServiceNameString(
10936        aEntry: *mut otSrpClientBuffersServiceEntry,
10937        aSize: *mut u16,
10938    ) -> *mut ::std::os::raw::c_char;
10939}
10940extern "C" {
10941    #[doc = " Gets the string buffer for service instance name from a service entry.\n\n @param[in]  aEntry   A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize    A pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n                      NULL).\n\n @returns A pointer to the string buffer."]
10942    pub fn otSrpClientBuffersGetServiceEntryInstanceNameString(
10943        aEntry: *mut otSrpClientBuffersServiceEntry,
10944        aSize: *mut u16,
10945    ) -> *mut ::std::os::raw::c_char;
10946}
10947extern "C" {
10948    #[doc = " Gets the buffer for TXT record from a service entry.\n\n @param[in]  aEntry   A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize    A pointer to a variable to return the size (number of bytes) of the buffer (MUST NOT be NULL).\n\n @returns A pointer to the buffer."]
10949    pub fn otSrpClientBuffersGetServiceEntryTxtBuffer(
10950        aEntry: *mut otSrpClientBuffersServiceEntry,
10951        aSize: *mut u16,
10952    ) -> *mut u8;
10953}
10954extern "C" {
10955    #[doc = " Gets the array for service subtype labels from the service entry.\n\n @param[in]  aEntry          A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aArrayLength    A pointer to a variable to return the array length (MUST NOT be NULL).\n\n @returns A pointer to the array."]
10956    pub fn otSrpClientBuffersGetSubTypeLabelsArray(
10957        aEntry: *mut otSrpClientBuffersServiceEntry,
10958        aArrayLength: *mut u16,
10959    ) -> *mut *const ::std::os::raw::c_char;
10960}
10961#[repr(C)]
10962#[derive(Debug, Copy, Clone)]
10963pub struct otSrpServerHost {
10964    _unused: [u8; 0],
10965}
10966#[repr(C)]
10967#[derive(Debug, Copy, Clone)]
10968pub struct otSrpServerService {
10969    _unused: [u8; 0],
10970}
10971#[doc = " The ID of a SRP service update transaction on the SRP Server."]
10972pub type otSrpServerServiceUpdateId = u32;
10973#[doc = "< The SRP server is disabled."]
10974pub const OT_SRP_SERVER_STATE_DISABLED: otSrpServerState = 0;
10975#[doc = "< The SRP server is enabled and running."]
10976pub const OT_SRP_SERVER_STATE_RUNNING: otSrpServerState = 1;
10977#[doc = "< The SRP server is enabled but stopped."]
10978pub const OT_SRP_SERVER_STATE_STOPPED: otSrpServerState = 2;
10979#[doc = " Represents the state of the SRP server."]
10980pub type otSrpServerState = ::std::os::raw::c_uint;
10981#[doc = "< Unicast address mode. Use Network Data publisher."]
10982pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST: otSrpServerAddressMode = 0;
10983#[doc = "< Anycast address mode. Use Network Data publisher"]
10984pub const OT_SRP_SERVER_ADDRESS_MODE_ANYCAST: otSrpServerAddressMode = 1;
10985#[doc = "< Unicast address mode. Immediately force add to Network Data."]
10986pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD: otSrpServerAddressMode = 2;
10987#[doc = " Represents the address mode used by the SRP server.\n\n Address mode specifies how the address and port number are determined by the SRP server and how this info is\n published in the Thread Network Data.\n\n @warning Using the `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD` option will make the implementation\n non-compliant with the Thread specification. This option is intended for testing and specific use-cases.\n When selected, the SRP server, upon being enabled, will bypass the Network Data publisher and always add the\n \"SRP/DNS unicast\" entry directly to the Network Data, regardless of how many other similar entries are present."]
10988pub type otSrpServerAddressMode = ::std::os::raw::c_uint;
10989#[doc = " Includes SRP server TTL configurations."]
10990#[repr(C)]
10991#[derive(Debug, Default, Copy, Clone)]
10992pub struct otSrpServerTtlConfig {
10993    #[doc = "< The minimum TTL in seconds."]
10994    pub mMinTtl: u32,
10995    #[doc = "< The maximum TTL in seconds."]
10996    pub mMaxTtl: u32,
10997}
10998#[doc = " Includes SRP server LEASE and KEY-LEASE configurations."]
10999#[repr(C)]
11000#[derive(Debug, Default, Copy, Clone)]
11001pub struct otSrpServerLeaseConfig {
11002    #[doc = "< The minimum LEASE interval in seconds."]
11003    pub mMinLease: u32,
11004    #[doc = "< The maximum LEASE interval in seconds."]
11005    pub mMaxLease: u32,
11006    #[doc = "< The minimum KEY-LEASE interval in seconds."]
11007    pub mMinKeyLease: u32,
11008    #[doc = "< The maximum KEY-LEASE interval in seconds."]
11009    pub mMaxKeyLease: u32,
11010}
11011#[doc = " Includes SRP server lease information of a host/service."]
11012#[repr(C)]
11013#[derive(Debug, Default, Copy, Clone)]
11014pub struct otSrpServerLeaseInfo {
11015    #[doc = "< The lease time of a host/service in milliseconds."]
11016    pub mLease: u32,
11017    #[doc = "< The key lease time of a host/service in milliseconds."]
11018    pub mKeyLease: u32,
11019    #[doc = "< The remaining lease time of the host/service in milliseconds."]
11020    pub mRemainingLease: u32,
11021    #[doc = "< The remaining key lease time of a host/service in milliseconds."]
11022    pub mRemainingKeyLease: u32,
11023}
11024#[doc = " Includes the statistics of SRP server responses."]
11025#[repr(C)]
11026#[derive(Debug, Default, Copy, Clone)]
11027pub struct otSrpServerResponseCounters {
11028    #[doc = "< The number of successful responses."]
11029    pub mSuccess: u32,
11030    #[doc = "< The number of server failure responses."]
11031    pub mServerFailure: u32,
11032    #[doc = "< The number of format error responses."]
11033    pub mFormatError: u32,
11034    #[doc = "< The number of 'name exists' responses."]
11035    pub mNameExists: u32,
11036    #[doc = "< The number of refused responses."]
11037    pub mRefused: u32,
11038    #[doc = "< The number of other responses."]
11039    pub mOther: u32,
11040}
11041extern "C" {
11042    #[doc = " Returns the domain authorized to the SRP server.\n\n If the domain if not set by SetDomain, \"default.service.arpa.\" will be returned.\n A trailing dot is always appended even if the domain is set without it.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns A pointer to the dot-joined domain string."]
11043    pub fn otSrpServerGetDomain(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
11044}
11045extern "C" {
11046    #[doc = " Sets the domain on the SRP server.\n\n A trailing dot will be appended to @p aDomain if it is not already there.\n Should only be called before the SRP server is enabled.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aDomain    The domain to be set. MUST NOT be NULL.\n\n @retval  OT_ERROR_NONE           Successfully set the domain to @p aDomain.\n @retval  OT_ERROR_INVALID_STATE  The SRP server is already enabled and the Domain cannot be changed.\n @retval  OT_ERROR_INVALID_ARGS   The argument @p aDomain is not a valid DNS domain name.\n @retval  OT_ERROR_NO_BUFS        There is no memory to store content of @p aDomain."]
11047    pub fn otSrpServerSetDomain(
11048        aInstance: *mut otInstance,
11049        aDomain: *const ::std::os::raw::c_char,
11050    ) -> otError;
11051}
11052extern "C" {
11053    #[doc = " Returns the state of the SRP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The current state of the SRP server."]
11054    pub fn otSrpServerGetState(aInstance: *mut otInstance) -> otSrpServerState;
11055}
11056extern "C" {
11057    #[doc = " Returns the port the SRP server is listening to.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns  The port of the SRP server. It returns 0 if the server is not running."]
11058    pub fn otSrpServerGetPort(aInstance: *mut otInstance) -> u16;
11059}
11060extern "C" {
11061    #[doc = " Returns the address mode being used by the SRP server.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @returns The SRP server's address mode."]
11062    pub fn otSrpServerGetAddressMode(aInstance: *mut otInstance) -> otSrpServerAddressMode;
11063}
11064extern "C" {
11065    #[doc = " Sets the address mode to be used by the SRP server.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aMode      The address mode to use.\n\n @retval OT_ERROR_NONE           Successfully set the address mode.\n @retval OT_ERROR_INVALID_STATE  The SRP server is enabled and the address mode cannot be changed."]
11066    pub fn otSrpServerSetAddressMode(
11067        aInstance: *mut otInstance,
11068        aMode: otSrpServerAddressMode,
11069    ) -> otError;
11070}
11071extern "C" {
11072    #[doc = " Returns the sequence number used with anycast address mode.\n\n The sequence number is included in \"DNS/SRP Service Anycast Address\" entry published in the Network Data.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n\n @returns The anycast sequence number."]
11073    pub fn otSrpServerGetAnycastModeSequenceNumber(aInstance: *mut otInstance) -> u8;
11074}
11075extern "C" {
11076    #[doc = " Sets the sequence number used with anycast address mode.\n\n @param[in] aInstance        A pointer to an OpenThread instance.\n @param[in] aSequenceNumber  The sequence number to use.\n\n @retval OT_ERROR_NONE            Successfully set the address mode.\n @retval OT_ERROR_INVALID_STATE   The SRP server is enabled and the sequence number cannot be changed."]
11077    pub fn otSrpServerSetAnycastModeSequenceNumber(
11078        aInstance: *mut otInstance,
11079        aSequenceNumber: u8,
11080    ) -> otError;
11081}
11082extern "C" {
11083    #[doc = " Enables/disables the SRP server.\n\n On a Border Router, it is recommended to use `otSrpServerSetAutoEnableMode()` instead.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   A boolean to enable/disable the SRP server."]
11084    pub fn otSrpServerSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
11085}
11086extern "C" {
11087    #[doc = " Enables/disables the auto-enable mode on SRP server.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` feature.\n\n When this mode is enabled, the Border Routing Manager controls if/when to enable or disable the SRP server.\n SRP sever is auto-enabled if/when Border Routing is started and it is done with the initial prefix and route\n configurations (when the OMR and on-link prefixes are determined, advertised in emitted Router Advertisement message\n on infrastructure side and published in the Thread Network Data). The SRP server is auto-disabled if/when BR is\n stopped (e.g., if the infrastructure network interface is brought down or if BR gets detached).\n\n This mode can be disabled by a `otSrpServerSetAutoEnableMode()` call with @p aEnabled set to `false` or if the SRP\n server is explicitly enabled or disabled by a call to `otSrpServerSetEnabled()` function. Disabling auto-enable mode\n using `otSrpServerSetAutoEnableMode(false)` will not change the current state of SRP sever (e.g., if it is enabled\n it stays enabled).\n\n @param[in] aInstance   A pointer to an OpenThread instance.\n @param[in] aEnabled    A boolean to enable/disable the auto-enable mode."]
11088    pub fn otSrpServerSetAutoEnableMode(aInstance: *mut otInstance, aEnabled: bool);
11089}
11090extern "C" {
11091    #[doc = " Indicates whether the auto-enable mode is enabled or disabled.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` feature.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @retval TRUE   The auto-enable mode is enabled.\n @retval FALSE  The auto-enable mode is disabled."]
11092    pub fn otSrpServerIsAutoEnableMode(aInstance: *mut otInstance) -> bool;
11093}
11094extern "C" {
11095    #[doc = " Enables the \"Fast Start Mode\" on the SRP server.\n\n Requires the `OPENTHREAD_CONFIG_SRP_SERVER_FAST_START_MODE_ENABLE` feature to be enabled.\n\n The Fast Start Mode is designed for scenarios where a device, often a mobile device, needs to act as a provisional\n SRP server (e.g., functioning as a temporary Border Router). The SRP server function is enabled only if no other\n Border Routers (BRs) are already providing the SRP service within the Thread network. A common use case is a mobile\n device joining a Thread network where it may be the first, or only, BR.  Importantly, Fast Start Mode allows the\n device to quickly start its SRP server functionality upon joining the network, allowing other Thread devices to\n quickly connect and register their services without the typical delays associated with standard Border Router\n initialization (and SRP server startup).\n\n When Fast Start Mode is enabled, the SRP server manages when to start or stop based on the presence of other BRs,\n following this process:\n - Upon initial attachment to the Thread network, the device immediately inspects the received Network Data for any\n   existing \"SRP/DNS\" entries. These entries indicate the presence of other active BRs providing SRP server service:\n   - If no \"SRP/DNS\" entries from other BRs are found, the device immediately enables its own SRP server. This\n     activation uses `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD`, which bypasses the usual delay associated with\n     the standard Network Data publisher, directly adding its own \"SRP/DNS unicast\" entry to the Network Data.\n   - If \"SRP/DNS\" entries from other BRs are detected, the device will not enable its SRP server, deferring to the\n     existing ones.\n - After starting its SRP server in Fast Start Mode, the device continuously monitors the Network Data. If, at any\n   point, new \"SRP/DNS\" entries appear (indicating that another BR has become active), the device automatically\n   disables its own SRP server functionality, relinquishing the role to the newly available BR.\n\n The Fast Start Mode can be enabled when the device is in the detached or disabled state, the SRP server is currently\n disabled, and \"auto-enable mode\" is not in use (i.e., `otSrpServerIsAutoEnableMode()` returns `false`).\n\n After successfully enabling Fast Start Mode, it can be disabled either by a call to `otSrpServerSetEnabled()`,\n explicitly enabling or disabling the SRP server, or by a call to `otSrpServerSetAutoEnableMode()`, enabling or\n disabling the auto-enable mode. If the Fast Start Mode (while active) enables the SRP server, upon disabling\n Fast Start Mode (regardless of how it is done), the SRP server will also be stopped, and the use of the\n `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD` address mode will be stopped, and the address mode will be\n automatically reverted back to its previous setting before Fast Start Mode was enabled.\n\n @param[in] aInstance             A pointer to the OpenThread instance.\n\n @retval OT_ERROR_NONE            Fast Start Mode was successfully enabled.\n @retval OT_ERROR_INVALID_STATE   Cannot enable Fast Start Mode (e.g., already attached or server already enabled)."]
11096    pub fn otSrpServerEnableFastStartMode(aInstance: *mut otInstance) -> otError;
11097}
11098extern "C" {
11099    #[doc = " Indicates whether the Fast Start Mode is enabled or disabled.\n\n Requires `OPENTHREAD_CONFIG_SRP_SERVER_FAST_START_MODE_ENABLE` feature to be enabled.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n\n @retval TRUE   The fast-start mode is enabled.\n @retval FALSE  The fast-start mode is disabled."]
11100    pub fn otSrpServerIsFastStartModeEnabled(aInstance: *mut otInstance) -> bool;
11101}
11102extern "C" {
11103    #[doc = " Returns SRP server TTL configuration.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n @param[out]  aTtlConfig  A pointer to an `otSrpServerTtlConfig` instance."]
11104    pub fn otSrpServerGetTtlConfig(
11105        aInstance: *mut otInstance,
11106        aTtlConfig: *mut otSrpServerTtlConfig,
11107    );
11108}
11109extern "C" {
11110    #[doc = " Sets SRP server TTL configuration.\n\n The granted TTL will always be no greater than the max lease interval configured via `otSrpServerSetLeaseConfig()`,\n regardless of the minimum and maximum TTL configuration.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aTtlConfig  A pointer to an `otSrpServerTtlConfig` instance.\n\n @retval  OT_ERROR_NONE          Successfully set the TTL configuration.\n @retval  OT_ERROR_INVALID_ARGS  The TTL configuration is not valid."]
11111    pub fn otSrpServerSetTtlConfig(
11112        aInstance: *mut otInstance,
11113        aTtlConfig: *const otSrpServerTtlConfig,
11114    ) -> otError;
11115}
11116extern "C" {
11117    #[doc = " Returns SRP server LEASE and KEY-LEASE configurations.\n\n @param[in]   aInstance     A pointer to an OpenThread instance.\n @param[out]  aLeaseConfig  A pointer to an `otSrpServerLeaseConfig` instance."]
11118    pub fn otSrpServerGetLeaseConfig(
11119        aInstance: *mut otInstance,
11120        aLeaseConfig: *mut otSrpServerLeaseConfig,
11121    );
11122}
11123extern "C" {
11124    #[doc = " Sets SRP server LEASE and KEY-LEASE configurations.\n\n When a non-zero LEASE time is requested from a client, the granted value will be\n limited in range [aMinLease, aMaxLease]; and a non-zero KEY-LEASE will be granted\n in range [aMinKeyLease, aMaxKeyLease]. For zero LEASE or KEY-LEASE time, zero will\n be granted.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aLeaseConfig  A pointer to an `otSrpServerLeaseConfig` instance.\n\n @retval  OT_ERROR_NONE          Successfully set the LEASE and KEY-LEASE ranges.\n @retval  OT_ERROR_INVALID_ARGS  The LEASE or KEY-LEASE range is not valid."]
11125    pub fn otSrpServerSetLeaseConfig(
11126        aInstance: *mut otInstance,
11127        aLeaseConfig: *const otSrpServerLeaseConfig,
11128    ) -> otError;
11129}
11130#[doc = " Handles SRP service updates.\n\n Is called by the SRP server to notify that a SRP host and possibly SRP services\n are being updated. It is important that the SRP updates are not committed until the handler\n returns the result by calling otSrpServerHandleServiceUpdateResult or times out after @p aTimeout.\n\n A SRP service observer should always call otSrpServerHandleServiceUpdateResult with error code\n OT_ERROR_NONE immediately after receiving the update events.\n\n A more generic handler may perform validations on the SRP host/services and rejects the SRP updates\n if any validation fails. For example, an Advertising Proxy should advertise (or remove) the host and\n services on a multicast-capable link and returns specific error code if any failure occurs.\n\n @param[in]  aId       The service update transaction ID. This ID must be passed back with\n                       `otSrpServerHandleServiceUpdateResult`.\n @param[in]  aHost     A pointer to the otSrpServerHost object which contains the SRP updates. The\n                       handler should publish/un-publish the host and each service points to this\n                       host with below rules:\n                         1. If the host is not deleted (indicated by `otSrpServerHostIsDeleted`),\n                            then it should be published or updated with mDNS. Otherwise, the host\n                            should be un-published (remove AAAA RRs).\n                         2. For each service points to this host, it must be un-published if the host\n                            is to be un-published. Otherwise, the handler should publish or update the\n                            service when it is not deleted (indicated by `otSrpServerServiceIsDeleted`)\n                            and un-publish it when deleted.\n @param[in]  aTimeout  The maximum time in milliseconds for the handler to process the service event.\n @param[in]  aContext  A pointer to application-specific context.\n\n @sa otSrpServerSetServiceUpdateHandler\n @sa otSrpServerHandleServiceUpdateResult"]
11131pub type otSrpServerServiceUpdateHandler = ::std::option::Option<
11132    unsafe extern "C" fn(
11133        aId: otSrpServerServiceUpdateId,
11134        aHost: *const otSrpServerHost,
11135        aTimeout: u32,
11136        aContext: *mut ::std::os::raw::c_void,
11137    ),
11138>;
11139extern "C" {
11140    #[doc = " Sets the SRP service updates handler on SRP server.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aServiceHandler  A pointer to a service handler. Use NULL to remove the handler.\n @param[in]  aContext         A pointer to arbitrary context information.\n                              May be NULL if not used."]
11141    pub fn otSrpServerSetServiceUpdateHandler(
11142        aInstance: *mut otInstance,
11143        aServiceHandler: otSrpServerServiceUpdateHandler,
11144        aContext: *mut ::std::os::raw::c_void,
11145    );
11146}
11147extern "C" {
11148    #[doc = " Reports the result of processing a SRP update to the SRP server.\n\n The Service Update Handler should call this function to return the result of its\n processing of a SRP update.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aId        The service update transaction ID. This should be the same ID\n                        provided via `otSrpServerServiceUpdateHandler`.\n @param[in]  aError     An error to be returned to the SRP server. Use OT_ERROR_DUPLICATED\n                        to represent DNS name conflicts."]
11149    pub fn otSrpServerHandleServiceUpdateResult(
11150        aInstance: *mut otInstance,
11151        aId: otSrpServerServiceUpdateId,
11152        aError: otError,
11153    );
11154}
11155extern "C" {
11156    #[doc = " Returns the next registered host on the SRP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aHost      A pointer to current host; use NULL to get the first host.\n\n @returns  A pointer to the registered host. NULL, if no more hosts can be found."]
11157    pub fn otSrpServerGetNextHost(
11158        aInstance: *mut otInstance,
11159        aHost: *const otSrpServerHost,
11160    ) -> *const otSrpServerHost;
11161}
11162extern "C" {
11163    #[doc = " Returns the response counters of the SRP server.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns  A pointer to the response counters of the SRP server."]
11164    pub fn otSrpServerGetResponseCounters(
11165        aInstance: *mut otInstance,
11166    ) -> *const otSrpServerResponseCounters;
11167}
11168extern "C" {
11169    #[doc = " Tells if the SRP service host has been deleted.\n\n A SRP service host can be deleted but retains its name for future uses.\n In this case, the host instance is not removed from the SRP server/registry.\n\n @param[in]  aHost  A pointer to the SRP service host.\n\n @returns  TRUE if the host has been deleted, FALSE if not."]
11170    pub fn otSrpServerHostIsDeleted(aHost: *const otSrpServerHost) -> bool;
11171}
11172extern "C" {
11173    #[doc = " Returns the full name of the host.\n\n @param[in]  aHost  A pointer to the SRP service host.\n\n @returns  A pointer to the null-terminated host name string."]
11174    pub fn otSrpServerHostGetFullName(
11175        aHost: *const otSrpServerHost,
11176    ) -> *const ::std::os::raw::c_char;
11177}
11178extern "C" {
11179    #[doc = " Indicates whether the host matches a given host name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in]  aHost       A pointer to the SRP service host.\n @param[in]  aFullName   A full host name.\n\n @retval  TRUE   If host matches the host name.\n @retval  FALSE  If host does not match the host name."]
11180    pub fn otSrpServerHostMatchesFullName(
11181        aHost: *const otSrpServerHost,
11182        aFullName: *const ::std::os::raw::c_char,
11183    ) -> bool;
11184}
11185extern "C" {
11186    #[doc = " Returns the addresses of given host.\n\n @param[in]   aHost          A pointer to the SRP service host.\n @param[out]  aAddressesNum  A pointer to where we should output the number of the addresses to.\n\n @returns  A pointer to the array of IPv6 Address."]
11187    pub fn otSrpServerHostGetAddresses(
11188        aHost: *const otSrpServerHost,
11189        aAddressesNum: *mut u8,
11190    ) -> *const otIp6Address;
11191}
11192extern "C" {
11193    #[doc = " Returns the LEASE and KEY-LEASE information of a given host.\n\n @param[in]   aHost       A pointer to the SRP server host.\n @param[out]  aLeaseInfo  A pointer to where to output the LEASE and KEY-LEASE information."]
11194    pub fn otSrpServerHostGetLeaseInfo(
11195        aHost: *const otSrpServerHost,
11196        aLeaseInfo: *mut otSrpServerLeaseInfo,
11197    );
11198}
11199extern "C" {
11200    #[doc = " Returns the next service of given host.\n\n @param[in]  aHost     A pointer to the SRP service host.\n @param[in]  aService  A pointer to current SRP service instance; use NULL to get the first service.\n\n @returns  A pointer to the next service or NULL if there is no more services."]
11201    pub fn otSrpServerHostGetNextService(
11202        aHost: *const otSrpServerHost,
11203        aService: *const otSrpServerService,
11204    ) -> *const otSrpServerService;
11205}
11206extern "C" {
11207    #[doc = " Indicates whether or not the SRP service has been deleted.\n\n A SRP service can be deleted but retains its name for future uses.\n In this case, the service instance is not removed from the SRP server/registry.\n It is guaranteed that all services are deleted if the host is deleted.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  TRUE if the service has been deleted, FALSE if not."]
11208    pub fn otSrpServerServiceIsDeleted(aService: *const otSrpServerService) -> bool;
11209}
11210extern "C" {
11211    #[doc = " Returns the full service instance name of the service.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  A pointer to the null-terminated service instance name string."]
11212    pub fn otSrpServerServiceGetInstanceName(
11213        aService: *const otSrpServerService,
11214    ) -> *const ::std::os::raw::c_char;
11215}
11216extern "C" {
11217    #[doc = " Indicates whether this service matches a given service instance name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in]  aService       A pointer to the SRP service.\n @param[in]  aInstanceName  The service instance name.\n\n @retval  TRUE   If service matches the service instance name.\n @retval  FALSE  If service does not match the service instance name."]
11218    pub fn otSrpServerServiceMatchesInstanceName(
11219        aService: *const otSrpServerService,
11220        aInstanceName: *const ::std::os::raw::c_char,
11221    ) -> bool;
11222}
11223extern "C" {
11224    #[doc = " Returns the service instance label (first label in instance name) of the service.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  A pointer to the null-terminated service instance label string.."]
11225    pub fn otSrpServerServiceGetInstanceLabel(
11226        aService: *const otSrpServerService,
11227    ) -> *const ::std::os::raw::c_char;
11228}
11229extern "C" {
11230    #[doc = " Returns the full service name of the service.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  A pointer to the null-terminated service name string."]
11231    pub fn otSrpServerServiceGetServiceName(
11232        aService: *const otSrpServerService,
11233    ) -> *const ::std::os::raw::c_char;
11234}
11235extern "C" {
11236    #[doc = " Indicates whether this service matches a given service name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in]  aService       A pointer to the SRP service.\n @param[in]  aServiceName  The service  name.\n\n @retval  TRUE   If service matches the service name.\n @retval  FALSE  If service does not match the service name."]
11237    pub fn otSrpServerServiceMatchesServiceName(
11238        aService: *const otSrpServerService,
11239        aServiceName: *const ::std::os::raw::c_char,
11240    ) -> bool;
11241}
11242extern "C" {
11243    #[doc = " Gets the number of sub-types of the service.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns The number of sub-types of @p aService."]
11244    pub fn otSrpServerServiceGetNumberOfSubTypes(aService: *const otSrpServerService) -> u16;
11245}
11246extern "C" {
11247    #[doc = " Gets the sub-type service name (full name) of the service at a given index\n\n The full service name for a sub-type service follows \"<sub-label>._sub.<service-labels>.<domain>.\".\n\n @param[in]  aService  A pointer to the SRP service.\n @param[in] aIndex     The index to get.\n\n @returns A pointer to sub-type service name at @p aIndex, or `NULL` if no sub-type at this index."]
11248    pub fn otSrpServerServiceGetSubTypeServiceNameAt(
11249        aService: *const otSrpServerService,
11250        aIndex: u16,
11251    ) -> *const ::std::os::raw::c_char;
11252}
11253extern "C" {
11254    #[doc = " Indicates whether or not the service has a given sub-type.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in] aService             A pointer to the SRP service.\n @param[in] aSubTypeServiceName  The sub-type service name (full name) to check.\n\n @retval TRUE   Service contains the sub-type @p aSubTypeServiceName.\n @retval FALSE  Service does not contain the sub-type @p aSubTypeServiceName."]
11255    pub fn otSrpServerServiceHasSubTypeServiceName(
11256        aService: *const otSrpServerService,
11257        aSubTypeServiceName: *const ::std::os::raw::c_char,
11258    ) -> bool;
11259}
11260extern "C" {
11261    #[doc = " Parses a sub-type service name (full name) and extracts the sub-type label.\n\n The full service name for a sub-type service follows \"<sub-label>._sub.<service-labels>.<domain>.\".\n\n @param[in]  aSubTypeServiceName  A sub-type service name (full name).\n @param[out] aLabel               A pointer to a buffer to copy the extracted sub-type label.\n @param[in]  aLabelSize           Maximum size of @p aLabel buffer.\n\n @retval OT_ERROR_NONE          Name was successfully parsed and @p aLabel was updated.\n @retval OT_ERROR_NO_BUFS       The sub-type label could not fit in @p aLabel buffer (number of chars from label\n                                that could fit are copied in @p aLabel ensuring it is null-terminated).\n @retval OT_ERROR_INVALID_ARGS  @p aSubTypeServiceName is not a valid sub-type format."]
11262    pub fn otSrpServerParseSubTypeServiceName(
11263        aSubTypeServiceName: *const ::std::os::raw::c_char,
11264        aLabel: *mut ::std::os::raw::c_char,
11265        aLabelSize: u8,
11266    ) -> otError;
11267}
11268extern "C" {
11269    #[doc = " Returns the port of the service instance.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  The port of the service."]
11270    pub fn otSrpServerServiceGetPort(aService: *const otSrpServerService) -> u16;
11271}
11272extern "C" {
11273    #[doc = " Returns the weight of the service instance.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  The weight of the service."]
11274    pub fn otSrpServerServiceGetWeight(aService: *const otSrpServerService) -> u16;
11275}
11276extern "C" {
11277    #[doc = " Returns the priority of the service instance.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  The priority of the service."]
11278    pub fn otSrpServerServiceGetPriority(aService: *const otSrpServerService) -> u16;
11279}
11280extern "C" {
11281    #[doc = " Returns the TTL of the service instance.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  The TTL of the service instance.."]
11282    pub fn otSrpServerServiceGetTtl(aService: *const otSrpServerService) -> u32;
11283}
11284extern "C" {
11285    #[doc = " Returns the TXT record data of the service instance.\n\n @param[in]  aService        A pointer to the SRP service.\n @param[out] aDataLength     A pointer to return the TXT record data length. MUST NOT be NULL.\n\n @returns A pointer to the buffer containing the TXT record data (the TXT data length is returned in @p aDataLength)."]
11286    pub fn otSrpServerServiceGetTxtData(
11287        aService: *const otSrpServerService,
11288        aDataLength: *mut u16,
11289    ) -> *const u8;
11290}
11291extern "C" {
11292    #[doc = " Returns the host which the service instance reside on.\n\n @param[in]  aService  A pointer to the SRP service.\n\n @returns  A pointer to the host instance."]
11293    pub fn otSrpServerServiceGetHost(aService: *const otSrpServerService)
11294        -> *const otSrpServerHost;
11295}
11296extern "C" {
11297    #[doc = " Returns the LEASE and KEY-LEASE information of a given service.\n\n @param[in]   aService    A pointer to the SRP server service.\n @param[out]  aLeaseInfo  A pointer to where to output the LEASE and KEY-LEASE information."]
11298    pub fn otSrpServerServiceGetLeaseInfo(
11299        aService: *const otSrpServerService,
11300        aLeaseInfo: *mut otSrpServerLeaseInfo,
11301    );
11302}
11303extern "C" {
11304    #[doc = " Run all queued OpenThread tasklets at the time this is called.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
11305    pub fn otTaskletsProcess(aInstance: *mut otInstance);
11306}
11307extern "C" {
11308    #[doc = " Indicates whether or not OpenThread has tasklets pending.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   If there are tasklets pending.\n @retval FALSE  If there are no tasklets pending."]
11309    pub fn otTaskletsArePending(aInstance: *mut otInstance) -> bool;
11310}
11311extern "C" {
11312    #[doc = " OpenThread calls this function when the tasklet queue transitions from empty to non-empty.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
11313    pub fn otTaskletsSignalPending(aInstance: *mut otInstance);
11314}
11315#[doc = " A linked buffer structure for use with TCP.\n\n A single otLinkedBuffer structure references an array of bytes in memory,\n via mData and mLength. The mNext field is used to form a chain of\n otLinkedBuffer structures."]
11316#[repr(C)]
11317#[derive(Debug, Copy, Clone)]
11318pub struct otLinkedBuffer {
11319    #[doc = "< Pointer to the next linked buffer in the chain, or NULL if it is the end."]
11320    pub mNext: *mut otLinkedBuffer,
11321    #[doc = "< Pointer to data referenced by this linked buffer."]
11322    pub mData: *const u8,
11323    #[doc = "< Length of this linked buffer (number of bytes)."]
11324    pub mLength: usize,
11325}
11326impl Default for otLinkedBuffer {
11327    fn default() -> Self {
11328        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11329        unsafe {
11330            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11331            s.assume_init()
11332        }
11333    }
11334}
11335#[doc = " This callback informs the application that the TCP 3-way handshake is\n complete and that the connection is now established.\n\n @param[in]  aEndpoint  The TCP endpoint whose connection is now established."]
11336pub type otTcpEstablished =
11337    ::std::option::Option<unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint)>;
11338#[doc = " This callback informs the application that data in the provided\n @p aData have been acknowledged by the connection peer and that @p aData and\n the data it contains can be reclaimed by the application.\n\n The @p aData are guaranteed to be identical to those passed in to TCP via\n otTcpSendByReference(), including any extensions effected via\n otTcpSendByExtension().\n\n @param[in]  aEndpoint  The TCP endpoint for the connection.\n @param[in]  aData      A pointer to the otLinkedBuffer that can be reclaimed."]
11339pub type otTcpSendDone = ::std::option::Option<
11340    unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aData: *mut otLinkedBuffer),
11341>;
11342#[doc = " This callback informs the application if forward progress has been made in\n transferring data from the send buffer to the recipient. This callback is\n not necessary for correct TCP operation. Most applications can just rely on\n the otTcpSendDone() callback to reclaim linked buffers once the TCP stack is\n done using them. The purpose of this callback is to support advanced\n applications that benefit from finer-grained information about how the\n the connection is making forward progress in transferring data to the\n connection peer.\n\n This callback's operation is closely tied to TCP's send buffer. The send\n buffer can be understood as having two regions. First, there is the\n \"in-flight\" region at the head (front) of the send buffer. It corresponds\n to data which has been sent to the recipient, but is not yet acknowledged.\n Second, there is the \"backlog\" region, which consists of all data in the\n send buffer that is not in the \"in-flight\" region. The \"backlog\" region\n corresponds to data that is queued for sending, but has not yet been sent.\n\n The callback is invoked in response to two types of events. First, the\n \"in-flight\" region of the send buffer may shrink (e.g., when the recipient\n acknowledges data that we sent earlier). Second, the \"backlog\" region of the\n send buffer may shrink (e.g., new data was sent out). These two conditions\n often occur at the same time, in response to an ACK segment from the\n connection peer, which is why they are combined in a single callback.\n\n The TCP stack only uses the @p aInSendBuffer bytes at the tail of the send\n buffer; when @p aInSendBuffer decreases by an amount x, it means that x\n additional bytes that were formerly at the head of the send buffer are no\n longer part of the send buffer and can now be reclaimed (i.e., overwritten)\n by the application. Note that the otLinkedBuffer structure itself can only\n be reclaimed once all bytes that it references are no longer part of the\n send buffer.\n\n This callback subsumes otTcpSendDone(), in the following sense: applications\n can determine when linked buffers can be reclaimed by comparing\n @p aInSendBuffer with how many bytes are in each linked buffer. However, we\n expect otTcpSendDone(), which directly conveys which otLinkedBuffers can be\n reclaimed, to be much simpler to use. If both callbacks are registered and\n are triggered by the same event (e.g., the same ACK segment received), then\n the otTcpSendDone() callback will be triggered first, followed by this\n callback.\n\n Additionally, this callback provides @p aBacklog, which indicates how many\n bytes of data in the send buffer are not yet in flight. For applications\n that only want to add data to the send buffer when there is an assurance\n that it will be sent out soon, it may be desirable to only send out data\n when @p aBacklog is suitably small (0 or close to 0). For example, an\n application may use @p aBacklog so that it can react to queue buildup by\n dropping or aggregating data to avoid creating a backlog of data.\n\n After a call to otTcpSendByReference() or otTcpSendByExtension() with a\n positive number of bytes, the otTcpForwardProgress() callback is guaranteed\n to be called, to indicate when the bytes that were added to the send buffer\n are sent out. The call to otTcpForwardProgress() may be made immediately\n after the bytes are added to the send buffer (if some of those bytes are\n immediately sent out, reducing the backlog), or sometime in the future (once\n the connection sends out some or all of the data, reducing the backlog). By\n \"immediately,\" we mean that the callback is immediately scheduled for\n execution in a tasklet; to avoid reentrancy-related complexity, the\n otTcpForwardProgress() callback is never directly called from the\n otTcpSendByReference() or otTcpSendByExtension() functions.\n\n @param[in]  aEndpoint      The TCP endpoint for the connection.\n @param[in]  aInSendBuffer  The number of bytes in the send buffer (sum of \"in-flight\" and \"backlog\" regions).\n @param[in]  aBacklog       The number of bytes that are queued for sending but have not yet been sent (the \"backlog\"\n                            region)."]
11343pub type otTcpForwardProgress = ::std::option::Option<
11344    unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aInSendBuffer: usize, aBacklog: usize),
11345>;
11346#[doc = " This callback indicates the number of bytes available for consumption from\n the receive buffer.\n\n It is called whenever bytes are added to the receive buffer and when the\n end of stream is reached. If the end of the stream has been reached (i.e.,\n if no more data will become available to read because the connection peer\n has closed their end of the connection for writing), then @p aEndOfStream is\n true. Finally, @p aBytesRemaining indicates how much capacity is left in the\n receive buffer to hold additional data that arrives.\n\n @param[in]  aEndpoint        The TCP endpoint for the connection.\n @param[in]  aBytesAvailable  The number of bytes in the connection's receive buffer.\n @param[in]  aEndOfStream     Indicates if additional data, beyond what is already in the connection's receive buffer,\n                              can be received.\n @param[in]  aBytesRemaining  The number of additional bytes that can be received before the receive buffer becomes\n                              full."]
11347pub type otTcpReceiveAvailable = ::std::option::Option<
11348    unsafe extern "C" fn(
11349        aEndpoint: *mut otTcpEndpoint,
11350        aBytesAvailable: usize,
11351        aEndOfStream: bool,
11352        aBytesRemaining: usize,
11353    ),
11354>;
11355pub const OT_TCP_DISCONNECTED_REASON_NORMAL: otTcpDisconnectedReason = 0;
11356pub const OT_TCP_DISCONNECTED_REASON_REFUSED: otTcpDisconnectedReason = 1;
11357pub const OT_TCP_DISCONNECTED_REASON_RESET: otTcpDisconnectedReason = 2;
11358pub const OT_TCP_DISCONNECTED_REASON_TIME_WAIT: otTcpDisconnectedReason = 3;
11359pub const OT_TCP_DISCONNECTED_REASON_TIMED_OUT: otTcpDisconnectedReason = 4;
11360pub type otTcpDisconnectedReason = ::std::os::raw::c_uint;
11361#[doc = " This callback indicates that the connection was broken and should no longer\n be used, or that a connection has entered the TIME-WAIT state.\n\n It can occur if a connection establishment attempt (initiated by calling\n otTcpConnect()) fails, or any point thereafter (e.g., if the connection\n times out or an RST segment is received from the connection peer). Once this\n callback fires, all resources that the application provided for this\n connection (i.e., any `otLinkedBuffers` and memory they reference, but not\n the TCP endpoint itself or space for the receive buffers) can be reclaimed.\n In the case of a connection entering the TIME-WAIT state, this callback is\n called twice, once upon entry into the TIME-WAIT state (with\n OT_TCP_DISCONNECTED_REASON_TIME_WAIT, and again when the TIME-WAIT state\n expires (with OT_TCP_DISCONNECTED_REASON_NORMAL).\n\n @param[in]  aEndpoint  The TCP endpoint whose connection has been lost.\n @param[in]  aReason    The reason why the connection was lost."]
11362pub type otTcpDisconnected = ::std::option::Option<
11363    unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aReason: otTcpDisconnectedReason),
11364>;
11365#[doc = " Represents a TCP endpoint.\n\n A TCP endpoint acts an endpoint of TCP connection. It can be used to\n initiate TCP connections, and, once a TCP connection is established, send\n data to and receive data from the connection peer.\n\n The application should not inspect the fields of this structure directly; it\n should only interact with it via the TCP API functions whose signatures are\n provided in this file."]
11366#[repr(C)]
11367#[derive(Copy, Clone)]
11368pub struct otTcpEndpoint {
11369    pub mTcb: otTcpEndpoint__bindgen_ty_1,
11370    #[doc = "< A pointer to the next TCP endpoint (internal use only)"]
11371    pub mNext: *mut otTcpEndpoint,
11372    #[doc = "< A pointer to application-specific context"]
11373    pub mContext: *mut ::std::os::raw::c_void,
11374    #[doc = "< \"Established\" callback function"]
11375    pub mEstablishedCallback: otTcpEstablished,
11376    #[doc = "< \"Send done\" callback function"]
11377    pub mSendDoneCallback: otTcpSendDone,
11378    #[doc = "< \"Forward progress\" callback function"]
11379    pub mForwardProgressCallback: otTcpForwardProgress,
11380    #[doc = "< \"Receive available\" callback function"]
11381    pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11382    #[doc = "< \"Disconnected\" callback function"]
11383    pub mDisconnectedCallback: otTcpDisconnected,
11384    pub mTimers: [u32; 4usize],
11385    pub mReceiveLinks: [otLinkedBuffer; 2usize],
11386    pub mSockAddr: otSockAddr,
11387    pub mPendingCallbacks: u8,
11388}
11389#[repr(C)]
11390#[derive(Copy, Clone)]
11391pub union otTcpEndpoint__bindgen_ty_1 {
11392    pub mSize: [u8; 680usize],
11393    pub mAlign: u64,
11394}
11395impl Default for otTcpEndpoint__bindgen_ty_1 {
11396    fn default() -> Self {
11397        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11398        unsafe {
11399            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11400            s.assume_init()
11401        }
11402    }
11403}
11404impl Default for otTcpEndpoint {
11405    fn default() -> Self {
11406        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11407        unsafe {
11408            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11409            s.assume_init()
11410        }
11411    }
11412}
11413#[doc = " Contains arguments to the otTcpEndpointInitialize() function."]
11414#[repr(C)]
11415#[derive(Debug, Copy, Clone)]
11416pub struct otTcpEndpointInitializeArgs {
11417    #[doc = "< Pointer to application-specific context"]
11418    pub mContext: *mut ::std::os::raw::c_void,
11419    #[doc = "< \"Established\" callback function"]
11420    pub mEstablishedCallback: otTcpEstablished,
11421    #[doc = "< \"Send done\" callback function"]
11422    pub mSendDoneCallback: otTcpSendDone,
11423    #[doc = "< \"Forward progress\" callback function"]
11424    pub mForwardProgressCallback: otTcpForwardProgress,
11425    #[doc = "< \"Receive available\" callback function"]
11426    pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11427    #[doc = "< \"Disconnected\" callback function"]
11428    pub mDisconnectedCallback: otTcpDisconnected,
11429    #[doc = "< Pointer to memory provided to the system for the TCP receive buffer"]
11430    pub mReceiveBuffer: *mut ::std::os::raw::c_void,
11431    #[doc = "< Size of memory provided to the system for the TCP receive buffer"]
11432    pub mReceiveBufferSize: usize,
11433}
11434impl Default for otTcpEndpointInitializeArgs {
11435    fn default() -> Self {
11436        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11437        unsafe {
11438            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11439            s.assume_init()
11440        }
11441    }
11442}
11443extern "C" {
11444    #[doc = " Initializes a TCP endpoint.\n\n Calling this function causes OpenThread to keep track of the TCP endpoint\n and store and retrieve TCP data inside the @p aEndpoint. The application\n should refrain from directly accessing or modifying the fields in\n @p aEndpoint. If the application needs to reclaim the memory backing\n @p aEndpoint, it should call otTcpEndpointDeinitialize().\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEndpoint  A pointer to a TCP endpoint structure.\n @param[in]  aArgs      A pointer to a structure of arguments.\n\n @retval OT_ERROR_NONE    Successfully opened the TCP endpoint.\n @retval OT_ERROR_FAILED  Failed to open the TCP endpoint."]
11445    pub fn otTcpEndpointInitialize(
11446        aInstance: *mut otInstance,
11447        aEndpoint: *mut otTcpEndpoint,
11448        aArgs: *const otTcpEndpointInitializeArgs,
11449    ) -> otError;
11450}
11451extern "C" {
11452    #[doc = " Obtains the otInstance that was associated with @p aEndpoint upon\n initialization.\n\n @param[in]  aEndpoint  The TCP endpoint whose instance to obtain.\n\n @returns  The otInstance pointer associated with @p aEndpoint."]
11453    pub fn otTcpEndpointGetInstance(aEndpoint: *mut otTcpEndpoint) -> *mut otInstance;
11454}
11455extern "C" {
11456    #[doc = " Obtains the context pointer that was associated with @p aEndpoint upon\n initialization.\n\n @param[in]  aEndpoint  The TCP endpoint whose context to obtain.\n\n @returns  The context pointer associated with @p aEndpoint."]
11457    pub fn otTcpEndpointGetContext(aEndpoint: *mut otTcpEndpoint) -> *mut ::std::os::raw::c_void;
11458}
11459extern "C" {
11460    #[doc = " Obtains a pointer to a TCP endpoint's local host and port.\n\n The contents of the host and port may be stale if this socket is not in a\n connected state and has not been bound after it was last disconnected.\n\n @param[in]  aEndpoint  The TCP endpoint whose local host and port to obtain.\n\n @returns  The local host and port of @p aEndpoint."]
11461    pub fn otTcpGetLocalAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11462}
11463extern "C" {
11464    #[doc = " Obtains a pointer to a TCP endpoint's peer's host and port.\n\n The contents of the host and port may be stale if this socket is not in a\n connected state.\n\n @param[in]  aEndpoint  The TCP endpoint whose peer's host and port to obtain.\n\n @returns  The host and port of the connection peer of @p aEndpoint."]
11465    pub fn otTcpGetPeerAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11466}
11467extern "C" {
11468    #[doc = " Binds the TCP endpoint to an IP address and port.\n\n @param[in]  aEndpoint   A pointer to the TCP endpoint structure to bind.\n @param[in]  aSockName   The address and port to which to bind this TCP endpoint.\n\n @retval OT_ERROR_NONE    Successfully bound the TCP endpoint.\n @retval OT_ERROR_FAILED  Failed to bind the TCP endpoint."]
11469    pub fn otTcpBind(aEndpoint: *mut otTcpEndpoint, aSockName: *const otSockAddr) -> otError;
11470}
11471pub const OT_TCP_CONNECT_NO_FAST_OPEN: _bindgen_ty_11 = 1;
11472#[doc = " Defines flags passed to otTcpConnect()."]
11473pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
11474extern "C" {
11475    #[doc = " Records the remote host and port for this connection.\n\n TCP Fast Open must be enabled or disabled using @p aFlags. If it is\n disabled, then the TCP connection establishment handshake is initiated\n immediately. If it is enabled, then this function merely records the\n the remote host and port, and the TCP connection establishment handshake\n only happens on the first call to `otTcpSendByReference()`.\n\n If TCP Fast Open is disabled, then the caller must wait for the\n `otTcpEstablished` callback indicating that TCP connection establishment\n handshake is done before it can start sending data e.g., by calling\n `otTcpSendByReference()`.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure to connect.\n @param[in]  aSockName  The IP address and port of the host to which to connect.\n @param[in]  aFlags     Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE    Successfully completed the operation.\n @retval OT_ERROR_FAILED  Failed to complete the operation."]
11476    pub fn otTcpConnect(
11477        aEndpoint: *mut otTcpEndpoint,
11478        aSockName: *const otSockAddr,
11479        aFlags: u32,
11480    ) -> otError;
11481}
11482pub const OT_TCP_SEND_MORE_TO_COME: _bindgen_ty_12 = 1;
11483#[doc = " Defines flags passed to @p otTcpSendByReference."]
11484pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
11485extern "C" {
11486    #[doc = " Adds data referenced by the linked buffer pointed to by @p aBuffer to the\n send buffer.\n\n Upon a successful call to this function, the linked buffer and data it\n references are owned by the TCP stack; they should not be modified by the\n application until a \"send done\" callback returns ownership of those objects\n to the application. It is acceptable to call this function to add another\n linked buffer to the send queue, even if the \"send done\" callback for a\n previous invocation of this function has not yet fired.\n\n Note that @p aBuffer should not be chained; its mNext field should be\n NULL. If additional data will be added right after this call, then the\n OT_TCP_SEND_MORE_TO_COME flag should be used as a hint to the TCP\n implementation.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint on which to send data.\n @param[in]  aBuffer    A pointer to the linked buffer chain referencing data to add to the send buffer.\n @param[in]  aFlags     Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE    Successfully added data to the send buffer.\n @retval OT_ERROR_FAILED  Failed to add data to the send buffer."]
11487    pub fn otTcpSendByReference(
11488        aEndpoint: *mut otTcpEndpoint,
11489        aBuffer: *mut otLinkedBuffer,
11490        aFlags: u32,
11491    ) -> otError;
11492}
11493extern "C" {
11494    #[doc = " Adds data to the send buffer by extending the length of the final\n otLinkedBuffer in the send buffer by the specified amount.\n\n If the send buffer is empty, then the operation fails.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint on which to send data.\n @param[in]  aNumBytes  The number of bytes by which to extend the length of the final linked buffer.\n @param[in]  aFlags     Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE    Successfully added data to the send buffer.\n @retval OT_ERROR_FAILED  Failed to add data to the send buffer."]
11495    pub fn otTcpSendByExtension(
11496        aEndpoint: *mut otTcpEndpoint,
11497        aNumBytes: usize,
11498        aFlags: u32,
11499    ) -> otError;
11500}
11501extern "C" {
11502    #[doc = " Provides the application with a linked buffer chain referencing data\n currently in the TCP receive buffer.\n\n The linked buffer chain is valid until the \"receive ready\" callback is next\n invoked, or until the next call to otTcpReceiveContiguify() or\n otTcpCommitReceive().\n\n @param[in]   aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint on which to receive\n                         data.\n @param[out]  aBuffer    A pointer to the linked buffer chain referencing data currently in the receive buffer.\n\n @retval OT_ERROR_NONE    Successfully completed the operation.\n @retval OT_ERROR_FAILED  Failed to complete the operation."]
11503    pub fn otTcpReceiveByReference(
11504        aEndpoint: *mut otTcpEndpoint,
11505        aBuffer: *mut *const otLinkedBuffer,
11506    ) -> otError;
11507}
11508extern "C" {
11509    #[doc = " Reorganizes the receive buffer to be entirely contiguous in memory.\n\n This is optional; an application can simply traverse the linked buffer\n chain obtained by calling @p otTcpReceiveByReference. Some\n applications may wish to call this function to make the receive buffer\n contiguous to simplify their data processing, but this comes at the expense\n of CPU time to reorganize the data in the receive buffer.\n\n @param[in]   aEndpoint  A pointer to the TCP endpoint whose receive buffer to reorganize.\n\n @retval OT_ERROR_NONE    Successfully completed the operation.\n @retval OT_ERROR_FAILED  Failed to complete the operation."]
11510    pub fn otTcpReceiveContiguify(aEndpoint: *mut otTcpEndpoint) -> otError;
11511}
11512extern "C" {
11513    #[doc = " Informs the TCP stack that the application has finished processing\n @p aNumBytes bytes of data at the start of the receive buffer and that the\n TCP stack need not continue maintaining those bytes in the receive buffer.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint on which to receive\n                        data.\n @param[in]  aNumBytes  The number of bytes consumed.\n @param[in]  aFlags     Flags specifying options for this operation (none yet).\n\n @retval OT_ERROR_NONE    Successfully completed the receive operation.\n @retval OT_ERROR_FAILED  Failed to complete the receive operation."]
11514    pub fn otTcpCommitReceive(
11515        aEndpoint: *mut otTcpEndpoint,
11516        aNumBytes: usize,
11517        aFlags: u32,
11518    ) -> otError;
11519}
11520extern "C" {
11521    #[doc = " Informs the connection peer that this TCP endpoint will not send more data.\n\n This should be used when the application has no more data to send to the\n connection peer. For this connection, future reads on the connection peer\n will result in the \"end of stream\" condition, and future writes on this\n connection endpoint will fail.\n\n The \"end of stream\" condition only applies after any data previously\n provided to the TCP stack to send out has been received by the connection\n peer.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint to shut down.\n\n @retval OT_ERROR_NONE    Successfully queued the \"end of stream\" condition for transmission.\n @retval OT_ERROR_FAILED  Failed to queue the \"end of stream\" condition for transmission."]
11522    pub fn otTcpSendEndOfStream(aEndpoint: *mut otTcpEndpoint) -> otError;
11523}
11524extern "C" {
11525    #[doc = " Forcibly ends the TCP connection associated with this TCP endpoint.\n\n This immediately makes the TCP endpoint free for use for another connection\n and empties the send and receive buffers, transferring ownership of any data\n provided by the application in otTcpSendByReference() and\n otTcpSendByExtension() calls back to the application. The TCP endpoint's\n callbacks and memory for the receive buffer remain associated with the\n TCP endpoint.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure representing the TCP endpoint to abort.\n\n @retval OT_ERROR_NONE    Successfully aborted the TCP endpoint's connection.\n @retval OT_ERROR_FAILED  Failed to abort the TCP endpoint's connection."]
11526    pub fn otTcpAbort(aEndpoint: *mut otTcpEndpoint) -> otError;
11527}
11528extern "C" {
11529    #[doc = " Deinitializes this TCP endpoint.\n\n This means that OpenThread no longer keeps track of this TCP endpoint and\n deallocates all resources it has internally allocated for this TCP endpoint.\n The application can reuse the memory backing the TCP endpoint as it sees fit.\n\n If it corresponds to a live TCP connection, the connection is terminated\n unceremoniously (as in otTcpAbort()). All resources the application has\n provided for this TCP endpoint (linked buffers for the send buffer, memory\n for the receive buffer, the @p aEndpoint structure itself, etc.) are\n immediately returned to the application.\n\n @param[in]  aEndpoint  A pointer to the TCP endpoint structure to deinitialize.\n\n @retval OT_ERROR_NONE    Successfully deinitialized the TCP endpoint.\n @retval OT_ERROR_FAILED  Failed to deinitialize the TCP endpoint."]
11530    pub fn otTcpEndpointDeinitialize(aEndpoint: *mut otTcpEndpoint) -> otError;
11531}
11532#[doc = "< Accept the incoming connection."]
11533pub const OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT: otTcpIncomingConnectionAction = 0;
11534#[doc = "< Defer (silently ignore) the incoming connection."]
11535pub const OT_TCP_INCOMING_CONNECTION_ACTION_DEFER: otTcpIncomingConnectionAction = 1;
11536#[doc = "< Refuse the incoming connection."]
11537pub const OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE: otTcpIncomingConnectionAction = 2;
11538#[doc = " Defines incoming connection actions.\n\n This is used in otTcpAcceptReady() callback."]
11539pub type otTcpIncomingConnectionAction = ::std::os::raw::c_uint;
11540#[doc = " This callback indicates that an incoming connection that matches this TCP\n listener has arrived.\n\n The typical response is for the application to accept the incoming\n connection. It does so by populating @p aAcceptInto with a pointer to the\n otTcpEndpoint into which to accept the incoming connection. This\n otTcpEndpoint must already be initialized using otTcpEndpointInitialize().\n Then, the application returns OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT.\n\n Alternatively, the application can decline to accept the incoming\n connection. There are two ways for the application to do this. First, if the\n application returns OT_TCP_INCOMING_CONNECTION_ACTION_DEFER, then OpenThread\n silently ignores the connection establishment request; the connection peer\n will likely retransmit the request, at which point the callback will be\n called again. This is valuable if resources are not presently available to\n accept the connection, but they may be available when the connection peer\n retransmits its connection establishment attempt. Second, if the application\n returns OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE, then OpenThread sends a\n \"connection refused\" message to the host that attempted to establish a\n connection. If the application declines the incoming connection, it is not\n required to populate @p aAcceptInto.\n\n @param[in]   aListener    The TCP listener that matches the incoming connection.\n @param[in]   aPeer        The host and port from which the incoming connection originates.\n @param[out]  aAcceptInto  The TCP endpoint into which to accept the incoming connection.\n\n @returns  Description of how to handle the incoming connection."]
11541pub type otTcpAcceptReady = ::std::option::Option<
11542    unsafe extern "C" fn(
11543        aListener: *mut otTcpListener,
11544        aPeer: *const otSockAddr,
11545        aAcceptInto: *mut *mut otTcpEndpoint,
11546    ) -> otTcpIncomingConnectionAction,
11547>;
11548#[doc = " This callback indicates that the TCP connection is now ready for two-way\n communication.\n\n In the case of TCP Fast Open, this may be before the TCP\n connection handshake has actually completed. The application is provided\n with the context pointers both for the TCP listener that accepted the\n connection and the TCP endpoint into which it was accepted. The provided\n context is the one associated with the TCP listener.\n\n @param[in]  aListener  The TCP listener that matches the incoming connection.\n @param[in]  aEndpoint  The TCP endpoint into which the incoming connection was accepted.\n @param[in]  aPeer      the host and port from which the incoming connection originated."]
11549pub type otTcpAcceptDone = ::std::option::Option<
11550    unsafe extern "C" fn(
11551        aListener: *mut otTcpListener,
11552        aEndpoint: *mut otTcpEndpoint,
11553        aPeer: *const otSockAddr,
11554    ),
11555>;
11556#[doc = " Represents a TCP listener.\n\n A TCP listener is used to listen for and accept incoming TCP connections.\n\n The application should not inspect the fields of this structure directly; it\n should only interact with it via the TCP API functions whose signatures are\n provided in this file."]
11557#[repr(C)]
11558#[derive(Copy, Clone)]
11559pub struct otTcpListener {
11560    pub mTcbListen: otTcpListener__bindgen_ty_1,
11561    #[doc = "< A pointer to the next TCP listener (internal use only)"]
11562    pub mNext: *mut otTcpListener,
11563    #[doc = "< A pointer to application-specific context"]
11564    pub mContext: *mut ::std::os::raw::c_void,
11565    #[doc = "< \"Accept ready\" callback function"]
11566    pub mAcceptReadyCallback: otTcpAcceptReady,
11567    #[doc = "< \"Accept done\" callback function"]
11568    pub mAcceptDoneCallback: otTcpAcceptDone,
11569}
11570#[repr(C)]
11571#[derive(Copy, Clone)]
11572pub union otTcpListener__bindgen_ty_1 {
11573    pub mSize: [u8; 40usize],
11574    pub mAlign: *mut ::std::os::raw::c_void,
11575}
11576impl Default for otTcpListener__bindgen_ty_1 {
11577    fn default() -> Self {
11578        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11579        unsafe {
11580            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11581            s.assume_init()
11582        }
11583    }
11584}
11585impl Default for otTcpListener {
11586    fn default() -> Self {
11587        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11588        unsafe {
11589            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11590            s.assume_init()
11591        }
11592    }
11593}
11594#[doc = " Contains arguments to the otTcpListenerInitialize() function."]
11595#[repr(C)]
11596#[derive(Debug, Copy, Clone)]
11597pub struct otTcpListenerInitializeArgs {
11598    #[doc = "< Pointer to application-specific context"]
11599    pub mContext: *mut ::std::os::raw::c_void,
11600    #[doc = "< \"Accept ready\" callback function"]
11601    pub mAcceptReadyCallback: otTcpAcceptReady,
11602    #[doc = "< \"Accept done\" callback function"]
11603    pub mAcceptDoneCallback: otTcpAcceptDone,
11604}
11605impl Default for otTcpListenerInitializeArgs {
11606    fn default() -> Self {
11607        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11608        unsafe {
11609            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11610            s.assume_init()
11611        }
11612    }
11613}
11614extern "C" {
11615    #[doc = " Initializes a TCP listener.\n\n Calling this function causes OpenThread to keep track of the TCP listener\n and store and retrieve TCP data inside @p aListener. The application should\n refrain from directly accessing or modifying the fields in @p aListener. If\n the application needs to reclaim the memory backing @p aListener, it should\n call otTcpListenerDeinitialize().\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aListener  A pointer to a TCP listener structure.\n @param[in]  aArgs      A pointer to a structure of arguments.\n\n @retval OT_ERROR_NONE    Successfully opened the TCP listener.\n @retval OT_ERROR_FAILED  Failed to open the TCP listener."]
11616    pub fn otTcpListenerInitialize(
11617        aInstance: *mut otInstance,
11618        aListener: *mut otTcpListener,
11619        aArgs: *const otTcpListenerInitializeArgs,
11620    ) -> otError;
11621}
11622extern "C" {
11623    #[doc = " Obtains the otInstance that was associated with @p aListener upon\n initialization.\n\n @param[in]  aListener  The TCP listener whose instance to obtain.\n\n @returns  The otInstance pointer associated with @p aListener."]
11624    pub fn otTcpListenerGetInstance(aListener: *mut otTcpListener) -> *mut otInstance;
11625}
11626extern "C" {
11627    #[doc = " Obtains the context pointer that was associated with @p aListener upon\n initialization.\n\n @param[in]  aListener  The TCP listener whose context to obtain.\n\n @returns  The context pointer associated with @p aListener."]
11628    pub fn otTcpListenerGetContext(aListener: *mut otTcpListener) -> *mut ::std::os::raw::c_void;
11629}
11630extern "C" {
11631    #[doc = " Causes incoming TCP connections that match the specified IP address and port\n to trigger this TCP listener's callbacks.\n\n @param[in]  aListener  A pointer to the TCP listener structure that should begin listening.\n @param[in]  aSockName  The address and port on which to listen for incoming connections.\n\n @retval OT_ERROR_NONE    Successfully initiated listening on the TCP listener.\n @retval OT_ERROR_FAILED  Failed to initiate listening on the TCP listener."]
11632    pub fn otTcpListen(aListener: *mut otTcpListener, aSockName: *const otSockAddr) -> otError;
11633}
11634extern "C" {
11635    #[doc = " Causes this TCP listener to stop listening for incoming connections.\n\n @param[in]  aListener  A pointer to the TCP listener structure that should stop listening.\n\n @retval OT_ERROR_NONE    Successfully stopped listening on the TCP listener.\n @retval OT_ERROR_FAILED  Failed to stop listening on the TCP listener."]
11636    pub fn otTcpStopListening(aListener: *mut otTcpListener) -> otError;
11637}
11638extern "C" {
11639    #[doc = " Deinitializes this TCP listener.\n\n This means that OpenThread no longer keeps track of this TCP listener and\n deallocates all resources it has internally allocated for this TCP listener.\n The application can reuse the memory backing the TCP listener as it sees\n fit.\n\n If the TCP listener is currently listening, it stops listening.\n\n @param[in]  aListener  A pointer to the TCP listener structure to deinitialize.\n\n @retval OT_ERROR_NONE    Successfully deinitialized the TCP listener.\n @retval OT_ERROR_FAILED  Failed to deinitialize the TCP listener."]
11640    pub fn otTcpListenerDeinitialize(aListener: *mut otTcpListener) -> otError;
11641}
11642#[doc = " Holds diagnostic information for a Thread Child"]
11643#[repr(C)]
11644#[derive(Debug, Default, Copy, Clone)]
11645pub struct otChildInfo {
11646    #[doc = "< IEEE 802.15.4 Extended Address"]
11647    pub mExtAddress: otExtAddress,
11648    #[doc = "< Timeout"]
11649    pub mTimeout: u32,
11650    #[doc = "< Seconds since last heard"]
11651    pub mAge: u32,
11652    #[doc = "< Seconds since attach (requires `OPENTHREAD_CONFIG_UPTIME_ENABLE`)"]
11653    pub mConnectionTime: u64,
11654    #[doc = "< RLOC16"]
11655    pub mRloc16: u16,
11656    #[doc = "< Child ID"]
11657    pub mChildId: u16,
11658    #[doc = "< Network Data Version"]
11659    pub mNetworkDataVersion: u8,
11660    #[doc = "< Link Quality In"]
11661    pub mLinkQualityIn: u8,
11662    #[doc = "< Average RSSI"]
11663    pub mAverageRssi: i8,
11664    #[doc = "< Last observed RSSI"]
11665    pub mLastRssi: i8,
11666    #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
11667    pub mFrameErrorRate: u16,
11668    #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
11669    pub mMessageErrorRate: u16,
11670    #[doc = "< Number of queued messages for the child."]
11671    pub mQueuedMessageCnt: u16,
11672    #[doc = "< Supervision interval (in seconds)."]
11673    pub mSupervisionInterval: u16,
11674    #[doc = "< MLE version"]
11675    pub mVersion: u8,
11676    pub _bitfield_align_1: [u8; 0],
11677    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11678    pub __bindgen_padding_0: [u16; 3usize],
11679}
11680impl otChildInfo {
11681    #[inline]
11682    pub fn mRxOnWhenIdle(&self) -> bool {
11683        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11684    }
11685    #[inline]
11686    pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
11687        unsafe {
11688            let val: u8 = ::std::mem::transmute(val);
11689            self._bitfield_1.set(0usize, 1u8, val as u64)
11690        }
11691    }
11692    #[inline]
11693    pub fn mFullThreadDevice(&self) -> bool {
11694        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11695    }
11696    #[inline]
11697    pub fn set_mFullThreadDevice(&mut self, val: bool) {
11698        unsafe {
11699            let val: u8 = ::std::mem::transmute(val);
11700            self._bitfield_1.set(1usize, 1u8, val as u64)
11701        }
11702    }
11703    #[inline]
11704    pub fn mFullNetworkData(&self) -> bool {
11705        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11706    }
11707    #[inline]
11708    pub fn set_mFullNetworkData(&mut self, val: bool) {
11709        unsafe {
11710            let val: u8 = ::std::mem::transmute(val);
11711            self._bitfield_1.set(2usize, 1u8, val as u64)
11712        }
11713    }
11714    #[inline]
11715    pub fn mIsStateRestoring(&self) -> bool {
11716        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
11717    }
11718    #[inline]
11719    pub fn set_mIsStateRestoring(&mut self, val: bool) {
11720        unsafe {
11721            let val: u8 = ::std::mem::transmute(val);
11722            self._bitfield_1.set(3usize, 1u8, val as u64)
11723        }
11724    }
11725    #[inline]
11726    pub fn mIsCslSynced(&self) -> bool {
11727        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
11728    }
11729    #[inline]
11730    pub fn set_mIsCslSynced(&mut self, val: bool) {
11731        unsafe {
11732            let val: u8 = ::std::mem::transmute(val);
11733            self._bitfield_1.set(4usize, 1u8, val as u64)
11734        }
11735    }
11736    #[inline]
11737    pub fn new_bitfield_1(
11738        mRxOnWhenIdle: bool,
11739        mFullThreadDevice: bool,
11740        mFullNetworkData: bool,
11741        mIsStateRestoring: bool,
11742        mIsCslSynced: bool,
11743    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11744        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11745        __bindgen_bitfield_unit.set(0usize, 1u8, {
11746            let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
11747            mRxOnWhenIdle as u64
11748        });
11749        __bindgen_bitfield_unit.set(1usize, 1u8, {
11750            let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
11751            mFullThreadDevice as u64
11752        });
11753        __bindgen_bitfield_unit.set(2usize, 1u8, {
11754            let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
11755            mFullNetworkData as u64
11756        });
11757        __bindgen_bitfield_unit.set(3usize, 1u8, {
11758            let mIsStateRestoring: u8 = unsafe { ::std::mem::transmute(mIsStateRestoring) };
11759            mIsStateRestoring as u64
11760        });
11761        __bindgen_bitfield_unit.set(4usize, 1u8, {
11762            let mIsCslSynced: u8 = unsafe { ::std::mem::transmute(mIsCslSynced) };
11763            mIsCslSynced as u64
11764        });
11765        __bindgen_bitfield_unit
11766    }
11767}
11768pub type otChildIp6AddressIterator = u16;
11769pub const OT_CACHE_ENTRY_STATE_CACHED: otCacheEntryState = 0;
11770pub const OT_CACHE_ENTRY_STATE_SNOOPED: otCacheEntryState = 1;
11771pub const OT_CACHE_ENTRY_STATE_QUERY: otCacheEntryState = 2;
11772pub const OT_CACHE_ENTRY_STATE_RETRY_QUERY: otCacheEntryState = 3;
11773#[doc = " Defines the EID cache entry state."]
11774pub type otCacheEntryState = ::std::os::raw::c_uint;
11775#[doc = " Represents an EID cache entry."]
11776#[repr(C)]
11777#[derive(Copy, Clone)]
11778pub struct otCacheEntryInfo {
11779    #[doc = "< Target EID"]
11780    pub mTarget: otIp6Address,
11781    #[doc = "< RLOC16"]
11782    pub mRloc16: otShortAddress,
11783    #[doc = "< Entry state"]
11784    pub mState: otCacheEntryState,
11785    pub _bitfield_align_1: [u8; 0],
11786    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11787    #[doc = "< Last transaction time (applicable in cached state)."]
11788    pub mLastTransTime: u32,
11789    #[doc = "< Mesh Local EID (applicable if entry in cached state)."]
11790    pub mMeshLocalEid: otIp6Address,
11791    #[doc = "< Timeout in seconds (applicable if in snooped/query/retry-query states)."]
11792    pub mTimeout: u16,
11793    #[doc = "< Retry delay in seconds (applicable if in query-retry state)."]
11794    pub mRetryDelay: u16,
11795}
11796impl Default for otCacheEntryInfo {
11797    fn default() -> Self {
11798        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11799        unsafe {
11800            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11801            s.assume_init()
11802        }
11803    }
11804}
11805impl otCacheEntryInfo {
11806    #[inline]
11807    pub fn mCanEvict(&self) -> bool {
11808        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11809    }
11810    #[inline]
11811    pub fn set_mCanEvict(&mut self, val: bool) {
11812        unsafe {
11813            let val: u8 = ::std::mem::transmute(val);
11814            self._bitfield_1.set(0usize, 1u8, val as u64)
11815        }
11816    }
11817    #[inline]
11818    pub fn mRampDown(&self) -> bool {
11819        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11820    }
11821    #[inline]
11822    pub fn set_mRampDown(&mut self, val: bool) {
11823        unsafe {
11824            let val: u8 = ::std::mem::transmute(val);
11825            self._bitfield_1.set(1usize, 1u8, val as u64)
11826        }
11827    }
11828    #[inline]
11829    pub fn mValidLastTrans(&self) -> bool {
11830        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11831    }
11832    #[inline]
11833    pub fn set_mValidLastTrans(&mut self, val: bool) {
11834        unsafe {
11835            let val: u8 = ::std::mem::transmute(val);
11836            self._bitfield_1.set(2usize, 1u8, val as u64)
11837        }
11838    }
11839    #[inline]
11840    pub fn new_bitfield_1(
11841        mCanEvict: bool,
11842        mRampDown: bool,
11843        mValidLastTrans: bool,
11844    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11845        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11846        __bindgen_bitfield_unit.set(0usize, 1u8, {
11847            let mCanEvict: u8 = unsafe { ::std::mem::transmute(mCanEvict) };
11848            mCanEvict as u64
11849        });
11850        __bindgen_bitfield_unit.set(1usize, 1u8, {
11851            let mRampDown: u8 = unsafe { ::std::mem::transmute(mRampDown) };
11852            mRampDown as u64
11853        });
11854        __bindgen_bitfield_unit.set(2usize, 1u8, {
11855            let mValidLastTrans: u8 = unsafe { ::std::mem::transmute(mValidLastTrans) };
11856            mValidLastTrans as u64
11857        });
11858        __bindgen_bitfield_unit
11859    }
11860}
11861#[doc = " Represents an iterator used for iterating through the EID cache table entries.\n\n To initialize the iterator and start from the first entry in the cache table, set all its fields in the structure to\n zero (e.g., `memset` the iterator to zero)."]
11862#[repr(C)]
11863#[derive(Debug, Copy, Clone)]
11864pub struct otCacheEntryIterator {
11865    #[doc = "< Opaque data used by the core implementation. Should not be changed by user."]
11866    pub mData: [*const ::std::os::raw::c_void; 2usize],
11867}
11868impl Default for otCacheEntryIterator {
11869    fn default() -> Self {
11870        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11871        unsafe {
11872            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11873            s.assume_init()
11874        }
11875    }
11876}
11877extern "C" {
11878    #[doc = " Gets the maximum number of children currently allowed.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of children currently allowed.\n\n @sa otThreadSetMaxAllowedChildren"]
11879    pub fn otThreadGetMaxAllowedChildren(aInstance: *mut otInstance) -> u16;
11880}
11881extern "C" {
11882    #[doc = " Sets the maximum number of children currently allowed.\n\n This parameter can only be set when Thread protocol operation has been stopped.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMaxChildren  The maximum allowed children.\n\n @retval  OT_ERROR_NONE           Successfully set the max.\n @retval  OT_ERROR_INVALID_ARGS   If @p aMaxChildren is not in the range [1, OPENTHREAD_CONFIG_MLE_MAX_CHILDREN].\n @retval  OT_ERROR_INVALID_STATE  If Thread isn't stopped.\n\n @sa otThreadGetMaxAllowedChildren"]
11883    pub fn otThreadSetMaxAllowedChildren(aInstance: *mut otInstance, aMaxChildren: u16) -> otError;
11884}
11885extern "C" {
11886    #[doc = " Indicates whether or not the device is router-eligible.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval TRUE   If device is router-eligible.\n @retval FALSE  If device is not router-eligible."]
11887    pub fn otThreadIsRouterEligible(aInstance: *mut otInstance) -> bool;
11888}
11889extern "C" {
11890    #[doc = " Sets whether or not the device is router-eligible.\n\n If @p aEligible is false and the device is currently operating as a router, this call will cause the device to\n detach and attempt to reattach as a child.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEligible  TRUE to configure the device as router-eligible, FALSE otherwise.\n\n @retval OT_ERROR_NONE         Successfully set the router-eligible configuration.\n @retval OT_ERROR_NOT_CAPABLE  The device is not capable of becoming a router."]
11891    pub fn otThreadSetRouterEligible(aInstance: *mut otInstance, aEligible: bool) -> otError;
11892}
11893extern "C" {
11894    #[doc = " Set the preferred Router Id.\n\n Upon becoming a router/leader the node attempts to use this Router Id. If the preferred Router Id is not set or if\n it can not be used, a randomly generated router id is picked. This property can be set only when the device role is\n either detached or disabled.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n @param[in]  aRouterId    The preferred Router Id.\n\n @retval OT_ERROR_NONE          Successfully set the preferred Router Id.\n @retval OT_ERROR_INVALID_STATE Could not set (role is not detached or disabled)"]
11895    pub fn otThreadSetPreferredRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
11896}
11897#[doc = "< Battery powered."]
11898pub const OT_POWER_SUPPLY_BATTERY: otPowerSupply = 0;
11899#[doc = "< Externally powered (mains-powered)."]
11900pub const OT_POWER_SUPPLY_EXTERNAL: otPowerSupply = 1;
11901#[doc = "< Stable external power with a battery backup or UPS."]
11902pub const OT_POWER_SUPPLY_EXTERNAL_STABLE: otPowerSupply = 2;
11903#[doc = "< Potentially unstable ext power (e.g. light bulb powered via a switch)."]
11904pub const OT_POWER_SUPPLY_EXTERNAL_UNSTABLE: otPowerSupply = 3;
11905#[doc = " Represents the power supply property on a device.\n\n This is used as a property in `otDeviceProperties` to calculate the leader weight."]
11906pub type otPowerSupply = ::std::os::raw::c_uint;
11907#[doc = " Represents the device properties which are used for calculating the local leader weight on a\n device.\n\n The parameters are set based on device's capability, whether acting as border router, its power supply config, etc.\n\n `mIsUnstable` indicates operational stability of device and is determined via a vendor specific mechanism. It can\n include the following cases:\n  - Device internally detects that it loses external power supply more often than usual. What is usual is\n    determined by the vendor.\n  - Device internally detects that it reboots more often than usual. What is usual is determined by the vendor."]
11908#[repr(C)]
11909#[derive(Debug, Copy, Clone)]
11910pub struct otDeviceProperties {
11911    #[doc = "< Power supply config."]
11912    pub mPowerSupply: otPowerSupply,
11913    pub _bitfield_align_1: [u8; 0],
11914    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11915    #[doc = "< Weight adjustment. Should be -16 to +16 (clamped otherwise)."]
11916    pub mLeaderWeightAdjustment: i8,
11917}
11918impl Default for otDeviceProperties {
11919    fn default() -> Self {
11920        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11921        unsafe {
11922            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11923            s.assume_init()
11924        }
11925    }
11926}
11927impl otDeviceProperties {
11928    #[inline]
11929    pub fn mIsBorderRouter(&self) -> bool {
11930        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11931    }
11932    #[inline]
11933    pub fn set_mIsBorderRouter(&mut self, val: bool) {
11934        unsafe {
11935            let val: u8 = ::std::mem::transmute(val);
11936            self._bitfield_1.set(0usize, 1u8, val as u64)
11937        }
11938    }
11939    #[inline]
11940    pub fn mSupportsCcm(&self) -> bool {
11941        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11942    }
11943    #[inline]
11944    pub fn set_mSupportsCcm(&mut self, val: bool) {
11945        unsafe {
11946            let val: u8 = ::std::mem::transmute(val);
11947            self._bitfield_1.set(1usize, 1u8, val as u64)
11948        }
11949    }
11950    #[inline]
11951    pub fn mIsUnstable(&self) -> bool {
11952        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11953    }
11954    #[inline]
11955    pub fn set_mIsUnstable(&mut self, val: bool) {
11956        unsafe {
11957            let val: u8 = ::std::mem::transmute(val);
11958            self._bitfield_1.set(2usize, 1u8, val as u64)
11959        }
11960    }
11961    #[inline]
11962    pub fn new_bitfield_1(
11963        mIsBorderRouter: bool,
11964        mSupportsCcm: bool,
11965        mIsUnstable: bool,
11966    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11967        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11968        __bindgen_bitfield_unit.set(0usize, 1u8, {
11969            let mIsBorderRouter: u8 = unsafe { ::std::mem::transmute(mIsBorderRouter) };
11970            mIsBorderRouter as u64
11971        });
11972        __bindgen_bitfield_unit.set(1usize, 1u8, {
11973            let mSupportsCcm: u8 = unsafe { ::std::mem::transmute(mSupportsCcm) };
11974            mSupportsCcm as u64
11975        });
11976        __bindgen_bitfield_unit.set(2usize, 1u8, {
11977            let mIsUnstable: u8 = unsafe { ::std::mem::transmute(mIsUnstable) };
11978            mIsUnstable as u64
11979        });
11980        __bindgen_bitfield_unit
11981    }
11982}
11983extern "C" {
11984    #[doc = " Get the current device properties.\n\n Requires `OPENTHREAD_CONFIG_MLE_DEVICE_PROPERTY_LEADER_WEIGHT_ENABLE`.\n\n @returns The device properties `otDeviceProperties`."]
11985    pub fn otThreadGetDeviceProperties(aInstance: *mut otInstance) -> *const otDeviceProperties;
11986}
11987extern "C" {
11988    #[doc = " Set the device properties which are then used to determine and set the Leader Weight.\n\n Requires `OPENTHREAD_CONFIG_MLE_DEVICE_PROPERTY_LEADER_WEIGHT_ENABLE`.\n\n @param[in]  aInstance           A pointer to an OpenThread instance.\n @param[in]  aDeviceProperties   The device properties."]
11989    pub fn otThreadSetDeviceProperties(
11990        aInstance: *mut otInstance,
11991        aDeviceProperties: *const otDeviceProperties,
11992    );
11993}
11994extern "C" {
11995    #[doc = " Gets the Thread Leader Weight used when operating in the Leader role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Leader Weight value.\n\n @sa otThreadSetLeaderWeight\n @sa otThreadSetDeviceProperties"]
11996    pub fn otThreadGetLocalLeaderWeight(aInstance: *mut otInstance) -> u8;
11997}
11998extern "C" {
11999    #[doc = " Sets the Thread Leader Weight used when operating in the Leader role.\n\n Directly sets the Leader Weight to the new value, replacing its previous value (which may have been\n determined from the current `otDeviceProperties`).\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aWeight   The Thread Leader Weight value.\n\n @sa otThreadGetLeaderWeight"]
12000    pub fn otThreadSetLocalLeaderWeight(aInstance: *mut otInstance, aWeight: u8);
12001}
12002extern "C" {
12003    #[doc = " Get the preferred Thread Leader Partition Id used when operating in the Leader role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Leader Partition Id value."]
12004    pub fn otThreadGetPreferredLeaderPartitionId(aInstance: *mut otInstance) -> u32;
12005}
12006extern "C" {
12007    #[doc = " Set the preferred Thread Leader Partition Id used when operating in the Leader role.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aPartitionId  The Thread Leader Partition Id value."]
12008    pub fn otThreadSetPreferredLeaderPartitionId(aInstance: *mut otInstance, aPartitionId: u32);
12009}
12010extern "C" {
12011    #[doc = " Gets the Joiner UDP Port.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Joiner UDP Port number.\n\n @sa otThreadSetJoinerUdpPort"]
12012    pub fn otThreadGetJoinerUdpPort(aInstance: *mut otInstance) -> u16;
12013}
12014extern "C" {
12015    #[doc = " Sets the Joiner UDP Port.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aJoinerUdpPort  The Joiner UDP Port number.\n\n @retval  OT_ERROR_NONE  Successfully set the Joiner UDP Port.\n\n @sa otThreadGetJoinerUdpPort"]
12016    pub fn otThreadSetJoinerUdpPort(aInstance: *mut otInstance, aJoinerUdpPort: u16) -> otError;
12017}
12018extern "C" {
12019    #[doc = " Set Steering data out of band.\n\n Configuration option `OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE` should be set to enable setting of steering\n data out of band.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aExtAddress     Address used to update the steering data.\n                             All zeros to clear the steering data (no steering data).\n                             All 0xFFs to set steering data/bloom filter to accept/allow all.\n                             A specific EUI64 which is then added to current steering data/bloom filter."]
12020    pub fn otThreadSetSteeringData(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
12021}
12022extern "C" {
12023    #[doc = " Get the CONTEXT_ID_REUSE_DELAY parameter used in the Leader role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The CONTEXT_ID_REUSE_DELAY value.\n\n @sa otThreadSetContextIdReuseDelay"]
12024    pub fn otThreadGetContextIdReuseDelay(aInstance: *mut otInstance) -> u32;
12025}
12026extern "C" {
12027    #[doc = " Set the CONTEXT_ID_REUSE_DELAY parameter used in the Leader role.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aDelay    The CONTEXT_ID_REUSE_DELAY value.\n\n @sa otThreadGetContextIdReuseDelay"]
12028    pub fn otThreadSetContextIdReuseDelay(aInstance: *mut otInstance, aDelay: u32);
12029}
12030extern "C" {
12031    #[doc = " Get the `NETWORK_ID_TIMEOUT` parameter.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The `NETWORK_ID_TIMEOUT` value.\n\n @sa otThreadSetNetworkIdTimeout"]
12032    pub fn otThreadGetNetworkIdTimeout(aInstance: *mut otInstance) -> u8;
12033}
12034extern "C" {
12035    #[doc = " Set the `NETWORK_ID_TIMEOUT` parameter.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n @param[in]  aTimeout  The `NETWORK_ID_TIMEOUT` value.\n\n @sa otThreadGetNetworkIdTimeout"]
12036    pub fn otThreadSetNetworkIdTimeout(aInstance: *mut otInstance, aTimeout: u8);
12037}
12038extern "C" {
12039    #[doc = " Get the ROUTER_UPGRADE_THRESHOLD parameter used in the REED role.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The ROUTER_UPGRADE_THRESHOLD value.\n\n @sa otThreadSetRouterUpgradeThreshold"]
12040    pub fn otThreadGetRouterUpgradeThreshold(aInstance: *mut otInstance) -> u8;
12041}
12042extern "C" {
12043    #[doc = " Set the ROUTER_UPGRADE_THRESHOLD parameter used in the Leader role.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aThreshold  The ROUTER_UPGRADE_THRESHOLD value.\n\n @sa otThreadGetRouterUpgradeThreshold"]
12044    pub fn otThreadSetRouterUpgradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12045}
12046extern "C" {
12047    #[doc = " Get the MLE_CHILD_ROUTER_LINKS parameter used in the REED role.\n\n This parameter specifies the max number of neighboring routers with which the device (as an FED)\n  will try to establish link.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The MLE_CHILD_ROUTER_LINKS value.\n\n @sa otThreadSetChildRouterLinks"]
12048    pub fn otThreadGetChildRouterLinks(aInstance: *mut otInstance) -> u8;
12049}
12050extern "C" {
12051    #[doc = " Set the MLE_CHILD_ROUTER_LINKS parameter used in the REED role.\n\n @param[in]  aInstance         A pointer to an OpenThread instance.\n @param[in]  aChildRouterLinks The MLE_CHILD_ROUTER_LINKS value.\n\n @retval OT_ERROR_NONE           Successfully set the value.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetChildRouterLinks"]
12052    pub fn otThreadSetChildRouterLinks(
12053        aInstance: *mut otInstance,
12054        aChildRouterLinks: u8,
12055    ) -> otError;
12056}
12057extern "C" {
12058    #[doc = " Release a Router ID that has been allocated by the device in the Leader role.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aRouterId  The Router ID to release. Valid range is [0, 62].\n\n @retval OT_ERROR_NONE           Successfully released the router id.\n @retval OT_ERROR_INVALID_ARGS   @p aRouterId is not in the range [0, 62].\n @retval OT_ERROR_INVALID_STATE  The device is not currently operating as a leader.\n @retval OT_ERROR_NOT_FOUND      The router id is not currently allocated."]
12059    pub fn otThreadReleaseRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
12060}
12061extern "C" {
12062    #[doc = " Attempt to become a router.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully begin attempt to become a router.\n @retval OT_ERROR_INVALID_STATE  Thread is disabled."]
12063    pub fn otThreadBecomeRouter(aInstance: *mut otInstance) -> otError;
12064}
12065extern "C" {
12066    #[doc = " Become a leader and start a new partition.\n\n If the device is not attached, this API will force the device to start as the leader of the network. This use case\n is only intended for testing and demo purposes, and using the API while the device is detached can make a production\n application non-compliant with the Thread Specification.\n\n If the device is already attached, this API can be used to try to take over as the leader, creating a new partition.\n For this to work, the local leader weight (`otThreadGetLocalLeaderWeight()`) must be larger than the weight of the\n current leader (`otThreadGetLeaderWeight()`). If it is not, `OT_ERROR_NOT_CAPABLE` is returned to indicate to the\n caller that they need to adjust the weight.\n\n Taking over the leader role in this way is only allowed when triggered by an explicit user action. Using this API\n without such user action can make a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE           Successfully became a leader and started a new partition, or was leader already.\n @retval OT_ERROR_INVALID_STATE  Thread is disabled.\n @retval OT_ERROR_NOT_CAPABLE    Device cannot override the current leader due to its local leader weight being same\n                                 or smaller than current leader's weight, or device is not router eligible."]
12067    pub fn otThreadBecomeLeader(aInstance: *mut otInstance) -> otError;
12068}
12069extern "C" {
12070    #[doc = " Get the ROUTER_DOWNGRADE_THRESHOLD parameter used in the Router role.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns The ROUTER_DOWNGRADE_THRESHOLD value.\n\n @sa otThreadSetRouterDowngradeThreshold"]
12071    pub fn otThreadGetRouterDowngradeThreshold(aInstance: *mut otInstance) -> u8;
12072}
12073extern "C" {
12074    #[doc = " Set the ROUTER_DOWNGRADE_THRESHOLD parameter used in the Leader role.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aThreshold  The ROUTER_DOWNGRADE_THRESHOLD value.\n\n @sa otThreadGetRouterDowngradeThreshold"]
12075    pub fn otThreadSetRouterDowngradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12076}
12077extern "C" {
12078    #[doc = " Get the ROUTER_SELECTION_JITTER parameter used in the REED/Router role.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n\n @returns The ROUTER_SELECTION_JITTER value.\n\n @sa otThreadSetRouterSelectionJitter"]
12079    pub fn otThreadGetRouterSelectionJitter(aInstance: *mut otInstance) -> u8;
12080}
12081extern "C" {
12082    #[doc = " Set the ROUTER_SELECTION_JITTER parameter used in the REED/Router role.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance      A pointer to an OpenThread instance.\n @param[in]  aRouterJitter  The ROUTER_SELECTION_JITTER value.\n\n @sa otThreadGetRouterSelectionJitter"]
12083    pub fn otThreadSetRouterSelectionJitter(aInstance: *mut otInstance, aRouterJitter: u8);
12084}
12085extern "C" {
12086    #[doc = " Gets diagnostic information for an attached Child by its Child ID or RLOC16.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n @param[in]   aChildId    The Child ID or RLOC16 for the attached child.\n @param[out]  aChildInfo  A pointer to where the child information is placed.\n\n @retval OT_ERROR_NONE          @p aChildInfo was successfully updated with the info for the given ID.\n @retval OT_ERROR_NOT_FOUND     No valid child with this Child ID.\n @retval OT_ERROR_INVALID_ARGS  If @p aChildInfo is NULL."]
12087    pub fn otThreadGetChildInfoById(
12088        aInstance: *mut otInstance,
12089        aChildId: u16,
12090        aChildInfo: *mut otChildInfo,
12091    ) -> otError;
12092}
12093extern "C" {
12094    #[doc = " The function retains diagnostic information for an attached Child by the internal table index.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[in]   aChildIndex  The table index.\n @param[out]  aChildInfo   A pointer to where the child information is placed.\n\n @retval OT_ERROR_NONE             @p aChildInfo was successfully updated with the info for the given index.\n @retval OT_ERROR_NOT_FOUND        No valid child at this index.\n @retval OT_ERROR_INVALID_ARGS     Either @p aChildInfo is NULL, or @p aChildIndex is out of range (higher\n                                   than max table index).\n\n @sa otGetMaxAllowedChildren"]
12095    pub fn otThreadGetChildInfoByIndex(
12096        aInstance: *mut otInstance,
12097        aChildIndex: u16,
12098        aChildInfo: *mut otChildInfo,
12099    ) -> otError;
12100}
12101extern "C" {
12102    #[doc = " Gets the next IPv6 address (using an iterator) for a given child.\n\n @param[in]      aInstance    A pointer to an OpenThread instance.\n @param[in]      aChildIndex  The child index.\n @param[in,out]  aIterator    A pointer to the iterator. On success the iterator will be updated to point to next\n                              entry in the list. To get the first IPv6 address the iterator should be set to\n                              OT_CHILD_IP6_ADDRESS_ITERATOR_INIT.\n @param[out]     aAddress     A pointer to an IPv6 address where the child's next address is placed (on success).\n\n @retval OT_ERROR_NONE          Successfully found the next IPv6 address (@p aAddress was successfully updated).\n @retval OT_ERROR_NOT_FOUND     The child has no subsequent IPv6 address entry.\n @retval OT_ERROR_INVALID_ARGS  @p aIterator or @p aAddress are NULL, or child at @p aChildIndex is not valid.\n\n @sa otThreadGetChildInfoByIndex"]
12103    pub fn otThreadGetChildNextIp6Address(
12104        aInstance: *mut otInstance,
12105        aChildIndex: u16,
12106        aIterator: *mut otChildIp6AddressIterator,
12107        aAddress: *mut otIp6Address,
12108    ) -> otError;
12109}
12110extern "C" {
12111    #[doc = " Get the current Router ID Sequence.\n\n @param[in]  aInstance A pointer to an OpenThread instance.\n\n @returns The Router ID Sequence."]
12112    pub fn otThreadGetRouterIdSequence(aInstance: *mut otInstance) -> u8;
12113}
12114extern "C" {
12115    #[doc = " The function returns the maximum allowed router ID\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n\n @returns The maximum allowed router ID."]
12116    pub fn otThreadGetMaxRouterId(aInstance: *mut otInstance) -> u8;
12117}
12118extern "C" {
12119    #[doc = " The function retains diagnostic information for a given Thread Router.\n\n @param[in]   aInstance    A pointer to an OpenThread instance.\n @param[in]   aRouterId    The router ID or RLOC16 for a given router.\n @param[out]  aRouterInfo  A pointer to where the router information is placed.\n\n @retval OT_ERROR_NONE          Successfully retrieved the router info for given id.\n @retval OT_ERROR_NOT_FOUND     No router entry with the given id.\n @retval OT_ERROR_INVALID_ARGS  @p aRouterInfo is NULL."]
12120    pub fn otThreadGetRouterInfo(
12121        aInstance: *mut otInstance,
12122        aRouterId: u16,
12123        aRouterInfo: *mut otRouterInfo,
12124    ) -> otError;
12125}
12126extern "C" {
12127    #[doc = " Gets the next EID cache entry (using an iterator).\n\n @param[in]     aInstance   A pointer to an OpenThread instance.\n @param[out]    aEntryInfo  A pointer to where the EID cache entry information is placed.\n @param[in,out] aIterator   A pointer to an iterator. It will be updated to point to next entry on success. To get\n                            the first entry, initialize the iterator by setting all its fields to zero\n                            (e.g., `memset` the iterator structure to zero).\n\n @retval OT_ERROR_NONE          Successfully populated @p aEntryInfo for next EID cache entry.\n @retval OT_ERROR_NOT_FOUND     No more entries in the address cache table."]
12128    pub fn otThreadGetNextCacheEntry(
12129        aInstance: *mut otInstance,
12130        aEntryInfo: *mut otCacheEntryInfo,
12131        aIterator: *mut otCacheEntryIterator,
12132    ) -> otError;
12133}
12134extern "C" {
12135    #[doc = " Get the Thread PSKc\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n @param[out]  aPskc       A pointer to an `otPskc` to return the retrieved Thread PSKc.\n\n @sa otThreadSetPskc"]
12136    pub fn otThreadGetPskc(aInstance: *mut otInstance, aPskc: *mut otPskc);
12137}
12138extern "C" {
12139    #[doc = " Get Key Reference to Thread PSKc stored\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n\n @returns Key Reference to PSKc\n\n @sa otThreadSetPskcRef"]
12140    pub fn otThreadGetPskcRef(aInstance: *mut otInstance) -> otPskcRef;
12141}
12142extern "C" {
12143    #[doc = " Set the Thread PSKc\n\n Will only succeed when Thread protocols are disabled.  A successful\n call to this function will also invalidate the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aPskc       A pointer to the new Thread PSKc.\n\n @retval OT_ERROR_NONE           Successfully set the Thread PSKc.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetPskc"]
12144    pub fn otThreadSetPskc(aInstance: *mut otInstance, aPskc: *const otPskc) -> otError;
12145}
12146extern "C" {
12147    #[doc = " Set the Key Reference to the Thread PSKc\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n Will only succeed when Thread protocols are disabled.  Upon success,\n this will also invalidate the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in]  aInstance   A pointer to an OpenThread instance.\n @param[in]  aKeyRef     Key Reference to the new Thread PSKc.\n\n @retval OT_ERROR_NONE           Successfully set the Thread PSKc.\n @retval OT_ERROR_INVALID_STATE  Thread protocols are enabled.\n\n @sa otThreadGetPskcRef"]
12148    pub fn otThreadSetPskcRef(aInstance: *mut otInstance, aKeyRef: otPskcRef) -> otError;
12149}
12150extern "C" {
12151    #[doc = " Get the assigned parent priority.\n\n @param[in]   aInstance   A pointer to an OpenThread instance.\n\n @returns The assigned parent priority value, -2 means not assigned.\n\n @sa otThreadSetParentPriority"]
12152    pub fn otThreadGetParentPriority(aInstance: *mut otInstance) -> i8;
12153}
12154extern "C" {
12155    #[doc = " Set the parent priority.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aParentPriority  The parent priority value.\n\n @retval OT_ERROR_NONE           Successfully set the parent priority.\n @retval OT_ERROR_INVALID_ARGS   If the parent priority value is not among 1, 0, -1 and -2.\n\n @sa otThreadGetParentPriority"]
12156    pub fn otThreadSetParentPriority(aInstance: *mut otInstance, aParentPriority: i8) -> otError;
12157}
12158extern "C" {
12159    #[doc = " Gets the maximum number of IP addresses that each MTD child may register with this device as parent.\n\n @param[in]  aInstance    A pointer to an OpenThread instance.\n\n @returns The maximum number of IP addresses that each MTD child may register with this device as parent.\n\n @sa otThreadSetMaxChildIpAddresses"]
12160    pub fn otThreadGetMaxChildIpAddresses(aInstance: *mut otInstance) -> u8;
12161}
12162extern "C" {
12163    #[doc = " Sets or restores the maximum number of IP addresses that each MTD child may register with this\n device as parent.\n\n Pass `0` to clear the setting and restore the default.\n\n Available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @note Only used by Thread Test Harness to limit the address registrations of the reference\n parent in order to test the MTD DUT reaction.\n\n @param[in]  aInstance        A pointer to an OpenThread instance.\n @param[in]  aMaxIpAddresses  The maximum number of IP addresses that each MTD child may register with this\n                              device as parent. 0 to clear the setting and restore the default.\n\n @retval OT_ERROR_NONE           Successfully set/cleared the number.\n @retval OT_ERROR_INVALID_ARGS   If exceeds the allowed maximum number.\n\n @sa otThreadGetMaxChildIpAddresses"]
12164    pub fn otThreadSetMaxChildIpAddresses(
12165        aInstance: *mut otInstance,
12166        aMaxIpAddresses: u8,
12167    ) -> otError;
12168}
12169#[doc = "< A child is being added."]
12170pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_ADDED: otNeighborTableEvent = 0;
12171#[doc = "< A child is being removed."]
12172pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_REMOVED: otNeighborTableEvent = 1;
12173#[doc = "< An existing child's mode is changed."]
12174pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_MODE_CHANGED: otNeighborTableEvent = 2;
12175#[doc = "< A router is being added."]
12176pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_ADDED: otNeighborTableEvent = 3;
12177#[doc = "< A router is being removed."]
12178pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_REMOVED: otNeighborTableEvent = 4;
12179#[doc = " Defines the constants used in `otNeighborTableCallback` to indicate changes in neighbor table."]
12180pub type otNeighborTableEvent = ::std::os::raw::c_uint;
12181#[doc = " Represent a neighbor table entry info (child or router) and is used as a parameter in the neighbor table\n callback `otNeighborTableCallback`."]
12182#[repr(C)]
12183#[derive(Copy, Clone)]
12184pub struct otNeighborTableEntryInfo {
12185    #[doc = "< The OpenThread instance."]
12186    pub mInstance: *mut otInstance,
12187    pub mInfo: otNeighborTableEntryInfo__bindgen_ty_1,
12188}
12189#[repr(C)]
12190#[derive(Copy, Clone)]
12191pub union otNeighborTableEntryInfo__bindgen_ty_1 {
12192    #[doc = "< The child neighbor info."]
12193    pub mChild: otChildInfo,
12194    #[doc = "< The router neighbor info."]
12195    pub mRouter: otNeighborInfo,
12196}
12197impl Default for otNeighborTableEntryInfo__bindgen_ty_1 {
12198    fn default() -> Self {
12199        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12200        unsafe {
12201            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12202            s.assume_init()
12203        }
12204    }
12205}
12206impl Default for otNeighborTableEntryInfo {
12207    fn default() -> Self {
12208        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12209        unsafe {
12210            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12211            s.assume_init()
12212        }
12213    }
12214}
12215#[doc = " Pointer is called to notify that there is a change in the neighbor table.\n\n @param[in]  aEvent      A event flag.\n @param[in]  aEntryInfo  A pointer to table entry info."]
12216pub type otNeighborTableCallback = ::std::option::Option<
12217    unsafe extern "C" fn(aEvent: otNeighborTableEvent, aEntryInfo: *const otNeighborTableEntryInfo),
12218>;
12219extern "C" {
12220    #[doc = " Registers a neighbor table callback function.\n\n The provided callback (if non-NULL) will be invoked when there is a change in the neighbor table (e.g., a child or a\n router neighbor entry is being added/removed or an existing child's mode is changed).\n\n Subsequent calls to this method will overwrite the previous callback.  Note that this callback in invoked while the\n neighbor/child table is being updated and always before the `otStateChangedCallback`.\n\n @param[in] aInstance  A pointer to an OpenThread instance.\n @param[in] aCallback  A pointer to callback handler function."]
12221    pub fn otThreadRegisterNeighborTableCallback(
12222        aInstance: *mut otInstance,
12223        aCallback: otNeighborTableCallback,
12224    );
12225}
12226extern "C" {
12227    #[doc = " Sets whether the device was commissioned using CCM.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used by Thread Test Harness\n       to indicate whether this device was commissioned using CCM.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   TRUE if the device was commissioned using CCM, FALSE otherwise."]
12228    pub fn otThreadSetCcmEnabled(aInstance: *mut otInstance, aEnabled: bool);
12229}
12230extern "C" {
12231    #[doc = " Sets whether the Security Policy TLV version-threshold for routing (VR field) is enabled.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used by Thread Test Harness\n       to indicate that thread protocol version check VR should be skipped.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   TRUE to enable Security Policy TLV version-threshold for routing, FALSE otherwise."]
12232    pub fn otThreadSetThreadVersionCheckEnabled(aInstance: *mut otInstance, aEnabled: bool);
12233}
12234extern "C" {
12235    #[doc = " Enables or disables the filter to drop TMF UDP messages from untrusted origin.\n\n TMF messages are only trusted when they originate from a trusted source, such as the Thread interface. In\n special cases, such as when a device uses platform UDP socket to send TMF messages, they will be dropped due\n to untrusted origin. This filter is enabled by default.\n\n When this filter is disabled, UDP messages sent to the TMF port that originate from untrusted origin (such as\n host, CLI or an external IPv6 node) will be allowed.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` and is only used by Thread Test Harness\n to test network behavior by sending special TMF messages from the CLI on a POSIX host.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnabled   TRUE to enable filter, FALSE otherwise."]
12236    pub fn otThreadSetTmfOriginFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
12237}
12238extern "C" {
12239    #[doc = " Indicates whether the filter that drops TMF UDP messages from untrusted origin is enabled or not.\n\n This is intended for testing only and available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` config is enabled.\n\n @retval TRUE   The filter is enabled.\n @retval FALSE  The filter is not enabled."]
12240    pub fn otThreadIsTmfOriginFilterEnabled(aInstance: *mut otInstance) -> bool;
12241}
12242extern "C" {
12243    #[doc = " Gets the range of router IDs that are allowed to assign to nodes within the thread network.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used for test purpose. All the\n router IDs in the range [aMinRouterId, aMaxRouterId] are allowed.\n\n @param[in]   aInstance     A pointer to an OpenThread instance.\n @param[out]  aMinRouterId  The minimum router ID.\n @param[out]  aMaxRouterId  The maximum router ID.\n\n @sa otThreadSetRouterIdRange"]
12244    pub fn otThreadGetRouterIdRange(
12245        aInstance: *mut otInstance,
12246        aMinRouterId: *mut u8,
12247        aMaxRouterId: *mut u8,
12248    );
12249}
12250extern "C" {
12251    #[doc = " Sets the range of router IDs that are allowed to assign to nodes within the thread network.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used for test purpose. All the\n router IDs in the range [aMinRouterId, aMaxRouterId] are allowed.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aMinRouterId  The minimum router ID.\n @param[in]  aMaxRouterId  The maximum router ID.\n\n @retval  OT_ERROR_NONE           Successfully set the range.\n @retval  OT_ERROR_INVALID_ARGS   aMinRouterId > aMaxRouterId, or the range is not covered by [0, 62].\n\n @sa otThreadGetRouterIdRange"]
12252    pub fn otThreadSetRouterIdRange(
12253        aInstance: *mut otInstance,
12254        aMinRouterId: u8,
12255        aMaxRouterId: u8,
12256    ) -> otError;
12257}
12258extern "C" {
12259    #[doc = " Gets the current Interval Max value used by Advertisement trickle timer.\n\n This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is intended for testing only.\n\n @returns The Interval Max of Advertisement trickle timer in milliseconds."]
12260    pub fn otThreadGetAdvertisementTrickleIntervalMax(aInstance: *mut otInstance) -> u32;
12261}
12262extern "C" {
12263    #[doc = " Indicates whether or not a Router ID is currently allocated.\n\n @param[in]  aInstance     A pointer to an OpenThread instance.\n @param[in]  aRouterId     The router ID to check.\n\n @retval TRUE  The @p aRouterId is allocated.\n @retval FALSE The @p aRouterId is not allocated."]
12264    pub fn otThreadIsRouterIdAllocated(aInstance: *mut otInstance, aRouterId: u8) -> bool;
12265}
12266extern "C" {
12267    #[doc = " Gets the next hop and path cost towards a given RLOC16 destination.\n\n Can be used with either @p aNextHopRloc16 or @p aPathCost being NULL indicating caller does not want\n to get the value.\n\n @param[in]  aInstance       A pointer to an OpenThread instance.\n @param[in]  aDestRloc16     The RLOC16 of destination.\n @param[out] aNextHopRloc16  A pointer to return RLOC16 of next hop, 0xfffe if no next hop.\n @param[out] aPathCost       A pointer to return path cost towards destination."]
12268    pub fn otThreadGetNextHopAndPathCost(
12269        aInstance: *mut otInstance,
12270        aDestRloc16: u16,
12271        aNextHopRloc16: *mut u16,
12272        aPathCost: *mut u8,
12273    );
12274}
12275#[doc = " Represents a TREL peer."]
12276#[repr(C)]
12277#[derive(Copy, Clone)]
12278pub struct otTrelPeer {
12279    #[doc = "< The Extended MAC Address of TREL peer."]
12280    pub mExtAddress: otExtAddress,
12281    #[doc = "< The Extended PAN Identifier of TREL peer."]
12282    pub mExtPanId: otExtendedPanId,
12283    #[doc = "< The IPv6 socket address of TREL peer."]
12284    pub mSockAddr: otSockAddr,
12285}
12286impl Default for otTrelPeer {
12287    fn default() -> Self {
12288        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12289        unsafe {
12290            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12291            s.assume_init()
12292        }
12293    }
12294}
12295#[doc = " Represents an iterator for iterating over TREL peer table entries."]
12296pub type otTrelPeerIterator = u16;
12297extern "C" {
12298    #[doc = " Enables or disables TREL operation.\n\n When @p aEnable is true, this function initiates an ongoing DNS-SD browse on the service name \"_trel._udp\" within the\n local browsing domain to discover other devices supporting TREL. Device also registers a new service to be advertised\n using DNS-SD, with the service name is \"_trel._udp\" indicating its support for TREL. Device is then ready to receive\n TREL messages from peers.\n\n When @p aEnable is false, this function stops the DNS-SD browse on the service name \"_trel._udp\", stops advertising\n TREL DNS-SD service, and clears the TREL peer table.\n\n @note By default the OpenThread stack enables the TREL operation on start.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n @param[in]  aEnable    A boolean to enable/disable the TREL operation."]
12299    pub fn otTrelSetEnabled(aInstance: *mut otInstance, aEnable: bool);
12300}
12301extern "C" {
12302    #[doc = " Indicates whether the TREL operation is enabled.\n\n @param[in] aInstance   The OpenThread instance.\n\n @retval TRUE if the TREL operation is enabled.\n @retval FALSE if the TREL operation is disabled."]
12303    pub fn otTrelIsEnabled(aInstance: *mut otInstance) -> bool;
12304}
12305extern "C" {
12306    #[doc = " Initializes a peer table iterator.\n\n @param[in] aInstance   The OpenThread instance.\n @param[in] aIterator   The iterator to initialize."]
12307    pub fn otTrelInitPeerIterator(aInstance: *mut otInstance, aIterator: *mut otTrelPeerIterator);
12308}
12309extern "C" {
12310    #[doc = " Iterates over the peer table entries and get the next entry from the table\n\n @param[in] aInstance   The OpenThread instance.\n @param[in] aIterator   The iterator. MUST be initialized.\n\n @returns A pointer to the next `otTrelPeer` entry or `NULL` if no more entries in the table."]
12311    pub fn otTrelGetNextPeer(
12312        aInstance: *mut otInstance,
12313        aIterator: *mut otTrelPeerIterator,
12314    ) -> *const otTrelPeer;
12315}
12316extern "C" {
12317    #[doc = " Returns the number of TREL peers.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns  The number of TREL peers."]
12318    pub fn otTrelGetNumberOfPeers(aInstance: *mut otInstance) -> u16;
12319}
12320extern "C" {
12321    #[doc = " Sets the filter mode (enables/disables filtering).\n\n When filter mode is enabled, any rx and tx traffic through TREL interface is silently dropped. This is mainly\n intended for use during testing.\n\n Unlike `otTrel{Enable/Disable}()` which fully starts/stops the TREL operation, when filter mode is enabled the\n TREL interface continues to be enabled.\n\n @param[in] aInstance   The OpenThread instance.\n @param[in] aFiltered   TRUE to enable filter mode, FALSE to disable filter mode."]
12322    pub fn otTrelSetFilterEnabled(aInstance: *mut otInstance, aEnable: bool);
12323}
12324extern "C" {
12325    #[doc = " Indicates whether or not the filter mode is enabled.\n\n @param[in] aInstance   The OpenThread instance.\n\n @retval TRUE if the TREL filter mode is enabled.\n @retval FALSE if the TREL filter mode is disabled."]
12326    pub fn otTrelIsFilterEnabled(aInstance: *mut otInstance) -> bool;
12327}
12328#[doc = " Represents a group of TREL related counters in the platform layer."]
12329pub type otTrelCounters = otPlatTrelCounters;
12330extern "C" {
12331    #[doc = " Gets the TREL counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns  A pointer to the TREL counters."]
12332    pub fn otTrelGetCounters(aInstance: *mut otInstance) -> *const otTrelCounters;
12333}
12334extern "C" {
12335    #[doc = " Resets the TREL counters.\n\n @param[in]  aInstance  A pointer to an OpenThread instance."]
12336    pub fn otTrelResetCounters(aInstance: *mut otInstance);
12337}
12338extern "C" {
12339    #[doc = " Gets the UDP port of the TREL interface.\n\n @param[in]  aInstance  A pointer to an OpenThread instance.\n\n @returns UDP port of the TREL interface."]
12340    pub fn otTrelGetUdpPort(aInstance: *mut otInstance) -> u16;
12341}
12342pub type __builtin_va_list = [__va_list_tag; 1usize];
12343#[repr(C)]
12344#[derive(Debug, Copy, Clone)]
12345pub struct __va_list_tag {
12346    pub gp_offset: ::std::os::raw::c_uint,
12347    pub fp_offset: ::std::os::raw::c_uint,
12348    pub overflow_arg_area: *mut ::std::os::raw::c_void,
12349    pub reg_save_area: *mut ::std::os::raw::c_void,
12350}
12351impl Default for __va_list_tag {
12352    fn default() -> Self {
12353        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12354        unsafe {
12355            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12356            s.assume_init()
12357        }
12358    }
12359}