diff --git a/frameworks/js/napi/include/manager/napi_cancel.h b/frameworks/js/napi/include/manager/napi_cancel.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ff198c965bbc0173e8fec9026c4c15a1cb1b5d2
--- /dev/null
+++ b/frameworks/js/napi/include/manager/napi_cancel.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_INCLUDE_CANCEL_H
+#define BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_INCLUDE_CANCEL_H
+
+#include "common.h"
+
+namespace OHOS {
+namespace NotificationNapi {
+using namespace OHOS::Notification;
+
+napi_value NapiCancel(napi_env env, napi_callback_info info);
+napi_value NapiCancelAll(napi_env env, napi_callback_info info);
+napi_value NapiCancelGroup(napi_env env, napi_callback_info info);
+napi_value NapiCancelAsBundle(napi_env env, napi_callback_info info);
+}  // namespace NotificationNapi
+}  // namespace OHOS
+
+#endif  // BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_INCLUDE_CANCEL_H
\ No newline at end of file
diff --git a/frameworks/js/napi/include/manager/napi_slot.h b/frameworks/js/napi/include/manager/napi_slot.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d63119ae4e505560d11bb964c87e3546616cf1e
--- /dev/null
+++ b/frameworks/js/napi/include/manager/napi_slot.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_SLOT_H
+#define BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_SLOT_H
+
+#include "common.h"
+
+namespace OHOS {
+namespace NotificationNapi {
+using namespace OHOS::Notification;
+
+struct ParametersInfoAddSlot {
+    NotificationSlot slot;
+    NotificationConstant::SlotType inType = NotificationConstant::SlotType::OTHER;
+    bool isAddSlotByType = false;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoAddSlot {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    NotificationSlot slot;
+    NotificationConstant::SlotType inType = NotificationConstant::SlotType::OTHER;
+    bool isAddSlotByType = false;
+    CallbackPromiseInfo info;
+};
+
+struct ParametersInfoAddSlots {
+    std::vector<NotificationSlot> slots;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoAddSlots {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    std::vector<NotificationSlot> slots;
+    CallbackPromiseInfo info;
+};
+
+struct ParametersInfoSetSlotByBundle {
+    NotificationBundleOption option;
+    std::vector<sptr<NotificationSlot>> slots;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoSetSlotByBundle {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    ParametersInfoSetSlotByBundle params;
+    CallbackPromiseInfo info;
+};
+
+struct ParametersInfoGetSlot {
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoGetSlot {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    CallbackPromiseInfo info;
+    sptr<NotificationSlot> slot = nullptr;
+};
+
+struct ParametersInfoGetSlotNumByBundle {
+    NotificationBundleOption option;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoGetSlotNumByBundle {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    ParametersInfoGetSlotNumByBundle params;
+    CallbackPromiseInfo info;
+    uint64_t num = 0;
+};
+
+struct AsyncCallbackInfoGetSlots {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    CallbackPromiseInfo info;
+    std::vector<sptr<NotificationSlot>> slots;
+};
+
+struct ParametersInfoGetSlotsByBundle {
+    NotificationBundleOption option;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoGetSlotsByBundle {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    ParametersInfoGetSlotsByBundle params;
+    CallbackPromiseInfo info;
+    std::vector<sptr<NotificationSlot>> slots;
+};
+
+struct ParametersInfoRemoveSlot {
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoRemoveSlot {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    CallbackPromiseInfo info;
+};
+
+struct AsyncCallbackInfoRemoveAllSlots {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    CallbackPromiseInfo info;
+};
+
+struct ParametersInfoEnableSlot {
+    NotificationBundleOption option;
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    bool enable = false;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoInfoEnableSlot {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    ParametersInfoEnableSlot params;
+    CallbackPromiseInfo info;
+};
+
+struct ParametersInfoIsEnableSlot {
+    NotificationBundleOption option;
+    NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
+    napi_ref callback = nullptr;
+};
+
+struct AsyncCallbackInfoInfoIsEnableSlot {
+    napi_env env = nullptr;
+    napi_async_work asyncWork = nullptr;
+    ParametersInfoIsEnableSlot params;
+    bool isEnable = false;
+    CallbackPromiseInfo info;
+};
+
+napi_value NapiAddSlot(napi_env env, napi_callback_info info);
+napi_value NapiAddSlots(napi_env env, napi_callback_info info);
+napi_value NapiSetSlotByBundle(napi_env env, napi_callback_info info);
+napi_value NapiGetSlot(napi_env env, napi_callback_info info);
+napi_value NapiGetSlotNumByBundle(napi_env env, napi_callback_info info);
+napi_value NapiGetSlots(napi_env env, napi_callback_info info);
+napi_value NapiGetSlotsByBundle(napi_env env, napi_callback_info info);
+napi_value NapiRemoveSlot(napi_env env, napi_callback_info info);
+napi_value NapiRemoveAllSlots(napi_env env, napi_callback_info info);
+napi_value NapiEnableNotificationSlot(napi_env env, napi_callback_info info);
+napi_value NapiIsEnableNotificationSlot(napi_env env, napi_callback_info info);
+
+napi_value ParseParametersByAddSlot(const napi_env &env, const napi_callback_info &info, ParametersInfoAddSlot &paras);
+napi_value ParseParametersByAddSlots(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoAddSlots &paras);
+napi_value ParseParametersSetSlotByBundle(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoSetSlotByBundle &params);
+napi_value ParseParametersByGetSlot(const napi_env &env, const napi_callback_info &info, ParametersInfoGetSlot &paras);
+napi_value ParseParametersGetSlotNumByBundle(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoGetSlotNumByBundle &params);
+napi_value ParseParametersGetSlotsByBundle(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoGetSlotsByBundle &params);
+napi_value ParseParametersByRemoveSlot(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoRemoveSlot &paras);
+napi_value ParseParametersEnableSlot(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoEnableSlot &params);
+napi_value ParseParametersIsEnableSlot(
+    const napi_env &env, const napi_callback_info &info, ParametersInfoIsEnableSlot &params);
+}  // namespace NotificationNapi
+}  // namespace OHOS
+
+#endif  // BASE_NOTIFICATION_DISTRIBUTED_NOTIFICATION_SERVICE_FRAMEWORKS_JS_NAPI_SLOT_H
\ No newline at end of file
diff --git a/frameworks/js/napi/src/manager/BUILD.gn b/frameworks/js/napi/src/manager/BUILD.gn
index 8d04207cdbdb3ab168ad6881b6ac08345be5d97e..5babc88c77866852a5201c41c8a7c06cafd7b7c9 100644
--- a/frameworks/js/napi/src/manager/BUILD.gn
+++ b/frameworks/js/napi/src/manager/BUILD.gn
@@ -51,7 +51,9 @@ ohos_shared_library("notificationmanager") {
     "../publish.cpp",
     "../slot.cpp",
     "init_module.cpp",
+    "napi_cancel.cpp",
     "napi_publish.cpp",
+    "napi_slot.cpp",
   ]
 
   deps = [
diff --git a/frameworks/js/napi/src/manager/init_module.cpp b/frameworks/js/napi/src/manager/init_module.cpp
index 14c523c89673b4fc6787955cb2c540cd0f7db4fe..41d8c3230d520c148ba6d91c5919103706c27ec9 100644
--- a/frameworks/js/napi/src/manager/init_module.cpp
+++ b/frameworks/js/napi/src/manager/init_module.cpp
@@ -15,7 +15,9 @@
 
 #include "init_module.h"
 #include "constant.h"
+#include "napi_cancel.h"
 #include "napi_publish.h"
+#include "napi_slot.h"
 #include "pixel_map_napi.h"
 
 namespace OHOS {
@@ -32,6 +34,21 @@ napi_value NotificationManagerInit(napi_env env, napi_value exports)
         DECLARE_NAPI_FUNCTION("publish", NapiPublish),
         DECLARE_NAPI_FUNCTION("publishAsBundle", NapiPublishAsBundle),
         DECLARE_NAPI_FUNCTION("show", NapiShowNotification),
+        DECLARE_NAPI_FUNCTION("cancel", NapiCancel),
+        DECLARE_NAPI_FUNCTION("cancelAll", NapiCancelAll),
+        DECLARE_NAPI_FUNCTION("cancelGroup", NapiCancelGroup),
+        DECLARE_NAPI_FUNCTION("cancelAsBundle", NapiCancelAsBundle),
+        DECLARE_NAPI_FUNCTION("addSlot", NapiAddSlot),
+        DECLARE_NAPI_FUNCTION("addSlots", NapiAddSlots),
+        DECLARE_NAPI_FUNCTION("setSlotByBundle", NapiSetSlotByBundle),
+        DECLARE_NAPI_FUNCTION("getSlot", NapiGetSlot),
+        DECLARE_NAPI_FUNCTION("getSlotNumByBundle", NapiGetSlotNumByBundle),
+        DECLARE_NAPI_FUNCTION("getSlots", NapiGetSlots),
+        DECLARE_NAPI_FUNCTION("getSlotsByBundle", NapiGetSlotsByBundle),
+        DECLARE_NAPI_FUNCTION("removeSlot", NapiRemoveSlot),
+        DECLARE_NAPI_FUNCTION("removeAllSlots", NapiRemoveAllSlots),
+        DECLARE_NAPI_FUNCTION("setNotificationEnableSlot", NapiEnableNotificationSlot),
+        DECLARE_NAPI_FUNCTION("isNotificationSlotEnabled", NapiIsEnableNotificationSlot),
     };
 
     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc));
diff --git a/frameworks/js/napi/src/manager/napi_cancel.cpp b/frameworks/js/napi/src/manager/napi_cancel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..de99f633fbaa9c8914028fcf8900f222283ed8d8
--- /dev/null
+++ b/frameworks/js/napi/src/manager/napi_cancel.cpp
@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "napi_cancel.h"
+
+#include "ans_inner_errors.h"
+#include "cancel.h"
+
+namespace OHOS {
+namespace NotificationNapi {
+napi_value NapiCancel(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoCancel paras;
+    if (ParseParameters(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoCancel *asynccallbackinfo = new (std::nothrow)
+        AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr, .id = paras.id, .label = paras.label};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "cancel", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("Cancel napi_create_async_work start");
+            AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
+
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::CancelNotification(asynccallbackinfo->label, asynccallbackinfo->id);
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("Cancel napi_create_async_work end");
+            AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiCancelAll(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    napi_ref callback = nullptr;
+    if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "cancelAll", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("CancelAll napi_create_async_work start");
+            AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::CancelAllNotifications();
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("CancelAll napi_create_async_work end");
+            AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiCancelGroup(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoCancelGroup params {};
+    if (ParseParameters(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoCancelGroup *asynccallbackinfo = new (std::nothrow)
+        AsyncCallbackInfoCancelGroup {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "cancelGroup", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("CancelGroup napi_create_async_work start");
+            AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
+            if (asynccallbackinfo) {
+                ANS_LOGI("asynccallbackinfo->params.groupName = %{public}s",
+                    asynccallbackinfo->params.groupName.c_str());
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::CancelGroup(asynccallbackinfo->params.groupName);
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("CancelGroup napi_create_async_work end");
+            AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiCancelAsBundle(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoCancelAsBundle paras;
+    if (ParseParameters(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancelAsBundle {
+        .env = env, .asyncWork = nullptr,
+        .id = paras.id,
+        .representativeBundle = paras.representativeBundle,
+        .userId = paras.userId
+    };
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "cancelasbundle", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("Cancel napi_create_async_work start");
+            AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
+
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::CancelAsBundle(
+                    asynccallbackinfo->id, asynccallbackinfo->representativeBundle, asynccallbackinfo->userId);
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("Cancel napi_create_async_work end");
+            AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+}  // namespace NotificationNapi
+}  // namespace OHOS
\ No newline at end of file
diff --git a/frameworks/js/napi/src/manager/napi_slot.cpp b/frameworks/js/napi/src/manager/napi_slot.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d394922a78217c5b7609a1293514fc712f3f5730
--- /dev/null
+++ b/frameworks/js/napi/src/manager/napi_slot.cpp
@@ -0,0 +1,701 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "napi_slot.h"
+
+#include "ans_inner_errors.h"
+#include "slot.h"
+
+namespace OHOS {
+namespace NotificationNapi {
+napi_value NapiAddSlot(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoAddSlot paras;
+    if (ParseParametersByAddSlot(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoAddSlot *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoAddSlot {
+        .env = env,
+        .asyncWork = nullptr,
+        .slot = paras.slot,
+        .inType = paras.inType,
+        .isAddSlotByType = paras.isAddSlotByType
+    };
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "addSlot", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("AddSlot napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
+            if (asynccallbackinfo->isAddSlotByType) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
+            } else {
+                asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
+            }
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("AddSlot napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiAddSlots(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoAddSlots paras;
+    if (ParseParametersByAddSlots(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoAddSlots *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoAddSlots {.env = env, .asyncWork = nullptr, .slots = paras.slots};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "addSlots", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("AddSlots napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
+            asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("AddSlots napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiSetSlotByBundle(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoSetSlotByBundle params {};
+    if (ParseParametersSetSlotByBundle(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoSetSlotByBundle *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoSetSlotByBundle {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "setSlotByBundle", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("SetSlotByBundle napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
+
+            asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
+                asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("SetSlotByBundle napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+
+void AsyncCompleteCallbackNapiGetSlot(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("GetSlot napi_create_async_work end");
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+
+    auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
+    napi_value result = Common::NapiGetNull(env);
+    if (asynccallbackinfo->info.errorCode == ERR_OK) {
+        if (asynccallbackinfo->slot == nullptr) {
+            asynccallbackinfo->info.errorCode = ERROR;
+        } else {
+            napi_create_object(env, &result);
+            if (!Common::SetNotificationSlot(env, *asynccallbackinfo->slot, result)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
+            }
+        }
+    }
+    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    delete asynccallbackinfo;
+    asynccallbackinfo = nullptr;
+}
+
+napi_value NapiGetSlot(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoGetSlot paras;
+    if (ParseParametersByGetSlot(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoGetSlot *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoGetSlot {.env = env, .asyncWork = nullptr, .outType = paras.outType};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "getSlot", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("GetSlot napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
+
+            asynccallbackinfo->info.errorCode =
+                NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
+        },
+        AsyncCompleteCallbackNapiGetSlot,
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiGetSlotNumByBundle(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoGetSlotNumByBundle params {};
+    if (ParseParametersGetSlotNumByBundle(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoGetSlotNumByBundle *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoGetSlotNumByBundle {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "getSlotNumByBundle", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("GetSlotNumByBundle napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
+
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
+                asynccallbackinfo->params.option, asynccallbackinfo->num);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("GetSlotNumByBundle napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
+            if (asynccallbackinfo) {
+                napi_value result = nullptr;
+                napi_create_uint32(env, asynccallbackinfo->num, &result);
+                Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+void AsyncCompleteCallbackNapiGetSlots(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("enter");
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+    napi_value result = nullptr;
+    auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
+    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+        result = Common::NapiGetNull(env);
+    } else {
+        napi_value arr = nullptr;
+        napi_create_array(env, &arr);
+        size_t count = 0;
+        for (auto vec : asynccallbackinfo->slots) {
+            if (!vec) {
+                ANS_LOGW("Invalid NotificationSlot object ptr");
+                continue;
+            }
+            napi_value nSlot = nullptr;
+            napi_create_object(env, &nSlot);
+            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
+                continue;
+            }
+            napi_set_element(env, arr, count, nSlot);
+            count++;
+        }
+        ANS_LOGI("getSlots count = %{public}zu", count);
+        result = arr;
+        if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+            asynccallbackinfo->info.errorCode = ERROR;
+            result = Common::NapiGetNull(env);
+        }
+    }
+    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    delete asynccallbackinfo;
+    asynccallbackinfo = nullptr;
+}
+
+napi_value NapiGetSlots(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    napi_ref callback = nullptr;
+    if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetSlots {.env = env, .asyncWork = nullptr};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "getSlots", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("GetSlots napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
+        },
+        AsyncCompleteCallbackNapiGetSlots,
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+void AsyncCompleteCallbackNapiGetSlotsByBundle(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("enter");
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+    napi_value result = nullptr;
+    auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
+    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+        result = Common::NapiGetNull(env);
+    } else {
+        napi_value arr = nullptr;
+        napi_create_array(env, &arr);
+        size_t count = 0;
+        for (auto vec : asynccallbackinfo->slots) {
+            if (!vec) {
+                ANS_LOGW("Invalid NotificationSlot object ptr");
+                continue;
+            }
+            napi_value nSlot = nullptr;
+            napi_create_object(env, &nSlot);
+            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
+                continue;
+            }
+            napi_set_element(env, arr, count, nSlot);
+            count++;
+        }
+        ANS_LOGI("getSlots count = %{public}zu", count);
+        result = arr;
+        if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+            asynccallbackinfo->info.errorCode = ERROR;
+            result = Common::NapiGetNull(env);
+        }
+    }
+    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    delete asynccallbackinfo;
+    asynccallbackinfo = nullptr;
+}
+
+napi_value NapiGetSlotsByBundle(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoGetSlotsByBundle params {};
+    if (ParseParametersGetSlotsByBundle(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoGetSlotsByBundle *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoGetSlotsByBundle {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "getSlotsByBundle", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("GetSlotsByBundle napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(
+                asynccallbackinfo->params.option, asynccallbackinfo->slots);
+        },
+        AsyncCompleteCallbackNapiGetSlotsByBundle,
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiRemoveSlot(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoRemoveSlot paras;
+    if (ParseParametersByRemoveSlot(env, info, paras) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoRemoveSlot *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoRemoveSlot {.env = env, .asyncWork = nullptr, .outType = paras.outType};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, paras.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "removeSlot", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("removeSlot napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
+            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("removeSlot napi_create_async_work end");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiRemoveAllSlots(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    napi_ref callback = nullptr;
+    if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    auto *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoRemoveAllSlots {.env = env, .asyncWork = nullptr};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "removeAll", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("RemoveAllSlots napi_create_async_work start");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
+            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("RemoveAllSlots napi_create_async_work end");
+            auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiEnableNotificationSlot(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoEnableSlot params {};
+    if (ParseParametersEnableSlot(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoInfoEnableSlot *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoInfoEnableSlot {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "EnableNotificationSlot", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("EnableNotificationSlot napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
+
+            asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
+                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->params.enable);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("EnableNotificationSlot napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+
+napi_value NapiIsEnableNotificationSlot(napi_env env, napi_callback_info info)
+{
+    ANS_LOGI("enter");
+    ParametersInfoIsEnableSlot params {};
+    if (ParseParametersIsEnableSlot(env, info, params) == nullptr) {
+        Common::NapiThrow(env, ERROR_PARAM_INVALID);
+        return Common::NapiGetUndefined(env);
+    }
+
+    AsyncCallbackInfoInfoIsEnableSlot *asynccallbackinfo =
+        new (std::nothrow) AsyncCallbackInfoInfoIsEnableSlot {.env = env, .asyncWork = nullptr, .params = params};
+    if (!asynccallbackinfo) {
+        return Common::JSParaError(env, params.callback);
+    }
+    napi_value promise = nullptr;
+    Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
+
+    napi_value resourceName = nullptr;
+    napi_create_string_latin1(env, "IsEnableNotificationSlot", NAPI_AUTO_LENGTH, &resourceName);
+    // Asynchronous function call
+    napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        [](napi_env env, void *data) {
+            ANS_LOGI("IsEnableNotificationSlot napi_create_async_work start");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
+
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
+                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
+        },
+        [](napi_env env, napi_status status, void *data) {
+            ANS_LOGI("IsEnableNotificationSlot napi_create_async_work end");
+            auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
+            if (asynccallbackinfo) {
+                napi_value result = nullptr;
+                napi_get_boolean(env, asynccallbackinfo->isEnable, &result);
+                Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
+        },
+        (void *)asynccallbackinfo,
+        &asynccallbackinfo->asyncWork);
+
+    NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
+    if (asynccallbackinfo->info.isCallback) {
+        return Common::NapiGetNull(env);
+    } else {
+        return promise;
+    }
+}
+}  // namespace NotificationNapi
+}  // namespace OHOS
\ No newline at end of file