diff --git a/interfaces/kits/ani/printani/ets/@ohos.print.ets b/interfaces/kits/ani/printani/ets/@ohos.print.ets
index a63f53553077fdaf1a7a67b3afc00318b4a32781..eb435040faf091e21903ccee5a935ddb408fb646 100644
--- a/interfaces/kits/ani/printani/ets/@ohos.print.ets
+++ b/interfaces/kits/ani/printani/ets/@ohos.print.ets
@@ -547,14 +547,17 @@ export default namespace print {
         }
     }
 
-    export function print(files: Array<string>, callback: AsyncCallback<PrintTask, void>): void {
+    export overload print { printWithCallback, printReturnsPromise, printWithContextCallbackOfPrintTask, 
+                printWithContextReturnsPromise,printWithJobNameReturnsPromise }
+
+    export function printWithCallback(files: Array<string>, callback: AsyncCallback<PrintTask, void>): void {
         let myCall = new AsyncCallbackWrapper<PrintTask>(callback);
         taskpool.execute((): void => {
             printNative(files, myCall);
         })
     }
 
-    export function print(files: Array<string>): Promise<PrintTask> {
+    export function printReturnsPromise(files: Array<string>): Promise<PrintTask> {
         let p:Promise<PrintTask> =
             new Promise<PrintTask>((resolve: (data: PrintTask | undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<PrintTask>((err: BusinessError<void> | null, data: PrintTask | undefined)=>{
@@ -571,14 +574,14 @@ export default namespace print {
         return p;
     }
 
-    export function print(files: Array<string>, context: Context, callback: AsyncCallback<PrintTask>): void {
+    export function printWithContextCallbackOfPrintTask(files: Array<string>, context: Context, callback: AsyncCallback<PrintTask>): void {
         let myCall = new AsyncCallbackWrapper<PrintTask>(callback);
         taskpool.execute((): void => {
             printWithContextNative(files, context, myCall);
         })
     }
 
-    export function print(files: Array<string>, context: Context): Promise<PrintTask> {
+    export function printWithContextReturnsPromise(files: Array<string>, context: Context): Promise<PrintTask> {
         let p:Promise<PrintTask> =
             new Promise<PrintTask>((resolve: (data: PrintTask | undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<PrintTask>((err: BusinessError<void> | null, data: PrintTask | undefined)=>{
@@ -595,7 +598,7 @@ export default namespace print {
         return p;
     }
 
-    export function print(jobName: string, printAdapter: PrintDocumentAdapter, printAttributes: PrintAttributes,
+    export function printWithJobNameReturnsPromise(jobName: string, printAdapter: PrintDocumentAdapter, printAttributes: PrintAttributes,
     context: Context): Promise<PrintTask> {
         let p:Promise<PrintTask> =
             new Promise<PrintTask>((resolve: (data: PrintTask | undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
@@ -619,14 +622,16 @@ export default namespace print {
         return p;
     }
 
-    export function queryAllPrinterExtensionInfos(callback: AsyncCallback<Array<PrinterExtensionInfo>>): void {
+    export overload queryallprinterextensioninfos { queryAllPrinterExtensionInfosWithCallback, queryAllPrinterExtensionInfosReturnsPromise }
+
+    export function queryAllPrinterExtensionInfosWithCallback(callback: AsyncCallback<Array<PrinterExtensionInfo>>): void {
         let myCall = new AsyncCallbackArrayWrapper<PrinterExtensionInfo>(callback);
         taskpool.execute((): void => {
             queryAllPrinterExtensionInfosNative(myCall);
         })
     }
 
-    export function queryAllPrinterExtensionInfos(): Promise<Array<PrinterExtensionInfo>> {
+    export function queryAllPrinterExtensionInfosReturnsPromise(): Promise<Array<PrinterExtensionInfo>> {
         let p:Promise<Array<PrinterExtensionInfo>> =
             new Promise<Array<PrinterExtensionInfo>>((resolve: (data: Array<PrinterExtensionInfo> | undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackArrayWrapper<PrinterExtensionInfo>((err: BusinessError<void> | null, data: Array<PrinterExtensionInfo> | undefined)=>{
@@ -643,14 +648,16 @@ export default namespace print {
         return p;
     }
 
-    export function startDiscoverPrinter(extensionList: Array<string>, callback: AsyncCallback<void>): void {
+    export overload startdiscoverprinter { startDiscoverPrinterWithCallback, startDiscoverPrinterReturnsPromise }
+
+    export function startDiscoverPrinterWithCallback(extensionList: Array<string>, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             startDiscoverPrinterNative(extensionList, myCall);
         });
     }
 
-    export function startDiscoverPrinter(extensionList: Array<string>): Promise<void> {
+    export function startDiscoverPrinterReturnsPromise(extensionList: Array<string>): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -666,14 +673,16 @@ export default namespace print {
         });
     }
 
-    export function stopDiscoverPrinter(callback: AsyncCallback<void>): void {
+    export overload stopdiscoverprinter { stopDiscoverPrinterWithCallback, stopDiscoverPrinterReturnsPromise }
+
+    export function stopDiscoverPrinterWithCallback(callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             stopDiscoverPrinterNative(myCall);
         });
     }
 
-    export function stopDiscoverPrinter(): Promise<void> {
+    export function stopDiscoverPrinterReturnsPromise(): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -688,14 +697,16 @@ export default namespace print {
         });
     }
 
-    export function connectPrinter(printerId: string, callback: AsyncCallback<void>): void {
+    export overload connectprinter { connectPrinterWithCallback, connectPrinterReturnsPromise }
+
+    export function connectPrinterWithCallback(printerId: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             connectPrinterNative(printerId, myCall);
         });
     }
 
-    export function connectPrinter(printerId: string): Promise<void> {
+    export function connectPrinterReturnsPromise(printerId: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -710,14 +721,16 @@ export default namespace print {
         });
     }
 
-    export function disconnectPrinter(printerId: string, callback: AsyncCallback<void>): void {
+    export overload disconnectprinter { disconnectPrinterWithCallback, disconnectPrinterReturnsPromise }
+
+    export function disconnectPrinterWithCallback(printerId: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             disconnectPrinterNative(printerId, myCall);
         });
     }
 
-    export function disconnectPrinter(printerId: string): Promise<void> {
+    export function disconnectPrinterReturnsPromise(printerId: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -732,14 +745,16 @@ export default namespace print {
         });
     }
 
-    export function queryPrinterCapability(printerId: string, callback: AsyncCallback<void>): void {
+    export overload queryprintercapability { queryPrinterCapabilityWithCallback, queryPrinterCapabilityReturnsPromise }
+
+    export function queryPrinterCapabilityWithCallback(printerId: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             queryPrinterCapabilityNative(printerId, myCall);
         });
     }
 
-    export function queryPrinterCapability(printerId: string): Promise<void> {
+    export function queryPrinterCapabilityReturnsPromise(printerId: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -754,14 +769,16 @@ export default namespace print {
         });
     }
 
-    export function startPrintJob(jobInfo: PrintJob, callback: AsyncCallback<void>): void {
+    export overload startprintjob { startPrintJobWithCallback, startPrintJobReturnsPromise}
+
+    export function startPrintJobWithCallback(jobInfo: PrintJob, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             startPrintJobNative(jobInfo, myCall);
         });
     }
 
-    export function startPrintJob(jobInfo: PrintJob): Promise<void> {
+    export function startPrintJobReturnsPromise(jobInfo: PrintJob): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -776,14 +793,16 @@ export default namespace print {
         });
     }
 
-    export function cancelPrintJob(jobId: string, callback: AsyncCallback<void>): void {
+    export overload cancelprintjob { cancelPrintJobWithCallback, cancelPrintJobReturnsPromise }
+
+    export function cancelPrintJobWithCallback(jobId: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             cancelPrintJobNative(jobId, myCall);
         });
     }
 
-    export function cancelPrintJob(jobId: string): Promise<void> {
+    export function cancelPrintJobReturnsPromise(jobId: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -798,14 +817,16 @@ export default namespace print {
         });
     }
 
-    export function requestPrintPreview(jobInfo: PrintJob, callback: Callback<int>): void {
+    export overload requestprintpreview { requestPrintPreviewWithCallback, requestPrintPreviewReturnsPromise }
+
+    export function requestPrintPreviewWithCallback(jobInfo: PrintJob, callback: Callback<int>): void {
         let myCall = new CallbackWrapper<int>(callback);
         taskpool.execute((): void => {
             requestPrintPreviewCallbackNative(jobInfo, myCall);
         });
     }
 
-    export function requestPrintPreview(jobInfo: PrintJob): Promise<int> {
+    export function requestPrintPreviewReturnsPromise(jobInfo: PrintJob): Promise<int> {
         return new Promise<int>((resolve: (data:int | undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<int>((err, data) => {
                 if (err === null || err.code == 0) {
@@ -902,14 +923,16 @@ export default namespace print {
         });
     }
 
-    export function addPrinters(printers: Array<PrinterInfo>, callback: AsyncCallback<void>): void {
+    export overload addprinters { addPrintersWithCallback, addPrintersReturnsPromise }
+
+    export function addPrintersWithCallback(printers: Array<PrinterInfo>, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             addPrintersNative(printers, myCall);
         });
     }
 
-    export function addPrinters(printers: Array<PrinterInfo>): Promise<void> {
+    export function addPrintersReturnsPromise(printers: Array<PrinterInfo>): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -924,14 +947,16 @@ export default namespace print {
         });
     }
 
-    export function removePrinters(printerIds: Array<string>, callback: AsyncCallback<void>): void {
+    export overload removeprinters { removePrintersWithCallback, removePrintersReturnsPromise }
+
+    export function removePrintersWithCallback(printerIds: Array<string>, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             removePrintersNative(printerIds, myCall);
         });
     }
 
-    export function removePrinters(printerIds: Array<string>): Promise<void> {
+    export function removePrintersReturnsPromise(printerIds: Array<string>): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -946,14 +971,16 @@ export default namespace print {
         });
     }
 
-    export function updatePrinters(printers: Array<PrinterInfo>, callback: AsyncCallback<void>): void {
+    export overload updateprinters { updatePrintersWithCallback, updatePrintersReturnsPromise }
+
+    export function updatePrintersWithCallback(printers: Array<PrinterInfo>, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             updatePrintersNative(printers, myCall);
         });
     }
 
-    export function updatePrinters(printers: Array<PrinterInfo>): Promise<void> {
+    export function updatePrintersReturnsPromise(printers: Array<PrinterInfo>): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -968,14 +995,16 @@ export default namespace print {
         });
     }
 
-    export function updatePrinterState(printerId: string, state: PrinterState, callback: AsyncCallback<void>): void {
+    export overload updateprinterstate { updatePrinterStateWithCallback, updatePrinterStateReturnsPromise }
+
+    export function updatePrinterStateWithCallback(printerId: string, state: PrinterState, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             updatePrinterStateNative(printerId, state, myCall);
         });
     }
 
-    export function updatePrinterState(printerId: string, state: PrinterState): Promise<void> {
+    export function updatePrinterStateReturnsPromise(printerId: string, state: PrinterState): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -990,14 +1019,16 @@ export default namespace print {
         });
     }
 
-    export function updatePrintJobState(jobId: string, state: PrintJobState, subState: PrintJobSubState, callback: AsyncCallback<void>): void {
+    export overload updateprintjobstate { updatePrintJobStateWithCallback, updatePrintJobStateReturnsPromise }
+
+    export function updatePrintJobStateWithCallback(jobId: string, state: PrintJobState, subState: PrintJobSubState, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             updatePrintJobStateNative(jobId, state, subState, myCall);
         });
     }
 
-    export function updatePrintJobState(jobId: string, state: PrintJobState, subState: PrintJobSubState): Promise<void> {
+    export function updatePrintJobStateReturnsPromise(jobId: string, state: PrintJobState, subState: PrintJobSubState): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -1012,14 +1043,16 @@ export default namespace print {
         });
     }
 
-    export function updateExtensionInfo(info: string, callback: AsyncCallback<void>): void {
+    export overload updateextensioninfo { updateExtensionInfoWithCallback, updateExtensionInfoReturnsPromise }
+
+    export function updateExtensionInfoWithCallback(info: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             updateExtensionInfoNative(info, myCall);
         });
     }
 
-    export function updateExtensionInfo(info: string): Promise<void> {
+    export function updateExtensionInfoReturnsPromise(info: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -1034,14 +1067,16 @@ export default namespace print {
         });
     }
 
-    export function queryAllPrintJobs(callback: AsyncCallback<void>): void {
+    export overload queryAllPrintJobs { queryAllPrintJobsWithCallback, queryAllPrintJobsReturnsPromise }
+
+    export function queryAllPrintJobsWithCallback(callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             queryAllPrintJobsNative(myCall);
         });
     }
 
-    export function queryAllPrintJobs(): Promise<void> {
+    export function queryAllPrintJobsReturnsPromise(): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {
@@ -1056,14 +1091,16 @@ export default namespace print {
         });
     }
 
-    export function queryPrintJobList(callback: AsyncCallback<Array<PrintJob>>): void {
+    export overload queryprintjoblist { queryPrintJobListWithCallback, queryPrintJobListReturnsPromise }
+
+    export function queryPrintJobListWithCallback(callback: AsyncCallback<Array<PrintJob>>): void {
         let myCall = new AsyncCallbackArrayWrapper<PrintJob>(callback);
         taskpool.execute((): void => {
             queryPrintJobListNative(myCall);
         });
     }
 
-    export function queryPrintJobList(): Promise<Array<PrintJob>> {
+    export function queryPrintJobListReturnsPromise(): Promise<Array<PrintJob>> {
         return new Promise<Array<PrintJob>>((resolve: (data: Array<PrintJob> | undefined)=>void, reject:(err: BusinessError<void> | null)=>void): void => {
             let myCall = new AsyncCallbackArrayWrapper<PrintJob>((err : BusinessError<void> | null, data : Array<PrintJob>|undefined) => {
                 if (err === null || err.code == 0) {
@@ -1078,14 +1115,16 @@ export default namespace print {
         });
     }
 
-    export function queryPrintJobById(jobId: string, callback: AsyncCallback<PrintJob>): void {
+    export overload queryprintjobbyid { queryPrintJobByIdWithCallback, queryPrintJobByIdReturnsPromise }
+
+    export function queryPrintJobByIdWithCallback(jobId: string, callback: AsyncCallback<PrintJob>): void {
         let myCall = new AsyncCallbackWrapper<PrintJob>(callback);
         taskpool.execute((): void => {
             queryPrintJobByIdNative(jobId, myCall);
         });
     }
 
-    export function queryPrintJobById(jobId: string): Promise<PrintJob> {
+    export function queryPrintJobByIdReturnsPromise(jobId: string): Promise<PrintJob> {
         return new Promise<PrintJob>((resolve: (data: PrintJob | undefined)=>void, reject:(err: BusinessError<void> | null)=>void): void => {
             let myCall = new AsyncCallbackWrapper<PrintJob>((err : BusinessError<void> | null, data : PrintJob|undefined) => {
                 if (err === null || err.code == 0) {
@@ -1107,15 +1146,16 @@ export default namespace print {
         });
     }
 
+    export overload notifyprintservice { notifyPrintServiceWithCallback, notifyPrintServiceReturnsPromise }
 
-    export function notifyPrintService(jobId: string, type: string, callback: AsyncCallback<void>): void {
+    export function notifyPrintServiceWithCallback(jobId: string, type: string, callback: AsyncCallback<void>): void {
         let myCall = new AsyncCallbackWrapper<void>(callback);
         taskpool.execute((): void => {
             notifyPrintServiceNative(jobId, type, myCall);
         });
     }
 
-    export function notifyPrintService(jobId: string, type: string): Promise<void> {
+    export function notifyPrintServiceReturnsPromise(jobId: string, type: string): Promise<void> {
         return new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError<void> | null)=>void):void => {
             let myCall = new AsyncCallbackWrapper<void>((err : BusinessError<void> | null) => {
                 if (err === null || err.code == 0) {