arkui-sys 0.3.3

// automatically generated by rust-bindgen 0.71.1

#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
use crate::native_type::*;
use crate::ui_input_event::ArkUI_UIInputEvent;

/// Defines a gesture recognizer.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_GestureRecognizer {
    _unused: [u8; 0],
}
/// Defines the gesture interruption information.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_GestureInterruptInfo {
    _unused: [u8; 0],
}
/// Defines the gesture event.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_GestureEvent {
    _unused: [u8; 0],
}
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureEventActionType {
    /// Triggered.
    pub const GESTURE_EVENT_ACTION_ACCEPT: ArkUI_GestureEventActionType =
        ArkUI_GestureEventActionType(1);
    /// Updated.
    pub const GESTURE_EVENT_ACTION_UPDATE: ArkUI_GestureEventActionType =
        ArkUI_GestureEventActionType(2);
    /// Ended.
    pub const GESTURE_EVENT_ACTION_END: ArkUI_GestureEventActionType =
        ArkUI_GestureEventActionType(4);
    /// Canceled.
    pub const GESTURE_EVENT_ACTION_CANCEL: ArkUI_GestureEventActionType =
        ArkUI_GestureEventActionType(8);
}
#[repr(transparent)]
/// Enumerates gesture event types.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureEventActionType(pub ::core::ffi::c_uint);
/// Defines a set of gesture event types.
///
/// Example: ArkUI_GestureEventActionTypeMask actions = GESTURE_EVENT_ACTION_ACCEPT | GESTURE_EVENT_ACTION_UPDATE;
///
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
pub type ArkUI_GestureEventActionTypeMask = u32;
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GesturePriority {
    /// Normal.
    pub const NORMAL: ArkUI_GesturePriority = ArkUI_GesturePriority(0);
    /// High-priority.
    pub const PRIORITY: ArkUI_GesturePriority = ArkUI_GesturePriority(1);
    /// Parallel.
    pub const PARALLEL: ArkUI_GesturePriority = ArkUI_GesturePriority(2);
}
#[repr(transparent)]
/// Enumerates gesture event modes.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GesturePriority(pub ::core::ffi::c_uint);
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GroupGestureMode {
    /// Sequential recognition. Gestures are recognized in the registration sequence until all gestures are recognized
    /// successfully. Once one gesture fails to be recognized, all subsequent gestures fail to be recognized.
    /// Only the last gesture in the gesture group can respond to the end event.
    pub const SEQUENTIAL_GROUP: ArkUI_GroupGestureMode = ArkUI_GroupGestureMode(0);
    /// Parallel recognition. Registered gestures are recognized concurrently until all gestures are recognized.
    /// The recognition result of each gesture does not affect each other.
    pub const PARALLEL_GROUP: ArkUI_GroupGestureMode = ArkUI_GroupGestureMode(1);
    /// Exclusive recognition. Registered gestures are identified concurrently.
    /// If one gesture is successfully recognized, gesture recognition ends.
    pub const EXCLUSIVE_GROUP: ArkUI_GroupGestureMode = ArkUI_GroupGestureMode(2);
}
#[repr(transparent)]
/// Enumerates gesture group modes.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GroupGestureMode(pub ::core::ffi::c_uint);
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureDirection {
    /// All directions.
    pub const GESTURE_DIRECTION_ALL: ArkUI_GestureDirection = ArkUI_GestureDirection(15);
    /// Horizontal direction.
    pub const GESTURE_DIRECTION_HORIZONTAL: ArkUI_GestureDirection = ArkUI_GestureDirection(3);
    /// Vertical direction.
    pub const GESTURE_DIRECTION_VERTICAL: ArkUI_GestureDirection = ArkUI_GestureDirection(12);
    /// Leftward.
    pub const GESTURE_DIRECTION_LEFT: ArkUI_GestureDirection = ArkUI_GestureDirection(1);
    /// Rightward.
    pub const GESTURE_DIRECTION_RIGHT: ArkUI_GestureDirection = ArkUI_GestureDirection(2);
    /// Upward.
    pub const GESTURE_DIRECTION_UP: ArkUI_GestureDirection = ArkUI_GestureDirection(4);
    /// Downward.
    pub const GESTURE_DIRECTION_DOWN: ArkUI_GestureDirection = ArkUI_GestureDirection(8);
    /// None.
    pub const GESTURE_DIRECTION_NONE: ArkUI_GestureDirection = ArkUI_GestureDirection(0);
}
#[repr(transparent)]
/// Enumerates gesture directions.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureDirection(pub ::core::ffi::c_uint);
/// Defines a set of gesture directions.
///
/// Example: ArkUI_GestureDirectionMask directions = GESTURE_DIRECTION_LEFT | GESTURE_DIRECTION_RIGHT
///
/// This example indicates that the leftward and rightward directions are supported.
///
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
pub type ArkUI_GestureDirectionMask = u32;
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureMask {
    /// The gestures of child components are enabled and recognized based on the default gesture recognition sequence.
    pub const NORMAL_GESTURE_MASK: ArkUI_GestureMask = ArkUI_GestureMask(0);
    /// The gestures of child components are disabled, including the built-in gestures.
    pub const IGNORE_INTERNAL_GESTURE_MASK: ArkUI_GestureMask = ArkUI_GestureMask(1);
}
#[repr(transparent)]
/// Enumerates gesture masking modes.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureMask(pub ::core::ffi::c_uint);
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureRecognizerType {
    /// Tap.
    pub const TAP_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(0);
    /// Long press.
    pub const LONG_PRESS_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(1);
    /// Pan.
    pub const PAN_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(2);
    /// Pinch.
    pub const PINCH_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(3);
    /// Rotate.
    pub const ROTATION_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(4);
    /// Swipe.
    pub const SWIPE_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(5);
    /// A group of gestures.
    pub const GROUP_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(6);
    /// The click gesture registed through onClick.
    ///
    ///
    /// Available since API-level: 20
    #[cfg(feature = "api-20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-20")))]
    pub const CLICK_GESTURE: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(7);
    /// Drag gesture used for drag and drop.
    ///
    ///
    /// Available since API-level: 20
    #[cfg(feature = "api-20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-20")))]
    pub const DRAG_DROP: ArkUI_GestureRecognizerType = ArkUI_GestureRecognizerType(8);
}
#[repr(transparent)]
/// Enumerates gesture types.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureRecognizerType(pub ::core::ffi::c_uint);
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureInterruptResult {
    /// The gesture recognition process continues.
    pub const CONTINUE: ArkUI_GestureInterruptResult = ArkUI_GestureInterruptResult(0);
    /// The gesture recognition process is paused.
    pub const REJECT: ArkUI_GestureInterruptResult = ArkUI_GestureInterruptResult(1);
}
#[repr(transparent)]
/// Enumerates gesture interruption results.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureInterruptResult(pub ::core::ffi::c_uint);
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
impl ArkUI_GestureRecognizerState {
    /// Ready.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_READY: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(0);
    /// Detecting.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_DETECTING: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(1);
    /// Pending.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_PENDING: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(2);
    /// Blocked.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_BLOCKED: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(3);
    /// Successful.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_SUCCESSFUL: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(4);
    /// Failed.
    pub const ARKUI_GESTURE_RECOGNIZER_STATE_FAILED: ArkUI_GestureRecognizerState =
        ArkUI_GestureRecognizerState(5);
}
#[repr(transparent)]
/// Enumerates the gesture recognizer states.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ArkUI_GestureRecognizerState(pub ::core::ffi::c_uint);
/// Defines the gesture recognizer handle.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
pub type ArkUI_GestureRecognizerHandle = *mut ArkUI_GestureRecognizer;
/// Defines the gesture recognizer handle array.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
pub type ArkUI_GestureRecognizerHandleArray = *mut ArkUI_GestureRecognizerHandle;
/// Defines a <b>GestureEventTargetInfo</b> object that provides information about a gesture event target.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_GestureEventTargetInfo {
    _unused: [u8; 0],
}
/// Defines a parallel internal gesture event.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_ParallelInnerGestureEvent {
    _unused: [u8; 0],
}
/// Defines a touch recognizer.
///
///
/// Available since API-level: 15
#[cfg(feature = "api-15")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
#[repr(C)]
pub struct ArkUI_TouchRecognizer {
    _unused: [u8; 0],
}
/// Defines a touch recognizer handle.
///
///
/// Available since API-level: 15
#[cfg(feature = "api-15")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
pub type ArkUI_TouchRecognizerHandle = *mut ArkUI_TouchRecognizer;
/// Defines an array of touch recognizer handle.
///
///
/// Available since API-level: 15
#[cfg(feature = "api-15")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
pub type ArkUI_TouchRecognizerHandleArray = *mut ArkUI_TouchRecognizerHandle;
/// Defines a callback function for notifying gesture recognizer destruction.
///
/// # Arguments
///
/// * `recognizer` - Indicates the pointer to a gesture recognizer.
///
/// * `userData` - Indicates the custom data.
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
pub type ArkUI_GestureRecognizerDisposeNotifyCallback = ::core::option::Option<
    unsafe extern "C" fn(
        recognizer: *mut ArkUI_GestureRecognizer,
        userData: *mut ::core::ffi::c_void,
    ),
>;
/// Defines the gesture APIs.
///
///
/// Available since API-level: 12
#[cfg(feature = "api-12")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
#[repr(C)]
pub struct ArkUI_NativeGestureAPI_1 {
    /// The struct version is 1.
    pub version: i32,
    /// Creates a tap gesture.
    ///
    /// 1. This API is used to trigger a tap gesture with one, two, or more taps.
    ///
    /// 2. If multi-tap is configured, the timeout interval between a lift and the next tap is 300 ms.
    ///
    /// 3. If the distance between the last tapped position and the current tapped position exceeds 60 vp,
    /// gesture recognition fails.
    ///
    /// 4. If the value is greater than 1, the tap gesture will fail to be recognized when the number of fingers
    /// touching the screen within 300 ms of the first finger touch is less than the required number,
    ///
    /// or when the number of fingers lifted from the screen within 300 ms of the first finger's being lifted
    /// is less than the required number.
    ///
    /// 5. When the number of fingers touching the screen exceeds the set value, the gesture can be recognized.
    ///
    ///
    /// # Arguments
    ///
    /// * `countNum` - Indicates the number of consecutive taps. If the value is less than 1 or is not set,
    /// the default value <b>1</b> is used.
    ///
    /// * `fingersNum` - Indicates the number of fingers required to trigger a tap. The value ranges
    /// from 1 to 10. If the value is less than 1 or is not set, the default value <b>1</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createTapGesture: ::core::option::Option<
        unsafe extern "C" fn(countNum: i32, fingersNum: i32) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a long press gesture.
    ///
    /// 1. This API is used to trigger a long press gesture, which requires one or more fingers with a minimum
    /// The value ranges 500 ms hold-down time.
    ///
    /// 2. In components that support drag actions by default, such as <b><Text></b>, <b><TextInput></b>,
    /// <b><TextArea></b>, <b><Hyperlink></b>, <b><Image></b>, and <b>RichEditor></b>, the long press gesture
    ///
    /// may conflict with the drag action. If this occurs, they are handled as follows:
    ///
    /// If the minimum duration of the long press gesture is less than 500 ms, the long press gesture receives
    /// a higher response priority than the drag action.
    ///
    /// If the minimum duration of the long press gesture is greater than or equal to 500 ms,
    /// the drag action receives a higher response priority than the long press gesture.
    ///
    /// 3. If a finger moves more than 15 px after being pressed, the gesture recognition fails.
    ///
    ///
    /// # Arguments
    ///
    /// * `fingersNum` - Indicates the minimum number of fingers to trigger a long press gesture.
    /// The value ranges from 1 to 10.
    ///
    /// * `repeatResult` - Indicates whether to continuously trigger the event callback.
    ///
    /// * `durationNum` - Indicates the minimum hold-down time, in ms.
    /// If the value is less than or equal to 0, the default value <b>500</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createLongPressGesture: ::core::option::Option<
        unsafe extern "C" fn(
            fingersNum: i32,
            repeatResult: bool,
            durationNum: i32,
        ) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a pan gesture.
    ///
    /// 1. This API is used to trigger a pan gesture when the movement distance of a finger on the screen exceeds
    /// the minimum value.
    ///
    /// 2. If a pan gesture and a tab swipe occur at the same time, set <b>distanceNum</b> to <b>1</b>
    /// so that the gesture can be more easily recognized.
    ///
    ///
    /// # Arguments
    ///
    /// * `fingersNum` - Indicates the minimum number of fingers to trigger a pan gesture. The value ranges from 1 to 10.
    /// If the value is less than 1 or is not set, the default value <b>1</b> is used.
    ///
    /// * `directions` - Indicates the pan direction. The value supports the AND (&amp;) and OR (operations.
    ///
    /// * `distanceNum` - Indicates the minimum pan distance to trigger the gesture, in vp. If this parameter is
    /// set to a value less than or equal to 0, the default value <b>5</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createPanGesture: ::core::option::Option<
        unsafe extern "C" fn(
            fingersNum: i32,
            directions: ArkUI_GestureDirectionMask,
            distanceNum: f64,
        ) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a pinch gesture.
    ///
    /// 1. This API is used to trigger a pinch gesture, which requires two to five fingers with a minimum 5 vp
    /// distance between the fingers.
    ///
    /// 2. While more fingers than the minimum number can be pressed to trigger the gesture, only the first
    /// fingers of the minimum number participate in gesture calculation.
    ///
    ///
    /// # Arguments
    ///
    /// * `fingersNum` - Indicates the minimum number of fingers to trigger a pinch. The value ranges from 2 to 5.
    /// Default value: <b>2</b>
    ///
    /// * `distanceNum` - Indicates the minimum recognition distance, in px. If this parameter is set to a value less
    /// than or equal to 0, the default value <b>5</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createPinchGesture: ::core::option::Option<
        unsafe extern "C" fn(fingersNum: i32, distanceNum: f64) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a rotation gesture.
    ///
    /// 1. This API is used to trigger a rotation gesture, which requires two to five fingers with a
    /// minimum 1-degree rotation angle.
    ///
    /// 2. While more fingers than the minimum number can be pressed to trigger the gesture, only the first
    /// two fingers participate in gesture calculation.
    ///
    ///
    /// # Arguments
    ///
    /// * `fingersNum` - Indicates the minimum number of fingers to trigger a rotation. The value ranges from 2 to 5.
    /// Default value: <b>2</b>
    ///
    /// * `angleNum` - Indicates the minimum degree that can trigger the rotation gesture. Default value: <b>1</b>
    /// If this parameter is set to a value less than or equal to 0 or greater than 360,
    /// the default value <b>1</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createRotationGesture: ::core::option::Option<
        unsafe extern "C" fn(fingersNum: i32, angleNum: f64) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a swipe gesture.
    ///
    /// This API is used to implement a swipe gesture, which can be recognized when the swipe speed is 100
    /// vp/s or higher.
    ///
    ///
    /// # Arguments
    ///
    /// * `fingersNum` - Indicates the minimum number of fingers to trigger a swipe gesture.
    /// The value ranges from 1 to 10.
    ///
    /// * `directions` - Indicates the swipe direction.
    ///
    /// * `speedNum` - Indicates the minimum speed of the swipe gesture, in px/s.
    /// If this parameter is set to a value less than or equal to 0, the default value <b>100</b> is used.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createSwipeGesture: ::core::option::Option<
        unsafe extern "C" fn(
            fingersNum: i32,
            directions: ArkUI_GestureDirectionMask,
            speedNum: f64,
        ) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Creates a gesture group.
    ///
    /// # Arguments
    ///
    /// * `gestureMode` - Indicates the gesture group mode.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture group.
    pub createGroupGesture: ::core::option::Option<
        unsafe extern "C" fn(gestureMode: ArkUI_GroupGestureMode) -> *mut ArkUI_GestureRecognizer,
    >,
    /// Disposes a gesture to release resources.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to the gesture to dispose.
    pub dispose:
        ::core::option::Option<unsafe extern "C" fn(recognizer: *mut ArkUI_GestureRecognizer)>,
    /// Adds a gesture to a gesture group.
    ///
    /// # Arguments
    ///
    /// * `group` - Indicates the pointer to the gesture group.
    ///
    /// * `child` - Indicates the gesture to be added to the gesture group.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs. Returns 401 if a parameter exception occurs.
    pub addChildGesture: ::core::option::Option<
        unsafe extern "C" fn(
            group: *mut ArkUI_GestureRecognizer,
            child: *mut ArkUI_GestureRecognizer,
        ) -> i32,
    >,
    /// Removes a gesture to a gesture group.
    ///
    /// # Arguments
    ///
    /// * `group` - Indicates the pointer to the gesture group.
    ///
    /// * `child` - Indicates the gesture to be removed to the gesture group.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs.
    pub removeChildGesture: ::core::option::Option<
        unsafe extern "C" fn(
            group: *mut ArkUI_GestureRecognizer,
            child: *mut ArkUI_GestureRecognizer,
        ) -> i32,
    >,
    /// Registers a callback for gestures.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to the gesture recognizer.
    ///
    /// * `actionTypeMask` - Indicates the set of gesture event types. Multiple callbacks can be registered at once,
    /// with the callback event types distinguished in the callbacks.
    /// Example: actionTypeMask = GESTURE_EVENT_ACTION_ACCEPT | GESTURE_EVENT_ACTION_UPDATE;
    ///
    /// * `extraParams` - Indicates the context passed in the <b>targetReceiver</b> callback.
    ///
    /// * `targetReceiver` - Indicates the callback to register for processing the gesture event types.
    /// <b>event</b> indicates the gesture callback data.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs.
    pub setGestureEventTarget: ::core::option::Option<
        unsafe extern "C" fn(
            recognizer: *mut ArkUI_GestureRecognizer,
            actionTypeMask: ArkUI_GestureEventActionTypeMask,
            extraParams: *mut ::core::ffi::c_void,
            targetReceiver: ::core::option::Option<
                unsafe extern "C" fn(
                    event: *mut ArkUI_GestureEvent,
                    extraParams: *mut ::core::ffi::c_void,
                ),
            >,
        ) -> i32,
    >,
    /// Adds a gesture to a UI component.
    ///
    /// # Arguments
    ///
    /// * `node` - Indicates the UI component to which you want to add the gesture.
    ///
    /// * `recognizer` - Indicates the gesture to be added to the UI component.
    ///
    /// * `mode` - Indicates the gesture event mode. Available options are <b>NORMAL_GESTURE</b>,
    /// <b>PARALLEL_GESTURE</b>, and <b>PRIORITY_GESTURE</b>.
    ///
    /// * `mask` - Indicates the gesture masking mode.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs.
    pub addGestureToNode: ::core::option::Option<
        unsafe extern "C" fn(
            node: ArkUI_NodeHandle,
            recognizer: *mut ArkUI_GestureRecognizer,
            mode: ArkUI_GesturePriority,
            mask: ArkUI_GestureMask,
        ) -> i32,
    >,
    /// Removes a gesture from a node.
    ///
    /// # Arguments
    ///
    /// * `node` - Indicates the node from which you want to remove the gesture.
    ///
    /// * `recognizer` - Indicates the gesture to be removed.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs.
    pub removeGestureFromNode: ::core::option::Option<
        unsafe extern "C" fn(
            node: ArkUI_NodeHandle,
            recognizer: *mut ArkUI_GestureRecognizer,
        ) -> i32,
    >,
    /// Sets a gesture interruption callback for a node.
    ///
    /// # Arguments
    ///
    /// * `node` - Indicates the node for which you want to set a gesture interruption callback.
    ///
    /// * `interrupter` - Indicates the gesture interruption callback to set.
    /// <b>info</b> indicates the gesture interruption data. If <b>interrupter</b> returns
    /// <b>GESTURE_INTERRUPT_RESULT_CONTINUE</b>, the gesture recognition process continues. If it returns
    /// <b>GESTURE_INTERRUPT_RESULT_REJECT</b>, the gesture recognition process is paused.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter exception occurs.
    pub setGestureInterrupterToNode: ::core::option::Option<
        unsafe extern "C" fn(
            node: ArkUI_NodeHandle,
            interrupter: ::core::option::Option<
                unsafe extern "C" fn(
                    info: *mut ArkUI_GestureInterruptInfo,
                ) -> ArkUI_GestureInterruptResult,
            >,
        ) -> i32,
    >,
    /// Obtains the type of a gesture.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to the gesture.
    ///
    /// # Returns
    ///
    /// * Returns the gesture type.
    pub getGestureType: ::core::option::Option<
        unsafe extern "C" fn(
            recognizer: *mut ArkUI_GestureRecognizer,
        ) -> ArkUI_GestureRecognizerType,
    >,
    /// Sets the callback function for a parallel internal gesture event.
    ///
    /// # Arguments
    ///
    /// * `node` - Indicates the ArkUI node for which the callback of a parallel internal gesture event is to be set.
    ///
    /// * `userData` - Indicates the custom data.
    ///
    /// * `parallelInnerGesture` - Indicates the parallel internal gesture event. <b>event</b> returns the data of the
    /// parallel internal gesture event; <b>parallelInnerGesture</b> returns the pointer to the gesture recognizer
    /// that requires parallel recognition.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    pub setInnerGestureParallelTo: ::core::option::Option<
        unsafe extern "C" fn(
            node: ArkUI_NodeHandle,
            userData: *mut ::core::ffi::c_void,
            parallelInnerGesture: ::core::option::Option<
                unsafe extern "C" fn(
                    event: *mut ArkUI_ParallelInnerGestureEvent,
                ) -> *mut ArkUI_GestureRecognizer,
            >,
        ) -> i32,
    >,
    /// Creates a tap gesture that is subject to distance restrictions.
    ///
    /// 1. This API is used to trigger a tap gesture with one, two, or more taps.
    ///
    /// 2. If multi-tap is configured, the timeout interval between a lift and the next tap is 300 ms.
    ///
    /// 3. If the distance between the last tapped position and the current tapped position exceeds 60 vp,
    /// gesture recognition fails.
    ///
    /// 4. If the value is greater than 1, the tap gesture will fail to be recognized when the number of fingers
    /// touching the screen within 300 ms of the first finger touch is less than the required number,
    /// or when the number of fingers lifted from the screen within 300 ms of the first finger's being lifted
    /// is less than the required number.
    ///
    /// 5. When the number of fingers touching the screen exceeds the set value, the gesture can be recognized.
    ///
    /// 6. If the finger moves beyond the preset distance limit, gesture recognition fails.
    ///
    ///
    /// # Arguments
    ///
    /// * `countNum` - Indicates the number of consecutive taps. If the value is less than 1 or is not set, the default
    /// value <b>1</b> is used.
    ///
    /// * `fingersNum` - Indicates the number of fingers required to trigger a tap. The value ranges from 1 to 10.
    /// If the value is less than 1 or is not set, the default value <b>1</b> is used.
    ///
    /// * `distanceThreshold` - Indicates the allowed moving distance of a finger.
    /// If the value is less than 0 or is not set, it will be converted to the default value of infinity.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the created gesture.
    pub createTapGestureWithDistanceThreshold: ::core::option::Option<
        unsafe extern "C" fn(
            countNum: i32,
            fingersNum: i32,
            distanceThreshold: f64,
        ) -> *mut ArkUI_GestureRecognizer,
    >,
}
/// Defines the gesture APIs.
///
///
/// Available since API-level: 18
#[cfg(feature = "api-18")]
#[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ArkUI_NativeGestureAPI_2 {
    /// Pointer to the <b>ArkUI_NativeGestureAPI_1</b> struct.
    pub gestureApi1: *mut ArkUI_NativeGestureAPI_1,
    /// Sets the callback for gesture interruption events.
    ///
    /// # Arguments
    ///
    /// * `node` - Node for which you want to set a gesture interruption callback.
    ///
    /// * `userData` - Custom data.
    ///
    /// * `interrupter` - Gesture interruption callback to set. <b>info</b> indicates the gesture interruption data.
    /// If <b>interrupter</b> returns <b>GESTURE_INTERRUPT_RESULT_CONTINUE</b>, the gesture recognition process proceeds
    /// properly. If it returns <b>GESTURE_INTERRUPT_RESULT_REJECT</b>, the gesture recognition process is paused.
    ///
    /// # Returns
    ///
    /// * Returns <b>0</b> if success.
    /// Returns <b>401</b> if a parameter error occurs.
    pub setGestureInterrupterToNode: ::core::option::Option<
        unsafe extern "C" fn(
            node: ArkUI_NodeHandle,
            userData: *mut ::core::ffi::c_void,
            interrupter: ::core::option::Option<
                unsafe extern "C" fn(
                    info: *mut ArkUI_GestureInterruptInfo,
                ) -> ArkUI_GestureInterruptResult,
            >,
        ) -> i32,
    >,
}
extern "C" {
    /// Checks whether a gesture is a built-in gesture of the component.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture interruption information.
    ///
    /// # Returns
    ///
    /// * Returns <b>true</b> if the gesture is a built-in gesture; returns <b>false</b> otherwise.
    ///
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureInterruptInfo_GetSystemFlag(
        event: *const ArkUI_GestureInterruptInfo,
    ) -> bool;
    /// Obtains the pointer to interrupted gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture interruption information.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to interrupted gesture recognizer.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureInterruptInfo_GetRecognizer(
        event: *const ArkUI_GestureInterruptInfo,
    ) -> *mut ArkUI_GestureRecognizer;
    /// Obtains the pointer to the interrupted gesture event.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture interruption information.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the interrupted gesture event.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureInterruptInfo_GetGestureEvent(
        event: *const ArkUI_GestureInterruptInfo,
    ) -> *mut ArkUI_GestureEvent;
    /// Obtains the type of the system gesture to trigger.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture interruption information.
    ///
    /// # Returns
    ///
    /// * Returns the type of the system gesture to trigger. If the gesture to trigger is not a system gesture,
    /// <b>-1</b> is returned.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureInterruptInfo_GetSystemRecognizerType(
        event: *const ArkUI_GestureInterruptInfo,
    ) -> i32;
    /// Get the touch recognizer handles from the gesture interrupt info.
    ///
    /// # Arguments
    ///
    /// * `info` - Indicates the pointer to a gesture interrupt info.
    ///
    /// * `recognizers` - Indicates the pointer to an array of touch recognizer handles.
    ///
    /// * `size` - Indicates the size of recognizers.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 15
    #[cfg(feature = "api-15")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
    pub fn OH_ArkUI_GestureInterruptInfo_GetTouchRecognizers(
        info: *const ArkUI_GestureInterruptInfo,
        recognizers: *mut ArkUI_TouchRecognizerHandleArray,
        size: *mut i32,
    ) -> i32;
    /// Get component object of the specific touch recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to the TouchRecognizer.
    ///
    /// # Returns
    ///
    /// * Get component object of the specific touch recognizer.
    ///
    /// Available since API-level: 15
    #[cfg(feature = "api-15")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
    pub fn OH_ArkUI_TouchRecognizer_GetNodeHandle(
        recognizer: ArkUI_TouchRecognizerHandle,
    ) -> ArkUI_NodeHandle;
    /// Send touch-cancel event to the touch recognizer in a gesture interruption callback.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the touch recognizer handle.
    ///
    /// * `info` - Indicates the pointer to a gesture interrupt info.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 15
    #[cfg(feature = "api-15")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
    pub fn OH_ArkUI_TouchRecognizer_CancelTouch(
        recognizer: ArkUI_TouchRecognizerHandle,
        info: *mut ArkUI_GestureInterruptInfo,
    ) -> i32;
    /// Obtains the gesture event type.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the gesture event type.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureEvent_GetActionType(
        event: *const ArkUI_GestureEvent,
    ) -> ArkUI_GestureEventActionType;
    /// Obtains gesture input.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the input event of the gesture event.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureEvent_GetRawInputEvent(
        event: *const ArkUI_GestureEvent,
    ) -> *const ArkUI_UIInputEvent;
    /// Obtains the number of times that a long press gesture is triggered periodically.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the number of times that the long press gesture is triggered periodically.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_LongPress_GetRepeatCount(event: *const ArkUI_GestureEvent) -> i32;
    /// Obtains the velocity of a pan gesture along the main axis.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the velocity of the pan gesture along the main axis, in px/s.
    /// The value is the square root of the sum of the squares of the velocity on the x-axis and y-axis.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PanGesture_GetVelocity(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the velocity of a pan gesture along the x-axis.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the velocity of the pan gesture along the x-axis, in px/s.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PanGesture_GetVelocityX(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the velocity of a pan gesture along the y-axis.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the velocity of the pan gesture along the y-axis, in px/s.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PanGesture_GetVelocityY(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the relative offset of a pan gesture along the x-axis.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the relative offset of the gesture along the x-axis, in px.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PanGesture_GetOffsetX(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the relative offset of a pan gesture along the y-axis.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the relative offset of the gesture along the y-axis, in px.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PanGesture_GetOffsetY(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the angle information of the swipe gesture.
    ///
    /// After a swipe gesture is recognized, a line connecting the two fingers is identified as the initial line.
    /// As the fingers swipe, the line between the fingers rotates.
    ///
    /// Based on the coordinates of the initial line's and current line's end points, the arc tangent function is used to
    /// calculate the respective included angle of the points relative to the horizontal direction
    ///
    /// by using the following formula: Rotation angle = arctan2(cy2-cy1,cx2-cx1) - arctan2(y2-y1,x2-x1).
    ///
    /// The initial line is used as the coordinate system. Values from 0 to 180 degrees represent clockwise rotation,
    /// while values from –180 to 0 degrees represent counterclockwise rotation.
    ///
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the angle of the swipe gesture, which is the result obtained based on the aforementioned formula.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_SwipeGesture_GetAngle(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the average velocity of all fingers used in the swipe gesture.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the average velocity of all fingers used in the swipe gesture, in px/s.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_SwipeGesture_GetVelocity(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the angle information of a rotation gesture.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the rotation angle.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_RotationGesture_GetAngle(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the scale ratio of a pinch gesture.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the scale ratio.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PinchGesture_GetScale(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the X coordinate of the center of the pinch gesture, in vp,
    /// relative to the upper left corner of the current component.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the X coordinate of the center of the pinch gesture, in vp,
    /// relative to the upper left corner of the current component.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PinchGesture_GetCenterX(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains the Y coordinate of the center of the pinch gesture, in vp,
    /// relative to the upper left corner of the current component.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the Y coordinate of the center of the pinch gesture, in vp,
    /// relative to the upper left corner of the current component.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_PinchGesture_GetCenterY(event: *const ArkUI_GestureEvent) -> f32;
    /// Obtains information about a gesture response chain.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to the gesture interruption information.
    ///
    /// * `responseChain` - Indicates the pointer to an array of gesture recognizers on the response chain.
    ///
    /// * `count` - Indicates the pointer to the number of gesture recognizers on the response chain.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetResponseRecognizersFromInterruptInfo(
        event: *const ArkUI_GestureInterruptInfo,
        responseChain: *mut ArkUI_GestureRecognizerHandleArray,
        count: *mut i32,
    ) -> i32;
    /// Sets the enabled state of a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `enabled` - Indicates the enabled state.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_SetGestureRecognizerEnabled(
        recognizer: *mut ArkUI_GestureRecognizer,
        enabled: bool,
    ) -> i32;
    /// Sets whether to enable strict finger count checking. If this feature is enabled and the actual number of touch
    /// fingers does not match the set number, the gesture recognition fails.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `limitFingerCount` - Indicates whether to enable strict finger count checking.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter error occurs.
    ///
    /// Available since API-level: 15
    #[cfg(feature = "api-15")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-15")))]
    pub fn OH_ArkUI_SetGestureRecognizerLimitFingerCount(
        recognizer: *mut ArkUI_GestureRecognizer,
        limitFingerCount: bool,
    ) -> i32;
    /// Obtains the enabled state of a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns <b>true</b> if the gesture recognizer is enabled.
    /// Returns <b>false</b> if the gesture recognizer is disabled.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetGestureRecognizerEnabled(recognizer: *mut ArkUI_GestureRecognizer) -> bool;
    /// Obtains the state of a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `state` - Indicates the pointer to the state of the gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetGestureRecognizerState(
        recognizer: *mut ArkUI_GestureRecognizer,
        state: *mut ArkUI_GestureRecognizerState,
    ) -> i32;
    /// Obtains the information about a gesture event target.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `info` - Indicates the information about a gesture event target.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetGestureEventTargetInfo(
        recognizer: *mut ArkUI_GestureRecognizer,
        info: *mut *mut ArkUI_GestureEventTargetInfo,
    ) -> i32;
    /// Obtains whether this scroll container is scrolled to the top.
    ///
    /// # Arguments
    ///
    /// * `info` - Indicates the information about a gesture event target.
    ///
    /// * `ret` - Indicates whether the scroll container is scrolled to the top.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    /// Returns [`ARKUI_ERROR_CODE_NON_SCROLLABLE_CONTAINER`] if the component is not a scroll container.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureEventTargetInfo_IsScrollBegin(
        info: *mut ArkUI_GestureEventTargetInfo,
        ret: *mut bool,
    ) -> i32;
    /// Obtains whether this scroll container is scrolled to the bottom.
    ///
    /// # Arguments
    ///
    /// * `info` - Indicates the information about a gesture event target.
    ///
    /// * `ret` - Indicates whether the scroll container is scrolled to the bottom.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    /// Returns [`ARKUI_ERROR_CODE_NON_SCROLLABLE_CONTAINER`] if the component is not a scroll container.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GestureEventTargetInfo_IsScrollEnd(
        info: *mut ArkUI_GestureEventTargetInfo,
        ret: *mut bool,
    ) -> i32;
    /// Obtains the direction of a pan gesture.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `directionMask` - Indicates the pan direction.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetPanGestureDirectionMask(
        recognizer: *mut ArkUI_GestureRecognizer,
        directionMask: *mut ArkUI_GestureDirectionMask,
    ) -> i32;
    /// Obtains whether a gesture is a built-in gesture.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns <b>true</b> if the gesture is a built-in gesture; returns <b>false</b> otherwise.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_IsBuiltInGesture(recognizer: *mut ArkUI_GestureRecognizer) -> bool;
    /// Obtains the tag of a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `buffer` - Indicates the buffer.
    ///
    /// * `bufferSize` - Indicates the buffer size.
    ///
    /// * `result` - Indicates the length of the string to be written to the buffer.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    /// Returns [`ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH`] if the buffer is not large enough.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetGestureTag(
        recognizer: *mut ArkUI_GestureRecognizer,
        buffer: *mut ::core::ffi::c_char,
        bufferSize: i32,
        result: *mut i32,
    ) -> i32;
    /// Obtains the ID of the component linked to a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `nodeId` - Indicates the component ID.
    ///
    /// * `size` - Indicates the buffer size.
    ///
    /// * `result` - Indicates the length of the string to be written to the buffer.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    /// Returns [`ARKUI_ERROR_CODE_BUFFER_SIZE_NOT_ENOUGH`] if the buffer is not large enough.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_GetGestureBindNodeId(
        recognizer: *mut ArkUI_GestureRecognizer,
        nodeId: *mut ::core::ffi::c_char,
        size: i32,
        result: *mut i32,
    ) -> i32;
    /// Obtains whether a gesture recognizer is valid.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns <b>true</b> if the gesture recognizer is valid.
    /// Returns <b>false</b> if the gesture recognizer is invalid.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_IsGestureRecognizerValid(recognizer: *mut ArkUI_GestureRecognizer) -> bool;
    /// Obtains custom data in the parallel internal gesture event.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to a parallel internal gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to custom data.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_ParallelInnerGestureEvent_GetUserData(
        event: *mut ArkUI_ParallelInnerGestureEvent,
    ) -> *mut ::core::ffi::c_void;
    /// Obtains the current gesture recognizer in a parallel internal gesture event.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to a parallel internal gesture event.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the current gesture recognizer.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_ParallelInnerGestureEvent_GetCurrentRecognizer(
        event: *mut ArkUI_ParallelInnerGestureEvent,
    ) -> *mut ArkUI_GestureRecognizer;
    /// Obtains the conflicting gesture recognizers in a parallel internal gesture event.
    ///
    /// # Arguments
    ///
    /// * `event` - Indicates the pointer to a parallel internal gesture event.
    ///
    /// * `array` - Indicates the pointer to the array of conflicting gesture recognizers.
    ///
    /// * `size` - Indicates the size of the array of conflicting gesture recognizers.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_ParallelInnerGestureEvent_GetConflictRecognizers(
        event: *mut ArkUI_ParallelInnerGestureEvent,
        array: *mut ArkUI_GestureRecognizerHandleArray,
        size: *mut i32,
    ) -> i32;
    /// Sets a callback function for notifying gesture recognizer destruction.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `callback` - Indicates the callback function for notifying gesture recognizer destruction.
    ///
    /// * `userData` - Indicates the custom data.
    ///
    /// # Returns
    ///
    /// * Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if success.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    ///
    /// Available since API-level: 12
    #[cfg(feature = "api-12")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-12")))]
    pub fn OH_ArkUI_SetArkUIGestureRecognizerDisposeNotify(
        recognizer: *mut ArkUI_GestureRecognizer,
        callback: ArkUI_GestureRecognizerDisposeNotifyCallback,
        userData: *mut ::core::ffi::c_void,
    ) -> i32;
    /// Obtains the swipe direction of a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `directMask` - Swipe direction of the gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter error occurs.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_DirectMask(
        recognizer: *mut ArkUI_GestureRecognizer,
        directMask: *mut ArkUI_GestureDirectionMask,
    ) -> i32;
    /// Obtains the number of fingers used by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `finger` - Number of fingers used by the gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter error occurs.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_FingerCount(
        recognizer: *mut ArkUI_GestureRecognizer,
        finger: *mut ::core::ffi::c_int,
    ) -> i32;
    /// Checks whether a gesture recognizer has a finger count limit.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `isLimited` - Whether the gesture recognizer has a finger count limit.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter error occurs.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_limitFingerCount(
        recognizer: *mut ArkUI_GestureRecognizer,
        isLimited: *mut bool,
    ) -> i32;
    /// Checks whether a gesture recognizer supports repeated event callbacks.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `isRepeat` - Whether the gesture recognizer supports repeated event callbacks.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_repeat(
        recognizer: *mut ArkUI_GestureRecognizer,
        isRepeat: *mut bool,
    ) -> i32;
    /// Obtains the allowed movement distance range for a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `distance` - Allowed movement distance range of the gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_distance(
        recognizer: *mut ArkUI_GestureRecognizer,
        distance: *mut f64,
    ) -> i32;
    /// Obtains the minimum swipe speed recognized by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `speed` - Minimum swipe speed recognized by a gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_speed(
        recognizer: *mut ArkUI_GestureRecognizer,
        speed: *mut f64,
    ) -> i32;
    /// Obtains the minimum duration required to trigger a long press by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `duration` - Minimum duration for a long press.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_duration(
        recognizer: *mut ArkUI_GestureRecognizer,
        duration: *mut ::core::ffi::c_int,
    ) -> i32;
    /// Obtains the minimum angle change required for a rotation gesture to be recognized by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `angle` - Minimum angle change.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_angle(
        recognizer: *mut ArkUI_GestureRecognizer,
        angle: *mut f64,
    ) -> i32;
    /// Obtains the movement threshold for gestures to be recognized by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// * `distanceThresHold` - Movement threshold.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is not
    /// supported.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GetGestureParam_distanceThreshold(
        recognizer: *mut ArkUI_GestureRecognizer,
        distanceThreshold: *mut f64,
    ) -> i32;
    /// Sets the minimum movement distance thresholds for gestures to be recognized by a gesture recognizer.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `size` - Size of the array of minimum movement distance thresholds.
    ///
    /// * `toolTypeArray` - Pointer to the array of tool types for which thresholds are set.
    ///
    /// * `distanceArray` - Pointer to the array of minimum movement distances, in px.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter error occurs.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is
    /// not supported.
    ///
    /// Available since API-level: 19
    #[cfg(feature = "api-19")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-19")))]
    pub fn OH_ArkUI_PanGesture_SetDistanceMap(
        recognizer: *mut ArkUI_GestureRecognizer,
        size: ::core::ffi::c_int,
        toolTypeArray: *mut ::core::ffi::c_int,
        distanceArray: *mut f64,
    ) -> ArkUiResult;
    /// Obtains the movement threshold for gestures to be recognized by a gesture recognizer for a specific tool type.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Indicates the pointer to a gesture recognizer.
    ///
    /// * `toolType` - Tool type for which you want to obtain the threshold.
    ///
    /// * `distance` - Gesture movement threshold of the gesture recognizer, in px.
    ///
    /// # Returns
    ///
    /// * Returns the result code.
    /// Returns [`ARKUI_ERROR_CODE_NO_ERROR`] if the operation is successful.
    /// Returns [`ARKUI_ERROR_CODE_PARAM_INVALID`] if a parameter exception occurs.
    /// Returns [`ARKUI_ERROR_CODE_RECOGNIZER_TYPE_NOT_SUPPORTED`] if the gesture recognizer type is
    /// not supported.
    ///
    /// Available since API-level: 19
    #[cfg(feature = "api-19")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-19")))]
    pub fn OH_ArkUI_PanGesture_GetDistanceByToolType(
        recognizer: *mut ArkUI_GestureRecognizer,
        toolType: ::core::ffi::c_int,
        distance: *mut f64,
    ) -> ArkUiResult;
    /// Registers a callback that is executed after all gesture recognizers are collected.
    /// When the user begins touching the screen, the system performs hit testing and collects gesture recognizers
    /// based on the touch location. Subsequently, before processing any move events, the component can use this API
    /// to determine the gesture recognizers that will participate in and compete for recognition.
    ///
    /// # Arguments
    ///
    /// * `node` - Handle to the node on which the callback is to be set.
    ///
    /// * `userData` - Custom data.
    ///
    /// * `touchTestDone` - Callback for completion of gesture recognizer collection.
    /// - event: Basic information of the gesture.
    /// - recognizers: Array of gesture recognizers.
    /// - count: Number of gesture recognizers.
    ///
    /// # Returns
    ///
    /// * Result code.
    /// [`ARKUI_ERROR_CODE_NO_ERROR`]: The operation is successful.
    /// [`ARKUI_ERROR_CODE_PARAM_INVALID`]: A parameter error occurs.
    ///
    /// Available since API-level: 20
    #[cfg(feature = "api-20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-20")))]
    pub fn OH_ArkUI_SetTouchTestDoneCallback(
        node: ArkUI_NodeHandle,
        userData: *mut ::core::ffi::c_void,
        touchTestDone: ::core::option::Option<
            unsafe extern "C" fn(
                event: *mut ArkUI_GestureEvent,
                recognizers: ArkUI_GestureRecognizerHandleArray,
                count: i32,
                userData: *mut ::core::ffi::c_void,
            ),
        >,
    ) -> ArkUiResult;
    /// Obtains the custom data from a gesture interruption event.
    ///
    /// # Arguments
    ///
    /// * `event` - Pointer to the gesture interruption information.
    ///
    /// # Returns
    ///
    /// * Returns the pointer to the custom data.
    ///
    /// Available since API-level: 18
    #[cfg(feature = "api-18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-18")))]
    pub fn OH_ArkUI_GestureInterrupter_GetUserData(
        event: *mut ArkUI_GestureInterruptInfo,
    ) -> *mut ::core::ffi::c_void;
    /// Prevents a gesture recognizer from participating in the current gesture recognition before all fingers are
    /// lifted.
    /// If the system has already determined the result of the gesture recognizer (regardless of success or failure),
    /// calling this API will be ineffective.
    ///
    /// # Arguments
    ///
    /// * `recognizer` - Pointer to a gesture recognizer.
    ///
    /// # Returns
    ///
    /// * Result code.
    /// [`ARKUI_ERROR_CODE_NO_ERROR`]: The operation is successful.
    /// [`ARKUI_ERROR_CODE_PARAM_INVALID`]: A parameter error occurs.
    ///
    /// Available since API-level: 20
    #[cfg(feature = "api-20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "api-20")))]
    pub fn OH_ArkUI_PreventGestureRecognizerBegin(
        recognizer: *mut ArkUI_GestureRecognizer,
    ) -> ArkUiResult;
}