@lynx-js/types 3.4.11 → 3.5.9

package/types/common/element/list.d.ts

@@ -1,1144 +1,724 @@
-// Copyright 2024 The Lynx Authors. All rights reserved.
+// Copyright 2025 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
 
-import { AppearanceEvent, BaseEvent, BaseMethod, EventHandler } from '../events';
+import { BaseEvent, BaseMethod, EventHandler } from '../events';
 import { StandardProps } from '../props';
 
-export enum ListEventSource {
-  DIFF = 0,
-  LAYOUT = 1,
-  SCROLL = 2,
-}
-
-/** The enum value of list batch render strategy.
- * DEFAULT: The default value with the normal list's rendering process.
- * BATCH_RENDER: Use batch render and the list will batch render multiple items.
- * ASYNC_RESOLVE_PROPERTY: Use batch render and enable async resolve property of the list item.
- * ASYNC_RESOLVE_PROPERTY_AND_ELEMENT_TREE (Recommended): Use batch render and enable async resolve property and element tree of the list item.
+/**
+ * The scroll state of the list.
+ * SCROLL_STATE_STOP: In an idle, settled state.
+ * SCROLL_STATE_DRAGGING: Is currently being dragged by outside input such as user touch.
+ * SCROLL_STATE_DECELERATE: Is currently animating to a final position triggered by fling.
+ * SCROLL_STATE_ANIMATION: Is currently animating to a final position triggered by smooth scroll.
  * @Android
  * @iOS
+ * @Harmony
+ * @PC
  */
-export enum BatchRenderStrategy {
-  DEFAULT = 0,
-  BATCH_RENDER = 1,
-  ASYNC_RESOLVE_PROPERTY = 2,
-  ASYNC_RESOLVE_PROPERTY_AND_ELEMENT_TREE = 3
+export enum ListScrollState {
+  SCROLL_STATE_STOP = 1,
+  SCROLL_STATE_DRAGGING = 2,
+  SCROLL_STATE_DECELERATE = 3,
+  SCROLL_STATE_ANIMATION = 4,
 }
 
-export interface ListScrollInfo {
-  /**
-   * scroll left from start
-   * @Android
-   * @iOS
-   */
-  scrollLeft: number;
-  /**
-   * scroll top from start
-   * @Android
-   * @iOS
-   */
-  scrollTop: number;
-  /**
-   * scroll content width
-   * @Android
-   * @iOS
-   */
-  scrollWidth: number;
-  /**
-   * scroll content height
-   * @Android
-   * @iOS
-   */
-  scrollHeight: number;
-  /**
-   * list width
-   * @Android
-   * @iOS
-   */
-  listWidth: number;
-  /**
-   * list height
-   * @Android
-   * @iOS
-   */
-  listHeight: number;
-  /**
-   * X-axis scroll delta for this scroll. It's always 0 in some non-scroll related events.
-   * @Android
-   * @iOS
-   */
-  deltaX: number;
-  /**
-   * Y-axis scroll delta for this scroll. It's always 0 in some non-scroll related events.
-   * @Android
-   * @iOS
-   */
-  deltaY: number;
-  /**
-   * Source of the event.
-   * @Android
-   * @iOS
-   */
-  eventSource: ListEventSource;
-  /**
-   * attached cells
-   * @iOS
-   * @Android
-   */
-  attachedCells: ListAttachedCell[];
+/**
+ * The source of the scroll event.
+ * @Android
+ * @iOS
+ * @Harmony
+ * @PC
+ */
+export enum ListEventSource {
+  DIFF = 0,
+  LAYOUT = 1,
+  SCROLL = 2,
 }
 
-export interface ListScrollEvent extends BaseEvent<'scroll', ListScrollInfo> {}
-export interface ListScrollToLowerEvent extends BaseEvent<'scrolltolower', ListScrollInfo> {}
-export interface ListScrollToUpperEvent extends BaseEvent<'scrolltoupper', ListScrollInfo> {}
-export interface ListScrollToUpperEdgeEvent extends BaseEvent<'scrolltoupperedge', ListScrollInfo> {}
-export interface ListScrollToLowerEdgeEvent extends BaseEvent<'scrolltoloweredge', ListScrollInfo> {}
-export interface ListScrollToNormalStateEvent extends BaseEvent<'scrolltonormalstate', ListScrollInfo> {}
-
-export interface ListItemSnapAlignment {
-  /**
-   * Paging factor, 0.0 means align to the top, while 1.0 means align to the bottom.
-   * @Android
-   * @iOS
-   */
-  factor: number;
+export interface ListAttachedCell {
   /**
-   * In addition to the parameter of factor, an offset for alignment can be set, in px.
-   * @Android
+   * id of list item
    * @iOS
-   */
-  offset: number;
-}
-
-export interface ListItemInfo {
-  /**
-   * Height of the item, in px.
    * @Android
-   * @iOS
-   * @H
+   * @Harmony
+   * @PC
    */
-  height: number;
+  id: string;
   /**
-   * Width of the item, in px.
-   * @Android
+   * item-key of list item
    * @iOS
-   * @H
-   */
-  width: number;
-  /**
-   * ItemKey of the list-item.
    * @Android
-   * @iOS
-   * @H
+   * @Harmony
+   * @PC
    */
   itemKey: string;
   /**
-   * When the list is running in multi-thread mode, this property indicates whether the item is currently being rendered and has not finished rendering. In this state, the item will have a default height that is the same as the list's height or an estimated height if one has been set.
-   * @Android
-   * @iOS
-   * @H
-   */
-  isBinding: boolean;
-  /**
-   * The x coordinate of the item's top-left corner, in px. The axis is based on the total length of the content rather than the visible area or screen.
-   * @Android
-   * @iOS
-   * @H
-   */
-  originX: number;
-  /**
-   * The y coordinate of the item's top-left corner, in px. The axis is based on the total length of the content rather than the visible area or screen.
-   * @Android
-   * @iOS
-   * @H
-   */
-  originY: number;
-  /**
-   * Show if the list-item is currently being updated in this layout.
-   * @Android
-   * @iOS
-   * @H
-   */
-  updated: boolean;
-}
-
-export interface ListAttachedCell {
-  /**
-   * id
+   * index of list item
    * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
-  id: string;
+  index: number;
   /**
-   * bottom
+   * left position of list item relative to list, in px
    * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
-  bottom: number;
+  left: number;
   /**
-   * top
+   * top position of list item relative to list, in px
    * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
   top: number;
   /**
-   * left
-   * @iOS
-   * @Android
-   */
-  left: number;
-  /**
-   * right
+   * right position of list item relative to list, in px
    * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
   right: number;
   /**
-   * postion
+   * bottom position of list item relative to list, in px
    * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
-  position: number;
+  bottom: number;
 }
 
-export interface ListDetail {
-  /**
-   * scroll top from start
-   * @iOS
-   * @Android
-   */
-  scrollTop: number;
+export interface ListScrollInfo {
   /**
-   * scrolling delta at y axis
-   * @iOS
+   * Horizontal scroll offset since the last scroll, in px.
    * @Android
-   */
-  deltaY: number;
-  /**
-   * attached cells
    * @iOS
-   * @Android
+   * @Harmony
+   * @PC
    */
-  attachedCells: ListAttachedCell[];
-}
-
-export interface ListEvent<T> extends BaseEvent<T, ListDetail> {}
-
-export enum ListScrollState {
-  SCROLL_STATE_STOP = 1,
-  SCROLL_STATE_DRAGGING = 2,
-  SCROLL_STATE_DECELERATE = 3,
-}
-
-export interface ListScrollStateChangeEvent extends BaseEvent<'scrollstatechange', {}> {
-  detail: {
-    /**
-     * scroll state
-     * @iOS
-     * @Android
-     */
-    state: ListScrollState;
-  };
-}
-
-export interface ListLayoutFinishEvent extends BaseEvent<'layoutcomplete', {}> {
-  detail: {
-    /**
-     * timestamp, in ms
-     * @iOS
-     * @Android
-     */
-    timestamp: number;
-    /**
-     * All the component names after this layout
-     * @iOS
-     * @Android
-     */
-    cells: string[];
-  };
-}
-
-interface ListDebugInfoEvent extends BaseEvent<'debuginfo', {}> {
-  detail: {};
-}
-
-export interface ListSnapEvent extends BaseEvent<'snap', {}> {
-  detail: {
-    /**
-     * Will snap to a position.
-     * @iOS
-     * @Android
-     */
-    position: number;
-    /**
-     * Current scrolling left offset, in px.
-     * @iOS
-     * @Android
-     */
-    currentScrollLeft: number;
-    /**
-     * Current scrolling top offset, in px.
-     * @iOS
-     * @Android
-     */
-    currentScrollTop: number;
-    /**
-     * Snap scrolling left offset, in px.
-     * @iOS
-     * @Android
-     */
-    targetScrollLeft: number;
-    /**
-     * Snap scrolling top offset, in px.
-     * @iOS
-     * @Android
-     */
-    targetScrollTop: number;
-  };
-}
-
-export interface LayoutCompleteEvent extends BaseEvent<'layoutcomplete', {}> {
+  deltaX: number;
   /**
-   * Layout details
-   * @iOS
+   * Vertical scroll offset since the last scroll, in px.
    * @Android
-   * @H
-   * @Since 2.15
-   */
-  detail: {
-    /**
-     * Connected to a setState.
-     * @iOS
-     * @Android
-     * @H
-     */
-    'layout-id': number;
-    /**
-     * The diffResult of current layout change. If this diffResult is undefined, it means that the layout is triggered by a list-item update.
-     * @iOS
-     * @Android
-     * @H
-     */
-    diffResult?: {
-      insertions: number[];
-      // eslint-disable-next-line
-      move_from: number[];
-      // eslint-disable-next-line
-      move_to: number[];
-      removals: number[];
-      // eslint-disable-next-line
-      update_from: number[];
-      // eslint-disable-next-line
-      update_to: number[];
-    };
-    /**
-     * Cell info of the list after layout.
-     * @iOS
-     * @Android
-     * @H
-     */
-    visibleItemAfterUpdate?: ListItemInfo[];
-    /**
-     * Cell info of the list before layout.
-     * @iOS
-     * @Android
-     * @H
-     */
-    visibleItemBeforeUpdate?: ListItemInfo[];
-    /**
-     * The scroll info after layout.
-     * @iOS
-     * @Android
-     * @H
-     */
-    scrollInfo: ListScrollInfo;
-    /**
-     * The unit of event's parameters.
-     * @iOS
-     * @Android
-     * @H
-     */
-    eventUnit: string;
-  };
-}
-
-/**
- * list. A list does not support adaptive height and the 'height' property must be specified for the <list> tag in order to set its height.
- */
-export interface ListProps extends StandardProps {
-  /**
-   * Whether to display the scrollbar of the list
-   * @defaultValue true
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'scroll-bar-enable'?: boolean;
-
-  /**
-   * Control whether list should produce bounces effect when scrolling past its content boundaries.
-   * @defaultValue true
-   * @iOS
-   */
-  bounces?: boolean;
-
-  /**
-   * z-index is undefined by default. When enabled, z-index will be assigned in ascending order for each item.
-   * @defaultValue false
-   * @iOS
-   */
-  'ios-index-as-z-index'?: boolean;
-
-  /**
-   * To solve the flickering issue of list, it's recommended to enable it.
-   * @defaultValue false
-   * @iOS
-   */
-  'ios-fixed-content-offset'?: boolean;
-
-  /**
-   * To solve the flickering issue of list, it's only necessary to enable when using bottom-up layout. It's recommended to understand the principle before using.
-   * @defaultValue false
-   * @iOS
-   */
-  'ios-fix-offset-from-start'?: boolean;
-
-  /**
-   * Interrupt List rendering switch. It is usually used when creating drag-and-drop effects to prevent the list from refreshing child nodes.
-   * @defaultValue false
-   * @Android
-   */
-  'no-invalidate'?: boolean;
-
-  /**
-   * Under asynchronous layout, it is recommended to enable this property if a child node renders blank.
-   * @defaultValue false
-   * @Android
-   */
-  'component-init-measure'?: boolean;
-
+  deltaY: number;
   /**
-   * Control whether dataSet can be used as the unique identifier. It will call RecyclerView.setHasStableIds() internally.
-   * @defaultValue false
+   * Current horizontal scroll offset, in px.
    * @Android
-   */
-  'android-diffable'?: boolean;
-
-  /**
-   * ”upperBounce“ can only forbid bounces effect at top or left (right for RTL); ”lowerBounce“ can only forbid bounces effect at bottom or right (left for RTL). iOS uses bounces to implement refresh-view. This prop can be used when you need a refresh-view without bounces on the other side.
-   * @defaultValue "none"
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'ios-forbid-single-sided-bounce'?: 'upperBounce' | 'lowerBounce' | 'none';
-
+  scrollLeft: number;
   /**
-   * Control whether list should produce over-scroll effect when scrolling past its content boundaries.
-   * @defaultValue false
+   * Current vertical scroll offset, in px.
    * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'over-scroll'?: boolean;
-
+  scrollTop: number;
   /**
-   * Whether to allow scrolling for a list.
-   * @defaultValue true
+   * Current content area width, in px.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'enable-scroll'?: boolean;
-
+  scrollWidth: number;
   /**
-   * Whether to allow scrolling for a list. It's recommended to enable 'enable-scroll=true' and disable 'touch-scroll' on Android.
-   * @defaultValue true
+   * Current content area height, in px.
    * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'touch-scroll'?: boolean;
-
+  scrollHeight: number;
   /**
-   * layout type of the list
-   * @defaultValue  "single"
+   * list width, in px.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'list-type'?: 'single' | 'flow' | 'waterfall';
-
+  listWidth: number;
   /**
-   * The number of columns for a list, only effective when list-type is 'flow' or 'waterfall'.
-   * @defaultValue 0
+   * list height, in px.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'column-count'?: number;
-
+  listHeight: number;
   /**
-   * Control the horizontal and vertical scrolling direction of a list. If it is horizontal scrolling, you need to also set the CSS layout property 'style="display:linear; linear-orientation:horizontal"
-   * @defaultValue undefined
+   * Source of the event.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'vertical-orientation'?: boolean;
-
+  eventSource: ListEventSource;
   /**
-   * Replacement of vertical-orientation
-   * @since 3.0
+   * Information of the currently rendering list items.
    * @iOS
    * @Android
-   * @H
-   */
-  'scroll-orientation'?: 'vertical' | 'horizontal';
-
-  /**
-   * Control the list to fill the elements from the bottom. It is used in reverse layout scenarios such as message list.
-   * @defaultValue false
-   * @Android
-   */
-  'android-stack-from-end'?: boolean;
-
-  /**
-   * Control the switch of RTL (Right-to-Left) mode, the order of vertical two-column layout will also be mirrored and upside-down.
-   * @defaultValue false
-   * @Android
-   * @iOS
+   * @Harmony
+   * @PC
    */
-  'enable-rtl'?: boolean;
+  attachedCells: ListAttachedCell[];
+}
 
+export interface ListItemInfo {
   /**
-   * The ceiling or floor effect is not compatible with flatten.
-   * @defaultValue  false
+   * Height of the list item, in px.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  sticky?: boolean;
-
+  height: number;
   /**
-   * The distance between the ceiling or floor position and the top or bottom of the list, in pixels.
-   * @defaultValue 0
+   * Width of the list item, in px.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'sticky-offset'?: number;
-
+  width: number;
   /**
-   * The property to control whether recycle sticky item. The default value is true if sdk version >= 3.4 and false if sdk version < 3.4.
-   * @defaultValue false
+   * ItemKey of the list-item.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'experimental-recycle-sticky-item'?: boolean;
-
+  itemKey: string;
   /**
-   * The property to set the capacity of sticky item cache. The default value is 1 if thread mode is ALL_ON_UI and 2 if thread mode is MOST_ON_TASM / PART_ON_LAYOUT / MULTI_THREADS.
-   * @defaultValue 1
+   * When the list is running in multi-thread mode, this property indicates whether the item is currently being rendered and has not finished rendering. In this state, the item will have a default height that is the same as the list's height or an estimated height if one has been set.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'sticky-buffer-count'?: number;
-
-  /**
-   * When enabled, the upper or lower element will also be shifted together with the bounces effect.
-   * @defaultValue false
-   * @iOS
-   */
-  'sticky-with-bounces'?: boolean;
-
+  isBinding: boolean;
   /**
-   * Rollback to the older version's sticky feature.
-   * @defaultValue  false
+   * The x coordinate of the item's top-left corner, in px. The axis is based on the total length of the content rather than the visible area or screen.
    * @Android
    * @iOS
-   * @deprecated since 2.14
-   */
-  'use-old-sticky'?: boolean;
-
-  /**
-   * To solve the conflict between list and x-refresh-view
-   * @defaultValue false
-   * @experimental
-   * @iOS
-   * @since 2.18
+   * @Harmony
+   * @PC
    */
-  'experimental-disable-filter-scroll'?: boolean;
-
+  originX: number;
   /**
-   * Limit the inertia scrolling distance of asynchronous list to this value multiplied by the height (width) of the list, in order to reduce the chance of white screen. When it is set to 'auto', it will automatically calculate the rendering distance in preload-buffer when asynchronous list is enabled to ensure there is no white screen, but the inertia scrolling experience may be abnormal.
-   * @defaultValue undefined
-   * @experimental
+   * The y coordinate of the item's top-left corner, in px. The axis is based on the total length of the content rather than the visible area or screen.
    * @Android
    * @iOS
-   * @since 2.17
-   */
-  'experimental-max-fling-distance-ratio'?: 'auto' | number;
-
-  /**
-   * Attempt to increase the CPU frequency if a gesture is set to the list
-   * @defaultValue false
-   * @experimental
-   * @iOS
-   * @since 2.18
+   * @Harmony
+   * @PC
    */
-  'experimental-ios-gesture-frequency-increasing'?: boolean;
-
+  originY: number;
   /**
-   * On iOS, force-can-scroll should be used with ios-block-gesture-class and ios-recognized-view-tag. Can be used alone on Android.
-   * @defaultValue false
-   * @iOS
+   * Show if the list-item is currently being updated in this layout.
    * @Android
-   * @since 3.1
-   */
-  'force-can-scroll'?: boolean;
-
-  /**
-   * Whether to scroll to the top when the iOS status bar is clicked. Note that even if it is set to true, it may not scroll to the top. In such cas, you need to check the behavior of other scrollable components.{@link https://developer.apple.com/documentation/uikit/uiscrollview/1619421-scrollstotop?language=objc | Reference }
-   * @defaultValue undefined
-   * @iOS
-   * @since 2.16
-   */
-  'ios-scrolls-to-top'?: boolean;
-
-  /**
-   * There are stability issues. Please use `<Component align-height={true}/>` instead. It is not recommended to use.
-   * @defaultValue false
-   * @iOS
-   * @deprecated since 2.10
-   */
-  'ios-enable-align-height'?: boolean;
-
-  /**
-   * Deprecated
-   * @defaultValue true
-   * @iOS
-   * @deprecated since 2.10
-   */
-  'ios-no-recursive-layout'?: boolean;
-
-  /**
-   * Deprecated
-   * @defaultValue true
    * @iOS
-   * @deprecated since 2.10
-   */
-  'ios-force-reload-data'?: boolean;
-
-  /**
-   * Deprecated
-   * @defaultValue true
-   * @iOS
-   * @deprecated since 2.10
-   */
-  'ios-update-valid-layout'?: boolean;
-
-  /**
-   * Deprecated
-   * @defaultValue false
-   * @iOS
-   * @deprecated since 2.10
-   */
-  'ios-enable-adjust-offset-for-selfsizing'?: boolean;
-
-  /**
-   * In Android, this attribute controls whether the list uses the RecyclerView's ItemDecoration to implement the main-axis-gap and cross-axis-gap.
-   * @defaultValue false
-   * @Android
-   */
-  'android-enable-gap-item-decoration'?: boolean;
-
-  /**
-   * In some Android scenarios, the element that is currently being ceilinged or floored may not be correctly measured and laid out, resulting in blank rendering. Therefore, it is recommended to enable it.
-   * @defaultValue false
-   * @Android
+   * @Harmony
+   * @PC
    */
-  'android-trigger-sticky-layout'?: boolean;
+  updated: boolean;
+}
 
+export interface ListScrollStateInfo {
   /**
-   * Specify this property as 'default' to enable update animation for the list.
-   * @defaultValue  "none"
-   * @Android
+   * scroll state
    * @iOS
-   */
-  'update-animation'?: 'none' | 'default';
-
-  /**
-   * Indicates whether to use the new exposure strategy. The new exposure strategy handles the situation where the node is covered, such as the list nested in x-viewpager-ng or x-swiper. The performance of the new exposure strategy is slightly worse than the old one, but the result is more accurate.
-   * @defaultValue  false
-   * @Android
-   */
-  'enable-new-exposure-strategy'?: boolean;
-
-  /**
-   * Allows notification to send disappear event. It is recommended to enable.
-   * @defaultValue false
    * @Android
+   * @Harmony
+   * @PC
    */
-  'enable-disappear'?: boolean;
+  state: ListScrollState;
+}
 
+export interface ListSnapInfo {
   /**
-   * Enable asynchronous strategy
-   * @defaultValue false
-   * @Android
+   * The index of the node that will be paginated to.
    * @iOS
-   */
-  'enable-async-list'?: boolean;
-
-  /**
-   * Cache the size when rendering components in child nodes of List. It is only allowed to enable under asynchronous mode.
-   * @defaultValue false
-   * @Android
-   */
-  'enable-size-cache'?: boolean;
-
-  /**
-   * The maximum scrolling speed of the list, with a value between [0,1].
-   * @defaultValue 1.0
    * @Android
+   * @Harmony
    */
-  'max-fling-velocity-percent'?: number;
-
-  /**
-   * When scrolling down, when the number of remaining displayable child nodes at the bottom is first less than lower-threshold-item-count, a scrolltolower event is triggered. If lower-threshold-item-count is specified, lower-threshold is not effective.
-   * @defaultValue  none
-   * @Android
-   * @iOS
-   */
-  'lower-threshold-item-count'?: number;
-
+  position: number;
   /**
-   * When scrolling up, when the number of remaining displayable child nodes at the top is first less than upper-threshold-item-count, a scrolltoupper event is triggered. If upper-threshold-item-count is specified, upper-threshold is not effective.
-   * @defaultValue  none
-   * @Android
+   * Current scrolling left offset, in px.
    * @iOS
-   */
-  'upper-threshold-item-count'?: number;
-
-  /**
-   * The property to control whether to update sticky item for diff. The default value is true if sdk version >= 3.4 and false if sdk version < 3.4.
-   * @defaultValue false
    * @Android
-   * @iOS
+   * @Harmony
    */
-  'experimental-update-sticky-for-diff'?: boolean;
-
+  currentScrollLeft: number;
   /**
-   * During a single sliding process, when the upper_distance is first smaller than the value specified by upper-threshold, a scrolltoupper event is triggered. When upper_distance is already smaller than the value specified by upper-threshold, the scrolltoupper event will no longer be triggered.
-   * @defaultValue  50
-   * @Android
+   * Current scrolling top offset, in px.
    * @iOS
-   */
-  'upper-threshold'?: number;
-
-  /**
-   * During a single sliding process, when the lower_distance is first smaller than the value specified by lower-threshold, a scrolltolower event is triggered. When lower_distance is already smaller than the value specified by lower-threshold, the scrolltolower event will no longer be triggered.
-   * @defaultValue  50
    * @Android
-   * @iOS
+   * @Harmony
    */
-  'lower-threshold'?: number;
-
+  currentScrollTop: number;
   /**
-   * Control whether the 'attachedCells' is included in the scroll event callback parameters.
-   * @defaultValue  false
-   * @Android
+   * Snap scrolling left offset, in px.
    * @iOS
-   */
-  'needs-visible-cells'?: boolean;
-
-  /**
-   * Control whether the list recycle available items before layout, so list can reuse these items in this layout pass. By default, the list will recycle all items after layout.
-   * @defaultValue  false
    * @Android
-   * @iOS
    * @Harmony
-   */
-  'experimental-recycle-available-item-before-layout'?: boolean;
-
-   /**
-   * Control whether the 'attachedCells' is included in the scroll event callback parameters on native list.
-   * @defaultValue  false
-   * @Android
-   * @iOS
-   * @H
-   */
-    'need-visible-item-info'?: boolean;
-
-  /**
-   * Specify the callback frequency of the scroll event by passing in a value, which specifies how many milliseconds (ms) <list> will call the scroll callback event during scrolling.
-   * @defaultValue  200
-   * @Android
-   * @iOS
-   */
-  'scroll-event-throttle'?: number;
-
+   */
+  targetScrollLeft: number;
   /**
-   * List scrolling event refactoring switch. It is recommended to enable it.
-   * @defaultValue false
+   * Snap scrolling top offset, in px.
    * @iOS
+   * @Android
+   * @Harmony
    */
-  'ios-scroll-emitter-helper'?: boolean;
+  targetScrollTop: number;
+}
 
+export interface ListLayoutCompleteInfo {
   /**
-   * Solve the problem of inaccurate sliding distance in the list scrolling event callback. It is recommended to enable it.
-   * @defaultValue false
+   * Connected to a setState.
+   * @defaultValue -1
+   * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
-  'android-new-scroll-top'?: boolean;
+  'layout-id'?: number;
 
   /**
-   * Allow frontend code to specify the automatic positioning of the list after rendering, only valid for single columns.
-   * @defaultValue 0
-   * @Android
+   * The diffResult of current layout change. If this diffResult is undefined, it means that the layout is triggered by a list-item update.
    * @iOS
-   */
-  'initial-scroll-index'?: number;
+   * @Android
+   * @Harmony
+   * @PC
+   */
+  diffResult?: {
+    insertions: number[];
+    removals: number[];
+    // eslint-disable-next-line
+    move_from: number[];
+    // eslint-disable-next-line
+    move_to: number[];
+    // eslint-disable-next-line
+    update_from: number[];
+    // eslint-disable-next-line
+    update_to: number[];
+  };
 
   /**
-   * The difference of double-sided page turning effect: On Android, it controls scrolling one child node at a time; on iOS, it controls scrolling one list viewport distance at a time.
-   * @defaultValue false
-   * @Android
+   * Cell info of the list before layout.
    * @iOS
-   * @experimental
+   * @Android
+   * @Harmony
+   * @PC
    */
-  'paging-enabled'?: boolean;
+  visibleItemBeforeUpdate?: ListItemInfo[];
 
   /**
-   * Enable the paging effect, and after each scroll, the list-item will stop at a specified position. For list-type:single only/
-   * @defaultValue undefined
-   * @Android
+   * Cell info of the list after layout.
    * @iOS
-   * @experimental
+   * @Android
+   * @Harmony
+   * @PC
    */
-  'item-snap'?: ListItemSnapAlignment;
+  visibleItemAfterUpdate?: ListItemInfo[];
 
   /**
-   * Notify the parent view not to intercept the event. Enable this when the list is in a client container (RecyclerView) and needs to be scrollable.
-   * @defaultValue false
+   * The scroll info after layout.
+   * @iOS
    * @Android
+   * @Harmony
+   * @PC
    */
-  'android-preference-consume-gesture'?: boolean;
+  scrollInfo: ListScrollInfo;
+}
 
-  /** scroll-view and list can be nested for scrolling. The scrolling of the child view triggered by a single gesture can drive the scrolling of the parent view when the inertial scrolling touches the edge.
-   * @defaultValue false
-   * @iOS
-   */
-  'enable-nested-scroll'?: boolean;
+export interface ListScrollEvent extends BaseEvent<'scroll', ListScrollInfo> {}
 
+export interface ListScrollToLowerEvent extends BaseEvent<'scrolltolower', ListScrollInfo> {}
 
-  /**
-   * NestedScrollOptions for scrollForward
-   * @since 3.0
-   * @H
-   */
-  'temporary-nested-scroll-forward'?: 'selfOnly' | 'selfFirst'|'parentFirst'|'parallel';
+export interface ListScrollToUpperEvent extends BaseEvent<'scrolltoupper', ListScrollInfo> {}
 
-  /**
-   * NestedScrollOptions for scrollBackward
-   * @since 3.0
-   * @H
-   */
-  'temporary-nested-scroll-backward'?: 'selfOnly' | 'selfFirst'|'parentFirst'|'parallel' ;
+export interface ListScrollStateChangeEvent extends BaseEvent<'scrollstatechange', ListScrollStateInfo> {}
+
+export interface ListSnapEvent extends BaseEvent<'snap', ListSnapInfo> {}
 
+export interface ListLayoutCompleteEvent extends BaseEvent<'layoutcomplete', ListLayoutCompleteInfo> {}
+
+export interface ListItemSnapAlignment {
   /**
-   * Preload count.
-   * @defaultValue  0
+   * Paging factor, 0.0 means align to the top, while 1.0 means align to the bottom.
    * @Android
    * @iOS
-   * @experimental
+   * @Harmony
    */
-  'preload-buffer-count'?: number;
+  factor: number;
 
   /**
-   * Whether to enable the self-preloading strategy of the list system.
-   * @defaultValue  0
+   * In addition to the parameter of factor, an offset for alignment can be set, in px.
    * @Android
-   * @experimental
-   */
-  'android-enable-item-prefetch'?: boolean;
-
-  /**
-   * Determine whether the list is laid out from the top or from the bottom.
-   * @defaultValue  'fromBegin'
    * @iOS
-   * @experimental
+   * @Harmony
    */
-  'anchor-priority'?: 'fromBegin' | 'fromEnd';
+  offset: number;
+}
 
+/**
+ * list. A list does not support adaptive height and the 'height' property must be specified for the <list> tag in order to set its height.
+ */
+export interface ListProps extends StandardProps {
   /**
-   * When all nodes on the screen are deleted, find the anchor point outside the top/bottom area.
-   * @defaultValue  'toTop'
+   * Sets the scrolling direction and layout direction.
+   * @defaultValue 'vertical'
    * @iOS
-   * @experimental
+   * @Android
+   * @Harmony
+   * @PC
    */
-  'delete-regress-policy'?: 'toTop' | 'toBottom';
+  'scroll-orientation'?: 'vertical' | 'horizontal';
 
   /**
-   * Using 'outside' can make the inserted element visible at the edge of the screen, and using 'inside' can make the inserted element invisible at the edge of the screen.
-   * @defaultValue  'inside'
+   * The number of columns or rows for the list, and only effective when list-type is 'flow' or 'waterfall'.
+   * @defaultValue 1
+   * @Android
    * @iOS
-   * @experimental
+   * @Harmony
+   * @PC
    */
-  'insert-anchor-mode'?: 'outside' | 'inside';
+  'span-count'?: number;
 
   /**
-   * "The dot element is positioned at the fully visible position (show) or at the point just invisible (hide), and no adjustment is made by default."
-   * @defaultValue  'noAdjustment'
+   * layout type of the list
+   * @defaultValue  'single'
+   * @Android
    * @iOS
-   * @experimental
+   * @Harmony
+   * @PC
    */
-  'anchor-visibility'?: 'noAdjustment' | 'show' | 'hide';
+  'list-type'?: 'single' | 'flow' | 'waterfall';
 
   /**
-   * 'anchor-align-to-bottom' will keep the bottom of the anchor at the same distance from the visible area, while 'anchor-align-to-top' will keep the top of the anchor at the same distance from the visible area.
-   * @defaultValue  'toTop'
+   * Whether to allow scrolling for a list.
+   * @defaultValue true
+   * @Android
    * @iOS
-   * @experimental
+   * @Harmony
+   * @PC
    */
-  'anchor-align'?: 'toBottom' | 'toTop';
+  'enable-scroll'?: boolean;
 
   /**
-   * From version 2.17 and above, you can directly use should-request-state-restore instead of internal-cell-appear-notification/internal-cell-prepare-for-reuse-notification/internal-cell-disappear-notification. The lifecycle of element layer reuse solves the problem of reuse status disorder in the UI layer. It is recommended to enable it when there is <scroll-view/> in the list item.
-   * @defaultValue false
-   * @deprecated 2.17
-   * @iOS
+   * Indicates whether list can achieve nested scrolling with other scrollable containers. When enabled, the inner container scrolls first, followed by the outer container.
+   * @defaultValue  false
    * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'internal-cell-appear-notification'?: boolean;
+  'enable-nested-scroll'?: boolean;
 
   /**
-   * From version 2.17 and above, you can directly use should-request-state-restore instead of internal-cell-appear-notification/internal-cell-prepare-for-reuse-notification/internal-cell-disappear-notification. The lifecycle of element layer reuse solves the problem of reuse status disorder in the UI layer. It is recommended to enable it when there is <scroll-view/> in the list item.
-   * @defaultValue false
-   * @deprecated 2.17
-   * @iOS
+   * Declared on the list to control whether the list as a whole is allowed to be sticky at the top or bottom.
+   * @defaultValue  false
    * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'internal-cell-disappear-notification'?: boolean;
+  sticky?: boolean;
 
   /**
-   * From version 2.17 and above, you can directly use should-request-state-restore instead of internal-cell-appear-notification/internal-cell-prepare-for-reuse-notification/internal-cell-disappear-notification. The lifecycle of element layer reuse solves the problem of reuse status disorder in the UI layer. It is recommended to enable it when there is <scroll-view/> in the list item.
-   * @defaultValue false
-   * @deprecated 2.17
-   * @iOS
+   * The offset distance from the top or bottom of list for sticky positioning, in px.
+   * @defaultValue  0
    * @Android
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'internal-cell-prepare-for-reuse-notification'?: boolean;
+  'sticky-offset'?: number;
 
   /**
-   * The lifecycle of element layer reuse. It solves the problem of reuse status disorder in the UI layer. It is recommended to enable it when there is <scroll-view/> in the list item. It replaces internal-cell-appear-notification, internal-cell-disappear-notification, and internal-cell-prepare-for-reuse-notification.
-   * @defaultValue false
-   * @since 2.17
+   * Control whether list should produce bounces effect when scrolling past its content boundaries.
+   * @defaultValue  true
    * @iOS
-   * @Android
+   * @Harmony
+   * @PC
    */
-  'should-request-state-restore'?: boolean;
+  bounces?: boolean;
 
   /**
-   * After the layout of the list is completed, preload the vdom of the remaining nodes in advance to improve the scrolling frame rate of the subsequent list.
-   * @defaultValue false
-   * @experimental
-   * @iOS
+   * Specifies the node position to which list automatically scrolls after rendering.
+   * @defaultValue  0
    * @Android
-   * @since 2.17
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'experimental-enable-preload-section'?: boolean;
+  'initial-scroll-index'?: number;
 
   /**
-   * Since RecyclerView is a collection ViewGroup that includes virtual children (items that are in the Adapter but not visible in the UI), it employs a more involved focus search strategy that differs from other ViewGroups, which may lead to unexpected scroll behavior. This property is used to control whether the focus search strategy is enabled, and if set to false, the focus search strategy of RecyclerView will be disabled and directly return the current focused view in focusSearch method.
-   * @defaultValue true
+   * Controls whether the scroll event callback parameters include the position information of the currently rendering node.
+   * @defaultValue  false
    * @Android
-   * @since 2.17
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'android-enable-focus-search'?: boolean;
+  'need-visible-item-info'?: boolean;
 
   /**
-   * Warning: It is not recommended to enable it in the production environment. Adjust the level of detail for bindlistdebugevent, with 0 meaning no output, 1 meaning outputting warnings, 2 meaning outputting information, and 3 meaning outputting detailed debug information.
-   * @defaultValue 2
-   * @iOS
+   * When scrolling down, when the number of remaining displayable child nodes at the bottom is first less than lower-threshold-item-count, a scrolltolower event is triggered. If lower-threshold-item-count is specified, lower-threshold is not effective.
+   * @defaultValue  0
    * @Android
-   * @since 2.18
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'list-debug-info-level'?: number;
+  'lower-threshold-item-count'?: number;
 
   /**
-   * The strategy of list batch rendering in Fiber arch. The value of this property can be set to the value of Enum BatchRenderStrategy.
-   * @defaultValue BatchRenderStrategy.DEFAULT
-   * @iOS
+   * When scrolling up, when the number of remaining displayable child nodes at the top is first less than upper-threshold-item-count, a scrolltoupper event is triggered. If upper-threshold-item-count is specified, upper-threshold is not effective.
+   * @defaultValue  0
    * @Android
-   * @since 3.1
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  'experimental-batch-render-strategy'?: BatchRenderStrategy;
+  'upper-threshold-item-count'?: number;
 
   /**
-   * Scroll event.
+   * Specify the callback frequency of the scroll event by passing in a value, which specifies how many milliseconds (ms) list will call the scroll callback event during scrolling.
+   * @defaultValue  200
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindscroll?: EventHandler<ListScrollEvent>;
+  'scroll-event-throttle'?: number;
 
   /**
-   * Callback function for scrolling to the top.
+   * Enable the paging effect, and after each scroll, the list-item will stop at a specified position. For list-type:single only.
    * @Android
    * @iOS
+   * @Harmony
    */
-  bindscrolltoupper?: EventHandler<ListScrollToUpperEvent>;
+  'item-snap'?: ListItemSnapAlignment;
 
   /**
-   * Callback function for scrolling to the bottom.
+   * Controls whether the layoutcomplete event includes the node layout information before and after this layout, and the list Diff information that triggered this layout, and the current list scroll state information.
+   * @defaultValue  false
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindscrolltolower?: EventHandler<ListScrollToLowerEvent>;
+  'need-layout-complete-info'?: boolean;
 
   /**
-   * This callback function is triggered when the scrolling state of the list changes.
+   * Used to mark the unique identifier for this data source update, which will be returned in the layoutcomplete event callback.
+   * @defaultValue  -1
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindscrollstatechange?: EventHandler<ListScrollStateChangeEvent>;
+  'layout-id'?: number;
+
   /**
-   * This callback function will be triggered when the first screen of the list has finished rendering. On iOS, this callback function will be triggered when list has an update.
+   * This attribute controls the number of nodes outside list that are preloaded.
+   * @defaultValue  0
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindlayoutcomplete?: EventHandler<ListLayoutFinishEvent> | EventHandler<LayoutCompleteEvent>;
+  'preload-buffer-count'?: number;
+
   /**
-   * Warning: It is not recommended to enable it in the production environment. Output debug information for the list.
-   * @since 2.18
-   * @Android
+   * Whether to display the scroll bar of the list, with false on Harmony platform and true on other platforms.
+   * @defaultValue undefined
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindlistdebugevent?: EventHandler<ListDebugInfoEvent>;
+  'scroll-bar-enable'?: boolean;
+
   /**
-   * scrollview scrolls to upper edge
-   * @since 3.0
-   * @iOS
+   * The property to control whether recycle sticky item. The default value is true if sdk version >= 3.4 and false if sdk version < 3.4.
+   * @defaultValue false
    * @Android
-   * @H
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  bindscrolltoupperedge?: EventHandler<ListScrollToUpperEdgeEvent>;
+  'experimental-recycle-sticky-item'?: boolean;
 
   /**
-   * scrollview scrolls to lower edge
-   * @since 3.0
-   * @iOS
-   * @Android
-   * @H
+   * When the content size of a component is smaller than the component itself, decide whether to enable scrolling.
+   * @defaultValue false
+   * @Harmony
+   * @since 3.4
    */
-  bindscrolltoloweredge?: EventHandler<ListScrollToLowerEdgeEvent>;
+  'harmony-scroll-edge-effect'?: boolean;
 
   /**
-   * scrollview scrolls to normal position. Not at upper or lower edge
-   * @since 3.0
-   * @iOS
+   * Scroll event.
    * @Android
-   * @H
+   * @iOS
+   * @Harmony
+   * @PC
    */
-  bindscrolltonormalstate?: EventHandler<ListScrollToNormalStateEvent>;
-}
+  bindscroll?: EventHandler<ListScrollEvent>;
 
-export interface ListItemProps extends StandardProps {
   /**
-   * sticky top effect. Not compatible with flatten.
-   * @defaultValue  false
+   * Callback function for scrolling to the top.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'sticky-top'?: boolean;
+  bindscrolltoupper?: EventHandler<ListScrollToUpperEvent>;
 
   /**
-   * sticky bottom effect. Not compatible with flatten.
-   * @defaultValue  false
+   * Callback function for scrolling to the bottom.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'sticky-bottom'?: boolean;
+  bindscrolltolower?: EventHandler<ListScrollToLowerEvent>;
 
   /**
-   * Adding the `full-span` attribute to `<list-item/>` will make it occupy a single line. You need to configure {@link ListProps."list-type" | list-type} correctly to make the list enter a multi-column layout for this to work.
-   * @defaultValue undefined
+   * This callback function is triggered when the scrolling state of the list changes.
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'full-span'?: boolean;
+  bindscrollstatechange?: EventHandler<ListScrollStateChangeEvent>;
 
   /**
-   * Preset height to control the placeholder height of the view while the list component has not finished rendering. The more accurately it is set, the less flickering the list will have.
-   * @defaultValue undefined
+   * This callback function will be triggered when the first screen of the list has finished rendering. On iOS, this callback function will be triggered when list has an update.
    * @Android
    * @iOS
-   * @deprecated For Lynx>=3.1, use {@link estimated-main-axis-size-px} instead
+   * @Harmony
+   * @PC
    */
-  'estimated-height-px'?: number;
+  bindlayoutcomplete?: EventHandler<ListLayoutCompleteEvent>;
 
   /**
-   * Preset height to control the placeholder height (in physical pixels) of the view while the list component has not finished rendering. The more accurately it is set, the less flickering the list will have.
-   * @defaultValue undefined
+   * Snap callback
+   * @since 2.16
    * @Android
    * @iOS
-   * @deprecated For Lynx>=3.1, use {@link estimated-main-axis-size-px} instead
+   * @Harmony
    */
-  'estimated-height'?: number;
+  bindsnap?: EventHandler<ListSnapEvent>;
+}
 
+export interface ScrollToPositionParams {
   /**
-   * Preset size in main scroll axis to control the placeholder size of the view while the list component has not finished rendering. The more accurately it is set, the less flickering the list will have.
-   * @since 3.1
-   * @defaultValue undefined
+   * Specify the index of the node to scroll to, with a value range of [0, itemCount).
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'estimated-main-axis-size-px'?: number;
+  index: number;
 
   /**
-   * Snap callback
+   * Specify the alignment method when scrolling to a target position.
+   *  "bottom": Scroll to make the node fully visible in the list and align the bottom of the node with the bottom of the list.
+   *  "top": Scroll to make the node fully visible in the list and align the top of the node with the top of the list.
+   *  "middle": Scroll to make the node fully visible in the list and align the center of the node with the center of the list. This is only supported in LynxSDK 2.12 and above.
+   * @defaultValue 'top'
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  bindsnap?: EventHandler<ListEvent<'snap'>>;
+  alignTo?: 'bottom' | 'top' | 'middle';
 
   /**
+   * Align the node with alignTo, and then move the node downward by a length of offset.
+   * @defaultValue 0
    * @Android
    * @iOS
+   * @Harmony
+   * @PC
    */
-  'item-key': string;
+  offset?: number;
 
   /**
-   * Control whether the list-item can be recycled. If set to false, the list-item will not be recycled after being scrolled off the screen, and do not need to be re-rendered when they come back on the screen. The default value is true.
-   * @since 3.4
-   * @defaultValue true
+   * Enable scroll animation during scroll.
+   * @defaultValue  false
    * @Android
    * @iOS
    * @Harmony
+   * @PC
    */
-  recyclable?: boolean | undefined;
-
-  bindnodeappear?: EventHandler<AppearanceEvent>;
-  bindnodedisappear?: EventHandler<AppearanceEvent>;
+  smooth?: boolean;
 }
 
-export interface ListRowProps extends ListItemProps {}
+/**
+ * Scroll the list to the specified position.
+ * @Android
+ * @iOS
+ * @Harmony
+ * @PC
+ */
+export interface ScrollToPositionMethod extends BaseMethod {
+  method: 'scrollToPosition';
+
+  params: ScrollToPositionParams;
+}
 
 /**
- * Automatic scrolling
+ * Automatic scrolling.
  * @Android
  * @iOS
+ * @Harmony
  */
 export interface AutoScrollMethod extends BaseMethod {
   method: 'autoScroll';
   params: {
     /**
-     *  The distance of each second's scrolling, which supports positive and negative values. The unit of distance can be "px", "rpx", "ppx", or null (for iOS, the value must be greater than 1/screen.scale px).
+     * Start/stop automatic scrolling.
+     * @defaultValue false
      * @Android
      * @iOS
+     * @Harmony
      */
-    rate: string;
+    start?: boolean;
+
     /**
-     * Start/stop automatic scrolling.
-     * @defaultValue false
+     *  The distance of each second's scrolling, which supports positive and negative values. The unit of distance can be "px", "rpx", "ppx", or null (for iOS, the value must be greater than 1/screen.scale px).
      * @Android
      * @iOS
+     * @Harmony
      */
-    start: boolean;
+    rate: string;
+
     /**
      * Whether to stop automatically when sliding to the bottom.
      * @defaultValue true
      * @Android
      * @iOS
+     * @Harmony
      */
-    autoStop: boolean;
+    autoStop?: boolean;
   };
 }
 
@@ -1146,93 +726,33 @@ export interface AutoScrollMethod extends BaseMethod {
  * Get the info of the currently displayed list item.
  * @Android
  * @iOS
+ * @Harmony
+ * @PC
  */
 export interface GetVisibleCellsMethod extends BaseMethod {
   method: 'getVisibleCells';
 }
 
 /**
- * Get the index of the currently displayed list item.
- * @Android
- */
-export interface GetVisibleItemsPositionsMethod extends BaseMethod {
-  method: 'getVisibleItemsPositions';
-}
-
-/**
- * Remove current sticky view.
- * @Android
- */
-export interface RemoveStickyViewMethod extends BaseMethod {
-  method: 'removeStickyView';
-}
-
-/**
- * Init the cache of the list.
- * @Android
- */
-export interface InitCacheMethod extends BaseMethod {
-  method: 'initCache';
-}
-
-/**
- * Scroll the list to the specified position.
+ * Scroll by specified offset
  * @Android
  * @iOS
+ * @Harmony
+ * @PC
  */
-export interface ScrollToPositionMethod extends BaseMethod {
-  method: 'scrollToPosition';
-  params: {
-    /**
-     * From version 2.17 and above, it is recommended to use 'index' instead. Specify the index of the node to scroll to, with a value range of [0, itemCount).
-     * @deprecated 2.17
-     * @Android
-     * @iOS
-     */
-    position: number;
-
-    /**
-     * Specify the index of the node to scroll to, with a value range of [0, itemCount).
-     * @since 2.17
-     * @Android
-     * @iOS
-     */
-    index: number;
-
-    /**
-     * Specify the alignment method when scrolling to a target position.
-     *  "none": Scroll to make the node fully visible in the list. If the node is above the visible range of the list, it will scroll to align the top of the node with the top of the list. If the node is below the visible range of the list, it will scroll to align the bottom of the node with the bottom of the list. If the node is within the visible range of the list, no movement will occur.
-     *  "bottom": Scroll to make the node fully visible in the list and align the bottom of the node with the bottom of the list.
-     *  "top": Scroll to make the node fully visible in the list and align the top of the node with the top of the list.
-     *  "middle": Scroll to make the node fully visible in the list and align the center of the node with the center of the list. This is only supported in LynxSDK 2.12 and above.
-     * @defaultValue none
-     * @Android
-     * @iOS
-     */
-    alignTo?: 'none' | 'bottom' | 'top' | 'middle';
-
-    /**
-     * Align the node with alignTo, and then move the node downward by a length of offset.
-     * @Android
-     * @iOS
-     */
-    offset?: number;
+export interface ScrollByMethod extends BaseMethod {
+  method: 'scrollBy';
 
+  params: {
     /**
-     * Enable scroll animation during scroll.
-     * @defaultValue  false
+     * Offset to scroll, in px.
      * @Android
      * @iOS
+     * @Harmony
+     * @PC
      */
-    smooth?: boolean;
-
-    /**
-     * When enabled, it uses the refactored logic which helps to solve some existing bugs. It is recommended to enable it.
-     * @defaultValue false
-     * @iOS
-     */
-    useScroller?: boolean;
+    offset: number;
   };
 }
 
-export type ListUIMethods = ScrollToPositionMethod | AutoScrollMethod | GetVisibleCellsMethod | GetVisibleItemsPositionsMethod | RemoveStickyViewMethod | InitCacheMethod;
+export type ListUIMethods = ScrollToPositionMethod | AutoScrollMethod | GetVisibleCellsMethod | ScrollByMethod;