diff --git a/frameworks/ets/ets/@ohos.app.ability.InsightIntentContext.ets b/frameworks/ets/ets/@ohos.app.ability.InsightIntentContext.ets
index 40a7569f487971f41cb11b18a6d4fcf56d24602d..98630dcade4ae92534753b02cba2777aa828e457 100644
--- a/frameworks/ets/ets/@ohos.app.ability.InsightIntentContext.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.InsightIntentContext.ets
@@ -21,7 +21,7 @@ export default class InsightIntentContext {
 
   public native nativeStartAbilitySync(want: Want): BusinessError;
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void {
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): BusinessError => {
       return this.nativeStartAbilitySync(want);
     });
@@ -33,7 +33,7 @@ export default class InsightIntentContext {
     });
   }
 
-  startAbility(want: Want): Promise<void> {
+  startAbilityWithWantReturnsPromise(want: Want): Promise<void> {
     let p = new Promise<void>((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => {
       let p1 = taskpool.execute((): BusinessError => {
         return this.nativeStartAbilitySync(want);
@@ -51,4 +51,9 @@ export default class InsightIntentContext {
     });
     return p;
   }
+
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantReturnsPromise
+  }
 }
\ No newline at end of file
diff --git a/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets b/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
index 266dbed17a1cbe272dda6f47f28733f3be3d2845..1c5040a95f475e8cf2415a2c8f0bd72aa5140290 100644
--- a/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
@@ -72,14 +72,14 @@ export default class UIExtensionContentSession {
     this.nativeSetReceiveDataForResultCallback(callback);
   }
 
-  terminateSelf(callback:AsyncCallback<void>): void {
+  terminateSelfWithCallback(callback:AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.terminateSelfSync(myCall);
     });
   }
 
-  terminateSelf(): Promise<void> {
+  terminateSelfReturnsPromise(): Promise<void> {
     let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -95,14 +95,19 @@ export default class UIExtensionContentSession {
     return p;
   }
 
-  terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
+  overload terminateSelf {
+    terminateSelfWithCallback,
+    terminateSelfReturnsPromise
+  }
+
+  terminateSelfWithResultWithParameterCallback(parameter: AbilityResult, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.terminateSelfWithResultSync(parameter, myCall);
     });
   }
 
-  terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
+  terminateSelfWithResultWithParameterReturnsPromise(parameter: AbilityResult): Promise<void> {
     let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -118,7 +123,12 @@ export default class UIExtensionContentSession {
     return p;
   }
 
-  startAbilityByType(type: string, wantParam: Record<string, Object>, startCallback: AbilityStartCallback,
+  overload terminateSelfWithResult {
+    terminateSelfWithResultWithParameterCallback,
+    terminateSelfWithResultWithParameterReturnsPromise
+  }
+
+  startAbilityByTypeWithTypeWantParamStartCallbackCallback(type: string, wantParam: Record<string, Object>, startCallback: AbilityStartCallback,
     callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): BusinessError<void> => {
       return this.nativeStartAbilityByTypeSync(type, wantParam, startCallback);
@@ -135,7 +145,7 @@ export default class UIExtensionContentSession {
     });
   }
 
-  startAbilityByType(type: string, wantParam: Record<string, Object>,
+  startAbilityByTypeWithTypeWantParamStartCallbackReturnsPromise(type: string, wantParam: Record<string, Object>,
     startCallback: AbilityStartCallback): Promise<void> {
     let p = new Promise<void>((resolve: (v: undefined) => void, reject: (error: BusinessError<void>) => void): void => {
       let p1 = taskpool.execute((): BusinessError<void> => {
@@ -154,4 +164,9 @@ export default class UIExtensionContentSession {
     });
     return p;
   }
+
+  overload startAbilityByType {
+    startAbilityByTypeWithTypeWantParamStartCallbackCallback,
+    startAbilityByTypeWithTypeWantParamStartCallbackReturnsPromise
+  }
 }
diff --git a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
index 6d653337ba12c9945a1f267aa00104c516d0b6af..f812e0a8c05ed4f09ccd828c699dc443fc469666 100644
--- a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
@@ -33,7 +33,7 @@ export default namespace abilityManager {
   export native function nativeOn(type:string, observer: AbilityForegroundStateObserver): void;
   export native function nativeOff(type:string, observer?: AbilityForegroundStateObserver): void;
 
-  export function getForegroundUIAbilities():Promise<Array<AbilityStateData>> {
+  export function getForegroundUIAbilitiesReturnsPromise():Promise<Array<AbilityStateData>> {
     let p = new Promise<Array<AbilityStateData>>((resolve: (data: Array<AbilityStateData>) => void, reject: (error: Error) => void): void => {
       let executeFunc = (): Array<AbilityStateData> => {
         return nativeGetForegroundUIAbilities();
@@ -49,14 +49,19 @@ export default namespace abilityManager {
     return p;
   }
 
-  export function getForegroundUIAbilities(callback: AsyncCallback<Array<AbilityStateData>, void>): void {
+  export function getForegroundUIAbilitiesWithCallback(callback: AsyncCallback<Array<AbilityStateData>, void>): void {
       let myCall = new AsyncCallbackWrapper<Array<AbilityStateData>>(callback);
       taskpool.execute((): void => {
         abilityManager.getForegroundUIAbilitiesCallback(myCall);
       })
   }
 
-  export function getTopAbility():Promise<ElementName> {
+  overload getForegroundUIAbilities {
+    getForegroundUIAbilitiesWithCallback,
+    getForegroundUIAbilitiesReturnsPromise
+  }
+
+  export function getTopAbilityReturnsPromise():Promise<ElementName> {
     let p = new Promise<ElementName>((resolve: (data: ElementName)=>void, reject:(err: BusinessError)=>void):void => {
       let myCall = new AsyncCallbackWrapper<ElementName>((err: BusinessError | null, data: ElementName | undefined)=>{
         if (err == null || err.code == 0) {
@@ -72,14 +77,19 @@ export default namespace abilityManager {
     return p;
   }
 
-  export function getTopAbility(callback: AsyncCallback<ElementName, void>): void {
+  export function getTopAbilityWithCallback(callback: AsyncCallback<ElementName, void>): void {
       let myCall = new AsyncCallbackWrapper<ElementName>(callback);
       taskpool.execute( (): void => {
           abilityManager.nativeGetTopAbility(myCall);
       });
   }
 
-  function getAbilityRunningInfos(): Promise<Array<AbilityRunningInfo>> {
+  overload getTopAbility {
+    getTopAbilityWithCallback,
+    getTopAbilityReturnsPromise
+  }
+
+  function getAbilityRunningInfosReturnsPromise(): Promise<Array<AbilityRunningInfo>> {
     return new Promise<Array<AbilityRunningInfo>>((resolve: (data: Array<AbilityRunningInfo>) => void,
       reject: (err: BusinessError) => void): void => {
       let syncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>((err: BusinessError | null,
@@ -96,13 +106,18 @@ export default namespace abilityManager {
     });
   }
 
-  function getAbilityRunningInfos(callback: AsyncCallback<Array<AbilityRunningInfo>>): void {
+  function getAbilityRunningInfosWithCallback(callback: AsyncCallback<Array<AbilityRunningInfo>>): void {
     let syncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>(callback);
     taskpool.execute((): void => {
       abilityManager.nativeGetAbilityRunningInfos(syncCall);
     });
   }
 
+  overload getAbilityRunningInfos {
+    getAbilityRunningInfosWithCallback,
+    getAbilityRunningInfosReturnsPromise
+  }
+
   function isEmbeddedOpenAllowed(context: Context, appId: string): Promise<boolean> {
     return new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
       let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
diff --git a/frameworks/ets/ets/@ohos.app.ability.appManager.ets b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
index 836870f7f0f67317c085fb6caf0d777887962abc..2f2ad13e92aeb4418d738360a7c88a38017d3d36 100644
--- a/frameworks/ets/ets/@ohos.app.ability.appManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
@@ -100,14 +100,14 @@ export function preloadApplication(bundleName: string, userId: int, mode: Preloa
 }
 
 export native function nativeGetRunningProcessInformation(callback: AsyncCallbackWrapper<Array<ProcessInformation>>): void;
-export function getRunningProcessInformation(callback: AsyncCallback<Array<ProcessInformation>>): void {
+export function getRunningProcessInformationWithCallback(callback: AsyncCallback<Array<ProcessInformation>>): void {
    let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
     taskpool.execute((): void => {
       appManager.nativeGetRunningProcessInformation(myCall);
     });
 }
 
-export function getRunningProcessInformation(): Promise<Array<ProcessInformation>> {
+export function getRunningProcessInformationReturnsPromise(): Promise<Array<ProcessInformation>> {
     let p = new Promise<Array<ProcessInformation>>((resolve:(data:Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
       let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
         if (err == null || err.code == 0) {
@@ -123,15 +123,20 @@ export function getRunningProcessInformation(): Promise<Array<ProcessInformation
     return p;
 }
 
+  overload getRunningProcessInformation {
+    getRunningProcessInformationWithCallback,
+    getRunningProcessInformationReturnsPromise
+  }
+
 export native function nativeGetForegroundApplications(callback:AsyncCallbackWrapper<Array<AppStateData>>): void;
-export function getForegroundApplications(callback: AsyncCallback<Array<AppStateData>>): void {
+export function getForegroundApplicationsWithCallback(callback: AsyncCallback<Array<AppStateData>>): void {
     let myCall = new AsyncCallbackWrapper<Array<AppStateData>>(callback);
     taskpool.execute((): void => {
       appManager.nativeGetForegroundApplications(myCall);
     });
 }
 
-export function getForegroundApplications(): Promise<Array<AppStateData>> {
+export function getForegroundApplicationsReturnsPromise(): Promise<Array<AppStateData>> {
     let p = new Promise<Array<AppStateData>>((resolve:(data:Array<AppStateData>)=>void, reject:(err: BusinessError)=>void):void => {
       let myCall = new AsyncCallbackWrapper<Array<AppStateData>>((err: BusinessError | null, data: Array<AppStateData> | undefined)=>{
         if (err == null || err.code == 0) {
@@ -147,6 +152,11 @@ export function getForegroundApplications(): Promise<Array<AppStateData>> {
     return p;
 }
 
+  overload getForegroundApplications {
+    getForegroundApplicationsWithCallback,
+    getForegroundApplicationsReturnsPromise
+  }
+
 export native function nativeGetRunningMultiAppInfo(bundleName: string, callback: AsyncCallbackWrapper<RunningMultiAppInfo>): void;
 export function getRunningMultiAppInfo(bundleName: string): Promise<RunningMultiAppInfo> {
     let p = new Promise<RunningMultiAppInfo>((resolve:(data: RunningMultiAppInfo)=>void, reject:(err: BusinessError)=>void):void => {
@@ -165,14 +175,16 @@ export function getRunningMultiAppInfo(bundleName: string): Promise<RunningMulti
 }
 
 export native function nativeGetRunningProcessInfoByBundleName(bundleName: string, callback:AsyncCallbackWrapper<Array<ProcessInformation>>):void;
-export function getRunningProcessInfoByBundleName(bundleName: string, callback: AsyncCallback<Array<ProcessInformation>>): void  {
+export function getRunningProcessInfoByBundleNameWithBundleNameCallback(
+  bundleName: string, callback: AsyncCallback<Array<ProcessInformation>>): void  {
     let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
     taskpool.execute((): void => {
       appManager.nativeGetRunningProcessInfoByBundleName(bundleName, myCall);
     });
 }
 
-export function getRunningProcessInfoByBundleName(bundleName: string): Promise<Array<ProcessInformation>> {
+export function getRunningProcessInfoByBundleNameWithBundleNameReturnsPromise(
+  bundleName: string): Promise<Array<ProcessInformation>> {
     let p = new Promise<Array<ProcessInformation>>((resolve:(data: Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
       let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
         if (err == null || err.code == 0) {
@@ -190,14 +202,16 @@ export function getRunningProcessInfoByBundleName(bundleName: string): Promise<A
 
 export native function nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName: string,
   userId: int, callback:AsyncCallbackWrapper<Array<ProcessInformation>>):void;
-export function getRunningProcessInfoByBundleName(bundleName: string, userId: int, callback: AsyncCallback<Array<ProcessInformation>>): void {
+export function getRunningProcessInfoByBundleNameWithBundleNameUserIdCallback(
+  bundleName: string, userId: int, callback: AsyncCallback<Array<ProcessInformation>>): void {
     let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
     taskpool.execute((): void => {
       appManager.nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName, userId, myCall);
     });
 }
 
-export function getRunningProcessInfoByBundleName(bundleName: string, userId: int): Promise<Array<ProcessInformation>> {
+export function getRunningProcessInfoByBundleNameWithBundleNameUserIdReturnsPromise(
+  bundleName: string, userId: int): Promise<Array<ProcessInformation>> {
     let p = new Promise<Array<ProcessInformation>>((resolve:(data: Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
       let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
         if (err == null || err.code == 0) {
@@ -213,26 +227,34 @@ export function getRunningProcessInfoByBundleName(bundleName: string, userId: in
     return p;
 }
 
+  overload getRunningProcessInfoByBundleName {
+    getRunningProcessInfoByBundleNameWithBundleNameCallback,
+    getRunningProcessInfoByBundleNameWithBundleNameReturnsPromise,
+    getRunningProcessInfoByBundleNameWithBundleNameUserIdCallback,
+    getRunningProcessInfoByBundleNameWithBundleNameUserIdReturnsPromise
+  }
+
 export native function nativeOn(type: string, observer: ApplicationStateObserver, bundleNameList?: Array<string>) : int;
 export native function nativeOn(type: string, observer: ApplicationStateObserver) : int;
 
-export function on(type: 'applicationState', observer: ApplicationStateObserver): int {
+export function onApplicationStateWithObserver(type: 'applicationState', observer: ApplicationStateObserver): int {
   return appManager.nativeOn('applicationState', observer);
 }
 
-export function on(type: 'applicationState', observer: ApplicationStateObserver, bundleNameList: Array<string>): int {
+export function onApplicationStateWithObserverBundleNameList(type: 'applicationState',
+  observer: ApplicationStateObserver, bundleNameList: Array<string>): int {
   return appManager.nativeOn('applicationState', observer, bundleNameList);
 }
 
 export native function nativeOff(type:string, observerId: int, callback: AsyncCallbackWrapper<void>) : void;
-export function off(type: 'applicationState', observerId: int, callback: AsyncCallback<void>): void {
+export function offApplicationState(type: 'applicationState', observerId: int, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       appManager.nativeOff(type, observerId, myCall);
     });
 }
 
-export function off(type: 'applicationState', observerId: int): Promise<void> {
+export function offApplicationStateReturnsPromise(type: 'applicationState', observerId: int): Promise<void> {
     let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
         if (err == null || err.code == 0) {
@@ -249,14 +271,14 @@ export function off(type: 'applicationState', observerId: int): Promise<void> {
 }
 
 export native function nativeGetAppMemorySize(callback: AsyncCallbackWrapper<int>) : void;
-export function getAppMemorySize(callback: AsyncCallback<int>): void
+export function getAppMemorySizeWithCallback(callback: AsyncCallback<int>): void
 {
     let myCall = new AsyncCallbackWrapper<int>(callback);
     taskpool.execute((): void => {
       appManager.nativeGetAppMemorySize(myCall);
     });
 }
-export function getAppMemorySize(): Promise<int> {
+export function getAppMemorySizeReturnsPromise(): Promise<int> {
     let p = new Promise<int>((resolve:(data:int)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined)=>{
         if (err == null || err.code == 0) {
@@ -272,14 +294,19 @@ export function getAppMemorySize(): Promise<int> {
     return p;
 }
 
+  overload getAppMemorySize {
+    getAppMemorySizeWithCallback,
+    getAppMemorySizeReturnsPromise
+  }
+
 export native function nativeIsRamConstrainedDevice(callback: AsyncCallbackWrapper<boolean>) : void;
-export function isRamConstrainedDevice(callback: AsyncCallback<boolean>): void {
+export function isRamConstrainedDeviceWithCallback(callback: AsyncCallback<boolean>): void {
     let myCall = new AsyncCallbackWrapper<boolean>(callback);
     taskpool.execute((): void => {
       appManager.nativeIsRamConstrainedDevice(myCall);
     });
 }
-export function isRamConstrainedDevice(): Promise<boolean> {
+export function isRamConstrainedDeviceReturnsPromise(): Promise<boolean> {
     let p = new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
         if (err == null || err.code == 0) {
@@ -295,14 +322,19 @@ export function isRamConstrainedDevice(): Promise<boolean> {
     return p;
 }
 
+  overload isRamConstrainedDevice {
+    isRamConstrainedDeviceWithCallback,
+    isRamConstrainedDeviceReturnsPromise
+  }
+
 export native function nativeIsRunningInStabilityTest(callback: AsyncCallbackWrapper<boolean>) : void;
-export function isRunningInStabilityTest(callback: AsyncCallback<boolean>): void {
+export function isRunningInStabilityTestWithCallback(callback: AsyncCallback<boolean>): void {
     let myCall = new AsyncCallbackWrapper<boolean>(callback);
     taskpool.execute((): void => {
       appManager.nativeIsRunningInStabilityTest(myCall);
     });
 }
-export function isRunningInStabilityTest(): Promise<boolean> {
+export function isRunningInStabilityTestReturnsPromise(): Promise<boolean> {
     let p = new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
         if (err == null || err.code == 0) {
@@ -318,15 +350,20 @@ export function isRunningInStabilityTest(): Promise<boolean> {
     return p;
 }
 
+  overload isRunningInStabilityTest {
+    isRunningInStabilityTestWithCallback,
+    isRunningInStabilityTestReturnsPromise
+  }
+
 export native function nativeKillProcessesByBundleNameSync(bundleName: string, callback: AsyncCallbackWrapper<void>) : void;
 export native function nativeKillProcessesByBundleName(callback: AsyncCallbackWrapper<void>, bundleName: string, clearPageStack: boolean, appIndex?: int) : void;
-export function killProcessesByBundleName(bundleName: string, callback: AsyncCallback<void>) : void {
+export function killProcessesByBundleNameWithBundleNameCallback(bundleName: string, callback: AsyncCallback<void>) : void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       appManager.nativeKillProcessesByBundleNameSync(bundleName, myCall);
     });
 }
-export function killProcessesByBundleName(bundleName: string): Promise<void> {
+export function killProcessesByBundleNameWithBundleNameReturnsPromise(bundleName: string): Promise<void> {
     let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
         if (err == null || err.code == 0) {
@@ -341,7 +378,8 @@ export function killProcessesByBundleName(bundleName: string): Promise<void> {
     });
     return p;
 }
-export function killProcessesByBundleName(bundleName: string, clearPageStack: boolean, appIndex?: int): Promise<void> {
+export function killProcessesByBundleNameWithBundleNameClearPageStackAppIndexReturnsPromise(
+  bundleName: string, clearPageStack: boolean, appIndex?: int): Promise<void> {
     let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
         if (err == null || err.code == 0) {
@@ -357,34 +395,56 @@ export function killProcessesByBundleName(bundleName: string, clearPageStack: bo
     return p;
 }
 
+  overload killProcessesByBundleName {
+    killProcessesByBundleNameWithBundleNameCallback,
+    killProcessesByBundleNameWithBundleNameReturnsPromise,
+    killProcessesByBundleNameWithBundleNameClearPageStackAppIndexReturnsPromise
+  }
+
 export native function nativeOnAbilityFirstFrameState(type: string, observer: AbilityFirstFrameStateObserver, bundleName?: string) : void;
-export function on(type: 'abilityFirstFrameState', observer: AbilityFirstFrameStateObserver, bundleName?: string) : void {
+export function onAbilityFirstFrameState(type: 'abilityFirstFrameState', observer: AbilityFirstFrameStateObserver, bundleName?: string) : void {
   appManager.nativeOnAbilityFirstFrameState('abilityFirstFrameState', observer, bundleName);
 }
 
 export native function nativeOffAbilityFirstFrameState(type: string, observer?: AbilityFirstFrameStateObserver) : void;
-export function off(type: 'abilityFirstFrameState', observer?: AbilityFirstFrameStateObserver) : void {
+export function offAbilityFirstFrameState(type: 'abilityFirstFrameState', observer?: AbilityFirstFrameStateObserver) : void {
   appManager.nativeOffAbilityFirstFrameState('abilityFirstFrameState', observer);
 }
 
 export native function nativeOnAppForeGroundState(type: string, observer: AppForegroundStateObserver) : void;
-export function on(type: 'appForegroundState', observer: AppForegroundStateObserver) : void {
+export function onAppForegroundState(type: 'appForegroundState', observer: AppForegroundStateObserver) : void {
   appManager.nativeOnAppForeGroundState('appForegroundState', observer);
 }
 
 export native function nativeOffAppForeGroundState(type: string, observer?: AppForegroundStateObserver) : void;
-export function off(type: 'appForegroundState', observer?: AppForegroundStateObserver) : void {
+export function offAppForegroundState(type: 'appForegroundState', observer?: AppForegroundStateObserver) : void {
   appManager.nativeOffAppForeGroundState('appForegroundState', observer);
 }
 
+  overload on {
+    onAbilityFirstFrameState,
+    onAppForegroundState,
+    onApplicationStateWithObserver,
+    onApplicationStateWithObserverBundleNameList
+  }
+
+  overload off {
+    offAbilityFirstFrameState,
+    offAppForegroundState,
+    offApplicationState,
+    offApplicationStateReturnsPromise
+  }
+
 export native function nativeKillProcessWithAccountSync(bundleName: string, accountId: int, callback: AsyncCallbackWrapper<void>) : void;
-export function killProcessWithAccount(bundleName: string, accountId: int, callback: AsyncCallback<void>): void {
+export function killProcessWithAccountWithBundleNameAccountIdCallback(bundleName: string,
+  accountId: int, callback: AsyncCallback<void>): void {
   let myCall = new AsyncCallbackWrapper<void>(callback);
   taskpool.execute((): void => {
     appManager.nativeKillProcessWithAccountSync(bundleName, accountId, myCall);
   });
 }
-export function killProcessWithAccount(bundleName: string, accountId: int): Promise<void> {
+export function killProcessWithAccountWithBundleNameAccountIdReturnsPromise(bundleName: string,
+  accountId: int): Promise<void> {
   let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
     let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
       if (err == null || err.code == 0) {
@@ -401,8 +461,8 @@ export function killProcessWithAccount(bundleName: string, accountId: int): Prom
 }
 export native function nativeKillProcessWithAccount(callback: AsyncCallbackWrapper<void>,
   bundleName: string, accountId: int, clearPageStack: boolean, appIndex?: int) : void;
-export function killProcessWithAccount(bundleName: string, accountId: int,
-  clearPageStack: boolean, appIndex?: int): Promise<void>
+export function killProcessWithAccountWithBundleNameAccountIdClearPageStackAppIndexReturnsPromise(bundleName: string,
+  accountId: int, clearPageStack: boolean, appIndex?: int): Promise<void>
 {
   let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
     let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
@@ -419,14 +479,20 @@ export function killProcessWithAccount(bundleName: string, accountId: int,
   return p;
 }
 
+  overload killProcessWithAccount {
+    killProcessWithAccountWithBundleNameAccountIdCallback,
+    killProcessWithAccountWithBundleNameAccountIdReturnsPromise,
+    killProcessWithAccountWithBundleNameAccountIdClearPageStackAppIndexReturnsPromise
+  }
+
 export native function nativeGetProcessMemoryByPid(pid: int, callback: AsyncCallbackWrapper<int>) : void;
-export function getProcessMemoryByPid(pid: int, callback: AsyncCallback<int>): void {
+export function getProcessMemoryByPidWithPidCallback(pid: int, callback: AsyncCallback<int>): void {
   let myCall = new AsyncCallbackWrapper<int>(callback);
   taskpool.execute((): void => {
     appManager.nativeGetProcessMemoryByPid(pid, myCall);
   });
 }
-export function getProcessMemoryByPid(pid: int): Promise<int> {
+export function getProcessMemoryByPidWithPidReturnsPromise(pid: int): Promise<int> {
   let p = new Promise<int>((resolve:(data:int)=>void, reject:(err: BusinessError)=>void):void => {
     let myCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined)=>{
       if (err == null || err.code == 0) {
@@ -442,6 +508,11 @@ export function getProcessMemoryByPid(pid: int): Promise<int> {
   return p;
 }
 
+  overload getProcessMemoryByPid {
+    getProcessMemoryByPidWithPidCallback,
+    getProcessMemoryByPidWithPidReturnsPromise
+  }
+
 export native function nativeGetRunningProcessInformationByBundleType(bundleType: bundleManager.BundleType,
   callback: AsyncCallbackWrapper<Array<ProcessInformation>>) : void;
 export function getRunningProcessInformationByBundleType(bundleType: bundleManager.BundleType): Promise<Array<ProcessInformation>>
@@ -462,13 +533,15 @@ export function getRunningProcessInformationByBundleType(bundleType: bundleManag
 }
 
 export native function nativeIsSharedBundleRunning(bundleName: string, versionCode: long, callback: AsyncCallbackWrapper<boolean>) : void;
-export function isSharedBundleRunning(bundleName: string, versionCode: long, callback: AsyncCallback<boolean>): void {
+export function isSharedBundleRunningWithBundleNameVersionCodeCallback(bundleName: string,
+  versionCode: long, callback: AsyncCallback<boolean>): void {
   let myCall = new AsyncCallbackWrapper<boolean>(callback);
   taskpool.execute((): void => {
     appManager.nativeIsSharedBundleRunning(bundleName, versionCode, myCall);
   });
 }
-export function isSharedBundleRunning(bundleName: string, versionCode: long): Promise<boolean> {
+export function isSharedBundleRunningWithBundleNameVersionCodeReturnsPromise(bundleName: string,
+  versionCode: long): Promise<boolean> {
   let p = new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError)=>void):void => {
     let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
       if (err == null || err.code == 0) {
@@ -484,6 +557,11 @@ export function isSharedBundleRunning(bundleName: string, versionCode: long): Pr
   return p;
 }
 
+  overload isSharedBundleRunning {
+    isSharedBundleRunningWithBundleNameVersionCodeCallback,
+    isSharedBundleRunningWithBundleNameVersionCodeReturnsPromise
+  }
+
 export native function nativeGetSupportedProcessCachePids(bundleName: string, callback: AsyncCallbackWrapper<Array<int>>) : void;
 export function getSupportedProcessCachePids(bundleName: string): Promise<Array<int>> {
   let p = new Promise<Array<int>>((resolve:(data:Array<int>)=>void, reject:(err: BusinessError)=>void):void => {
diff --git a/frameworks/ets/ets/@ohos.app.ability.application.ets b/frameworks/ets/ets/@ohos.app.ability.application.ets
index 91f6354351219055deddcf87c701c220e8338ce3..c3724fce54443e9e6251c850833ca1531d68cbe8 100644
--- a/frameworks/ets/ets/@ohos.app.ability.application.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.application.ets
@@ -31,7 +31,8 @@ export default namespace application {
 
   export native function nativeGetApplicationContext(): ApplicationContext;
 
-  export function createModuleContext(context: Context, moduleName: string): Promise<Context> {
+  export function createModuleContextWithContextModuleNameReturnsPromise(context: Context,
+    moduleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
@@ -48,7 +49,8 @@ export default namespace application {
     return p;
   }
 
-  export function createModuleContext(context: Context, bundleName: string, moduleName: string): Promise<Context> {
+  export function createModuleContextWithContextBundleNameModuleNameReturnsPromise(context: Context,
+    bundleName: string, moduleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
@@ -65,6 +67,11 @@ export default namespace application {
     return p;
   }
 
+  overload createModuleContext {
+    createModuleContextWithContextModuleNameReturnsPromise,
+    createModuleContextWithContextBundleNameModuleNameReturnsPromise
+  }
+
   export function createBundleContext(context: Context, bundleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
diff --git a/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets b/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
index 20c9bcfe130b6887ef916ce492ae27b094ecc4bd..6fce67feb4d2217dc8fb693f81c37389f53588f0 100644
--- a/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
@@ -39,14 +39,14 @@ export default namespace insightIntentDriver {
     callback: AsyncCallbackWrapper<insightIntent.ExecuteResult>,
     isCallback: boolean): void;
 
-  export function execute(param: ExecuteParam, callback: AsyncCallback<insightIntent.ExecuteResult>): void {
+  export function executeWithParamCallback(param: ExecuteParam, callback: AsyncCallback<insightIntent.ExecuteResult>): void {
     let pCallback = new AsyncCallbackWrapper<insightIntent.ExecuteResult>(callback);
     taskpool.execute((): void => {
       nativeExecuteSync(param, pCallback, true);
     });
   }
 
-  export function execute(param: ExecuteParam): Promise<insightIntent.ExecuteResult> {
+  export function executeWithParamReturnsPromise(param: ExecuteParam): Promise<insightIntent.ExecuteResult> {
     let pPromise = new Promise<insightIntent.ExecuteResult>((
       resolve: (data: insightIntent.ExecuteResult) => void,
       reject: (err: BusinessError) => void) => {
@@ -64,4 +64,9 @@ export default namespace insightIntentDriver {
     });
     return pPromise;
   }
+
+  overload execute {
+    executeWithParamCallback,
+    executeWithParamReturnsPromise
+  }
 }
\ No newline at end of file
diff --git a/frameworks/ets/ets/@ohos.app.ability.missionManager.ets b/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
index ad2ec9c8f728ccf271758b9e4368368aced57de1..b55bc8a9309912003e24ad23cd1e301eb91d81e1 100644
--- a/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
@@ -22,14 +22,14 @@ export default namespace missionManager {
   export native function nativeGetMissionInfo(deviceId: string, missionId: int,
     callback: AsyncCallbackWrapper<MissionInfo>): void;
 
-  export function clearAllMissions(callback: AsyncCallback<void>): void {
+  export function clearAllMissionsWithCallback(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       missionManager.nativeClearAllMissions(myCall);
     });
   }
 
-  export function clearAllMissions(): Promise<void> {
+  export function clearAllMissionsReturnsPromise(): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -46,14 +46,19 @@ export default namespace missionManager {
     return p;
   }
 
-  export function getMissionInfo(deviceId: string, missionId: int, callback: AsyncCallback<MissionInfo>): void {
+  overload clearAllMissions {
+    clearAllMissionsWithCallback,
+    clearAllMissionsReturnsPromise
+  }
+
+  export function getMissionInfoWithDeviceIdMissionIdCallback(deviceId: string, missionId: int, callback: AsyncCallback<MissionInfo>): void {
     let myCall = new AsyncCallbackWrapper<MissionInfo>(callback);
     taskpool.execute((): void => {
       missionManager.nativeGetMissionInfo(deviceId, missionId, myCall);
     });
   }
 
-  export function getMissionInfo(deviceId: string, missionId: int): Promise<MissionInfo> {
+  export function getMissionInfoWithDeviceIdMissionIdReturnsPromise(deviceId: string, missionId: int): Promise<MissionInfo> {
     let p =
       new Promise<MissionInfo>((resolve: (data: MissionInfo) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<MissionInfo>((err: BusinessError | null, data: MissionInfo | undefined) => {
@@ -70,5 +75,10 @@ export default namespace missionManager {
     return p;
   }
 
+  overload getMissionInfo {
+    getMissionInfoWithDeviceIdMissionIdCallback,
+    getMissionInfoWithDeviceIdMissionIdReturnsPromise
+  }
+
   export type MissionInfo = _MissionInfo;
 }
\ No newline at end of file
diff --git a/frameworks/ets/ets/@ohos.app.ability.wantAgent.ets b/frameworks/ets/ets/@ohos.app.ability.wantAgent.ets
index b0ba39051dbd0b37ffba7cc173778dd2fbfd3004..8454a41e75c68ffdb5ca529e11844c5d8fcb6e63 100644
--- a/frameworks/ets/ets/@ohos.app.ability.wantAgent.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.wantAgent.ets
@@ -69,7 +69,7 @@ namespace wantAgent {
   native function nativeGetWant(agent: WantAgent, callback: AsyncCallbackWrapper<Want>): void;
   native function nativeGetWantAgent(agent: WantAgentInfo, callback: AsyncCallbackWrapper<WantAgent>): void;
 
-  export function getBundleName(agent: WantAgent, callback: AsyncCallback<string>): void {
+  export function getBundleNameWithAgentCallback(agent: WantAgent, callback: AsyncCallback<string>): void {
     let call = new AsyncCallbackWrapper<string>(callback);
     taskpool.execute((): void => {
       try {
@@ -80,7 +80,7 @@ namespace wantAgent {
     });
   }
 
-  export function getBundleName(agent: WantAgent): Promise<string> {
+  export function getBundleNameWithAgentReturnsPromise(agent: WantAgent): Promise<string> {
     return new Promise<string>((resolve: (data: string) => void, reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<string>((err: BusinessError | null, data: string | undefined) => {
         if (err == null || err.code == 0) {
@@ -99,7 +99,12 @@ namespace wantAgent {
     });
   }
 
-  export function getUid(agent: WantAgent, callback: AsyncCallback<int>): void {
+  overload getBundleName {
+    getBundleNameWithAgentCallback,
+    getBundleNameWithAgentReturnsPromise
+  }
+
+  export function getUidWithAgentCallback(agent: WantAgent, callback: AsyncCallback<int>): void {
     let call = new AsyncCallbackWrapper<int>(callback);
     taskpool.execute((): void => {
       try {
@@ -110,7 +115,7 @@ namespace wantAgent {
     });
   }
 
-  export function getUid(agent: WantAgent): Promise<int> {
+  export function getUidWithAgentReturnsPromise(agent: WantAgent): Promise<int> {
     return new Promise<int>((resolve: (data: int) => void, reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined) => {
         if (err == null || err.code == 0) {
@@ -129,7 +134,12 @@ namespace wantAgent {
     });
   }
 
-  export function getWant(agent: WantAgent, callback: AsyncCallback<Want>): void {
+  overload getUid {
+    getUidWithAgentCallback,
+    getUidWithAgentReturnsPromise
+  }
+
+  export function getWantWithAgentCallback(agent: WantAgent, callback: AsyncCallback<Want>): void {
     let call = new AsyncCallbackWrapper<Want>(callback);
     taskpool.execute((): void => {
       try {
@@ -140,7 +150,7 @@ namespace wantAgent {
     });
   }
 
-  export function getWant(agent: WantAgent): Promise<Want> {
+  export function getWantWithAgentReturnsPromise(agent: WantAgent): Promise<Want> {
     return new Promise<Want>((resolve: (data: Want) => void, reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<Want>((err: BusinessError | null, data: Want | undefined) => {
         if (err == null || err.code == 0) {
@@ -159,7 +169,12 @@ namespace wantAgent {
     });
   }
 
-  export function cancel(agent: WantAgent, callback: AsyncCallback<void>): void {
+  overload getWant {
+    getWantWithAgentCallback,
+    getWantWithAgentReturnsPromise
+  }
+
+  export function cancelWithAgentCallback(agent: WantAgent, callback: AsyncCallback<void>): void {
     let call = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       try {
@@ -170,7 +185,7 @@ namespace wantAgent {
     });
   }
 
-  export function cancel(agent: WantAgent): Promise<void> {
+  export function cancelWithAgentReturnsPromise(agent: WantAgent): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -189,6 +204,11 @@ namespace wantAgent {
     });
   }
 
+  overload cancel {
+    cancelWithAgentCallback,
+    cancelWithAgentReturnsPromise
+  }
+
   export function trigger(agent: WantAgent, triggerInfo: TriggerInfo, callback?: AsyncCallback<CompleteData>): void {
     taskpool.execute((): void => {
       if (callback == undefined) {
@@ -204,7 +224,7 @@ namespace wantAgent {
     });
   }
 
-  export function equal(agent: WantAgent, otherAgent: WantAgent, callback: AsyncCallback<boolean>): void {
+  export function equalWithAgentOtherAgentCallback(agent: WantAgent, otherAgent: WantAgent, callback: AsyncCallback<boolean>): void {
     let call = new AsyncCallbackWrapper<boolean>(callback);
     taskpool.execute((): void => {
       try {
@@ -215,7 +235,7 @@ namespace wantAgent {
     });
   }
 
-  export function equal(agent: WantAgent, otherAgent: WantAgent): Promise<boolean> {
+  export function equalWithAgentOtherAgentReturnsPromise(agent: WantAgent, otherAgent: WantAgent): Promise<boolean> {
     return new Promise<boolean>((resolve: (data: boolean) => void,
       reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
@@ -235,7 +255,12 @@ namespace wantAgent {
     });
   }
 
-  export function getWantAgent(info: WantAgentInfo, callback: AsyncCallback<WantAgent>): void {
+  overload equal {
+    equalWithAgentOtherAgentCallback,
+    equalWithAgentOtherAgentReturnsPromise
+  }
+
+  export function getWantAgentWithInfoCallback(info: WantAgentInfo, callback: AsyncCallback<WantAgent>): void {
     let call = new AsyncCallbackWrapper<WantAgent>(callback);
     taskpool.execute((): void => {
       try {
@@ -246,7 +271,7 @@ namespace wantAgent {
     });
   }
 
-  export function getWantAgent(info: WantAgentInfo): Promise<WantAgent> {
+  export function getWantAgentWithInfoReturnsPromise(info: WantAgentInfo): Promise<WantAgent> {
     return new Promise<WantAgent>((resolve: (data: WantAgent) => void,
       reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<WantAgent>((err: BusinessError | null, data: WantAgent | undefined) => {
@@ -266,7 +291,12 @@ namespace wantAgent {
     });
   }
 
-  export function getOperationType(agent: WantAgent, callback: AsyncCallback<int>): void {
+  overload getWantAgent {
+    getWantAgentWithInfoCallback,
+    getWantAgentWithInfoReturnsPromise
+  }
+
+  export function getOperationTypeWithAgentCallback(agent: WantAgent, callback: AsyncCallback<int>): void {
     let call = new AsyncCallbackWrapper<int>(callback);
     taskpool.execute((): void => {
       try {
@@ -277,7 +307,7 @@ namespace wantAgent {
     });
   }
 
-  export function getOperationType(agent: WantAgent): Promise<int> {
+  export function getOperationTypeWithAgentReturnsPromise(agent: WantAgent): Promise<int> {
     return new Promise<int>((resolve: (data: int) => void, reject: (err: BusinessError) => void): void => {
       let call = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined) => {
         if (err == null || err.code == 0) {
@@ -296,6 +326,11 @@ namespace wantAgent {
     });
   }
 
+  overload getOperationType {
+    getOperationTypeWithAgentCallback,
+    getOperationTypeWithAgentReturnsPromise
+  }
+
   export enum WantAgentFlags {
     ONE_TIME_FLAG = 0,
     NO_BUILD_FLAG,
diff --git a/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets b/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
index 93bdc519cb1c1d201daab5e497452abd5d8d1a6f..416e921d841090bda4d1a1092c272e88961f5c0a 100644
--- a/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
+++ b/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
@@ -25,7 +25,8 @@ export default namespace uriPermissionManager {
     export native function revokeUriPermissionCallbackSync(uri: string, targetBundleName: string, appCloneIndex: int,
         callback: AsyncCallbackWrapper<number>): void;
 
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string): Promise<number> {
+    export function grantUriPermissionWithUriFlagTargetBundleNameReturnsPromise(uri: string, flag: wantConstant.Flags,
+        targetBundleName: string): Promise<number> {
         let p:Promise<number> = new Promise<number>((resolve: (data: number)=>void, reject:(err: BusinessError)=>void):void => {
             let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
                 if (err === null || err.code === 0) {
@@ -45,8 +46,8 @@ export default namespace uriPermissionManager {
         return p;
     }
 
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
-        appCloneIndex: int): Promise<void> {
+    export function grantUriPermissionWithUriFlagTargetBundleNameAppCloneIndexReturnsPromise(uri: string,
+        flag: wantConstant.Flags, targetBundleName: string, appCloneIndex: int): Promise<void> {
         let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
             let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
                 if (err === null || err.code === 0) {
@@ -63,15 +64,22 @@ export default namespace uriPermissionManager {
         return p;
     }
 
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
-        callback: AsyncCallback<number, void>): void {
+    export function grantUriPermissionWithUriFlagTargetBundleNameCallback(uri: string, flag: wantConstant.Flags,
+        targetBundleName: string, callback: AsyncCallback<number, void>): void {
         let myCall = new AsyncCallbackWrapper<number>(callback);
         taskpool.execute((): void => {
             uriPermissionManager.grantUriPermissionCallbackSync(uri, flag, targetBundleName, 0, myCall);
         })
     }
 
-    export function revokeUriPermission(uri: string, targetBundleName: string): Promise<number> {
+  overload grantUriPermission {
+    grantUriPermissionWithUriFlagTargetBundleNameReturnsPromise,
+    grantUriPermissionWithUriFlagTargetBundleNameAppCloneIndexReturnsPromise,
+    grantUriPermissionWithUriFlagTargetBundleNameCallback
+  }
+
+    export function revokeUriPermissionWithUriTargetBundleNameReturnsPromise(uri: string,
+        targetBundleName: string): Promise<number> {
         let p:Promise<number> = new Promise<number>((resolve: (data: number)=>void, reject:(err: BusinessError)=>void):void => {
             let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
                 if (err === null || err.code === 0) {
@@ -91,7 +99,8 @@ export default namespace uriPermissionManager {
         return p;
     }
 
-    export function revokeUriPermission(uri: string, targetBundleName: string, appCloneIndex: int): Promise<void> {
+    export function revokeUriPermissionWithUriTargetBundleNameAppCloneIndexReturnsPromise(uri: string,
+        targetBundleName: string, appCloneIndex: int): Promise<void> {
         let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
             let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
                 if (err === null || err.code === 0) {
@@ -107,10 +116,17 @@ export default namespace uriPermissionManager {
         return p;
     }
 
-    export function revokeUriPermission(uri: string, targetBundleName: string, callback: AsyncCallback<number, void>): void {
+    export function revokeUriPermissionWithUriTargetBundleNameCallback(uri: string, targetBundleName: string,
+        callback: AsyncCallback<number, void>): void {
         let myCall = new AsyncCallbackWrapper<number>(callback);
         taskpool.execute((): void => {
             uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, 0, myCall);
         })
     }
+
+  overload revokeUriPermission {
+    revokeUriPermissionWithUriTargetBundleNameReturnsPromise,
+    revokeUriPermissionWithUriTargetBundleNameAppCloneIndexReturnsPromise,
+    revokeUriPermissionWithUriTargetBundleNameCallback
+  }
 }
\ No newline at end of file
diff --git a/frameworks/ets/ets/application/AbilityDelegator.ets b/frameworks/ets/ets/application/AbilityDelegator.ets
index fec39c5bcea8ec2dab35dd9a8a89cc03a2966d80..29d3ba9715923b769d693a4c0cbdceeb03144fe1 100644
--- a/frameworks/ets/ets/application/AbilityDelegator.ets
+++ b/frameworks/ets/ets/application/AbilityDelegator.ets
@@ -28,75 +28,148 @@ export interface AbilityDelegator {
 
   getAppContext(): Context;
 
-  finishTest(msg: string, code: long, callback: AsyncCallback<void>): void;
+  finishTestWithMsgCodeCallback(msg: string, code: long, callback: AsyncCallback<void>): void;
 
-  finishTest(msg: string, code: long): Promise<void>;
+  finishTestWithMsgCodeReturnsPromise(msg: string, code: long): Promise<void>;
 
-  executeShellCommand(cmd: String, callback: AsyncCallback<ShellCmdResult>): void;
+  overload finishTest {
+    finishTestWithMsgCodeCallback,
+    finishTestWithMsgCodeReturnsPromise
+  }
+
+  executeShellCommandWithCmdCallback(cmd: String, callback: AsyncCallback<ShellCmdResult>): void;
 
-  executeShellCommand(cmd: String, timeoutSecs: long, callback: AsyncCallback<ShellCmdResult>): void;
+  executeShellCommandWithCmdTimeoutSecsCallback(cmd: String, timeoutSecs: long,
+    callback: AsyncCallback<ShellCmdResult>): void;
 
-  executeShellCommand(cmd: string, timeoutSecs?: long): Promise<ShellCmdResult>;
+  executeShellCommandWithCmdTimeoutSecsReturnsPromise(cmd: string, timeoutSecs?: long): Promise<ShellCmdResult>;
+
+  overload executeShellCommand {
+    executeShellCommandWithCmdCallback,
+    executeShellCommandWithCmdTimeoutSecsCallback,
+    executeShellCommandWithCmdTimeoutSecsReturnsPromise
+  }
 
-  addAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void;
+  addAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<void>): void;
 
-  addAbilityMonitor(monitor: AbilityMonitor): Promise<void>;
+  addAbilityMonitorWithMonitorReturnsPromise(monitor: AbilityMonitor): Promise<void>;
+
+  overload addAbilityMonitor {
+    addAbilityMonitorWithMonitorCallback,
+    addAbilityMonitorWithMonitorReturnsPromise
+  }
 
   addAbilityMonitorSync(monitor: AbilityMonitor): void;
 
-  removeAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void
+  removeAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<void>): void
+
+  removeAbilityMonitorWithMonitorReturnsPromise(monitor: AbilityMonitor): Promise<void>;
 
-  removeAbilityMonitor(monitor: AbilityMonitor): Promise<void>;
+  overload removeAbilityMonitor {
+    removeAbilityMonitorWithMonitorCallback,
+    removeAbilityMonitorWithMonitorReturnsPromise
+  }
 
   removeAbilityMonitorSync(monitor: AbilityMonitor): void;
 
-  waitAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<UIAbility>): void;
+  waitAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<UIAbility>): void;
+
+  waitAbilityMonitorWithMonitorTimeoutCallback(monitor: AbilityMonitor, timeout: long,
+    callback: AsyncCallback<UIAbility>): void;
 
-  waitAbilityMonitor(monitor: AbilityMonitor, timeout: long, callback: AsyncCallback<UIAbility>): void;
+  waitAbilityMonitorWithMonitorTimeoutReturnsPromise(monitor: AbilityMonitor, timeout?: long): Promise<UIAbility>;
 
-  waitAbilityMonitor(monitor: AbilityMonitor, timeout?: long): Promise<UIAbility>;
+  overload waitAbilityMonitor {
+    waitAbilityMonitorWithMonitorCallback,
+    waitAbilityMonitorWithMonitorTimeoutCallback,
+    waitAbilityMonitorWithMonitorTimeoutReturnsPromise
+  }
 
-  addAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void;
+  addAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void;
 
-  addAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void>;
+  addAbilityStageMonitorWithMonitorReturnsPromise(monitor: AbilityStageMonitor): Promise<void>;
+
+  overload addAbilityStageMonitor {
+    addAbilityStageMonitorWithMonitorCallback,
+    addAbilityStageMonitorWithMonitorReturnsPromise
+  }
 
   addAbilityStageMonitorSync(monitor: AbilityStageMonitor): void;
 
-  removeAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void;
+  removeAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void;
+
+  removeAbilityStageMonitorWithMonitorReturnsPromise(monitor: AbilityStageMonitor): Promise<void>;
 
-  removeAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void>;
+  overload removeAbilityStageMonitor {
+    removeAbilityStageMonitorWithMonitorCallback,
+    removeAbilityStageMonitorWithMonitorReturnsPromise
+  }
 
   removeAbilityStageMonitorSync(monitor: AbilityStageMonitor): void;
 
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<AbilityStage>): void;
+  waitAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor,
+    callback: AsyncCallback<AbilityStage>): void;
 
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout: long, callback: AsyncCallback<AbilityStage>): void;
+  waitAbilityStageMonitorWithMonitorTimeoutCallback(monitor: AbilityStageMonitor,
+    timeout: long, callback: AsyncCallback<AbilityStage>): void;
 
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout?: long): Promise<AbilityStage>;
+  waitAbilityStageMonitorWithMonitorTimeoutReturnsPromise(monitor: AbilityStageMonitor,
+    timeout?: long): Promise<AbilityStage>;
 
-  doAbilityForeground(ability: UIAbility, callback: AsyncCallback<void>): void;
+  overload waitAbilityStageMonitor {
+    waitAbilityStageMonitorWithMonitorCallback,
+    waitAbilityStageMonitorWithMonitorTimeoutCallback,
+    waitAbilityStageMonitorWithMonitorTimeoutReturnsPromise
+  }
+
+  doAbilityForegroundWithAbilityCallback(ability: UIAbility, callback: AsyncCallback<void>): void;
 
-  doAbilityForeground(ability: UIAbility): Promise<void>;
+  doAbilityForegroundWithAbilityReturnsPromise(ability: UIAbility): Promise<void>;
 
-  doAbilityBackground(ability: UIAbility, callback: AsyncCallback<void>): void;
+  overload doAbilityForeground {
+    doAbilityForegroundWithAbilityCallback,
+    doAbilityForegroundWithAbilityReturnsPromise
+  }
 
-  doAbilityBackground(ability: UIAbility): Promise<void>;
+  doAbilityBackgroundWithAbilityCallback(ability: UIAbility, callback: AsyncCallback<void>): void;
 
-  print(msg: string, callback: AsyncCallback<void>): void;
+  doAbilityBackgroundWithAbilityReturnsPromise(ability: UIAbility): Promise<void>;
 
-  print(msg: string): Promise<void>;
+  overload doAbilityBackground {
+    doAbilityBackgroundWithAbilityCallback,
+    doAbilityBackgroundWithAbilityReturnsPromise
+  }
+
+  printWithMsgCallback(msg: string, callback: AsyncCallback<void>): void;
+
+  printWithMsgReturnsPromise(msg: string): Promise<void>;
+
+  overload print {
+    printWithMsgCallback,
+    printWithMsgReturnsPromise
+  }
 
   getAbilityState(ability: UIAbility): int;
 
   setMockList(mockList: Record<string, string>): void;
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void;
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void;
+
+  startAbilityWithWantReturnsPromise(want: Want): Promise<void>;
+
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantReturnsPromise
+  }
 
-  startAbility(want: Want): Promise<void>;
+  getCurrentTopAbilityWithCallback(callback: AsyncCallback<UIAbility>);
 
-  getCurrentTopAbility(callback: AsyncCallback<UIAbility>);
+  getCurrentTopAbilityReturnsPromise(): Promise<UIAbility>;
 
-  getCurrentTopAbility(): Promise<UIAbility>;
+  overload getCurrentTopAbility {
+    getCurrentTopAbilityWithCallback,
+    getCurrentTopAbilityReturnsPromise
+  }
 }
 
 class AbilityDelegatorInner implements AbilityDelegator {
@@ -146,13 +219,13 @@ class AbilityDelegatorInner implements AbilityDelegator {
 
   public native nativeStartAbility(want: Want, callback: AsyncCallbackWrapper<void>): void;
 
-  finishTest(msg: string, code: long, callback: AsyncCallback<void>): void {
+  finishTestWithMsgCodeCallback(msg: string, code: long, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeFinishTest(msg, code, myCall);
     });
   }
-  finishTest(msg: string, code: long): Promise<void> {
+  finishTestWithMsgCodeReturnsPromise(msg: string, code: long): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -169,20 +242,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  executeShellCommand(cmd: string, callback: AsyncCallback<ShellCmdResult, void>): void {
+  overload finishTest {
+    finishTestWithMsgCodeCallback,
+    finishTestWithMsgCodeReturnsPromise
+  }
+
+  executeShellCommandWithCmdCallback(cmd: string, callback: AsyncCallback<ShellCmdResult, void>): void {
     let timeoutSecs = 0;
     let myCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
     taskpool.execute((): void => {
       this.nativeExecuteShellCommand(cmd, timeoutSecs, myCall);
     });
   }
-  executeShellCommand(cmd: string, timeoutSecs: long, callback: AsyncCallback<ShellCmdResult, void>): void {
+  executeShellCommandWithCmdTimeoutSecsCallback(cmd: string, timeoutSecs: long,
+    callback: AsyncCallback<ShellCmdResult, void>): void {
     let myCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
     taskpool.execute((): void => {
       this.nativeExecuteShellCommand(cmd, timeoutSecs, myCall);
     });
   }
-  executeShellCommand(cmd: string, timeoutSecs?: long): Promise<ShellCmdResult> {
+  executeShellCommandWithCmdTimeoutSecsReturnsPromise(cmd: string, timeoutSecs?: long): Promise<ShellCmdResult> {
     let p = new Promise<ShellCmdResult>((resolve: (data: ShellCmdResult) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall =
@@ -204,13 +283,19 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  addAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
+  overload executeShellCommand {
+    executeShellCommandWithCmdCallback,
+    executeShellCommandWithCmdTimeoutSecsCallback,
+    executeShellCommandWithCmdTimeoutSecsReturnsPromise
+  }
+
+  addAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeAddAbilityMonitor(monitor, myCall);
     });
   }
-  addAbilityMonitor(monitor: AbilityMonitor): Promise<void> {
+  addAbilityMonitorWithMonitorReturnsPromise(monitor: AbilityMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -227,13 +312,18 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  removeAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
+  overload addAbilityMonitor {
+    addAbilityMonitorWithMonitorCallback,
+    addAbilityMonitorWithMonitorReturnsPromise
+  }
+
+  removeAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.removeAbilityMonitorAsync(monitor, myCall);
     });
   }
-  removeAbilityMonitor(monitor: AbilityMonitor): Promise<void> {
+  removeAbilityMonitorWithMonitorReturnsPromise(monitor: AbilityMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -250,20 +340,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  waitAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<UIAbility, void>): void {
+  overload removeAbilityMonitor {
+    removeAbilityMonitorWithMonitorCallback,
+    removeAbilityMonitorWithMonitorReturnsPromise
+  }
+
+  waitAbilityMonitorWithMonitorCallback(monitor: AbilityMonitor, callback: AsyncCallback<UIAbility, void>): void {
     let timeout = -1;
     let myCall = new AsyncCallbackWrapper<UIAbility>(callback);
     taskpool.execute((): void => {
       this.waitAbilityMonitorAsync(monitor, timeout, myCall);
     });
   }
-  waitAbilityMonitor(monitor: AbilityMonitor, timeout: long, callback: AsyncCallback<UIAbility, void>): void {
+  waitAbilityMonitorWithMonitorTimeoutCallback(monitor: AbilityMonitor, timeout: long,
+    callback: AsyncCallback<UIAbility, void>): void {
     let myCall = new AsyncCallbackWrapper<UIAbility>(callback);
     taskpool.execute((): void => {
       this.waitAbilityMonitorAsync(monitor, timeout, myCall);
     });
   }
-  waitAbilityMonitor(monitor: AbilityMonitor, timeout?: long): Promise<UIAbility> {
+  waitAbilityMonitorWithMonitorTimeoutReturnsPromise(monitor: AbilityMonitor, timeout?: long): Promise<UIAbility> {
     let p = new Promise<UIAbility>((resolve: (data: UIAbility) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
@@ -284,13 +380,19 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  addAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
+  overload waitAbilityMonitor {
+    waitAbilityMonitorWithMonitorCallback,
+    waitAbilityMonitorWithMonitorTimeoutCallback,
+    waitAbilityMonitorWithMonitorTimeoutReturnsPromise
+  }
+
+  addAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.addAbilityStageMonitorAsync(monitor, myCall);
     });
   }
-  addAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void> {
+  addAbilityStageMonitorWithMonitorReturnsPromise(monitor: AbilityStageMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -307,13 +409,18 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  removeAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
+  overload addAbilityStageMonitor {
+    addAbilityStageMonitorWithMonitorCallback,
+    addAbilityStageMonitorWithMonitorReturnsPromise
+  }
+
+  removeAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.removeAbilityStageMonitorAsync(monitor, myCall);
     });
   }
-  removeAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void> {
+  removeAbilityStageMonitorWithMonitorReturnsPromise(monitor: AbilityStageMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -330,21 +437,28 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<AbilityStage, void>): void {
+  overload removeAbilityStageMonitor {
+    removeAbilityStageMonitorWithMonitorCallback,
+    removeAbilityStageMonitorWithMonitorReturnsPromise
+  }
+
+  waitAbilityStageMonitorWithMonitorCallback(monitor: AbilityStageMonitor,
+    callback: AsyncCallback<AbilityStage, void>): void {
     let timeout = -1;
     let myCall = new AsyncCallbackWrapper<AbilityStage>(callback);
     taskpool.execute((): void => {
       this.waitAbilityStageMonitorAsync(monitor, timeout, myCall);
     });
   }
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout: long,
+  waitAbilityStageMonitorWithMonitorTimeoutCallback(monitor: AbilityStageMonitor, timeout: long,
     callback: AsyncCallback<AbilityStage, void>): void {
     let myCall = new AsyncCallbackWrapper<AbilityStage>(callback);
     taskpool.execute((): void => {
       this.waitAbilityStageMonitorAsync(monitor, timeout, myCall);
     });
   }
-  waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout?: long): Promise<AbilityStage> {
+  waitAbilityStageMonitorWithMonitorTimeoutReturnsPromise(monitor: AbilityStageMonitor,
+    timeout?: long): Promise<AbilityStage> {
     let p = new Promise<AbilityStage>((resolve: (data: AbilityStage) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall =
@@ -366,13 +480,19 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  doAbilityForeground(ability: UIAbility, callback: AsyncCallback<void>): void {
+  overload waitAbilityStageMonitor {
+    waitAbilityStageMonitorWithMonitorCallback,
+    waitAbilityStageMonitorWithMonitorTimeoutCallback,
+    waitAbilityStageMonitorWithMonitorTimeoutReturnsPromise
+  }
+
+  doAbilityForegroundWithAbilityCallback(ability: UIAbility, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.doAbilityForegroundAsync(ability, myCall);
     });
   }
-  doAbilityForeground(ability: UIAbility): Promise<void> {
+  doAbilityForegroundWithAbilityReturnsPromise(ability: UIAbility): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -389,13 +509,18 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  doAbilityBackground(ability: UIAbility, callback: AsyncCallback<void>): void {
+  overload doAbilityForeground {
+    doAbilityForegroundWithAbilityCallback,
+    doAbilityForegroundWithAbilityReturnsPromise
+  }
+
+  doAbilityBackgroundWithAbilityCallback(ability: UIAbility, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.doAbilityBackgroundAsync(ability, myCall);
     });
   }
-  doAbilityBackground(ability: UIAbility): Promise<void> {
+  doAbilityBackgroundWithAbilityReturnsPromise(ability: UIAbility): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -412,13 +537,18 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  print(msg: string, callback: AsyncCallback<void>): void {
+  overload doAbilityBackground {
+    doAbilityBackgroundWithAbilityCallback,
+    doAbilityBackgroundWithAbilityReturnsPromise
+  }
+
+  printWithMsgCallback(msg: string, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.printAsync(msg, myCall);
     });
   }
-  print(msg: string): Promise<void> {
+  printWithMsgReturnsPromise(msg: string): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -435,13 +565,18 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void {
+  overload print {
+    printWithMsgCallback,
+    printWithMsgReturnsPromise
+  }
+
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbility(want, myCall);
     });
   }
-  startAbility(want: Want): Promise<void> {
+  startAbilityWithWantReturnsPromise(want: Want): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -458,14 +593,19 @@ class AbilityDelegatorInner implements AbilityDelegator {
     return p;
   }
 
-  getCurrentTopAbility(callback: AsyncCallback<UIAbility, void>): void {
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantReturnsPromise
+  }
+
+  getCurrentTopAbilityWithCallback(callback: AsyncCallback<UIAbility, void>): void {
     let getCurrentTopAbilityCall = new AsyncCallbackWrapper<UIAbility>(callback);
     let p = taskpool.execute((): UIAbility => {
       this.nativeGetCurrentTopAbility(getCurrentTopAbilityCall)
     });
     console.log("getCurrentTopAbility callback2_04");
   }
-  getCurrentTopAbility(): Promise<UIAbility> {
+  getCurrentTopAbilityReturnsPromise(): Promise<UIAbility> {
     let p: Promise<UIAbility>  = new Promise<UIAbility>((resolve: (v: UIAbility) => void, reject: (error: Error) => void) => {
       console.log("getCurrentTopAbility promise1_01");
       let getCurrentTopAbilityCall = new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
@@ -481,4 +621,9 @@ class AbilityDelegatorInner implements AbilityDelegator {
     });
     return p;
   }
+
+  overload getCurrentTopAbility {
+    getCurrentTopAbilityWithCallback,
+    getCurrentTopAbilityReturnsPromise
+  }
 }
diff --git a/frameworks/ets/ets/application/ApplicationContext.ets b/frameworks/ets/ets/application/ApplicationContext.ets
index 5565205a386933bbddd66fec0dbddee2f5b37102..a6154728694d8755bb4a26b1a7b5fe5ba48e0baf 100644
--- a/frameworks/ets/ets/application/ApplicationContext.ets
+++ b/frameworks/ets/ets/application/ApplicationContext.ets
@@ -108,14 +108,14 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
-  killAllProcesses(callback: AsyncCallback<void>): void {
+  killAllProcessesWithCallback(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativekillAllProcessesSync(false, myCall);
     });
   }
 
-  killAllProcesses(): Promise<void> {
+  killAllProcessesReturnsPromise(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -132,7 +132,7 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
-  killAllProcesses(clearPageStack: boolean): Promise<void> {
+  killAllProcessesWithClearPageStackReturnsPromise(clearPageStack: boolean): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -149,14 +149,20 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
-  getRunningProcessInformation(callback: AsyncCallback<Array<ProcessInformation>>): void {
+  overload killAllProcesses {
+    killAllProcessesWithCallback,
+    killAllProcessesReturnsPromise,
+    killAllProcessesWithClearPageStackReturnsPromise
+  }
+
+  getRunningProcessInformationWithCallback(callback: AsyncCallback<Array<ProcessInformation>>): void {
     let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
     taskpool.execute((): void => {
       this.nativegetRunningProcessInformation(myCall);
     });
   }
 
-  getRunningProcessInformation(): Promise<Array<ProcessInformation>> {
+  getRunningProcessInformationReturnsPromise(): Promise<Array<ProcessInformation>> {
     let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
@@ -174,14 +180,19 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
-  clearUpApplicationData(callback: AsyncCallback<void>): void {
+  overload getRunningProcessInformation {
+    getRunningProcessInformationWithCallback,
+    getRunningProcessInformationReturnsPromise,
+  }
+
+  clearUpApplicationDataWithCallback(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeclearUpApplicationData(myCall);
     });
   }
 
-  clearUpApplicationData(): Promise<void> {
+  clearUpApplicationDataReturnsPromise(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -198,6 +209,11 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
+  overload clearUpApplicationData {
+    clearUpApplicationDataWithCallback,
+    clearUpApplicationDataReturnsPromise,
+  }
+
   setLanguage(language: string): void {
     this.nativesetLanguage(language);
   }
@@ -236,22 +252,25 @@ export default class ApplicationContext extends Context {
     return p;
   }
 
-  on(type: 'environment', callback: EnvironmentCallback): int {
+  onEnvironment(type: 'environment', callback: EnvironmentCallback): int {
     return this.nativeOnEnvironmentSync(callback);
   }
 
-  off(type: string, callbackId: int, callback: AsyncCallback<void>): void {
+  offEnvironmentWithCallbackId(type: 'environment', callbackId: int, callback: AsyncCallback<void>): void {
+    let myCall = new AsyncCallbackWrapper<void>(callback);
+    taskpool.execute((): void => {
+      this.nativeOffEnvironmentSync(callbackId, myCall);
+    });
+  }
+
+  offAbilityLifecycleWithCallbackId(type: 'abilityLifecycle', callbackId: int, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      if (type == 'environment') {
-        this.nativeOffEnvironmentSync(callbackId, myCall);
-      } else if (type == 'abilityLifecycle') {
-        this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
-      }
+      this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
     });
   }
 
-  off(type: string, callbackId: int): Promise<void> {
+  offEnvironmentWithCallbackIdReturnsPromise(type: 'environment', callbackId: int): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -262,21 +281,34 @@ export default class ApplicationContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          if (type == 'environment') {
-            this.nativeOffEnvironmentSync(callbackId, myCall);
-          } else if (type == 'abilityLifecycle') {
-            this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
+          this.nativeOffEnvironmentSync(callbackId, myCall);
+        });
+      });
+    return p;
+  }
+
+  offAbilityLifecycleWithCallbackIdReturnsPromise(type: 'abilityLifecycle', callbackId: int): Promise<void> {
+    let p =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+          if (err == null || err.code == 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
           }
         });
+        taskpool.execute((): void => {
+          this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
+        });
       });
     return p;
   }
 
-  on(type: 'applicationStateChange', callback: ApplicationStateChangeCallback): void {
+  onApplicationStateChange(type: 'applicationStateChange', callback: ApplicationStateChangeCallback): void {
     this.nativeOnApplicationStateChangeSync(callback);
   }
 
-  off(type: 'applicationStateChange', callback?: ApplicationStateChangeCallback): void {
+  offApplicationStateChange(type: 'applicationStateChange', callback?: ApplicationStateChangeCallback): void {
     this.nativeOffApplicationStateChangeSync(callback);
   }
 
@@ -303,8 +335,21 @@ export default class ApplicationContext extends Context {
     return ApplicationContext.nativeTransferDynamic(input).unwrap();
   }
 
-  on(type: 'abilityLifecycle', callback: AbilityLifecycleCallback): int {
+  onAbilityLifecycle(type: 'abilityLifecycle', callback: AbilityLifecycleCallback): int {
     return this.nativeOnLifecycleCallbackSync(type, callback);
   }
 
+  overload on {
+    onEnvironment,
+    onApplicationStateChange,
+    onAbilityLifecycle
+  }
+
+  overload off {
+    offEnvironmentWithCallbackId,
+    offAbilityLifecycleWithCallbackId,
+    offEnvironmentWithCallbackIdReturnsPromise,
+    offAbilityLifecycleWithCallbackIdReturnsPromise,
+    offApplicationStateChange
+  }
 }
diff --git a/frameworks/ets/ets/application/Context.ets b/frameworks/ets/ets/application/Context.ets
index e285cb169afb91b147fbd4f64299068b6bf07f99..c86ca59b8fb8945834414d34bb89658456641bbd 100644
--- a/frameworks/ets/ets/application/Context.ets
+++ b/frameworks/ets/ets/application/Context.ets
@@ -104,14 +104,14 @@ export class Context extends BaseContext {
     return this.getArea();
   }
 
-  getGroupDir(dataGroupID: string, callback: AsyncCallback<string>): void {
+  getGroupDirWitdhDataGroupIDCallback(dataGroupID: string, callback: AsyncCallback<string>): void {
     let myCall = new AsyncCallbackWrapper<string>(callback);
     taskpool.execute((): void => {
       this.nativeGetGroupDir(dataGroupID, myCall);
     });
   }
 
-  getGroupDir(dataGroupID: string): Promise<string> {
+  getGroupDirWitdhDataGroupIDReturnsPromise(dataGroupID: string): Promise<string> {
     return new Promise<string>((resolve: (data: string) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<string>((err: BusinessError | null, data: string | undefined) => {
         if (err == null || err.code == 0) {
@@ -126,6 +126,11 @@ export class Context extends BaseContext {
     });
   }
 
+  overload getGroupDir {
+    getGroupDirWitdhDataGroupIDCallback,
+    getGroupDirWitdhDataGroupIDReturnsPromise
+  }
+
   static transferStatic(input: Any): Object {
     let type: string = '';
     try {
diff --git a/frameworks/ets/ets/application/ServiceExtensionContext.ets b/frameworks/ets/ets/application/ServiceExtensionContext.ets
index 2bb11c2f1f5b3dce31fec9f54417d783ffca9de5..28638b5cf03bad3e80c656d8f213da16fc9e819d 100644
--- a/frameworks/ets/ets/application/ServiceExtensionContext.ets
+++ b/frameworks/ets/ets/application/ServiceExtensionContext.ets
@@ -72,14 +72,14 @@ export default class ServiceExtensionContext extends ExtensionContext {
 
   native nativeDisconnectServiceExtensionAbility(connection: long, callback: AsyncCallbackWrapper<void>): void;
 
-  terminateSelf(callback: AsyncCallback<void>): void {
+  terminateSelfWithCallback(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeTerminateSelf(myCall);
     });
   }
 
-  terminateSelf(): Promise<void> {
+  terminateSelfReturnsPromise(): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
@@ -94,14 +94,19 @@ export default class ServiceExtensionContext extends ExtensionContext {
       });
   }
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void {
+  overload terminateSelf {
+    terminateSelfWithCallback,
+    terminateSelfReturnsPromise
+  }
+
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbility(want, myCall);
     });
   }
 
-  startAbility(want: Want, options?: StartOptions): Promise<void> {
+  startAbilityWithWantOptionsReturnsPromise(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -122,14 +127,19 @@ export default class ServiceExtensionContext extends ExtensionContext {
     });
   }
 
-  startServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantOptionsReturnsPromise
+  }
+
+  startServiceExtensionAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartServiceExtensionAbility(want, myCall);
     });
   }
 
-  startServiceExtensionAbility(want: Want): Promise<void> {
+  startServiceExtensionAbilityWithWantReturnsPromise(want: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
@@ -144,14 +154,19 @@ export default class ServiceExtensionContext extends ExtensionContext {
       });
   }
 
-  stopServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
+  overload startServiceExtensionAbility {
+    startServiceExtensionAbilityWithWantCallback,
+    startServiceExtensionAbilityWithWantReturnsPromise
+  }
+
+  stopServiceExtensionAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStopServiceExtensionAbility(want, myCall);
     });
   }
 
-  stopServiceExtensionAbility(want: Want): Promise<void> {
+  stopServiceExtensionAbilityWithWantReturnsPromise(want: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -166,18 +181,23 @@ export default class ServiceExtensionContext extends ExtensionContext {
     });
   }
 
+  overload stopServiceExtensionAbility {
+    stopServiceExtensionAbilityWithWantCallback,
+    stopServiceExtensionAbilityWithWantReturnsPromise
+  }
+
   connectServiceExtensionAbility(want: Want, options: ConnectOptions): long {
     return this.nativeConnectServiceExtensionAbility(want, options);
   }
 
-  disconnectServiceExtensionAbility(connection: long, callback: AsyncCallback<void>): void {
+  disconnectServiceExtensionAbilityWithConnectionCallback(connection: long, callback: AsyncCallback<void>): void {
     let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeDisconnectServiceExtensionAbility(connection, asyncCall);
     });
   }
 
-  disconnectServiceExtensionAbility(connection: long): Promise<void> {
+  disconnectServiceExtensionAbilityWithConnectionReturnsPromise(connection: long): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -191,4 +211,9 @@ export default class ServiceExtensionContext extends ExtensionContext {
       })
     });
   }
+
+  overload disconnectServiceExtensionAbility {
+    disconnectServiceExtensionAbilityWithConnectionCallback,
+    disconnectServiceExtensionAbilityWithConnectionReturnsPromise
+  }
 }
diff --git a/frameworks/ets/ets/application/UIAbilityContext.ets b/frameworks/ets/ets/application/UIAbilityContext.ets
index da67bf4a0968a455ce0ba97ff95005ce4f3555e9..507c0832e5fd021c474eb5678fb677733b9db425 100644
--- a/frameworks/ets/ets/application/UIAbilityContext.ets
+++ b/frameworks/ets/ets/application/UIAbilityContext.ets
@@ -150,21 +150,21 @@ export default class UIAbilityContext extends Context {
 
   private native nativeDisconnectAppServiceExtensionAbility(connection: long, callback: AsyncCallbackWrapper<void>): void;
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void {
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbilitySync(want, myCall);
     });
   }
 
-  startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
+  startAbilityWithWantOptionsCallback(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbilitySync(want, options, myCall);
     });
   }
 
-  startAbility(want: Want, options?: StartOptions): Promise<void> {
+  startAbilityWithWantOptionsReturnsPromise(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -185,21 +185,27 @@ export default class UIAbilityContext extends Context {
     });
   }
 
-  startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantOptionsCallback,
+    startAbilityWithWantOptionsReturnsPromise
+  }
+
+  startAbilityForResultWithWantCallback(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
     let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbilityForResult(want, myCall);
     });
   }
 
-  startAbilityForResult(want: Want, startOptions: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
+  startAbilityForResultWithWantOptionsCallback(want: Want, options: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
     let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, startOptions, myCall);
+      this.nativeStartAbilityForResult(want, options, myCall);
     });
   }
 
-  startAbilityForResult(want: Want, startOptions?: StartOptions): Promise<AbilityResult> {
+  startAbilityForResultWithWantOptionsReturnsPromise(want: Want, options?: StartOptions): Promise<AbilityResult> {
     return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall =
@@ -211,10 +217,10 @@ export default class UIAbilityContext extends Context {
           }
         });
       taskpool.execute((): void => {
-        if (startOptions == null) {
+        if (options == null) {
           this.nativeStartAbilityForResult(want, myCall);
         } else {
-          this.nativeStartAbilityForResult(want, startOptions as StartOptions, myCall);
+          this.nativeStartAbilityForResult(want, options as StartOptions, myCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -222,20 +228,26 @@ export default class UIAbilityContext extends Context {
     });
   }
 
+  overload startAbilityForResult {
+    startAbilityForResultWithWantCallback,
+    startAbilityForResultWithWantOptionsCallback,
+    startAbilityForResultWithWantOptionsReturnsPromise
+  }
+
   startAbilityByCall(want: Want): Promise<Caller> {
     return taskpool.execute((): Caller => {
       return this.nativeStartAbilityByCallSync(want);
     }) as Promise<Caller>;
   }
 
-  terminateSelf(callback: AsyncCallback<void>): void {
+  terminateSelfWithCallback(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeTerminateSelfSync(myCall);
     });
   }
 
-  terminateSelf(): Promise<void> {
+  terminateSelfReturnsPromise(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -252,14 +264,19 @@ export default class UIAbilityContext extends Context {
     return p;
   }
 
-  terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
+  overload terminateSelf {
+    terminateSelfWithCallback,
+    terminateSelfReturnsPromise
+  }
+
+  terminateSelfWithResultWithParameterCallback(parameter: AbilityResult, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeTerminateSelfWithResult(parameter, myCall);
     });
   }
 
-  terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
+  terminateSelfWithResultWithParameterReturnsPromise(parameter: AbilityResult): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
         let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -276,6 +293,11 @@ export default class UIAbilityContext extends Context {
     return p;
   }
 
+  overload terminateSelfWithResult {
+    terminateSelfWithResultWithParameterCallback,
+    terminateSelfWithResultWithParameterReturnsPromise
+  }
+
   reportDrawnCompleted(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
@@ -283,12 +305,12 @@ export default class UIAbilityContext extends Context {
     });
   }
 
-  startServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
+  startServiceExtensionAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     this.nativeStartServiceExtensionAbility(want, myCall);
   }
 
-  startServiceExtensionAbility(want: Want): Promise<void> {
+  startServiceExtensionAbilityWithWantReturnsPromise(want: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined)=>void, reject:(err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -301,6 +323,11 @@ export default class UIAbilityContext extends Context {
     });
   }
 
+  overload startServiceExtensionAbility {
+    startServiceExtensionAbilityWithWantCallback,
+    startServiceExtensionAbilityWithWantReturnsPromise
+  }
+
   openLink(link: string, options?: OpenLinkOptions, callback?: AsyncCallback<AbilityResult, void>): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -339,14 +366,14 @@ export default class UIAbilityContext extends Context {
     });
   }
 
-  requestModalUIExtension(pickerWant: Want, callback: AsyncCallback<void>): void {
+  requestModalUIExtensionWithPickerWantCallback(pickerWant: Want, callback: AsyncCallback<void>): void {
     let syncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeRequestModalUIExtension(pickerWant, syncCall);
     });
   }
 
-  requestModalUIExtension(pickerWant: Want): Promise<void> {
+  requestModalUIExtensionWithPickerWantReturnsPromise(pickerWant: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -361,6 +388,11 @@ export default class UIAbilityContext extends Context {
     });
   }
 
+  overload requestModalUIExtension {
+    requestModalUIExtensionWithPickerWantCallback,
+    requestModalUIExtensionWithPickerWantReturnsPromise
+  }
+
   backToCallerAbilityWithResult(abilityResult: AbilityResult, requestCode: string): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
@@ -376,14 +408,14 @@ export default class UIAbilityContext extends Context {
     });
   }
 
-  setMissionLabel(label: string, callback: AsyncCallback<void>): void {
+  setMissionLabelWithLabelCallback(label: string, callback: AsyncCallback<void>): void {
     let syncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeSetMissionLabel(label, syncCall);
     });
   }
 
-  setMissionLabel(label: string): Promise<void> {
+  setMissionLabelWithLabelReturnsPromise(label: string): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -398,18 +430,23 @@ export default class UIAbilityContext extends Context {
     });
   }
 
+  overload setMissionLabel {
+    setMissionLabelWithLabelCallback,
+    setMissionLabelWithLabelReturnsPromise
+  }
+
   connectServiceExtensionAbility(want: Want, options: ConnectOptions): long {
     return this.nativeConnectServiceExtensionAbility(want, options);
   }
 
-  disconnectServiceExtensionAbility(connection: long, callback: AsyncCallback<void>): void {
+  disconnectServiceExtensionAbilityWithConnectionCallback(connection: long, callback: AsyncCallback<void>): void {
     let syncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeDisconnectServiceExtensionAbility(connection, syncCall);
     });
   }
 
-  disconnectServiceExtensionAbility(connection: long): Promise<void> {
+  disconnectServiceExtensionAbilityWithConnectionReturnsPromise(connection: long): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let callback = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -424,14 +461,19 @@ export default class UIAbilityContext extends Context {
     });
   }
 
+  overload disconnectServiceExtensionAbility {
+    disconnectServiceExtensionAbilityWithConnectionCallback,
+    disconnectServiceExtensionAbilityWithConnectionReturnsPromise
+  }
+
   setColorMode(colorMode: ConfigurationConstant.ColorMode): void {
     this.nativeSetColorMode(colorMode);
   }
 
-  startAbilityByType(type: string, wantParam: Record<string, Object>, startCallback: AbilityStartCallback,
-    callback: AsyncCallback<void>): void {
+  startAbilityByTypeWithTypeWantParamAbilityStartCallbackCallback(type: string, wantParam: Record<string, Object>,
+    abilityStartCallback: AbilityStartCallback, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): BusinessError => {
-      return this.nativeStartAbilityByTypeSync(type, wantParam, startCallback);
+      return this.nativeStartAbilityByTypeSync(type, wantParam, abilityStartCallback);
     });
     p1.then((e: NullishType) => {
       let retError = e as BusinessError;
@@ -479,11 +521,11 @@ hideAbility(): Promise<void> {
   return p;
 }
 
-  startAbilityByType(type: string, wantParam: Record<string, Object>,
-    startCallback: AbilityStartCallback): Promise<void> {
+  startAbilityByTypeWithTypeWantParamAbilityStartCallbackReturnsPromise(type: string, wantParam: Record<string, Object>,
+    abilityStartCallback: AbilityStartCallback): Promise<void> {
     let p = new Promise<void>((resolve: (v: undefined) => void, reject: (error: BusinessError) => void): void => {
       let p1 = taskpool.execute((): BusinessError => {
-        return this.nativeStartAbilityByTypeSync(type, wantParam, startCallback);
+        return this.nativeStartAbilityByTypeSync(type, wantParam, abilityStartCallback);
       });
       p1.then((e: NullishType) => {
         let retError = e as BusinessError;
@@ -499,6 +541,11 @@ hideAbility(): Promise<void> {
     return p;
   }
 
+  overload startAbilityByType {
+    startAbilityByTypeWithTypeWantParamAbilityStartCallbackCallback,
+    startAbilityByTypeWithTypeWantParamAbilityStartCallbackReturnsPromise
+  }
+
   openAtomicService(appId: string, options?: AtomicServiceOptions): Promise<AbilityResult> {
     return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void, reject: (err: BusinessError) => void): void => {
       let asyncCall = new AsyncCallbackWrapper<AbilityResult>((err: BusinessError | null, data: AbilityResult | undefined) => {
diff --git a/frameworks/ets/ets/application/UIExtensionContext.ets b/frameworks/ets/ets/application/UIExtensionContext.ets
index fc684e9764fbdff81c3f0091179c498233cd452a..eea2fee7a37b4fbb43edf49a5bce3cb35275c3e4 100644
--- a/frameworks/ets/ets/application/UIExtensionContext.ets
+++ b/frameworks/ets/ets/application/UIExtensionContext.ets
@@ -65,14 +65,14 @@ export default class UIExtensionContext extends ExtensionContext {
   native setColorMode(colorMode: ConfigurationConstant.ColorMode): void;
   native nativeReportDrawnCompleted(callback:AsyncCallbackWrapper<void>): void;
 
-  terminateSelf(callback:AsyncCallback<void>): void {
+  terminateSelfWithCallback(callback:AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.terminateSelfSync(myCall);
     });
   }
 
-  terminateSelf(): Promise<void> {
+  terminateSelfReturnsPromise(): Promise<void> {
     let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -88,14 +88,19 @@ export default class UIExtensionContext extends ExtensionContext {
     return p;
   }
 
-  terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
+  overload terminateSelf {
+    terminateSelfWithCallback,
+    terminateSelfReturnsPromise
+  }
+
+  terminateSelfWithResultWithParameterCallback(parameter: AbilityResult, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.terminateSelfWithResultSync(parameter, myCall);
     });
   }
 
-  terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
+  terminateSelfWithResultWithParameterReturnsPromise(parameter: AbilityResult): Promise<void> {
     let p = new Promise<void>((resolve: (data: undefined)=>void, reject:(err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -111,21 +116,26 @@ export default class UIExtensionContext extends ExtensionContext {
     return p;
   }
 
-  startAbility(want: Want, callback: AsyncCallback<void>): void {
+  overload terminateSelfWithResult {
+    terminateSelfWithResultWithParameterCallback,
+    terminateSelfWithResultWithParameterReturnsPromise
+  }
+
+  startAbilityWithWantCallback(want: Want, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbility(want, myCall);
     });
   }
 
-  startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
+  startAbilityWithWantOptionsCallback(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbility(want, options, myCall);
     });
   }
 
-  startAbility(want: Want, options?: StartOptions): Promise<void> {
+  startAbilityWithWantOptionsReturnsPromise(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -146,18 +156,24 @@ export default class UIExtensionContext extends ExtensionContext {
     });
   }
 
+  overload startAbility {
+    startAbilityWithWantCallback,
+    startAbilityWithWantOptionsCallback,
+    startAbilityWithWantOptionsReturnsPromise
+  }
+
   connectServiceExtensionAbility(want: Want, options: ConnectOptions): long {
     return this.nativeConnectServiceExtensionAbility(want, options);
   }
 
-  disconnectServiceExtensionAbility(connection: long, callback: AsyncCallback<void>): void {
+  disconnectServiceExtensionAbilityWithConnectionCallback(connection: long, callback: AsyncCallback<void>): void {
     let syncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeDisconnectServiceExtensionAbilitySync(connection, syncCall);
     });
   }
 
-  disconnectServiceExtensionAbility(connection: long): Promise<void> {
+  disconnectServiceExtensionAbilityWithConnectionReturnsPromise(connection: long): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
       let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
@@ -172,21 +188,26 @@ export default class UIExtensionContext extends ExtensionContext {
     });
   }
 
-  startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
+  overload disconnectServiceExtensionAbility {
+    disconnectServiceExtensionAbilityWithConnectionCallback,
+    disconnectServiceExtensionAbilityWithConnectionReturnsPromise
+  }
+
+  startAbilityForResultWithWantCallback(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
     let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
       this.nativeStartAbilityForResult(want, myCall);
     });
   }
 
-  startAbilityForResult(want: Want, startOptions: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
+  startAbilityForResultWithWantOptionsCallback(want: Want, options: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
     let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, startOptions, myCall);
+      this.nativeStartAbilityForResult(want, options, myCall);
     });
   }
 
-  startAbilityForResult(want: Want, startOptions?: StartOptions): Promise<AbilityResult> {
+  startAbilityForResultWithWantOptionsReturnsPromise(want: Want, options?: StartOptions): Promise<AbilityResult> {
     return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void,
       reject: (err: BusinessError) => void): void => {
       let myCall =
@@ -198,10 +219,10 @@ export default class UIExtensionContext extends ExtensionContext {
           }
         });
       taskpool.execute((): void => {
-        if (startOptions == null) {
+        if (options == null) {
           this.nativeStartAbilityForResult(want, myCall);
         } else {
-          this.nativeStartAbilityForResult(want, startOptions as StartOptions, myCall);
+          this.nativeStartAbilityForResult(want, options as StartOptions, myCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -209,6 +230,12 @@ export default class UIExtensionContext extends ExtensionContext {
     });
   }
 
+  overload startAbilityForResult {
+    startAbilityForResultWithWantCallback,
+    startAbilityForResultWithWantOptionsCallback,
+    startAbilityForResultWithWantOptionsReturnsPromise
+  }
+
   reportDrawnCompleted(callback: AsyncCallback<void>): void {
     let myCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {