diff --git a/frameworks/ets/ani/connection/ets/@ohos.net.connection.ets b/frameworks/ets/ani/connection/ets/@ohos.net.connection.ets
index 3f6b4bb590a9f5b3db858b36d49177bf8dcaafce..50f8848682cf68a46673960c8e69cead00075861 100644
--- a/frameworks/ets/ani/connection/ets/@ohos.net.connection.ets
+++ b/frameworks/ets/ani/connection/ets/@ohos.net.connection.ets
@@ -42,7 +42,7 @@ export default namespace connection {
 
   export native function createNetConnection(netSpecifier?: NetSpecifier, timeout?: int): NetConnection;
 
-  export function getDefaultNet(callback: AsyncCallback<NetHandle>): void {
+  export function getDefaultNetWithCallback(callback: AsyncCallback<NetHandle>): void {
     let p1 = taskpool.execute((): NetHandle => {
         return getDefaultNetSync();
     })
@@ -53,7 +53,7 @@ export default namespace connection {
     });
   }
 
-  export function getDefaultNet(): Promise<NetHandle> {
+  export function getDefaultNetReturnsPromise(): Promise<NetHandle> {
       return new Promise<NetHandle>((resolve, reject) => {
           taskpool.execute((): NetHandle => {
               return getDefaultNetSync();
@@ -65,9 +65,11 @@ export default namespace connection {
       });
   }
 
+  export overload getDefaultNet { getDefaultNetWithCallback, getDefaultNetReturnsPromise };
+
   export native function getDefaultNetSync(): NetHandle;
 
-  export function getAllNets(callback: AsyncCallback<Array<NetHandle>>): void {
+  export function getAllNetsWithCallback(callback: AsyncCallback<Array<NetHandle>>): void {
     let p1 = taskpool.execute((): Array<NetHandle> => {
         return getAllNetsSync();
     })
@@ -78,7 +80,7 @@ export default namespace connection {
     });
   }
 
-  export function getAllNets(): Promise<Array<NetHandle>> {
+  export function getAllNetsReturnsPromise(): Promise<Array<NetHandle>> {
     return new Promise<Array<NetHandle>>((resolve, reject) => {
         taskpool.execute((): Array<NetHandle> => {
             return getAllNetsSync();
@@ -90,9 +92,12 @@ export default namespace connection {
     });
   }
 
+  export overload getAllNets { getAllNetsWithCallback, getAllNetsReturnsPromise };
+
   export native function getAllNetsSync(): Array<NetHandle>;
 
-  export function getConnectionProperties(netHandle: NetHandle, callback: AsyncCallback<ConnectionProperties>): void {
+  export function getConnectionPropertiesWithCallback(
+    netHandle: NetHandle, callback: AsyncCallback<ConnectionProperties>): void {
     let p1 = taskpool.execute((): ConnectionProperties => {
         return getConnectionPropertiesSync(netHandle);
     })
@@ -103,7 +108,7 @@ export default namespace connection {
     });
   }
 
-  export function getConnectionProperties(netHandle: NetHandle): Promise<ConnectionProperties> {
+  export function getConnectionPropertiesReturnsPromise(netHandle: NetHandle): Promise<ConnectionProperties> {
     return new Promise<ConnectionProperties>((resolve, reject) => {
         taskpool.execute((): ConnectionProperties => {
             return getConnectionPropertiesSync(netHandle);
@@ -115,9 +120,14 @@ export default namespace connection {
     });
   }
 
+  export overload getConnectionProperties {
+    getConnectionPropertiesWithCallback,
+    getConnectionPropertiesReturnsPromise };
+
   export native function getConnectionPropertiesSync(netHandle: NetHandle): ConnectionProperties;
 
-  export function getNetCapabilities(netHandle: NetHandle, callback: AsyncCallback<NetCapabilities>): void {
+  export function getNetCapabilitiesWithCallback(
+    netHandle: NetHandle, callback: AsyncCallback<NetCapabilities>): void {
     let p1 = taskpool.execute((): NetCapabilities => {
         return getNetCapabilitiesSync(netHandle);
     })
@@ -128,7 +138,7 @@ export default namespace connection {
     });
   }
 
-  export function getNetCapabilities(netHandle: NetHandle): Promise<NetCapabilities> {
+  export function getNetCapabilitiesReturnsPromise(netHandle: NetHandle): Promise<NetCapabilities> {
     return new Promise<NetCapabilities>((resolve, reject) => {
         taskpool.execute((): NetCapabilities => {
             return getNetCapabilitiesSync(netHandle);
@@ -140,6 +150,8 @@ export default namespace connection {
     });
   }
 
+  export overload getNetCapabilities { getNetCapabilitiesWithCallback, getNetCapabilitiesReturnsPromise };
+
   export native function getNetCapabilitiesSync(netHandle: NetHandle): NetCapabilities;
 
   // function setNetExtAttribute(netHandle: NetHandle, netExtAttribute: string): Promise<void>;
@@ -150,7 +162,7 @@ export default namespace connection {
 
   // function getNetExtAttributeSync(netHandle: NetHandle): string;
 
-  export function isDefaultNetMetered(callback: AsyncCallback<boolean>): void {
+  export function isDefaultNetMeteredWithCallback(callback: AsyncCallback<boolean>): void {
     let p1 = taskpool.execute((): boolean => {
         return isDefaultNetMeteredSync();
     })
@@ -161,7 +173,7 @@ export default namespace connection {
     });
   }
 
-  export function isDefaultNetMetered(): Promise<boolean> {
+  export function isDefaultNetMeteredReturnsPromise(): Promise<boolean> {
       return new Promise<boolean>((resolve, reject) => {
         taskpool.execute((): boolean => {
             return isDefaultNetMeteredSync();
@@ -173,9 +185,11 @@ export default namespace connection {
     });
   }
 
+  export overload isDefaultNetMetered { isDefaultNetMeteredWithCallback, isDefaultNetMeteredReturnsPromise };
+
   export native function isDefaultNetMeteredSync(): boolean;
 
-  export function hasDefaultNet(callback: AsyncCallback<boolean>): void {
+  export function hasDefaultNetWithCallback(callback: AsyncCallback<boolean>): void {
     let p1 = taskpool.execute((): boolean => {
         return hasDefaultNetSync();
     })
@@ -186,7 +200,7 @@ export default namespace connection {
     });
   }
 
-  export function hasDefaultNet(): Promise<boolean> {
+  export function hasDefaultNetReturnsPromise(): Promise<boolean> {
     return new Promise<boolean>((resolve, reject) => {
         taskpool.execute((): boolean => {
             return hasDefaultNetSync();
@@ -198,11 +212,13 @@ export default namespace connection {
     });
   }
 
+  export overload hasDefaultNet { hasDefaultNetWithCallback, hasDefaultNetReturnsPromise };
+
   export native function hasDefaultNetSync(): boolean;
 
   export native function enableAirplaneModeSync():void;
 
-  export function enableAirplaneMode(callback: AsyncCallback<void>): void {
+  export function enableAirplaneModeWithCallback(callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
        return enableAirplaneModeSync();
     })
@@ -213,7 +229,7 @@ export default namespace connection {
     });
   }
 
-  export function enableAirplaneMode(): Promise<void> {
+  export function enableAirplaneModeReturnsPromise(): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         taskpool.execute((): undefined => {
           return enableAirplaneModeSync();
@@ -225,9 +241,11 @@ export default namespace connection {
     });
   }
 
+  export overload enableAirplaneMode { enableAirplaneModeWithCallback, enableAirplaneModeReturnsPromise };
+
   export native function disableAirplaneModeSync():void;
 
-  export function disableAirplaneMode(callback: AsyncCallback<void>): void {
+  export function disableAirplaneModeWithCallback(callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
       return disableAirplaneModeSync();
     })
@@ -238,7 +256,7 @@ export default namespace connection {
     });
   }
 
-  export function disableAirplaneMode(): Promise<void> {
+  export function disableAirplaneModeReturnsPromise(): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         taskpool.execute((): undefined => {
           return disableAirplaneModeSync();
@@ -250,7 +268,9 @@ export default namespace connection {
     });
   }
 
-  export function reportNetConnected(netHandle: NetHandle, callback: AsyncCallback<void>): void {
+  export overload disableAirplaneMode { disableAirplaneModeWithCallback, disableAirplaneModeReturnsPromise };
+
+  export function reportNetConnectedWithCallback(netHandle: NetHandle, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
         return reportNetConnectedSync(netHandle);
     })
@@ -261,7 +281,7 @@ export default namespace connection {
     });
   }
 
-  export function reportNetConnected(netHandle: NetHandle): Promise<void> {
+  export function reportNetConnectedReturnsPromise(netHandle: NetHandle): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         taskpool.execute((): undefined => {
             return reportNetConnectedSync(netHandle);
@@ -273,9 +293,11 @@ export default namespace connection {
     });
   }
 
+  export overload reportNetConnected { reportNetConnectedWithCallback, reportNetConnectedReturnsPromise };
+
   export native function reportNetConnectedSync(netHandle: NetHandle): void;
 
-  export function reportNetDisconnected(netHandle: NetHandle, callback: AsyncCallback<void>): void {
+  export function reportNetDisconnectedWithCallback(netHandle: NetHandle, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
        return reportNetDisconnectedSync(netHandle)
     })
@@ -286,7 +308,7 @@ export default namespace connection {
     });
   }
 
-  export function reportNetDisconnected(netHandle: NetHandle): Promise<void> {
+  export function reportNetDisconnectedReturnsPromise(netHandle: NetHandle): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         taskpool.execute((): undefined => {
            return reportNetDisconnectedSync(netHandle);
@@ -298,9 +320,11 @@ export default namespace connection {
     });
   }
 
+  export overload reportNetDisconnected { reportNetDisconnectedWithCallback, reportNetDisconnectedReturnsPromise };
+
   export native function reportNetDisconnectedSync(netHandle: NetHandle): void;
 
-  export function getAddressesByName(host: string, callback: AsyncCallback<Array<NetAddress>>): void{
+  export function getAddressesByNameWithCallback(host: string, callback: AsyncCallback<Array<NetAddress>>): void{
     let p1 = taskpool.execute((): Array<NetAddress> => {
         return getAddressesByNameSync(host);
     })
@@ -311,7 +335,7 @@ export default namespace connection {
     });
   }
 
-  export function getAddressesByName(host: string): Promise<Array<NetAddress>> {
+  export function getAddressesByNameReturnsPromise(host: string): Promise<Array<NetAddress>> {
     return new Promise<Array<NetAddress>>((resolve, reject) => {
         taskpool.execute((): Array<NetAddress> => {
             return getAddressesByNameSync(host);
@@ -323,9 +347,11 @@ export default namespace connection {
     });
   }
 
+  export overload getAddressesByName { getAddressesByNameWithCallback, getAddressesByNameReturnsPromise };
+
   export native function getAddressesByNameSync(host: string): Array<NetAddress>;
 
-  export function getAppNet(callback: AsyncCallback<NetHandle>): void {
+  export function getAppNetWithCallback(callback: AsyncCallback<NetHandle>): void {
     let p1 = taskpool.execute((): NetHandle => {
         return getAppNetSync();
     })
@@ -336,7 +362,7 @@ export default namespace connection {
     });
   }
 
-  export function getAppNet(): Promise<NetHandle> {
+  export function getAppNetReturnsPromise(): Promise<NetHandle> {
     return new Promise<NetHandle>((resolve, reject) => {
       taskpool.execute((): NetHandle => {
           return getAppNetSync();
@@ -348,9 +374,11 @@ export default namespace connection {
     });
   }
 
+  export overload getAppNet { getAppNetWithCallback, getAppNetReturnsPromise };
+
   export native function getAppNetSync(): NetHandle;
 
-  export function setAppNet(netHandle: NetHandle, callback: AsyncCallback<void>): void {
+  export function setAppNetWithCallback(netHandle: NetHandle, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
         return setAppNetSync(netHandle);
     })
@@ -361,7 +389,7 @@ export default namespace connection {
     });
   }
 
-  export function setAppNet(netHandle: NetHandle): Promise<void> {
+  export function setAppNetReturnsPromise(netHandle: NetHandle): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       taskpool.execute((): undefined => {
           return setAppNetSync(netHandle);
@@ -373,9 +401,11 @@ export default namespace connection {
     });
   }
 
+  export overload setAppNet { setAppNetWithCallback, setAppNetReturnsPromise };
+
   export native function setAppNetSync(netHandle: NetHandle): void;
 
-  function getDefaultHttpProxy(callback: AsyncCallback<HttpProxy>): void {
+  function getDefaultHttpProxyWithCallback(callback: AsyncCallback<HttpProxy>): void {
     let p1 = taskpool.execute((): HttpProxy => {
         return getDefaultHttpProxySync();
     })
@@ -386,7 +416,7 @@ export default namespace connection {
     });
   }
 
-  function getDefaultHttpProxy(): Promise<HttpProxy> {
+  function getDefaultHttpProxyReturnsPromise(): Promise<HttpProxy> {
     return new Promise<HttpProxy>((resolve, reject) => {
         taskpool.execute((): HttpProxy => {
             return getDefaultHttpProxySync();
@@ -398,9 +428,11 @@ export default namespace connection {
     });
   }
 
+  overload getDefaultHttpProxy { getDefaultHttpProxyWithCallback, getDefaultHttpProxyReturnsPromise };
+
   export native function getDefaultHttpProxySync(): HttpProxy;
 
-  export function getGlobalHttpProxy(callback: AsyncCallback<HttpProxy>): void {
+  export function getGlobalHttpProxyWithCallback(callback: AsyncCallback<HttpProxy>): void {
     let p1 = taskpool.execute((): HttpProxy => {
         return getGlobalHttpProxySync();
     })
@@ -411,7 +443,7 @@ export default namespace connection {
     });
   }
 
-  export function getGlobalHttpProxy(): Promise<HttpProxy> {
+  export function getGlobalHttpProxyReturnsPromise(): Promise<HttpProxy> {
     return new Promise<HttpProxy>((resolve, reject) => {
         taskpool.execute((): HttpProxy => {
             return getGlobalHttpProxySync();
@@ -423,11 +455,13 @@ export default namespace connection {
     });
   }
 
+  export overload getGlobalHttpProxy { getGlobalHttpProxyWithCallback, getGlobalHttpProxyReturnsPromise };
+
   export native function getGlobalHttpProxySync(): HttpProxy;
 
   export native function setAppHttpProxy(httpProxy: HttpProxy): void;
 
-  export function setGlobalHttpProxy(httpProxy: HttpProxy, callback: AsyncCallback<void>): void {
+  export function setGlobalHttpProxyWithCallback(httpProxy: HttpProxy, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
         return setGlobalHttpProxySync(httpProxy);
     })
@@ -438,7 +472,7 @@ export default namespace connection {
     });
   }
 
-  export function setGlobalHttpProxy(httpProxy: HttpProxy): Promise<void> {
+  export function setGlobalHttpProxyReturnsPromise(httpProxy: HttpProxy): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       taskpool.execute((): undefined => {
           return setGlobalHttpProxySync(httpProxy);
@@ -450,13 +484,15 @@ export default namespace connection {
     });
   }
 
+  export overload setGlobalHttpProxy { setGlobalHttpProxyWithCallback, setGlobalHttpProxyReturnsPromise };
+
   export native function setGlobalHttpProxySync(httpProxy: HttpProxy): void;
 
   export native function setPacUrl(pacUrl: string): void;
 
   export native function getPacUrl(): string;
 
-  export function addCustomDnsRule(host: string, ip: Array<string>, callback: AsyncCallback<void>): void {
+  export function addCustomDnsRuleWithCallback(host: string, ip: Array<string>, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
          return addCustomDnsRuleSync(host ,ip);
     })
@@ -467,7 +503,7 @@ export default namespace connection {
     });
   }
 
-  export function addCustomDnsRule(host: string, ip: Array<string>): Promise<void> {
+  export function addCustomDnsRuleReturnsPromise(host: string, ip: Array<string>): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       taskpool.execute((): undefined => {
           return addCustomDnsRuleSync(host, ip);
@@ -479,9 +515,11 @@ export default namespace connection {
     });
   }
 
+  export overload addCustomDnsRule { addCustomDnsRuleWithCallback, addCustomDnsRuleReturnsPromise };
+
   export native function addCustomDnsRuleSync(host: string, ip: Array<string>): void;
 
-  export function removeCustomDnsRule(host: string, callback: AsyncCallback<void>): void {
+  export function removeCustomDnsRuleWithCallback(host: string, callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
         return removeCustomDnsRuleSync(host);
     })
@@ -492,7 +530,7 @@ export default namespace connection {
     });
   }
 
-  export function removeCustomDnsRule(host: string): Promise<void> {
+  export function removeCustomDnsRuleReturnsPromise(host: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       taskpool.execute((): undefined => {
           return removeCustomDnsRuleSync(host)
@@ -504,9 +542,11 @@ export default namespace connection {
     });
   }
 
+  export overload removeCustomDnsRule { removeCustomDnsRuleWithCallback, removeCustomDnsRuleReturnsPromise };
+
   export native function removeCustomDnsRuleSync(host:string): void;
 
-  export function clearCustomDnsRules(callback: AsyncCallback<void>): void {
+  export function clearCustomDnsRulesWithCallback(callback: AsyncCallback<void>): void {
     let p1 = taskpool.execute((): undefined => {
          return clearCustomDnsRulesSync();
     })
@@ -517,7 +557,7 @@ export default namespace connection {
     });
   }
 
-  export function clearCustomDnsRules(): Promise<void> {
+  export function clearCustomDnsRulesReturnsPromise(): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       taskpool.execute((): undefined => {
           return clearCustomDnsRulesSync();
@@ -529,6 +569,8 @@ export default namespace connection {
     });
   }
 
+  export overload clearCustomDnsRules { clearCustomDnsRulesWithCallback, clearCustomDnsRulesReturnsPromise };
+
   export native function clearCustomDnsRulesSync(): void;
 
   export native function factoryResetSync():void;
@@ -546,7 +588,22 @@ export default namespace connection {
   }
 
   export interface NetConnection {
-      on(type: string, callback: Object): void;
+      onNetAvailableWithCallback(type: 'netAvailable', callback: Callback<NetHandle>): void;
+
+      onNetBlockStatusChangeWithCallback(type: 'netBlockStatusChange', callback: Callback<NetBlockStatusInfo>): void;
+
+      onNetCapabilitiesChangeWithCallback(type: 'netCapabilitiesChange', callback: Callback<NetCapabilityInfo>): void;
+
+      onNetConnectionPropertiesChangeWithCallback(
+        type: 'netConnectionPropertiesChange', callback: Callback<NetConnectionPropertyInfo>): void;
+
+      onNetLostWithCallback(type: 'netLost', callback: Callback<NetHandle>): void;
+
+      onNetUnavailableWithCallback(type: 'netUnavailable', callback: Callback<void>): void;
+
+      overload on { onNetAvailableWithCallback, onNetBlockStatusChangeWithCallback,
+        onNetCapabilitiesChangeWithCallback, onNetConnectionPropertiesChangeWithCallback,
+        onNetLostWithCallback, onNetUnavailableWithCallback };
 
       register(callback: AsyncCallback<void>): void;
 
@@ -572,20 +629,46 @@ export default namespace connection {
         destroyRegister.unregister(unregisterToken);
     }
 
-    on(type: string, callback: Object): void {
-      if (type == 'netAvailable') {
-        this.onNetAvailable(callback as Callback<NetHandle>);
-      } else if (type == 'netBlockStatusChange') {
-        this.onNetBlockStatusChange(callback as Callback<NetBlockStatusInfo>);
-      } else if (type == 'netCapabilitiesChange') {
-        this.onNetCapabilitiesChange(callback as Callback<NetCapabilityInfo>);
-      } else if (type == 'netConnectionPropertiesChange') {
-        this.onNetConnectionPropertiesChange(callback as Callback<NetConnectionPropertyInfo>);
-      } else if (type == 'netLost') {
-        this.onNetLost(callback as Callback<NetHandle>);
-      } else if (type == 'netUnavailable') {
-        this.onNetUnavailable(callback as Callback<void>);
+    onNetAvailableWithCallback(type: 'netAvailable', callback: Callback<NetHandle>): void {
+      if (type != 'netAvailable') {
+        throw new Error('Invalid event type: ' + type);
+      }
+      this.onNetAvailable(callback as Callback<NetHandle>);
+    }
+
+    onNetBlockStatusChangeWithCallback(type: 'netBlockStatusChange', callback: Callback<NetBlockStatusInfo>): void {
+      if (type != 'netBlockStatusChange') {
+        throw new Error('Invalid event type: ' + type);
+      }
+      this.onNetBlockStatusChange(callback as Callback<NetBlockStatusInfo>);
+    }
+
+    onNetCapabilitiesChangeWithCallback(type: 'netCapabilitiesChange', callback: Callback<NetCapabilityInfo>): void {
+      if (type != 'netCapabilitiesChange') {
+        throw new Error('Invalid event type: ' + type);
       }
+      this.onNetCapabilitiesChange(callback as Callback<NetCapabilityInfo>);
+    }
+
+    onNetConnectionPropertiesChangeWithCallback(type: 'netConnectionPropertiesChange', callback: Callback<NetConnectionPropertyInfo>): void {
+      if (type != 'netConnectionPropertiesChange') {
+        throw new Error('Invalid event type: ' + type);
+      }
+      this.onNetConnectionPropertiesChange(callback as Callback<NetConnectionPropertyInfo>);
+    }
+
+    onNetLostWithCallback(type: 'netLost', callback: Callback<NetHandle>): void {
+      if (type != 'netLost') {
+        throw new Error('Invalid event type: ' + type);
+      }
+      this.onNetLost(callback as Callback<NetHandle>);
+    }
+
+    onNetUnavailableWithCallback(type: 'netUnavailable', callback: Callback<void>): void {
+      if (type != 'netUnavailable') {
+        throw new Error('Invalid event type: ' + type);
+      }
+      this.onNetUnavailable(callback as Callback<void>);
     }
 
     native onNetAvailable(callback: Callback<NetHandle>):void;
@@ -644,9 +727,11 @@ export default namespace connection {
 
     // getAddressesByName(host: string): Promise<Array<NetAddress>>;
 
-    getAddressByName(host: string, callback: AsyncCallback<NetAddress>): void;
+    getAddressByNameWithCallback(host: string, callback: AsyncCallback<NetAddress>): void;
+
+    getAddressByNameReturnsPromise(host: string): Promise<NetAddress>;
 
-    getAddressByName(host: string): Promise<NetAddress>;
+    overload getAddressByName { getAddressByNameWithCallback, getAddressByNameReturnsPromise };
   }
 
   export class NetHandleInner implements NetHandle{
@@ -655,7 +740,7 @@ export default namespace connection {
 
     native getAddressByNameSync(host:string): NetAddress;
 
-    getAddressByName(host: string, callback: AsyncCallback<NetAddress>): void {
+    getAddressByNameWithCallback(host: string, callback: AsyncCallback<NetAddress>): void {
       let p1 = taskpool.execute((): NetAddress => {
         return this.getAddressByNameSync(host);
       })
@@ -666,7 +751,7 @@ export default namespace connection {
       });
     }
 
-    getAddressByName(host: string): Promise<NetAddress> {
+    getAddressByNameReturnsPromise(host: string): Promise<NetAddress> {
       return new Promise<NetAddress>((resolve, reject) => {
         taskpool.execute((): NetAddress => {
             return this.getAddressByNameSync(host);
diff --git a/frameworks/ets/ani/statistics/ets/@ohos.net.statistics.d.ets b/frameworks/ets/ani/statistics/ets/@ohos.net.statistics.d.ets
index 5823cdbf6a8f9588be863e9c8fc9d4b6ac08671b..04460d7742e94acb0c376f52de2d5855d8550ef6 100644
--- a/frameworks/ets/ani/statistics/ets/@ohos.net.statistics.d.ets
+++ b/frameworks/ets/ani/statistics/ets/@ohos.net.statistics.d.ets
@@ -25,7 +25,7 @@ export default namespace statistics {
 
   export native function getIfaceRxBytesSync(nic: string): long;
 
-  function getIfaceRxBytes(nic: string, callback: AsyncCallback<long>): void {
+  function getIfaceRxBytesWithCallback(nic: string, callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getIfaceRxBytesSync(nic);
       })
@@ -36,7 +36,7 @@ export default namespace statistics {
       });
   }
 
-  function getIfaceRxBytes(nic: string): Promise<long> {
+  function getIfaceRxBytesReturnsPromise(nic: string): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getIfaceRxBytesSync(nic);
@@ -48,9 +48,11 @@ export default namespace statistics {
   });
   }
 
+  overload getIfaceRxBytes { getIfaceRxBytesWithCallback, getIfaceRxBytesReturnsPromise };
+
   export native function getIfaceTxBytesSync(nic: string): long;
 
-  function getIfaceTxBytes(nic: string, callback: AsyncCallback<long>): void {
+  function getIfaceTxBytesWithCallback(nic: string, callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getIfaceTxBytesSync(nic);
       })
@@ -61,7 +63,7 @@ export default namespace statistics {
       });
   }
 
-  function getIfaceTxBytes(nic: string): Promise<long> {
+  function getIfaceTxBytesReturnsPromise(nic: string): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getIfaceTxBytesSync(nic);
@@ -73,9 +75,11 @@ export default namespace statistics {
   });
   }
 
+  overload getIfaceTxBytes { getIfaceTxBytesWithCallback, getIfaceTxBytesReturnsPromise };
+
   export native function getCellularRxBytesSync(): long;
 
-  function getCellularRxBytes(callback: AsyncCallback<long>): void {
+  function getCellularRxBytesWithCallback(callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getCellularRxBytesSync();
       })
@@ -86,7 +90,7 @@ export default namespace statistics {
       });
   }
 
-  function getCellularRxBytes(): Promise<long> {
+  function getCellularRxBytesReturnsPromise(): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getCellularRxBytesSync();
@@ -98,9 +102,11 @@ export default namespace statistics {
   });
   }
 
+  overload getCellularRxBytes { getCellularRxBytesWithCallback, getCellularRxBytesReturnsPromise };
+
   export native function getCellularTxBytesSync(): long;
 
-  function getCellularTxBytes(callback: AsyncCallback<long>): void {
+  function getCellularTxBytesWithCallback(callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getCellularTxBytesSync();
       })
@@ -111,7 +117,7 @@ export default namespace statistics {
       });
   }
 
-  function getCellularTxBytes(): Promise<long> {
+  function getCellularTxBytesReturnsPromise(): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getCellularTxBytesSync();
@@ -123,9 +129,11 @@ export default namespace statistics {
   });
   }
 
+  overload getCellularTxBytes { getCellularTxBytesWithCallback, getCellularTxBytesReturnsPromise };
+
   export native function getAllRxBytesSync(): long;
 
-  function getAllRxBytes(callback: AsyncCallback<long>): void {
+  function getAllRxBytesWithCallback(callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getAllRxBytesSync();
       })
@@ -136,7 +144,7 @@ export default namespace statistics {
       });
   }
 
-  function getAllRxBytes(): Promise<long> {
+  function getAllRxBytesReturnsPromise(): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getAllRxBytesSync();
@@ -148,9 +156,11 @@ export default namespace statistics {
   });
   }
 
+  overload getAllRxBytes { getAllRxBytesWithCallback, getAllRxBytesReturnsPromise };
+
   export native function getAllTxBytesSync(): long;
 
-  function getAllTxBytes(callback: AsyncCallback<long>): void {
+  function getAllTxBytesWithCallback(callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getAllTxBytesSync();
       })
@@ -161,7 +171,7 @@ export default namespace statistics {
       });
   }
 
-  function getAllTxBytes(): Promise<long> {
+  function getAllTxBytesReturnsPromise(): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getAllTxBytesSync();
@@ -173,9 +183,11 @@ export default namespace statistics {
   });
   }
 
+  overload getAllTxBytes { getAllTxBytesWithCallback, getAllTxBytesReturnsPromise };
+
   export native function getUidRxBytesSync(uid: long): long;
 
-  function getUidRxBytes(uid: long, callback: AsyncCallback<long>): void {
+  function getUidRxBytesWithCallback(uid: long, callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getUidRxBytesSync(uid);
       })
@@ -186,7 +198,7 @@ export default namespace statistics {
       });
   }
 
-  function getUidRxBytes(uid: long): Promise<long> {
+  function getUidRxBytesReturnsPromise(uid: long): Promise<long> {
       return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getUidRxBytesSync(uid);
@@ -198,9 +210,11 @@ export default namespace statistics {
   });
   }
 
+  overload getUidRxBytes { getUidRxBytesWithCallback, getUidRxBytesReturnsPromise };
+
   export native function getUidTxBytesSync(uid: long): long;
 
-  function getUidTxBytes(uid: long, callback: AsyncCallback<long>): void {
+  function getUidTxBytesWithCallback(uid: long, callback: AsyncCallback<long>): void {
       let p1 = taskpool.execute((): long => {
           return getUidTxBytesSync(uid);
       })
@@ -211,7 +225,7 @@ export default namespace statistics {
       });
   }
 
-  function getUidTxBytes(uid: long): Promise<long> {
+  function getUidTxBytesReturnsPromise(uid: long): Promise<long> {
       return new Promise<long>((resolve, reject) => {
         taskpool.execute((): long => {
         return getUidTxBytesSync(uid);
@@ -223,6 +237,8 @@ export default namespace statistics {
     });
   }
 
+  overload getUidTxBytes { getUidTxBytesWithCallback, getUidTxBytesReturnsPromise };
+
   // function on(type: 'netStatsChange', callback: Callback<NetStatsChangeInfo>): void;
 
   // function off(type: 'netStatsChange', callback?: Callback<NetStatsChangeInfo>): void;
@@ -237,7 +253,7 @@ export default namespace statistics {
 
   export native function getSockfdRxBytesSync(sockfd: int): long;
 
-  function getSockfdRxBytes(sockfd: int, callback: AsyncCallback<long>): void {
+  function getSockfdRxBytesWithCallback(sockfd: int, callback: AsyncCallback<long>): void {
     let p1 = taskpool.execute((): long => {
         return getSockfdRxBytesSync(sockfd);
     })
@@ -248,7 +264,7 @@ export default namespace statistics {
     });
   }
 
-  function getSockfdRxBytes(sockfd: int): Promise<long> {
+  function getSockfdRxBytesReturnsPromise(sockfd: int): Promise<long> {
     return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getSockfdRxBytesSync(sockfd);
@@ -260,9 +276,11 @@ export default namespace statistics {
     });
   }
 
+  overload getSockfdRxBytes { getSockfdRxBytesWithCallback, getSockfdRxBytesReturnsPromise };
+
   export native function getSockfdTxBytesSync(sockfd: int): long;
 
-  function getSockfdTxBytes(sockfd: int, callback: AsyncCallback<long>): void {
+  function getSockfdTxBytesWithCallback(sockfd: int, callback: AsyncCallback<long>): void {
     let p1 = taskpool.execute((): long => {
         return getSockfdTxBytesSync(sockfd);
     })
@@ -273,7 +291,7 @@ export default namespace statistics {
     });
   }
 
-  function getSockfdTxBytes(sockfd: int): Promise<long> {
+  function getSockfdTxBytesReturnsPromise(sockfd: int): Promise<long> {
     return new Promise<long>((resolve, reject) => {
           taskpool.execute((): long => {
           return getSockfdTxBytesSync(sockfd);
@@ -285,6 +303,8 @@ export default namespace statistics {
     });
   }
 
+  overload getSockfdTxBytes { getSockfdTxBytesWithCallback, getSockfdTxBytesReturnsPromise };
+
   export interface IfaceInfo {
     iface: string;