diff --git a/interfaces/kits/js/backup/session_restore_n_exporter.cpp b/interfaces/kits/js/backup/session_restore_n_exporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..55215541c428d74b0818ad7899d256615a3b8b40
--- /dev/null
+++ b/interfaces/kits/js/backup/session_restore_n_exporter.cpp
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2023 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 "session_restore_n_exporter.h"
+
+#include <functional>
+#include <memory>
+
+#include "b_error/b_error.h"
+#include "b_filesystem/b_dir.h"
+#include "b_filesystem/b_file.h"
+#include "b_resources/b_constants.h"
+#include "b_session_restore.h"
+#include "backup_kit_inner.h"
+#include "filemgmt_libhilog.h"
+#include "general_callbacks.h"
+#include "service_proxy.h"
+
+namespace OHOS::FileManagement::Backup {
+using namespace std;
+using namespace LibN;
+
+struct RestoreEntity {
+    unique_ptr<BSessionRestore> session;
+    shared_ptr<GeneralCallbacks> callbacks;
+};
+
+static void OnFileReady(weak_ptr<GeneralCallbacks> pCallbacks, const BFileInfo &fileInfo, UniqueFd fd)
+{
+    if (pCallbacks.expired()) {
+        HILOGI("callbacks is unbound");
+        return;
+    }
+    auto callbacks = pCallbacks.lock();
+    if (!callbacks) {
+        HILOGI("callback function onFileReady has already been released");
+        return;
+    }
+    if (!bool(callbacks->onFileReady)) {
+        HILOGI("callback function onFileReady is undefined");
+        return;
+    }
+
+    auto cbCompl = [bundleName {fileInfo.owner}, fileName {fileInfo.fileName},
+                    fd {make_shared<UniqueFd>(fd.Release())}](napi_env env, NError err) -> NVal {
+        if (err) {
+            return {env, err.GetNapiErr(env)};
+        }
+        NVal obj = NVal::CreateObject(env);
+        obj.AddProp({NVal::DeclareNapiProperty("bundleName", NVal::CreateUTF8String(env, bundleName).val_),
+                     NVal::DeclareNapiProperty("uri", NVal::CreateUTF8String(env, fileName).val_),
+                     NVal::DeclareNapiProperty("fd", NVal::CreateInt32(env, fd->Release()).val_)});
+
+        return {obj};
+    };
+
+    callbacks->onFileReady.ThreadSafeSchedule(cbCompl);
+}
+
+static void onBundleBegin(weak_ptr<GeneralCallbacks> pCallbacks, ErrCode err, const BundleName name)
+{
+    if (pCallbacks.expired()) {
+        HILOGI("callbacks is unbound");
+        return;
+    }
+    auto callbacks = pCallbacks.lock();
+    if (!callbacks) {
+        HILOGI("callback function onBundleBegin has already been released");
+        return;
+    }
+    if (!bool(callbacks->onBundleBegin)) {
+        HILOGI("callback function onBundleBegin is undefined");
+        return;
+    }
+
+    auto cbCompl = [name {name}](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUTF8String(env, name);
+    };
+
+    callbacks->onBundleBegin.ThreadSafeSchedule(cbCompl);
+}
+
+static void onBundleEnd(weak_ptr<GeneralCallbacks> pCallbacks, ErrCode err, const BundleName name)
+{
+    if (pCallbacks.expired()) {
+        HILOGI("callbacks is unbound");
+        return;
+    }
+    auto callbacks = pCallbacks.lock();
+    if (!callbacks) {
+        HILOGI("callback function onBundleEnd has already been released");
+        return;
+    }
+    if (!bool(callbacks->onBundleEnd)) {
+        HILOGI("callback function onBundleEnd is undefined");
+        return;
+    }
+
+    auto cbCompl = [name {name}](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUTF8String(env, name);
+    };
+
+    callbacks->onBundleEnd.ThreadSafeSchedule(cbCompl);
+}
+
+static void onAllBundlesEnd(weak_ptr<GeneralCallbacks> pCallbacks, ErrCode err)
+{
+    if (pCallbacks.expired()) {
+        HILOGI("callbacks is unbound");
+        return;
+    }
+    auto callbacks = pCallbacks.lock();
+    if (!callbacks) {
+        HILOGI("callback function onAllBundlesEnd has already been released");
+        return;
+    }
+    if (!bool(callbacks->onAllBundlesEnd)) {
+        HILOGI("callback function onAllBundlesEnd is undefined");
+        return;
+    }
+
+    auto cbCompl = [](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUndefined(env);
+    };
+
+    callbacks->onAllBundlesEnd.ThreadSafeSchedule(cbCompl);
+}
+
+static void OnBackupServiceDied(weak_ptr<GeneralCallbacks> pCallbacks)
+{
+    if (pCallbacks.expired()) {
+        HILOGI("callbacks is unbound");
+        return;
+    }
+    auto callbacks = pCallbacks.lock();
+    if (!callbacks) {
+        HILOGI("js callback function onBackupServiceDied has already been released");
+        return;
+    }
+    if (!bool(callbacks->onBackupServiceDied)) {
+        HILOGI("callback function onBackupServiceDied is undefined");
+        return;
+    }
+
+    auto cbCompl = [](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUndefined(env);
+    };
+
+    callbacks->onBackupServiceDied.ThreadSafeSchedule(cbCompl);
+}
+
+napi_value SessionRestoreNExporter::Constructor(napi_env env, napi_callback_info cbinfo)
+{
+    HILOGI("called SessionRestore::Constructor begin");
+    NFuncArg funcArg(env, cbinfo);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        HILOGE("Number of arguments unmatched");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal callbacks(env, funcArg[NARG_POS::FIRST]);
+    if (!callbacks.TypeIs(napi_object)) {
+        HILOGE("First argument is not an object.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal ptr(env, funcArg.GetThisVar());
+    auto restoreEntity = std::make_unique<RestoreEntity>();
+    restoreEntity->callbacks = make_shared<GeneralCallbacks>(env, ptr, callbacks);
+    restoreEntity->session = BSessionRestore::Init(BSessionRestore::Callbacks {
+        .onFileReady = bind(OnFileReady, restoreEntity->callbacks, placeholders::_1, placeholders::_2),
+        .onBundleStarted = bind(onBundleBegin, restoreEntity->callbacks, placeholders::_1, placeholders::_2),
+        .onBundleFinished = bind(onBundleEnd, restoreEntity->callbacks, placeholders::_1, placeholders::_2),
+        .onAllBundlesFinished = bind(onAllBundlesEnd, restoreEntity->callbacks, placeholders::_1),
+        .onBackupServiceDied = bind(OnBackupServiceDied, restoreEntity->callbacks)});
+    if (!restoreEntity->session) {
+        NError(BError(BError::Codes::SDK_INVAL_ARG, "Failed to init restore").GetCode()).ThrowErr(env);
+        return nullptr;
+    }
+    if (!NClass::SetEntityFor<RestoreEntity>(env, funcArg.GetThisVar(), move(restoreEntity))) {
+        HILOGE("Failed to set SessionRestore entity");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    HILOGI("called SessionRestore::Constructor end");
+    return funcArg.GetThisVar();
+}
+
+napi_value SessionRestoreNExporter::AppendBundles(napi_env env, napi_callback_info cbinfo)
+{
+    HILOGI("called SessionRestore::AppendBundles begin");
+    NFuncArg funcArg(env, cbinfo);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        HILOGE("Number of arguments unmatched");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal remoteCap(env, funcArg[NARG_POS::FIRST]);
+    auto [err, fd] = remoteCap.ToInt32();
+    if (!err) {
+        HILOGE("First argument is not remote capabilitily file number.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal jsBundles(env, funcArg[NARG_POS::SECOND]);
+    auto [succ, bundles, ignore] = jsBundles.ToStringArray();
+    if (!succ) {
+        HILOGE("First argument is not bundles array.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto restoreEntity = NClass::GetEntityOf<RestoreEntity>(env, funcArg.GetThisVar());
+    if (!(restoreEntity && restoreEntity->session)) {
+        HILOGE("Failed to get RestoreSession entity.");
+        NError(EPERM).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto cbExec = [session {restoreEntity->session.get()}, fd {fd}, bundles {bundles}]() -> NError {
+        if (!session) {
+            return NError(BError(BError::Codes::SDK_INVAL_ARG, "restore session is nullptr").GetCode());
+        }
+        return NError(session->AppendBundles(UniqueFd(fd), bundles));
+    };
+    auto cbCompl = [](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUndefined(env);
+    };
+
+    HILOGE("Called SessionRestore::AppendBundles end.");
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(className, cbExec, cbCompl).val_;
+    }
+}
+
+napi_value SessionRestoreNExporter::PublishFile(napi_env env, napi_callback_info cbinfo)
+{
+    HILOGI("called SessionRestore::PublishFile begin");
+    NFuncArg funcArg(env, cbinfo);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        HILOGE("Number of arguments unmatched");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal fileMeta(env, funcArg[NARG_POS::FIRST]);
+    if (!fileMeta.TypeIs(napi_object)) {
+        HILOGE("First arguments is not an object");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto [succ, bundleName, size] = fileMeta.GetProp("bundleName").ToUTF8String();
+    if (!succ) {
+        HILOGE("First argument is not have property bundle name.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    std::unique_ptr<char[]> fileName = nullptr;
+    tie(succ, fileName, ignore) = fileMeta.GetProp("uri").ToUTF8String();
+    if (!succ) {
+        HILOGE("First argument is not have property file name.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto restoreEntity = NClass::GetEntityOf<RestoreEntity>(env, funcArg.GetThisVar());
+    if (!(restoreEntity && restoreEntity->session)) {
+        HILOGE("Failed to get RestoreSession entity.");
+        NError(EPERM).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto cbExec = [session {restoreEntity->session.get()}, bundleName {string(bundleName.get())},
+                   fileName {string(fileName.get())}]() -> NError {
+        if (!session) {
+            return NError(BError(BError::Codes::SDK_INVAL_ARG, "restore session is nullptr").GetCode());
+        }
+        BFileInfo fileInfo(bundleName, fileName, 0);
+        return NError(session->PublishFile(fileInfo));
+    };
+    auto cbCompl = [](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUndefined(env);
+    };
+
+    HILOGE("Called SessionRestore::PublishFile end.");
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(className, cbExec, cbCompl).val_;
+    }
+}
+
+napi_value SessionRestoreNExporter::GetFileHandle(napi_env env, napi_callback_info cbinfo)
+{
+    HILOGI("called SessionRestore::GetFileHandle begin");
+    NFuncArg funcArg(env, cbinfo);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        HILOGE("Number of arguments unmatched");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    NVal fileMeta(env, funcArg[NARG_POS::FIRST]);
+    if (!fileMeta.TypeIs(napi_object)) {
+        HILOGE("First arguments is not an object");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto [succ, bundleName, ignore] = fileMeta.GetProp("bundleName").ToUTF8String();
+    if (!succ) {
+        HILOGE("First argument is not have property bundle name.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    std::unique_ptr<char[]> fileName = nullptr;
+    tie(succ, fileName, ignore) = fileMeta.GetProp("uri").ToUTF8String();
+    if (!succ) {
+        HILOGE("First argument is not have property file name.");
+        NError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto restoreEntity = NClass::GetEntityOf<RestoreEntity>(env, funcArg.GetThisVar());
+    if (!(restoreEntity && restoreEntity->session)) {
+        HILOGE("Failed to get RestoreSession entity.");
+        NError(EPERM).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto cbExec = [session {restoreEntity->session.get()}, bundleName {string(bundleName.get())},
+                   fileName {string(fileName.get())}]() -> NError {
+        if (!session) {
+            return NError(BError(BError::Codes::SDK_INVAL_ARG, "restore session is nullptr").GetCode());
+        }
+        string bundle = bundleName;
+        string file = fileName;
+        return NError(session->GetFileHandle(bundle, file));
+    };
+    auto cbCompl = [](napi_env env, NError err) -> NVal {
+        return err ? NVal {env, err.GetNapiErr(env)} : NVal::CreateUndefined(env);
+    };
+
+    HILOGE("Called SessionRestore::GetFileHandle end.");
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(className, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(className, cbExec, cbCompl).val_;
+    }
+}
+
+bool SessionRestoreNExporter::Export()
+{
+    HILOGI("called SessionRestoreNExporter::Export begin");
+    vector<napi_property_descriptor> props = {
+        NVal::DeclareNapiFunction("appendBundles", AppendBundles),
+        NVal::DeclareNapiFunction("publishFile", PublishFile),
+        NVal::DeclareNapiFunction("getFileHandle", GetFileHandle),
+    };
+
+    auto [succ, classValue] = NClass::DefineClass(exports_.env_, className, Constructor, std::move(props));
+    if (!succ) {
+        HILOGE("Failed to define class");
+        NError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+    succ = NClass::SaveClass(exports_.env_, className, classValue);
+    if (!succ) {
+        HILOGE("Failed to save class");
+        NError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+
+    HILOGI("called SessionRestoreNExporter::Export end");
+    return exports_.AddProp(className, classValue);
+}
+
+string SessionRestoreNExporter::GetClassName()
+{
+    return SessionRestoreNExporter::className;
+}
+
+SessionRestoreNExporter::SessionRestoreNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
+
+SessionRestoreNExporter::~SessionRestoreNExporter() {}
+} // namespace OHOS::FileManagement::Backup
\ No newline at end of file
diff --git a/interfaces/kits/js/backup/session_restore_n_exporter.h b/interfaces/kits/js/backup/session_restore_n_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..b389b55f5685c0563b0054167586a5141185c7c8
--- /dev/null
+++ b/interfaces/kits/js/backup/session_restore_n_exporter.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2023 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 INTERFACES_KITS_JS_SRC_MOD_BACKUP_PROPERTIES_SESSION_RESTORE_N_EXPORTER_H
+#define INTERFACES_KITS_JS_SRC_MOD_BACKUP_PROPERTIES_SESSION_RESTORE_N_EXPORTER_H
+
+#include <node_api.h>
+#include <string>
+
+#include "filemgmt_libn.h"
+
+namespace OHOS::FileManagement::Backup {
+class SessionRestoreNExporter final : public LibN::NExporter {
+public:
+    inline static const std::string className = "SessionRestore";
+
+    bool Export() override;
+    std::string GetClassName() override;
+
+    static napi_value Constructor(napi_env env, napi_callback_info cbinfo);
+    static napi_value AppendBundles(napi_env env, napi_callback_info cbinfo);
+    static napi_value PublishFile(napi_env env, napi_callback_info cbinfo);
+    static napi_value GetFileHandle(napi_env env, napi_callback_info cbinfo);
+
+    SessionRestoreNExporter(napi_env env, napi_value exports);
+    ~SessionRestoreNExporter() override;
+};
+} // namespace OHOS::FileManagement::Backup
+#endif // INTERFACES_KITS_JS_SRC_MOD_BACKUP_PROPERTIES_SESSION_RESTORE_N_EXPORTER_H
\ No newline at end of file