diff --git a/BUILD.gn b/BUILD.gn
index e1f24e6f1ed45eec69c4cebfb7bb9b1e18f6e049..9e3164720c9ebc438e035f6f5a00f2f3374a032c 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -120,6 +120,35 @@ ohos_copy("common_api") {
   module_install_name = ""
 }
 
+template("ohos_declaration_template") {
+  forward_variables_from(invoker, "*")
+  action_with_pydeps(target_name) {
+    script = "//interface/sdk-js/remove_internal.py"
+    outputs = [ root_out_dir + "/$target_name/" ]
+    args = [
+      "--input",
+      rebase_path("//interface/sdk-js/api", root_build_dir),
+      "--output",
+      rebase_path(root_out_dir + "/ohos_declaration/$target_name/",
+                  root_build_dir),
+    ]
+  }
+  _module_info_target = "/ohos_declaration/${target_name}_info"
+  _target_name = target_name
+  generate_module_info(_module_info_target) {
+    module_type = "jsdoc"
+    module_install_name = ""
+    module_name = _target_name
+    module_source_dir = root_out_dir + "/ohos_declaration/$_target_name"
+    install_enable = false
+  }
+}
+
+ohos_declaration_template("ohos_declaration_ets") {
+}
+ohos_declaration_template("ohos_declaration_phone") {
+}
+
 ohos_copy("ace_platform") {
   sources = [
     "api/config",
@@ -129,3 +158,14 @@ ohos_copy("ace_platform") {
   module_source_dir = target_out_dir + "/$target_name"
   module_install_name = ""
 }
+
+ohos_copy("form_declaration") {
+  sources = [
+    "api/form/action",
+    "api/form/css",
+    "api/form/hml",
+  ]
+  outputs = [ target_out_dir + "/$target_name/{{source_file_part}}" ]
+  module_source_dir = target_out_dir + "/$target_name"
+  module_install_name = ""
+}
diff --git a/README.md b/README.md
deleted file mode 100644
index 5c6f8b5693c4c30bd71c14bcc690392f47b74686..0000000000000000000000000000000000000000
--- a/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Public JS API Repository<a name="EN-US_TOPIC_0000001151209521"></a>
-
--   [Introduction](#section11660541593)
-
-## Introduction<a name="section11660541593"></a>
-
-This repository is used to submit  **d.ts**  declaration files of JS APIs.
-
diff --git a/api/@internal/component/ets/ability_component.d.ts b/api/@internal/component/ets/ability_component.d.ts
index 06bb6c2d78768190c05f83dd9c480b34b64f9897..2ca00277284586bbe46e14156c25f717b9f2f150 100644
--- a/api/@internal/component/ets/ability_component.d.ts
+++ b/api/@internal/component/ets/ability_component.d.ts
@@ -1,36 +1,41 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod} from "./common";
-import {Want} from "../../../ability/want";
-
-export declare class AbilityController {
-    constructor();
-    startAbility(value: Want);
-    performBackPress();
-    getStackCount();
-}
-
-interface AbilityComponent extends CommonMethod<AbilityComponent> {
-  (value: { want: Want, controller?: AbilityController }): AbilityComponent;
-
-  onReady(event: () => void): AbilityComponent;
-  onDestroy(event: () => void): AbilityComponent;
-  onAbilityCreated(event: (name: string) => void): AbilityComponent;
-  onAbilityMoveToFront(event: () => void): AbilityComponent;
-  onAbilityWillRemove(event: () => void): AbilityComponent;
-}
-
-export declare const AbilityComponentInterface: AbilityComponent;
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonMethod} from "./common";
+import {Want} from "../api/common/ability/want";
+
+export declare class AbilityController {
+    constructor();
+    startAbility(value: Want);
+    performBackPress();
+    getStackCount();
+}
+
+export declare class AbilityComponentExtend<T> extends AbilityComponentAttribute<T> {
+}
+
+interface AbilityComponent extends AbilityComponentAttribute<AbilityComponent> {
+  (value: { want: Want, controller?: AbilityController }): AbilityComponent;
+}
+
+declare class AbilityComponentAttribute<T> extends CommonMethod<T> {
+  onReady(event: () => void): T;
+  onDestroy(event: () => void): T;
+  onAbilityCreated(event: (name: string) => void): T;
+  onAbilityMoveToFront(event: () => void): T;
+  onAbilityWillRemove(event: () => void): T;
+}
+
+export declare const AbilityComponentInterface: AbilityComponent;
diff --git a/api/@system.network.d.ts b/api/@internal/component/ets/action_sheet.d.ts
old mode 100755
new mode 100644
similarity index 41%
rename from api/@system.network.d.ts
rename to api/@internal/component/ets/action_sheet.d.ts
index 85edb3608e44dd31337b53542bf6fe078c55b101..26a0620988ba02a72140f0e6594110ea990e3817
--- a/api/@system.network.d.ts
+++ b/api/@internal/component/ets/action_sheet.d.ts
@@ -1,33 +1,47 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface NetworkResponse {
-  type: string;
-  metered: boolean;
-}
-export interface GetNetworkTypeOptions {
-  success?: (data: NetworkResponse) => void;
-  fail?: (data: any, code: number) => void;
-  complete?: () => void;
-}
-export interface SubscribeNetworkOptions {
-  success?: (data: NetworkResponse) => void;
-  fail?: (data: any, code: number) => void;
-}
-export default class Network {
-  static getType(options?: GetNetworkTypeOptions): void;
-  static subscribe(options?: SubscribeNetworkOptions): void;
-  static unsubscribe(): void;
-}
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { DialogAlignment } from "./alert_dialog";
+import {CommonMethod, Resource} from "./common"
+
+interface SheetInfo {
+  title: string | Resource;
+  icon?: string | Resource;
+  action: () => void;
+}
+
+export declare class ActionSheetExtend<T> extends ActionSheetAttribute<T> {
+}
+
+interface ActionSheet extends ActionSheetAttribute<ActionSheet> {
+}
+
+declare class ActionSheetAttribute<T> extends CommonMethod<T> {
+  show(value: {
+    title: string | Resource;
+    message: string | Resource;
+    confirm?: {
+      value: string | Resource;
+      action: () => void;
+    };
+    cancel?: () => void;
+    sheets: Array<SheetInfo>;
+    autoCancel?: boolean;
+    alignment?: DialogAlignment;
+    offset?: { dx: number | string | Resource, dy: number | string | Resource };
+  });
+}
+
+export declare const ActionSheetInterface: ActionSheet;
diff --git a/api/@internal/component/ets/alert_dialog.d.ts b/api/@internal/component/ets/alert_dialog.d.ts
index 620f47db15360d2d22437bfdba9591eda0e3cfa9..361b9823cc132048c5780b626f13d481cb3cfdf3 100644
--- a/api/@internal/component/ets/alert_dialog.d.ts
+++ b/api/@internal/component/ets/alert_dialog.d.ts
@@ -1,44 +1,55 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod, Resource} from "./common"
-
-interface AlertDialog extends CommonMethod<AlertDialog> {
-    show(value: {
-        title?: string | Resource;
-        message: string | Resource;
-        autoCancel?: boolean;
-        confirm?: {
-            value: string | Resource;
-            action: () => void;
-        };
-        cancel?: () => void;
-    } | {
-        title?: string | Resource;
-        message: string | Resource;
-        autoCancel?: boolean;
-        primaryButton: {
-            value: string | Resource;
-            action: () => void;
-        };
-        secondaryButton: {
-            value: string | Resource;
-            action: () => void;
-        };
-        cancel?: () => void;
-    });
-}
-
-export declare const AlertDialogInterface: AlertDialog;
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonMethod, Resource} from "./common"
+
+export declare enum DialogAlignment {
+  Top,
+  Center,
+  Bottom,
+  Default
+}
+
+interface AlertDialog {
+  show(value: {
+    title?: string | Resource;
+    message: string | Resource;
+    autoCancel?: boolean;
+    confirm?: {
+      value: string | Resource;
+      action: () => void;
+    };
+    cancel?: () => void;
+    alignment?: DialogAlignment;
+    offset?: { dx: number | string | Resource, dy: number | string | Resource };
+  } | {
+    title?: string | Resource;
+    message: string | Resource;
+    autoCancel?: boolean;
+    primaryButton: {
+      value: string | Resource;
+      action: () => void;
+    };
+    secondaryButton: {
+      value: string | Resource;
+      action: () => void;
+    };
+    cancel?: () => void;
+    alignment?: DialogAlignment;
+    offset?: { dx: number | string | Resource, dy: number | string | Resource };
+  });
+}
+
+export declare const AlertDialogInterface: AlertDialog;
diff --git a/api/@internal/component/ets/alphabet_indexer.d.ts b/api/@internal/component/ets/alphabet_indexer.d.ts
index db74e50e4cf284eb1cde57d1d6ff21a9f618c22a..27d0858af6d35065cd5795a3082390cb79f7ef05 100644
--- a/api/@internal/component/ets/alphabet_indexer.d.ts
+++ b/api/@internal/component/ets/alphabet_indexer.d.ts
@@ -17,36 +17,41 @@ import {CommonMethod, Color, Resource} from "./common";
 import {FontWeight, FontStyle} from "./text";
 
 export declare enum IndexerAlign {
-    Left,
-    Right
+  Left,
+  Right
 }
 
-interface AlphabetIndexer extends CommonMethod<AlphabetIndexer> {
+export declare class AlphabetIndexerExtend<T> extends AlphabetIndexerAttribute<T> {
+}
+
+interface AlphabetIndexer extends AlphabetIndexerAttribute<AlphabetIndexer> {
   (value: {ArrayValue : Array<string>, selected : number}): AlphabetIndexer;
+}
 
-  onSelected(event: (index: number) => void): AlphabetIndexer;
+declare class AlphabetIndexerAttribute<T> extends CommonMethod<T> {
+  onSelected(event: (index: number) => void): T;
 
-  color(value: Color | number | string | Resource): AlphabetIndexer;
+  color(value: Color | number | string | Resource): T;
 
-  selectedColor(value: Color | number | string | Resource): AlphabetIndexer;
+  selectedColor(value: Color | number | string | Resource): T;
 
-  popupColor(value: Color | number | string | Resource): AlphabetIndexer;
+  popupColor(value: Color | number | string | Resource): T;
 
-  selectedBackgroundColor(value: Color | number | string | Resource): AlphabetIndexer;
+  selectedBackgroundColor(value: Color | number | string | Resource): T;
 
-  popupBackground(value: Color | number | string | Resource): AlphabetIndexer;
+  popupBackground(value: Color | number | string | Resource): T;
 
-  usingPopup(value: boolean): AlphabetIndexer;
+  usingPopup(value: boolean): T;
 
-  selectedFont(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): AlphabetIndexer;
+  selectedFont(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): T;
 
-  popupFont(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): AlphabetIndexer;
+  popupFont(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): T;
 
-  iteamSize(value: string | number): AlphabetIndexer;
+  itemSize(value: string | number): T;
 
-  font(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): AlphabetIndexer;
+  font(value: { size?: number, weight?: FontWeight, family?: string, style?: FontStyle}): T;
 
-  alignStyle(value: IndexerAlign): AlphabetIndexer;
+  alignStyle(value: IndexerAlign): T;
 }
 
 export declare const AlphabetIndexerInterface: AlphabetIndexer;
diff --git a/api/@internal/component/ets/animator.d.ts b/api/@internal/component/ets/animator.d.ts
index 5b2b585be9b07839347aa037032d62c593f87dc0..2e51167d79395db85b2229575965e5b04518afca 100644
--- a/api/@internal/component/ets/animator.d.ts
+++ b/api/@internal/component/ets/animator.d.ts
@@ -16,51 +16,56 @@
 import {CommonMethod, AnimationStatus, Curve, FillMode, PlayMode} from "./common";
 
 export declare class SpringProp {
-    constructor(mass: number, stiffness: number, damping: number): SpringProp;
+  constructor(mass: number, stiffness: number, damping: number);
 }
 
 export declare class SpringMotion {
-    constructor(start: number, end: number, velocity: number, prop: SpringProp): SpringMotion;
+  constructor(start: number, end: number, velocity: number, prop: SpringProp);
 }
 
 export declare class FrictionMotion {
-    constructor(friction: number, position: number, velocity: number): FrictionMotion;
+  constructor(friction: number, position: number, velocity: number);
 }
 
 export declare class ScrollMotion {
-    constructor(position: number, velocity: number, min: number, max: number, prop: SpringProp): ScrollMotion;
+  constructor(position: number, velocity: number, min: number, max: number, prop: SpringProp);
 }
 
-interface Animator extends CommonMethod<Animator> {
-    (value: string): Animator;
+export declare class AnimatorExtend<T> extends AnimatorAttribute<T> {
+}
+
+interface Animator extends AnimatorAttribute<Animator> {
+  (value: string): Animator;
+}
 
-    state(value: AnimationStatus): Animator;
+declare class AnimatorAttribute<T> extends CommonMethod<T> {
+  state(value: AnimationStatus): T;
 
-    duration(value: number): Animator;
+  duration(value: number): T;
 
-    curve(value: Curve): Animator;
+  curve(value: Curve): T;
 
-    delay(value: number): Animator;
+  delay(value: number): T;
 
-    fillMode(value: FillMode): Animator;
+  fillMode(value: FillMode): T;
 
-    iterations(value: number): Animator;
+  iterations(value: number): T;
 
-    playMode(value: PlayMode): Animator;
+  playMode(value: PlayMode): T;
 
-    motion(value: Motion): Animator;
+  motion(value: SpringMotion | FrictionMotion | ScrollMotion): T;
 
-    onStart(event: () => void): Animator;
+  onStart(event: () => void): T;
 
-    onPause(event: () => void): Animator;
+  onPause(event: () => void): T;
 
-    onRepeat(event: () => void): Animator;
+  onRepeat(event: () => void): T;
 
-    onCancel(event: () => void): Animator;
+  onCancel(event: () => void): T;
 
-    onFinish(event: () => void): Animator;
+  onFinish(event: () => void): T;
 
-    onFrame(event: (value: number) => void): Animator;
+  onFrame(event: (value: number) => void): T;
 }
 
 export declare const AnimatorInterface: Animator;
\ No newline at end of file
diff --git a/api/@internal/component/ets/badge.d.ts b/api/@internal/component/ets/badge.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..49587d21ee2bd80205bd31d44c626d767193c63c
--- /dev/null
+++ b/api/@internal/component/ets/badge.d.ts
@@ -0,0 +1,42 @@
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod, Color} from "./common"
+
+declare enum BadgePosition {
+  Right,
+  RightTop,
+  Left
+}
+
+interface BadgeStyle {
+  color?: Color;
+  fontSize?: number | string;
+  badgeSize?: number | string;
+  badgeColor: Color;
+}
+
+export declare class BadgeExtend<T> extends BadgeAttribute<T> {
+}
+
+interface Badge extends BadgeAttribute<Badge> {
+  (value: {count: number, position?: BadgePosition, maxCount?: number, style?: BadgeStyle}): Badge;
+  (value: {value: string, position?: BadgePosition, maxCount?: number, style?: BadgeStyle}): Badge;
+}
+
+declare class BadgeAttribute<T> extends CommonMethod<T> {
+}
+
+export declare const BadgeInterface: Badge
\ No newline at end of file
diff --git a/api/@internal/component/ets/blank.d.ts b/api/@internal/component/ets/blank.d.ts
index 91fcb25f9be5d7aedb4be61b2458ea3517049bbe..42a841d29d59dd3b8c6f03ffbf8ae2ab277b198a 100644
--- a/api/@internal/component/ets/blank.d.ts
+++ b/api/@internal/component/ets/blank.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod, Color, Resource} from "./common"
 
-interface Blank extends CommonMethod<Blank> {
+export declare class BlankExtend<T> extends BlankAttribute<T> {
+}
+
+interface Blank extends BlankAttribute<Blank> {
   (min?: number | string): Blank;
+}
 
-  color(value: Color | number | string | Resource): Blank;
+declare class BlankAttribute<T> extends CommonMethod<T> {
+  color(value: Color | number | string | Resource): T;
 }
 
 export declare const BlankInterface: Blank
\ No newline at end of file
diff --git a/api/@internal/component/ets/button.d.ts b/api/@internal/component/ets/button.d.ts
index a27720e294d7dac0d8792f5fd9b4207fd7ff487a..8f7fd66a661e841cab04781a665e23344d266a7b 100644
--- a/api/@internal/component/ets/button.d.ts
+++ b/api/@internal/component/ets/button.d.ts
@@ -23,22 +23,27 @@ export declare enum ButtonType {
   Normal
 }
 
-interface Button extends CommonMethod<Button> {
+export declare class ButtonExtend<T> extends ButtonAttribute<T> {
+}
+
+interface Button extends ButtonAttribute<Button> {
   (): Button;
 
   (options: { type?: ButtonType, stateEffect?: boolean }): Button;
 
   (label: string, options?: { type?: ButtonType, stateEffect?: boolean }): Button;
+}
 
-  type(value: ButtonType): Button;
+declare class ButtonAttribute<T> extends CommonMethod<T> {
+  type(value: ButtonType): T;
 
-  stateEffect(value: boolean): Button;
+  stateEffect(value: boolean): T;
 
-  fontColor(value: Color | number | string | Resource): Button;
+  fontColor(value: Color | number | string | Resource): T;
 
-  fontSize(value: number | string | Resource): Button;
+  fontSize(value: number | string | Resource): T;
 
-  fontWeight(value: number | FontWeight | string): Button;
+  fontWeight(value: number | FontWeight | string): T;
 }
 
 export declare const ButtonInterface: Button
diff --git a/api/@internal/component/ets/calendar.d.ts b/api/@internal/component/ets/calendar.d.ts
index ffc0bf5c26d75d57611e6f68ce5038d610569a0c..9de2d52019c9d0a4fec5c2a5673e477a03c8c6f9 100644
--- a/api/@internal/component/ets/calendar.d.ts
+++ b/api/@internal/component/ets/calendar.d.ts
@@ -96,38 +96,44 @@ export interface WorkStateStyle {
 }
 
 declare class CalendarController {
-    constructor();
-    backToToday();
+  constructor();
+  backToToday();
+  goTo(value: { year: number, month: number, day: number });
 }
 
-interface Calendar {
+export declare class CalendarExtend<T> extends CalendarAttribute<T> {
+}
+
+interface Calendar extends CalendarAttribute<Calendar> {
   (value: { date: { year: number, month: number, day: number }, currentData: MonthData, preData: MonthData, nextData: MonthData, controller?: CalendarController }): Calendar;
+}
 
-  showLunar(value: boolean): Calendar;
+declare class CalendarAttribute<T> {
+  showLunar(value: boolean): T;
 
-  showHoliday(value: boolean): Calendar;
+  showHoliday(value: boolean): T;
 
-  needSlide(value: boolean): Calendar;
+  needSlide(value: boolean): T;
 
-  startOfWeek(value: number): Calendar;
+  startOfWeek(value: number): T;
 
-  offDays(value: number): Calendar;
+  offDays(value: number): T;
 
-  direction(value: Axis): Calendar;
+  direction(value: Axis): T;
 
-  currentDayStyle(value: CurrentDayStyle): Calendar;
+  currentDayStyle(value: CurrentDayStyle): T;
 
-  nonCurrentDayStyle(value: NonCurrentDayStyle): Calendar;
+  nonCurrentDayStyle(value: NonCurrentDayStyle): T;
 
-  todayStyle(value: TodayStyle): Calendar;
+  todayStyle(value: TodayStyle): T;
 
-  weekStyle(value: WeekStyle): Calendar;
+  weekStyle(value: WeekStyle): T;
 
-  workStateStyle(value: WorkStateStyle): Calendar;
+  workStateStyle(value: WorkStateStyle): T;
 
-  onSelectChange(event: (event: { year: number, month: number, day: number }) => void): Calendar;
+  onSelectChange(event: (event: { year: number, month: number, day: number }) => void): T;
 
-  onRequestData(event: (event: { year: number, month: number, currentYear: number, currentMonth: number, monthState: number }) => void): Calendar;
+  onRequestData(event: (event: { year: number, month: number, currentYear: number, currentMonth: number, monthState: number }) => void): T;
 }
 
 export declare const CalendarInterface: Calendar
diff --git a/api/@internal/component/ets/camera.d.ts b/api/@internal/component/ets/camera.d.ts
index 9487797ea65619ace03905162475f64f536cb1b1..6a9ebdb6e8fadebf9c1d1bb44fe80a91211f594d 100644
--- a/api/@internal/component/ets/camera.d.ts
+++ b/api/@internal/component/ets/camera.d.ts
@@ -20,10 +20,15 @@ export declare enum DevicePosition {
   Back
 }
 
-interface Camera extends CommonMethod<Camera> {
+export declare class CameraExtend<T> extends CameraAttribute<T> {
+}
+
+interface Camera extends CameraAttribute<Camera> {
   (value: { id: string, resolutionWidth: number, resolutionHeight: number }): Camera;
+}
 
-  devicePosition(value: DevicePosition): Camera;
+declare class CameraAttribute<T> extends CommonMethod<T> {
+  devicePosition(value: DevicePosition): T;
 }
 
 export declare const CameraInterface: Camera;
diff --git a/api/@internal/component/ets/circle.d.ts b/api/@internal/component/ets/circle.d.ts
index e9808f4d4434d5c48e62b2075994dac0caa693ff..457310a8b996cac36b9576c12f0e575f6a9dbf74 100644
--- a/api/@internal/component/ets/circle.d.ts
+++ b/api/@internal/component/ets/circle.d.ts
@@ -15,9 +15,15 @@
 
 import {CommonShapeMethod} from "./common";
 
-interface Circle extends CommonShapeMethod<Circle> {
+export declare class CircleExtend<T> extends CircleAttribute<T> {
+}
+
+interface Circle extends CircleAttribute<Circle> {
   new (value?: { width?: string | number, height?: string | number }): Circle;
   (value?: { width?: string | number, height?: string | number }): Circle;
 }
 
+declare class CircleAttribute<T> extends CommonShapeMethod<T> {
+}
+
 export declare const CircleInterface: Circle;
diff --git a/api/@internal/component/ets/column.d.ts b/api/@internal/component/ets/column.d.ts
index ca4af45cd6cbac67eb25c8282f9796690848e32e..0c73073bda482633bf880d7427e2a69561fde6f9 100644
--- a/api/@internal/component/ets/column.d.ts
+++ b/api/@internal/component/ets/column.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod, HorizontalAlignDeclaration, HorizontalAlign} from "./common";
 
-interface Column extends CommonMethod<Column> {
+export declare class ColumnExtend<T> extends ColumnAttribute<T> {
+}
+
+interface Column extends ColumnAttribute<Column> {
   (value?: { useAlign?: HorizontalAlignDeclaration, space?: string | number }): Column;
+}
 
-  alignItems(value: HorizontalAlign): Column;
+export declare class ColumnAttribute<T> extends CommonMethod<T> {
+  alignItems(value: HorizontalAlign): T;
 }
 
 export declare const ColumnInterface: Column;
diff --git a/api/@internal/component/ets/column_split.d.ts b/api/@internal/component/ets/column_split.d.ts
index 5215c007acbbaaf9d1412b6dd23a991dd6e9f71d..eafeac0043f8f567357bf84289216577517f6616 100644
--- a/api/@internal/component/ets/column_split.d.ts
+++ b/api/@internal/component/ets/column_split.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod} from "./common";
 
-interface ColumnSplit extends CommonMethod<ColumnSplit> {
+export declare class ColumnSplitExtend<T> extends ColumnSplitAttribute<T> {
+}
+
+interface ColumnSplit extends ColumnSplitAttribute<ColumnSplit> {
   (): ColumnSplit;
+}
 
-  resizeable(value: boolean): ColumnSplit;
+declare class ColumnSplitAttribute<T> extends CommonMethod<T> {
+  resizeable(value: boolean): T;
 }
 
 export declare const ColumnSplitInterface: ColumnSplit;
diff --git a/api/@internal/component/ets/common.d.ts b/api/@internal/component/ets/common.d.ts
index 736aa5aff695ff0a9fcad3559700e3f3b3084f06..09843ce1d9e311de6bc72d76e6a7235e24087c5f 100644
--- a/api/@internal/component/ets/common.d.ts
+++ b/api/@internal/component/ets/common.d.ts
@@ -33,6 +33,7 @@ export declare const StorageProp: (value: string) => PropertyDecorator;
 export declare const StorageLink: (value: string) => PropertyDecorator;
 export declare const Watch: (value: string) => PropertyDecorator;
 export declare const Builder: MethodDecorator;
+export declare const CustomDialog: ClassDecorator;
 declare interface NormalResource {
   readonly id: number;
   readonly type: number;
@@ -458,6 +459,8 @@ export declare class CommonMethod<T> {
 
   onTouch(event: (event?: TouchEvent) => void): T;
 
+  onHover(event: (isHover?: boolean) => void): T;
+
   onKeyEvent(event: (event?: KeyEvent) => void): T;
 
   onPan(event: (event?: any) => void): T;
@@ -482,6 +485,22 @@ export declare class CommonMethod<T> {
 
   blur(value: number): T;
 
+  brightness(value: number): T;
+
+  contrast(value: number): T;
+
+  grayscale(value: number): T;
+
+  colorBlend(value: Color | string | Resource): T;
+
+  saturate(value: number): T;
+
+  sepia(value: number): T;
+
+  invert(value: number): T;
+
+  hueRotate(value:{deg: string | number}): T;
+
   backdropBlur(value: number): T;
 
   windowBlur(value: { percent: number, style?: BlurStyle }): T;
@@ -536,11 +555,11 @@ export declare class CommonMethod<T> {
 
   align(value: Alignment): T;
 
-  position(value: { x?: number | string, y?: number | string }): T;
+  position(value: { x?: number | string | Resource, y?: number | string | Resource }): T;
 
-  markAnchor(value: { x?: number | string, y?: number | string }): T;
+  markAnchor(value: { x?: number | string | Resource, y?: number | string | Resource }): T;
 
-  offset(value: { x?: number | string, y?: number | string }): T;
+  offset(value: { x?: number | string | Resource, y?: number | string | Resource }): T;
 
   enabled(value: boolean): T;
 
@@ -573,7 +592,7 @@ export declare class CommonMethod<T> {
 
   motionPath(value: { path: string, from?: number, to?: number, rotatable?: boolean }): T;
 
-  shadow(value: { radius: number | Resource, color?: Color | string | Resource, offsetX?: number, offsetY?: number}): T;
+  shadow(value: { radius: number | Resource, color?: Color | string | Resource, offsetX?: number | Resource, offsetY?: number | Resource }): T;
 
   clip(value: boolean | Circle | Ellipse | Path | Rect): T;
 
@@ -588,6 +607,22 @@ export declare class CommonMethod<T> {
   accessibilityImportance(value: string): T;
 
   onAccessibility(callback: (event?: { eventType: number }) => void): T;
+
+  geometryTransition(id: string): T;
+
+  bindPopup(show: boolean, popup: {
+    message: string,
+    placementOnTop: boolean,
+    primaryButton: {
+      value: string;
+      action: () => void;
+    };
+    secondaryButton: {
+      value: string;
+      action: () => void;
+    };
+    onStateChange?: (callback: (event?: { isVisible: boolean }) => void) => void;
+  }): T;
 }
 
 export declare class CommonShapeMethod<T> extends CommonMethod<T> {
@@ -609,7 +644,7 @@ export declare class CommonShapeMethod<T> extends CommonMethod<T> {
 
   fillOpacity(value: number | string | Resource): T;
 
-  strokeWidth(value: number | string): T;
+  strokeWidth(value: number | string | Resource): T;
 
   antiAlias(value: boolean): T;
 
diff --git a/api/@internal/component/ets/counter.d.ts b/api/@internal/component/ets/counter.d.ts
index 2b4f863b0da0d0eb1c9f80d54662943519917201..9959aa096796762abd40e5a875aac8633fbe6430 100644
--- a/api/@internal/component/ets/counter.d.ts
+++ b/api/@internal/component/ets/counter.d.ts
@@ -15,14 +15,19 @@
 
 import {CommonMethod} from "./common";
 
-interface Counter extends CommonMethod<Counter> {
+export declare class CounterExtend<T> extends CounterAttribute<T> {
+}
+
+interface Counter extends CounterAttribute<Counter> {
   (): Counter;
+}
 
-  onStateChange(event: () => void): Counter;
+declare class CounterAttribute<T> extends CommonMethod<T> {
+  onStateChange(event: () => void): T;
 
-  onInc(event: () => void): Counter;
+  onInc(event: () => void): T;
 
-  onDec(event: () => void): Counter;
+  onDec(event: () => void): T;
 }
 
 export declare const CounterInterface: Counter;
diff --git a/api/@internal/component/ets/custom_dialog_controller.d.ts b/api/@internal/component/ets/custom_dialog_controller.d.ts
index 52389f76a82a58d89609ab05d1b5c93ced0756f8..6fe37be319a7eccbd47a32f78ea0db2e5c375047 100644
--- a/api/@internal/component/ets/custom_dialog_controller.d.ts
+++ b/api/@internal/component/ets/custom_dialog_controller.d.ts
@@ -1,24 +1,28 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod} from "./common";
-
-export declare const CustomDialog: ClassDecorator;
-
-export declare class CustomDialogController {
-    constructor(value: { builder: any, cancel?: () => void, autoCancel?: boolean });
-    open();
-    close();
-}
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { DialogAlignment } from "./alert_dialog";
+import {CommonMethod, Resource} from "./common";
+
+export declare class CustomDialogController {
+  constructor(value: {
+    builder: any, cancel?: () => void,
+    autoCancel?: boolean,
+    alignment?: DialogAlignment,
+    offset?: { dx: number | string | Resource, dy: number | string | Resource }
+  });
+  open();
+  close();
+}
diff --git a/api/@internal/component/ets/datapanel.d.ts b/api/@internal/component/ets/datapanel.d.ts
index c675fd2a8a08adaa01348400420feba0ab92d4c2..9e20789ecb25b13a3e035c9de5d784499c81296a 100644
--- a/api/@internal/component/ets/datapanel.d.ts
+++ b/api/@internal/component/ets/datapanel.d.ts
@@ -1,23 +1,29 @@
-/*
-  * Copyright (c) 2021 Huawei Device Co., Ltd.
-  * Licensed under the Apache License, Version 2.0 (the "License");
-  * you may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at
-  *
-  *     http://www.apache.org/licenses/LICENSE-2.0
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  */
-
-import {CommonMethod} from "./common";
-
-interface DataPanel extends CommonMethod<DataPanel> {
-    (options: {values: number[], max?: number}): DataPanel;
-    closeEffect(value: boolean): DataPanel;
-}
-
-export declare const DataPanelInterface: DataPanel;
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod} from "./common";
+
+export declare class DataPanelExtend<T> extends DataPanelAttribute<T> {
+}
+
+interface DataPanel extends DataPanelAttribute<DataPanel> {
+  (options: {values: number[], max?: number}): DataPanel;
+}
+
+declare class DataPanelAttribute<T> extends CommonMethod<T> {
+  closeEffect(value: boolean): T;
+}
+
+export declare const DataPanelInterface: DataPanel;
diff --git a/api/@system.prompt.d.ts b/api/@internal/component/ets/datePicker.d.ts
old mode 100755
new mode 100644
similarity index 46%
rename from api/@system.prompt.d.ts
rename to api/@internal/component/ets/datePicker.d.ts
index 2c395c5c0f5ce355193f4ec7d95235dbcf1c3d8c..a54d1cd7946b91954760bc9252b4c7beb70f6a99
--- a/api/@system.prompt.d.ts
+++ b/api/@internal/component/ets/datePicker.d.ts
@@ -13,26 +13,33 @@
  * limitations under the License.
  */
 
-export interface ShowToastOptions {
-  message: string;
-  duration?: number;
+import {CommonMethod} from "./common";
+
+export declare class DatePickerExtend<T> extends DatePickerAttribute<T> {
 }
-export interface Button {
-  text: string;
-  color: string;
+
+export declare enum DatePickerType {
+  Time,
+  Date
 }
-export interface ShowDialogSuccessResponse {
-  index: number;
+
+export interface DatePickerResult {
+  year?: number;
+  month?: number;
+  day?: number;
+  hour?: number;
+  minute?: number;
+  second?: number;
 }
-export interface ShowDialogOptions {
-  title?: string;
-  message?: string;
-  buttons?: [Button, Button?, Button?];
-  success?: (data: ShowDialogSuccessResponse) => void;
-  cancel?: (data: string, code: string) => void;
-  complete?: (data: string) => void;
+
+interface DatePicker extends DatePickerAttribute<DatePicker> {
+  (options?: {start?: Date, end?: Date, selected?: Date, type?: DatePickerType}): DatePicker;
 }
-export default class Prompt {
-  static showToast(options: ShowToastOptions): void;
-  static showDialog(options: ShowDialogOptions): void;
+
+declare class DatePickerAttribute<T> extends CommonMethod<T> {
+  lunar(value: boolean): T;
+  useMilitaryTime(value: boolean): T;
+  onChange(callback: (value: DatePickerResult) => void): T;
 }
+
+export declare const DatePickerInterface: DatePicker;
diff --git a/api/@internal/component/ets/divider.d.ts b/api/@internal/component/ets/divider.d.ts
index 70d01add968c5ccf233cb8655b695774a3595f9b..c6c487ed4db13c8110dcc85f20e739acf345c9ab 100644
--- a/api/@internal/component/ets/divider.d.ts
+++ b/api/@internal/component/ets/divider.d.ts
@@ -15,16 +15,21 @@
 
 import {CommonMethod, Color, LineCapStyle, Resource} from "./common";
 
-interface Divider extends CommonMethod<Divider> {
+export declare class DividerExtend<T> extends DividerAttribute<T> {
+}
+
+interface Divider extends DividerAttribute<Divider> {
   (): Divider;
+}
 
-  vertical(value: boolean): Divider;
+declare class DividerAttribute<T> extends CommonMethod<T> {
+  vertical(value: boolean): T;
 
-  color(value: Color | number | string | Resource): Divider;
+  color(value: Color | number | string | Resource): T;
 
-  strokeWidth(value: number | string): Divider;
+  strokeWidth(value: number | string): T;
 
-  lineCap(value: LineCapStyle): Divider;
+  lineCap(value: LineCapStyle): T;
 }
 
 export declare const DividerInterface: Divider;
diff --git a/api/@internal/component/ets/ellipse.d.ts b/api/@internal/component/ets/ellipse.d.ts
index 0a2497b768cf6fe85e1ce9d00646b9ffde732fdf..6ec158aeb7f2274b6126127f2ea7f6f8764e1370 100644
--- a/api/@internal/component/ets/ellipse.d.ts
+++ b/api/@internal/component/ets/ellipse.d.ts
@@ -15,9 +15,15 @@
 
 import {CommonShapeMethod} from "./common";
 
-interface Ellipse extends CommonShapeMethod<Ellipse> {
+export declare class EllipseExtend<T> extends EllipseAttribute<T> {
+}
+
+interface Ellipse extends EllipseAttribute<Ellipse> {
   new (value?: { width?: string | number, height?: string | number }): Ellipse;
   (value?: { width?: string | number, height?: string | number }): Ellipse;
 }
 
+declare class EllipseAttribute<T> extends CommonShapeMethod<T> {
+}
+
 export declare const EllipseInterface: Ellipse;
diff --git a/api/@internal/component/ets/flex.d.ts b/api/@internal/component/ets/flex.d.ts
index badc2194d3207f926027bc8b575a02862035c150..2503bb40ebf75ee5fa076fd2917b3bd8aa2a5f82 100644
--- a/api/@internal/component/ets/flex.d.ts
+++ b/api/@internal/component/ets/flex.d.ts
@@ -15,11 +15,17 @@
 
 import {CommonMethod, FlexDirection, FlexWrap, FlexAlign, ItemAlign} from "./common";
 
-interface Flex extends CommonMethod<Flex> {
+export declare class FlexExtend<T> extends FlexAttribute<T> {
+}
+
+interface Flex extends FlexAttribute<Flex> {
   (value?: {
     direction?: FlexDirection, wrap?: FlexWrap, justifyContent?: FlexAlign,
     alignItems?: ItemAlign, alignContent?: FlexAlign
   }): Flex;
 }
 
+declare class FlexAttribute<T> extends CommonMethod<T> {
+}
+
 export declare const FlexInterface: Flex;
diff --git a/api/@internal/component/ets/form_component.d.ts b/api/@internal/component/ets/form_component.d.ts
index 77243d3e9e5bffc1756ff896ed88800067f25c1f..004594f5b7b6370e93caa78fb1b155ac978f29aa 100644
--- a/api/@internal/component/ets/form_component.d.ts
+++ b/api/@internal/component/ets/form_component.d.ts
@@ -22,24 +22,29 @@ export declare enum FormDimension {
   Dimension_4_4
 }
 
-interface FormComponent extends CommonMethod<FormComponent> {
+export declare class FormComponentExtend<T> extends FormComponentAttribute<T> {
+}
+
+interface FormComponent extends FormComponentAttribute<FormComponent> {
   (value: {id: number, name: string, bundle: string, ability: string, module: string, dimension?: FormDimension}): FormComponent;
+}
 
-  size(value: {width: number, height: number}): FormComponent;
+declare class FormComponentAttribute<T> extends CommonMethod<T> {
+  size(value: {width: number, height: number}): T;
 
-  moduleName(value: string): FormComponent;
+  moduleName(value: string): T;
 
-  dimension(value: FormDimension): FormComponent;
+  dimension(value: FormDimension): T;
 
-  allowUpdate(value: boolean): FormComponent;
+  allowUpdate(value: boolean): T;
 
-  visibility(value: Visibility): FormComponent;
+  visibility(value: Visibility): T;
 
-  onAcquired(callback: (info: {id: number}) => void): FormComponent;
+  onAcquired(callback: (info: {id: number}) => void): T;
 
-  onError(callback: (info: {errcode: number, msg: string}) => void): FormComponent;
+  onError(callback: (info: {errcode: number, msg: string}) => void): T;
 
-  onRouter(callback: (info: any) => void): FormComponent;
+  onRouter(callback: (info: any) => void): T;
 }
 
 export declare const FormComponentInterface: FormComponent;
diff --git a/api/@internal/component/ets/gauge.d.ts b/api/@internal/component/ets/gauge.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..54a6bdd4aa72cf6e887ef6bf7afe32e43547d948
--- /dev/null
+++ b/api/@internal/component/ets/gauge.d.ts
@@ -0,0 +1,35 @@
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod, Color} from "./common";
+
+export declare class GaugeExtend<T> extends GaugeAttribute<T> {
+}
+
+interface Gauge extends GaugeAttribute<Gauge> {
+  (options: {value: number, min?: number, max?: number}): Gauge;
+}
+
+declare class GaugeAttribute<T> extends CommonMethod<T> {
+  value(value: number): T;
+  startAngle(angle: number): T;
+  endAngle(angle: number): T;
+  colors(colors: Array<any>): T;
+  strokeWidth(length: number): T;
+  labelTextConfig(markedLabelText: string): T;
+  labelColorConfig(markedLabelColor: Color): T;
+}
+
+export declare const GaugeInterface: Gauge;
\ No newline at end of file
diff --git a/api/@internal/component/ets/geometryView.d.ts b/api/@internal/component/ets/geometryView.d.ts
index 2a99abf732c2da4e7f0acbb6f64280a26e76de4c..a9c489bea31e564f1290be92ab0b44cea3722b1f 100644
--- a/api/@internal/component/ets/geometryView.d.ts
+++ b/api/@internal/component/ets/geometryView.d.ts
@@ -15,8 +15,14 @@
 
 import {CommonMethod} from "./common";
 
-interface GeometryView extends CommonMethod<GeometryView> {
+export declare class GeometryViewExtend<T> extends GeometryViewAttribute<T> {
+}
+
+interface GeometryView extends GeometryViewAttribute<GeometryView> {
   (callback: (geometry?: any) => void): GeometryView;
 }
 
+declare class GeometryViewAttribute<T> extends CommonMethod<T> {
+}
+
 export declare const GeometryViewInterface: GeometryView;
diff --git a/api/@internal/component/ets/grid.d.ts b/api/@internal/component/ets/grid.d.ts
index 426aacc3ceecf7c67319439724fa9c5e583a1de2..c2468c6da6d6406806f83d2bfe3826296652a5e5 100644
--- a/api/@internal/component/ets/grid.d.ts
+++ b/api/@internal/component/ets/grid.d.ts
@@ -13,27 +13,34 @@
  * limitations under the License.
  */
 
-import {CommonMethod, BarState, Color} from "./common";
+import {CommonMethod, BarState, Color, Resource} from "./common";
 import {Scroller} from "./scroll";
 
-interface Grid extends CommonMethod<Grid> {
+export declare class GridExtend<T> extends GridAttribute<T> {
+}
+
+interface Grid extends GridAttribute<Grid> {
   (scroller?: Scroller): Grid;
+}
+
+declare class GridAttribute<T> extends CommonMethod<T> {
+  columnsTemplate(value: string): T;
 
-  columnsTemplate(value: string): Grid;
+  rowsTemplate(value: string): T;
 
-  rowsTemplate(value: string): Grid;
+  columnsGap(value: number | string | Resource): T;
 
-  columnsGap(value: number | string): Grid;
+  rowsGap(value: number | string | Resource): T;
 
-  rowsGap(value: number | string): Grid;
+  scrollBarWidth(value: number | string): T;
 
-  scrollBarWidth(value: number | string): Grid;
+  scrollBarColor(value: Color | number | string): T;
 
-  scrollBarColor(value: Color | number | string): Grid;
+  scrollBar(value: BarState): T;
 
-  scrollBar(value: BarState): Grid;
+  onScrollIndex(event: (first: number) => void): T;
 
-  onScrollIndex(event: (first: number) => void): Grid;
+  cachedCount(value: number): T;
 }
 
 export declare const GridInterface: Grid;
diff --git a/api/@internal/component/ets/gridItem.d.ts b/api/@internal/component/ets/gridItem.d.ts
index 865d3a1d68b89227912d70ca1d22028288a9c4e1..d55401a25d591ef53936a99326c79b20c4590af0 100644
--- a/api/@internal/component/ets/gridItem.d.ts
+++ b/api/@internal/component/ets/gridItem.d.ts
@@ -1,32 +1,37 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod} from "./common";
-
-interface GridItem extends CommonMethod<GridItem> {
-  (): GridItem;
-
-  rowStart(value: number): GridItem;
-
-  rowEnd(value: number): GridItem;
-
-  columnStart(value: number): GridItem;
-
-  columnEnd(value: number): GridItem;
-
-  forceRebuild(value: boolean): GridItem;
-}
-
-export declare const GridItemInterface: GridItem;
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonMethod} from "./common";
+
+export declare class GridItemExtend<T> extends GridItemAttribute<T> {
+}
+
+interface GridItem extends GridItemAttribute<GridItem> {
+  (): GridItem;
+}
+
+declare class GridItemAttribute<T> extends CommonMethod<T> {
+  rowStart(value: number): T;
+
+  rowEnd(value: number): T;
+
+  columnStart(value: number): T;
+
+  columnEnd(value: number): T;
+
+  forceRebuild(value: boolean): T;
+}
+
+export declare const GridItemInterface: GridItem;
diff --git a/api/@internal/component/ets/grid_container.d.ts b/api/@internal/component/ets/grid_container.d.ts
index 55ca7fb72f4f7b3ea2d288a27ded05c74cf8ad11..f6e353f697723a7264fc5a8b25c12e6ae0e93bb0 100644
--- a/api/@internal/component/ets/grid_container.d.ts
+++ b/api/@internal/component/ets/grid_container.d.ts
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import {Column} from "./column";
+import {ColumnAttribute} from "./column";
 
 export declare enum SizeType {
   Auto,
@@ -23,7 +23,10 @@ export declare enum SizeType {
   LG
 }
 
-interface GridContainer extends Column {
+export declare class GridContainerExtend<T> extends GridContainerAttribute<T> {
+}
+
+interface GridContainer extends GridContainerAttribute<GridContainer> {
   (
     value?: {
       columns?: number | 'auto',
@@ -34,4 +37,7 @@ interface GridContainer extends Column {
   ): GridContainer;
 }
 
+declare class GridContainerAttribute<T> extends ColumnAttribute<T> {
+}
+
 export declare const GridContainerInterface: GridContainer;
\ No newline at end of file
diff --git a/api/@system.mediaquery.d.ts b/api/@internal/component/ets/hyperlink.d.ts
old mode 100755
new mode 100644
similarity index 58%
rename from api/@system.mediaquery.d.ts
rename to api/@internal/component/ets/hyperlink.d.ts
index 442930b92caeb396c9568092306e98664038878a..fd536cea7ab1884d7ace766690476d62528174d9
--- a/api/@system.mediaquery.d.ts
+++ b/api/@internal/component/ets/hyperlink.d.ts
@@ -13,16 +13,17 @@
  * limitations under the License.
  */
 
-export interface MediaQueryEvent {
-  matches: boolean;
+import {CommonMethod, Color, Resource} from "./common";
+
+export declare class HyperlinkExtend<T> extends HyperlinkAttribute<T> {
 }
-export interface MediaQueryList {
-  media?: string;
-  matches?: boolean;
-  onchange?: (matches: boolean) => void;
-  addListener(callback: (event: MediaQueryEvent) => void): void;
-  removeListener(callback: (event: MediaQueryEvent) => void): void;
+
+interface Hyperlink extends HyperlinkAttribute<Hyperlink> {
+  (address: string | Resource, content?: string | Resource): Hyperlink;
 }
-export default class MediaQuery {
-  static matchMedia(condition: string): MediaQueryList;
+
+declare class HyperlinkAttribute<T> extends CommonMethod<T> {
+  color(value: Color | number | string | Resource): T;
 }
+
+export declare const HyperlinkInterface: Hyperlink;
diff --git a/api/@internal/component/ets/image.d.ts b/api/@internal/component/ets/image.d.ts
index abe057ea2d2e9e0e2b3836ed9bd3e354cd580962..ff095b7c90104108e6b8876ecf4d6ab1cad7cbfa 100644
--- a/api/@internal/component/ets/image.d.ts
+++ b/api/@internal/component/ets/image.d.ts
@@ -27,34 +27,39 @@ export declare enum ImageInterpolation {
   High
 }
 
-interface Image extends CommonMethod<Image> {
+export declare class ImageExtend<T> extends ImageAttribute<T> {
+}
+
+interface Image extends ImageAttribute<Image> {
   (src: string | PixelMap | Resource): Image;
+}
 
-  alt(value: string | Resource): Image;
+declare class ImageAttribute<T> extends CommonMethod<T> {
+  alt(value: string | Resource): T;
 
-  matchTextDirection(value: boolean): Image;
+  matchTextDirection(value: boolean): T;
 
-  fitOriginalSize(value: boolean): Image;
+  fitOriginalSize(value: boolean): T;
 
-  fillColor(value: Color | number | string | Resource): Image;
+  fillColor(value: Color | number | string | Resource): T;
 
-  objectFit(value: ImageFit): Image;
+  objectFit(value: ImageFit): T;
 
-  objectRepeat(value: ImageRepeat): Image;
+  objectRepeat(value: ImageRepeat): T;
 
-  autoResize(value: boolean): Image;
+  autoResize(value: boolean): T;
 
-  renderMode(value: ImageRenderMode): Image;
+  renderMode(value: ImageRenderMode): T;
 
-  interpolation(value: ImageInterpolation): Image;
+  interpolation(value: ImageInterpolation): T;
 
-  sourceSize(value: { width: number, height: number }): Image;
+  sourceSize(value: { width: number, height: number }): T;
 
-  onComplete(callback: (event?: { width: number, height: number, componentWidth: number, componentHeight: number, loadingStatus: number }) => void): Image;
+  onComplete(callback: (event?: { width: number, height: number, componentWidth: number, componentHeight: number, loadingStatus: number }) => void): T;
 
-  onError(callback: (event?: { componentWidth: number, componentHeight: number }) => void): Image;
+  onError(callback: (event?: { componentWidth: number, componentHeight: number }) => void): T;
 
-  onFinish(event: () => void): Image;
+  onFinish(event: () => void): T;
 }
 
 export declare const ImageInterface: Image;
diff --git a/api/@internal/component/ets/image_animator.d.ts b/api/@internal/component/ets/image_animator.d.ts
index 896a4688040516787a9ca9cc6a1849fadf3bcb2d..a219ccb2b5998aed56bc5e45315e8615b98329b1 100644
--- a/api/@internal/component/ets/image_animator.d.ts
+++ b/api/@internal/component/ets/image_animator.d.ts
@@ -15,37 +15,42 @@
 
 import {CommonMethod, AnimationStatus} from "./common";
 
-interface ImageAnimator extends CommonMethod<ImageAnimator> {
+export declare class ImageAnimatorExtend<T> extends ImageAnimatorAttribute<T> {
+}
+
+interface ImageAnimator extends ImageAnimatorAttribute<ImageAnimator> {
   (): ImageAnimator;
+}
 
+declare class ImageAnimatorAttribute<T> extends CommonMethod<T> {
   images(value: Array<{
     src: string, width?: number | string, height?: number | string, top?: number | string, left?:
       number | string, duration?: number
-  }>): ImageAnimator;
+  }>): T;
 
-  state(value: AnimationStatus): ImageAnimator;
+  state(value: AnimationStatus): T;
 
-  duration(value: number): ImageAnimator;
+  duration(value: number): T;
 
-  reverse(value: boolean): ImageAnimator;
+  reverse(value: boolean): T;
 
-  fixedSize(value: boolean): ImageAnimator;
+  fixedSize(value: boolean): T;
 
-  preDecode(value: number): ImageAnimator;
+  preDecode(value: number): T;
 
-  fillMode(value: FillMode): ImageAnimator;
+  fillMode(value: FillMode): T;
 
-  iterations(value: number): ImageAnimator;
+  iterations(value: number): T;
 
-  onStart(event: () => void): ImageAnimator;
+  onStart(event: () => void): T;
 
-  onPause(event: () => void): ImageAnimator;
+  onPause(event: () => void): T;
 
-  onRepeat(event: () => void): ImageAnimator;
+  onRepeat(event: () => void): T;
 
-  onCancel(event: () => void): ImageAnimator;
+  onCancel(event: () => void): T;
 
-  onFinish(event: () => void): ImageAnimator;
+  onFinish(event: () => void): T;
 }
 
 export declare const ImageAnimatorInterface: ImageAnimator;
diff --git a/api/@internal/component/ets/index.d.ts b/api/@internal/component/ets/index.d.ts
index 68cee499752f6a958958bd548e0a1b3f7ac41e69..d9d19e5d4e4247c7ac5bc9a8fdb582528faa1e4e 100644
--- a/api/@internal/component/ets/index.d.ts
+++ b/api/@internal/component/ets/index.d.ts
@@ -14,9 +14,11 @@
  */
 
 export * from './ability_component';
+export * from './action_sheet';
 export * from './alert_dialog';
 export * from './alphabet_indexer';
 export * from './animator';
+export * from './badge';
 export * from './blank';
 export * from './button';
 export * from './calendar';
@@ -27,11 +29,13 @@ export * from './column_split';
 export * from './common';
 export * from './counter';
 export * from './custom_dialog_controller';
+export * from './datePicker';
 export * from './divider';
 export * from './ellipse';
 export * from './flex';
 export * from './forEach';
 export * from './form_component';
+export * from './gauge';
 export * from './geometryView';
 export * from './gesture';
 export * from './grid';
@@ -40,9 +44,11 @@ export * from './grid_container';
 export * from './image';
 export * from './image_animator';
 export * from './lazyForEach';
+export * from './line';
 export * from './list';
 export * from './listItem';
 export * from './loadingProgress';
+export * from './marquee';
 export * from './navigator';
 export * from './navigatorView';
 export * from './pageTransition';
@@ -64,6 +70,9 @@ export * from './swiper';
 export * from './tab_content';
 export * from './tabs';
 export * from './text';
+export * from './textarea';
+export * from './textinput';
+export * from './textPicker';
 export * from './toggle';
 export * from './video';
 export * from './progress';
@@ -71,3 +80,6 @@ export * from './polygon';
 export * from './polyline';
 export * from './radio';
 export * from './datapanel';
+export * from './hyperlink';
+export * from './menu';
+export * from './option';
diff --git a/api/@system.battery.d.ts b/api/@internal/component/ets/line.d.ts
old mode 100755
new mode 100644
similarity index 58%
rename from api/@system.battery.d.ts
rename to api/@internal/component/ets/line.d.ts
index 8196688966cb4f10461aedf37106a52294802955..c31bce273a85ede721d82471538eecf2a39dd7f2
--- a/api/@system.battery.d.ts
+++ b/api/@internal/component/ets/line.d.ts
@@ -1,27 +1,31 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface BatteryResponse {
-  charging: boolean;
-  level: number;
-}
-export interface GetStatusOptions {
-  success?: (data: BatteryResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export default class Battery {
-  static getStatus(options?: GetStatusOptions): void;
-}
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonShapeMethod} from "./common";
+
+export declare class LineExtend<T> extends LineAttribute<T> {
+}
+
+interface Line extends LineAttribute<Line> {
+  (): Line;
+  (value?: { width?: string | number, height?: string | number }) :Line;
+}
+
+declare class LineAttribute<T> extends CommonShapeMethod<T> {
+  startPoint(value: Array<any>): T;
+  endPoint(value: Array<any>): T;
+}
+
+export declare const LineInterface: Line;
\ No newline at end of file
diff --git a/api/@internal/component/ets/list.d.ts b/api/@internal/component/ets/list.d.ts
index ef3501ec224f24b682da1d957e409994942e236e..e06e424a8f43b654e75c07e5f3f85ed3b41d1670 100644
--- a/api/@internal/component/ets/list.d.ts
+++ b/api/@internal/component/ets/list.d.ts
@@ -13,60 +13,53 @@
  * limitations under the License.
  */
 
-import {CommonMethod, Axis, Color, Resource} from "./common";
+import {CommonMethod, Axis, Color, Resource, BarState, EdgeEffect} from "./common";
 import {Scroller} from "./scroll";
 
-export declare enum BarState {
-  Off,
-  Auto,
-  On
-}
-
-export declare enum EdgeEffect {
-  Spring,
-  Fade,
-  None
-}
-
 export declare enum ScrollState {
   Idle,
   Scroll,
   Fling
 }
 
-interface List extends CommonMethod<List> {
+export declare class ListExtend<T> extends ListAttribute<T> {
+}
+
+interface List extends ListAttribute<List> {
   (value?: { initialIndex?: number, space?: number | string, scroller?: Scroller }): List;
+}
 
-  listDirection(value: Axis): List;
+declare class ListAttribute<T> extends CommonMethod<T> {
+  listDirection(value: Axis): T;
 
-  scrollBar(value: BarState): List;
+  scrollBar(value: BarState): T;
 
-  edgeEffect(value: EdgeEffect): List;
+  edgeEffect(value: EdgeEffect): T;
 
   divider(value: {
     strokeWidth: number | string | Resource, color?: Color | number | string | Resource,
     startMargin?: number | string | Resource, endMargin?: number | string | Resource
-  } | null): List;
+  } | null): T;
 
-  editMode(value: boolean): List;
+  editMode(value: boolean): T;
 
-  cachedCount(value: number): List;
+  cachedCount(value: number): T;
 
-  chainAnimation(value: boolean): List;
+  chainAnimation(value: boolean): T;
 
-  onScroll(event: (scrollOffset: number, scrollState: ScrollState) => void): List;
+  onScroll(event: (scrollOffset: number, scrollState: ScrollState) => void): T;
 
-  onScrollIndex(event: (start: number, end: number) => void): List;
+  onScrollIndex(event: (start: number, end: number) => void): T;
 
-  onReachStart(event: () => void): List;
+  onReachStart(event: () => void): T;
 
-  onReachEnd(event: () => void): List;
+  onReachEnd(event: () => void): T;
 
-  onScrollStop(event: () => void): List;
+  onScrollStop(event: () => void): T;
 
-  onItemDelete(event: (index: number) => boolean): List;
+  onItemDelete(event: (index: number) => boolean): T;
 
-  onItemMove(event: (from: number, to: number) => boolean): List;
+  onItemMove(event: (from: number, to: number) => boolean): T;
 }
 
 export declare const ListInterface: List;
diff --git a/api/@internal/component/ets/listItem.d.ts b/api/@internal/component/ets/listItem.d.ts
index 0bef157255b4b57271cd3a291cce47763812e187..aa9ead44d79cfdabf07f6ebc94adecdfb0021125 100644
--- a/api/@internal/component/ets/listItem.d.ts
+++ b/api/@internal/component/ets/listItem.d.ts
@@ -21,12 +21,23 @@ export declare enum Sticky {
   Opacity,
 }
 
-interface ListItem extends CommonMethod<ListItem> {
+export declare enum EditMode {
+  None,
+  Deletable,
+  Movable,
+}
+
+export declare class ListItemExtend<T> extends ListItemAttribute<T> {
+}
+
+interface ListItem extends ListItemAttribute<ListItem> {
   (value?: string): ListItem;
+}
 
-  sticky(value: Sticky): ListItem;
+declare class ListItemAttribute<T> extends CommonMethod<T> {
+  sticky(value: Sticky): T;
 
-  editable(value: boolean): ListItem;
+  editable(value: boolean | EditMode): T;
 }
 
 export declare const ListItemInterface: ListItem;
diff --git a/api/@internal/component/ets/loadingProgress.d.ts b/api/@internal/component/ets/loadingProgress.d.ts
index 61722c1d9aecb2bc970845f961379ca4ede1a2d1..a949feae207381c9e522e1ca74e2c7b8d920ec0f 100644
--- a/api/@internal/component/ets/loadingProgress.d.ts
+++ b/api/@internal/component/ets/loadingProgress.d.ts
@@ -21,9 +21,15 @@ export declare enum LoadingProgressStyle{
   Orbital,
 }
 
-interface LoadingProgress extends CommonMethod<LoadingProgress> {
+export declare class LoadingProgressExtend<T> extends LoadingProgressAttribute<T> {
+}
+
+interface LoadingProgress extends LoadingProgressAttribute<LoadingProgress> {
   (): LoadingProgress;
-  color(value: Color | Resource): LoadingProgress;
+}
+
+declare class LoadingProgressAttribute<T> extends CommonMethod<T> {
+  color(value: Color | Resource): T;
 }
 
 export declare const LoadingProgressInterface: LoadingProgress;
diff --git a/api/@internal/component/ets/marquee.d.ts b/api/@internal/component/ets/marquee.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b02294ad68ff852fd8404e8d775cbf9d15ebd0c
--- /dev/null
+++ b/api/@internal/component/ets/marquee.d.ts
@@ -0,0 +1,31 @@
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod} from "./common";
+
+export declare class MarqueeExtend<T> extends MarqueeAttribute<T> {
+}
+
+interface Marquee extends MarqueeAttribute<Marquee> {
+  (value?: {start: boolean, step?: number, loop?: number, fromStart?: boolean, src?: string}): Marquee;
+}
+
+declare class MarqueeAttribute<T> extends CommonMethod<T> {
+  onStart(event: () => void): T;
+  onBounce(event: () => void): T;
+  onFinish(event: () => void): T;
+}
+
+export declare const MarqueeInterface: Marquee;
\ No newline at end of file
diff --git a/api/@internal/component/ets/menu.d.ts b/api/@internal/component/ets/menu.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2a4e6217b62c0951f89771adc1cdc1a28d3ab8db
--- /dev/null
+++ b/api/@internal/component/ets/menu.d.ts
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { CommonMethod, Resource } from "./common";
+
+export declare enum MenuType {
+  Click,
+  LongPress
+}
+
+export declare class MenuExtend<T> extends MenuAttribute<T> {
+}
+
+interface Menu extends MenuAttribute<Menu> {
+  (options?: {type?: MenuType, title?: string | Resource}): Menu;
+}
+
+declare class MenuAttribute<T> extends CommonMethod<T> {
+  show(value: boolean): T;
+  showPosition(options: {x: number, y: number}): T;
+}
+
+export declare const MenuInterface: Menu;
\ No newline at end of file
diff --git a/api/@internal/component/ets/navigator.d.ts b/api/@internal/component/ets/navigator.d.ts
index f94f0d95c7713f8f8ed75df1e4b777526e7a2303..89eef4eabc91b0d2dbf7f012cc57fe63ed23ebc6 100644
--- a/api/@internal/component/ets/navigator.d.ts
+++ b/api/@internal/component/ets/navigator.d.ts
@@ -21,18 +21,23 @@ export declare enum NavigationType {
   Replace
 }
 
-interface Navigator extends CommonMethod<Navigator> {
+export declare class NavigatorExtend<T> extends NavigatorAttribute<T> {
+}
+
+interface Navigator extends NavigatorAttribute<Navigator> {
   (value?: { target: string, type?: NavigationType }): Navigator;
 
   (): Navigator;
+}
 
-  active(value: boolean): Navigator;
+declare class NavigatorAttribute<T> extends CommonMethod<T> {
+  active(value: boolean): T;
 
-  type(value: NavigationType): Navigator;
+  type(value: NavigationType): T;
 
-  target(value: string): Navigator;
+  target(value: string): T;
 
-  params(value: object): Navigator;
+  params(value: object): T;
 }
 
 export declare const NavigatorInterface: Navigator;
diff --git a/api/@internal/component/ets/navigatorView.d.ts b/api/@internal/component/ets/navigatorView.d.ts
index eabdb77b83569efca671dba6854be9eeefccf819..be44e291a4c10f51053c85118da6779df6429578 100644
--- a/api/@internal/component/ets/navigatorView.d.ts
+++ b/api/@internal/component/ets/navigatorView.d.ts
@@ -15,8 +15,14 @@
 
 import {CommonMethod} from "./common";
 
-interface NavigationView extends CommonMethod<NavigationView> {
+export declare class NavigationViewExtend<T> extends NavigationViewAttribute<T> {
+}
+
+interface NavigationView extends NavigationViewAttribute<NavigationView> {
   (): NavigationView;
 }
 
+declare class NavigationViewAttribute<T> extends CommonMethod<T> {
+}
+
 export declare const NavigationViewInterface: NavigationView;
diff --git a/api/@system.notification.d.ts b/api/@internal/component/ets/option.d.ts
old mode 100755
new mode 100644
similarity index 65%
rename from api/@system.notification.d.ts
rename to api/@internal/component/ets/option.d.ts
index be1f0fc35b3013cfe3ede1dc6df8d044cc9b4077..d3ecb5d4ce8287a83bd90aba232f1849c572a882
--- a/api/@system.notification.d.ts
+++ b/api/@internal/component/ets/option.d.ts
@@ -13,16 +13,16 @@
  * limitations under the License.
  */
 
-export interface ActionResult {
-  bundleName: string;
-  abilityName: string;
-  uri: string;
+import { CommonMethod, Resource } from "./common";
+
+export declare class OptionExtend<T> extends OptionAttribute<T> {
 }
-export interface ShowNotificationOptions {
-  contentTitle?: string;
-  contentText?: string;
-  clickAction?: ActionResult;
+
+interface Option extends OptionAttribute<Option> {
+  (content?: string | Resource): Option;
 }
-export default class Notification {
-  static show(options?: ShowNotificationOptions): void;
+
+declare class OptionAttribute<T> extends CommonMethod<T> {
 }
+
+export declare const OptionInterface: Option;
\ No newline at end of file
diff --git a/api/@internal/component/ets/pageTransition.d.ts b/api/@internal/component/ets/pageTransition.d.ts
index fc7c52cf0fe1a6396b1c05992754655e613efc6c..bc8fc0f9e74cdde931e8a90c849165f857559325 100644
--- a/api/@internal/component/ets/pageTransition.d.ts
+++ b/api/@internal/component/ets/pageTransition.d.ts
@@ -40,13 +40,13 @@ export declare class CommonTransition<T> {
   opacity(value: number): T;
 }
 
-export interface PageTransitionEnter extends CommonTransition<PageTransitionEnter> {
+interface PageTransitionEnter extends CommonTransition<PageTransitionEnter> {
   (value: { type?: RouteType, duration?: number, curve?: Curve | string, delay?: number }): PageTransitionEnter;
 
   onEnter(event: (type?: RouteType, progress?: number) => void): PageTransitionEnter;
 }
 
-export interface PageTransitionExit extends CommonTransition<PageTransitionExit> {
+interface PageTransitionExit extends CommonTransition<PageTransitionExit> {
   (value: { type?: RouteType, duration?: number, curve?: Curve | string, delay?: number }): PageTransitionExit;
 
   onExit(event: (type?: RouteType, progress?: number) => void): PageTransitionExit;
diff --git a/api/@internal/component/ets/panel.d.ts b/api/@internal/component/ets/panel.d.ts
index dd2e5e9b3a0161b4815e83645d07fa71df70f582..28cad065bc9b20f63fdecc10871446f4d0b285be 100644
--- a/api/@internal/component/ets/panel.d.ts
+++ b/api/@internal/component/ets/panel.d.ts
@@ -27,24 +27,29 @@ export declare enum PanelType {
   Temporary
 }
 
-interface Panel extends CommonMethod<Panel> {
+export declare class PanelExtend<T> extends PanelAttribute<T> {
+}
+
+interface Panel extends PanelAttribute<Panel> {
   (show: boolean): Panel;
+}
 
-  mode(value: PanelMode): Panel;
+declare class PanelAttribute<T> extends CommonMethod<T> {
+  mode(value: PanelMode): T;
 
-  type(value: PanelType): Panel;
+  type(value: PanelType): T;
 
-  dragBar(value: boolean): Panel;
+  dragBar(value: boolean): T;
 
-  fullHeight(value: number | string): Panel;
+  fullHeight(value: number | string): T;
 
-  halfHeight(value: number | string): Panel;
+  halfHeight(value: number | string): T;
 
-  miniHeight(value: number | string): Panel;
+  miniHeight(value: number | string): T;
 
-  show(value: boolean): Panel;
+  show(value: boolean): T;
 
-  onChange(event: (width: number, height: number, mode: PanelMode) => void): Panel;
+  onChange(event: (width: number, height: number, mode: PanelMode) => void): T;
 }
 
 export declare const PanelInterface: Panel;
diff --git a/api/@internal/component/ets/path.d.ts b/api/@internal/component/ets/path.d.ts
index dc60b68e7ebedbd13bffc8a4cade48fc8bab48e7..33c4a2cf73fb755fb465d8d608552231860c4791 100644
--- a/api/@internal/component/ets/path.d.ts
+++ b/api/@internal/component/ets/path.d.ts
@@ -15,11 +15,16 @@
 
 import {CommonShapeMethod} from "./common";
 
-interface Path extends CommonShapeMethod<Path> {
+export declare class PathExtend<T> extends PathAttribute<T> {
+}
+
+interface Path extends PathAttribute<Path> {
   new (value?: { width?: number | string, height?: number | string, commands?: string }): Path;
   (value?: { width?: number | string, height?: number | string, commands?: string }): Path;
+}
 
-  commands(value: string): Path;
+declare class PathAttribute<T> extends CommonShapeMethod<T> {
+  commands(value: string): T;
 }
 
 export declare const PathInterface: Path;
diff --git a/api/@internal/component/ets/piece.d.ts b/api/@internal/component/ets/piece.d.ts
index 8eeda1b7d98fdb98dcd8b7fdb85b69e854af4db3..6ca273747bf1ca44cf3fde9184be4a8e95e9e738 100644
--- a/api/@internal/component/ets/piece.d.ts
+++ b/api/@internal/component/ets/piece.d.ts
@@ -20,9 +20,15 @@ export declare enum IconPosition {
   End
 }
 
-interface Piece extends CommonMethod<Piece> {
+export declare class PieceExtend<T> extends PieceAttribute<T> {
+}
+
+interface Piece extends PieceAttribute<Piece> {
   (options?: {content: string, icon?: string}): Piece;
-  iconPosition(value: IconPosition): Piece;
+}
+
+declare class PieceAttribute<T> extends CommonMethod<T> {
+  iconPosition(value: IconPosition): T;
 }
 
 export declare const PieceInterface: Piece;
\ No newline at end of file
diff --git a/api/@internal/component/ets/polygon.d.ts b/api/@internal/component/ets/polygon.d.ts
index 05e5af8bf9966a93327595c259e1698607116203..208f8c3b0710d267b7cf0a3b4f40066a1e2f2d76 100644
--- a/api/@internal/component/ets/polygon.d.ts
+++ b/api/@internal/component/ets/polygon.d.ts
@@ -1,24 +1,30 @@
-/*
-  * Copyright (c) 2021 Huawei Device Co., Ltd.
-  * Licensed under the Apache License, Version 2.0 (the "License");
-  * you may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at
-  *
-  *     http://www.apache.org/licenses/LICENSE-2.0
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  */
-
-import {CommonShapeMethod} from "./common";
-
-interface Polygon extends CommonShapeMethod<Polygon> {
-    (): Polygon;
-    (value?: { width?: string | number, height?: string | number }): Polygon;
-    points(value: Array<any>): Polygon;
-}
-
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonShapeMethod} from "./common";
+
+export declare class PolygonExtend<T> extends PolygonAttribute<T> {
+}
+
+interface Polygon extends PolygonAttribute<Polygon> {
+    (): Polygon;
+    (value?: { width?: string | number, height?: string | number }): Polygon;
+}
+
+declare class PolygonAttribute<T> extends CommonShapeMethod<T> {
+    points(value: Array<any>): T;
+}
+
 export declare const PolygonInterface: Polygon;
\ No newline at end of file
diff --git a/api/@internal/component/ets/polyline.d.ts b/api/@internal/component/ets/polyline.d.ts
index e0b886ac5a5913d6bd205b4fbfe0d5917a17638a..774ea51443de26732910d46f29c32a79e1e774bf 100644
--- a/api/@internal/component/ets/polyline.d.ts
+++ b/api/@internal/component/ets/polyline.d.ts
@@ -1,24 +1,30 @@
-/*
-  * Copyright (c) 2021 Huawei Device Co., Ltd.
-  * Licensed under the Apache License, Version 2.0 (the "License");
-  * you may not use this file except in compliance with the License.
-  * You may obtain a copy of the License at
-  *
-  *     http://www.apache.org/licenses/LICENSE-2.0
-  *
-  * Unless required by applicable law or agreed to in writing, software
-  * distributed under the License is distributed on an "AS IS" BASIS,
-  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  * See the License for the specific language governing permissions and
-  * limitations under the License.
-  */
-
-import {CommonShapeMethod} from "./common";
-
-interface Polyline extends CommonShapeMethod<Polyline> {
-    (): Polyline;
-    (value?: { width?: string | number, height?: string | number }): Polyline;
-    points(value: Array<any>): Polyline;
-}
-
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonShapeMethod} from "./common";
+
+export declare class PolylineExtend<T> extends PolylineAttribute<T> {
+}
+
+interface Polyline extends PolylineAttribute<Polyline> {
+  (): Polyline;
+  (value?: { width?: string | number, height?: string | number }): Polyline;
+}
+
+declare class PolylineAttribute<T> extends CommonShapeMethod<T> {
+  points(value: Array<any>): T;
+}
+
 export declare const PolylineInterface: Polyline;
\ No newline at end of file
diff --git a/api/@internal/component/ets/progress.d.ts b/api/@internal/component/ets/progress.d.ts
index e936c3ae25f80107292c2fdad840ab34ab8217ad..55ffb6546e95cc591f48b2bb19c571fe693ef529 100644
--- a/api/@internal/component/ets/progress.d.ts
+++ b/api/@internal/component/ets/progress.d.ts
@@ -22,11 +22,17 @@ export declare enum ProgressStyle {
     Circular,
 }
 
-interface Progress extends CommonMethod<Progress> {
-    (object: { value: number, total?: number, style?: ProgressStyle }): Progress;
-    value(value: number): Progress;
-    color(value: Color): Progress;
-    cricularStyle(value: { strokeWidth?: number, scaleCount?: number, scaleWidth?: number }): Progress;
+export declare class ProgressExtend<T> extends ProgressAttribute<T> {
+}
+
+interface Progress extends ProgressAttribute<Progress> {
+  (object: { value: number, total?: number, style?: ProgressStyle }): Progress;
+}
+
+declare class ProgressAttribute<T> extends CommonMethod<T> {
+  value(value: number): T;
+  color(value: Color): T;
+  cricularStyle(value: { strokeWidth?: number, scaleCount?: number, scaleWidth?: number }): T;
 }
 
 export declare const ProgressInterface: Progress;
\ No newline at end of file
diff --git a/api/@internal/component/ets/qrcode.d.ts b/api/@internal/component/ets/qrcode.d.ts
index bed92f321d0f4921a6c844f419901111b863ed42..4c7a834ff6b8c00e4712ff8b352dcacfe0ad5244 100644
--- a/api/@internal/component/ets/qrcode.d.ts
+++ b/api/@internal/component/ets/qrcode.d.ts
@@ -15,11 +15,16 @@
 
 import {CommonMethod, Color, Resource} from "./common";
 
-interface QRCode extends CommonMethod<QRCode> {
+export declare class QRCodeExtend<T> extends QRCodeAttribute<T> {
+}
+
+interface QRCode extends QRCodeAttribute<QRCode> {
   (value: string): QRCode;
+}
 
-  color(value: Color | number | string | Resource): QRCode;
-  backgroundColor(value: Color | number | string | Resource): QRCode;
+declare class QRCodeAttribute<T> extends CommonMethod<T> {
+  color(value: Color | number | string | Resource): T;
+  backgroundColor(value: Color | number | string | Resource): T;
 }
 
 export declare const QRCodeInterface: QRCode;
diff --git a/api/@internal/component/ets/radio.d.ts b/api/@internal/component/ets/radio.d.ts
index 0c47a28ea3b3b91258dc82f99edf78affebce145..ae00f19993a6e11d42526d30be9a6399a52f3668 100644
--- a/api/@internal/component/ets/radio.d.ts
+++ b/api/@internal/component/ets/radio.d.ts
@@ -15,10 +15,16 @@
 
 import {CommonMethod} from "./common";
 
-interface Radio extends CommonMethod<Radio> {
-    (options: {value: string}): Radio;
-    checked(value: boolean): Radio;
-    onChange(callback: (isChecked: boolean) => void): Radio;
+export declare class RadioExtend<T> extends RadioAttribute<T> {
+}
+
+interface Radio extends RadioAttribute<Radio> {
+  (options: {value: string}): Radio;
+}
+
+declare class RadioAttribute<T> extends CommonMethod<T> {
+  checked(value: boolean): T;
+  onChange(callback: (isChecked: boolean) => void): T;
 }
 
 export declare const RadioInterface: Radio;
diff --git a/api/@internal/component/ets/rating.d.ts b/api/@internal/component/ets/rating.d.ts
index 4c56e0107016f16975e27fbb93e7e7ec68534c3f..293841bce72b3d752fb99e5b927276fe964295d0 100644
--- a/api/@internal/component/ets/rating.d.ts
+++ b/api/@internal/component/ets/rating.d.ts
@@ -1,26 +1,32 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod} from "./common";
-
-interface Rating extends CommonMethod<Rating> {
-  (options?: {rating: number, indicator?: boolean}): Rating;
-  stars(value: number): Rating;
-  stepSize(value: number): Rating;
-  starStyle(value: {backgroundUri: string, foregroundUri: string, secondaryUri?: string}): Rating;
-  onChange(callback:(value: number) => void): Rating;
-}
-
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonMethod} from "./common";
+
+export declare class RatingExtend<T> extends RatingAttribute<T> {
+}
+
+interface Rating extends RatingAttribute<Rating> {
+  (options?: {rating: number, indicator?: boolean}): Rating;
+}
+
+declare class RatingAttribute<T> extends CommonMethod<T> {
+  stars(value: number): T;
+  stepSize(value: number): T;
+  starStyle(value: {backgroundUri: string, foregroundUri: string, secondaryUri?: string}): T;
+  onChange(callback:(value: number) => void): T;
+}
+
 export declare const RatingInterface: Rating;
\ No newline at end of file
diff --git a/api/@internal/component/ets/rect.d.ts b/api/@internal/component/ets/rect.d.ts
index 683220de42ac3345b26115f2fb2473b813718627..ecc1a5a8fd3fe7af24f23062381a13db9f5fe8c6 100644
--- a/api/@internal/component/ets/rect.d.ts
+++ b/api/@internal/component/ets/rect.d.ts
@@ -15,7 +15,10 @@
 
 import {CommonShapeMethod} from "./common";
 
-interface Rect extends CommonShapeMethod<Rect> {
+export declare class RectExtend<T> extends RectAttribute<T> {
+}
+
+interface Rect extends RectAttribute<Rect> {
   new (value?: { width?: number | string, height?: number | string, radius?: number | string | Array<any> } |
     {
       width?: number | string, height?: number | string, radiusWidth?: number | string,
@@ -26,12 +29,14 @@ interface Rect extends CommonShapeMethod<Rect> {
       width?: number | string, height?: number | string, radiusWidth?: number | string,
       radiusHeight?: number | string
     }): Rect;
+}
 
-  radiusWidth(value: number | string): Rect;
+declare class RectAttribute<T> extends CommonShapeMethod<T> {
+  radiusWidth(value: number | string): T;
 
-  radiusHeight(value: number | string): Rect;
+  radiusHeight(value: number | string): T;
 
-  radius(value: number | string | Array<any>): Rect;
+  radius(value: number | string | Array<any>): T;
 }
 
 export declare const RectInterface: Rect;
diff --git a/api/@internal/component/ets/row.d.ts b/api/@internal/component/ets/row.d.ts
index 4a8f55faa5e2ae4d7a98e2234aa1fb6dcdac10c7..3882b1dc3cc5566a56a35bf2f357e1726383a9ec 100644
--- a/api/@internal/component/ets/row.d.ts
+++ b/api/@internal/component/ets/row.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod, VerticalAlign, VerticalAlignDeclaration} from "./common";
 
-interface Row extends CommonMethod<Row> {
+export declare class RowExtend<T> extends RowAttribute<T> {
+}
+
+interface Row extends RowAttribute<Row> {
   (value?: { space?: string | number, useAlign?: VerticalAlignDeclaration }): Row;
+}
 
-  alignItems(value: VerticalAlign): Row;
+declare class RowAttribute<T> extends CommonMethod<T> {
+  alignItems(value: VerticalAlign): T;
 }
 
 export declare const RowInterface: Row;
diff --git a/api/@internal/component/ets/row_split.d.ts b/api/@internal/component/ets/row_split.d.ts
index 4e0c1738519289f43fccd2e2300fbfc14e98a0bd..6bd57a89b2399dd0f8e9120aa5505f180f34bcc9 100644
--- a/api/@internal/component/ets/row_split.d.ts
+++ b/api/@internal/component/ets/row_split.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod} from "./common";
 
-interface RowSplit extends CommonMethod<RowSplit> {
+export declare class RowSplitExtend<T> extends RowSplitAttribute<T> {
+}
+
+interface RowSplit extends RowSplitAttribute<RowSplit> {
   (): RowSplit;
+}
 
-  resizeable(value: boolean): RowSplit;
+declare class RowSplitAttribute<T> extends CommonMethod<T> {
+  resizeable(value: boolean): T;
 }
 
 export declare const RowSplitInterface: RowSplit;
diff --git a/api/@internal/component/ets/scroll.d.ts b/api/@internal/component/ets/scroll.d.ts
index f2f3b094688fe140e525fae52f6c61830b0d6214..2550e6eb2bb737529eaa18c593145c8d3b8575b2 100644
--- a/api/@internal/component/ets/scroll.d.ts
+++ b/api/@internal/component/ets/scroll.d.ts
@@ -37,24 +37,29 @@ export declare class Scroller {
   scrollToIndex(value: number);
 }
 
-interface Scroll extends CommonMethod<Scroll> {
+export declare class ScrollExtend<T> extends ScrollAttribute<T> {
+}
+
+interface Scroll extends ScrollAttribute<Scroll> {
   (scroller?: Scroller): Scroll;
+}
 
-  scrollable(value: ScrollDirection): Scroll;
+declare class ScrollAttribute<T> extends CommonMethod<T> {
+  scrollable(value: ScrollDirection): T;
 
-  onScroll(event: (xOffset: number, yOffset: number) => void): Scroll;
+  onScroll(event: (xOffset: number, yOffset: number) => void): T;
 
-  onScrollEdge(event: (side: Edge) => void): Scroll;
+  onScrollEdge(event: (side: Edge) => void): T;
 
-  onScrollEnd(event: () => void): Scroll;
+  onScrollEnd(event: () => void): T;
 
-  scrollBar(barState: BarState): Scroll;
+  scrollBar(barState: BarState): T;
 
-  scrollBarColor(color: Color | number | string): Scroll;
+  scrollBarColor(color: Color | number | string): T;
 
-  scrollBarWidth(value: number | string): Scroll;
+  scrollBarWidth(value: number | string): T;
 
-  edgeEffect(edgeEffect: EdgeEffect): Scroll;
+  edgeEffect(edgeEffect: EdgeEffect): T;
 }
 
 export declare const ScrollInterface: Scroll;
diff --git a/api/@internal/component/ets/shape.d.ts b/api/@internal/component/ets/shape.d.ts
index ef4ff4efa8c726fa053be04370c1be3641dc9096..5a6cb0a2be9e4bc65333610b9fbc4833d10483eb 100644
--- a/api/@internal/component/ets/shape.d.ts
+++ b/api/@internal/component/ets/shape.d.ts
@@ -13,37 +13,42 @@
  * limitations under the License.
  */
 
-import {CommonMethod, Color, LineCapStyle, LineJoinStyle, Resource} from "./common";
+import {CommonMethod, Color, LineCapStyle, LineJoinStyle, Resource, PixelMap} from "./common";
 
-interface Shape extends CommonMethod<Shape> {
-  (): Shape;
+export declare class ShapeExtend<T> extends ShapeAttribute<T> {
+}
+
+interface Shape extends ShapeAttribute<Shape> {
+  (value?: PixelMap): Shape;
+}
 
+declare class ShapeAttribute<T> extends CommonMethod<T> {
   viewPort(value: {
     x?: number | string, y?: number | string,
     width?: number | string, height?: number | string
-  }): Shape;
+  }): T;
 
-  stroke(value: Color | number | string | Resource): Shape;
+  stroke(value: Color | number | string | Resource): T;
 
-  fill(value: Color | number | string | Resource): Shape;
+  fill(value: Color | number | string | Resource): T;
 
-  strokeDashOffset(value: number | string): Shape;
+  strokeDashOffset(value: number | string): T;
 
-  strokeDashArray(value: Array<any>): Shape;
+  strokeDashArray(value: Array<any>): T;
 
-  strokeLineCap(value: LineCapStyle): Shape;
+  strokeLineCap(value: LineCapStyle): T;
 
-  strokeLineJoin(value: LineJoinStyle): Shape;
+  strokeLineJoin(value: LineJoinStyle): T;
 
-  strokeMiterLimit(value: number | string): Shape;
+  strokeMiterLimit(value: number | string): T;
 
-  strokeOpacity(value: number | string | Resource): Shape;
+  strokeOpacity(value: number | string | Resource): T;
 
-  fillOpacity(value: number | string | Resource): Shape;
+  fillOpacity(value: number | string | Resource): T;
 
-  strokeWidth(value: number | string): Shape;
+  strokeWidth(value: number | string): T;
 
-  antiAlias(value: boolean): Shape;
+  antiAlias(value: boolean): T;
 }
 
 export declare const ShapeInterface: Shape;
diff --git a/api/@internal/component/ets/slider.d.ts b/api/@internal/component/ets/slider.d.ts
index cc45a3aaeded771a3a8b9b5ddf5e0401d4eab4b4..bee0476cd00ddbcda6e41469b881e3d64e417af6 100644
--- a/api/@internal/component/ets/slider.d.ts
+++ b/api/@internal/component/ets/slider.d.ts
@@ -1,41 +1,47 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import {CommonMethod, Color} from "./common";
-
-export declare enum SliderStyle {
-  OUTSET = 0,
-  INSET,
-}
-
-export declare enum SliderChangeMode {
-  BEGIN = 0,
-  MOVING,
-  END,
-}
-
-interface Slider extends CommonMethod<Slider> {
-  (options?: {value?: number, min?: number, max?: number, step?: number, style?: SliderStyle}): Slider;
-  blockColor(value: Color): Slider;
-  trackColor(value: Color): Slider;
-  selectedColor(value: Color): Slider;
-  minLabel(value: string): Slider;
-  maxLabel(value: string): Slider;
-  showSteps(value: boolean): Slider;
-  showTips(value: boolean): Slider;
-  onChange(callback:(value: number, mode: SliderChangeMode) => void): Slider;
-}
-
-export declare const SliderInterface: Slider;
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {CommonMethod, Color} from "./common";
+
+export declare enum SliderStyle {
+  OUTSET = 0,
+  INSET,
+}
+
+export declare enum SliderChangeMode {
+  BEGIN = 0,
+  MOVING,
+  END,
+}
+
+export declare class SliderExtend<T> extends SliderAttribute<T> {
+}
+
+interface Slider extends SliderAttribute<Slider> {
+  (options?: {value?: number, min?: number, max?: number, step?: number, style?: SliderStyle}): Slider;
+}
+
+declare class SliderAttribute<T> extends CommonMethod<T> {
+  blockColor(value: Color): T;
+  trackColor(value: Color): T;
+  selectedColor(value: Color): T;
+  minLabel(value: string): T;
+  maxLabel(value: string): T;
+  showSteps(value: boolean): T;
+  showTips(value: boolean): T;
+  onChange(callback:(value: number, mode: SliderChangeMode) => void): T;
+}
+
+export declare const SliderInterface: Slider;
diff --git a/api/@internal/component/ets/span.d.ts b/api/@internal/component/ets/span.d.ts
index a2520d802641de99ac79b1fba35bcd0b19c70967..bee0d93d093a8b8fcdc8586e11db9ac29b9e3f37 100644
--- a/api/@internal/component/ets/span.d.ts
+++ b/api/@internal/component/ets/span.d.ts
@@ -16,24 +16,29 @@
 import {CommonMethod, Color, Resource} from "./common";
 import {FontStyle, FontWeight, TextDecorationType, TextCase} from "./text";
 
-interface Span extends CommonMethod<Span> {
+export declare class SpanExtend<T> extends SpanAttribute<T> {
+}
+
+interface Span extends SpanAttribute<Span> {
   (value: string | Resource): Span;
+}
 
-  fontColor(value: Color | number | string | Resource): Span;
+declare class SpanAttribute<T> extends CommonMethod<T> {
+  fontColor(value: Color | number | string | Resource): T;
 
-  fontSize(value: number | string | Resource): Span;
+  fontSize(value: number | string | Resource): T;
 
-  fontStyle(value: FontStyle): Span;
+  fontStyle(value: FontStyle): T;
 
-  fontWeight(value: number | FontWeight | string): Span;
+  fontWeight(value: number | FontWeight | string): T;
 
-  fontFamily(value: string | Resource): Span;
+  fontFamily(value: string | Resource): T;
 
-  decoration(value: { type: TextDecorationType, color?: Color | number | string | Resource}): Span;
+  decoration(value: { type: TextDecorationType, color?: Color | number | string | Resource}): T;
 
-  letterSpacing(value: number | string): Span;
+  letterSpacing(value: number | string): T;
 
-  textCase(value: TextCase): Span;
+  textCase(value: TextCase): T;
 }
 
 export declare const SpanInterface: Span;
diff --git a/api/@internal/component/ets/stack.d.ts b/api/@internal/component/ets/stack.d.ts
index c470f7d802073d9043e3988bc9cb57f5a218dc43..6bbe22c24252133f0b6fb4f0bc406cd319ae67f1 100644
--- a/api/@internal/component/ets/stack.d.ts
+++ b/api/@internal/component/ets/stack.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod, Alignment} from "./common";
 
-interface Stack extends CommonMethod<Stack> {
+export declare class StackExtend<T> extends StackAttribute<T> {
+}
+
+interface Stack extends StackAttribute<Stack> {
   (value?: { alignContent?: Alignment }): Stack;
+}
 
-  alignContent(value: Alignment): Stack;
+declare class StackAttribute<T> extends CommonMethod<T> {
+  alignContent(value: Alignment): T;
 }
 
 export declare const StackInterface: Stack;
diff --git a/api/@internal/component/ets/stateManagement.d.ts b/api/@internal/component/ets/stateManagement.d.ts
index 1b990ddf1a405171d64113f1d86946c2c5d4bbd7..7a4a27511a3155166ddafec613bf58ec84be5330 100644
--- a/api/@internal/component/ets/stateManagement.d.ts
+++ b/api/@internal/component/ets/stateManagement.d.ts
@@ -44,26 +44,28 @@ declare class SyncedPropertyOneWay<T> extends SubscribedAbstractProperty<T> impl
 }
 
 export declare class AppStorage {
-  static GetOrCreate(): AppStorage;
-  static Get(): AppStorage | undefined;
-  link<T>(propName: string): SubscribedAbstractProperty<T> | undefined;
-  setAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T>;
-  prop<S>(propName: string): SubscribedAbstractProperty<S> | undefined;
-  setAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S>;
-  has(propName: string): boolean;
-  get<T>(propName: string): T | undefined;
-  set<T>(propName: string, newValue: T): boolean;
-  setOrCreate<T>(propName: string, newValue: T): void;
-  delete(propName: string): boolean;
-  keys(): IterableIterator<string>;
-  protected clear(): boolean;
-  getOrCreatePersistentStorage(): PersistentStorage;
+  static Link<T>(propName: string): SubscribedAbstractProperty<T> | undefined;
+  static SetAndLink<T>(propName: string, defaultValue: T): SubscribedAbstractProperty<T>;
+  static Prop<S>(propName: string): SubscribedAbstractProperty<S> | undefined;
+  static SetAndProp<S>(propName: string, defaultValue: S): SubscribedAbstractProperty<S>;
+  static Has(propName: string): boolean;
+  static Get<T>(propName: string): T | undefined;
+  static Set<T>(propName: string, newValue: T): boolean;
+  static SetOrCreate<T>(propName: string, newValue: T): void;
+  static Delete(propName: string): boolean;
+  static Keys(): IterableIterator<string>;
+  static staticClear(): boolean;
+  static IsMutable(propName: string): boolean;
+  static Size(): number;
 }
 
 export declare class Environment {
   constructor();
-  static Prop(key:string, defaultValue:any): boolean;
-  static Props(props: Array<{key: string, defaultValue: any}>): void;
+  static EnvProp<S>(key: string, value: S): boolean;
+  static EnvProps(props: {
+    key: string;
+    defaultValue: any;
+  }[]): void;
   static Keys(): Array<string>;
 }
 
@@ -79,10 +81,13 @@ export declare enum LayoutDirection {
 
 export declare class PersistentStorage {
   constructor(appStorage: AppStorage, storage: Storage);
-  link(propName: string): void;
-  links(props: Array<string>): void;
-  unlink(propName: string): void;
-  keys(): IterableIterator<string>;
+  static PersistProp<T>(key: string, defaultValue: T): void;
+  static DeleteProp(key: string): void;
+  static PersistProps(properties: {
+      key: string;
+      defaultValue: any;
+  }[]): void;
+  static Keys(): Array<string>;
 }
 
 export declare class Storage {
diff --git a/api/@internal/component/ets/swiper.d.ts b/api/@internal/component/ets/swiper.d.ts
index 45e804e87b95621f37d40a782fd440fbaaa23c43..22830c7721a7bcab79d50621dbea1b358f29d6b2 100644
--- a/api/@internal/component/ets/swiper.d.ts
+++ b/api/@internal/component/ets/swiper.d.ts
@@ -23,26 +23,38 @@ export declare class SwiperController {
   showPrevious();
 }
 
-interface Swiper extends CommonMethod<Swiper> {
+export declare enum SwiperDisplayMode {
+  Stretch,
+  AutoLinear
+}
+
+export declare class SwiperExtend<T> extends SwiperAttribute<T> {
+}
+
+interface Swiper extends SwiperAttribute<Swiper> {
   (controller?: SwiperController): Swiper;
+}
+
+declare class SwiperAttribute<T> extends CommonMethod<T> {
+  index(value: number): T;
 
-  index(value: number): Swiper;
+  autoPlay(value: boolean): T;
 
-  autoPlay(value: boolean): Swiper;
+  interval(value: number): T;
 
-  interval(value: number): Swiper;
+  indicator(value: boolean): T;
 
-  indicator(value: boolean): Swiper;
+  loop(value: boolean): T;
 
-  loop(value: boolean): Swiper;
+  duration(value: number): T;
 
-  duration(value: number): Swiper;
+  vertical(value: boolean): T;
 
-  vertical(value: boolean): Swiper;
+  itemSpace(value: number | string): T;
 
-  itemSpace(value: number | string): Swiper;
+  displayMode(value: SwiperDisplayMode): T;
 
-  onChange(event: (index: number) => void): Swiper;
+  onChange(event: (index: number) => void): T;
 }
 
 export declare const SwiperInterface: Swiper;
diff --git a/api/@internal/component/ets/tab_content.d.ts b/api/@internal/component/ets/tab_content.d.ts
index afbc0cbd543a7ac1eb6011104429411a7cdae5dc..0990ad2dafe7f33240eecbf634fad74987b9f923 100644
--- a/api/@internal/component/ets/tab_content.d.ts
+++ b/api/@internal/component/ets/tab_content.d.ts
@@ -15,10 +15,15 @@
 
 import {CommonMethod} from "./common";
 
-interface TabContent extends CommonMethod<TabContent> {
+export declare class TabContentExtend<T> extends TabContentAttribute<T> {
+}
+
+interface TabContent extends TabContentAttribute<TabContent> {
   (): TabContent;
+}
 
-  tabBar(value: string | { icon?: string, text?: string }): TabContent;
+declare class TabContentAttribute<T> extends CommonMethod<T> {
+  tabBar(value: string | { icon?: string, text?: string }): T;
 }
 
 export declare const TabContentInterface: TabContent;
diff --git a/api/@internal/component/ets/tabs.d.ts b/api/@internal/component/ets/tabs.d.ts
index ba47d674796905fbd003e6ab575378c6ae6effb4..d72922f4de7ac4ce7342935f5b24b6f6fbb263cf 100644
--- a/api/@internal/component/ets/tabs.d.ts
+++ b/api/@internal/component/ets/tabs.d.ts
@@ -31,22 +31,27 @@ export declare class TabsController {
   changeIndex(value: number): void;
 }
 
-interface Tabs extends CommonMethod<Tabs> {
-  (value?: { barPosition?: BarPosition, initialIndex?: number, controller?: TabsController }): Tabs;
+export declare class TabsExtend<T> extends TabsAttribute<T> {
+}
+
+interface Tabs extends TabsAttribute<Tabs> {
+  (value?: { barPosition?: BarPosition, index?: number, controller?: TabsController }): Tabs;
+}
 
-  vertical(value: boolean): Tabs;
+declare class TabsAttribute<T> extends CommonMethod<T> {
+  vertical(value: boolean): T;
 
-  scrollable(value: boolean): Tabs;
+  scrollable(value: boolean): T;
 
-  barMode(value: BarMode): Tabs;
+  barMode(value: BarMode): T;
 
-  barWidth(value: number): Tabs;
+  barWidth(value: number): T;
 
-  barHeight(value: number): Tabs;
+  barHeight(value: number): T;
 
-  animationDuration(value: number): Tabs;
+  animationDuration(value: number): T;
 
-  onChange(event: (index: number) => void): Tabs;
+  onChange(event: (index: number) => void): T;
 }
 
 export declare const TabsInterface: Tabs;
diff --git a/api/@internal/component/ets/text.d.ts b/api/@internal/component/ets/text.d.ts
index 65efdfde556d29d532f96a9d6a361354457d8ecf..a30dfa647c202737a8e6462b3f56339996e44a8d 100644
--- a/api/@internal/component/ets/text.d.ts
+++ b/api/@internal/component/ets/text.d.ts
@@ -37,7 +37,8 @@ export declare enum TextAlign {
 
 export declare enum TextOverflow {
   Clip,
-  Ellipsis
+  Ellipsis,
+  None
 }
 
 export declare enum TextDecorationType {
@@ -53,38 +54,43 @@ export declare enum TextCase {
   UpperCase
 }
 
-interface Text extends CommonMethod<Text> {
+export declare class TextExtend<T> extends TextAttribute<T> {
+}
+
+interface Text extends TextAttribute<Text> {
   (content?: string | Resource): Text;
+}
 
-  fontColor(value: Color | number | string | Resource): Text;
+declare class TextAttribute<T> extends CommonMethod<T> {
+  fontColor(value: Color | number | string | Resource): T;
 
-  fontSize(value: number | string | Resource): Text;
+  fontSize(value: number | string | Resource): T;
 
-  minFontSize(value: number | string | Resource): Text;
+  minFontSize(value: number | string | Resource): T;
 
-  maxFontSize(value: number | string | Resource): Text;
+  maxFontSize(value: number | string | Resource): T;
 
-  fontStyle(value: FontStyle): Text;
+  fontStyle(value: FontStyle): T;
 
-  fontWeight(value: number | FontWeight | string): Text;
+  fontWeight(value: number | FontWeight | string): T;
 
-  textAlign(value: TextAlign): Text;
+  textAlign(value: TextAlign): T;
 
-  lineHeight(value: number | string): Text;
+  lineHeight(value: number | string | Resource): T;
 
-  textOverflow(value: { overflow: TextOverflow }): Text;
+  textOverflow(value: { overflow: TextOverflow }): T;
 
-  fontFamily(value: string | Resource): Text;
+  fontFamily(value: string | Resource): T;
 
-  maxLines(value: number): Text;
+  maxLines(value: number): T;
 
-  decoration(value: { type: TextDecorationType, color?: Color | number | string | Resource}): Text;
+  decoration(value: { type: TextDecorationType, color?: Color | number | string | Resource }): T;
 
-  letterSpacing(value: number | string): Text;
+  letterSpacing(value: number | string): T;
 
-  textCase(value: TextCase): Text;
+  textCase(value: TextCase): T;
 
-  baselineOffset(value: number | string): Text;
+  baselineOffset(value: number | string): T;
 }
 
 export declare const TextInterface: Text;
diff --git a/api/@system.cipher.d.ts b/api/@internal/component/ets/textPicker.d.ts
old mode 100755
new mode 100644
similarity index 47%
rename from api/@system.cipher.d.ts
rename to api/@internal/component/ets/textPicker.d.ts
index 3fa74e43c5d5cbe312829edd2e5b2980086fa0a9..c04f44c0a3788e2050511be742e5477061838f7b
--- a/api/@system.cipher.d.ts
+++ b/api/@internal/component/ets/textPicker.d.ts
@@ -13,31 +13,26 @@
  * limitations under the License.
  */
 
-export interface CipherResponse {
-  text: string;
+import {CommonMethod} from "./common";
+
+export declare enum PickerStyle {
+  INLINE = 0,
+  BLOCK,
+  FADE,
 }
-export interface CipherRsaOptions {
-  action: string;
-  text: string;
-  key: string;
-  transformation?: string;
-  success: (data: CipherResponse) => void;
-  fail: (data: string, code: number) => void;
-  complete: () => void;
+
+export declare class TextPickerExtend<T> extends TextPickerAttribute<T> {
 }
-export interface CipherAesOptions {
-  action: string;
-  text: string;
-  key: string;
-  transformation?: string;
-  iv?: string;
-  ivOffset?: string;
-  ivLen?: string;
-  success: (data: CipherResponse) => void;
-  fail: (data: string, code: number) => void;
-  complete: () => void;
+
+interface TextPicker extends TextPickerAttribute<TextPicker> {
+  (options?: {range: string[], value?: string, selected?: number, loop?: boolean , style?: PickerStyle}): TextPicker;
 }
-export default class Cipher {
-  static rsa(options: CipherRsaOptions): void;
-  static aes(options: CipherAesOptions): void;
+
+declare class TextPickerAttribute<T> extends CommonMethod<T> {
+  defaultPickerItemHeight(value: number): T;
+  onAccept(callback: (value: string, index: number) => void): T;
+  onCancel(callback: () => void): T;
+  onChange(callback: (value: string, index: number) => void): T;
 }
+
+export declare const TextPickerInterface: TextPicker;
diff --git a/api/@internal/component/ets/textarea.d.ts b/api/@internal/component/ets/textarea.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..91fb656edfc29b4445c8489a4a137ab687a54de0
--- /dev/null
+++ b/api/@internal/component/ets/textarea.d.ts
@@ -0,0 +1,38 @@
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod, Color, Resource} from "./common";
+import {TextAlign, FontWeight, FontStyle} from "./text";
+
+export declare class TextAreaExtend<T> extends TextAreaAttribute<T> {
+}
+
+interface TextArea extends TextAreaAttribute<TextArea> {
+  (options?: {
+      placeholder: string;
+      text: string;
+  }): TextArea;
+}
+
+declare class TextAreaAttribute<T> extends CommonMethod<T> {
+  placeholderColor(value: Color): T;
+  placeholderFont(value:{ size: number, weight: FontWeight, fontFamily: string | Resource, style: FontStyle }): T;
+  textAlign(value: TextAlign): T;
+  caretColor(value: Color): T;
+  correction(value: boolean): T;
+  onChange(callback: (value: string) => void): T;
+}
+
+export declare const TextAreaInterface: TextArea;
\ No newline at end of file
diff --git a/api/@internal/component/ets/textinput.d.ts b/api/@internal/component/ets/textinput.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..60a367e5d342cc7f0f84823ab6d5d264e7e4381a
--- /dev/null
+++ b/api/@internal/component/ets/textinput.d.ts
@@ -0,0 +1,68 @@
+/*
+  * Copyright (c) 2021 Huawei Device Co., Ltd.
+  * Licensed under the Apache License, Version 2.0 (the "License");
+  * you may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at
+  *
+  *     http://www.apache.org/licenses/LICENSE-2.0
+  *
+  * Unless required by applicable law or agreed to in writing, software
+  * distributed under the License is distributed on an "AS IS" BASIS,
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  */
+
+import {CommonMethod, Color, Resource} from "./common";
+import {FontWeight, FontStyle} from "./text";
+
+export declare enum TextInputType {
+  BEGIN = 0,
+  TEXT = BEGIN,
+  MULTILINE = 1,
+  NUMBER = 2,
+  PHONE = 3,
+  DATETIME = 4,
+  EMAIL_ADDRESS = 5,
+  URL = 6,
+  VISIBLE_PASSWORD = 7,
+  END
+}
+
+export declare enum TextInputAction {
+  BEGIN = 0,
+  UNSPECIFIED = BEGIN,
+  NONE = 1,
+  GO = 2,
+  SEARCH = 3,
+  SEND = 4,
+  NEXT = 5,
+  DONE = 6,
+  PREVIOUS = 7,
+  END = PREVIOUS
+}
+
+export declare class TextInputExtend<T> extends TextInputAttribute<T> {
+}
+
+interface TextInput extends TextInputAttribute<TextInput> {
+  (options?: {
+      placeholder: string;
+      text: string;
+  }): TextInput;
+}
+
+declare class TextInputAttribute<T> extends CommonMethod<T> {
+  textInputType(value: TextInputType): T;
+  placeholderColor(value: Color): T;
+  placeholderFont(value: {size: number, weight: FontWeight, fontFamily: string | Resource, style: FontStyle}): T;
+  textInputAction(value: TextInputAction): T;
+  inputFilter(value: boolean): T;
+  caretColor(value: Color): T;
+  correction(value: boolean): T;
+  onEditChanged(callback: (isEditing: boolean) => void): T;
+  onSubmit(callback: (enterKey: TextInputAction) => void): T;
+  onChange(callback: (value: string) => void): T;
+}
+
+export declare const TextInputInterface: TextInput;
diff --git a/api/@internal/component/ets/toggle.d.ts b/api/@internal/component/ets/toggle.d.ts
index c8bba85406e4fe1219cb1fded7c2d4af4f6e2f90..1840bcdacdd505f38f931b0ea74ae846ce7363bf 100644
--- a/api/@internal/component/ets/toggle.d.ts
+++ b/api/@internal/component/ets/toggle.d.ts
@@ -21,11 +21,17 @@ export declare enum ToggleType {
   Button
 }
 
-interface Toggle extends CommonMethod<Toggle> {
-  (options?: {type?: ToggleType, isOn?: boolean}): Toggle;
-  onChange(callback: (isOn: boolean) => void): Toggle;
-  selectedColor(value: Color): Toggle;
-  swithPointStyle(color: Color): Toggle;
+export declare class ToggleExtend<T> extends ToggleAttribute<T> {
+}
+
+interface Toggle extends ToggleAttribute<Toggle> {
+  (options?: {type: ToggleType, isOn?: boolean}): Toggle;
+}
+
+declare class ToggleAttribute<T> extends CommonMethod<T> {
+  onChange(callback: (isOn: boolean) => void): T;
+  selectedColor(value: Color): T;
+  swithPointStyle(color: Color): T;
 }
 
 export declare const ToggleInterface: Toggle;
diff --git a/api/@internal/component/ets/video.d.ts b/api/@internal/component/ets/video.d.ts
index 64cbd421dd855b7e644302571592793895fe551d..3eaa2b2b97a8325475133376052af3126d79c029 100644
--- a/api/@internal/component/ets/video.d.ts
+++ b/api/@internal/component/ets/video.d.ts
@@ -25,29 +25,34 @@ declare class VideoController {
   exitFullscreen();
 }
 
-interface Video extends CommonMethod<Video> {
+export declare class VideoExtend<T> extends VideoAttribute<T> {
+}
+
+interface Video extends VideoAttribute<Video> {
   (value: {
     src?: string,
     currentProgressRate?: number | string,
     previewUri?: string,
     controller?: VideoController
   }): Video;
+}
 
-  muted(value: boolean): Video;
-  autoPlay(value: boolean): Video;
-  controls(value: boolean): Video;
-  loop(value: boolean): Video;
-  objectFit(value: ImageFit): Video;
+declare class VideoAttribute<T> extends CommonMethod<T> {
+  muted(value: boolean): T;
+  autoPlay(value: boolean): T;
+  controls(value: boolean): T;
+  loop(value: boolean): T;
+  objectFit(value: ImageFit): T;
 
-  onStart(event: () => void): Video;
-  onPause(event: () => void): Video;
-  onFinish(event: () => void): Video;
-  onFullscreenChange(callback: (event?: { fullscreen: boolean }) => void): Video;
-  onPrepared(callback: (event?: { duration: number }) => void): Video;
-  onSeeking(callback: (event?: { time: number }) => void): Video;
-  onSeeked(callback: (event?: { time: number }) => void): Video;
-  onUpdate(callback: (event?: { time: number }) => void): Video;
-  onError(event: () => void): Video;
+  onStart(event: () => void): T;
+  onPause(event: () => void): T;
+  onFinish(event: () => void): T;
+  onFullscreenChange(callback: (event?: { fullscreen: boolean }) => void): T;
+  onPrepared(callback: (event?: { duration: number }) => void): T;
+  onSeeking(callback: (event?: { time: number }) => void): T;
+  onSeeked(callback: (event?: { time: number }) => void): T;
+  onUpdate(callback: (event?: { time: number }) => void): T;
+  onError(event: () => void): T;
 }
 
 export declare const VideoInterface: Video;
diff --git a/api/@ohos.ability.featureAbility.d.ts b/api/@ohos.ability.featureAbility.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..062abd922a8ab345d5404caa334a586c6f55f3e9
--- /dev/null
+++ b/api/@ohos.ability.featureAbility.d.ts
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AsyncCallback } from './basic';
+import { Want } from './ability/want';
+import { StartAbilityParameter } from './ability/startAbilityParameter';
+import { AbilityResult } from './ability/abilityResult';
+import { Context } from './app/context';
+
+/**
+ * A Feature Ability represents an ability with a UI and is designed to interact with users.
+ * @name featureAbility
+ * @since 6
+ * @sysCap AAFwk
+ * @devices phone, tablet
+ * @permission N/A
+ */
+declare namespace featureAbility {
+  /**
+   * Obtain the want sended from the source ability.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @param parameter Indicates the ability to start.
+   * @return -
+   */
+  function getWant(callback: AsyncCallback<Want>): void;
+  function getWant(): Promise<Want>;
+
+  /**
+   * Starts a new ability.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @param parameter Indicates the ability to start.
+   * @return -
+   */
+  function startAbility(parameter: StartAbilityParameter, callback: AsyncCallback<number>): void;
+  function startAbility(parameter: StartAbilityParameter): Promise<number>;
+
+  /**
+   * Obtains the application context.
+   *
+   * @return Returns the application context.
+   * @since 6
+   */
+  function getContext(): Context;
+
+  /**
+   * Starts an ability and returns the execution result when the ability is destroyed.
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   * @param parameter Indicates the ability to start.
+   * @return -
+   */
+  function startAbilityForResult(parameter: StartAbilityParameter, callback: AsyncCallback<AbilityResult>): void;
+  function startAbilityForResult(parameter: StartAbilityParameter): Promise<AbilityResult>;
+
+  /**
+   * Sets the result code and data to be returned by this Page ability to the caller
+   * and destroys this Page ability.
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   * @param parameter Indicates the result to return.
+   * @return -
+   */
+  function terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void;
+  function terminateSelfWithResult(parameter: AbilityResult): Promise<void>;
+
+  /**
+   * Destroys this Page ability.
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   * @return -
+   */
+  function terminateSelf(callback: AsyncCallback<void>): void;
+
+   /**
+   * Checks whether the main window of this ability has window focus.
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   */
+   function hasWindowFocus(callback: AsyncCallback<boolean>): void;
+   function hasWindowFocus(): Promise<boolean>;
+}
+export default featureAbility;
\ No newline at end of file
diff --git a/api/phone/app/elementname.d.ts b/api/@ohos.ability.particleAbility.d.ts
old mode 100755
new mode 100644
similarity index 46%
rename from api/phone/app/elementname.d.ts
rename to api/@ohos.ability.particleAbility.d.ts
index e0da17167a3c52a7f6cb9f2594cdbdf4de02a0ea..fda9282af1680285fb93f156d5ddec33c887fbed
--- a/api/phone/app/elementname.d.ts
+++ b/api/@ohos.ability.particleAbility.d.ts
@@ -1,55 +1,40 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Contains basic Ability information, which uniquely identifies an ability.
- * You can use this class to obtain values of the fields set in an element,
- * such as the device ID, bundle name, and ability name.
- * @name ElementName
- * @since 6
- * @sysCap aafwk
- * @devices phone
- * @permission N/A
- * @testapi
- **/
-export interface ElementName {
-
-    /**
-    * device id
-    * @default -
-    * @devices phone, tablet
-    * @since 6
-    * @sysCap AAFwk
-    */
-    deviceId: string;
-
-    /**
-    * bundle name
-    * @default -
-    * @devices phone, tablet
-    * @since 6
-    * @sysCap AAFwk
-    */
-    bundleName: string;
-
-    /**
-    * ability name
-    * @default -
-    * @devices phone, tablet
-    * @since 6
-    * @sysCap AAFwk
-    */
-    abilityName: string;
-}
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AsyncCallback } from './basic';
+import { StartAbilityParameter } from './ability/startAbilityParameter';
+
+/**
+ * A Particle Ability represents an ability with service.
+ * @name particleAbility
+ * @since 7
+ * @sysCap AAFwk
+ * @devices phone, tablet
+ * @permission N/A
+ */
+declare namespace particleAbility {
+
+  /**
+   * Service ability uses this method to start a specific ability.
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   * @param parameter Indicates the ability to start.
+   * @return -
+   */
+  function startAbility(parameter: StartAbilityParameter, callback: AsyncCallback<void>): void;
+  function startAbility(parameter: StartAbilityParameter): Promise<void>;
+
+}
+export default particleAbility;
diff --git a/api/@ohos.ability.wantConstant.d.ts b/api/@ohos.ability.wantConstant.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..edae0e993c1c9d4df226b2465058e56bf50b5254
--- /dev/null
+++ b/api/@ohos.ability.wantConstant.d.ts
@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License"),
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * the constant for action and entity in the want
+ * @name wantConstant
+ * @since 6
+ * @sysCap aafwk
+ * @devices phone, tablet
+ * @permission N/A
+ */
+declare namespace wantConstant {
+  /**
+   * the constant for action of the want
+   * @name Action
+   * @since 6
+   * @sysCap aafwk
+   * @devices phone, tablet
+   * @permission N/A
+   */
+  export enum Action {
+    /**
+     * Indicates the action of backing home.
+     *
+     * @since 1
+     */
+    ACTION_HOME = "ohos.want.action.home",
+
+    /**
+     * Indicates the action of starting a Page ability that displays a keypad.
+     *
+     * @since 6
+     */
+    ACTION_DIAL = "ohos.want.action.dial",
+
+    /**
+     * Indicates the action of starting a Page ability for search.
+     *
+     * @since 6
+     */
+    ACTION_SEARCH = "ohos.want.action.search",
+
+    /**
+     * Indicates the action of starting a Page ability that provides wireless network settings, for example,
+     * Wi-Fi options.
+     *
+     * @since 6
+     */
+    ACTION_WIRELESS_SETTINGS = "ohos.settings.wireless",
+
+    /**
+     * Indicates the action of starting a Page ability that manages installed applications.
+     *
+     * @since 6
+     */
+    ACTION_MANAGE_APPLICATIONS_SETTINGS = "ohos.settings.manage.applications",
+
+    /**
+     * Indicates the action of starting a Page ability that displays details of a specified application.
+     *
+     * <p>You must specify the application bundle name in the {@code package} attribute of the {@code Intent}
+     * containing this action.
+     *
+     * @since 6
+     */
+    ACTION_APPLICATION_DETAILS_SETTINGS = "ohos.settings.application.details",
+
+    /**
+     * Indicates the action of starting a Page ability for setting an alarm clock.
+     *
+     * @since 6
+     */
+    ACTION_SET_ALARM = "ohos.want.action.setAlarm",
+
+    /**
+     * Indicates the action of starting a Page ability that displays all alarm
+     * clocks.
+     *
+     * @since 6
+     */
+    ACTION_SHOW_ALARMS = "ohos.want.action.showAlarms",
+
+    /**
+     * Indicates the action of starting a Page ability for snoozing an alarm clock.
+     *
+     * @since 6
+     */
+    ACTION_SNOOZE_ALARM = "ohos.want.action.snoozeAlarm",
+
+    /**
+     * Indicates the action of starting a Page ability for deleting an alarm clock.
+     *
+     * @since 6
+     */
+    ACTION_DISMISS_ALARM = "ohos.want.action.dismissAlarm",
+
+    /**
+     * Indicates the action of starting a Page ability for dismissing a timer.
+     *
+     * @since 6
+     */
+    ACTION_DISMISS_TIMER = "ohos.want.action.dismissTimer",
+
+    /**
+     * Indicates the action of starting a Page ability for sending a sms.
+     *
+     * @since 6
+     */
+    ACTION_SEND_SMS = "ohos.want.action.sendSms",
+
+    /**
+     * Indicates the action of starting a Page ability for opening contacts or pictures.
+     *
+     * @since 6
+     */
+    ACTION_CHOOSE = "ohos.want.action.choose",
+
+    /**
+     * Indicates the action of showing the application selection dialog box.
+     *
+     * @since 6
+     */
+    ACTION_SELECT = "ohos.want.action.select",
+
+    /**
+     * Indicates the action of sending a single data record.
+     *
+     * @since 6
+     */
+    ACTION_SEND_DATA = "ohos.want.action.sendData",
+
+    /**
+     * Indicates the action of sending multiple data records.
+     *
+     * @since 6
+     */
+    ACTION_SEND_MULTIPLE_DATA = "ohos.want.action.sendMultipleData",
+
+    /**
+     * Indicates the action of requesting the media scanner to scan files and adding the files to the media library.
+     *
+     * @since 6
+     */
+    ACTION_SCAN_MEDIA_FILE = "ohos.want.action.scanMediaFile",
+
+    /**
+     * Indicates the action of viewing data.
+     *
+     * @since 6
+     */
+    ACTION_VIEW_DATA = "ohos.want.action.viewData",
+
+    /**
+     * Indicates the action of editing data.
+     *
+     * @since 6
+     */
+    ACTION_EDIT_DATA = "ohos.want.action.editData",
+
+    /**
+     * Indicates the choices you will show with {@link #ACTION_PICKER}.
+     *
+     * @since 6
+     */
+    INTENT_PARAMS_INTENT = "ability.want.params.INTENT",
+
+    /**
+     * Indicates the CharSequence dialog title when used with a {@link #ACTION_PICKER}.
+     *
+     * @since 6
+     */
+    INTENT_PARAMS_TITLE = "ability.want.params.TITLE",
+
+    /**
+     * Indicates the action of select file.
+     *
+     * @since 7
+     */
+    ACTION_FILE_SELECT = "ohos.action.fileSelect",
+
+    /**
+     * Indicates the URI holding a stream of data associated with the Intent when used with a {@link #ACTION_SEND_DATA}.
+     *
+     * @since 7
+     */
+    PARAMS_STREAM = "ability.params.stream",
+  }
+
+  /**
+   * the constant for Entity of the want
+   * @name Action
+   * @since 6
+   * @sysCap aafwk
+   * @devices phone, tablet
+   * @permission N/A
+   */
+  export enum Entity {
+    /**
+     * Indicates the default entity, which is used if the entity is not specified.
+     *
+     * @since 6
+     */
+    ENTITY_DEFAULT = "entity.system.default",
+
+    /**
+     * Indicates the home screen entity.
+     *
+     * @since 6
+     */
+    ENTITY_HOME = "entity.system.home",
+
+    /**
+     * Indicates the voice interaction entity.
+     *
+     * @since 6
+     */
+    ENTITY_VOICE = "entity.system.voice",
+
+    /**
+     * Indicates the browser category.
+     *
+     * @since 6
+     */
+    ENTITY_BROWSABLE = "entity.system.browsable",
+
+    /**
+     * Indicates the video category.
+     */
+    ENTITY_VIDEO = "entity.system.video"
+  }
+
+  export enum Flags {
+    /**
+     * Indicates the grant to perform read operations on the URI.
+     *
+     * @hide
+     */
+    FLAG_AUTH_READ_URI_PERMISSION = 0x00000001,
+
+    /**
+     * Indicates the grant to perform write operations on the URI.
+     *
+     * @hide
+     */
+    FLAG_AUTH_WRITE_URI_PERMISSION = 0x00000002,
+
+    /**
+     * Returns the result to the source ability.
+     */
+    FLAG_ABILITY_FORWARD_RESULT = 0x00000004,
+
+    /**
+     * Determines whether an ability on the local device can be migrated to a remote device.
+     */
+    FLAG_ABILITY_CONTINUATION = 0x00000008,
+
+    /**
+     * Specifies whether a component does not belong to OHOS.
+     */
+    FLAG_NOT_OHOS_COMPONENT = 0x00000010,
+
+    /**
+     * Specifies whether an ability is started.
+     */
+    FLAG_ABILITY_FORM_ENABLED = 0x00000020,
+
+    /**
+     * Indicates the grant for possible persisting on the URI.
+     *
+     * @hide
+     */
+    FLAG_AUTH_PERSISTABLE_URI_PERMISSION = 0x00000040,
+
+    /**
+     * Returns the result to the source ability slice.
+     *
+     * @hide
+     */
+    FLAG_AUTH_PREFIX_URI_PERMISSION = 0x00000080,
+
+    /**
+     * Supports multi-device startup in the distributed scheduling system.
+     */
+    FLAG_ABILITYSLICE_MULTI_DEVICE = 0x00000100,
+
+    /**
+     * Indicates that an ability using the Service template is started regardless of whether the host application has
+     * been started.
+     */
+    FLAG_START_FOREGROUND_ABILITY = 0x00000200,
+
+    /**
+     * Indicates the continuation is reversible.
+     *
+     * @hide
+     */
+    FLAG_ABILITY_CONTINUATION_REVERSIBLE = 0x00000400,
+
+    /**
+     * Install the specified ability if it's not installed.
+     */
+    FLAG_INSTALL_ON_DEMAND = 0x00000800,
+
+    /**
+     * Install the specifiedi ability with background mode if it's not installed.
+     */
+    FLAG_INSTALL_WITH_BACKGROUND_MODE = 0x80000000,
+
+    /**
+     * Indicates the operation of clearing other missions. This flag can be set for the {@code Intent} passed to
+     * {@link ohos.app.Context#startAbility} and must be used together with {@link FLAG_ABILITY_NEW_MISSION}.
+     */
+    FLAG_ABILITY_CLEAR_MISSION = 0x00008000,
+
+    /**
+     * Indicates the operation of creating a task on the historical mission stack.
+     */
+    FLAG_ABILITY_NEW_MISSION = 0x10000000,
+
+    /**
+     * Indicates that the existing instance of the ability to start will be reused if it is already at the top of
+     * the mission stack. Otherwise, a new ability instance will be created.
+     *
+     */
+    FLAG_ABILITY_MISSION_TOP = 0x20000000
+  }
+}
+
+export default wantConstant;
\ No newline at end of file
diff --git a/api/phone/@ohos.account.distributedaccount.d.ts b/api/@ohos.account.distributedaccount.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.account.distributedaccount.d.ts
rename to api/@ohos.account.distributedaccount.d.ts
diff --git a/api/@ohos.app.abilityManager.d.ts b/api/@ohos.app.abilityManager.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f9393afbaf24419f201a4d5dd423d739cc8540d0
--- /dev/null
+++ b/api/@ohos.app.abilityManager.d.ts
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AsyncCallback } from './basic';
+import { AbilityMissionInfo } from './app/abilityMissionInfo';
+import { ActiveProcessInfo } from './app/activeProcessInfo';
+
+/**
+ * This module provides the capability to manage abilities and obtaining system task information.
+ *
+ * @since 7
+ * @SysCap SystemCapability.Appexecfwk
+ * @devices phone, tablet, tv, wearable
+ * @import import abilityManager from '@ohos.app.abilityManager'
+ * @permission N/A
+ */
+declare namespace abilityManager {
+
+    enum ProcessErrCode {
+        NO_ERROR = 0,
+        CRASHED,
+        NO_RESPONSE,
+    }
+
+
+    /**
+     * Get information about running processes
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
+     * @devices phone, tablet, tv, wearable
+     * @return a list of ActiveProcessInfo records describing each process.
+     * @permission ohos.permission.INTERACT_ACROSS_LOCAL_ACCOUNTS_EXTENSION
+     * @systemapi hide this for inner system use
+     */
+    function getActiveProcessInfos(): Promise<Array<ActiveProcessInfo>>;
+    function getActiveProcessInfos(callback: AsyncCallback<Array<ActiveProcessInfo>>): void;
+
+    /**
+     * Get information about the running ability missions
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
+     * @devices phone, tablet, tv, wearable
+     * @param upperLimit The maximum number of mission infos to return in the array.
+     * @return an array of AbilityMissionInfo records describing each active mission.
+     * @permission ohos.permission.ACCESS_MISSIONS
+     * @systemapi hide this for inner system use
+     */
+    function getActiveAbilityMissionInfos(upperLimit: number): Promise<Array<AbilityMissionInfo>>;
+    function getActiveAbilityMissionInfos(upperLimit: number, callback: AsyncCallback<Array<AbilityMissionInfo>>): void;
+
+    /**
+     * Get information about recently run missions
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
+     * @devices phone, tablet, tv, wearable
+     * @param upperLimit The maximum number of previous mission infos to return in the array.
+     * @return an array of AbilityMissionInfo records describing each of the previous mission.
+     * @permission ohos.permission.ACCESS_MISSIONS_EXTRA
+     * @systemapi hide this for inner system use
+     */
+    function getPreviousAbilityMissionInfos(upperLimit: number): Promise<Array<AbilityMissionInfo>>;
+    function getPreviousAbilityMissionInfos(upperLimit: number, callback: AsyncCallback<Array<AbilityMissionInfo>>): void;
+
+    /**
+     * Delete the specified missions
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
+     * @devices phone, tablet, tv, wearable
+     * @param missionIds An array of missions, representing the missions that need to be deleted.
+     * @permission ohos.permission.DELETE_MISSIONS
+     * @systemapi hide this for inner system use
+     */
+    function deleteMissions(missionIds: Array<number>): Promise<void>;
+    function deleteMissions(missionIds: Array<number>, callback: AsyncCallback<void>): void;
+
+}
+
+export default abilityManager;
diff --git a/api/phone/@ohos.batteryinfo.d.ts b/api/@ohos.batteryinfo.d.ts
similarity index 100%
rename from api/phone/@ohos.batteryinfo.d.ts
rename to api/@ohos.batteryinfo.d.ts
diff --git a/api/phone/@ohos.brightness.d.ts b/api/@ohos.brightness.d.ts
similarity index 100%
rename from api/phone/@ohos.brightness.d.ts
rename to api/@ohos.brightness.d.ts
diff --git a/api/@ohos.bytrace.d.ts b/api/@ohos.bytrace.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dcc5ba1bf0bf811d192ad06bacfcab6f5903b14f
--- /dev/null
+++ b/api/@ohos.bytrace.d.ts
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Provides interfaces to trace a task for performance measure, the logs can be capture by the
+ * bytrace cmdline available on the device.
+ *
+ * <p>This interfaces trace the start, end, and value changes of key processes that last for at least 3 ms.
+ *
+ * <p>Example:
+ * To trace a name verification that is expected to complete within 5 ms:
+ * <pre>{@code
+ * bytrace.startTrace("checkName", 111, 5);
+ * //your process
+ * bytrace.finishTrace("checkName", 111);
+ * }</pre>
+ * To trace the number of layers, which is 3:
+ * <pre>{@code
+ * bytrace.traceByValue("curLayer", 3);
+ * }</pre>
+ *
+ * <p>Each {@code startTrace} matches one {@code finishTrace}, and they must have the same name
+ * and taskId.
+ *
+ * @SysCap SystemCapability.Developtools.Bytrace
+ * @devices phone, tablet
+ * @since 7
+ */
+declare namespace bytrace {
+  /**
+   * Records a trace marking it as the start of a task, can with the expected completion time between
+   * startTrace and finishTrace.
+   *
+   * This method is invoked at the start of a transaction to indicate that a task has started, whose name
+   * is specified by {@code name}, and the taskId is used to distinguish the tasks. It must be followed by
+   * {@link #finishTrace}, the name and taskId need to be the same.
+   *
+   * @param name Indicates the task name.
+   * @param taskId The unique id used to distinguish the tasks and match with the id in follow finishTrace.
+   * @param expectedTime Indicates the expected time required for completing the task, in milliseconds.
+   * @since 7
+   */
+  function startTrace(name: string, taskId: number, expectedTime?: number): void;
+
+  /**
+   * Records a trace and marks it as the end of a task.
+   *
+   * This method is invoked at the end of a transaction to indicate that a task has ended, whose name
+   * is specified by {@code name}. This method must be invoked after the the startTrace.
+   *
+   * @param name Indicates the task name. It must be the same whith the {@code name} of startTrace.
+   * @param taskId The unique id used to distinguish the tasks and must be the same whith the .
+   * {@code taskId} of startTrace.
+   * @since 7
+   */
+  function finishTrace(name: string, taskId: number): void;
+
+  /**
+   * Records a trace for generating a count, such as clock pulse and the number of layers.
+   *
+   * @param name Indicates the name used to identify the count.
+   * @param count Indicates the number of the count.
+   * @since 7
+   */
+  function traceByValue(name: string, count: number): void;
+}
+export default bytrace;
\ No newline at end of file
diff --git a/api/phone/@ohos.commonevent.d.ts b/api/@ohos.commonEvent.d.ts
old mode 100755
new mode 100644
similarity index 97%
rename from api/phone/@ohos.commonevent.d.ts
rename to api/@ohos.commonEvent.d.ts
index 53027cf967f81587d0a4b743f773a0eb3cc8a829..cff53acc23f3e199a9bd26f0ed2953e0f8fd8334
--- a/api/phone/@ohos.commonevent.d.ts
+++ b/api/@ohos.commonEvent.d.ts
@@ -13,43 +13,35 @@
  * limitations under the License.
  */
 import { AsyncCallback } from './basic';
-import { CommonEventData } from './commonevent/commoneventdata';
-import { CommonEventSubscriber } from './commonevent/commoneventsubscriber';
-import { CommonEventSubscribeInfo } from './commonevent/commoneventsubscribeinfo';
-import { CommonEventPublishData } from './commonevent/commoneventpublishdata';
+import { CommonEventData } from './commonEvent/commonEventData';
+import { CommonEventSubscriber } from './commonEvent/commonEventSubscriber'
+import { CommonEventSubscribeInfo } from './commonEvent/commonEventSubscribeInfo';
+import { CommonEventPublishData } from './commonEvent/commonEventPublishData';
 
 /**
  * the defination for commonevent
  * @name commonEvent
- * @since 6
- * @sysCap ces
- * @devices phone, tablet
+ * @since 7
  * @permission N/A
  */
 declare namespace commonEvent {
   /**
    * Publishes an ordered, sticky, or standard common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param data Indicate the CommonEventPublishData containing the common event content and attributes.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function publish(event: string, callback: AsyncCallback<void>): void;
 
   /**
    * Publishes an ordered, sticky, or standard common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param data Indicate the CommonEventPublishData containing the common event content and attributes.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function publish(event: string, options: CommonEventPublishData, callback: AsyncCallback<void>): void;
 
@@ -57,63 +49,48 @@ declare namespace commonEvent {
   /**
    * create the CommonEventSubscriber for the SubscriberInfo.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param subscribeInfo Indicate the information of the subscriber.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function createSubscriber(subscribeInfo: CommonEventSubscribeInfo, callback: AsyncCallback<CommonEventSubscriber>): void;
 
   /**
    * create the CommonEventSubscriber for the SubscriberInfo.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param subscribeInfo Indicate the information of the subscriber.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function createSubscriber(subscribeInfo: CommonEventSubscribeInfo): Promise<CommonEventSubscriber>;
 
   /**
    * subscribe an ordered, sticky, or standard common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param subscriber Indicate the subscriber of the common event.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function subscribe(subscriber: CommonEventSubscriber, callback: AsyncCallback<CommonEventData>): void;
 
   /**
    * unsubscribe an ordered, sticky, or standard common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param subscriber Indicate the subscriber of the common event.
    * @param callback Specified callback method.
    * @return -
-   * @testapi
    */
   function unsubscribe(subscriber: CommonEventSubscriber, callback?: AsyncCallback<void>): void;
 
   /**
    * the event type that the commonEvent supported
    * @name Support
-   * @since 6
-   * @sysCap ces
-   * @devices phone
+   * @since 7
    * @permission N/A
-   * @testapi
    */
   export enum Support {
     /**
@@ -966,7 +943,7 @@ declare namespace commonEvent {
     /**
      * Only for test case.
      */
-    COMMON_EVENT_TEST_ACTION2 = "usual.event.test2",
+    COMMON_EVENT_TEST_ACTION2 = "usual.event.test2"
   }
 }
 
diff --git a/api/@ohos.data.distributedData.d.ts b/api/@ohos.data.distributedData.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..efd0a34d36c21c7c676f9bdac9570e48315f832f
--- /dev/null
+++ b/api/@ohos.data.distributedData.d.ts
@@ -0,0 +1,443 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AsyncCallback, Callback } from './basic';
+
+declare namespace distributedData {
+    /**
+     * Provides configuration information for {@link KVManager} instances,
+     * including the caller's package name and distributed network type.
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     */
+    interface KVManagerConfig {
+        /**
+         * Indicates the user information
+         */
+        userInfo: UserInfo;
+
+        /**
+         * Indicates the bundleName
+         */
+        bundleName: string;
+    }
+
+    /**
+     * Manages user information.
+     *
+     * <p>This class provides methods for obtaining the user ID and type, setting the user ID and type,
+     * and checking whether two users are the same.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    interface UserInfo {
+        /** Indicates the user ID to set */
+        userId?: string;
+
+        /** Indicates the user type to set */
+        userType?: UserType;
+    }
+
+    /**
+     * Enumerates user types.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    enum UserType {
+        /** Indicates a user that logs in to different devices using the same account. */
+        SAME_USER_ID = 0
+    }
+
+    /**
+     * KVStore constants
+     */
+    namespace Constants {
+        /**
+        * max key length.
+        */
+        const MAX_KEY_LENGTH = 1024;
+
+        /**
+         * max value length.
+         */
+        const MAX_VALUE_LENGTH = 4194303;
+
+        /**
+         * max device coordinate key length.
+         */
+        const MAX_KEY_LENGTH_DEVICE = 896;
+
+        /**
+         * max store id length.
+         */
+        const MAX_STORE_ID_LENGTH = 128;
+
+        /**
+         * max query length.
+         */
+        const MAX_QUERY_LENGTH = 512000;
+
+        /**
+         * max batch operation size.
+         */
+        const MAX_BATCH_SIZE = 128;
+    }
+
+    /**
+     * Indicates the {@code ValueType}.
+     *
+     * <p>{@code ValueType} is obtained based on the value.
+     *
+     * @since 7
+     */
+    enum ValueType {
+        /** Indicates that the value type is string. */
+        STRING = 0,
+
+        /** Indicates that the value type is int. */
+        INTEGER = 1,
+
+        /** Indicates that the value type is float. */
+        FLOAT = 2,
+
+        /** Indicates that the value type is byte array. */
+        BYTE_ARRAY = 3,
+
+        /** Indicates that the value type is boolean. */
+        BOOLEAN = 4,
+
+        /** Indicates that the value type is double. */
+        DOUBLE = 5
+    }
+
+    /**
+     * Obtains {@code Value} objects stored in a {@link KVStore} database.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     */
+    interface Value {
+        /**
+         * Indicates value type
+         *
+         * @see ValueType
+         * @type {number}
+         * @memberof Value
+         */
+        type: ValueType;
+        value: Uint8Array | string | number | boolean;
+    }
+
+    /**
+     * Provides key-value pairs stored in the distributed database.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     */
+    interface Entry {
+        key: string;
+        value: Value;
+    }
+
+    /**
+     * Receives notifications of all data changes, including data insertion, update, and deletion.
+     *
+     * <p>If you have subscribed to {@code KVStore}, you will receive data change notifications and obtain the changed data
+     * from the parameters in callback methods upon data insertion, update, or deletion.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     */
+    interface ChangeNotification {
+        /** Indicates data addition records. */
+        insertEntries: Entry[];
+        /** Indicates data update records. */
+        updateEntries: Entry[];
+        /** Indicates data deletion records. */
+        deleteEntries: Entry[];
+        /** Indicates from device id. */
+        deviceId: string;
+    }
+
+    /**
+     * Indicates the database synchronization mode.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    enum SyncMode {
+        /** Indicates that data is only pulled from the remote end. */
+        PULL_ONLY = 0,
+        /** Indicates that data is only pushed from the local end. */
+        PUSH_ONLY = 1,
+        /** Indicates that data is pushed from the local end, and then pulled from the remote end. */
+        PUSH_PULL = 2
+    }
+
+    /**
+     * Describes the subscription type.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     */
+    enum SubscribeType {
+        /** Subscription to local data changes */
+        SUBSCRIBE_TYPE_LOCAL = 0,
+
+        /** Subscription to remote data changes */
+        SUBSCRIBE_TYPE_REMOTE = 1,
+
+        /** Subscription to both local and remote data changes */
+        SUBSCRIBE_TYPE_ALL = 2,
+    }
+
+    /**
+     * Describes the {@code KVStore} type.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    enum KVStoreType {
+        /** Device-collaborated database, as specified by {@code DeviceKVStore} */
+        DEVICE_COLLABORATION = 0,
+
+        /** Single-version database, as specified by {@code SingleKVStore} */
+        SINGLE_VERSION = 1,
+
+        /** Multi-version database, as specified by {@code MultiKVStore} */
+        MULTI_VERSION = 2,
+    }
+
+    /**
+     * Describes the {@code KVStore} type.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    enum SecurityLevel {
+        /**
+         * NO_LEVEL: mains not set the security level.
+         *
+         * @since 7
+         */
+        NO_LEVEL = 0,
+
+        /**
+         * S0: mains the db is public.
+         * There is no impact even if the data is leaked.
+         *
+         * @since 7
+         */
+        S0 = 1,
+
+        /**
+         * S1: mains the db is low level security
+         * There are some low impact, when the data is leaked.
+         *
+         * @since 7
+         */
+        S1 = 2,
+
+        /**
+         * S2: mains the db is middle level security
+         * There are some major impact, when the data is leaked.
+         *
+         * @since 7
+         */
+        S2 = 3,
+
+        /**
+         * S3: mains the db is high level security
+         * There are some severity impact, when the data is leaked.
+         *
+         * @since 7
+         */
+        S3 = 5,
+
+        /**
+         * S4: mains the db is critical level security
+         * There are some critical impact, when the data is leaked.
+         *
+         * @since 7
+         */
+        S4 = 6,
+    }
+
+    /**
+     * Provides configuration options for creating a {@code KVStore}.
+     *
+     * <p>You can determine whether to create another database if a {@code KVStore} database is missing,
+     * whether to encrypt the database, and the database type.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     */
+    interface Options {
+        createIfMissing?: boolean;
+        encrypt?: boolean;
+        backup?: boolean;
+        autoSync?: boolean;
+        kvStoreType?: KVStoreType;
+        securityLevel?: SecurityLevel;
+    }
+
+    /**
+     * Represents a key-value distributed database and provides methods for adding, deleting, modifying, querying,
+     * and subscribing to distributed data.
+     *
+     * <p>You can create distributed databases of different types by {@link KVManager#getKVStore (Options, String)}
+     * with input parameter {@code Options}. Distributed database types are defined in {@code KVStoreType},
+     * including {@code SingleKVStore}.
+     *
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @devices phone, tablet
+     * @since 7
+     * @version 1
+     */
+    interface KVStore {
+        /**
+         * Writes a key-value pair of the byte array type into the {@code KVStore} database.
+         *
+         * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
+         * Spaces before and after the key will be cleared.
+         * @param value Indicates the byte array, which must be less than 4 MB.
+         * @return Returns the error code of databases.
+         * @since 7
+         */
+        put(key: string, value: Uint8Array | string | number | boolean, callback: AsyncCallback<void>): void;
+        put(key: string, value: Uint8Array | string | number | boolean): Promise<void>;
+
+        /**
+         * Deletes the key-value pair based on a specified key.
+         *
+         * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
+         * Spaces before and after the key will be cleared.
+         * @return Returns the error code of databases.
+         * @since 7
+         */
+        delete(key: string, callback: AsyncCallback<void>): void;
+        delete(key: string): Promise<void>;
+
+        /**
+         * turn on from the data change notify based on the specified {@code subscribeType}.
+         *
+         * @param type Indicates the subscription type, which is defined in {@code SubscribeType}.
+         * @param observer Indicates the observer of data change events in the distributed database.
+         * @return Returns the error code of databases.
+         * @since 7
+         */
+        on(event: 'dataChange', type: SubscribeType, observer: Callback<ChangeNotification>): void;
+
+        /**
+         * Subscribe to the notification of store synchronization completion.
+         *
+         * <p>Sync result is returned through asynchronous callback.
+         *
+         * @param syncCallback Indicates the callback used to send the synchronization result to the caller.
+         * @return Returns the {@code number} object.
+         * @since 7
+         */
+        on(event: 'syncComplete', syncCallback: Callback<Array<[string, number]>>): void;
+    }
+
+    /**
+     * Provides methods related to single-version distributed databases.
+     *
+     * <p>To create a {@code SingleKVStore} database,
+     * you can use the {@link data.distributed.common.KVManager#getKVStore​(Options, String)} method
+     * with {@code KVStoreType} set to {@code SINGLE_VERSION} for the input parameter {@code Options}.
+     * This database synchronizes data to other databases in time sequence.
+     * The {@code SingleKVStore} database does not support
+     * synchronous transactions, or data search using snapshots.
+     *
+     * @devices phone, tablet
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     * @version 1
+     */
+    interface SingleKVStore extends KVStore {
+        /**
+         * Obtains the value of a specified key.
+         *
+         * @param key Indicates the key of the value to be queried.
+         * @return Returns the value matching the given criteria.
+         * @throws Throws exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
+         * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}, and {@code KEY_NOT_FOUND}.
+         * @since 7
+         */
+        get(key: string, callback: AsyncCallback<Uint8Array | string | boolean | number>): void;
+        get(key: string): Promise<Uint8Array | string | boolean | number>;
+
+        /**
+         * Synchronizing KVStore Data Between Devices.
+         *
+         * @param deviceIdList Indicates the {@code string}.
+         * @param mode Indicates the {@code SyncMode} object.
+         * @param allowedDelayMs Indicates the number type parameter.
+         * @return Returns the {@code number} object.
+         * @since 7
+         */
+        sync(deviceIdList: string[], mode: SyncMode, allowedDelayMs?: number): void;
+    }
+    
+    /**
+     * Creates a {@link KVManager} instance based on the configuration information.
+     *
+     * <p>You must pass {@link KVManagerConfig} to provide configuration information
+     * for creating the {@link KVManager} instance.
+     *
+     * @param config Indicates the {@link KVStore} configuration information,
+     * including the user information and package name.
+     * @return Returns the {@code KVManager} instance.
+     * @throws Throws exception if input is invalid.
+     * @since 7
+     */
+    function createKVManager(config: KVManagerConfig, callback: AsyncCallback<KVManager>): void;
+    function createKVManager(config: KVManagerConfig): Promise<KVManager>;
+
+    /**
+     * Provides interfaces to manage a {@code KVStore} database,
+     * including obtaining, closing, and deleting the {@code KVStore}.
+     *
+     * @devices phone, tablet
+     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
+     * @since 7
+     * @version 1
+     */
+    interface KVManager {
+        /**
+         * Creates and obtains a {@code KVStore} database by specifying {@code Options} and {@code storeId}.
+         *
+         * @param options Indicates the options used for creating and obtaining the {@code KVStore} database,
+         * including {@code isCreateIfMissing}, {@code isEncrypt}, and {@code KVStoreType}.
+         * @param storeId Identifies the {@code KVStore} database.
+         * The value of this parameter must be unique for the same application,
+         * and different applications can share the same value.
+         * @return Returns a {@code KVStore}, or {@code SingleKVStore},
+         * @since 7
+         */
+        getKVStore<T extends KVStore>(storeId: string, options: Options): Promise<T>;
+        getKVStore<T extends KVStore>(storeId: string, options: Options, callback: AsyncCallback<T>): void;
+    }
+}
+
+export default distributedData;
\ No newline at end of file
diff --git a/api/phone/@ohos.data.storage.d.ts b/api/@ohos.data.storage.d.ts
similarity index 100%
rename from api/phone/@ohos.data.storage.d.ts
rename to api/@ohos.data.storage.d.ts
diff --git a/api/phone/@ohos.deviceinfo.d.ts b/api/@ohos.deviceinfo.d.ts
similarity index 100%
rename from api/phone/@ohos.deviceinfo.d.ts
rename to api/@ohos.deviceinfo.d.ts
diff --git a/api/phone/@ohos.distributedHardware.deviceManager.d.ts b/api/@ohos.distributedHardware.deviceManager.d.ts
similarity index 85%
rename from api/phone/@ohos.distributedHardware.deviceManager.d.ts
rename to api/@ohos.distributedHardware.deviceManager.d.ts
index f918e3e45bee0d56953117797b608b100b87601b..2653619e4d65a52203837433a9cd5d8b4e802b2b 100644
--- a/api/phone/@ohos.distributedHardware.deviceManager.d.ts
+++ b/api/@ohos.distributedHardware.deviceManager.d.ts
@@ -226,6 +226,56 @@ declare namespace deviceManager {
     SUBSCRIBE_CAPABILITY_DDMP = 0
   }
 
+  /**
+   * Device Authentication param
+   *
+   * @systemapi this method can be used only by system applications
+   */
+  interface AuthParam {
+    /**
+     * Authentication type, 1 for pin code.
+     */
+    authType: number;
+
+    /**
+     * App application Icon.
+     */
+    appIcon?: Uint8Array;
+
+    /**
+     * App application thumbnail.
+     */
+    appThumbnail?: Uint8Array; 
+
+    /**
+     * Authentication extra infos.
+     */
+    extraInfo: {[key:string] : any};
+
+  }
+
+  /**
+   * Device auth info.
+   *
+   * @systemapi this method can be used only by system applications
+   */
+  interface AuthInfo {
+    /**
+     * Authentication type, 1 for pin code.
+     */
+    authType: number;
+
+    /**
+     * the token used for this authentication.
+     */
+    token: number;
+    
+    /**
+     * Authentication extra infos.
+     */
+    extraInfo: {[key:string] : any};
+  }
+
   /**
    * Creates a {@code DeviceManager} instance.
    *
@@ -275,13 +325,24 @@ declare namespace deviceManager {
     stopDeviceDiscovery(subscribeId: number): void;
 
     /**
-     * authenticate the specified device.
+     * Authenticate the specified device.
      *
-     * @param bundleName Indicates the bundle name of the application.
      * @param deviceInfo deviceInfo of device to authenticate
+     * @param authparam authparam of device to authenticate
+     * @param callback Indicates the callback to be invoked upon authenticateDevice
      * @systemapi this method can be used only by system applications.
-     */
-    authenticateDevice(deviceInfo: DeviceInfo): void;
+     */   
+    authenticateDevice(deviceInfo: DeviceInfo, authparam: AuthParam, callback: AsyncCallback<{deviceId: string, pinTone ?: number}>): void;
+    
+     /**
+     * verify auth info, such as pin code.
+     *
+     * @param authInfo device auth info o verify
+     * @param callback Indicates the callback to be invoked upon verifyAuthInfo
+     * @systemapi this method can be used only by system applications.
+     */   
+    verifyAuthInfo(authInfo: AuthInfo, callback: AsyncCallback<{deviceId: string, level: number}>): void;
+
 
     /**
      * Register a device state callback so that the application can be notified upon device state changes based on
@@ -332,22 +393,6 @@ declare namespace deviceManager {
      */
     off(type: 'discoverFail', callback?: Callback<{ subscribeId: number, reason: number }>): void;
 
-    /**
-     * Register a device auth result callback so that the application can be notified when the device was found
-     *
-     * @param callback Indicates the device auth result callback to register.
-     * @systemapi this method can be used only by system applications.
-     */
-    on(type: 'authResult', callback: Callback<{ deviceId: string, status: number, reason: number }>): void;
-
-    /**
-     * UnRegister a device auth result callback so that the application can be notified when the device was found
-     *
-     * @param callback Indicates the device auth result callback to register.
-     * @systemapi this method can be used only by system applications.
-     */
-    off(type: 'authResult', callback?: Callback<{ deviceId: string, status: number, reason: number }>): void;
-
     /**
      * Register a serviceError callback so that the application can be notified when devicemanager service died
      *
diff --git a/api/phone/@ohos.fileio.d.ts b/api/@ohos.fileio.d.ts
similarity index 100%
rename from api/phone/@ohos.fileio.d.ts
rename to api/@ohos.fileio.d.ts
diff --git a/api/phone/@ohos.intl.d.ts b/api/@ohos.intl.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.intl.d.ts
rename to api/@ohos.intl.d.ts
diff --git a/api/phone/@ohos.multimedia.audio.d.ts b/api/@ohos.multimedia.audio.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.multimedia.audio.d.ts
rename to api/@ohos.multimedia.audio.d.ts
diff --git a/api/phone/@ohos.multimedia.media.d.ts b/api/@ohos.multimedia.media.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.multimedia.media.d.ts
rename to api/@ohos.multimedia.media.d.ts
diff --git a/api/phone/@ohos.power.d.ts b/api/@ohos.power.d.ts
similarity index 100%
rename from api/phone/@ohos.power.d.ts
rename to api/@ohos.power.d.ts
diff --git a/api/phone/@ohos.resourceManager.d.ts b/api/@ohos.resourceManager.d.ts
similarity index 100%
rename from api/phone/@ohos.resourceManager.d.ts
rename to api/@ohos.resourceManager.d.ts
diff --git a/api/phone/@ohos.runninglock.d.ts b/api/@ohos.runninglock.d.ts
similarity index 100%
rename from api/phone/@ohos.runninglock.d.ts
rename to api/@ohos.runninglock.d.ts
diff --git a/api/phone/@ohos.systemTime.d.ts b/api/@ohos.systemTime.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.systemTime.d.ts
rename to api/@ohos.systemTime.d.ts
diff --git a/api/phone/@ohos.systemparameter.d.ts b/api/@ohos.systemparameter.d.ts
similarity index 100%
rename from api/phone/@ohos.systemparameter.d.ts
rename to api/@ohos.systemparameter.d.ts
diff --git a/api/phone/@ohos.telephony.call.d.ts b/api/@ohos.telephony.call.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.call.d.ts
rename to api/@ohos.telephony.call.d.ts
diff --git a/api/phone/@ohos.telephony.data.d.ts b/api/@ohos.telephony.data.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.data.d.ts
rename to api/@ohos.telephony.data.d.ts
diff --git a/api/phone/@ohos.telephony.observer.d.ts b/api/@ohos.telephony.observer.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.observer.d.ts
rename to api/@ohos.telephony.observer.d.ts
diff --git a/api/phone/@ohos.telephony.radio.d.ts b/api/@ohos.telephony.radio.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.radio.d.ts
rename to api/@ohos.telephony.radio.d.ts
diff --git a/api/phone/@ohos.telephony.sim.d.ts b/api/@ohos.telephony.sim.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.sim.d.ts
rename to api/@ohos.telephony.sim.d.ts
diff --git a/api/phone/@ohos.telephony.sms.d.ts b/api/@ohos.telephony.sms.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.telephony.sms.d.ts
rename to api/@ohos.telephony.sms.d.ts
diff --git a/api/phone/@ohos.update.d.ts b/api/@ohos.update.d.ts
similarity index 100%
rename from api/phone/@ohos.update.d.ts
rename to api/@ohos.update.d.ts
diff --git a/api/@ohos.wantAgent.d.ts b/api/@ohos.wantAgent.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..383a2ea493c108757201e81a25a2b8eb9e2f7b7e
--- /dev/null
+++ b/api/@ohos.wantAgent.d.ts
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AsyncCallback , Callback} from './basic';
+import { Want } from './ability/want';
+import { WantAgentInfo } from './wantAgent/wantAgentInfo';
+
+/**
+ * Provide the method obtain trigger, cancel, and compare and to obtain
+ * the bundle name, UID of an {@link WantAgent} object.
+ *
+ * @name wantAgent
+ * @since 7
+ * @devices phone, tablet
+ * @permission N/A
+ */
+declare namespace wantAgent {
+  /**
+   * Obtains an {@link WantAgent} object.
+   *
+   * @param info Indicates the {@link WantAgentInfo} object that contains parameters of the
+   * {@link WantAgent} object to create.
+   * @return Returns the created {@link WantAgent} object.
+   *
+   * @since 7
+   */
+  function getWantAgent(info: WantAgentInfo, callback: AsyncCallback<WantAgent>): void;
+  function getWantAgent(info: WantAgentInfo): Promise<WantAgent>;
+
+  /**
+   * Enumerates flags for using an {@link WantAgent}.
+   *
+   * @since 7
+   */
+  export enum WantAgentFlags {
+    ONE_TIME_FLAG = 0,
+    NO_BUILD_FLAG,
+    CANCEL_PRESENT_FLAG,
+    UPDATE_PRESENT_FLAG,
+    CONSTANT_FLAG,
+    REPLACE_ELEMENT,
+    REPLACE_ACTION,
+    REPLACE_URI,
+    REPLACE_ENTITIES,
+    REPLACE_BUNDLE
+  }
+
+  /**
+   * Identifies the operation for using an {@link WantAgent}, such as starting an ability or sending a common event.
+   *
+   * @since 7
+   */
+  export enum OperationType {
+    UNKNOWN_TYPE = 0,
+    START_ABILITY,
+    START_ABILITIES,
+    START_SERVICE,
+    SEND_COMMON_EVENT,
+    START_FOREGROUND_SERVICE
+  }
+}
+
+export type WantAgent = object;
+
+export default wantAgent;
\ No newline at end of file
diff --git a/api/phone/@ohos.wifi.d.ts b/api/@ohos.wifi.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/@ohos.wifi.d.ts
rename to api/@ohos.wifi.d.ts
diff --git a/api/phone/@ohos.window.d.ts b/api/@ohos.window.d.ts
similarity index 100%
rename from api/phone/@ohos.window.d.ts
rename to api/@ohos.window.d.ts
diff --git a/api/@system.brightness.d.ts b/api/@system.brightness.d.ts
deleted file mode 100755
index 8b7348232da7c300877eeb16c7d13d8aec6db5e9..0000000000000000000000000000000000000000
--- a/api/@system.brightness.d.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface BrightnessResponse {
-  value: number;
-}
-export interface GetBrightnessOptions {
-  success?: (data: BrightnessResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface SetBrightnessOptions {
-  value: number;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface BrightnessModeResponse {
-  mode: number;
-}
-export interface GetBrightnessModeOptions {
-  success?: (data: BrightnessModeResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface SetBrightnessModeOptions {
-  mode: number;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface SetKeepScreenOnOptions {
-  keepScreenOn: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export default class Brightness {
-  static getValue(options?: GetBrightnessOptions): void;
-  static setValue(options: SetBrightnessOptions): void;
-  static getMode(options?: GetBrightnessModeOptions): void;
-  static setMode(options: SetBrightnessModeOptions): void;
-  static setKeepScreenOn(options: SetKeepScreenOnOptions): void;
-}
diff --git a/api/@system.device.d.ts b/api/@system.device.d.ts
deleted file mode 100755
index 83aa8c6ec42c0c29155a557c5d4376ea34d6b478..0000000000000000000000000000000000000000
--- a/api/@system.device.d.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface DeviceResponse {
-  brand: string;
-  manufacturer: string;
-  model: string;
-  product: string;
-  language: string;
-  region: string;
-  windowWidth: number;
-  windowHeight: number;
-  screenDensity: number;
-  screenShape: "rect" | "circle";
-}
-export interface GetDeviceOptions {
-  success?: (data: DeviceResponse) => void;
-  fail?: (data: any, code: number) => void;
-  complete?: () => void;
-}
-export default class Device {
-  static getInfo(options?: GetDeviceOptions): void;
-}
diff --git a/api/@system.file.d.ts b/api/@system.file.d.ts
deleted file mode 100755
index fa9fd86dfb542d85d551b215123e5ab66a3862b6..0000000000000000000000000000000000000000
--- a/api/@system.file.d.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface FileResponse {
-  uri: string;
-  length: number;
-  lastModifiedTime: number;
-  type: "dir" | "file";
-  subFiles?: Array<FileResponse>;
-}
-export interface FileMoveOption {
-  srcUri: string;
-  dstUri: string;
-  success?: (uri: string) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileListResponse {
-  fileList: Array<FileResponse>;
-}
-export interface FileListOption {
-  uri: string;
-  success?: (data: FileListResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileCopyOption {
-  srcUri: string;
-  dstUri: string;
-  success?: (uri: string) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileGetOption {
-  uri: string;
-  recursive?: boolean;
-  success?: (file: FileResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileDeleteOption {
-  uri: string;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileWriteTextOption {
-  uri: string;
-  text: string;
-  encoding?: string;
-  append?: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileReadTextResponse {
-  text: string;
-}
-export interface FileReadTextOption {
-  uri: string;
-  encoding?: string;
-  position?: number;
-  length?: number;
-  success?: (data: FileReadTextResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileWriteArrayBufferOption {
-  uri: string;
-  buffer: Uint8Array;
-  position?: number;
-  append?: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileReadArrayBufferResponse {
-  buffer: Uint8Array;
-}
-export interface FileReadArrayBufferOption {
-  uri: string;
-  position?: number;
-  length?: number;
-  success?: (data: FileReadArrayBufferResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileAccessOption {
-  uri: string;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileMkdirOption {
-  uri: string;
-  recursive?: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface FileRmdirOption {
-  uri: string;
-  recursive?: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export default class File {
-  static move(options: FileMoveOption): void;
-  static copy(options: FileCopyOption): void;
-  static list(options: FileListOption): void;
-  static get(options: FileGetOption): void;
-  static delete(options: FileDeleteOption): void;
-  static writeText(options: FileWriteTextOption): void;
-  static readText(options: FileReadTextOption): void;
-  static writeArrayBuffer(options: FileWriteArrayBufferOption): void;
-  static readArrayBuffer(options: FileReadArrayBufferOption): void;
-  static access(options: FileAccessOption): void;
-  static mkdir(options: FileMkdirOption): void;
-  static rmdir(options: FileRmdirOption): void;
-}
diff --git a/api/@system.geolocation.d.ts b/api/@system.geolocation.d.ts
deleted file mode 100755
index e2ca9ac56c5dd640e6ebcd85d44f70bd9ed111c0..0000000000000000000000000000000000000000
--- a/api/@system.geolocation.d.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface GeolocationResponse {
-  longitude: number;
-  latitude: number;
-  altitude: number;
-  accuracy: number;
-  time: number;
-}
-export interface GetLocationOption {
-  timeout?: number;
-  coordType?: string;
-  success?: (data: GeolocationResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface GetLocationTypeResponse {
-  types: Array<string>;
-}
-export interface GetLocationTypeOption {
-  success?: (data: GetLocationTypeResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export interface SubscribeLocationOption {
-  coordType?: string;
-  success: (data: GeolocationResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export default class Geolocation {
-  static getLocation(options?: GetLocationOption): void;
-  static getLocationType(options?: GetLocationTypeOption): void;
-  static subscribe(options: SubscribeLocationOption): void;
-  static unsubscribe(): void;
-  static getSupportedCoordTypes(): Array<string>;
-}
diff --git a/api/@system.router.d.ts b/api/@system.router.d.ts
deleted file mode 100755
index 8cb0efc2af311329c474bf017aba3048d11a937c..0000000000000000000000000000000000000000
--- a/api/@system.router.d.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface RouterOptions {
-  uri: string;
-  params?: Object;
-}
-export interface BackRouterOptions {
-  path?: string;
-}
-export interface RouterState {
-  index: number;
-  name: string;
-  path: string;
-}
-export default class Router {
-  static push(options: RouterOptions): void;
-  static replace(options: RouterOptions): void;
-  static back(options?: BackRouterOptions): void;
-  static clear(): void;
-  static getLength(): string;
-  static getState(): RouterState;
-}
diff --git a/api/@system.sensor.d.ts b/api/@system.sensor.d.ts
deleted file mode 100755
index be6b11bbee43315913c35a85a2e8c96b393d8fa8..0000000000000000000000000000000000000000
--- a/api/@system.sensor.d.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface AccelerometerResponse {
-  x: number;
-  y: number;
-  z: number;
-}
-export interface subscribeAccelerometerOptions {
-  interval: string;
-  success: (data: AccelerometerResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface CompassResponse {
-  direction: number;
-}
-export interface SubscribeCompassOptions {
-  success: (data: CompassResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface ProximityResponse {
-  distance: number;
-}
-export interface SubscribeProximityOptions {
-  success: (data: ProximityResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface LightResponse {
-  intensity: number;
-}
-export interface SubscribeLightOptions {
-  success: (data: LightResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface StepCounterResponse {
-  steps: number;
-}
-export interface SubscribeStepCounterOptions {
-  success: (data: StepCounterResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface BarometerResponse {
-  pressure: number;
-}
-export interface SubscribeBarometerOptions {
-  success: (data: BarometerResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface HeartRateResponse {
-  heartRate: number;
-}
-export interface SubscribeHeartRateOptions {
-  success: (data: HeartRateResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface OnBodyStateResponse {
-  value: boolean;
-}
-export interface SubscribeOnBodyStateOptions {
-  success: (data: OnBodyStateResponse) => void;
-  fail?: (data: string, code: number) => void;
-}
-export interface GetOnBodyStateOptions {
-  success: (data: OnBodyStateResponse) => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
-export default class Sensor {
-  static subscribeAccelerometer(options: subscribeAccelerometerOptions): void;
-  static unsubscribeAccelerometer(): void;
-  static subscribeCompass(options: SubscribeCompassOptions): void;
-  static unsubscribeCompass(): void;
-  static subscribeProximity(options: SubscribeProximityOptions): void;
-  static unsubscribeProximity(): void;
-  static subscribeLight(options: SubscribeLightOptions): void;
-  static unsubscribeLight(): void;
-  static subscribeStepCounter(options: SubscribeStepCounterOptions): void;
-  static unsubscribeStepCounter(): void;
-  static subscribeBarometer(options: SubscribeBarometerOptions): void;
-  static unsubscribeBarometer(): void;
-  static subscribeHeartRate(options: SubscribeHeartRateOptions): void;
-  static unsubscribeHeartRate(): void;
-  static subscribeOnBodyState(options: SubscribeOnBodyStateOptions): void;
-  static unsubscribeOnBodyState(): void;
-  static getOnBodyState(options: GetOnBodyStateOptions): void;
-}
diff --git a/api/phone/app/moduleinfo.d.ts b/api/ability/abilityResult.d.ts
old mode 100755
new mode 100644
similarity index 51%
rename from api/phone/app/moduleinfo.d.ts
rename to api/ability/abilityResult.d.ts
index 9c6c608b3da67a6b1d6e5f755d2beeb37fd82ea4..834f9b505de9f57480cde67a05f61f641b062d60
--- a/api/phone/app/moduleinfo.d.ts
+++ b/api/ability/abilityResult.d.ts
@@ -12,34 +12,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Want } from './want';
 
-/**
- * @name ModuleInfo
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export interface ModuleInfo {
-    /**
-     * The module name.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     moduleName: string;
+export interface AbilityResult {
+  /**
+   * Indicates the result code returned after the ability is destroyed. You can define the result
+   * code to identify an error.
+   * @default -
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   */
+  resultCode: number;
 
-    /**
-     * The module source path.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     moduleSourceDir: string;
+  /**
+   * Indicates the data returned after the ability is destroyed. You can define the data returned.
+   * This parameter can be null.
+   * @default -
+   * @devices phone, tablet
+   * @since 7
+   * @sysCap AAFwk
+   */
+  want?: Want;
 }
\ No newline at end of file
diff --git a/api/phone/app/appprocessstate.ts b/api/ability/startAbilityParameter.d.ts
old mode 100755
new mode 100644
similarity index 54%
rename from api/phone/app/appprocessstate.ts
rename to api/ability/startAbilityParameter.d.ts
index 8fa104c9b8829cf6bf00804e65ee77e183c16479..9d99dcb38d8f2b35293d1884089d0da46c20e334
--- a/api/phone/app/appprocessstate.ts
+++ b/api/ability/startAbilityParameter.d.ts
@@ -12,23 +12,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Want } from './want';
+
+export interface StartAbilityParameter {
+  /**
+   * Indicates the Want containing information about the target ability to start.
+   *
+   * @default -
+   * @devices phone, tablet
+   * @since 3
+   * @SysCap aafwk
+   */
+  want: Want;
+
+  /**
+   * Indicates the special start setting used in starting ability.
+   *
+   * @default -
+   * @devices phone, tablet
+   * @since 3
+   * @SysCap aafwk
+   */
+  abilityStartSetting?: {[key: string]: any};
 
-/**
- * @name AppProcessState
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export enum AppProcessState {
-    APP_STATE_BEGIN = 0,
-    APP_STATE_CREATE = APP_STATE_BEGIN,
-    APP_STATE_READY,
-    APP_STATE_FOREGROUND,
-    APP_STATE_BACKGROUND,
-    APP_STATE_SUSPENDED,
-    APP_STATE_TERMINATED,
-    APP_STATE_END,
 }
\ No newline at end of file
diff --git a/api/phone/@ohos.feature_ability.d.ts b/api/ability/want.d.ts
old mode 100755
new mode 100644
similarity index 36%
rename from api/phone/@ohos.feature_ability.d.ts
rename to api/ability/want.d.ts
index 38b5a4d604b95291f11e40eccfa2de2b9e06a341..af2183ded2e6bd1db19f78012e18925d70a88482
--- a/api/phone/@ohos.feature_ability.d.ts
+++ b/api/ability/want.d.ts
@@ -1,71 +1,105 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AsyncCallback } from './app/common';
-
-declare namespace featureAbility {
-  /**
-   * Destroys the current ability.
-   * @devices phone
-   * @since 6
-   * @sysCap AAFwk
-   * @param -
-   * @return -
-   * @testapi
-   */
-  function terminateAbility(callback: AsyncCallback<void>): void;
-
-  /**
-   * Destroys the current ability.
-   * @devices phone
-   * @since 6
-   * @sysCap AAFwk
-   * @param -
-   * @return -
-   * @testapi
-   */
-  function terminateAbility(): Promise<void>;
-
-  /**
-   * Starts a new ability.
-   * @devices phone
-   * @since 6
-   * @sysCap AAFwk
-   * @param param Indicates the ability to start.
-   * @return -
-   * @testapi
-   */
-  function startAbility(
-    param: StartAbilityParameter,
-    callback: AsyncCallback<void>,
-  ): void;
-
-  /**
-   * Starts a new ability.
-   * @devices phone
-   * @since 6
-   * @sysCap AAFwk
-   * @param param Indicates the ability to start.
-   * @return -
-   * @testapi
-   */
-  function startAbility(param: StartAbilityParameter): Promise<void>;
-
-  export interface StartAbilityParameter {
-    want: object;
-    abilityStartSetting?: object;
-  }
-}
-export default featureAbility;
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+  * Want is the basic communication component of the system.
+  * @name Want
+  * @since 6
+  * @sysCap AAFwk
+  * @devices phone, tablet
+  * @permission N/A
+  */
+export declare interface Want {
+  /**
+   * device id
+   * @default -
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   */
+  deviceId?: string;
+
+  /**
+   * bundle name
+   * @default -
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   */
+  bundleName?: string;
+
+  /**
+   * ability name
+   * @default -
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   */
+  abilityName?: string;
+
+  /**
+   * The description of a URI in a Want.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  uri?: string;
+
+  /**
+   * The description of the type in this Want.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  type?: string;
+
+  /**
+   * The options of the flags in this Want.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  flags?: number;
+
+  /**
+   * The description of an action in an want.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  action?: string;
+
+  /**
+   * The description of the WantParams object in an Want
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  parameters?: {[key: string]: any};
+
+  /**
+   * The description of a entities in a Want.
+   * @devices phone, tablet
+   * @since 6
+   * @sysCap AAFwk
+   * @default -
+   */
+  entities?: Array<string>;
+}
\ No newline at end of file
diff --git a/api/app/abilityMissionInfo.d.ts b/api/app/abilityMissionInfo.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eb7d23cb39eb5fc2f67e574533e21098018ea19b
--- /dev/null
+++ b/api/app/abilityMissionInfo.d.ts
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ElementName } from '../bundle/elementName';
+
+/**
+ * @name Mission information corresponding to ability
+ * @since 7
+ * @SysCap SystemCapability.Appexecfwk
+ * @import import AbilityMissionInfo from 'app/abilityMissionInfo'
+ * @permission N/A
+ * @devices phone, tablet, tv, wearable
+ */
+export interface AbilityMissionInfo {
+  /**
+   * @default Unique identification of task stack information corresponding to ability
+   * @since 7
+   * @SysCap SystemCapability.Appexecfwk
+   */
+  missionId: number;
+
+  /**
+   * @default The component launched as the first ability in the task stack
+   * This can be considered the "application" of this task stack
+   * @since 7
+   * @SysCap SystemCapability.Appexecfwk
+   */
+  bottomAbility: ElementName;
+
+  /**
+   * @default The ability component at the top of the history stack of the task
+   * This is what the user is currently doing
+   * @since 7
+   * @SysCap SystemCapability.Appexecfwk
+   */
+  topAbility: ElementName;
+
+  /**
+   * @default The corresponding ability description information in the task stack
+   * @since 7
+   * @SysCap SystemCapability.Appexecfwk
+   */
+  windowMode: number;
+}
+
diff --git a/api/phone/app/processinfo.d.ts b/api/app/activeProcessInfo.d.ts
old mode 100755
new mode 100644
similarity index 52%
rename from api/phone/app/processinfo.d.ts
rename to api/app/activeProcessInfo.d.ts
index 8865b22cc772632b79dd9122924c91bed52d2104..b2034d7b174c3556abf0d4033a1452c04ff31278
--- a/api/phone/app/processinfo.d.ts
+++ b/api/app/activeProcessInfo.d.ts
@@ -13,46 +13,40 @@
  * limitations under the License.
  */
 
-import { AppProcessState } from "./appprocessstate"
-
 /**
  * @name This class saves process information about an application
- * @since 6
- * @SysCap appexecfwk
- * @import N/A
+ * @since 7
+ * @SysCap SystemCapability.Appexecfwk
+ * @import import app from 'app/activeProcessInfo'
  * @permission N/A
- * @devices phone
- * @testapi
+ * @devices phone, tablet, tv, wearable
  */
+export interface ActiveProcessInfo {
+    /**
+     * @default process id
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
+     */
+    pid: number;
 
- export interface ProcessInfo {
     /**
-     * The name of the current process
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
+     * @default user id
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
      */
-     processName: string;
+    uid: number;
 
     /**
-     * The id of the current process
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
+     * @default the name of the process
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
      */
-     pid: number;
+    processName: string;
 
     /**
-     * Obtains the state of the current applicaiton process
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
+     * @default an array of the bundleNames running in the process
+     * @since 7
+     * @SysCap SystemCapability.Appexecfwk
      */
-     appProcessState: AppProcessState;
-}
\ No newline at end of file
+    bundleNames: Array<string>;
+}
diff --git a/api/app/context.d.ts b/api/app/context.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6cd07ed04b58fe4df9746ee0d11bc3a3bbd93519
--- /dev/null
+++ b/api/app/context.d.ts
@@ -0,0 +1,105 @@
+/*
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import { AsyncCallback } from '../basic';
+
+/**
+ * The context of anability or an application.  It allows access to
+ * application-specific resources, request and verification permissions.
+ * Can only be obtained through the ability.
+ *
+ * @since 6
+ * @SysCap SystemCapability.Appexecfwk
+ * @devices phone, tablet, tv, wearable
+ * @import import abilityManager from 'app/context'
+ * @permission N/A
+ */
+export interface Context {
+    /**
+    * Verify whether the specified permission is allowed for a particular
+    * pid and uid running in the system.
+    * @param permission The name of the specified permission
+    * @param pid process id
+    * @param uid user id
+    * @note Pid and uid are optional. If you do not pass in pid and uid,
+    * it will check your own permission.
+    * @since 7
+    * @sysCap SystemCapability.Appexecfwk
+    * @devices phone, tablet, tv, wearable
+    * @return asynchronous callback with {@code 0} if the PID
+    *         and UID have the permission; callback with {@code -1} otherwise.
+    */
+    verifyPermission(permission: string, options?: PermissionOptions): Promise<number>;
+    verifyPermission(permission: string, options: PermissionOptions, callback: AsyncCallback<number>): void;
+    verifyPermission(permission: string, callback: AsyncCallback<number>): void;
+
+    /**
+    * Requests certain permissions from the system.
+    * @param permissions Indicates the list of permissions to be requested. This parameter cannot be null.
+    * @param requestCode Indicates the request code to be passed to the PermissionRequestResult
+    * @since 7
+    * @sysCap SystemCapability.Appexecfwk
+    * @devices phone, tablet, tv, wearable
+    */
+    requestPermissionsFromUser(permissions: Array<string>, requestCode: number, resultCallback: AsyncCallback<PermissionRequestResult>): void;
+    requestPermissionsFromUser(permissions: Array<string>, requestCode: number): Promise<PermissionRequestResult>;
+
+}
+
+/**
+ * @name the result of requestPermissionsFromUser with asynchronous callback
+ * @since 7
+ * @SysCap SystemCapability.Appexecfwk
+ * @permission N/A
+ * @devices phone, tablet, tv, wearable
+ */
+interface PermissionRequestResult {
+    /**
+    * @default The request code passed in by the user
+    * @since 7
+    * @SysCap SystemCapability.Appexecfwk
+    */
+    requestCode: number;
+
+    /**
+    * @default The permissions passed in by the user
+    * @since 7
+    * @SysCap SystemCapability.Appexecfwk
+    */
+    permissions: Array<string>;
+
+    /**
+    * @default The results for the corresponding request permissions
+    * @since 7
+    * @SysCap SystemCapability.Appexecfwk
+    */
+    authResults: Array<number>;
+}
+
+interface PermissionOptions {
+ /**
+  * @default The process id
+  * @since 7
+  * @SysCap SystemCapability.Appexecfwk
+  */
+ pid?: number;
+
+ /**
+  * @default The user id
+  * @since 7
+  * @SysCap SystemCapability.Appexecfwk
+  */
+ uid?: number;
+}
\ No newline at end of file
diff --git a/api/phone/basic.d.ts b/api/basic.d.ts
old mode 100755
new mode 100644
similarity index 100%
rename from api/phone/basic.d.ts
rename to api/basic.d.ts
diff --git a/api/phone/commonevent/commoneventdata.d.ts b/api/commonEvent/commonEventData.d.ts
old mode 100755
new mode 100644
similarity index 78%
rename from api/phone/commonevent/commoneventdata.d.ts
rename to api/commonEvent/commonEventData.d.ts
index 0d8f039d3641caccad1e261b7af0f81292507266..6447604ca61ad1292d2b0a7b41376d1fd2c24228
--- a/api/phone/commonevent/commoneventdata.d.ts
+++ b/api/commonEvent/commonEventData.d.ts
@@ -16,28 +16,21 @@
 /**
  * the data of the commonEvent
  * @name CommonEventData
- * @since 6
- * @sysCap ces
- * @devices phone
+ * @since 7
  * @permission N/A
- * @testapi
  */
 export interface CommonEventData {
   /**
    * event type
    * @default -
-   * @devices phone, tablet
-   * @since 6
-   * @sysCap AAFwk
+   * @since 7
    */
   event: string
 
   /**
    * bundle name
    * @default -
-   * @devices phone, tablet
-   * @since 6
-   * @sysCap AAFwk
+   * @since 7
    */
   bundleName?: string;
 
@@ -45,9 +38,7 @@ export interface CommonEventData {
    * The custom result code of the common event.
    *
    * @default 0
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   code?: number;
 
@@ -55,9 +46,7 @@ export interface CommonEventData {
    * The custom result data of the common event.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   data?: string;
 }
diff --git a/api/phone/commonevent/commoneventpublishdata.d.ts b/api/commonEvent/commonEventPublishData.d.ts
old mode 100755
new mode 100644
similarity index 78%
rename from api/phone/commonevent/commoneventpublishdata.d.ts
rename to api/commonEvent/commonEventPublishData.d.ts
index e15adc931ad6d61780fa215759e26e76ce36acd3..b9e46b93b092abdb8030c419408a2b1624d7fff8
--- a/api/phone/commonevent/commoneventpublishdata.d.ts
+++ b/api/commonEvent/commonEventPublishData.d.ts
@@ -16,19 +16,14 @@
 /**
  * containing the common event content and attributes
  * @name CommonEventPublishData
- * @since 6
- * @sysCap ces
- * @devices phone
+ * @since 7
  * @permission N/A
- * @testapi
  */
 export interface CommonEventPublishData {
   /**
    * bundle name
    * @default -
-   * @devices phone, tablet
-   * @since 6
-   * @sysCap AAFwk
+   * @since 7
    */
   bundleName?: string;
 
@@ -36,9 +31,7 @@ export interface CommonEventPublishData {
    * The custom result code of the common event.
    *
    * @default 0
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   code?: number;
 
@@ -46,9 +39,7 @@ export interface CommonEventPublishData {
    * The custom result data of the common event.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   data?: string;
 
@@ -56,9 +47,7 @@ export interface CommonEventPublishData {
    * The permissions for subscribers. Only subscribers with required permissions can receive published common events.
    *
    * @default -
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   subscriberPermissions?: Array<string>;
 
@@ -66,9 +55,7 @@ export interface CommonEventPublishData {
    * Whether the type of a common event is ordered or not.
    *
    * @default false
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   isOrdered?: boolean;
 
@@ -76,9 +63,7 @@ export interface CommonEventPublishData {
    * Whether the type of a common event is sticky or not.
    *
    * @default false
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   isSticky?: boolean;
 }
\ No newline at end of file
diff --git a/api/phone/commonevent/commoneventsubscribeinfo.d.ts b/api/commonEvent/commonEventSubscribeInfo.d.ts
old mode 100755
new mode 100644
similarity index 81%
rename from api/phone/commonevent/commoneventsubscribeinfo.d.ts
rename to api/commonEvent/commonEventSubscribeInfo.d.ts
index 98e82a64771ae4961439fb72bfc57e64b4010ddb..32ff8798fb3ce0e8d3276845e189e64a7f663e4a
--- a/api/phone/commonevent/commoneventsubscribeinfo.d.ts
+++ b/api/commonEvent/commonEventSubscribeInfo.d.ts
@@ -16,11 +16,8 @@
 /**
  * the information of the subscriber
  * @name CommonEventSubscribeInfo
- * @since 6
- * @sysCap ces
- * @devices phone
+ * @since 7
  * @permission N/A
- * @testapi
  */
 export interface CommonEventSubscribeInfo {
   /**
@@ -28,9 +25,7 @@ export interface CommonEventSubscribeInfo {
    * This subscriber receives only common events sent by publishers granted with this permission.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   events: Array<string>
 
@@ -39,9 +34,7 @@ export interface CommonEventSubscribeInfo {
    * This subscriber receives only common events sent by publishers granted with this permission.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   publisherPermission?: string;
 
@@ -49,9 +42,7 @@ export interface CommonEventSubscribeInfo {
    * deviceId Indicates the device ID. The value must be an existing device ID on the same ohos network.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   publisherDeviceId?: string;
 
@@ -60,9 +51,7 @@ export interface CommonEventSubscribeInfo {
   * current user. If this parameter is specified, the value must be an existing user ID in the system.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   userId?: number;
 
@@ -70,9 +59,7 @@ export interface CommonEventSubscribeInfo {
    * Indicates the subscriber priority. The value ranges from -100 to 1000.
    *
    * @default ""
-   * @devices phone, tablet
-   * @since 6
-   * @SysCap ces
+   * @since 7
    */
   priority?: number;
 }
\ No newline at end of file
diff --git a/api/phone/commonevent/commoneventsubscriber.d.ts b/api/commonEvent/commonEventSubscriber.d.ts
old mode 100755
new mode 100644
similarity index 32%
rename from api/phone/commonevent/commoneventsubscriber.d.ts
rename to api/commonEvent/commonEventSubscriber.d.ts
index 4a7b64c3d79210ed064c8868f275807953965285..65e5aba3537b2b8ea2080f0f63e701c46cae7435
--- a/api/phone/commonevent/commoneventsubscriber.d.ts
+++ b/api/commonEvent/commonEventSubscriber.d.ts
@@ -13,88 +13,218 @@
  * limitations under the License.
  */
 import { AsyncCallback } from './../basic';
-import { CommonEventSubscribeInfo } from './commoneventsubscribeinfo';
+import { CommonEventSubscribeInfo } from './commonEventSubscribeInfo';
 
 /**
  * the subscriber of common event
  * @name CommonEventSubscriber
- * @since 6
- * @sysCap ces
- * @devices phone
+ * @since 7
  * @permission N/A
- * @testapi
  */
 export interface CommonEventSubscriber {
+  /**
+   * Obtains the result code of the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getCode(callback: AsyncCallback<number>): void;
+
+  /**
+   * Obtains the result code of the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getCode(): Promise<number>;
+
+  /**
+   * Sets the result code of the current ordered common event.
+   *
+   * @since 7
+   * @param code Indicates the custom result code to set. You can set it to any value.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setCode(code: number, callback: AsyncCallback<void>): void;
+
+  /**
+   * Sets the result code of the current ordered common event.
+   *
+   * @since 7
+   * @param code Indicates the custom result code to set. You can set it to any value.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setCode(code: number): Promise<void>;
+
+  /**
+   * Obtains the result data of the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getData(callback: AsyncCallback<string>): void;
+
+  /**
+   * Obtains the result data of the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getData(): Promise<string>;
+
+  /**
+   * Sets the result data of the current ordered common event.
+   *
+   * @since 7
+   * @param data Indicates the custom result data to set. You can set it to any character string.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setData(data: string, callback: AsyncCallback<void>): void;
+
+  /**
+   * Sets the result data of the current ordered common event.
+   *
+   * @since 7
+   * @param data Indicates the custom result data to set. You can set it to any character string.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setData(data: string): Promise<void>;
+
+  /**
+   * Sets the result of the current ordered common event.
+   *
+   * @since 7
+   * @param code Indicates the custom result code to set. You can set it to any value.
+   * @param data Indicates the custom result data to set. You can set it to any character string.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setCodeAndData(code: number, data: string, callback: AsyncCallback<void>): void;
+
+  /**
+   * Sets the result of the current ordered common event.
+   *
+   * @since 7
+   * @param code Indicates the custom result code to set. You can set it to any value.
+   * @param data Indicates the custom result data to set. You can set it to any character string.
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  setCodeAndData(code: number, data: string): Promise<void>;
 
   /**
    * Checks whether the current common event is an ordered common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   isOrderedCommonEvent(callback: AsyncCallback<boolean>): void;
 
   /**
    * Checks whether the current common event is an ordered common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   isOrderedCommonEvent(): Promise<boolean>;
 
   /**
    * Checks whether the current common event is a sticky common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   isStickyCommonEvent(callback: AsyncCallback<boolean>): void;
 
   /**
    * Checks whether the current common event is a sticky common event.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   isStickyCommonEvent(): Promise<boolean>;
 
+  /**
+   * Aborts the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  abortCommonEvent(callback: AsyncCallback<void>): void;
+
+  /**
+   * Aborts the current ordered common event.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  abortCommonEvent(): Promise<void>;
+
+  /**
+   * Clears the abort state of the current ordered common event
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  clearAbortCommonEvent(callback: AsyncCallback<void>): void;
+
+  /**
+   * Clears the abort state of the current ordered common event
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  clearAbortCommonEvent(): Promise<void>;
+
+  /**
+   * Checks whether the current ordered common event should be aborted.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getAbortCommonEvent(callback: AsyncCallback<boolean>): void;
+
+  /**
+   * Checks whether the current ordered common event should be aborted.
+   *
+   * @since 7
+   * @param callback Indicate the callback funtion to receive the common event.
+   * @return -
+   */
+  getAbortCommonEvent(): Promise<boolean>;
+
   /**
    * get the CommonEventSubscribeInfo of this CommonEventSubscriber.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   getSubscribeInfo(callback: AsyncCallback<CommonEventSubscribeInfo>): void;
 
   /**
    * get the CommonEventSubscribeInfo of this CommonEventSubscriber.
    *
-   * @devices phone
-   * @since 6
-   * @SysCap ces
+   * @since 7
    * @param callback Indicate the callback funtion to receive the common event.
    * @return -
-   * @testapi
    */
   getSubscribeInfo(): Promise<CommonEventSubscribeInfo>;
 }
diff --git a/api/form/action/form-schema.json b/api/form/action/form-schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..cc2104a42b1e5ecd09454a14b7bc984b05413e81
--- /dev/null
+++ b/api/form/action/form-schema.json
@@ -0,0 +1,18 @@
+{
+  "type": "object",
+  "additionalProperties": false,
+  "properties":{
+    "data": {
+      "type": "object",
+      "description": "Defines variables."
+    },
+    "actions": {
+      "type": "object",
+      "description": "Defines events."
+    },
+    "apiVersion": {
+      "type": "object",
+      "description": "Defines api version compatibility information."
+    }
+  }
+}
diff --git a/api/form/css/css-json-schema.json b/api/form/css/css-json-schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..40ef282b6928113f60479fd5fe7edab544e328fc
--- /dev/null
+++ b/api/form/css/css-json-schema.json
@@ -0,0 +1,283 @@
+{
+  "type": "object",
+  "properties": {
+    "properties": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性支持所有的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "syntax": {
+            "type": "array",
+            "description": "语法",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "支持<length>、<color>、<percentage> 、<line-width>、<line-style>、<repeat-style>、<time>、<transform-list>等内置类型单个或多个(||分割)"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "version": {
+            "type": "array",
+            "description": "该属性的当前的版本",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "版本号例如:v3.0"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "description": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "属性的描述文档"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "restrictions": {
+            "type": "array",
+            "description": "语法限制",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "array",
+                  "description": "语法限制,单个或多个组合",
+                  "items": {
+                    "type": "string",
+                    "enum": [
+                      "enum",
+                      "length",
+                      "line-style",
+                      "color",
+                      "percentage",
+                      "image",
+                      "string",
+                      "repeat",
+                      "position",
+                      "identifier",
+                      "number",
+                      "time"
+                    ]
+                  }
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "values": {
+            "type": "array",
+            "description": "当restrictions字段存在enum时存在该字段,表示该属性对应的值的可选值",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "可选值"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                },
+                "description": {
+                  "type": "string"
+                }
+              },
+              "required": ["name"]
+            }
+          }
+        },
+        "required": ["name", "version", "description"]
+      }
+    },
+    "atDirectives": {
+      "type": "array",
+      "description": "指令列表",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "指令名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性支持所有的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "version": {
+            "type": "array",
+            "description": "版本",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "版本号eg: v3.0"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承指令支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "description": {
+            "type": "array",
+            "description": "指令的描述",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承指令支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          }
+        }
+      }
+    },
+    "pseudoClasses": {
+      "type": "array",
+      "description": "伪类列表",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "伪类名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该伪类支持所有的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "version": {
+            "type": "array",
+            "description": "版本",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "版本号eg: v3.0"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该伪类继承指令支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "description": {
+            "type": "array",
+            "description": "伪类的描述",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该伪类继承指令支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          }
+        }
+      }
+    }
+  },
+  "required": ["properties", "atDirectives", "pseudoClasses"]
+}
diff --git a/api/form/css/cssConfig.json b/api/form/css/cssConfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..b2ab859a2740259ef48c232e8e2a89b86656f401
--- /dev/null
+++ b/api/form/css/cssConfig.json
@@ -0,0 +1,5437 @@
+{
+  "properties": [
+    {
+      "name": "column-span",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of columns occupied by the current list-item in the list. By default, the list-item occupies one column. This attribute is valid only when the list contains multiple columns"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "width",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Component width. If this attribute is not set, the width required for the element content is used",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "height",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Component height. If this attribute is not set, the height required for the element content is used",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "padding",
+      "syntax": [
+        {
+          "name": "<length>{1,4} || <percentage>{1,4}",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The attribute can have one to four values: 1. If you set a value, it specifies the padding for four sides; 2. If you set two values, the first value specifies the top and bottom padding, and the second value specifies the left and right padding; 3. If you set three values, the first value specifies the top padding, the second value specifies the left and right padding, and the third value specifies the bottom padding; 4. If you set four values, they respectively specify the padding for top, right, bottom, and left sides (in clockwise order)",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-left",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Left padding (in px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-top",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Top padding (in px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-right",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Right padding (in px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-bottom",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Bottom padding (in px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-start",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Start padding"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "padding-end",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "End padding"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "margin",
+      "syntax": [
+        {
+          "name": "<length>{1,4} || <percentage>{1,4}"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set margins for all sides in a declaration. You can set one to four values: 1. One value: specifies the margin for all the four sides; 2. Two values: The first value is for the top and bottom sides, and the second value is for the left and right sides; 3. Three values: The first value is for the top, the second value for the left and right, and the third value for the bottom; 4. They are margins for top, right, bottom, and left sides, respectively"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-left",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Left margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-top",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Top margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-right",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Right margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-bottom",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Bottom margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-start",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Start margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "margin-end",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "End margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "border",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<line-width> || <line-style> || <color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set all boarders. You can set border-width, border-style, and border-color in sequence. Default values are used for attributes that are not set"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "line-style", "color"]
+        }
+      ]
+    },
+    {
+      "name": "border-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the style of all borders. The available values are as follows: 1. dotted: Dotted border. The radius of a dot is half of border-width;2. dashed: Dashed border;3. solid: Solid border;"
+        }
+      ],
+      "values": [
+        {
+          "name": "dotted"
+        },
+        {
+          "name": "dashed"
+        },
+        {
+          "name": "solid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "border-image-source",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "border image."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "string"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-image-slice",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The border of the image is shifted inward"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-image-width",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Width about the border of the image"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-image-outset",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The border image can exceed the size of the border box"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-image-repeat",
+      "syntax": [
+        {
+          "name": "stretch | repeat | round"
+        }
+      ],
+      "values": [
+        {
+          "name": "stretch",
+          "description": "Stretch the picture to fill the border"
+        },
+        {
+          "name": "repeat",
+          "description": "Tile the picture to fill the border"
+        },
+        {
+          "name": "round",
+          "description": "Tile the picture according to the image size"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How the picture fills the border"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-image",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "<line-source> || <line-slice> || <line-width> || <line-outset> || <line-repeat>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The image of border attributes"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "string",
+            "length",
+            "length",
+            "length",
+            "string"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "object-position",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet"
+      ],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "image position"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "string"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "previous-margin",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The previous margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "next-margin",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The next margin"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "border-left-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Styles of the left borders. The available values are dotted, dashed, and solid"
+        }
+      ],
+      "values": [
+        {
+          "name": "dotted"
+        },
+        {
+          "name": "dashed"
+        },
+        {
+          "name": "solid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "border-top-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Styles of the top borders. The available values are dotted, dashed, and solid"
+        }
+      ],
+      "values": [
+        {
+          "name": "dotted"
+        },
+        {
+          "name": "dashed"
+        },
+        {
+          "name": "solid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "border-right-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Styles of the right borders. The available values are dotted, dashed, and solid"
+        }
+      ],
+      "values": [
+        {
+          "name": "dotted"
+        },
+        {
+          "name": "dashed"
+        },
+        {
+          "name": "solid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Styles of the bottom borders. The available values are dotted, dashed, and solid"
+        }
+      ],
+      "values": [
+        {
+          "name": "dotted"
+        },
+        {
+          "name": "dashed"
+        },
+        {
+          "name": "solid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "border-left",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the boarders for every sides respectively. You can set border-width, border-style and border-color in sequence. Default values are used for attributes that are not set"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<line-width> || <line-style> || <color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "line-style", "color"]
+        }
+      ]
+    },
+    {
+      "name": "border-top",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the boarders for every sides respectively. You can set border-width, border-style and border-color in sequence. Default values are used for attributes that are not set"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<line-width> || <line-style> || <color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "line-style", "color"]
+        }
+      ]
+    },
+    {
+      "name": "border-right",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the boarders for every sides respectively. You can set border-width, border-style and border-color in sequence. Default values are used for attributes that are not set"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<line-width> || <line-style> || <color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "line-style", "color"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the boarders for every sides respectively. You can set border-width, border-style and border-color in sequence. Default values are used for attributes that are not set"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<line-width> || <line-style> || <color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "line-style", "color"]
+        }
+      ]
+    },
+    {
+      "name": "border-width",
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the width of all borders, or separately set the width of each border"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-left-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set widths of left borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-top-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set widths of top borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-right-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set widths of right borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set widths of right borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-color",
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Shorthand attribute to set the color of all borders, or separately set the color of each border"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<color>{1,4}"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "border-left-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set colors of left borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "border-top-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set colors of top borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "border-right-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set colors of right borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set colors of bottom borders"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "border-radius",
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to set the radius of round borders of an element. This attribute cannot be used to set the width, color, or style of a specific border. To set the width or color, you need to set border-width, border-color, or border-style for all the borders at the same time.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-top-left-radius",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to receptively set the radius of the upper-left rounded corner"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-top-right-radius",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to receptively set the radius of the upper-right rounded corner"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom-left-radius",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to receptively set the radius of the lower-left rounded corner"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "border-bottom-right-radius",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Attribute to receptively set the radius of the lower-right rounded corner"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "align-self",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "values": [
+        {
+          "name": "stretch"
+        },
+        {
+          "name": "flex-start"
+        },
+        {
+          "name": "flex-end"
+        },
+        {
+          "name": "center"
+        },
+        {
+          "name": "baseline"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Set the alignment of itself on the cross axis of the parent element. This style will override the align-items style of the parent element.  It is only supported when the parent container is div or list"
+        },
+        {
+          "syntax": [
+            {
+              "name": "stretch | flex-start | flex-end | center | baseline"
+            }
+          ]
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "start",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The start property specifies the starting edge of the element. This attribute defines the offset between the start outer margin boundary of the positioning element and the start boundary of the containing block."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "end",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The end property specifies the end edge of the element. This attribute defines the offset between the end margin boundary of an anchor element and the end boundary of its containing block."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "z-index",
+      "syntax": [
+        {
+          "name": "number"
+        }
+      ],
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents the rendering order of its children for the same parent node.The higher the value, the lower the rendering data."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "number"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "image-fill",
+      "syntax": [
+        {
+          "name": "color"
+        }
+      ],
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Fills colors for svg images. The following components can be used to set image resource attributes: button (icon attribute), piece (icon attribute), search (icon attribute), input (headicon attribute), textarea (headicon attribute), and image (src attribute)., navigation-bar(logo/starticon/endicon), toolbar-item (icon attribute)."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "color"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "clip-path",
+      "supportedDevices":[
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "[<geometry-box> || <basic-shape> ] | none"
+        }
+      ],
+      "values": [
+        {
+          "name": "border-box"
+        },
+        {
+          "name": "margin-box"
+        },
+        {
+          "name": "padding-box"
+        },
+        {
+          "name": "content-box"
+        },
+        {
+          "name": "inset()"
+        },
+        {
+          "name": "circle()"
+        },
+        {
+          "name": "ellipse()"
+        },
+        {
+          "name": "polygon()"
+        },
+        {
+          "name": "path()"
+        }
+      ],
+      "version":[
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Set the clip area of the component. Part of the area is displayed, and the area outside is not displayed"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "mask-image",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "values":[
+        {
+          "name": "url()"
+        },
+        {
+          "name": "linear-gradient()"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "This attribute supports Gradient Styles or SVG URL"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "mask-size",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "[ contain | cover | auto | <length> | <percentage> ]"
+        }
+      ],
+      "values": [
+        {
+          "name": "contain"
+        },
+        {
+          "name": "cover"
+        },
+        {
+          "name": "auto"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Specifies the display size of a mask image. This parameter is valid only when mask-image is an image resource.\nThe options are as follows:\ncontain: Extends the image to its maximum size so that its height and width are fully appropriate for the content area.\ncover: Expand the image to a large enough size so that the background image completely covers the background area. Some parts of the background image may not be displayed in the background anchor area.\nauto: Keep the original image scale unchanged.\nlength: Set the height and width of the image. The first value sets the width and the second value sets the height. If you set only one value, the second value is set to \"auto\".\nPercentage: Set the width and height of the original image as a percentage of the width and height of the original image. The first value sets the width and the second value sets the height. If you set only one value, the second value is set to \"auto\"."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum",
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "mask-position",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "[ <bg-position> | <length> | <percentage> ]"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Using keywords: If only one keyword is specified, the second value is center. The two values define the horizontal position and vertical position respectively. −left: leftmost in the horizontal direction −right: rightmost in the horizontal direction −top: top in the vertical direction −bottom: bottom in the vertical direction −center: center position 1. Using <length>: The first value indicates the horizontal position, and the second value indicates the vertical position. The values are in the Xpx Ypx format. 0 0 indicates the upper left corner. If only one value is specified, the other one is 50%. 2.Using <percentage>: The first value indicates the horizontal position, and the second value indicates the vertical position. 0% 0% indicates the upper left corner. 100% 100% indicates the lower right corner. If only one value is specified, the other one is 50%. 3.Using both <percentage> and <length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "position",
+            "length",
+            "percentage"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "background",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "This attribute supports Gradient Styles but is not compatible with background-color or background-image"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["image"]
+        }
+      ]
+    },
+    {
+      "name": "background-color",
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Background color"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "background-image",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Background image. Currently, this attribute is not compatible with background-color or border-color. Both Internet and local image resources are supported"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "background-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "contain"
+        },
+        {
+          "name": "cover"
+        },
+        {
+          "name": "auto"
+        }
+      ],
+      "syntax": [
+        {
+          "name": "[ contain | cover | auto | <length> | <percentage> ]"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Background image size. The string values are as follows: − contain: Expands the image to the maximum size so that the height and width of the image are applicable to the content area. − cover: Extends the background image to a large enough size so that the background image completely covers the background area. Some parts of the image may not be displayed in the background localization area. − auto: The original image width-height ratio is retained. The two <length> values are as follows: Height and width of the background image. The first value indicates the width, and the second value indicates the height. If you only set one value, the second value is set to auto by default. 2. The two <percentage> values are as follows: Width and height of the background image in percentage of the parent element. The first value indicates the width, and the second value indicates the height. If you only set one value, the other value is set to auto by default"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum", "length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "background-repeat",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<repeat-style>#"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Repeating attribute of a background image. By default, a background image is repeated both horizontally and vertically. 1. repeat: Draws images along the x axis and y axis at the same time. 2. repeat-x: Draws images along the x axis. 3. repeat-y: Draws images along the y axis. 4. no-repeat: The image is not drawn repeatedly."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["repeat"]
+        }
+      ]
+    },
+    {
+      "name": "background-position",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<bg-position>#"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Using keywords: If only one keyword is specified, the second value is center. The two values define the horizontal position and vertical position respectively. −left: leftmost in the horizontal direction −right: rightmost in the horizontal direction −top: top in the vertical direction −bottom: bottom in the vertical direction −center: center position 1. Using <length>: The first value indicates the horizontal position, and the second value indicates the vertical position. The values are in the Xpx Ypx format. 0 0 indicates the upper left corner. If only one value is specified, the other one is 50%. 2.Using <percentage>: The first value indicates the horizontal position, and the second value indicates the vertical position. 0% 0% indicates the upper left corner. 100% 100% indicates the lower right corner. If only one value is specified, the other one is 50%. 3.Using both <percentage> and <length>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["position", "length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "opacity",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Transparency of an element. The value ranges from 0 to 1. 1 indicates opaque, and 0 indicates completely transparent"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "display",
+      "values": [
+        {
+          "name": "flex",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "none",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Type of the view box of the element. Currently, dynamic modification is not supported. Available values are as follows:  flex: flexible layout;  none: This item is hidden"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "visibility",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "visible",
+          "description": "The element is visible"
+        },
+        {
+          "name": "hidden",
+          "description": "The element is hidden but still takes up space"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether to display an element. Invisible borders occupy layout space (set the display attribute to none to hide the borders). The values are as follows: 1. visible: The element is visible. 2. hidden: The element is hidden but still takes up space. NOTE If both visibility and display are set, only display takes effect."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "flex",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How to divide available space of the parent component for a child component. It is used as a shorthand attribute to set the flex-grow attribute of the parent component. NOTE This attribute takes effect only when the parent component is <div>, <list-item>, or <tabs>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "flex-grow",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How much a child component will grow. The value specifies allocation of the remaining space on the main axis of the parent component. Size of available space = Container size - Total size of all child components. Value 0 indicates that the child component does not grow. NOTE: This attribute takes effect only when the parent component is <div>, <list-item>, or <tabs>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "flex-shrink",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How much child component will shrink. The shrink occurs only when the sum of default item widths is greater than that of the parent component. Value 0 indicates that the child component does not shrink. NOTE: This attribute takes effect only when the parent component is <div>, <list-item>, or <tabs>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "flex-basis",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Initial length of the flex item on the main axis. NOTE: This attribute takes effect only when the parent component is <div>, <list-item>, or <tabs>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "position",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "fixed"
+        },
+        {
+          "name": "absolute"
+        },
+        {
+          "name": "relative"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Positioning type of an element. Dynamic changes are not supported. 1. fixed: The element is positioned related to the browser window. 2. absolute: The element is positioned absolutely to its parent element. 3. relative: The element is positioned relative to its normal position. NOTE: The absolute attribute takes effect only when the parent component is <div> or <stack>"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "left",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "left must be used together with position to determine the offset position of an element. The left attribute specifies the left edge position of the element. This attribute defines the offset between the left edge of a positioned element and that of a block included in the element"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "top",
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "top must be used together with position to determine the offset position of an element. The top attribute specifies the top edge position of the element. This attribute defines the offset between the top edge of a positioned element and that of a block included in the element"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "right",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "right must be used together with position to determine the offset position of an element. The right attribute specifies the right edge position of the element. This attribute defines the offset between the right edge of a positioned element and that of a block included in the element"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "bottom",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "bottom must be used together with position to determine the offset position of an element. The bottom attribute specifies the bottom edge position of the element. This attribute defines the offset between the bottom edge of a positioned element and that of a block included in the element"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "transform-origin",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "0px 0px"
+        },
+        {
+          "name": "0% 0%"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Origin position of the transformed element. The unit can be px or a percentage (relative to the animation target component), for example, 50px 100px or 50% 50%."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "transform",
+      "values": [
+        {
+          "name": "translate()",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "translateX()"
+        },
+        {
+          "name": "translateY()"
+        },
+        {
+          "name": "scale()",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "scaleX()",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "scaleY()",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "rotate()"
+        },
+        {
+          "name": "rotateX('angle')",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "rotateY('angle')",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "syntax": [
+        {
+          "name": "<transform-list>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Translation, rotation, and scaling attributes"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "animation-name",
+      "syntax": [
+        {
+          "name": "[ none | <keyframes-name> ]#"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "@keyframes rule"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["identifier"]
+        }
+      ]
+    },
+    {
+      "name": "animation-delay",
+      "syntax": [
+        {
+          "name": "<time>#"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Delay for playing the animation, in ms or s, for example, 1000 ms or 1s. The default unit is ms."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["time"]
+        }
+      ]
+    },
+    {
+      "name": "animation-duration",
+      "syntax": [
+        {
+          "name": "<time>#"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Animation duration, in ms or s, for example, 1000 ms or 1s. The default unit is ms. NOTE: For basic watches, the maximum animation duration is 60s. animation-duration must be specified. Otherwise, the duration is 0, which means the animation will not be played"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["time"]
+        }
+      ]
+    },
+    {
+      "name": "animation-iteration-count",
+      "syntax": [
+        {
+          "name": "<single-animation-iteration-count>#"
+        }
+      ],
+      "values": [
+        {
+          "name": "infinite"
+        },
+        {
+          "name": "1"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of times that an animation is played. The animation is played once by default. You can set the value to infinite to play the animation infinitely"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number", "enum"],
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "animation-timing-function",
+      "syntax": [
+        {
+          "name": "linear | ease-in | ease-out | ease-in-out"
+        }
+      ],
+      "values": [
+        {
+          "name": "linear"
+        },
+        {
+          "name": "ease",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "ease-in"
+        },
+        {
+          "name": "ease-out"
+        },
+        {
+          "name": "ease-in-out"
+        },
+        {
+          "name": "fast-out-slow-in",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "linear-out-slow-in",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "fast-out-linear-in",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "friction",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "extreme-deceleration",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "sharp",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "rhythm",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "smooth",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "cubic-bezier",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Speed curve of an animation, which makes the animation more fluent. Available values include: linear: The animation speed keeps unchanged; ease: The animation starts at a low speed and then accelerates. It slows down before the animation ends. cubic-bezier(0.25, 0.1, 0.25, 1.0); ease-in: The animation starts at a low speed. cubic-bezier(0.42, 0.0, 1.0, 1.0); ease-out: The animation ends at a low speed. cubic-bezier(0.0, 0.0, 0.58, 1.0); ease-in-out: The animation starts and ends at a low speed. cubic-bezier(0.42, 0.0, 0.58, 1.0); fast-out-slow-in: Standard curve, cubic-bezier(0.4, 0.0, 0.2, 1.0); linear-out-slow-in: Deceleration curve, cubic-bezier(0.0, 0.0, 0.2, 1.0); fast-out-linear-in: Acceleration curve, cubic-bezier(0.4, 0.0, 1.0, 1.0); friction: Damping curve, cubic-bezier(0.2, 0.0, 0.2, 1.0);extreme-deceleration: Extreme deceleration curve, cubic-bezier(0.0, 0.0, 0.0, 1.0) curve; sharp: Sharp curve, cubic-bezier(0.33, 0.0, 0.67, 1.0); rhythm: Rhythm curve, cubic-bezier(0.7, 0.0, 0.2, 1.0); smooth: Smooth curve, cubic-bezier(0.4, 0.0, 0.4, 1.0); cubic-bezier: You can customize an animation speed curve in the cubic-bezier() function. The x and y values of each input parameter must be between 0 and 1"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "animation-fill-mode",
+      "syntax": [
+        {
+          "name": "forwards | none"
+        }
+      ],
+      "values": [
+        {
+          "name": "forwards"
+        },
+        {
+          "name": "none"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether to restore the initial state after the animation is executed. Available values include: none: The initial state is restored after the animation is executed; forwards: The state at the end of the animation (defined in the last key frame) is retained after the animation is executed"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "shared-transition-effect",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "exchange"
+        },
+        {
+          "name": "static"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Entry style of shared elements during the transition, which can be exchange or static.During the transition, the style configured on the target page takes effect preferentially. exchange: The source page element is moved to the position of the target page element and is zoomed in or out properly. static: The position of the target page element remains unchanged. You can configure the transparency animation. Currently, only the static effect configured on the target page takes effect"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "shared-transition-name",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "During the transition, the style configured on the target page takes effect preferentially. This style is used to configure the animation effect of shared elements. The animation effect is an animation sequence defined by @keyframes supporting transform and transparency animations. If the effect of the shared element conflicts with the custom animation, the latter is used"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "shared-transition-timing-function",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "friction"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "During the transition, the style configured on the target page takes effect preferentially. This attribute defines the difference curve during the transition of shared elements. The friction curve is used by default if this parameter is not configured"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "transition-enter",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Related to @keyframes, which supports transform and transparent animations"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "transition-exit",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Related to @keyframes, which supports transform and transparent animations"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "transition-duration",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "The unit can be s or ms. The default unit is ms"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["time"]
+        }
+      ]
+    },
+    {
+      "name": "transition-timing-function",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "friction"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Speed curve of executing transition animation for smoother transition. For details about the parameters, see the description of the valid values of animation-timing-function"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "flex-direction",
+      "syntax": [
+        {
+          "name": "column | row"
+        }
+      ],
+      "values": [
+        {
+          "name": "column"
+        },
+        {
+          "name": "row"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Main axis direction of the flex container. Available values are as follows: column: Items are placed vertically from top to bottom; row: Items are placed horizontally from left to right"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "flex-wrap",
+      "syntax": [
+        {
+          "name": "nowrap | wrap"
+        }
+      ],
+      "values": [
+        {
+          "name": "nowrap"
+        },
+        {
+          "name": "wrap"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether flex items in the container are displayed in a single line or multiple lines. Currently, dynamic modification is not supported. Available values are as follows: nowrap: Items are displayed on a single axis; wrap: Items are displayed on multiple axes."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "justify-content",
+      "syntax": [
+        {
+          "name": "flex-start | flex-end | center | space-between | space-around | space-evenly"
+        }
+      ],
+      "values": [
+        {
+          "name": "flex-start"
+        },
+        {
+          "name": "flex-end"
+        },
+        {
+          "name": "center"
+        },
+        {
+          "name": "space-between"
+        },
+        {
+          "name": "space-around"
+        },
+        {
+          "name": "space-evenly"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How items are aligned along the main axis of the current line in a flex container. Available values are as follows: flex-start: Items are packed towards the start line. flex-end: Items are packed towards the end line. center: Items are centered along the line. space-between: Items are positioned with space between the lines. space-around: Items are positioned with space before, between, and after the lines."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "align-items",
+      "values": [
+        {
+          "name": "stretch",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "flex-start"
+        },
+        {
+          "name": "flex-end"
+        },
+        {
+          "name": "center"
+        },
+        {
+          "name": "baseline"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "How items are aligned along the cross axis of the current line in a flex container. Available values are as follows: stretch: Items are stretched to the same height or width as the container in the cross axis direction; flex-start: Items are aligned to the start of the cross axis; flex-end: Items are aligned to the end of the cross axis; center: Items are aligned in the middle of the cross axis"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "align-content",
+      "syntax": [
+        {
+          "name": "normal | <baseline-position> | <content-distribution> | <overflow-position>? <content-position>"
+        }
+      ],
+      "values": [
+        {
+          "name": "center",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "flex-start"
+        },
+        {
+          "name": "flex-end"
+        },
+        {
+          "name": "space-between",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "space-around",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Multi-line alignment mode when there is extra space in the cross axis. Available values are as follows: flex-start: All lines are packed towards the start of the cross axis. The start edge of the cross axis of the first line is aligned with the start edge of the cross axis of the container. All subsequent lines are aligned with the previous line; flex-end: All lines are packed towards the end of the cross axis. The end of the cross axis of the last line is aligned with the end of the cross axis of the container. All subsequent lines are aligned with the previous line; center: All lines are packed towards the center of the container. Lines are close to each other and aligned with the center of the container. The spacing between the start of the container's cross axis and the first line is equal to the spacing between the end of the container's cross axis and the last line; space-between: All lines are evenly distributed in the container. The spacing between two adjacent lines is the same. The start and end edges of the container's cross axis are aligned with the edges of the first and last lines, respectively; space-around: All lines are evenly distributed in the container, and the spacing between two adjacent lines is the same. The spacing between the start edge of the container's cross axis and the first line and that between the end edge and the last line are half of the spacing between two adjacent lines."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "grid-template-columns",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of columns in the current grid layout. If this attribute is not set, one row and one column are displayed by default. This attribute is valid only when display is set to grid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "grid-template-rows",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of rows in the current grid layout. If this attribute is not set, one row and one column are displayed by default. This attribute is valid only when display is set to grid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "grid-columns-gap",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Size of the gap between two consecutive columns in a grid layout. You can also use grid-gap to set the same size of the gap between rows and columns. This attribute is valid only when display is set to grid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "grid-rows-gap",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Size of the gap between two consecutive rows in a grid layout. You can also use grid-gap to set the same size of the gap between rows and columns. This attribute is valid only when display is set to grid"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "grid-row-start",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Start row numbers of the current item in the grid layout. This attribute is valid only when display of the parent component is grid. (The display attribute of the parent component can be set to grid only for the <div> container.)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "grid-row-end",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "End row numbers of the current item in the grid layout. This attribute is valid only when display of the parent component is grid. (The display attribute of the parent component can be set to grid only for the <div> container.)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "grid-column-start",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Start column numbers of the current item in the grid layout. This attribute is valid only when display of the parent component is grid. (The display attribute of the parent component can be set to grid only for the <div> container.)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "grid-column-end",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "End column numbers of the current item in the grid layout. This attribute is valid only when display of the parent component is grid. (The display attribute of the parent component can be set to grid only for the <div> container.)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "grid-auto-flow",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "scrollbar-color",
+      "syntax": [
+        {
+          "name": "color"
+        }
+      ],
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Sets the color of the scroll bar."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "color"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "scrollbar-width",
+      "syntax": [
+        {
+          "name": "length"
+        }
+      ],
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Sets the width of the scroll bar."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "scrollbar-offset",
+      "syntax": [
+        {
+          "name": "length"
+        }
+      ],
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Sets the offset of the scroll bar."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "divider-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": ""
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "divider-height",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": ""
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "divider-length",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": ""
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "divider-origin",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": ""
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "columns",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of columns displayed in the main axis direction of the element. The default value is 1"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "item-extent",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Size of an internal item. When a percentage is set, the value indicates the percentage of the length in the main axis direction relative to the list viewpoint"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "fade-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Color of the physical dynamic effect. This attribute is valid only when scrolleffect is set to fade"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Fill color of the navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-selected-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Color of the currently selected navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Diameter of the navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-top",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Position of the indicator relative to the swiper"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-left",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Diameter of the navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-right",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Diameter of the navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "indicator-bottom",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length> || <percentage>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Diameter of the navigation point indicator"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length", "percentage"]
+        }
+      ]
+    },
+    {
+      "name": "progress-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Loading color of the <refresh> component"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "object-fit",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "fill | contain | cover | none | scale-down"
+        }
+      ],
+      "values": [
+        {
+          "name": "cover",
+          "description": "The image is scaled with the aspect ratio retained for both sides to be greater than or equal to the display boundaries and displayed in the middle"
+        },
+        {
+          "name": "contain",
+          "description": "The image is scaled with the aspect ratio retained for the image to be completely displayed within the display boundaries and displayed in the middle"
+        },
+        {
+          "name": "fill",
+          "description": "The image is resized to fill the display area and its aspect ratio is not retained"
+        },
+        {
+          "name": "none",
+          "description": "The image is displayed in the middle with its aspect ratio and size retained"
+        },
+        {
+          "name": "scale-down",
+          "description": "The image is displayed in the middle with its aspect ratio retained. The size is equal to or smaller than the original size"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Image scale type. The SVG format is not supported. cover: The image is scaled with the aspect ratio retained for both sides to be greater than or equal to the display boundaries and displayed in the middle. contain: The image is scaled with the aspect ratio retained for the image to be completely displayed within the display boundaries and displayed in the middle. fill: The image is resized to fill the display area and its aspect ratio is not retained. none: The image is displayed in the middle with its aspect ratio and size retained. scale-down: The image is displayed in the middle with its aspect ratio retained. The size is equal to or smaller than the original size."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "match-text-direction",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "true | false"
+        }
+      ],
+      "values": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether image orientation changes with the text direction. The SVG format is not supported"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "fit-original-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "true | false"
+        }
+      ],
+      "values": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether the <image> component adapts to the image source size when the width and height are not set. If this attribute is set to true, the object-fit attribute does not take effect. SVG images do not support this attribute"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "color",
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Color of the component"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "opacity",
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Transparency of an element. The value ranges from 0 to 1. 1 indicates opaque, and 0 indicates completely transparent"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "appearing-duration",
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Appearing duration, The unit is ms."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "stroke-width",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Width of the component"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "secondary-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Secondary color of the component"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "scale-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Scale thickness of the ring progress bar with a scale. This style takes effect only when the type is scale-ring"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "scale-number",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Number of scales of the ring progress bar with a scale. This style takes effect only when the type is scale-ring"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "start-angle",
+      "syntax": [
+        {
+          "name": "<angle>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Start angle of the component, which starts from the direction of zero o'clock. The value ranges from 0 to 360 degrees (clockwise)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "total-angle",
+      "syntax": [
+        {
+          "name": "<angle>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Total length of the component. The value ranges from –360 to 360. A negative number indicates counterclockwise direction"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "center-x",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Center of the component (with the upper left corner of this widget as the coordinate origin). This style must be used together with center-y and radius"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "center-y",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Center of the component (with the upper left corner of this widget as the coordinate origin). This style must be used together with center-x and radius"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "radius",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Radius of the component. This style must be used together with center-x and center-y"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "font-size",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font size (px).Currently, only 30px and 38px font sizes are supported"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "allow-scale",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "[ true | false ]"
+        }
+      ],
+      "values": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether the font size changes following the system's font size settings. NOTE: For details about how to make the configuration take effect dynamically, see the config-changes attribute in the config.json file"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "letter-spacing",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Character spacing (px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "font-style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "normal"
+        },
+        {
+          "name": "italic"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font style. Available values are as follows: normal: standard font style. italic: italic font style"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "font-weight",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<font-weight-absolute>{1,2}"
+        }
+      ],
+      "values": [
+        {
+          "name": "lighter"
+        },
+        {
+          "name": "normal"
+        },
+        {
+          "name": "bold"
+        },
+        {
+          "name": "bolder"
+        },
+        {
+          "name": "medium"
+        },
+        {
+          "name": "regular"
+        },
+        {
+          "name": "100"
+        },
+        {
+          "name": "200"
+        },
+        {
+          "name": "300"
+        },
+        {
+          "name": "400"
+        },
+        {
+          "name": "500"
+        },
+        {
+          "name": "600"
+        },
+        {
+          "name": "700"
+        },
+        {
+          "name": "800"
+        },
+        {
+          "name": "900"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font width. For the number type, the value ranges from 100 to 900. The default value is 400. A larger value indicates a larger font width. NOTE: The value must be an integer multiple of 100. The value of the string type can be lighter, normal, hold, or bolder"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "text-decoration",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "underline",
+          "description": "An underline is used"
+        },
+        {
+          "name": "line-through",
+          "description": "A strikethrough is used"
+        },
+        {
+          "name": "none",
+          "description": "The standard text is used"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text modifier. Available values are as follows: underline: An underline is used; line-through: A strikethrough is used; none: The standard text is used"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "text-align",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "values": [
+        {
+          "name": "left",
+          "description": "The text is left-aligned",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "center",
+          "description": "The text is center-aligned",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "right",
+          "description": "The text is right-aligned",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "start",
+          "description": "The text is aligned with the direction in which the text is written",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "end",
+          "description": "The text in aligned with the opposite direction in which the text is written",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text alignment mode. Available values are as follows: left: The text is left-aligned; center: The text is center-aligned; right: The text is right-aligned; start: The text is aligned with the direction in which the text is written; end: The text in aligned with the opposite direction in which the text is written; NOTE If the text width is not specified, the alignment effect may not be obvious when the text width is the same as the width of the parent container"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "line-height",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text line height. When this parameter is set to 0px, the text line height is not limited and the font size is adaptive"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "text-overflow",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "[ clip | ellipsis | <string> ]{1,2}"
+        }
+      ],
+      "values": [
+        {
+          "name": "clip",
+          "description": "The text is clipped and displayed based on the size of the parent container"
+        },
+        {
+          "name": "ellipsis",
+          "description": "The text is displayed based on the size of the parent container. The text that cannot be displayed is replaced with ellipsis. This style must be used together with max-lines"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text line height. When this parameter is set to 0px, the text line height is not limited and the font size is adaptive"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "text-overflow",
+      "syntax": [
+        {
+          "name": "[ clip | ellipsis | <string> ]{1,2}"
+        }
+      ],
+      "values": [
+        {
+          "name": "clip",
+          "description": "The text is clipped and displayed based on the size of the parent container"
+        },
+        {
+          "name": "ellipsis",
+          "description": "The text is displayed based on the size of the parent container. The text that cannot be displayed is replaced with ellipsis. This style must be used together with max-lines"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text line height. When this parameter is set to 0px, the text line height is not limited and the font size is adaptive"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum", "string"]
+        }
+      ]
+    },
+    {
+      "name": "vertical-align",
+      "syntax": [
+        {
+          "name": "top | middle | bottom"
+        }
+      ],
+      "values": [
+        {
+          "name": "top",
+          "description": "The text is displayed based on the top of the parent container"
+        },
+        {
+          "name": "middle",
+          "description": "The text is displayed based on the middle of the parent container"
+        },
+        {
+          "name": "bottom",
+          "description": "The text is displayed based on the bottom of the parent container"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Set the vertical alignment of the current text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "white-space",
+      "syntax": [
+        {
+          "name": "normal | nowrap | pre | pre-wrap | pre-line"
+        }
+      ],
+      "values": [
+        {
+          "name": "normal",
+          "description": "Consecutive whitespace characters will be merged, and newline characters will be treated as whitespace characters"
+        },
+        {
+          "name": "nowrap",
+          "description": "Consecutive whitespace characters will be merged, and newline characters is invalid"
+        },
+        {
+          "name": "pre",
+          "description": "Consecutive whitespace will be preserved"
+        },
+        {
+          "name": "pre-wrap",
+          "description": "Consecutive whitespace will be preserved"
+        },
+        {
+          "name": "pre-line",
+          "description": "Consecutive whitespace characters will be merged"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Set the mode for handling blanks in text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "enum"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "word-spacing",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text spacing (px)"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "text-decoration-color",
+      "supportedDevices": [
+        "tv",
+        "phone",
+        "tablet",
+        "wearable"
+      ],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text decoration color"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "color"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "text-indent",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v7.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Set the amount of indentation before the first line of text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": [
+            "length"
+          ]
+        }
+      ]
+    },
+    {
+      "name": "font-family",
+      "syntax": [
+        {
+          "name": "[ clip | ellipsis | <string> ]{1,2}"
+        }
+      ],
+      "values": [
+        {
+          "name": "sans-serif"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font family, in which fonts are separated by commas (,). Each font is set using a font name or font family name. The first font that exists in the system or the font specified by Customizing Font Styles in the family is selected as the font for the text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "max-lines",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "[<string> | <number>]"
+        }
+      ],
+      "values": [
+        {
+          "name": "auto"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Maximum number of lines in the text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "min-font-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Minimum font size in the text. This style must be used together with max-font-size. The font size can be changed dynamically. After the maximum and minimum font sizes are set, font-size does not take effect"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "max-font-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Maximum font size in the text. This style must be used together with min-font-size. The font size can be changed dynamically. After the maximum and minimum font sizes are set, font-size does not take effect"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "font-size-step",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Step for dynamically adjusting the font size in the text. The minimum and maximum font sizes must be set"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "prefer-font-sizes",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Preset preferred font sizes. For dynamic font size adjusting, the preset sizes are used to match the maximum number of lines in the text. If the preferred font sizes were not set, the font size will be adjusted based on the maximum and minimum font sizes and the step you have set. If the font size cannot match the maximum number of lines in the text, use text-overflow to truncate the text. If this parameter is set, font-size, max-font-size, min-font-size, and font-size-step do not take effect. Example values: 12 px,14 px,16 px"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "adapt-height",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "true | false"
+        }
+      ],
+      "values": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": ""
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "star-background",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Background image when a rating star is unselected. Only PNG and JPG images in a local path are supported"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "star-foreground",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Secondary background image when a rating star is partially selected. This image will cover the background image and can only be of the PNG or JPG format and from a local path"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "star-secondary",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<url>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "values": [
+        {
+          "name": "url()"
+        }
+      ],
+      "description": [
+        {
+          "name": "Foreground image when a rating star is selected. Only PNG and JPG images in a local path are supported"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "rtl-flip",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "[ true | false ]"
+        }
+      ],
+      "values": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Whether the image source is automatically flipped in the RTL text direction"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "line-cap",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "[ butt | square | round ]"
+        }
+      ],
+      "values": [
+        {
+          "name": "butt",
+          "description": "The ends of the split line are squared off at the endpoints"
+        },
+        {
+          "name": "square",
+          "description": "The ends of the split line are squared off by adding a box with an equal width and half the height of the line's thickness"
+        },
+        {
+          "name": "round",
+          "description": "The ends of the split line are round"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Cap style of a divider. The default value is butt. Available values are as follows: butt: The ends of the divider are squared off. round: A rounded cap is added to each end of the divider. square: A square cap is added to each end of the divider. NOTE If the value is round or square, the line length increases by the line width"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "placeholder-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Color of the hint text"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "text-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text color"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "icon-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Width of the internal icon of a circle button. The entire circle button is filled by default."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "icon-height",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Height of the internal icon of a circle button. The entire circle button is filled by default."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "block-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Slider color"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "texton-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text color displayed when the component is checked"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "textoff-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Text color displayed when the component is not checked"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "text-padding",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Distance between the two sides of the longest text in texton and textoff and the border of the slider"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "selected-color",
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font color of the selected item"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "selected-font-size",
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font size of the selected item. The value is of the length type, in pixels"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "focus-color",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font color of the focus. This attribute is available only for smart TV"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "focus-font-size",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Font size of the focus. The value is of the length type, in pixels. This attribute is available only for smart TV'"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "colors",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Color of each section for the scale bar of the gauge component. For example, colors: #FF0000, #00FF00. This style is supported by the gauge chart only"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "weights",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Weight of each section for the scale bar of the gauge component. For example, weights: 2, 2. This style is supported by the gauge chart only"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "src",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<url>#"
+        }
+      ],
+      "values": [
+        {
+          "name": "url()"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Supported sources of customized fonts"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["enum"]
+        }
+      ]
+    },
+    {
+      "name": "min-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "min-height",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "max-width",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "max-height",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<length>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["length"]
+        }
+      ]
+    },
+    {
+      "name": "box-shadow",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "filter",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "backdrop-filter",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "window-filter",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<string>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["string"]
+        }
+      ]
+    },
+    {
+      "name": "display-index",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "flex-weight",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "aspect-ratio",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "syntax": [
+        {
+          "name": "<number>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v4.0"
+        }
+      ],
+      "description": [
+        {
+          "name": " "
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["number"]
+        }
+      ]
+    },
+    {
+      "name": "caret-color",
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Caret color"
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    },
+    {
+      "name": "click-color",
+      "syntax": [
+        {
+          "name": "<color>"
+        }
+      ],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "the background color when list item is clicked."
+        }
+      ],
+      "restrictions": [
+        {
+          "name": ["color"]
+        }
+      ]
+    }
+  ],
+  "atDirectives": [
+    {
+      "name": "@import",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Includes content of another file.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "@keyframes",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Defines set of animation key frames.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "@font-face",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Allows for linking to fonts that are automatically activated when needed. This permits authors to work around the limitation of 'web-safe' fonts, allowing for consistent rendering independent of the fonts available in a given user's environment.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "@media",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Defines a stylesheet for a particular media type.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "pseudoClasses": [
+    {
+      "name": ":active",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents an element that is being activated by the user.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": ":checked",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents an element that is checked or toggled to an on state..",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": ":waiting",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents an element that is waiting for operation finished.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": ":disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents any disabled element.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": ":focus",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "version": [
+        {
+          "name": "v3.0"
+        }
+      ],
+      "description": [
+        {
+          "name": "Represents an element that has received focus.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ]
+}
diff --git a/api/form/hml/basic/block.json b/api/form/hml/basic/block.json
new file mode 100644
index 0000000000000000000000000000000000000000..9c094d1b863308702c656b509e70737401b17f26
--- /dev/null
+++ b/api/form/hml/basic/block.json
@@ -0,0 +1,54 @@
+{
+  "name": "block",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "'Logic control block.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/button.json b/api/form/hml/basic/button.json
new file mode 100644
index 0000000000000000000000000000000000000000..1d98a2db61a2a9a826c2fc3d31928ad1b4342d97
--- /dev/null
+++ b/api/form/hml/basic/button.json
@@ -0,0 +1,400 @@
+{
+  "name": "button",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <button> component includes capsule, circle, text, arc, and download buttons.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "type",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Dynamic modification is not supported. If this attribute is not set, capsule-like buttons are displayed. Different from the capsule button, the four rounded corners of a capsule-like button can be configured using border-radius. Available button types are as follows: capsule: a capsule button with fillets, background color, and text. circle: a circle button which can be used to place icons. text: a text button which displays the text only. arc: an arc button. download: a download button. The download progress bar is added.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "capsule"
+        },
+        {
+          "name": "circle"
+        },
+        {
+          "name": "text"
+        }
+      ]
+    },
+    {
+      "name": "value",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Text value of the button. This attribute is unavailable for circle buttons.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "icon",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Path of the button icon. This parameter is valid only for the circle button. The supported icon formatformats are JPG, PNG, and SVG.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "url"
+    },
+    {
+      "name": "placement",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Position of the button icon in text. This attribute is valid only when type is not set. Available values are as follows: start: The button icon is at the beginning of the text. end: The button icon is at the end of the text. top: The button icon is at the top of the text.bottom: The button icon is at the bottom of the text.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "end"
+        },
+        {
+          "name": "start"
+        },
+        {
+          "name": "top"
+        },
+        {
+          "name": "bottom"
+        }
+      ]
+    },
+    {
+      "name": "waiting",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Waiting status. When waiting is set to true, the waiting transition is displayed on the left of the text. This attribute is unavailable for download buttons and smart watches.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/calendar.json b/api/form/hml/basic/calendar.json
new file mode 100644
index 0000000000000000000000000000000000000000..570ae3b929424089f1e2be21160ac9001323a9ac
--- /dev/null
+++ b/api/form/hml/basic/calendar.json
@@ -0,0 +1,373 @@
+{
+  "name": "calendar",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <calendar> component displays a calendar.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "date",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "cardcalendar",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "startdayofweek",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "calendardata",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "showholiday",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "selectedchange",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "requestdata",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/chart.json b/api/form/hml/basic/chart.json
new file mode 100644
index 0000000000000000000000000000000000000000..dc404a19024ff8147f3e53c788db05cdc3fff25d
--- /dev/null
+++ b/api/form/hml/basic/chart.json
@@ -0,0 +1,407 @@
+{
+  "name": "chart",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <chart> component displays line charts, gauge charts, and bar charts.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "type",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Chart type. Dynamic modification is not supported. Available values include: bar: bar chart. line: line chart. gauge: gauge chart (not supported by lite devices).",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "bar"
+        },
+        {
+          "name": "line"
+        },
+        {
+          "name": "gauge"
+        },
+        {
+          "name": "progress"
+        },
+        {
+          "name": "loading"
+        },
+        {
+          "name": "rainbow"
+        }
+      ]
+    },
+    {
+      "name": "options",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Chart parameters. You must set parameters for bar charts and line charts. Parameter settings for gauge charts do not take effect. You can set the minimum value, maximum value, scale, and line width of the x-axis or y-axis, whether to display the x-axis or y-axis, and whether the line is smooth. Dynamic modification is not supported.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "datasets",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Data set. You must set data sets for bar charts and line charts. Data set for a gauge chart does not take effect. You can set multiple datasets and their background colors.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "segments",
+      "supportedDevices": ["phone"],
+      "required": false,
+      "description": [
+        {
+          "name": "Data structures used by progress, loading, and rainbow charts. DataSegment is available for progress and loading charts.Array<DataSegment> is available for rainbow charts. A maximum of nine DataSegment are supported in the array.",
+          "supportedDevices": ["phone"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "effects",
+      "supportedDevices": ["phone"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to enable the effects for progress and rainbow charts.",
+          "supportedDevices": ["phone"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "percent",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Percentage of the current value to the total value. The value ranges from 0 to 100.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/clock.json b/api/form/hml/basic/clock.json
new file mode 100644
index 0000000000000000000000000000000000000000..eb345626ab25e87d959ec52890bfb2542a1d95ab
--- /dev/null
+++ b/api/form/hml/basic/clock.json
@@ -0,0 +1,284 @@
+{
+  "name": "clock",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <clock> component displays a clock.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "clockconfig",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "showdigit",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "hourswest",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/divider.json b/api/form/hml/basic/divider.json
new file mode 100644
index 0000000000000000000000000000000000000000..491be58dc98d3b4553e9874791fb43ec9140a022
--- /dev/null
+++ b/api/form/hml/basic/divider.json
@@ -0,0 +1,296 @@
+{
+  "name": "divider",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <divider> component is used to separate content blocks and content elements. It can be used for the list or interface layout.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "vertical",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to use the vertical divider. The default value is false, indicating that the horizontal divider is used.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/image.json b/api/form/hml/basic/image.json
new file mode 100644
index 0000000000000000000000000000000000000000..a3c496c4e9bdf552b03932d1b1e5d3994b554252
--- /dev/null
+++ b/api/form/hml/basic/image.json
@@ -0,0 +1,351 @@
+{
+  "name": "image",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <image> component is used to render and display images.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "src",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Image path, which supports both local and cloud paths. The supported image formats include PNG, JPG, SVG, and GIF. Image path. The supported image formats include PNG and JPG.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "url"
+    },
+    {
+      "name": "alt",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Placeholder image displayed during image loading.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "complete",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when an image is successfully loaded.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "error",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when an exception occurs during image loading.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/input.json b/api/form/hml/basic/input.json
new file mode 100644
index 0000000000000000000000000000000000000000..fb1ff22b4c7692c681261291252fb2ac05180b17
--- /dev/null
+++ b/api/form/hml/basic/input.json
@@ -0,0 +1,401 @@
+{
+  "name": "input",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <input> component provides an interactive interface to receive user input. It can be a radio button, check box, button, single-line text box, etc.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "type",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Type of the input component. Available values include text (Rich), email (Rich), date (Rich), time (Rich), number (Rich), password (Rich), button.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "radio"
+        }
+      ]
+    },
+    {
+      "name": "checked",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is checked or not.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "dir",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Specify the text direction of an element.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "ltr"
+        },
+        {
+          "name": "rtl"
+        },
+        {
+          "name": "auto"
+        }
+      ]
+    },
+    {
+      "name": "name",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Name of the input component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "value",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Value of the input component. When type is radio, this attribute is mandatory and the value must be unique for radio buttons with the same name.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "change",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when the content entered in the text box changes. The latest textsmost recent text entered by the user is returned.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/progress.json b/api/form/hml/basic/progress.json
new file mode 100644
index 0000000000000000000000000000000000000000..e008cb0a52e4fc4b8efd89b278dd1b5fdf355b84
--- /dev/null
+++ b/api/form/hml/basic/progress.json
@@ -0,0 +1,363 @@
+{
+  "name": "progress",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <progress> component is used to provide a progress bar that displays the progress of content loading or operation processing.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "type",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Type of the progress bar, which cannot be changed dynamically. Available values are as follows: horizontal: linear progress bar. circular (Rich): loading progress bar. ring (Rich): ring progress bar. scale-ring (Rich): ring progress bar with a scale. arc: arc progress bar.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "horizontal"
+        },
+        {
+          "name": "circular"
+        },
+        {
+          "name": "ring"
+        },
+        {
+          "name": "scale-ring"
+        },
+        {
+          "name": "arc"
+        },
+        {
+          "name": "eclipse"
+        }
+      ]
+    },
+    {
+      "name": "percent",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Current progress. The value ranges from 0 to 100.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "secondarypercent",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Secondary progress. The value ranges from 0 to 100.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "clockwise",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the ring progress bar uses clockwise.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/span.json b/api/form/hml/basic/span.json
new file mode 100644
index 0000000000000000000000000000000000000000..f1c611a8aa58a0b61817010c5a7321d7ddb56c4a
--- /dev/null
+++ b/api/form/hml/basic/span.json
@@ -0,0 +1,281 @@
+{
+  "name": "span",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <span> child component of <text> is used as a text modifier.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [
+    {
+      "name": "span",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/basic/text.json b/api/form/hml/basic/text.json
new file mode 100644
index 0000000000000000000000000000000000000000..2bb842d5a4f57b3626329eb64f33bad9e41e9440
--- /dev/null
+++ b/api/form/hml/basic/text.json
@@ -0,0 +1,313 @@
+{
+  "name": "text",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <text> component is used to display a piece of textual information.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [
+    {
+      "name": "span",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "level": 1
+    }
+  ],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
\ No newline at end of file
diff --git a/api/form/hml/container/badge.json b/api/form/hml/container/badge.json
new file mode 100644
index 0000000000000000000000000000000000000000..b4d1fa89927d753eb75ffcd2d3f769568da16944
--- /dev/null
+++ b/api/form/hml/container/badge.json
@@ -0,0 +1,417 @@
+{
+  "name": "badge",
+  "version": [
+    {
+      "name": "v4.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <badge> component is used to mark new events that require user attention in your application.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "placement",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Position of a number or dot badge. Available values are as follows: right: on the right border of the component. rightTop: in the upper right corner of the component border.left: on the left border of the component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "left"
+        },
+        {
+          "name": "right"
+        },
+        {
+          "name": "rightTop"
+        }
+      ]
+    },
+    {
+      "name": "count",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Number of notifications displayed via the badge. The default value is 0. If the number of notifications is greater than 0, the badge changes from a dot to the number. If this attribute is not set or the value is less than or equal to 0, the badge is a dot.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "visible",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to display the badge. The value true means that the badge shows up when a new notification is received. To use a number badge, set the count attribute.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "maxcount",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Maximum number of notifications. When the number of new notifications exceeds the value of this attribute, maxcount+ is displayed, for example, 99+.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "config",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Configuration of the badge.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "badgeColor": "#fa2a2d"
+        },
+        {
+          "textColor": "#ffffff"
+        },
+        {
+          "textSize": "10px"
+        },
+        {
+          "badgeSize": "6px"
+        }
+      ]
+    },
+    {
+      "name": "label",
+      "supportedDevices": ["phone", "tablet"],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "required": false,
+      "description": [
+        {
+          "name": "Sets the text value for the new event alert.",
+          "supportedDevices": ["phone", "tablet"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
\ No newline at end of file
diff --git a/api/form/hml/container/div.json b/api/form/hml/container/div.json
new file mode 100644
index 0000000000000000000000000000000000000000..49bde464e8ce23bb2de852ad51d37ccd516c5f16
--- /dev/null
+++ b/api/form/hml/container/div.json
@@ -0,0 +1,330 @@
+{
+  "name": "div",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <div> component is a basic container that is used as the root node of the page structure or is used to group the content.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "dir",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Specify the text direction of an element.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "ltr"
+        },
+        {
+          "name": "rtl"
+        },
+        {
+          "name": "auto"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/container/list-item.json b/api/form/hml/container/list-item.json
new file mode 100644
index 0000000000000000000000000000000000000000..5f0eb16b75ef2be86001796ccc26b725ce49b162
--- /dev/null
+++ b/api/form/hml/container/list-item.json
@@ -0,0 +1,380 @@
+{
+  "name": "list-item",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "<list-item> is a child component of <list> and is used to display items in a list.",
+      "supportedDevices": ["liteWearable", "smartVision"]
+    },
+    {
+      "name": "<list-item> is a child component of <list> and is used to display items in a list. The width of <list-item> fills that of <list>.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "type",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Type of the list-item. A list can contain multiple list-item types. The same type of list-items should have the same view layout after being rendered. If the type is fixed, replace the if attribute with the show attribute to ensure that the view layout remains unchanged.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "section",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Matching string of the item. It takes effect when the indexer is enabled. If this attribute is not specified, the matching string is empty. This attribute cannot be modified dynamically. In a group, only the matching string set for the primary item is valid.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "sticky",
+      "supportedDevices": ["tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Matching string of the item. It takes effect when the indexer is enabled. If this attribute is not specified, the matching string is empty. This attribute cannot be modified dynamically. In a group, only the matching string set for the primary item is valid.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "none",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "normal",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "opacity",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "clickeffect",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "version": [
+        {
+          "name": "v5.0"
+        }
+      ],
+      "required": false,
+      "description": [
+        {
+          "name": "Sets whether the current item has the click effect.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": [
+    {
+      "name": "list",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ]
+}
diff --git a/api/form/hml/container/list.json b/api/form/hml/container/list.json
new file mode 100644
index 0000000000000000000000000000000000000000..e90b8d36d9f88421af376c8cbe77a929a8a53a1b
--- /dev/null
+++ b/api/form/hml/container/list.json
@@ -0,0 +1,491 @@
+{
+  "name": "list",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <list> component provides a list container that presents a series of list items arranged in a column with the same width. Lists support presentations of the same data in a multiple and coherent row style, for example, images and texts.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "cachedcount",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Minimum number of cached list-items when the long list is loaded with delay. When the number of list-items cached outside the visible area is less than the value of this attribute, a requestitem event is triggered.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "dir",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Specify the text direction of an element.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "ltr"
+        },
+        {
+          "name": "rtl"
+        },
+        {
+          "name": "auto"
+        }
+      ]
+    },
+    {
+      "name": "scrollbar",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Display mode of the side scroll bar. (Currently, only the vertical scroll bar is supported.) off: No display; auto: Displayed on demand (The side scroll bar is displayed when you touch it and disappears 2s later.); on: Always displayed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "off",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "auto",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "on",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "scrolleffect",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Scroll effect. Available values are as follows: spring: Similar to the physical dynamic effect of a spring. After scrolling to the edge, you can continue to scroll for a distance based on the initial speed or by using a touch event. After you release your hand, the screen is rebounded; fade: Similar to the physical dynamic effect of fade. When you scroll to the edge, a wave shape fades. The fade changes according to the speed and scrolling distance; no: No effect after the scroll bar is moved to the edge.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "spring",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "fade",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "no",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "divider",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether list items are separated by dividers.For details about divider styles, see divider-color, divider-height, divider-length, and divider-origin in the Styles table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "shapemode",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Shape of the side scroll bar. default: Not specified (following the theme); rect: Rectangle; round: Circle.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "default",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "rect",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        },
+        {
+          "name": "round",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    },
+    {
+      "name": "updateeffect",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether a dynamic effect is displayed when an item in the list is deleted or added. false: No dynamic effect is displayed; true: A dynamic effect is displayed when an item is added or deleted.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "initialindex",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Item displayed at the start position of the viewport when the current list is loaded for the first time. The default value is 0, indicating that the first item is displayed. If the number you set is greater than the index of the last item, the setting does not take effect. When the initialoffset attribute is set, the current attribute does not take effect.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "initialoffset",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The start offset of the viewport when the current list is loaded for the first time. The offset cannot exceed the scrolling range of the current list. Otherwise, the offset is truncated to the maximum value of the scrolling range.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "length"
+    },
+    {
+      "name": "selected",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Selected item in the current list. The value can be a section value of any list items.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [
+    {
+      "name": "list-item",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "level": 2
+    }
+  ],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/container/stack.json b/api/form/hml/container/stack.json
new file mode 100644
index 0000000000000000000000000000000000000000..abcad72293377d7d15a383c535b22dce349b2470
--- /dev/null
+++ b/api/form/hml/container/stack.json
@@ -0,0 +1,267 @@
+{
+  "name": "stack",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <stack> component provides a stack container where child components are successively stacked and the latter one overwrites the previous one.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/container/swiper.json b/api/form/hml/container/swiper.json
new file mode 100644
index 0000000000000000000000000000000000000000..72c3f7d644e298aa0174ec472ae19c8d544c662a
--- /dev/null
+++ b/api/form/hml/container/swiper.json
@@ -0,0 +1,503 @@
+{
+  "name": "swiper",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "The <swiper> component provides a swiper container that enables the switch of child components.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "index",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Index of the child component currently displayed in the container.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "indicator",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to enable the navigation point indicator. The default value is true.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "digital",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to enable the digital indicator. The default value is false.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "false"
+        },
+        {
+          "name": "true"
+        }
+      ]
+    },
+    {
+      "name": "indicatordisabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether gesture operations are disabled on the indicator. If this attribute is set to true, the indicator does not respond to clicking or dragging operations.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "false"
+        },
+        {
+          "name": "true"
+        }
+      ]
+    },
+    {
+      "name": "loop",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether to enable looping.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "duration",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Duration of the animation played for switching between child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "vertical",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the swipe gesture is performed vertically. A vertical swipe uses the vertical indicator. Dynamic modification is not supported.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "id",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Unique ID of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "style",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style declaration of a component.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "class",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Style class of a component, which is used to refer to a style table.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "disabled",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the component is disabled. If the component is disabled, the component cannot respond to user interaction.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "voicelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice label. When a voice label is triggered, the click event of the component is triggered. NOTE: The voice label takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "subscriptflag",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Voice subscript switch. Available values are as follows: auto: For the <image> and <list-item> components, if subscriptflag is set to auto, the voice subscript is turned on. For other components, if subscriptflag is set to auto, the voice subscript is turned off. on: Turn on the voice subscript. off: Turn off the voice subscript. If no customized subscript is set, the subscript is automatically accumulated from 1. NOTE The voice subscript takes effect only when the click event is set.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "auto"
+        },
+        {
+          "name": "on"
+        },
+        {
+          "name": "off"
+        }
+      ]
+    },
+    {
+      "name": "subscriptlabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Custom subscript. After it is set, the subscript is displayed in the way you specified. To make this attribute take effect, you need to turn on the voice subscript.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "scenelabel",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Available values are as follows: video: Video scenario. For example, to watch a video, a user can say the voiceLabel (usually the video name), play voiceLabel, see voiceLabel, or watch voiceLabel, etc. audio: Music scenario. For example, to listen to a song, a user can say the voiceLabel (usually the song name), play voiceLabel, or listen voiceLabel, etc. page: Page scenario. For example, to go to a page, a user can say the voiceLabel (usually the page name), switch to voiceLabel, go to voiceLabel, or jump to voiceLabel, etc. switch: Switch scenario. For example, to turn on or turn off a switch, a user can say the voiceLabel (usually the switch name), turn on voiceLabel, open voiceLabel, turn off voiceLabel, close voiceLabel, etc. common: Common scenario, which is triggered by the voiceLabel.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "video"
+        },
+        {
+          "name": "audio"
+        },
+        {
+          "name": "page"
+        },
+        {
+          "name": "switch"
+        },
+        {
+          "name": "common"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitygroup",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility group. If this attribute is set to true, the component and all its child components form an entire selectable component, and the accessibility service will no longer available for the content of its child components.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "cachedsize",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "required": false,
+      "description": [
+        {
+          "name": "Sets the number of sub-elements loaded in front of and back of the current page of the swiper.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "number"
+    },
+    {
+      "name": "scrolleffect",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "version": [
+        {
+          "name": "v6.0"
+        }
+      ],
+      "required": false,
+      "description": [
+        {
+          "name": "Sets the boundary bounce effect.\nSpring: elastic physical action. After sliding to the edge, you can continue sliding for a certain distance based on the initial speed or touch event. When you release the hand, you can spring back.\nFading: The physical effect of fading. When you slide to the edge, a wave-like fading is displayed. The fading also changes according to the speed and sliding distance.\nnone: No effect is displayed when the user slides to the edge.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "spring"
+        },
+        {
+          "name": "fade"
+        },
+        {
+          "name": "none"
+        }
+      ]
+    },
+    {
+      "name": "accessibilitytext",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility text. If a component does not contain text information, it will not be read when the component is selected by the screen reader. In this case, the screen reader user cannot know which component is selected. To solve this problem, you can set this attribute for components without text information. When the component is selected by the screen reader, the specified accessibility text will be read, informing the user which component is selected. If a component with this attribute set contains text information, only the accessibility text will be read.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilitydescription",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility description. You can specify further explanation of the current component, for example, possible operation consequences, especially those cannot be learned from component attributes and accessibility text. You can set a detailed description text for the attribute of the component to help users understand the operation to be performed. If a component contains both text information and the accessibility description, the text is read first and then the accessibility description, when the component is selected.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "accessibilityimportance",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Accessibility importance, which is used to decide whether a component can be identified by the accessibility service. The value can be auto, yes, no, or no-hide-descendants. The last value forces the screen reader to ignore the current component and all its subcomponents. yes: The current component is selectable for the accessibility service. no: The current component is not selectable for the accessibility service.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "for",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Expands the current element based on the configured data list.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "tid",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "The tid attribute is used to accelerate the for loop. It is used to improve the re-rendering efficiency when data in a loop changes. The tid attribute specifies the unique ID of each element in the array. If it is not specified, the index of each element in the array is used as the ID. For example, tid='id' indicates that the id attribute of each element is its unique identifier.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "if",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is added or removed.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "dir",
+      "supportedDevices": ["phone", "tablet", "tv", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Specify the text direction of an element.",
+          "supportedDevices": ["phone", "tablet", "tv", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "ltr"
+        },
+        {
+          "name": "rtl"
+        },
+        {
+          "name": "auto"
+        }
+      ]
+    },
+    {
+      "name": "elif",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    },
+    {
+      "name": "else",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [],
+      "type": "string"
+    },
+    {
+      "name": "show",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "Whether the element is displayed or hidden.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "enum",
+      "options": [
+        {
+          "name": "true"
+        },
+        {
+          "name": "false"
+        }
+      ]
+    }
+  ],
+  "events": [
+    {
+      "name": "click",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "description": [
+        {
+          "name": "Triggered when a component is clicked.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ]
+    }
+  ],
+  "supportedSubComponents": true,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [
+    {
+      "name": "list"
+    }
+  ],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/custom/element.json b/api/form/hml/custom/element.json
new file mode 100644
index 0000000000000000000000000000000000000000..ebdce29f916fab9876be9ba094e08b09e893b29f
--- /dev/null
+++ b/api/form/hml/custom/element.json
@@ -0,0 +1,46 @@
+{
+  "name": "element",
+  "version": [
+    {
+      "name": "v3.0"
+    }
+  ],
+  "supportedDevices": ["phone", "tablet", "wearable"],
+  "description": [
+    {
+      "name": "custom component.",
+      "supportedDevices": ["phone", "tablet", "wearable"]
+    }
+  ],
+  "attributes": [
+    {
+      "name": "name",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": false,
+      "description": [
+        {
+          "name": "custom component name.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "string"
+    },
+    {
+      "name": "src",
+      "supportedDevices": ["phone", "tablet", "wearable"],
+      "required": true,
+      "description": [
+        {
+          "name": "custom component path.",
+          "supportedDevices": ["phone", "tablet", "wearable"]
+        }
+      ],
+      "type": "url"
+    }
+  ],
+  "events": [],
+  "supportedSubComponents": false,
+  "supportedSubComponentsRestriction": [],
+  "unSupportSubComponentsRestriction": [],
+  "parentComponentsRestriction": []
+}
diff --git a/api/form/hml/hml-json-schema.json b/api/form/hml/hml-json-schema.json
new file mode 100644
index 0000000000000000000000000000000000000000..5297e5531e3f427028920f927afbea29b508d4e8
--- /dev/null
+++ b/api/form/hml/hml-json-schema.json
@@ -0,0 +1,266 @@
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "组件名称，如div、list等"
+    },
+    "version": {
+      "type": "array",
+      "description": "该属性的当前的版本",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "版本号例如:V3.0"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          }
+        },
+        "required": ["name"]
+      }
+    },
+    "supportedDevices": {
+      "type": "array",
+      "description": "本字段非必填,如果为空，表示该属性支持所有的设备类型",
+      "items": {
+        "type": "string",
+        "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+      }
+    },
+    "description": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "属性的描述文档"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          }
+        },
+        "required": ["name"]
+      }
+    },
+    "attributes": {
+      "type": "array",
+      "description": "组件的属性信息",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "属性名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "required": {
+            "type": "boolean",
+            "description": "表示属性是否为组件的必填属性"
+          },
+          "description": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "属性的描述文档"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          },
+          "type": {
+            "type": "string",
+            "description": "属性的类型"
+          },
+          "options": {
+            "type": "array",
+            "description": "本字段非必填，表示属性值的枚举类型，当属性type为'enum'时才生效",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "属性值"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              },
+              "required": ["name"]
+            }
+          }
+        },
+        "required": ["name", "required", "description", "type"]
+      }
+    },
+    "events": {
+      "type": "array",
+      "description": "组件支持的事件",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "事件名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "description": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string",
+                  "description": "事件的描述文档"
+                },
+                "supportedDevices": {
+                  "type": "array",
+                  "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+                  "items": {
+                    "type": "string",
+                    "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+                  }
+                }
+              }
+            }
+          }
+        },
+        "required": ["name", "description"]
+      }
+    },
+    "supportedSubComponents": {
+      "type": "boolean",
+      "description": "组件是否支持子组件，参数为false表示不支持子组件，为true表示支持子组件。当参数为true并且supportedSubComponentsRestriction为空时，表示支持所以子组件"
+    },
+    "supportedSubComponentsRestriction": {
+      "type": "array",
+      "description": "组件支持的子组件列表",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "支持的子组件名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "level": {
+            "type": "number"
+          }
+        },
+        "required": ["name"]
+      }
+    },
+    "unSupportSubComponentsRestriction": {
+      "type": "array",
+      "description": "组件不支持的子组件列表",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "不支持的子组件名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "level": {
+            "type": "number"
+          }
+        },
+        "required": ["name"]
+      }
+    },
+    "parentComponentsRestriction": {
+      "type": "array",
+      "description": "支持的父组件列表，即只支持列表中的组件作为自己的父组件",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "支持的父组件的组件名称"
+          },
+          "supportedDevices": {
+            "type": "array",
+            "description": "本字段非必填,如果为空，表示该属性继承属性支持的设备类型",
+            "items": {
+              "type": "string",
+              "enum": ["tv", "phone", "tablet", "wearable", "liteWearable", "smartVision"]
+            }
+          },
+          "level": {
+            "type": "number",
+            "description": "本字段非必填,取值范围大于等于1，只有标签补齐时需要联想出对应子组件时需要填此字段，如果level为n+1时，level为n的组件有且只有一个(n>1)"
+          }
+        },
+        "required": ["name"]
+      }
+    }
+  },
+  "required": [
+    "name",
+    "version",
+    "description",
+    "attributes",
+    "events",
+    "supportedSubComponents",
+    "supportedSubComponentsRestriction",
+    "unSupportSubComponentsRestriction",
+    "parentComponentsRestriction"
+  ]
+}
diff --git a/api/phone/@ohos.bundle_mgr.d.ts b/api/phone/@ohos.bundle_mgr.d.ts
deleted file mode 100755
index b3dfe740e88442aa360a11ece01ee045f0f337de..0000000000000000000000000000000000000000
--- a/api/phone/@ohos.bundle_mgr.d.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { ApplicationInfo } from './app/applicationinfo';
-import { Want } from './app/want';
-import { AbilityInfo } from './app/abilityinfo';
-import { BundleInfo } from './app/bundleinfo';
-import { InstallResult } from './app/installresult';
-
-/**
- * @name BundleMgr
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-declare namespace bundleMgr {
-  /**
-   * Obtains the ApplicationInfo based on a given application name.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param appName Indicates the application name.
-   * @return ApplicationInfo.
-   * @testapi
-   */
-  function getApplicationInfo(appName: string): Promise<ApplicationInfo>;
-
-  /**
-   * Obtains BundleInfo of all bundles available in the system.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param NA
-   * @return Array of BundleInfo.
-   * @testapi
-   */
-  function getBundleInfos(): Promise<Array<BundleInfo>>;
-
-  /**
-   * Obtains BundleInfo based on a given bundle name.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param bundleName Indicates the bundle name.
-   * @return BundleInfo.
-   * @testapi
-   */
-  function getBundleInfo(bundleName: string): Promise<BundleInfo>;
-
-  /**
-   * Obtains information about all installed applications.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param NA
-   * @return Array of ApplicationInfo.
-   * @testapi
-   */
-  function getApplicationInfos(): Promise<Array<ApplicationInfo>>;
-
-  /**
-   * Query the AbilityInfo by the given Want.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param want Indicates the Want for the ability to be queried.
-   * @return AbilityInfo.
-   * @testapi
-   */
-  function queryAbilityInfo(want: Want): Promise<AbilityInfo>;
-
-  /**
-   * Install an application in a HAP.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param hapFilePath Indicates the path of the HAP.
-   * @return InstallResult
-   * @testapi
-   */
-  function install(hapFilePath: string): Promise<InstallResult>;
-
-  /**
-   * Uninstall an application.
-   *
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param hapFilePath Indicates the path of the HAP.
-   * @return InstallResult
-   * @testapi
-   */
-  function uninstall(bundleName: string): Promise<InstallResult>;
-}
-export default bundleMgr;
diff --git a/api/phone/@ohos.data.distributeddata.d.ts b/api/phone/@ohos.data.distributeddata.d.ts
deleted file mode 100644
index 579ab1129f50bf9b7810fa1a01cafeaeea8781d6..0000000000000000000000000000000000000000
--- a/api/phone/@ohos.data.distributeddata.d.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AsyncCallback, Callback } from './basic';
-import { KVStore } from "./data/distributeddata/kvstore";
-import { Options } from "./data/distributeddata/plain_ordinary_js_objects";
-import { KVManagerConfig } from './data/distributeddata/kvmanager_config'
-
-declare namespace distributedData {
-    /**
-     * Creates a {@link KVManager} instance based on the configuration information.
-     *
-     * <p>You must pass {@link KVManagerConfig} to provide configuration information
-     * for creating the {@link KVManager} instance.
-     *
-     * @param config Indicates the {@link KVStore} configuration information,
-     * including the user information and package name.
-     * @return Returns the {@code KVManager} instance.
-     * @throws Throws exception if input is invalid.
-     * @since 7
-     */
-    function createKVManager(config: KVManagerConfig, callback: AsyncCallback<KVManager>): void;
-    function createKVManager(config: KVManagerConfig): Promise<KVManager>;
-
-    /**
-     * Provides interfaces to manage a {@code KVStore} database,
-     * including obtaining, closing, and deleting the {@code KVStore}.
-     *
-     * @devices phone, tablet
-     * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
-     * @since 7
-     * @version 1
-     */
-    interface KVManager {
-        /**
-         * Creates and obtains a {@code KVStore} database by specifying {@code Options} and {@code storeId}.
-         *
-         * @param options Indicates the options used for creating and obtaining the {@code KVStore} database,
-         * including {@code isCreateIfMissing}, {@code isEncrypt}, and {@code KVStoreType}.
-         * @param storeId Identifies the {@code KVStore} database.
-         * The value of this parameter must be unique for the same application,
-         * and different applications can share the same value.
-         * @return Returns a {@code KVStore}, or {@code SingleKVStore},
-         * @since 7
-         */
-        getKVStore<T extends KVStore>(storeId: string, options: Options): Promise<T>;
-        getKVStore<T extends KVStore>(storeId: string, options: Options, callback: AsyncCallback<T>): void;
-    }
-}
-
-export default distributedData;
\ No newline at end of file
diff --git a/api/phone/@ohos.hiAppEvent.d.ts b/api/phone/@ohos.hiAppEvent.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..42b2b9734f76a0f480f15f2126867950b7440e86
--- /dev/null
+++ b/api/phone/@ohos.hiAppEvent.d.ts
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { AsyncCallback } from './basic';
+
+/**
+ * Provides the event logging function for applications to log the fault, statistical, security,
+ * and user behavior events reported during running. Based on event information,
+ * you will be able to analyze the running status of applications.
+ *
+ * @since 7
+ * @devices phone, tablet, tv, wearable
+ */
+declare namespace hiAppEvent {
+    /**
+     * Enumerate application event types.
+     */
+    enum EventType {
+        /**
+         * Fault event.
+         */
+        FAULT = 1,
+
+        /**
+         * Statistic event.
+         */
+        STATISTIC = 2,
+
+        /**
+         * Security event.
+         */
+        SECURITY = 3,
+
+        /**
+         * User behavior event.
+         */
+        BEHAVIOR = 4
+    }
+
+    /**
+     * Preset event.
+     */
+    namespace Event {
+        /**
+         * user login event.
+         */
+        const USER_LOGIN: string;
+
+        /**
+         * user logout event.
+         */
+        const USER_LOGOUT: string;
+
+        /**
+         * distributed service event.
+         */
+        const DISTRIBUTED_SERVICE_START: string;
+    }
+
+    /**
+     * Preset param.
+     */
+    namespace Param {
+        /**
+         * user id.
+         */
+        const USER_ID: string;
+
+        /**
+         * distributed service name.
+         */
+        const DISTRIBUTED_SERVICE_NAME: string;
+
+        /**
+         * distributed service instance id.
+         */
+        const DISTRIBUTED_SERVICE_INSTANCE_ID: string;
+    }
+
+    /**
+     * write application event.
+     *
+     * @static
+     * @param {string} eventName application event name.
+     * @param {EventType} eventType application event type.
+     * @param {object} keyValues application event key-value pair params.
+     * @param {AsyncCallback} [callback] callback function.
+     * @return {void | Promise<void>} no callback return Promise otherwise return void.
+     */
+    function write(eventName: string, eventType: EventType, keyValues: object): Promise<void>;
+    function write(eventName: string, eventType: EventType, keyValues: object, callback: AsyncCallback<void>): void;
+
+    /**
+     * application event logging configuration interface.
+     *
+     * @static
+     * @param {ConfigOption} config application event logging configuration item object.
+     * @return {boolean} configuration result.
+     */
+    function configure(config: ConfigOption): boolean;
+
+    interface ConfigOption {
+        /**
+         * configuration item: application event logging switch.
+         */
+        disable?: boolean;
+
+        /**
+         * configuration item: event file directory storage quota size.
+         */
+        maxStorage?: string;
+    }
+}
+
+export default hiAppEvent;
\ No newline at end of file
diff --git a/api/phone/@ohos.napi_ability_manager.d.ts b/api/phone/@ohos.napi_ability_manager.d.ts
deleted file mode 100755
index d4f8d8a546f3703834875424da0fed023893021d..0000000000000000000000000000000000000000
--- a/api/phone/@ohos.napi_ability_manager.d.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AbilityMissionInfo } from './app/abilitymissioninfo';
-import { ProcessInfo } from './app/processinfo';
-import { AsyncCallback } from './app/common';
-import { AppProcessState as _AppProcessState } from './app/appprocessstate';
-
-declare namespace abilityManager {
-  export import AppProcessState = _AppProcessState;
-  /**
-   * Obtains information about application processes that are running on the device.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @returns Returns a list of running processes.
-   * @testapi
-   */
-  function getAllRunningProcesses(): Promise<Array<ProcessInfo>>;
-
-  /**
-   * Obtains information about the application process running on the device through callback.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param callback Specified callback method.
-   * @testapi
-   */
-  function getAllRunningProcesses(
-    callback: AsyncCallback<Array<ProcessInfo>>,
-  ): void;
-
-  /**
-   * Queries information about the running Ability Mission.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @returns Returns the AbilityMissionInfos.
-   * @testapi
-   */
-  function queryRunningAbilityMissionInfos(): Promise<
-    Array<AbilityMissionInfo>
-  >;
-
-  /**
-   * Queries information about the running Ability Mission through callback.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param callback Specified callback method.
-   * @testapi
-   */
-  function queryRunningAbilityMissionInfos(
-    callback: AsyncCallback<Array<AbilityMissionInfo>>,
-  ): void;
-
-  /**
-   * Queries information about the recent Ability Mission.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @returns Returns the AbilityMissionInfos.
-   * @testapi
-   */
-  function queryRecentAbilityMissionInfos(): Promise<Array<AbilityMissionInfo>>;
-
-  /**
-   * Queries information about the recent Ability Mission.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param callback Specified callback method.
-   * @testapi
-   */
-  function queryRecentAbilityMissionInfos(
-    callback: AsyncCallback<Array<AbilityMissionInfo>>,
-  ): void;
-
-  /**
-   * Specifies that the task associated with the given task ID is removed from the stack.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param missionId Indicates the mission ID
-   * @returns Returns 0 for success, return non-0 for failure.
-   * @testapi
-   */
-  function removeMission(missionId: number): Promise<number>;
-
-  /**
-   * Specifies that the task associated with the given task ID is removed from the stack through callback.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param missionId Indicates the mission ID
-   * @param callback Specified callback method
-   * @testapi
-   */
-  function removeMission(
-    missionId: number,
-    callback: AsyncCallback<number>,
-  ): void;
-
-  /**
-   * Removes the specified mission stack by stack ID.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param stackId Indicates the stack ID
-   * @returns Returns 0 for success, return non-0 for failure.
-   * @testapi
-   */
-  function removeStack(stackId: number): Promise<number>;
-
-  /**
-   * Removes the specified mission stack by stack ID.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param stackId Indicates the stack ID
-   * @param callback Specified callback method.
-   * @testapi
-   */
-  function removeStack(stackId: number, callback: AsyncCallback<number>): void;
-
-  /**
-   * Ask that the mission associated with a given mission ID be moved to the
-   * front of the stack.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param missionId Indicates the mission ID
-   * @returns Returns 0 for success, return non-0 for failure.
-   * @testapi
-   */
-  function moveMissionToTop(missionId: number): Promise<number>;
-
-  /**
-   * Ask that the mission associated with a given mission ID be moved to the
-   * front of the stack.
-   *
-   * @default -
-   * @devices phone
-   * @since 6
-   * @SysCap appexecfwk
-   * @param missionId Indicates the mission ID
-   * @param callback Specified callback method.
-   * @testapi
-   */
-  function moveMissionToTop(
-    missionId: number,
-    callback: AsyncCallback<number>,
-  ): void;
-}
-export default abilityManager;
diff --git a/api/phone/@ohos.process.d.ts b/api/phone/@ohos.process.d.ts
new file mode 100755
index 0000000000000000000000000000000000000000..3f690ab00ccff5869e8377255744cb6161532d68
--- /dev/null
+++ b/api/phone/@ohos.process.d.ts
@@ -0,0 +1,83 @@
+/*
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+declare namespace process {
+
+    export interface ChildProcess {
+        readonly pid: number;
+        readonly ppid: number;
+        readonly exitCode: number;
+        readonly killed: boolean;
+
+        wait(): Promise<number>;
+        /**
+        * Buffer the stdout until EOF and return it as 'Uint8Array'
+        */
+        getOutput(): Promise<Uint8Array>;
+        /**
+        * Buffer the stderr until EOF and return it as 'Uint8Array'
+        */
+        getErrorOutput(): Promise<Uint8Array>;
+        /**
+        * close the target process
+        */
+        close(): void;
+        /**
+        * send a signal to process
+        */
+        kill(signal: number | string): void;
+    }
+    type EventListener = (evt: Object) => void;
+    /**
+    * spawns a new ChildProcess to run the command
+    */
+    function runCmd(command: string,
+        options?: { timeout : number, killSignal : number | string, maxBuffer : number }): ChildProcess;
+
+    /**
+    *abort current process
+    *@return void
+    */
+    function abort(): void;
+
+    function on(type: string, listener: EventListener): void;
+    function off(type: string): boolean;
+    function exit(code: number): void;
+    /**
+    *get current work directory;
+    */
+    function cwd(): string;
+
+    /**
+    *change current  directory
+    *@param dir
+    */
+    function chdir(dir: string): void;
+
+    function uptime(): number;
+    /**
+     * send some signal to target process
+     */
+    function kill(signal: number, pid: number): boolean;
+
+    readonly getEgid: number;
+    readonly getEuid: number;
+    readonly getGid: number;
+    readonly getUid: number;
+    readonly getGroups: number[];
+    readonly getPid: number;
+    readonly getPpid: number;
+}
+export default process;
\ No newline at end of file
diff --git a/api/phone/@ohos.url.d.ts b/api/phone/@ohos.url.d.ts
new file mode 100755
index 0000000000000000000000000000000000000000..78296ef60b7172524ab2d8d090749146d8aaa8a1
--- /dev/null
+++ b/api/phone/@ohos.url.d.ts
@@ -0,0 +1,120 @@
+/*
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+declare namespace url {
+    class URLSearchParams {
+        constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
+        /*
+        * Appends a specified key/value pair as a new search parameter.
+        */
+        append(name: string, value: string): void;
+
+        /** Deletes the given search parameter and its associated value,
+        * from the list of all search parameters.
+        */
+        delete(name: string): void;
+
+        /** Returns all the values associated with a given search parameter
+        * as an array.
+        */
+        getAll(name: string): string[];
+
+        /** Returns an iterator allowing to go through all key/value
+        * pairs contained in this object.
+        */
+        entries(): IterableIterator<[string, string]>;
+        /** Allows iteration through all values contained in this object via a callback function.
+        */
+        forEach(callbackfn: (value: string, key: string, parent: this) => void, thisArg?: Object): void;
+
+        /** Returns the first value associated to the given search parameter.
+        */
+        get(name: string): string | null;
+
+        /** Returns a Boolean that indicates whether a parameter with the
+        * specified name exists.
+        */
+        has(name: string): boolean;
+
+        /** Sets the value associated with a given search parameter to the
+        * given value. If there were several matching values, this method
+        * deletes the others. If the search parameter doesn't exist, this
+        * method creates it.
+        */
+        set(name: string, value: string): void;
+        /** Sort all key/value pairs contained in this object in place and
+        * return undefined.
+        */
+        sort(): void;
+
+        /** Returns an iterator allowing to go through all keys contained
+        * in this object.
+        */
+        keys(): IterableIterator<string>;
+
+        /** Returns an iterator allowing to go through all values contained
+        * in this object.
+        */
+        values(): IterableIterator<string>;
+
+        /** Returns an iterator allowing to go through all key/value
+        * pairs contained in this object.
+        */
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+
+        /*
+        * Returns a query string suitable for use in a URL.
+        */
+        toString(): string;
+    }
+    /* web api URL interface */
+    class URL {
+        /** constructor of URL
+        *  url: absolute URL string or a relative URL string
+        *  base: base URL string
+        */
+        constructor(url: string, base?: string | URL);
+
+        /* methods */
+        toString(): string;
+        toJSON(): string;
+
+        /* fragment identifier of URL */
+        hash: string;
+        /* domain:port of URL */
+        host: string;
+        /* domain of URL */
+        hostname: string;
+        /* whole URL */
+        href: string;
+        /* contain the origin of the URL, readonly */
+        readonly origin: string;
+        /* password specified before the domain name */
+        password: string;
+        /* an '/' followed by the path of the URL */
+        pathname: string;
+        /* port of the URL */
+        port: string;
+        /* the protocol scheme of the URL */
+        protocol: string;
+        /* indicating the parameter string of the URL */
+        search: string;
+        /* URLSearchParams object which used to access the individual query parameters */
+        readonly searchParams: URLSearchParams;
+        /* the username before the domain name */
+        username: string;
+    }
+}
+export default url;
\ No newline at end of file
diff --git a/api/phone/@ohos.util.d.ts b/api/phone/@ohos.util.d.ts
new file mode 100755
index 0000000000000000000000000000000000000000..7b3aeceaae2f37cf2cc572bbbd0b2d262f048b5c
--- /dev/null
+++ b/api/phone/@ohos.util.d.ts
@@ -0,0 +1,82 @@
+/*
+* Copyright (c) 2021 Huawei Device Co., Ltd.
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+declare namespace util {
+	/** return a formatted string using the first argument as a printf-like format. */
+	/**     %s: String will be used to convert all values except BigInt, Object and -0. BigInt values will 
+	be represented with an n and Objects that have no user defined toString function are inspected using
+	util.inspect() with options { depth: 0, colors: false, compact: 3 }.
+			%d: Number will be used to convert all values except BigInt and Symbol.
+			%i: parseInt(value, 10) is used for all values except BigInt and Symbol.
+			%f: parseFloat(value) is used for all values except Bigint and Symbol.
+			%j: JSON. Replaced whith the string '[Circular]' if the argument contains circular references.
+			%o: Object. A string representation of an object with generic JavaScript object formatting.
+			Similar to util.inspect() with options { showHidden: true, showProxy: true}. This will show the
+			full object including non-enumerable properties and proxies.
+			%O: Object. A string representation of an object with generic JavaScript object formatting.
+			Similar to util.inspect() without options. This will show the full object not including
+			non-enumerable properties and proxies.
+			%c: CSS. This specifier is ignored and will skip any CSS passed in.
+			%%: single percent sign ('%'). This does not consume an argument.
+			Returns: <string> The formatted string */
+	function printf(format: string, ...args: Object[]): string;
+		
+	/** return the string name of a system errno*/
+	function getErrorString(errno: number): string;
+		
+	/** Takes an async function (or a function that returns a Promise) and returns a function following the
+	error-first callback style */
+	function callbackWrapper(original: Function): (err: Object, value: Object) => void;
+		
+	/** Takes a function following the common error-first callback style, i.e taking an (err, value) => ...
+	callback as the last argument, and return a version that returns promises */
+	function promiseWrapper(original: (err: Object, value: Object) => void): Object;
+	
+	/**
+     *  encoding name: support full encoding in ICU data utf-8 utf-16 iso8859 must support in all device
+     */
+    class TextDecoder {
+        /** the source encoding's name, lowercased. */
+        readonly encoding: string;
+        /** Returns `true` if error mode is "fatal", and `false` otherwise. */
+        readonly fatal: boolean;
+        /** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
+        readonly ignoreBOM = false;
+        constructor(
+            encoding?: string,
+            options?: { fatal?: boolean; ignoreBOM?: boolean },
+        );
+        /** Returns the result of running encoding's decoder. */
+        decode(input?: ArrayBuffer | ArrayBufferView, options?: { stream?: false }): string;
+    }
+ /**
+     * TextEncoder takes a stream of code points as input and emits a stream of UTF-8 bytes.
+     */
+    class TextEncoder {
+        readonly encoding = "utf-8";
+
+        constructor();
+
+        /** Returns the result of encoder. */
+        encode(input?: string): Uint8Array;
+
+        /** encode string, write the result to dest array */
+        encodeInto(
+            input: string,
+            dest: Uint8Array,
+        ): { read: number; written: number };
+    }
+}
+
+export default util;
\ No newline at end of file
diff --git a/api/@system.app.d.ts b/api/phone/@system.app.d.ts
old mode 100755
new mode 100644
similarity index 42%
rename from api/@system.app.d.ts
rename to api/phone/@system.app.d.ts
index dfc8fb3f05e4616e64168f9a305f908a02fbbcf0..b33235d1c2558f4da91a775eac4d04c45a8d4d31
--- a/api/@system.app.d.ts
+++ b/api/phone/@system.app.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,22 +14,62 @@
  */
 
 export interface AppResponse {
+  /**
+   * Application bundleName.
+   * @since 6
+   */
+  appID: string;
+
+  /**
+   * Application name.
+   * @since 3
+   */
   appName: string;
+
+  /**
+   * Application version name.
+   * @since 3
+   */
   versionName: string;
+
+  /**
+   * Application version.
+   * @since 3
+   */
   versionCode: number;
 }
+
 export interface RequestFullWindowOptions {
+  /**
+   * Duration for transition from non-full window to full window, in milliseconds.
+   * By default, the value is in direct proportion to the distance between the non-full window and the full window.
+   * @devices phone, tablet
+   * @since 3
+   */
   duration?: number
 }
-export interface ScreenOnVisibleOptions {
-  visible?: boolean;
-  success?: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
-}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class App {
+  /**
+   * Obtains the declared information in the config.json file of an application.
+   */
   static getInfo(): AppResponse;
+
+  /**
+   * Destroys the current ability.
+   */
   static terminate(): void;
-  static screenOnVisible(options?: ScreenOnVisibleOptions): void;
+
+  /**
+   * Requests the application to run in full window.
+   * In some scenarios, such as semi-modal FA, the FA runs in non-full window.
+   * In this case, you can call this API.
+   * This API is invalid for an application already in full-window mode.
+   * @param obj Transition time from non-full window to full window, in milliseconds.
+   * By default, the value is in direct proportion to the distance between the non-full window and the full window.
+   */
   static requestFullWindow(options?: RequestFullWindowOptions): void;
 }
diff --git a/api/phone/@system.battery.d.ts b/api/phone/@system.battery.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7ae26125f6d99620d79329358f1eb906a34d0ff3
--- /dev/null
+++ b/api/phone/@system.battery.d.ts
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface BatteryResponse {
+  /**
+   * Whether the battery is being charged.
+   * @since 3
+   */
+  charging: boolean;
+
+  /**
+   * Current battery level, which ranges from 0.00 to 1.00.
+   * @since 3
+   */
+  level: number;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Battery {
+  /**
+   * Obtains the battery level of the current device.
+   * @param options
+   */
+  static getStatus(options?: {
+    /**
+     * Called when the current charging state and battery level are obtained.
+     * @since 3
+     */
+    success?: (data: BatteryResponse) => void;
+
+    /**
+     * Called when the current charging state and battery level fail to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+}
diff --git a/api/phone/@system.bluetooth.d.ts b/api/phone/@system.bluetooth.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7179d6fce62eb45ba3d384dede84629ea6ac5997
--- /dev/null
+++ b/api/phone/@system.bluetooth.d.ts
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface StartBLEScanOptions {
+  interval: number;
+
+  success: () => void;
+
+  fail: (data: string, code: number) => void;
+
+  complete: () => void;
+}
+
+export interface StopBLEScanOptions {
+  success: () => void;
+
+  fail: (data: string, code: number) => void;
+
+  complete: () => void;
+}
+
+export interface BluetoothDevice {
+  addrType: "public" | "random";
+
+  addr: string;
+
+  rssi: number;
+
+  txpower: string;
+
+  data: string;
+}
+
+export interface BLEFoundResponse {
+  devices: Array<BluetoothDevice>;
+}
+
+export interface SubscribeBLEFoundOptions{
+    success: (data: BLEFoundResponse) => void;
+
+    fail: (data: string, code: number) => void;
+}
+
+export default class Bluetooth {
+  /**
+   * Start BLE scan
+   * @param options Options
+   */
+  static startBLEScan(options: StartBLEScanOptions): void;
+
+  /**
+   * Stop BLE scan
+   * @param options Options
+   */
+  static stopBLEScan(options: StopBLEScanOptions): void;
+
+  /**
+   * Subscribe BLE found
+   * @param options Options
+   */
+  static subscribeBLEFound(options: SubscribeBLEFoundOptions): void;
+
+  /**
+   * Stop the subscription of BLE found
+   */
+  static unsubscribeBLEFound(): void;
+}
\ No newline at end of file
diff --git a/api/phone/@system.brightness.d.ts b/api/phone/@system.brightness.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ce62daf83fb19a68ba658b904e47107f63bc12b
--- /dev/null
+++ b/api/phone/@system.brightness.d.ts
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The screen brightness mode.
+ */
+export enum BrightnessModeResponse {
+  /**
+   * The screen brightness is manually adjusted.
+   * @since 3
+   */
+  MANUAL,
+
+  /**
+   * The screen brightness is automatically adjusted.
+   * @since 3
+   */
+  AUTO
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Brightness {
+  /**
+   * Obtains the current screen brightness.
+   * @param options
+   */
+  static getValue(options?: {
+    /**
+     * Called when the current screen brightness is obtains.
+     * @since 3
+     */
+    success?: (data: { value: number }) => void;
+
+    /**
+     * Called when the current screen bightness fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Sets the screen brightness.
+   * @param options
+   */
+  static setValue(options: {
+    /**
+     * Screen brightness. The value is an integer ranging from 1 to 255.
+     * If the value is less than or equal to 0, value 1 will be used.
+     * If the value is greater than 255, value 255 will be used.
+     * If the value contains decimals, the integral part of the value will be used.
+     * For example, if value 8.1 is set, value 8 will be used.
+     * @since 3
+     */
+    value: number;
+
+    /**
+     * Called when the setting is successful.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the setting fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution os completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Obtains the screen brightness adjustment mode.
+   * @param options
+   */
+  static getMode(options?: {
+    /**
+     * Called when the screen brightness adjustment mode is obtained.
+     * @since 3
+     */
+    success?: (data: { mode: BrightnessModeResponse }) => void;
+
+    /**
+     * Called when the screen brightness adjustment mode fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Sets the screen brightness adjustment mode.
+   * @param options
+   */
+  static setMode(options: {
+    /**
+     * The screen brightness mode
+     * 0: The screen brightness is manually adjusted.
+     * 1: The screen brightness is automatically adjusted.
+     * @since 3
+     */
+    mode: BrightnessModeResponse;
+
+    /**
+     * Called when the setting is successful.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the setting fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Sets whether to always keep the screen on.
+   * @param options
+   */
+  static setKeepScreenOn(options: {
+    /**
+     * Whether to always keep the screen on.
+     * @since 3
+     */
+    keepScreenOn: boolean;
+
+    /**
+     * Called when the setting is successful.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the setting fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+}
diff --git a/api/@system.configuration.d.ts b/api/phone/@system.configuration.d.ts
old mode 100755
new mode 100644
similarity index 58%
rename from api/@system.configuration.d.ts
rename to api/phone/@system.configuration.d.ts
index 84a0a6aabf7f00e62c7a9ac149519b90ce48b033..474fec0e5ce65b34931c82f7738e25edda0d7a31
--- a/api/@system.configuration.d.ts
+++ b/api/phone/@system.configuration.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,10 +14,33 @@
  */
 
 export interface LocaleResponse {
+  /**
+   * Current language of the application. Example: zh.
+   * @since 3
+   */
   language: string;
+
+  /**
+   * Country or region. Example: CN.
+   * @since 3
+   */
   countryOrRegion: string;
+
+  /**
+   * Text layout direction. Available values are as follows:
+   * ltr: The text direction is from left to right.
+   * rtl: The text direction is from right to left.
+   * @since 3
+   */
   dir: "ltr" | "rtl";
 }
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Configuration {
+  /**
+   * Obtains the current locale of the application, which is the same as the system locale.
+   */
   static getLocale(): LocaleResponse;
 }
diff --git a/api/phone/@system.device.d.ts b/api/phone/@system.device.d.ts
old mode 100755
new mode 100644
index 7ce278bc590266b266e437d6da5cd2134bc5de40..4d2949e48f57261789ff8a931514f9f3a742f7f7
--- a/api/phone/@system.device.d.ts
+++ b/api/phone/@system.device.d.ts
@@ -1,133 +1,133 @@
-/*
- * Copyright (c) 2020 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface DeviceResponse {
-  /**
-   * Brand.
-   * @since 3
-   */
-  brand: string;
-
-  /**
-   * Manufacturer.
-   * @since 3
-   */
-  manufacturer: string;
-
-  /**
-   * Model.
-   * @since 3
-   */
-  model: string;
-
-  /**
-   * Product number.
-   * @since 3
-   */
-  product: string;
-
-  /**
-   * System language.
-   * @since 4
-   */
-  language: string;
-
-  /**
-   * System region.
-   * @since 4
-   */
-  region: string;
-
-  /**
-   * Window width.
-   * @since 3
-   */
-  windowWidth: number;
-
-  /**
-   * Window Height.
-   * @since 3
-   */
-  windowHeight: number;
-
-  /**
-   * Screen density.
-   * @since 4
-   */
-  screenDensity: number;
-
-  /**
-   * Screen shape. The options are as follows:
-   * rect: Rectangle screen.
-   * cicle: Circle screen.
-   * @since 4
-   */
-  screenShape: "rect" | "circle";
-
-    /**
-   * API version.
-   * @devices tv, phone, tablet, wearable, liteWearable, smartVision
-   * @since 4
-   */
-  apiVersion: number;
-
-  /**
-   * Device type. The options are as follows:
-   * phone: smartphone
-   * tablet: tablet
-   * tv: smart TV
-   * wearable: wearable
-   * liteWearable: lite wearable
-   * ar: AR
-   * vr: virtual reality
-   * earphones: headset
-   * pc: personal computer
-   * speaker: speaker
-   * smartVision: smart visual device
-   * linkIoT: connection module
-   * @devices tv, phone, tablet, wearable, liteWearable, smartVision
-   * @since 4
-   */
-  deviceType: string;
-}
-
-/**
- * @Syscap SysCap.ACE.UIEngine
- */
-export default class Device {
-  /**
-   * Obtains the device information.
-   * @param options
-   */
-  static getInfo(options?: {
-    /**
-     * Called when the device information is obtained.
-     * @since 3
-     */
-    success?: (data: DeviceResponse) => void;
-
-    /**
-     * Called when the device information fails to be obtained.
-     * @since 3
-     */
-    fail?: (data: any, code: number) => void;
-
-    /**
-     * Called when the execution is completed.
-     * @since 3
-     */
-    complete?: () => void;
-  }): void;
-}
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface DeviceResponse {
+  /**
+   * Brand.
+   * @since 3
+   */
+  brand: string;
+
+  /**
+   * Manufacturer.
+   * @since 3
+   */
+  manufacturer: string;
+
+  /**
+   * Model.
+   * @since 3
+   */
+  model: string;
+
+  /**
+   * Product number.
+   * @since 3
+   */
+  product: string;
+
+  /**
+   * System language.
+   * @since 4
+   */
+  language: string;
+
+  /**
+   * System region.
+   * @since 4
+   */
+  region: string;
+
+  /**
+   * Window width.
+   * @since 3
+   */
+  windowWidth: number;
+
+  /**
+   * Window Height.
+   * @since 3
+   */
+  windowHeight: number;
+
+  /**
+   * Screen density.
+   * @since 4
+   */
+  screenDensity: number;
+
+  /**
+   * Screen shape. The options are as follows:
+   * rect: Rectangle screen.
+   * cicle: Circle screen.
+   * @since 4
+   */
+  screenShape: "rect" | "circle";
+
+    /**
+   * API version.
+   * @devices tv, phone, tablet, wearable, liteWearable, smartVision
+   * @since 4
+   */
+  apiVersion: number;
+
+  /**
+   * Device type. The options are as follows:
+   * phone: smartphone
+   * tablet: tablet
+   * tv: smart TV
+   * wearable: wearable
+   * liteWearable: lite wearable
+   * ar: AR
+   * vr: virtual reality
+   * earphones: headset
+   * pc: personal computer
+   * speaker: speaker
+   * smartVision: smart visual device
+   * linkIoT: connection module
+   * @devices tv, phone, tablet, wearable, liteWearable, smartVision
+   * @since 4
+   */
+  deviceType: string;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Device {
+  /**
+   * Obtains the device information.
+   * @param options
+   */
+  static getInfo(options?: {
+    /**
+     * Called when the device information is obtained.
+     * @since 3
+     */
+    success?: (data: DeviceResponse) => void;
+
+    /**
+     * Called when the device information fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+}
diff --git a/api/@system.fetch.d.ts b/api/phone/@system.fetch.d.ts
old mode 100755
new mode 100644
similarity index 31%
rename from api/@system.fetch.d.ts
rename to api/phone/@system.fetch.d.ts
index b210f0edf9be59044e2a83cf11fab33b21cda913..1effccc7fe17cbadddaac9259c504402ebf9f8f2
--- a/api/@system.fetch.d.ts
+++ b/api/phone/@system.fetch.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,20 +14,80 @@
  */
 
 export interface FetchResponse {
+  /**
+   * Server status code.
+   * @since 3
+   */
   code: number;
+
+  /**
+   * Data returned by the success function.
+   * @since 3
+   */
   data: string | object;
+
+  /**
+   * All headers in the response from the server.
+   * @since 3
+   */
   headers: Object;
 }
-export interface FetchOptions {
-  url: string;
-  data?: string | object;
-  header?: Object;
-  method?: "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE";
-  responseType?: string;
-  success?: (data: FetchResponse) => void;
-  fail?: (data: any, code: number) => void;
-  complete?: () => void;
-}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Fetch {
-  static fetch(options: FetchOptions): void;
+  /**
+   * Obtains data through the network.
+   * @param options
+   */
+  static fetch(options: {
+    /**
+     * Resource URL.
+     * @since 3
+     */
+    url: string;
+
+    /**
+     * Request parameter, which can be of the string type or a JSON object.
+     * @since 3
+     */
+    data?: string | object;
+
+    /**
+     * Request header, which accommodates all attributes of the request.
+     * @since 3
+     */
+    header?: Object;
+
+    /**
+     * Request methods available: OPTIONS, GET, HEAD, POST, PUT, DELETE and TRACE. The default value is GET.
+     * @since 3
+     */
+    method?: string;
+
+    /**
+     * The return type can be text, or JSON. By default, the return type is determined based on Content-Type in the header returned by the server.
+     * @since 3
+     */
+    responseType?: string;
+
+    /**
+     * Called when the network data is obtained successfully.
+     * @since 3
+     */
+    success?: (data: FetchResponse) => void;
+
+    /**
+     * Called when the network data fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
 }
diff --git a/api/phone/@system.file.d.ts b/api/phone/@system.file.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..262865ae290cc48c6d36016b0c1442ff2bff8654
--- /dev/null
+++ b/api/phone/@system.file.d.ts
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface FileResponse {
+  /**
+   * File URI.
+   * @since 3
+   */
+  uri: string;
+
+  /**
+   * File size, in bytes.
+   * @since 3
+   */
+  length: number;
+
+  /**
+   * Timestamp when the file is stored, which is the number of milliseconds elapsed since 1970/01/01 00:00:00 GMT.
+   * @since 3
+   */
+  lastModifiedTime: number;
+
+  /**
+   * File type. Available values are as follows:
+   * dir: directory
+   * file: file
+   * @since 3
+   */
+  type: "dir" | "file";
+
+  /**
+   * File list.
+   * @since 3
+   */
+  subFiles?: Array<FileResponse>;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class File {
+  /**
+   * Moves a specified file to a given location.
+   * @param options Options.
+   */
+  static move(options: {
+    /**
+     * URI of the file to move.
+     * @since 3
+     */
+    srcUri: string;
+
+    /**
+     * URI of the location to which the file is to move.
+     * @since 3
+     */
+    dstUri: string;
+
+    /**
+     * Called when the source file is moved to the specified location successfully.
+     * This function returns the URI of the file moved to the target location.
+     * @since 3
+     */
+    success?: (uri: string) => void;
+
+    /**
+     * Called when moving fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Copies a file and save the copy to a specified location.
+   * @param options Options.
+   */
+  static copy(options: {
+    /**
+     * URI of the file to copy.
+     * @since 3
+     */
+    srcUri: string;
+
+    /**
+     * URI of the location to which the copy is to save.
+     * The directory of application resources and URI of the tmp type are not supported.
+     * @since 3
+     */
+    dstUri: string;
+
+    /**
+     * Called when the source file is copied and saved to the specified location successfully.
+     * This function returns the URI of the file moved to the target location.
+     * @since 3
+     */
+    success?: (uri: string) => void;
+
+    /**
+     * Called when the copy or save operation fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Obtains the list of files in a specified directory.
+   * @param options Options.
+   */
+  static list(options: {
+    /**
+     * URI of the directory.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Called when the list is obtained successfully.
+     * @since 3
+     */
+    success?: (data: { fileList: Array<FileResponse> }) => void;
+
+    /**
+     * Called when the list fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Obtains information about a specified local file.
+   * @param options
+   */
+  static get(options: {
+    /**
+     * File URI.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Whether to recursively obtain the file list under a subdirectory.
+     * The default value is false.
+     * @since 3
+     */
+    recursive?: boolean;
+
+    /**
+     * Called when file information is obtained successfully.
+     * @since 3
+     */
+    success?: (file: FileResponse) => void;
+
+    /**
+     * Called when file information fails to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Deletes a local file.
+   * @param options
+   */
+  static delete(options: {
+    /**
+     * URI of the file to be deleted, which cannot be an application resource path.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Called when local files are deleted successfully.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the deletion fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Writes texts into a specified file.
+   * @param options
+   */
+  static writeText(options: {
+    /**
+     * URI of a local file. If it does not exist, a file will be created.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Character string to write into the local file.
+     * @since 3
+     */
+    text: string;
+
+    /**
+     * Encoding format. The default format is UTF-8.
+     * @since 3
+     */
+    encoding?: string;
+
+    /**
+     * Whether to enable the append mode. The default value is false.
+     * @since 3
+     */
+    append?: boolean;
+
+    /**
+     * Called when texts are written into a file successfully.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when texts fail to be written into a file.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Reads texts from a specified file.
+   * @param options
+   */
+  static readText(options: {
+    /**
+     * URI of a local file.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Encoding format. The default format is UTF-8.
+     * @since 3
+     */
+    encoding?: string;
+
+    /**
+     * Called when texts are read successfully.
+     * @since 3
+     */
+    success?: (data: { text: string }) => void;
+
+    /**
+     * Called when texts fail to be read.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Writes buffer data into a specified file.
+   * @param options Options.
+   */
+  static writeArrayBuffer(options: {
+    /**
+     * URI of a local file. If it does not exist, a file will be created.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Buffer from which the data is derived.
+     * @since 3
+     */
+    buffer: Uint8Array;
+
+    /**
+     * Offset to the position where the writing starts. The default value is 0.
+     * @since 3
+     */
+    position?: number;
+
+    /**
+     * Whether to enable the append mode. The default value is false. If the value is true, the position parameter will become invalid.
+     * @since 3
+     */
+    append?: boolean;
+
+    /**
+     * Called when data from a buffer is written into a file successfully.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when data from a buffer fails to be written into a file.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Reads buffer data from a specified file.
+   * @param options Options.
+   */
+  static readArrayBuffer(options: {
+    /**
+     * URI of a local file.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Position where the reading starts.
+     * The default value is the start position of the file.
+     * @since 3
+     */
+    position?: number;
+
+    /**
+     * Length of the content to read.
+     * If this parameter is not set, the reading proceeds until the end of the file.
+     * @since 3
+     */
+    length?: number;
+
+    /**
+     * Called when the buffer data is read successfully.
+     * @since 3
+     */
+    success?: (data: { buffer: Uint8Array }) => void;
+
+    /**
+     * Called when the buffer data fails to be read.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Checks whether a specified file or directory exists.
+   * @param options Options.
+   */
+  static access(options: {
+    /**
+     * URI of the directory or file.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Called when the check result is obtained successfully.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the check fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Creates a specified directory.
+   * @param options Options.
+   */
+  static mkdir(options: {
+    /**
+     * URI of the directory.
+     * @since 3
+     */
+    uri: string;
+
+    /**
+     * Whether to recursively create upper-level directories of the specified directory.
+     * The default value is false.
+     * @since 3
+     */
+    recursive?: boolean;
+
+    /**
+     * Called when the directory is created successfully.
+     * @since 3
+     */
+    success?: () => void;
+
+    /**
+     * Called when the creation fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Deletes a specified directory.
+   * @param options
+   */
+  static rmdir(options: {
+    /**
+     * URI of the directory.
+     */
+    uri: string;
+
+    /**
+     * Whether to recursively delete sub files and subdirectories of the specified directory.
+     * The default value is false.
+     */
+    recursive?: boolean;
+
+    /**
+     * Called when the directory is deleted successfully.
+     */
+    success?: () => void;
+
+    /**
+     * Called when the deletion fails.
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     */
+    complete?: () => void;
+  }): void;
+}
diff --git a/api/phone/@system.geolocation.d.ts b/api/phone/@system.geolocation.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..44ba6164c687ee6864e4876b70a24f6efe2787fb
--- /dev/null
+++ b/api/phone/@system.geolocation.d.ts
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface GeolocationResponse {
+  /**
+   * Longitude.
+   * @since 3
+   */
+  longitude: number;
+
+  /**
+   * Latitude.
+   * @since 3
+   */
+  latitude: number;
+
+  /**
+   * Altitude.
+   * @since 3
+   */
+  altitude: number;
+
+  /**
+   * Location accuracy.
+   * @since 3
+   */
+  accuracy: number;
+
+  /**
+   * Time when the location is obtained.
+   * @since 3
+   */
+  time: number;
+}
+
+export interface GetLocationTypeResponse {
+  /**
+   * Available location types, ['gps', 'network'].
+   * @since 3
+   */
+  types: Array<string>;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Geolocation {
+  /**
+   * Obtains the geographic location.
+   * @param options
+   */
+  static getLocation(options?: {
+    /**
+     * Timeout duration, in milliseconds. The default value is 30000.
+     * The timeout duration is necessary in case no result is returned if the request to obtain the geographic location is rejected for the lack of the required permission, weak positioning signal, or incorrect location settings. After the timeout duration expires, the fail function will be called.
+     * The value is a 32-digit positive integer. If the value set is less than or equal to 0, the default value will be used.
+     * @since 3
+     */
+    timeout?: number;
+
+    /**
+     * Coordinate system type. Available types can be obtained by getSupportedCoordTypes. The default type is wgs84.
+     * @since 3
+     */
+    coordType?: string;
+
+    /**
+     * Called when the geographic location is obtained.
+     * @since 3
+     */
+    success?: (data: GeolocationResponse) => void;
+
+    /**
+     * Called when the location types fail to be obtained
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Obtains the supported location types.
+   * @param options
+   */
+  static getLocationType(options?: {
+    /**
+     * Called when the location types are obtained.
+     * @since 3
+     */
+    success?: (data: GetLocationTypeResponse) => void;
+
+    /**
+     * Called when the location types fail to be obtained.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+
+    /**
+     * Called when the execution is completed.
+     * @since 3
+     */
+    complete?: () => void;
+  }): void;
+
+  /**
+   * Listens to the geographical location. If this method is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribe(options: {
+    /**
+     * Coordinate system type. Available types can be obtained by getSupportedCoordTypes. The default type is wgs84.
+     * @since 3
+     */
+    coordType?: string;
+
+    /**
+     * Called when the geographical location changes.
+     * @since 3
+     */
+    success: (data: GeolocationResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to the geographical location.
+   */
+  static unsubscribe(): void;
+
+  /**
+   * Obtains coordinate system types supported by the device.
+   * @returns A string array of the supported coordinate system types. For details about the value, see coordType.
+   */
+  static getSupportedCoordTypes(): Array<string>;
+}
diff --git a/api/phone/@system.mediaquery.d.ts b/api/phone/@system.mediaquery.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..da3f223c51ebf6d21ea1cc88072a2f05e3b98b1c
--- /dev/null
+++ b/api/phone/@system.mediaquery.d.ts
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface MediaQueryEvent {
+  matches: boolean;
+}
+
+export interface MediaQueryList {
+  /**
+  * Serialized media query condition.
+  * This parameter is read-only.
+  * @since 3
+  */
+  media?: string;
+
+  /**
+  * Whether the query is successful. True if the query condition is matched successfully, false otherwise.
+  * This parameter is read-only.
+  * @since 3
+  */
+  matches?: boolean;
+
+  /**
+  * Called when the matches value changes.
+  * @since 3
+  */
+  onchange?: (matches: boolean) => void;
+
+  /**
+   * Adds a listening function to MediaQueryList.
+   * The listening function must be added before onShow is called, that is, added to the onInit or onReady function.
+   * @since 3
+   */
+  addListener(callback: (event: MediaQueryEvent) => void): void;
+
+  /**
+   * Removes a listening function from MediaQueryList.
+   * @since 3
+   */
+  removeListener(callback: (event: MediaQueryEvent) => void): void;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class MediaQuery {
+  /**
+   * Queries a media item and returns a MediaQueryList object.
+   */
+  static matchMedia(condition: string): MediaQueryList;
+}
diff --git a/api/phone/app/want.d.ts b/api/phone/@system.network.d.ts
old mode 100755
new mode 100644
similarity index 33%
rename from api/phone/app/want.d.ts
rename to api/phone/@system.network.d.ts
index a1b19122d76b13f2af53cf753476569fca51b9ac..531ea6800be9e9d10c7837dc65c40e7e2d3f789a
--- a/api/phone/app/want.d.ts
+++ b/api/phone/@system.network.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -13,69 +13,69 @@
  * limitations under the License.
  */
 
-import {ElementName} from "./elementname"
+export interface NetworkResponse {
+  /**
+   * Network type. The values can be 2G, 3G, 4G, WiFi, or none.
+   * @since 3
+   */
+  type: string;
+
+  /**
+   * Whether the billing is based on the data volume.
+   * @since 3
+   */
+  metered: boolean;
+}
 
 /**
- * Want is the basic communication component of the system.
- * @name Want
- * @since 6
- * @sysCap aafwk
- * @devices phone
- * @permission N/A
- * @testapi
- **/
-export declare interface Want {
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Network {
+  /**
+   * Obtains the network type.
+   * @param options
+   */
+  static getType(options?: {
     /**
-     * The description of the type in this Want.
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
+     * Called when the network type is obtained.
+     * @since 3
      */
-    type: string;
+    success?: (data: NetworkResponse) => void;
 
     /**
-     * The description of the flags in this Want.
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
+     * Called when the network type fails to be obtained.
+     * @since 3
      */
-    flags: number;
+    fail?: (data: any, code: number) => void;
 
     /**
-     * The description of an action in an want.
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
+     * Called when the execution is completed.
+     * @since 3
      */
-    action: string;
+    complete?: () => void;
+  }): void;
 
+  /**
+   * Listens to the network connection state. If this method is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribe(options?: {
     /**
-     * The description of the WantParams object in an Want
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
+     * Called when the network connection state changes.
+     * @since 3
      */
-    want_param?: object
+    success?: (data: NetworkResponse) => void;
 
     /**
-     * The description of a entities in a Want.
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
+     * Called when the listening fails.
+     * @since 3
      */
-    entities: Array<string>;
+    fail?: (data: any, code: number) => void;
+  }): void;
 
-    /**
-     * The description of an elementname in a Want.
-     * @devices phone, tablet
-     * @since 6
-     * @sysCap AAFwk
-     * @default -
-     */
-    elementName: ElementName;
-}
\ No newline at end of file
+  /**
+   * Cancels listening to the network connection state.
+   * @param options
+   */
+  static unsubscribe(): void;
+}
diff --git a/api/phone/@system.notification.d.ts b/api/phone/@system.notification.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8066d0769d05eefc8071295e02235a7c0de91aab
--- /dev/null
+++ b/api/phone/@system.notification.d.ts
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ActionResult {
+  /**
+   * Bundle name of the application to be redirected to after the notification is clicked.
+   * @since 3
+   */
+  bundleName: string;
+
+  /**
+   * Ability name of the application to be redirected to after the notification is clicked.
+   * @since 3
+   */
+  abilityName: string;
+
+  /**
+   * URI of the page to be redirected to. The supported URI formats are as follows:
+   * 1. Absolute path of the page, which is provided by the pages list in the config.json file. Example:
+   * pages/index/index
+   * pages/detail/detail
+   * 2. Particular path. If the value is a slash (/), the home page is displayed.
+   * @since 3
+   */
+  uri: string;
+}
+
+export interface ShowNotificationOptions {
+  /**
+   * Notification title.
+   * @since 3
+   */
+  contentTitle?: string;
+
+  /**
+   * Notification content.
+   * @since 3
+   */
+  contentText?: string;
+
+  /**
+   * Action triggered after the notification is clicked.
+   * @since 3
+   */
+  clickAction?: ActionResult;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Notification {
+    /**
+     * Displays the notification.
+     * @param options
+     */
+    static show(options?: ShowNotificationOptions): void;
+}
\ No newline at end of file
diff --git a/api/@system.package.d.ts b/api/phone/@system.package.d.ts
old mode 100755
new mode 100644
similarity index 60%
rename from api/@system.package.d.ts
rename to api/phone/@system.package.d.ts
index a2a9d1a34d4819d30f07e283194a1cac8140f5cb..bcb42820845c41d873edb65c1fcd73d6370411da
--- a/api/@system.package.d.ts
+++ b/api/phone/@system.package.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,14 +14,46 @@
  */
 
 export interface CheckPackageHasInstalledResponse {
+  /**
+   * Whether the application exists, or whether the native application has been installed.
+   * @since 3
+   */
   result: boolean;
 }
+
 export interface CheckPackageHasInstalledOptions {
+  /**
+   * Application bundle name.
+   * @since 3
+   */
   bundleName: string;
+
+  /**
+   * Called when native applications are installed.
+   * @since 3
+   */
   success?: (data: CheckPackageHasInstalledResponse) => void;
+
+  /**
+   * Called when native applications fail to be installed.
+   * @since 3
+   */
   fail?: (data: any, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Package {
+  /**
+   * Checks whether an application exists, or whether a native application has been installed.
+   * @param options
+   */
   static hasInstalled(options: CheckPackageHasInstalledOptions): void;
 }
diff --git a/api/phone/@system.prompt.d.ts b/api/phone/@system.prompt.d.ts
old mode 100755
new mode 100644
index e5fe238932fceb8da777f57cf28358421c8ee300..9223d1b2b95479e19e5302c5188f92e3d5d22649
--- a/api/phone/@system.prompt.d.ts
+++ b/api/phone/@system.prompt.d.ts
@@ -1,132 +1,138 @@
-/*
- * Copyright (c) 2020 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-export interface ShowToastOptions {
-  /**
-   * Text to display.
-   * @since 3
-   */
-  message: string;
-
-  /**
-   * Duration of toast dialog box. The default value is 1500. The recommended value ranges from 1500 ms to 10000ms.
-   * NOTE:
-   * A value less than 1500 is automatically changed to 1500. The maximum value is 10000 ms.
-   * @since 3
-   */
-  duration?: number;
-}
-
-export interface Button {
-  text: string;
-  color: string;
-}
-
-export interface ShowDialogOptions {
-  /**
-   * Title of the text to display.
-   * @since 3
-   */
-  title?: string;
-
-  /**
-   * Text body.
-   * @since 3
-   */
-  message?: string;
-
-  /**
-   * Array of buttons in the dialog box.
-   * The array structure is {text:'button', color: '#666666'}.
-   * One to three buttons are supported. The first button is of the positiveButton type, the second is of the negativeButton type, and the third is of the neutralButton type.
-   * @since 3
-   */
-  buttons?: [Button, Button?, Button?];
-
-  /**
-   * Called when the dialog box is displayed.
-   * @since 3
-   */
-  success?: (data: { index: number }) => void;
-
-  /**
-   * Called when the operation is cancelled.
-   * @since 3
-   */
-  cancel?: (data: string, code: string) => void;
-
-  /**
-   * Called when the dialog box is closed.
-   * @since 3
-   */
-  complete?: (data: string) => void;
-}
-
-export interface ShowActionMenuOptions {
-  /**
-   * Title of the text to display.
-   * @since 6
-   */
-  title?: string;
-
-  /**
-   * Array of buttons in the dialog box.
-   * The array structure is {text:'button', color: '#666666'}.
-   * One to six buttons are supported.
-   * @since 6
-   */
-  buttons: [Button, Button?, Button?, Button?, Button?, Button?];
-
-  /**
-   * Called when the dialog box is displayed.
-   * @since 6
-   */
-  success?: (tapIndex: number, errMsg: string) => void;
-
-  /**
-   * Called when the operation is cancelled.
-   * @since 6
-   */
-  fail?: (errMsg: string) => void;
-
-  /**
-   * Called when the dialog box is closed.
-   * @since 6
-   */
-  complete?: () => void;
-}
-
-/**
- * @Syscap SysCap.ACE.UIEngine
- */
-export default class Prompt {
-  /**
-   * Displays the notification text.
-   * @param toast
-   */
-  static showToast(toast: ShowToastOptions): void;
-
-  /**
-   * Displays the dialog box.
-   * @param dialog
-   */
-  static showDialog(dialog: ShowDialogOptions): void;
-
-    /**
-   * Displays the menu.
-   * @param options Options.
-   */
-  static showActionMenu(options: ShowActionMenuOptions): void;
-}
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface ShowToastOptions {
+  /**
+   * Text to display.
+   * @since 3
+   */
+  message: string;
+
+  /**
+   * Duration of toast dialog box. The default value is 1500. The recommended value ranges from 1500 ms to 10000ms.
+   * NOTE:
+   * A value less than 1500 is automatically changed to 1500. The maximum value is 10000 ms.
+   * @since 3
+   */
+  duration?: number;
+
+  /**
+   * The distance between toast dialog box and the bottom of screen.
+   * @since 5
+   */
+  bottom?: string | number;
+}
+
+export interface Button {
+  text: string;
+  color: string;
+}
+
+export interface ShowDialogOptions {
+  /**
+   * Title of the text to display.
+   * @since 3
+   */
+  title?: string;
+
+  /**
+   * Text body.
+   * @since 3
+   */
+  message?: string;
+
+  /**
+   * Array of buttons in the dialog box.
+   * The array structure is {text:'button', color: '#666666'}.
+   * One to three buttons are supported. The first button is of the positiveButton type, the second is of the negativeButton type, and the third is of the neutralButton type.
+   * @since 3
+   */
+  buttons?: [Button, Button?, Button?];
+
+  /**
+   * Called when the dialog box is displayed.
+   * @since 3
+   */
+  success?: (data: { index: number }) => void;
+
+  /**
+   * Called when the operation is cancelled.
+   * @since 3
+   */
+  cancel?: (data: string, code: string) => void;
+
+  /**
+   * Called when the dialog box is closed.
+   * @since 3
+   */
+  complete?: (data: string) => void;
+}
+
+export interface ShowActionMenuOptions {
+  /**
+   * Title of the text to display.
+   * @since 6
+   */
+  title?: string;
+
+  /**
+   * Array of buttons in the dialog box.
+   * The array structure is {text:'button', color: '#666666'}.
+   * One to six buttons are supported.
+   * @since 6
+   */
+  buttons: [Button, Button?, Button?, Button?, Button?, Button?];
+
+  /**
+   * Called when the dialog box is displayed.
+   * @since 6
+   */
+  success?: (tapIndex: number, errMsg: string) => void;
+
+  /**
+   * Called when the operation is cancelled.
+   * @since 6
+   */
+  fail?: (errMsg: string) => void;
+
+  /**
+   * Called when the dialog box is closed.
+   * @since 6
+   */
+  complete?: () => void;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Prompt {
+  /**
+   * Displays the notification text.
+   * @param toast
+   */
+  static showToast(toast: ShowToastOptions): void;
+
+  /**
+   * Displays the dialog box.
+   * @param dialog
+   */
+  static showDialog(dialog: ShowDialogOptions): void;
+
+    /**
+   * Displays the menu.
+   * @param options Options.
+   */
+  static showActionMenu(options: ShowActionMenuOptions): void;
+}
diff --git a/api/@system.request.d.ts b/api/phone/@system.request.d.ts
old mode 100755
new mode 100644
similarity index 40%
rename from api/@system.request.d.ts
rename to api/phone/@system.request.d.ts
index 13bfc053696fb4402cc196ff7c419964b740e98e..fa1c61c5a43c101e5cea2e35a1ec526bb579fcdf
--- a/api/@system.request.d.ts
+++ b/api/phone/@system.request.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,53 +14,223 @@
  */
 
 export interface UploadResponse {
+  /**
+   * Status code returned by the server.
+   * @since 3
+   */
   code: number;
+
+  /**
+   * Content returned by the server. The value type is determined by the returned content.
+   * @since 3
+   */
   data: string;
+
+  /**
+   * Headers returned by the server.
+   * @since 3
+   */
   headers: Object;
 }
+
 export interface DownloadResponse {
+  /**
+   * Download token, which is used to obtain the download status.
+   * @since 3
+   */
   token: string;
 }
+
 export interface OnDownloadCompleteResponse {
+  /**
+   * URI of the download file.
+   * @since 3
+   */
   uri: string;
 }
+
 export interface RequestFile {
+  /**
+   * File name in the header when multipart is used.
+   * @since 3
+   */
   filename?: string;
+
+  /**
+   * Name of a form item when multipart is used. The default value is file.
+   * @since 3
+   */
   name?: string;
+
+  /**
+   * Local storage directory of a file.
+   * @since 3
+   */
   uri: string;
+
+  /**
+   * Type of the file content. By default, the type is obtained based on the suffix of the filename or URI.
+   * @since 3
+   */
   type?: string;
 }
+
 export interface RequestData {
+  /**
+   * Name of the form element.
+   * @since 3
+   */
   name: string;
+
+  /**
+   * Value of the form element.
+   * @since 3
+   */
   value: string;
 }
+
 export interface UploadRequestOptions {
+  /**
+   * Resource URL.
+   * @since 3
+   */
   url: string;
+
+  /**
+   * Form data in the request body.
+   * @since 3
+   */
   data?: Array<RequestData>;
+
+  /**
+   * List of files to upload, which is submitted through multipart/form-data.
+   * @since 3
+   */
   files: Array<RequestFile>;
+
+  /**
+   * Request header.
+   * @since 3
+   */
   header?: Object;
+
+  /**
+   * Request methods available: POST and PUT. The default value is POST.
+   * @since 3
+   */
   method?: string;
+
+  /**
+   * Called when the files are uploaded successfully.
+   * @since 3
+   */
   success?: (data: UploadResponse) => void;
+
+  /**
+   * Called when uploading fails.
+   * @since 3
+   */
   fail?: (data: any, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
 export interface DownloadRequestOptions {
+  /**
+   * Resource URL.
+   * @since 3
+   */
   url: string;
+
+  /**
+   * Name of the file to downloaded.
+   * The value is obtained from the current request or resource URL by default.
+   * @since 3
+   */
   filename?: string;
+
+  /**
+   * Request header.
+   * @since 3
+   */
   header?: string;
+
+  /**
+   * Download description.
+   * The default value is the file name.
+   * @since 3
+   */
   description?: string;
+
+  /**
+   * Called when the files are successfully downloaded.
+   * @since 3
+   */
   success?: (data: DownloadResponse) => void;
+
+  /**
+   * Called when downloading fails.
+   * @since 3
+   */
   fail?: (data: any, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
 export interface OnDownloadCompleteOptions {
+  /**
+   * Token of the result returned by the download function.
+   * @since 3
+   */
   token: string;
+
+  /**
+   * Called when the downloads are successfully obtained
+   * @since 3
+   */
   success?: (data: OnDownloadCompleteResponse) => void;
+
+  /**
+   * Called when the downloads fail to be obtained.
+   * @since 3
+   */
   fail?: (data: any, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Request {
+  /**
+   * Upload files.
+   * @param options Options.
+   */
   static upload(options: UploadRequestOptions): void;
+
+  /**
+   * This API is used to download files.
+   * @param options Options.
+   */
   static download(options: DownloadRequestOptions): void;
+
+  /**
+   * Listens to download task status.
+   * @param options Options.
+   */
   static onDownloadComplete(options: OnDownloadCompleteOptions): void;
 }
+
diff --git a/api/phone/@system.router.d.ts b/api/phone/@system.router.d.ts
old mode 100755
new mode 100644
index 296766ff808458362f4e54401d59d134ef1855c1..14394e0696e2ab6b45c33d0226486e953af5a1fb
--- a/api/phone/@system.router.d.ts
+++ b/api/phone/@system.router.d.ts
@@ -33,13 +33,7 @@ export interface RouterOptions {
    */
   params?: Object;
 }
-export interface BackRouterOptions {
-  /**
-   * Returns to the page of the specified path. If the page with the specified path does not exist in the page stack, router.back() is called by default.
-   * @since 6
-   */
-  uri?: string;
-}
+
 export interface RouterState {
   /**
    * Index of the current page in the stack.NOTE:The index starts from 1 from the bottom to the top of the stack.
@@ -125,8 +119,16 @@ export default class Router {
   /**
    * Returns to the previous page or a specified page.
    * @param obj
+   * @since 7
+   */
+  static back(options?: RouterOptions): void;
+
+  /**
+   * Obtains information about the current page params.
+   * @returns Page params.
+   * @since 7
    */
-  static back(obj?: BackRouterOptions): void;
+  static getParams(): Object;
 
   /**
    * Clears all historical pages and retains only the current page at the top of the stack.
diff --git a/api/phone/@system.sensor.d.ts b/api/phone/@system.sensor.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b0addd5d69f76347f1206d1efb87cad53c34e555
--- /dev/null
+++ b/api/phone/@system.sensor.d.ts
@@ -0,0 +1,467 @@
+/*
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export interface AccelerometerResponse {
+  /**
+   * X-coordinate
+   * @since 3
+   */
+  x: number;
+
+  /**
+   * Y-coordinate
+   * @since 3
+   */
+  y: number;
+
+  /**
+   * Z-coordinate
+   * @since 3
+   */
+  z: number;
+}
+
+export interface CompassResponse {
+  /**
+   * Direction of the device (in degrees).
+   * @since 3
+   */
+  direction: number;
+}
+
+export interface LightResponse {
+  /**
+   * Light intensity, in lux.
+   * @since 3
+   */
+  intensity: number;
+}
+
+export interface StepCounterResponse {
+  /**
+   * Number of steps counted.
+   * Each time the device restarts, the value is recalculated from 0.
+   * @since 3
+   */
+  steps: number;
+}
+
+export interface BarometerResponse {
+  /**
+   * Pressure, in pascal.
+   * @since 3
+   */
+  pressure: number;
+}
+
+export interface DeviceOrientationResponse {
+  /**
+   * alpha
+   * @since 6
+   */
+  alpha: number;
+
+  /**
+   * beta
+   * @since 6
+   */
+  beta: number;
+
+  /**
+   * gamma
+   * @since 6
+   */
+  gamma: number;
+}
+
+export interface GyroscopeResponse {
+  /**
+   * X-coordinate
+   * @since 6
+   */
+  x: number;
+
+  /**
+   * Y-coordinate
+   * @since 6
+   */
+  y: number;
+
+  /**
+   * Z-coordinate
+   * @since 6
+   */
+  z: number;
+}
+
+export interface GravityResponse {
+  /**
+   * X-coordinate
+   * @since 7
+   */
+  x: number;
+
+  /**
+   * Y-coordinate
+   * @since 7
+   */
+  y: number;
+
+  /**
+   * Z-coordinate
+   * @since 7
+   */
+  z: number;
+}
+
+export interface MagneticResponse {
+  /**
+   * X-coordinate
+   * @since 7
+   */
+  x: number;
+
+  /**
+   * Y-coordinate
+   * @since 7
+   */
+  y: number;
+
+  /**
+   * Z-coordinate
+   * @since 7
+   */
+  z: number;
+}
+
+export interface HallResponse {
+  /**
+   * Indicates the hall sensor data.
+   * @since 7
+   */
+  value: number;
+}
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
+export default class Sensor {
+  /**
+   * Listens to acceleration sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeAccelerometer(options: {
+    /**
+     * Execution frequency of the callback function for listening to acceleration sensor data.
+     * The default value is normal.
+     * @since 3
+     */
+    interval: string;
+
+    /**
+     * Called when acceleration sensor data changes.
+     * @since 3
+     */
+    success: (data: AccelerometerResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to acceleration sensor data.
+   */
+  static unsubscribeAccelerometer(): void;
+
+  /**
+   * Listens to compass sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options Options.
+   */
+  static subscribeCompass(options: {
+    /**
+     * Called when compass sensor data changes.
+     * @since 3
+     */
+    success: (data: CompassResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to compass sensor data.
+   */
+  static unsubscribeCompass(): void;
+
+  /**
+   * Listens to distance sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeProximity(options: {
+    /**
+     * Called when distance sensor data changes.
+     * @since 3
+     */
+    success: (ret: { distance: number}) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to distance sensor data.
+   * @param options
+   */
+  static unsubscribeProximity(): void;
+
+  /**
+   * Listens to ambient light sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeLight(options: {
+    /**
+     * Called when ambient light sensor data changes.
+     * @since 3
+     */
+    success: (data: LightResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to ambient light sensor data.
+   */
+  static unsubscribeLight(): void;
+
+  /**
+   * Listens to step counter sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeStepCounter(options: {
+    /**
+     * Called when step counter sensor data changes.
+     * @since 3
+     */
+    success: (data: StepCounterResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to step counter sensor data.
+   */
+  static unsubscribeStepCounter(): void;
+
+  /**
+   * Listens to barometer sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeBarometer(options: {
+    /**
+     * Called when the barometer sensor data changes.
+     * @since 3
+     */
+    success: (data: BarometerResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 3
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to barometer sensor data.
+   */
+  static unsubscribeBarometer(): void;
+
+  /**
+   * Listens to device orientation sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeDeviceOrientation(options: {
+    /**
+     * Execution frequency of the callback function for listening to device orientation sensor data.
+     * The default value is normal.
+     * @since 6
+     */
+    interval: string;
+
+    /**
+     * Called when device orientation sensor data changes.
+     * @since 6
+     */
+    success: (data: DeviceOrientationResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 6
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to device orientation sensor data.
+   */
+  static unsubscribeDeviceOrientation(): void;
+
+  /**
+   * Listens to gyroscope sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeGyroscope(options: {
+    /**
+     * Execution frequency of the callback function for listening to gyroscope sensor data.
+     * The default value is normal.
+     * @since 6
+     */
+    interval: string;
+
+    /**
+     * Called when gyroscope sensor data changes.
+     * @since 6
+     */
+    success: (data: GyroscopeResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 6
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to gyroscope sensor data.
+   */
+  static unsubscribeGyroscope(): void;
+
+  /**
+   * Listens to gravity sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeGravity(options: {
+    /**
+     * Execution frequency of the callback function for listening to gravity sensor data.
+     * The default value is normal.
+     * @since 7
+     */
+    interval: string;
+
+    /**
+     * Called when gravity sensor data changes.
+     * @since 7
+     */
+    success: (data: GravityResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 7
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to gravity sensor data.
+   */
+  static unsubscribeGravity(): void;
+
+  /**
+   * Listens to magnetic sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeMagnetic(options: {
+    /**
+     * Execution frequency of the callback function for listening to magnetic sensor data.
+     * The default value is normal.
+     * @since 7
+     */
+    interval: string;
+
+    /**
+     * Called when magnetic sensor data changes.
+     * @since 7
+     */
+    success: (data: MagneticResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 7
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to magnetic sensor data.
+   */
+  static unsubscribeMagnetic(): void;
+
+  /**
+   * Listens to hall sensor data changes.
+   * If this API is called multiple times, the last call takes effect.
+   * @param options
+   */
+  static subscribeHall(options: {
+    /**
+     * Execution frequency of the callback function for listening to hall sensor data.
+     * The default value is normal.
+     * @since 7
+     */
+    interval: string;
+
+    /**
+     * Called when hall sensor data changes.
+     * @since 7
+     */
+    success: (data: HallResponse) => void;
+
+    /**
+     * Called when the listening fails.
+     * @since 7
+     */
+    fail?: (data: any, code: number) => void;
+  }): void;
+
+  /**
+   * Cancels listening to hall sensor data.
+   */
+  static unsubscribeHall(): void;
+}
diff --git a/api/@system.storage.d.ts b/api/phone/@system.storage.d.ts
old mode 100755
new mode 100644
similarity index 37%
rename from api/@system.storage.d.ts
rename to api/phone/@system.storage.d.ts
index 7ea651f9cbbae5b86db0532b3d7278de59790f26..abb07c05e327c96f4ca7923de6f918b3c519a980
--- a/api/@system.storage.d.ts
+++ b/api/phone/@system.storage.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,33 +14,147 @@
  */
 
 export interface GetStorageOptions {
+  /**
+   * Content index.
+   * For liteWearable and smartVision, the value contains a maximum of 32 characters and cannot contain special characters such as \/"*+,:;<=>?[]|\x7F.
+   * @since 3
+   */
   key: string;
+
+  /**
+   * Default value returned when the key does not exist.
+   * If this parameter is not specified, an empty string is returned.
+   * @since 3
+   */
   default?: string;
+
+  /**
+   * Called when the stored content is read successfully.
+   * @since 3
+   */
   success?: (data: any) => void;
+
+  /**
+   * Called when the stored content fails to be read.
+   * @since 3
+   */
   fail?: (data: string, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
 export interface SetStorageOptions {
+  /**
+   * Index of the stored content to be modified.
+   * For liteWearable and smartVision, the value contains a maximum of 32 characters and cannot contain special characters such as \/"*+,:;<=>?[]|\x7F.
+   * @since 3
+   */
   key: string;
+
+  /**
+   * Target storage content. If the content is an empty string, the data item with the key as the index will be deleted.
+   * @since 3
+   */
   value: string;
+
+  /**
+   * Called when the stored content is modified successfully.
+   * @since 3
+   */
   success?: () => void;
+
+  /**
+   * Called when the stored content fails to be modified.
+   * @since 3
+   */
   fail?: (data: string, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
+/**
+ * @devices tv, phone, tablet, wearable, liteWearable, smartVision
+ */
 export interface ClearStorageOptions {
+  /**
+   * Called when the stored content is cleared successfully.
+   * @since 3
+   */
   success?: () => void;
+
+  /**
+   * Called when the stored content fails to be cleared.
+   * @since 3
+   */
   fail?: (data: string, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
 export interface DeleteStorageOptions {
+  /**
+   * Content index.
+   * For liteWearable and smartVision, the value contains a maximum of 32 characters and cannot contain special characters such as \/"*+,:;<=>?[]|\x7F.
+   * @since 3
+   */
   key: string;
+
+  /**
+   * Called when the stored content is deleted successfully.
+   * @since 3
+   */
   success?: () => void;
+
+  /**
+   * Called when the stored content fails to be deleted.
+   * @since 3
+   */
   fail?: (data: string, code: number) => void;
+
+  /**
+   * Called when the execution is completed.
+   * @since 3
+   */
   complete?: () => void;
 }
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Storage {
+  /**
+   * Reads the stored content.
+   * @param options Options.
+   */
   static get(options: GetStorageOptions): void;
+
+  /**
+   * Modifies the stored content.
+   * @param options Options.
+   */
   static set(options: SetStorageOptions): void;
+
+  /**
+   * Clears the stored content.
+   * @param options Options.
+   */
   static clear(options?: ClearStorageOptions): void;
+
+  /**
+   * Deletes the stored content.
+   * @param options Options.
+   */
   static delete(options: DeleteStorageOptions): void;
 }
diff --git a/api/@system.vibrator.d.ts b/api/phone/@system.vibrator.d.ts
old mode 100755
new mode 100644
similarity index 69%
rename from api/@system.vibrator.d.ts
rename to api/phone/@system.vibrator.d.ts
index 94573bf4e3a679eb281238ded9638400d9e4862b..af7fd34f764f3767827282bfad5387ba93372a8f
--- a/api/@system.vibrator.d.ts
+++ b/api/phone/@system.vibrator.d.ts
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Copyright (c) 2020 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -14,11 +14,21 @@
  */
 
 export interface VibrateOptions {
+  /**
+   * Vibration mode. The value long indicates long vibration, and short indicates short vibration.
+   * The default value is long.
+   * @since 3
+   */
   mode?: "long" | "short";
-  success: () => void;
-  fail?: (data: string, code: number) => void;
-  complete?: () => void;
 }
+
+/**
+ * @Syscap SysCap.ACE.UIEngine
+ */
 export default class Vibrator {
+  /**
+   * Triggers vibration.
+   * @param options Options.
+   */
   static vibrate(options?: VibrateOptions): void;
-}
+}
\ No newline at end of file
diff --git a/api/phone/app/abilityinfo.d.ts b/api/phone/app/abilityinfo.d.ts
deleted file mode 100755
index 5a6cde1249b8bd5199a8e743e112691c902ebe17..0000000000000000000000000000000000000000
--- a/api/phone/app/abilityinfo.d.ts
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { ApplicationInfo } from "./applicationinfo"
-
-/**
- * @name AbilityInfo
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export interface AbilityInfo {
-    /**
-     * The ability name, only the main class name.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    name: string;
-
-    /**
-     * The label of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    label: string;
-
-    /**
-     * The description of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    description: string;
-
-    /**
-     * The path of the icon of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    iconPath: string;
-
-    /**
-     * Whether the ability can be invoked by other applications.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    visible: boolean;
-
-    /**
-     * The ability category: page, service, data.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    kind: string;
-
-    /**
-     * The type of this ability, 0 means UNKNOWN, 1 means PAGE, 2 means SERVICE, 3 means DATA.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    type: number;
-
-    /**
-     * The display orientation of this ability: 0 means UNSPECIFIED, 1 means LANDSCAPE, 2 means PORTRAIT, 3 means FOLLOWRECENT.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    orientation: number;
-
-    /**
-     * The launch mode of this ability: 0 means SINGLETON, 1 means SINGLETOP, 2 means STANDARD.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    launchMode: number;
-
-    /**
-     * Represents Ability of another application The permission that needs to be applied when this Ability is invoked.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    permissions: Array<string>;
-
-    /**
-     * The process name of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    process: string;
-
-    /**
-     * The supported device types of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    deviceTypes: Array<string>;
-
-    /**
-     * The ability of the device to limit.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    deviceCapabilities: Array<string>;
-
-    /**
-     * Uniform resource identifier representing Ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    uri: string;
-
-    /**
-     * The application information of this ability.
-     * @devices phone
-     */
-    applicationInfo: ApplicationInfo;
-
-    /**
-     * The "module.package" in config.json.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    package: string;
-
-    /**
-     * The bundle name of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    bundleName: string;
-
-    /**
-     * The "module.name" in config.json of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    moduleName: string;
-
-    /**
-     * The "bundleName" in config.json of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    applicationName: string;
-
-    /**
-     * The device id.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    deviceId: string;
-
-    /**
-     * The main code path of this ability.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    codePath: string;
-
-    /**
-     * The resource path of this ability
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    resourcePath: string;
-
-    /**
-     * The library path of this ability
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    libPath: string;
-}
\ No newline at end of file
diff --git a/api/phone/app/abilitymissioninfo.d.ts b/api/phone/app/abilitymissioninfo.d.ts
deleted file mode 100755
index db792d7fc1b4666717802df3a2fb8fb67b2015d0..0000000000000000000000000000000000000000
--- a/api/phone/app/abilitymissioninfo.d.ts
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { ElementName }  from "./elementname"
-import { Want }         from "./want"
-
-/**
- * @name Task stack information corresponding to ability
- * @since 6
- * @SysCap appexecfwk
- * @import import AbilityMissionInfo from '@ohos.AbilityMissionInfo'
- * @permission N/A
- * @devices phone
- * @testapi
- */
-export interface AbilityMissionInfo {
-    /**
-     * Unique identification of task stack information corresponding to ability
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    id: number;
-
-    /**
-     * If this job is currently running, this is the identifier for it
-     * If it is not running, this will be -1
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    runingState: number;
-
-    /**
-     * The original Intent used to launch the task stack
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    baseWant: Want;
-
-    /**
-     * The component launched as the first ability in the task stack
-     * This can be considered the "application" of this task stack
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    baseAbility: ElementName;
-
-    /**
-     * The ability component at the top of the history stack of the task
-     * This is what the user is currently doing
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    topAbility: ElementName;
-
-    /**
-     * Size of abilities in this task
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    size: number;
-
-    /**
-     * The corresponding ability description information in the task stack
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    missionDescription: MissionDescriptionInfo;
-}
-
-/**
- * @name Task stack description information
- * @since 6
- * @SysCap appexecfwk
- * @import import app from '@system.app'
- * @permission N/A
- * @devices phone, tablet
- */
-
-export interface MissionDescriptionInfo {
-    /**
-     * The label of the specified ability in the task stack
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    label: string;
-
-    /**
-     * The path to the icon that specifies the ability in the task stack
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap appexecfwk
-     */
-    iconPath: string;
-}
\ No newline at end of file
diff --git a/api/phone/app/applicationinfo.d.ts b/api/phone/app/applicationinfo.d.ts
deleted file mode 100755
index 77a91c38dc4f6d82655ec4f8a51b1b6bb2c1595e..0000000000000000000000000000000000000000
--- a/api/phone/app/applicationinfo.d.ts
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { ModuleInfo } from "./moduleinfo"
-
-/**
- * @name ApplicationInfo
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export interface ApplicationInfo {
-    /**
-     * The application name.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    name: string;
-
-    /**
-     * The bundleName is same to the application name.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    bundleName: string;
-
-    /**
-     * The description of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    description: string;
-
-    /**
-     * The icon path of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    iconPath: string;
-
-    /**
-     * The label of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    label: string;
-
-    /**
-     * The label resource ID of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    labelId : number;
-
-    /**
-     * The icon resource ID of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    iconId : number;
-
-    /**
-     * The description resource ID of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    descriptionId : number;
-
-    /**
-     * The device id of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    deviceId: string;
-
-    /**
-     * The public key info of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    signatureKey: string;
-
-    /**
-     * Whether this application is a system application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    isSystemApp: boolean;
-
-    /**
-     * Whether this application is a launcher application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    isLauncherApp: boolean;
-
-    /**
-     * Whether the application support the driving mode, 0 means not support.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    supportedModes: number;
-
-    /**
-     * The process of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    process: string;
-
-    /**
-     * The permissions of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    permissions: Array<string>;
-
-    /**
-     * The module source directories of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    moduleSourceDirs: Array<string>;
-
-    /**
-     * The module information of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    moduleInfos: Array<ModuleInfo>;
-
-    /**
-     * The entry module path of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    entryDir: string;
-
-    /**
-     * The code path of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    codePath: string;
-
-    /**
-     * The data directory of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    dataDir: string;
-
-    /**
-    * The data base directory of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    dataBaseDir: string;
-
-    /**
-     * The cache directory of this application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    cacheDir: string;
-}
\ No newline at end of file
diff --git a/api/phone/app/bundleinfo.d.ts b/api/phone/app/bundleinfo.d.ts
deleted file mode 100755
index c8d8b4c42bc1cf5b18091140d9860e85d581244f..0000000000000000000000000000000000000000
--- a/api/phone/app/bundleinfo.d.ts
+++ /dev/null
@@ -1,266 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { AbilityInfo } from "./abilityinfo"
-
-/**
- * @name BundleInfo
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export interface BundleInfo {
-    /**
-     * The bundle name.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    name: string;
-
-    /**
-     * The label of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    label: string;
-
-    /**
-     * The description of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    description: string;
-
-    /**
-     * The vendor of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    vendor: string;
-
-    /**
-     * The version code of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-    versionCode: number;
-
-    /**
-     * The version name of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     versionName: string;
-
-    /**
-     * The jointUserId of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     jointUserId: string;
-
-    /**
-     * The min SDK version of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     minSdkVersion: number;
-
-    /**
-     * The max SDK version of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     maxSdkVersion: number;
-
-    /**
-     * The main entry path of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     mainEntry: string;
-
-    /**
-     * The cpuAbi of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     cpuAbi:string;
-
-    /**
-     * The appId of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     appId:string;
-
-    /**
-     * The compatible version of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     compatibleVersion: number;
-
-    /**
-     * The target version of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     targetVersion: number;
-
-    /**
-     * The release type of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     releaseType: string;
-
-    /**
-     * The uid of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     uid: number;
-
-    /**
-     * The gid of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     gid: number;
-
-    /**
-    * The seInfo of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     seInfo: string;
-
-    /**
-     * The entry module name of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     entryModuleName: string;
-
-    /**
-     * Whether the bundle is keep alive.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     isKeepAlive: boolean;
-
-    /**
-     * Whether the bundle is a native application.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     isNativeApp: boolean;
-
-    /**
-     * The install time of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     installTime: number;
-
-    /**
-     * The update time of this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     updateTime: number;
-
-    /**
-     * The information of the abilities in this bundle.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     abilityInfos: Array<AbilityInfo>;
-}
\ No newline at end of file
diff --git a/api/phone/app/installresult.d.ts b/api/phone/app/installresult.d.ts
deleted file mode 100755
index 625cb1c8153ef2b99eb92d688d0143d469c3edd0..0000000000000000000000000000000000000000
--- a/api/phone/app/installresult.d.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @name InstallResult
- * @since 6
- * @SysCap appexecfwk
- * @import NA
- * @permission NA
- * @devices phone
- * @testapi
- */
-export interface InstallResult {
-    /**
-     * The install result string message.
-     *
-     * @default -
-     * @devices phone, tablet
-     * @since 6
-     * @SysCap BMS
-     */
-     installResultMsg: string;
-}
diff --git a/api/phone/data/distributeddata/kvmanager_config.d.ts b/api/phone/data/distributeddata/kvmanager_config.d.ts
deleted file mode 100644
index 643aa1c2aa75bc79ee2a3a615efae974c9cdc24c..0000000000000000000000000000000000000000
--- a/api/phone/data/distributeddata/kvmanager_config.d.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Provides configuration information for {@link KVManager} instances,
- * including the caller's package name and distributed network type.
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- */
-export interface KVManagerConfig {
-    /**
-     * Indicates the user information
-     */
-    userInfo: UserInfo;
-
-    /**
-     * Indicates the bundleName
-     */
-    bundleName: string;
-}
-
-/**
- * Manages user information.
- *
- * <p>This class provides methods for obtaining the user ID and type, setting the user ID and type,
- * and checking whether two users are the same.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export interface UserInfo {
-    /** Indicates the user ID to set */
-    userId?: string;
-
-    /** Indicates the user type to set */
-    userType?: UserType;
-}
-
-/**
- * Enumerates user types.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export enum UserType {
-    /** Indicates a user that logs in to different devices using the same account. */
-    SAME_USER_ID = 0
-}
\ No newline at end of file
diff --git a/api/phone/data/distributeddata/kvstore.d.ts b/api/phone/data/distributeddata/kvstore.d.ts
deleted file mode 100644
index 6f6da977f73e03820ceaa6886ffc68a7e8c81532..0000000000000000000000000000000000000000
--- a/api/phone/data/distributeddata/kvstore.d.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AsyncCallback, Callback } from '../../basic';
-import { ChangeNotification, SubscribeType } from "./plain_ordinary_js_objects";
-
-/**
- * Represents a key-value distributed database and provides methods for adding, deleting, modifying, querying,
- * and subscribing to distributed data.
- *
- * <p>You can create distributed databases of different types by {@link KVManager#getKVStore (Options, String)}
- * with input parameter {@code Options}. Distributed database types are defined in {@code KVStoreType},
- * including {@code SingleKVStore}.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- * @version 1
- */
-export interface KVStore {
-    /**
-     * Writes a key-value pair of the byte array type into the {@code KVStore} database.
-     *
-     * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
-     * Spaces before and after the key will be cleared.
-     * @param value Indicates the byte array, which must be less than 4 MB.
-     * @return Returns the error code of databases.
-     * @since 7
-     */
-    put(key: string, value: Uint8Array | string | number | boolean, callback: AsyncCallback<void>): void;
-    put(key: string, value: Uint8Array | string | number | boolean): Promise<void>;
-
-    /**
-     * Deletes the key-value pair based on a specified key.
-     *
-     * @param key Indicates the key. The length must be less than {@code MAX_KEY_LENGTH}.
-     * Spaces before and after the key will be cleared.
-     * @return Returns the error code of databases.
-     * @since 7
-     */
-    delete(key: string, callback: AsyncCallback<void>): void;
-    delete(key: string): Promise<void>;
-
-    /**
-     * turn on from the data change notify based on the specified {@code subscribeType}.
-     *
-     * @param type Indicates the subscription type, which is defined in {@code SubscribeType}.
-     * @param observer Indicates the observer of data change events in the distributed database.
-     * @return Returns the error code of databases.
-     * @since 7
-     */
-    on(event: 'dataChange', type: SubscribeType, observer: Callback<ChangeNotification>): void;
-
-    /**
-     * Subscribe to the notification of store synchronization completion.
-     *
-     * <p>Sync result is returned through asynchronous callback.
-     *
-     * @param syncCallback Indicates the callback used to send the synchronization result to the caller.
-     * @return Returns the {@code number} object.
-     * @since 7
-     */
-    on(event: 'syncComplete', syncCallback: Callback<Array<[string, number]>>): void;
-}
-
-/**
- * KVStore constants
- */
-export module Constants {
-    /**
-    * max key length.
-    */
-    const MAX_KEY_LENGTH = 1024;
-
-    /**
-     * max value length.
-     */
-    const MAX_VALUE_LENGTH = 4194303;
-
-    /**
-     * max device coordinate key length.
-     */
-    const MAX_KEY_LENGTH_DEVICE = 896;
-
-    /**
-     * max store id length.
-     */
-    const MAX_STORE_ID_LENGTH = 128;
-
-    /**
-     * max query length.
-     */
-    const MAX_QUERY_LENGTH = 512000;
-
-    /**
-     * max batch operation size.
-     */
-    const MAX_BATCH_SIZE = 128;
-}
\ No newline at end of file
diff --git a/api/phone/data/distributeddata/plain_ordinary_js_objects.d.ts b/api/phone/data/distributeddata/plain_ordinary_js_objects.d.ts
deleted file mode 100644
index efcfd56078874d8e8f54f3ac0abb3360f21d3303..0000000000000000000000000000000000000000
--- a/api/phone/data/distributeddata/plain_ordinary_js_objects.d.ts
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Obtains {@code Value} objects stored in a {@link KVStore} database.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- */
-export interface Value {
-    /**
-     * Indicates value type
-     *
-     * @see ValueType
-     * @type {number}
-     * @memberof Value
-     */
-    type: ValueType;
-    value: Uint8Array | string | number | boolean;
-}
-
-/**
- * Provides key-value pairs stored in the distributed database.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- */
-export interface Entry {
-    key: string;
-    value: Value;
-}
-
-/**
- * Receives notifications of all data changes, including data insertion, update, and deletion.
- *
- * <p>If you have subscribed to {@code KVStore}, you will receive data change notifications and obtain the changed data
- * from the parameters in callback methods upon data insertion, update, or deletion.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- */
-export interface ChangeNotification {
-    /** Indicates data addition records. */
-    insertEntries: Entry[];
-    /** Indicates data update records. */
-    updateEntries: Entry[];
-    /** Indicates data deletion records. */
-    deleteEntries: Entry[];
-    /** Indicates from device id. */
-    deviceId: string;
-}
-
-/**
- * Describes the subscription type.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @devices phone, tablet
- * @since 7
- */
-export enum SubscribeType {
-    /** Subscription to local data changes */
-    SUBSCRIBE_TYPE_LOCAL = 0,
-
-    /** Subscription to remote data changes */
-    SUBSCRIBE_TYPE_REMOTE = 1,
-
-    /** Subscription to both local and remote data changes */
-    SUBSCRIBE_TYPE_ALL = 2,
-}
-
-/**
- * Describes the {@code KVStore} type.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export enum KVStoreType {
-    /** Device-collaborated database, as specified by {@code DeviceKVStore} */
-    DEVICE_COLLABORATION = 0,
-
-    /** Single-version database, as specified by {@code SingleKVStore} */
-    SINGLE_VERSION = 1,
-
-    /** Multi-version database, as specified by {@code MultiKVStore} */
-    MULTI_VERSION = 2,
-}
-
-/**
- * Describes the {@code KVStore} type.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export enum SecurityLevel {
-    /**
-     * NO_LEVEL: mains not set the security level.
-     *
-     * @since 7
-     */
-    NO_LEVEL = 0,
-
-    /**
-     * S0: mains the db is public.
-     * There is no impact even if the data is leaked.
-     *
-     * @since 7
-     */
-    S0 = 1,
-
-    /**
-     * S1: mains the db is low level security
-     * There are some low impact, when the data is leaked.
-     *
-     * @since 7
-     */
-    S1 = 2,
-
-    /**
-     * S2: mains the db is middle level security
-     * There are some major impact, when the data is leaked.
-     *
-     * @since 7
-     */
-    S2 = 3,
-
-    /**
-     * S3: mains the db is high level security
-     * There are some severity impact, when the data is leaked.
-     *
-     * @since 7
-     */
-    S3 = 5,
-
-    /**
-     * S4: mains the db is critical level security
-     * There are some critical impact, when the data is leaked.
-     *
-     * @since 7
-     */
-    S4 = 6,
-}
-
-/**
- * Provides configuration options for creating a {@code KVStore}.
- *
- * <p>You can determine whether to create another database if a {@code KVStore} database is missing,
- * whether to encrypt the database, and the database type.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export interface Options {
-    createIfMissing?: boolean;
-    encrypt?: boolean;
-    backup?: boolean;
-    autoSync?: boolean;
-    kvStoreType?: KVStoreType;
-    securityLevel?: SecurityLevel;
-}
-
-/**
- * Indicates the database synchronization mode.
- *
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- */
-export enum SyncMode {
-    /** Indicates that data is only pulled from the remote end. */
-    PULL_ONLY = 0,
-    /** Indicates that data is only pushed from the local end. */
-    PUSH_ONLY = 1,
-    /** Indicates that data is pushed from the local end, and then pulled from the remote end. */
-    PUSH_PULL = 2
-}
-
-/**
- * Indicates the {@code ValueType}.
- *
- * <p>{@code ValueType} is obtained based on the value.
- *
- * @since 7
- */
-export enum ValueType {
-    /** Indicates that the value type is string. */
-    STRING = 0,
-
-    /** Indicates that the value type is int. */
-    INTEGER = 1,
-
-    /** Indicates that the value type is float. */
-    FLOAT = 2,
-
-    /** Indicates that the value type is byte array. */
-    BYTE_ARRAY = 3,
-
-    /** Indicates that the value type is boolean. */
-    BOOLEAN = 4,
-
-    /** Indicates that the value type is double. */
-    DOUBLE = 5
-}
diff --git a/api/phone/data/distributeddata/single_kvstore.d.ts b/api/phone/data/distributeddata/single_kvstore.d.ts
deleted file mode 100644
index a631e52d24c9ebbb7babb70463670a648167ac88..0000000000000000000000000000000000000000
--- a/api/phone/data/distributeddata/single_kvstore.d.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { AsyncCallback } from '../../basic';
-import { KVStore } from "./kvstore";
-import { SyncMode } from "./plain_ordinary_js_objects";
-
-/**
- * Provides methods related to single-version distributed databases.
- *
- * <p>To create a {@code SingleKVStore} database,
- * you can use the {@link data.distributed.common.KVManager#getKVStore​(Options, String)} method
- * with {@code KVStoreType} set to {@code SINGLE_VERSION} for the input parameter {@code Options}.
- * This database synchronizes data to other databases in time sequence.
- * The {@code SingleKVStore} database does not support
- * synchronous transactions, or data search using snapshots.
- *
- * @devices phone, tablet
- * @Syscap SystemCapability.Data.DATA_DISTRIBUTEDDATAMGR
- * @since 7
- * @version 1
- */
-export interface SingleKVStore extends KVStore {
-    /**
-     * Obtains the value of a specified key.
-     *
-     * @param key Indicates the key of the value to be queried.
-     * @return Returns the value matching the given criteria.
-     * @throws Throws exception if any of the following errors occurs: {@code INVALID_ARGUMENT},
-     * {@code SERVER_UNAVAILABLE}, {@code IPC_ERROR}, {@code DB_ERROR}, and {@code KEY_NOT_FOUND}.
-     * @since 7
-     */
-    get(key: string, callback: AsyncCallback<Uint8Array | string | boolean | number>): void;
-    get(key: string): Promise<Uint8Array | string | boolean | number>;
-
-    /**
-     * Synchronizing KVStore Data Between Devices.
-     *
-     * @param deviceIdList Indicates the {@code string}.
-     * @param mode Indicates the {@code SyncMode} object.
-     * @param allowedDelayMs Indicates the number type parameter.
-     * @return Returns the {@code number} object.
-     * @since 7
-     */
-    sync(deviceIdList: string[], mode: SyncMode, allowedDelayMs?: number): void;
-}
-
-
diff --git a/api/phone/app/common.d.ts b/api/wantAgent/wantAgentInfo.d.ts
old mode 100755
new mode 100644
similarity index 57%
rename from api/phone/app/common.d.ts
rename to api/wantAgent/wantAgentInfo.d.ts
index 4c1137574f5a3e81849364220a097239fbf9f78f..4cc5aa29483145bc61d04637b86cfe002ef3ce34
--- a/api/phone/app/common.d.ts
+++ b/api/wantAgent/wantAgentInfo.d.ts
@@ -4,7 +4,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -13,15 +13,22 @@
  * limitations under the License.
  */
 
+import { Want } from '../ability/want';
+import wantAgent from '../@ohos.wantAgent'
+
 /**
- * @name The ability callback.
- * @since 6
- * @SysCap aafwk
+ * the info of WantAgent
+ *
+ * @name WantAgentInfo
+ * @since 7
+ * @sysCap ans
+ * @devices phone, tablet
  * @permission N/A
- * @devices phone
- * @testapi
  */
-export interface AsyncCallback<T> {
-    (data: T): void;
-    (err: number): void;
+export interface WantAgentInfo {
+  wants: Array<Want>;
+  operationType: wantAgent.OperationType;
+  requestCode: number;
+  wantAgentFlags?: Array<wantAgent.WantAgentFlags>;
+  extraInfo?: {[key: string]: any};
 }
\ No newline at end of file
diff --git a/remove_internal.py b/remove_internal.py
new file mode 100755
index 0000000000000000000000000000000000000000..0134a5cc1afff01b2023a574730bd5b86dfa7347
--- /dev/null
+++ b/remove_internal.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
+
+import os
+import sys
+import optparse
+import shutil
+
+# d.ts directories to be deleted
+remove_list = ["@internal", "common", "config", "form", "liteWearable",
+    "phone", "router", "smartVision", "tablet", "tv", "wearable"]
+
+
+# traversal all fill in project folder
+def copy_files(input_path, output_path):
+    for file in os.listdir(input_path):
+        src = os.path.join(input_path, file)
+        dst = os.path.join(output_path, file)
+        if os.path.isdir(src) and (not file in remove_list):
+            shutil.copytree(src, dst, dirs_exist_ok=True)
+        elif os.path.isfile(src) and (not file.startswith('@system')):
+            shutil.copy(src, dst)
+
+
+def parse_args(args):
+    parser = optparse.OptionParser()
+    parser.add_option('--input', help='d.ts document input path')
+    parser.add_option('--output', help='d.ts document output path')
+    options, _ = parser.parse_args(args)
+    return options
+
+
+def main(argv):
+    options = parse_args(argv)
+    if not os.path.exists(options.output):
+        os.makedirs(options.output)
+    copy_files(options.input, options.output)
+
+
+if __name__ == "__main__":
+    exit(main(sys.argv))
\ No newline at end of file
diff --git a/remove_internal.pydeps b/remove_internal.pydeps
new file mode 100755
index 0000000000000000000000000000000000000000..f2f25eed752fbefcb1af8f77d907df887cf68495
--- /dev/null
+++ b/remove_internal.pydeps
@@ -0,0 +1,3 @@
+# Generated by running:
+#   build/print_python_deps.py --root interface/sdk-js --output interface/sdk-js/remove_internal.pydeps interface/sdk-js/remove_internal.py
+remove_internal.py