@lynx-js/types 3.4.3 → 3.5.9

package/types/common/events.d.ts

@@ -64,25 +64,41 @@ export interface ChangedTouch {
 export interface BaseCommonEvent<T> extends BaseEventOrig<any, T> {}
 export interface CommonEvent extends BaseCommonEvent<Target | MainThreadElement> {}
 
-export interface AppearanceEvent {
-  type: 'nodeappear' | 'nodedisappear';
-  detail: {
-    position: number;
-    key: string;
-  };
-}
-
 export interface BaseTouchEvent<T> extends BaseEventOrig<any, T> {
-  /** The touch points currently on the touch plane. */
+  /** 
+   * Collection of touch points currently on the touch plane.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   touches: Array<Touch>;
 
-  /** The touch points whose state has changed compared to the last touch event. */
+  /** 
+   * Collection of touch points whose state has changed compared to the last touch event.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   changedTouches: Array<Touch>;
 
   detail: {
-    /** The current position of the touch point relative to the page's x-coordinate. */
+    /** 
+     * The current position of the touch point relative to the page's x-coordinate.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     x: number;
-    /** The current position of the touch point relative to the page's y-coordinate. */
+    /** 
+     * The current position of the touch point relative to the page's y-coordinate.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     y: number;
   }
 }
@@ -90,58 +106,137 @@ export interface BaseTouchEvent<T> extends BaseEventOrig<any, T> {
 export interface TouchEvent extends BaseTouchEvent<Target> {}
 
 export interface BaseMouseEvent<T> extends BaseEventOrig<{}, T> {
-  /** The currently pressed mouse button, if multiple buttons are pressed simultaneously, is the last one pressed. */
+  /** 
+   * The currently pressed mouse button, if multiple buttons are pressed simultaneously, is the last one pressed. 
+   * @PC
+   */
   button: number;
-  /** The current mouse button being pressed, if multiple buttons are simultaneously pressed, it is a bit field composed of all button codes. */
+  /** 
+   * The current mouse button being pressed, if multiple buttons are simultaneously pressed, it is a bit field composed of all button codes. 
+   * @PC
+   */
   buttons: number;
-  /** clientX */
+  /** 
+   * clientX 
+   * @PC
+   */
   x: number;
-  /** clientY */
+  /** 
+   * clientY 
+   * @PC
+   */
   y: number;
-  /** The current position of the cursor relative to the page's x-coordinate. */
+  /** 
+   * The current position of the cursor relative to the page's x-coordinate. 
+   * @PC
+   */
   pageX: number;
-  /** The current position of the cursor relative to the page's y-coordinate. */
+  /** 
+   * The current position of the cursor relative to the page's y-coordinate. 
+   * @PC
+   */
   pageY: number;
-  /** The current position of the cursor relative to the element's x-coordinate. */
+  /** 
+   * The current position of the cursor relative to the element's x-coordinate. 
+   * @PC
+   */
   clientX: number;
-  /** The current position of the cursor relative to the element's y-coordinate. */
+  /** 
+   * The current position of the cursor relative to the element's y-coordinate. 
+   * @PC
+   */
   clientY: number;
 }
 
 export interface MouseEvent extends BaseMouseEvent<Target> {}
 
 export interface BaseWheelEvent<T> extends BaseEventOrig<{}, T> {
-  /** clientX */
+  /** 
+   * clientX 
+   * @PC
+   */
   x: number;
-  /** clientY */
+  /** 
+   * clientY 
+   * @PC
+   */
   y: number;
-  /** The current position of the cursor relative to the page's x-coordinate. */
+  /** 
+   * The current position of the cursor relative to the page's x-coordinate. 
+   * @PC
+   */
   pageX: number;
-  /** The current position of the cursor relative to the page's y-coordinate. */
+  /** 
+   * The current position of the cursor relative to the page's y-coordinate. 
+   * @PC
+   */
   pageY: number;
-  /** The current position of the cursor relative to the element's x-coordinate. */
+  /** 
+   * The current position of the cursor relative to the element's x-coordinate. 
+   * @PC
+   */ 
   clientX: number;
-  /** The current position of the cursor relative to the element's y-coordinate. */
+  /** 
+   * The current position of the cursor relative to the element's y-coordinate. 
+   * @PC
+   */
   clientY: number;
-  /** The distance of x-axis scrolling on the mouse wheel. */
+  /** 
+   * The distance of x-axis scrolling on the mouse wheel. 
+   * @PC
+   */ 
   deltaX: number;
-  /** The distance of y-axis scrolling on the mouse wheel. */
+  /** 
+   * The distance of y-axis scrolling on the mouse wheel. 
+   * @PC
+   */
   deltaY: number;
 }
 
 export interface WheelEvent extends BaseWheelEvent<Target> {}
 
 export interface BaseKeyEvent<T> extends BaseEventOrig<{}, T> {
-  /** Button Name. */
+  /** 
+   * Button Name
+   * @PC 
+   */
   key: string;
 }
 
 export interface KeyEvent extends BaseKeyEvent<Target> {}
 
 export interface BaseAnimationEvent<T> extends BaseEventOrig<{}, T> {
+  /** 
+   * Animation params.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   params: {
+    /**
+     * Animation type.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     animation_type: 'keyframe-animation';
+    /**
+     * Animation name.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     animation_name: string;
+    /**
+     * If new animator enabled.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     new_animator?: true;
   };
 }
@@ -173,33 +268,51 @@ export interface BaseTransitionEvent<T> extends BaseEventOrig<{}, T> {
 export interface TransitionEvent extends BaseTransitionEvent<Target> {}
 
 export interface BaseImageLoadEvent<T> extends BaseEventOrig<{}, T> {
-  detail: {
-    width: number;
-    height: number;
-  };
+  /**
+   * Image width. In pixels.
+   * @Android
+   * @iOS
+   */
+  width: number;
+  /**
+   * Image height. In pixels. 
+   * @Android
+   * @iOS
+   */
+  height: number;
 }
 
 export interface ImageLoadEvent extends BaseImageLoadEvent<Target> {
-  detail: {
     width: number;
     height: number;
-  };
 }
 
+
 export interface BaseImageErrorEvent<T> extends BaseEventOrig<{}, T> {
-  detail: {
-    errMsg: string;
-    error_code: number;
-    lynx_categorized_code: number;
-  };
+  /**
+   * Error message.
+   * @Android
+   * @iOS
+   */
+  errMsg: string;
+  /**
+   * Error code.
+   * @Android
+   * @iOS
+   */
+  error_code: number;
+  /**
+   * Categorized error code.
+   * @Android
+   * @iOS
+   */
+  lynx_categorized_code: number;
 }
 
 export interface ImageErrorEvent extends BaseImageErrorEvent<Target> {
-  detail: {
     errMsg: string;
     error_code: number;
     lynx_categorized_code: number;
-  };
 }
 
 export interface TextLineInfo {
@@ -253,23 +366,74 @@ export interface LayoutChangeDetailEvent<T> extends BaseEventOrig<{}, T> {
 
   /**
    * This field is available on other platforms.
-   * */
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   detail: {
-    /** The id selector of the target. */
+    /**
+     * The id selector of the target.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     id: string;
-    /** The width of the target. */
+    /** 
+     * The width of the target. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     width: number;
-    /** The height of the target. */
+    /** The height of the target. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */ 
     height: number;
-    /** The position of the target's top border relative to the page's coordinate. */
+    /** 
+     * The position of the target's top border relative to the page's coordinate. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     top: number;
-    /** The position of the target's right border relative to the page's coordinate. */
+    /** 
+     * The position of the target's right border relative to the page's coordinate. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     right: number;
-    /** The position of the target's bottom border relative to the page's coordinate. */
+    /** 
+     * The position of the target's bottom border relative to the page's coordinate. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     bottom: number;
-    /** The position of the target's left border relative to the page's coordinate. */
+    /** 
+     * The position of the target's left border relative to the page's coordinate. In pixels.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     left: number;
-    /** The collection of custom attributes starting with data- on the event target. */
+    /** 
+     * The collection of custom attributes starting with data- on the event target.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     dataset: {
       [key: string]: any;
     };
@@ -279,13 +443,37 @@ export interface LayoutChangeDetailEvent<T> extends BaseEventOrig<{}, T> {
 export interface UIAppearanceDetailEvent<T> extends BaseEventOrig<{}, T> {
   type: 'uiappear' | 'uidisappear';
   detail: {
-    /** exposure-id set on the target. */
+    /** 
+     * exposure-id set on the target.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     'exposure-id': string;
-    /** exposure-scene set on the target. */
+    /** 
+     * exposure-scene set on the target.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     'exposure-scene': string;
-    /** uid of the target */
+    /** 
+     * uid of the target
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     'unique-id': string;
-    /** The collection of custom attributes starting with data- on the event target. */
+    /** 
+     * The collection of custom attributes starting with data- on the event target.
+     * @Android
+     * @iOS
+     * @Harmony
+     * @PC
+     */
     dataset: {
       [key: string]: any;
     };
@@ -315,32 +503,66 @@ export interface LepusEventInstance {
 export type EventHandler<T> = (event: T, instance?: LepusEventInstance) => void;
 
 export interface BaseEvent<T = string, D = any> {
-  /** Event type. */
+  /** 
+   * Event type.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   type: T;
 
-  /** Timestamp when the event was generated. */
+  /** 
+   * Timestamp when the event was generated.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   timestamp: number;
 
-  /** Collection of attribute values of the target that triggers the event. */
+  /** 
+   * Collection of attribute values of the target that triggers the event.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   target: Target;
 
-  /** Collection of attribute values of the target that listens to the event. */
+  /** 
+   * Collection of attribute values of the target that listens to the event.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   currentTarget: Target;
 
-  /** Additional information. */
+  /** 
+   * Additional information.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   detail: D;
 }
 
 export interface LynxEvent<T> {
   /**
    * Listening for background image loading success.
-   * @since since Lynx 2.6
+   * @Android
+   * @iOS
+   * @since 2.6
    */
   BGLoad?: EventHandler<BaseImageLoadEvent<T>>;
 
   /**
    * Failed to load background image for listening.
-   * @since since: Android: Lynx 2.6, iOS: Lynx 2.8
+   * @Android
+   * @iOS
+   * @since 2.8
    */
   BGError?: EventHandler<BaseImageErrorEvent<T>>;
 
@@ -348,87 +570,206 @@ export interface LynxEvent<T> {
 
   // NodeDisappear?: EventHandler<ReactLynx.AppearanceEvent>;
 
-  /** Finger touch action begins. */
+  /** 
+   * Finger touch action begins. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TouchStart?: EventHandler<BaseTouchEvent<T>>;
 
-  /** Moving after touching with fingers. */
+  /** 
+   * Moving after touching with fingers.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TouchMove?: EventHandler<BaseTouchEvent<T>>;
 
-  /** Finger touch actions are interrupted by incoming call reminders and pop-up windows. */
+  /** 
+   * Finger touch actions are interrupted by incoming call reminders and pop-up windows. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TouchCancel?: EventHandler<BaseTouchEvent<T>>;
 
-  /** Finger touch action ends. */
+  /** 
+   * Finger touch action ends. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TouchEnd?: EventHandler<BaseTouchEvent<T>>;
 
-  /** After touching the finger, if it leaves after more than 350ms and the event callback function is specified and triggered, the tap event will not be triggered. */
-  LongPress?: EventHandler<BaseCommonEvent<T>>;
+  /** 
+   * After touching the finger, if it leaves after more than 350ms and the event callback function is specified and triggered, the tap event will not be triggered. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
+  LongPress?: EventHandler<BaseTouchEvent<T>>;
 
-  /** It will trigger during a transition animation start. */
+  /** 
+   * It will trigger during a transition animation start. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */ 
   TransitionStart?: EventHandler<BaseTransitionEvent<T>>;
 
-  /** It will trigger when a transition animation is cancelled. */
+  /** 
+   * It will trigger when a transition animation is cancelled. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TransitionCancel?: EventHandler<BaseTransitionEvent<T>>;
 
-  /** It will trigger after the transition or createAnimation animation is finished. */
+  /** 
+   * It will trigger after the transition or createAnimation animation is finished. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   TransitionEnd?: EventHandler<BaseTransitionEvent<T>>;
 
-  /** It will trigger at the beginning of an animation. */
+  /** 
+   * It will trigger at the beginning of an animation. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   AnimationStart?: EventHandler<BaseAnimationEvent<T>>;
 
-  /** It will trigger during an animation iteration. */
+  /** 
+   * It will trigger during an animation iteration. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   AnimationIteration?: EventHandler<BaseAnimationEvent<T>>;
 
-  /** It will trigger when an animation is cancelled. */
+  /** 
+   * It will trigger when an animation is cancelled. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   AnimationCancel?: EventHandler<BaseAnimationEvent<T>>;
 
-  /** It will trigger upon completion of an animation. */
+  /** 
+   * It will trigger upon completion of an animation. 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   AnimationEnd?: EventHandler<BaseAnimationEvent<T>>;
 
-  /** Mouse Clicked. */
+  /** 
+   * Indicates that a mouse button (primary or secondary) is pressed. The target is the UI that contains the mouse pointer and is closest to the user.
+   * @PC
+   */
   MouseDown?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Mouse released. */
+  /** 
+   * Indicates that a mouse button (primary or secondary) is released. The target is the UI that contains the mouse pointer and is closest to the user.
+   * @PC
+   */
   MouseUp?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Mouse movement. */
+  /** 
+   * Mouse movement.
+   * @PC
+   */
   MouseMove?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Mouse click. */
+  /** 
+   * Mouse click.
+   * @PC
+   */
   MouseClick?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Double-click the mouse.  */
+  /** 
+   * Double-click the mouse.
+   * @PC  
+   */
   MouseDblClick?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Long press on the mouse. */
+  /** 
+   * Long press on the mouse.
+   * @PC
+   */
   MouseLongPress?: EventHandler<BaseMouseEvent<T>>;
 
-  /** Mouse (or touchpad) scrolling. */
+  /** 
+   * Mouse (or touchpad) scrolling.
+   * @PC
+   */
   Wheel?: EventHandler<BaseWheelEvent<T>>;
 
-  /** Keyboard (or remote control) button pressed. */
+  /** 
+   * Keyboard (or remote control) button pressed.
+   * @PC
+   */
   KeyDown?: EventHandler<BaseKeyEvent<T>>;
 
-  /** Keyboard (or remote control) key released. */
+  /** 
+   * Keyboard (or remote control) key released.
+   * @PC
+   */
   KeyUp?: EventHandler<BaseKeyEvent<T>>;
 
-  /** Element gets focus. */
+  /** 
+   * Element gets focus.
+   * @PC
+   */
   Focus?: EventHandler<BaseCommonEvent<T>>;
 
-  /** Element loses focus. */
+  /** 
+   * Element loses focus.
+   * @PC
+   */
   Blur?: EventHandler<BaseCommonEvent<T>>;
 
-  /** layout info Change event */
+  /** 
+   * Layout info changed event 
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   LayoutChange?: EventHandler<LayoutChangeDetailEvent<T>>;
 
-  /** UI appear event */
+  /**
+   * Element appear event
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   UIAppear?: EventHandler<UIAppearanceDetailEvent<T>>;
 
-  /** UI disappear event */
-  UIDisappear?: EventHandler<UIAppearanceDetailEvent<T>>;
-  /**
-   * The text layout event is triggered when the text layout changes.
-   * @since since: Android: Lynx 2.6, iOS: Lynx 2.8
+  /** 
+   * Element disappear event
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
+  UIDisappear?: EventHandler<UIAppearanceDetailEvent<T>>;
 
   /**
    * The custom actions of the current accessibility element is triggered.
@@ -447,18 +788,99 @@ export interface UIAppearanceEvent extends UIAppearanceDetailEvent<Target> {}
  * This type is different with LynxEvent that they only have `bind` and `catch` event. But not `on` Event.
  */
 export interface LynxBindCatchEvent<T = any> {
-  /** Immediately lift your finger after touching. */
+  /**
+   * Triggered when a finger clicks on the touch plane. This event and the `longpress` event are mutually exclusive in event listening. That is, if the front-end listens to both events simultaneously, the two events will not be triggered at the same time, and the `longpress` event takes precedence.
+   * @Android
+   * @iOS
+   * @Harmony
+   * @PC
+   */
   Tap?: EventHandler<BaseTouchEvent<T>>;
 
-  /** After touching the finger, leave after more than 350ms (it is recommended to use the longpress event instead). */
+  /** 
+   * After touching the finger, leave after more than 350ms
+   * @deprecated It is recommended to use the longpress event instead
+   */
   LongTap?: EventHandler<BaseTouchEvent<T>>;
 }
 
-export type LynxEventPropsBase<T> = {
-  [K in keyof LynxEvent<T> as Lowercase<`bind${K}` | `catch${K}` | `capture-bind${K}` | `capture-catch${K}` | `global-bind${K}`>]: LynxEvent<T>[K];
-} & {
-  [K in keyof LynxBindCatchEvent<T> as Lowercase<`bind${K}` | `catch${K}` | `capture-bind${K}` | `capture-catch${K}` | `global-bind${K}`>]: LynxBindCatchEvent<T>[K];
-};
+type PrefixedEvent<E> = {
+  bind?: E;
+  catch?: E;
+  'capture-bind'?: E;
+  'capture-catch'?: E;
+  'global-bind'?: E;
+}
+
+// Helper interfaces for each event, providing explicit properties
+// for bind, catch, capture-bind, capture-catch, and global-bind prefixes.
+interface BGLoadProps<T> { bindbgload?: LynxEvent<T>['BGLoad']; catchbgload?: LynxEvent<T>['BGLoad']; 'capture-bindbgload'?: LynxEvent<T>['BGLoad']; 'capture-catchbgload'?: LynxEvent<T>['BGLoad']; 'global-bindbgload'?: LynxEvent<T>['BGLoad']; }
+interface BGErrorProps<T> { bindbgerror?: LynxEvent<T>['BGError']; catchbgerror?: LynxEvent<T>['BGError']; 'capture-bindbgerror'?: LynxEvent<T>['BGError']; 'capture-catchbgerror'?: LynxEvent<T>['BGError']; 'global-bindbgerror'?: LynxEvent<T>['BGError']; }
+interface TouchStartProps<T> { bindtouchstart?: LynxEvent<T>['TouchStart']; catchtouchstart?: LynxEvent<T>['TouchStart']; 'capture-bindtouchstart'?: LynxEvent<T>['TouchStart']; 'capture-catchtouchstart'?: LynxEvent<T>['TouchStart']; 'global-bindtouchstart'?: LynxEvent<T>['TouchStart']; }
+interface TouchMoveProps<T> { bindtouchmove?: LynxEvent<T>['TouchMove']; catchtouchmove?: LynxEvent<T>['TouchMove']; 'capture-bindtouchmove'?: LynxEvent<T>['TouchMove']; 'capture-catchtouchmove'?: LynxEvent<T>['TouchMove']; 'global-bindtouchmove'?: LynxEvent<T>['TouchMove']; }
+interface TouchCancelProps<T> { bindtouchcancel?: LynxEvent<T>['TouchCancel']; catchtouchcancel?: LynxEvent<T>['TouchCancel']; 'capture-bindtouchcancel'?: LynxEvent<T>['TouchCancel']; 'capture-catchtouchcancel'?: LynxEvent<T>['TouchCancel']; 'global-bindtouchcancel'?: LynxEvent<T>['TouchCancel']; }
+interface TouchEndProps<T> { bindtouchend?: LynxEvent<T>['TouchEnd']; catchtouchend?: LynxEvent<T>['TouchEnd']; 'capture-bindtouchend'?: LynxEvent<T>['TouchEnd']; 'capture-catchtouchend'?: LynxEvent<T>['TouchEnd']; 'global-bindtouchend'?: LynxEvent<T>['TouchEnd']; }
+interface LongPressProps<T> { bindlongpress?: LynxEvent<T>['LongPress']; catchlongpress?: LynxEvent<T>['LongPress']; 'capture-bindlongpress'?: LynxEvent<T>['LongPress']; 'capture-catchlongpress'?: LynxEvent<T>['LongPress']; 'global-bindlongpress'?: LynxEvent<T>['LongPress']; }
+interface TransitionStartProps<T> { bindtransitionstart?: LynxEvent<T>['TransitionStart']; catchtransitionstart?: LynxEvent<T>['TransitionStart']; 'capture-bindtransitionstart'?: LynxEvent<T>['TransitionStart']; 'capture-catchtransitionstart'?: LynxEvent<T>['TransitionStart']; 'global-bindtransitionstart'?: LynxEvent<T>['TransitionStart']; }
+interface TransitionCancelProps<T> { bindtransitioncancel?: LynxEvent<T>['TransitionCancel']; catchtransitioncancel?: LynxEvent<T>['TransitionCancel']; 'capture-bindtransitioncancel'?: LynxEvent<T>['TransitionCancel']; 'capture-catchtransitioncancel'?: LynxEvent<T>['TransitionCancel']; 'global-bindtransitioncancel'?: LynxEvent<T>['TransitionCancel']; }
+interface TransitionEndProps<T> { bindtransitionend?: LynxEvent<T>['TransitionEnd']; catchtransitionend?: LynxEvent<T>['TransitionEnd']; 'capture-bindtransitionend'?: LynxEvent<T>['TransitionEnd']; 'capture-catchtransitionend'?: LynxEvent<T>['TransitionEnd']; 'global-bindtransitionend'?: LynxEvent<T>['TransitionEnd']; }
+interface AnimationStartProps<T> { bindanimationstart?: LynxEvent<T>['AnimationStart']; catchanimationstart?: LynxEvent<T>['AnimationStart']; 'capture-bindanimationstart'?: LynxEvent<T>['AnimationStart']; 'capture-catchanimationstart'?: LynxEvent<T>['AnimationStart']; 'global-bindanimationstart'?: LynxEvent<T>['AnimationStart']; }
+interface AnimationIterationProps<T> { bindanimationiteration?: LynxEvent<T>['AnimationIteration']; catchanimationiteration?: LynxEvent<T>['AnimationIteration']; 'capture-bindanimationiteration'?: LynxEvent<T>['AnimationIteration']; 'capture-catchanimationiteration'?: LynxEvent<T>['AnimationIteration']; 'global-bindanimationiteration'?: LynxEvent<T>['AnimationIteration']; }
+interface AnimationCancelProps<T> { bindanimationcancel?: LynxEvent<T>['AnimationCancel']; catchanimationcancel?: LynxEvent<T>['AnimationCancel']; 'capture-bindanimationcancel'?: LynxEvent<T>['AnimationCancel']; 'capture-catchanimationcancel'?: LynxEvent<T>['AnimationCancel']; 'global-bindanimationcancel'?: LynxEvent<T>['AnimationCancel']; }
+interface AnimationEndProps<T> { bindanimationend?: LynxEvent<T>['AnimationEnd']; catchanimationend?: LynxEvent<T>['AnimationEnd']; 'capture-bindanimationend'?: LynxEvent<T>['AnimationEnd']; 'capture-catchanimationend'?: LynxEvent<T>['AnimationEnd']; 'global-bindanimationend'?: LynxEvent<T>['AnimationEnd']; }
+interface MouseDownProps<T> { bindmousedown?: LynxEvent<T>['MouseDown']; catchmousedown?: LynxEvent<T>['MouseDown']; 'capture-bindmousedown'?: LynxEvent<T>['MouseDown']; 'capture-catchmousedown'?: LynxEvent<T>['MouseDown']; 'global-bindmousedown'?: LynxEvent<T>['MouseDown']; }
+interface MouseUpProps<T> { bindmouseup?: LynxEvent<T>['MouseUp']; catchmouseup?: LynxEvent<T>['MouseUp']; 'capture-bindmouseup'?: LynxEvent<T>['MouseUp']; 'capture-catchmouseup'?: LynxEvent<T>['MouseUp']; 'global-bindmouseup'?: LynxEvent<T>['MouseUp']; }
+interface MouseMoveProps<T> { bindmousemove?: LynxEvent<T>['MouseMove']; catchmousemove?: LynxEvent<T>['MouseMove']; 'capture-bindmousemove'?: LynxEvent<T>['MouseMove']; 'capture-catchmousemove'?: LynxEvent<T>['MouseMove']; 'global-bindmousemove'?: LynxEvent<T>['MouseMove']; }
+interface MouseClickProps<T> { bindmouseclick?: LynxEvent<T>['MouseClick']; catchmouseclick?: LynxEvent<T>['MouseClick']; 'capture-bindmouseclick'?: LynxEvent<T>['MouseClick']; 'capture-catchmouseclick'?: LynxEvent<T>['MouseClick']; 'global-bindmouseclick'?: LynxEvent<T>['MouseClick']; }
+interface MouseDblClickProps<T> { bindmousedblclick?: LynxEvent<T>['MouseDblClick']; catchmousedblclick?: LynxEvent<T>['MouseDblClick']; 'capture-bindmousedblclick'?: LynxEvent<T>['MouseDblClick']; 'capture-catchmousedblclick'?: LynxEvent<T>['MouseDblClick']; 'global-bindmousedblclick'?: LynxEvent<T>['MouseDblClick']; }
+interface MouseLongPressProps<T> { bindmouselongpress?: LynxEvent<T>['MouseLongPress']; catchmouselongpress?: LynxEvent<T>['MouseLongPress']; 'capture-bindmouselongpress'?: LynxEvent<T>['MouseLongPress']; 'capture-catchmouselongpress'?: LynxEvent<T>['MouseLongPress']; 'global-bindmouselongpress'?: LynxEvent<T>['MouseLongPress']; }
+interface WheelProps<T> { bindwheel?: LynxEvent<T>['Wheel']; catchwheel?: LynxEvent<T>['Wheel']; 'capture-bindwheel'?: LynxEvent<T>['Wheel']; 'capture-catchwheel'?: LynxEvent<T>['Wheel']; 'global-bindwheel'?: LynxEvent<T>['Wheel']; }
+interface KeyDownProps<T> { bindkeydown?: LynxEvent<T>['KeyDown']; catchkeydown?: LynxEvent<T>['KeyDown']; 'capture-bindkeydown'?: LynxEvent<T>['KeyDown']; 'capture-catchkeydown'?: LynxEvent<T>['KeyDown']; 'global-bindkeydown'?: LynxEvent<T>['KeyDown']; }
+interface KeyUpProps<T> { bindkeyup?: LynxEvent<T>['KeyUp']; catchkeyup?: LynxEvent<T>['KeyUp']; 'capture-bindkeyup'?: LynxEvent<T>['KeyUp']; 'capture-catchkeyup'?: LynxEvent<T>['KeyUp']; 'global-bindkeyup'?: LynxEvent<T>['KeyUp']; }
+interface FocusProps<T> { bindfocus?: LynxEvent<T>['Focus']; catchfocus?: LynxEvent<T>['Focus']; 'capture-bindfocus'?: LynxEvent<T>['Focus']; 'capture-catchfocus'?: LynxEvent<T>['Focus']; 'global-bindfocus'?: LynxEvent<T>['Focus']; }
+interface BlurProps<T> { bindblur?: LynxEvent<T>['Blur']; catchblur?: LynxEvent<T>['Blur']; 'capture-bindblur'?: LynxEvent<T>['Blur']; 'capture-catchblur'?: LynxEvent<T>['Blur']; 'global-bindblur'?: LynxEvent<T>['Blur']; }
+interface LayoutChangeProps<T> { bindlayoutchange?: LynxEvent<T>['LayoutChange']; catchlayoutchange?: LynxEvent<T>['LayoutChange']; 'capture-bindlayoutchange'?: LynxEvent<T>['LayoutChange']; 'capture-catchlayoutchange'?: LynxEvent<T>['LayoutChange']; 'global-bindlayoutchange'?: LynxEvent<T>['LayoutChange']; }
+interface UIAppearProps<T> { binduiappear?: LynxEvent<T>['UIAppear']; catchuiappear?: LynxEvent<T>['UIAppear']; 'capture-binduiappear'?: LynxEvent<T>['UIAppear']; 'capture-catchuiappear'?: LynxEvent<T>['UIAppear']; 'global-binduiappear'?: LynxEvent<T>['UIAppear']; }
+interface UIDisappearProps<T> { binduidisappear?: LynxEvent<T>['UIDisappear']; catchuidisappear?: LynxEvent<T>['UIDisappear']; 'capture-binduidisappear'?: LynxEvent<T>['UIDisappear']; 'capture-catchuidisappear'?: LynxEvent<T>['UIDisappear']; 'global-binduidisappear'?: LynxEvent<T>['UIDisappear']; }
+interface AccessibilityActionProps<T> { bindaccessibilityaction?: LynxEvent<T>['AccessibilityAction']; catchaccessibilityaction?: LynxEvent<T>['AccessibilityAction']; 'capture-bindaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; 'capture-catchaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; 'global-bindaccessibilityaction'?: LynxEvent<T>['AccessibilityAction']; }
+interface TapProps<T> { bindtap?: LynxBindCatchEvent<T>['Tap']; catchtap?: LynxBindCatchEvent<T>['Tap']; 'capture-bindtap'?: LynxBindCatchEvent<T>['Tap']; 'capture-catchtap'?: LynxBindCatchEvent<T>['Tap']; 'global-bindtap'?: LynxBindCatchEvent<T>['Tap']; }
+interface LongTapProps<T> { bindlongtap?: LynxBindCatchEvent<T>['LongTap']; catchlongtap?: LynxBindCatchEvent<T>['LongTap']; 'capture-bindlongtap'?: LynxBindCatchEvent<T>['LongTap']; 'capture-catchlongtap'?: LynxBindCatchEvent<T>['LongTap']; 'global-bindlongtap'?: LynxBindCatchEvent<T>['LongTap']; }
+
+/**
+ * A combination of all possible event properties, statically defined for IDE-friendliness.
+ * This replaces the previous dynamic mapped type.
+ */
+export type LynxEventPropsBase<T> = BGLoadProps<T> &
+  BGErrorProps<T> &
+  TouchStartProps<T> &
+  TouchMoveProps<T> &
+  TouchCancelProps<T> &
+  TouchEndProps<T> &
+  LongPressProps<T> &
+  TransitionStartProps<T> &
+  TransitionCancelProps<T> &
+  TransitionEndProps<T> &
+  AnimationStartProps<T> &
+  AnimationIterationProps<T> &
+  AnimationCancelProps<T> &
+  AnimationEndProps<T> &
+  MouseDownProps<T> &
+  MouseUpProps<T> &
+  MouseMoveProps<T> &
+  MouseClickProps<T> &
+  MouseDblClickProps<T> &
+  MouseLongPressProps<T> &
+  WheelProps<T> &
+  KeyDownProps<T> &
+  KeyUpProps<T> &
+  FocusProps<T> &
+  BlurProps<T> &
+  LayoutChangeProps<T> &
+  UIAppearProps<T> &
+  UIDisappearProps<T> &
+  AccessibilityActionProps<T> &
+  TapProps<T> &
+  LongTapProps<T>;
 
 export type LynxEventProps = LynxEventPropsBase<Target>;