diff --git a/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.cpp b/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1743c9e687bd7d14037dbfffe7f5b7d22de1069f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.cpp
@@ -0,0 +1,694 @@
+/*
+ * Copyright (c) 2021-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 "prop_n_exporter.h"
+
+#include <memory>
+#include <unistd.h>
+
+#include "../common_func.h"
+#include "chmod.h"
+#include "chown.h"
+#include "close.h"
+#include "copy_file.h"
+#include "create_stream.h"
+#include "fchmod.h"
+#include "fchown.h"
+#include "fdatasync.h"
+#include "fdopen_stream.h"
+#include "fstat.h"
+#include "fsync.h"
+#include "ftruncate.h"
+#include "hash.h"
+#include "lchown.h"
+#include "link.h"
+#include "lseek.h"
+#include "lstat.h"
+#include "mkdtemp.h"
+#include "open.h"
+#include "open_dir.h"
+#include "posix_fallocate.h"
+#include "read_text.h"
+#include "rename.h"
+#include "rmdir.h"
+#include "stat.h"
+#include "symlink.h"
+#include "truncate.h"
+#include "watcher.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+namespace {
+    static constexpr int MODE_RUO_RWX = 0750;
+}	
+napi_value PropNExporter::AccessSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    size_t argc = funcArg.GetArgc();
+    int ret = -1;
+    if (argc == NARG_CNT::ONE) {
+        ret = access(path.get(), 0);
+    } else {
+        auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid mode");
+            return nullptr;
+        }
+        ret = access(path.get(), mode);
+    }
+
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+static tuple<bool, string, int, bool> GetAccessArgs(napi_env env, const NFuncArg &funcArg)
+{
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return { false, nullptr, 0, false };
+    }
+
+    size_t argc = funcArg.GetArgc();
+    bool promise = true;
+    bool hasMode = false;
+    if (argc == NARG_CNT::ONE) {
+        hasMode = false;
+        promise = true;
+    } else if (argc == NARG_CNT::TWO) {
+        if (NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_function)) {
+            hasMode = false;
+            promise = false;
+        } else {
+            hasMode = true;
+            promise = true;
+        }
+    } else {
+        hasMode = true;
+        promise = false;
+    }
+
+    int mode = 0;
+    if (hasMode) {
+        auto [resGetSecondArg, modes] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid mode");
+            return { false, nullptr, 0, false };
+        }
+        mode = modes;
+    }
+
+    return { true, path.get(), mode, promise };
+}
+
+struct AsyncAccessArg {
+    unique_ptr<char[]> fp = nullptr;
+};
+
+napi_value PropNExporter::Access(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetAccessArgs, path, mode, promise] = GetAccessArgs(env, funcArg);
+    if (!resGetAccessArgs) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    auto cbExec = [path = move(path), mode](napi_env env) -> UniError {
+        int ret = access(path.c_str(), mode);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplete = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    const string procedureName = "FileIOAccess";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (promise) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        int cbInd = ((funcArg.GetArgc() == NARG_CNT::TWO) ? NARG_POS::SECOND : NARG_POS::THIRD);
+        NVal cb(env, funcArg[cbInd]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+
+napi_value PropNExporter::Unlink(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of Arguments Unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, tmp, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "invalid path");
+        return nullptr;
+    }
+
+    string path = tmp.get();
+    auto cbExec = [path](napi_env env) -> UniError {
+        if (unlink(path.c_str()) == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "FileIOStreamUnlink";
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value PropNExporter::Mkdir(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, tmp, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    string path = tmp.get();
+    int mode = 0775;
+    size_t argc = funcArg.GetArgc();
+    if ((argc == NARG_CNT::TWO && NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number)) ||
+        argc == NARG_CNT::THREE) {
+        auto [resGetSecondArg, modes] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid mode");
+            return nullptr;
+        }
+        mode = modes;
+    }
+
+    auto cbExec = [path, mode](napi_env env) -> UniError {
+        if (mkdir(path.c_str(), mode) == -1) {
+            return UniError(errno);
+        }
+        return UniError(ERRNO_NOERR);
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "fileioMkdir";
+    if ((argc == NARG_CNT::TWO && NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number)) || argc == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        int cbIdx = ((argc == NARG_CNT::TWO) ? NARG_POS::SECOND : NARG_POS::THIRD);
+        NVal cb(env, funcArg[cbIdx]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+
+napi_value PropNExporter::MkdirSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    int ret = -1;
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::ONE) {
+        ret = mkdir(path.get(), MODE_RUO_RWX);
+    } else {
+        auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid mode");
+            return nullptr;
+        }
+        ret = mkdir(path.get(), mode);
+    }
+
+    if (ret == -1) {
+        HILOGE("errno = %{public}d", errno);
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value PropNExporter::FchmodSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return nullptr;
+    }
+
+    int ret = fchmod(fd, mode);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value PropNExporter::FchownSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, owner] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid owner");
+    }
+
+    auto [resGetThirdArg, group] = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
+    if (!resGetThirdArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid group");
+    }
+
+    int ret = fchown(fd, owner, group);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value PropNExporter::ReadSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetReadArg, buf, len, hasPos, pos, unused] =
+        CommonFunc::GetReadArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
+    if (!resGetReadArg) {
+        return nullptr;
+    }
+
+    ssize_t actLen;
+    if (hasPos) {
+        actLen = pread(fd, buf, len, pos);
+    } else {
+        actLen = read(fd, buf, len);
+    }
+
+    if (actLen == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateInt64(env, actLen).val_;
+}
+
+struct AsyncIOReadArg {
+    ssize_t lenRead { 0 };
+    int offset { 0 };
+    NRef refReadBuf;
+
+    explicit AsyncIOReadArg(NVal jsReadBuf) : refReadBuf(jsReadBuf) {}
+    ~AsyncIOReadArg() = default;
+};
+
+napi_value PropNExporter::Read(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetReadArg, buf, len, hasPos, pos, offset] =
+        CommonFunc::GetReadArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
+    if (!resGetReadArg) {
+        UniError(EINVAL).ThrowErr(env, "Failed GetReadArg");
+        return nullptr;
+    }
+
+    auto arg = make_shared<AsyncIOReadArg>(NVal(env, funcArg[NARG_POS::SECOND]));
+    auto cbExec = [arg, buf, len, fd, hasPos, pos, offset](napi_env env) -> UniError {
+        ssize_t actLen;
+        if (hasPos) {
+            actLen = pread(fd, buf, len, pos);
+        } else {
+            actLen = read(fd, buf, len);
+        }
+    
+        if (actLen == -1) {
+            return UniError(errno);
+        } else {
+            arg->lenRead = actLen;
+            arg->offset = offset;
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        NVal obj = NVal::CreateObject(env);
+        obj.AddProp({
+            NVal::DeclareNapiProperty("bytesRead", NVal::CreateInt64(env, arg->lenRead).val_),
+            NVal::DeclareNapiProperty("buffer", arg->refReadBuf.Deref(env).val_),
+            NVal::DeclareNapiProperty("offset", NVal::CreateInt64(env, arg->offset).val_)
+            });
+        return { obj };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    size_t argc = funcArg.GetArgc();
+    bool hasOp = false;
+    if (argc == NARG_CNT::THREE) {
+        NVal op = NVal(env, funcArg[NARG_POS::THIRD]);
+        if (op.HasProp("offset") || op.HasProp("position") || op.HasProp("length")) {
+            hasOp = true;
+        }
+    }
+
+    if (argc == NARG_CNT::TWO || (argc == NARG_CNT::THREE && hasOp)) {
+        return NAsyncWorkPromise(env, thisVar).Schedule("FileIORead", cbExec, cbCompl).val_;
+    } else {
+        int cbIdx = ((argc == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::FOURTH);
+        NVal cb(env, funcArg[cbIdx]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule("FileIORead", cbExec, cbCompl).val_;
+    }
+}
+
+UniError PropNExporter::WriteExec(shared_ptr<AsyncIOWrtieArg> arg, void *buf, size_t len, int fd, size_t position)
+{
+    if (position == (size_t)INVALID_POSITION) {
+        arg->actLen = write(fd, buf, len);
+    } else {
+        arg->actLen = pwrite(fd, buf, len, position);
+    }
+
+    if (arg->actLen == -1) {
+        return UniError(errno);
+    }
+
+    return UniError(ERRNO_NOERR);
+}
+
+napi_value PropNExporter::Write(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetWriteArg, bufGuard, buf, len, hasPos, position] =
+        CommonFunc::GetWriteArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
+    if (!resGetWriteArgresGetWriteArg) {
+        UniError(EINVAL).ThrowErr(env, "Failed GetWriteArg");
+        return nullptr;
+    }
+
+    shared_ptr<AsyncIOWrtieArg> arg;
+    if (bufGuard) {
+        arg = make_shared<AsyncIOWrtieArg>(move(bufGuard));
+    } else {
+        arg = make_shared<AsyncIOWrtieArg>(NVal(env, funcArg[NARG_POS::SECOND]));
+    }
+
+    auto cbExec = [arg, buf, len, fd, position](napi_env env) -> UniError {
+        return WriteExec(arg, buf, len, fd, position);
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateInt64(env, arg->actLen) };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    bool hasOp = false;
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::THREE) {
+        NVal op = NVal(env, funcArg[NARG_POS::THIRD]);
+        if (op.HasProp("offset") || op.HasProp("position") || op.HasProp("length") || op.HasProp("encoding")) {
+            hasOp = true;
+        }
+    }
+
+    if (argc == NARG_CNT::TWO || (argc == NARG_CNT::THREE && hasOp)) {
+        return NAsyncWorkPromise(env, thisVar).Schedule("FileIOWrite", cbExec, cbCompl).val_;
+    } else {
+        int cbIdx = ((argc == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::FOURTH);
+        NVal cb(env, funcArg[cbIdx]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule("FileIOWrite", cbExec, cbCompl).val_;
+    }
+}
+
+napi_value PropNExporter::UnlinkSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    if (unlink(path.get()) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value PropNExporter::WriteSync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetWriteArg, bufGuard, buf, len, hasPos, position] =
+        CommonFunc::GetWriteArg(env, funcArg[NARG_POS::SECOND], funcArg[NARG_POS::THIRD]);
+    if (!resGetWriteArg) {
+        return nullptr;
+    }
+
+    ssize_t writeLen;
+    if (position == (size_t)INVALID_POSITION) {
+        writeLen = write(fd, buf, len);
+    } else {
+        writeLen = pwrite(fd, buf, len, position);
+    }
+
+    if (writeLen == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateInt64(env, writeLen).val_;
+}
+
+bool PropNExporter::Export()
+{
+    return exports_.AddProp({
+        NVal::DeclareNapiFunction("access", Access),
+        NVal::DeclareNapiFunction("accessSync", AccessSync),
+        NVal::DeclareNapiFunction("chmod", Chmod::Async),
+        NVal::DeclareNapiFunction("chmodSync", Chmod::Sync),
+        NVal::DeclareNapiFunction("chown", Chown::Async),
+        NVal::DeclareNapiFunction("chownSync", Chown::Sync),
+        NVal::DeclareNapiFunction("close", Close::Async),
+        NVal::DeclareNapiFunction("closeSync", Close::Sync),
+        NVal::DeclareNapiFunction("copyFile", CopyFile::Async),
+        NVal::DeclareNapiFunction("copyFileSync", CopyFile::Sync),
+        NVal::DeclareNapiFunction("createStream", CreateStream::Async),
+        NVal::DeclareNapiFunction("createStreamSync", CreateStream::Sync),
+        NVal::DeclareNapiFunction("createWatcher", Watcher::CreateWatcher),
+        NVal::DeclareNapiFunction("fchmod", Fchmod::Async),
+        NVal::DeclareNapiFunction("fchmodSync", Fchmod::Sync),
+        NVal::DeclareNapiFunction("fchown", Fchown::Async),
+        NVal::DeclareNapiFunction("fchownSync", Fchown::Sync),
+        NVal::DeclareNapiFunction("fdatasync", Fdatasync::Async),
+        NVal::DeclareNapiFunction("fdatasyncSync", Fdatasync::Sync),
+        NVal::DeclareNapiFunction("fdopenStream", FdopenStream::Async),
+        NVal::DeclareNapiFunction("fdopenStreamSync", FdopenStream::Sync),
+        NVal::DeclareNapiFunction("fstat", Fstat::Async),
+        NVal::DeclareNapiFunction("fstatSync", Fstat::Sync),
+        NVal::DeclareNapiFunction("fsync", Fsync::Async),
+        NVal::DeclareNapiFunction("fsyncSync", Fsync::Sync),
+        NVal::DeclareNapiFunction("ftruncate", Ftruncate::Async),
+        NVal::DeclareNapiFunction("ftruncateSync", Ftruncate::Sync),
+        NVal::DeclareNapiFunction("hash", Hash::Async),
+        NVal::DeclareNapiFunction("lchown", Lchown::Async),
+        NVal::DeclareNapiFunction("lchownSync", Lchown::Sync),
+        NVal::DeclareNapiFunction("link", Link::Async),
+        NVal::DeclareNapiFunction("linkSync", Link::Sync),
+        NVal::DeclareNapiFunction("lseek", Lseek::Async),
+        NVal::DeclareNapiFunction("lseekSync", Lseek::Sync),
+        NVal::DeclareNapiFunction("lstat", Lstat::Async),
+        NVal::DeclareNapiFunction("lstatSync", Lstat::Sync),
+        NVal::DeclareNapiFunction("mkdir", Mkdir),
+        NVal::DeclareNapiFunction("mkdirSync", MkdirSync),
+        NVal::DeclareNapiFunction("mkdtemp", Mkdtemp::Async),
+        NVal::DeclareNapiFunction("mkdtempSync", Mkdtemp::Sync),
+        NVal::DeclareNapiFunction("open", Open::Async),
+        NVal::DeclareNapiFunction("opendir", OpenDir::Async),
+        NVal::DeclareNapiFunction("opendirSync", OpenDir::Sync),
+        NVal::DeclareNapiFunction("openSync", Open::Sync),
+        NVal::DeclareNapiFunction("posixFallocate", PosixFallocate::Async),
+        NVal::DeclareNapiFunction("posixFallocateSync", PosixFallocate::Sync),
+        NVal::DeclareNapiFunction("read", Read),
+        NVal::DeclareNapiFunction("readSync", ReadSync),
+        NVal::DeclareNapiFunction("readText", ReadText::Async),
+        NVal::DeclareNapiFunction("readTextSync", ReadText::Sync),
+        NVal::DeclareNapiFunction("rename", Rename::Async),
+        NVal::DeclareNapiFunction("renameSync", Rename::Sync),
+        NVal::DeclareNapiFunction("rmdir", Rmdir::Async),
+        NVal::DeclareNapiFunction("rmdirSync", Rmdir::Sync),
+        NVal::DeclareNapiFunction("stat", Stat::Async),
+        NVal::DeclareNapiFunction("statSync", Stat::Sync),
+        NVal::DeclareNapiFunction("symlink", Symlink::Async),
+        NVal::DeclareNapiFunction("symlinkSync", Symlink::Sync),
+        NVal::DeclareNapiFunction("truncate", Truncate::Async),
+        NVal::DeclareNapiFunction("truncateSync", Truncate::Sync),
+        NVal::DeclareNapiFunction("unlink", Unlink),
+        NVal::DeclareNapiFunction("unlinkSync", UnlinkSync),
+        NVal::DeclareNapiFunction("write", Write),
+        NVal::DeclareNapiFunction("writeSync", WriteSync),
+    });
+}
+
+string PropNExporter::GetClassName()
+{
+    return PropNExporter::className_;
+}
+
+PropNExporter::PropNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.h b/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..d42aa4b57b7785285e50ec57a5e6d594c943373f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/prop_n_exporter.h
@@ -0,0 +1,66 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_PROP_N_EXPORTER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_PROP_N_EXPORTER_H
+
+#include "../../common/napi/n_async/n_ref.h"
+#include "../../common/napi/n_exporter.h"
+#include "../../common/napi/n_val.h"
+#include "../../common/uni_error.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+struct AsyncIOWrtieArg {
+    NRef refWriteArrayBuf_;
+    std::unique_ptr<char[]> guardWriteStr_;
+    ssize_t actLen = 0;
+
+    explicit AsyncIOWrtieArg(NVal refWriteArrayBuf) : refWriteArrayBuf_(refWriteArrayBuf) {}
+    explicit AsyncIOWrtieArg(std::unique_ptr<char[]> &&guardWriteStr) : guardWriteStr_(move(guardWriteStr)) {}
+    ~AsyncIOWrtieArg() = default;
+};
+
+class PropNExporter final : public NExporter {
+public:
+    inline static const std::string className_ = "__properities__";
+
+    static napi_value AccessSync(napi_env env, napi_callback_info info);
+    static napi_value FchmodSync(napi_env env, napi_callback_info info);
+    static napi_value FchownSync(napi_env env, napi_callback_info info);
+    static napi_value MkdirSync(napi_env env, napi_callback_info info);
+    static napi_value ReadSync(napi_env env, napi_callback_info info);
+    static napi_value RenameSync(napi_env env, napi_callback_info info);
+    static napi_value RmdirSync(napi_env env, napi_callback_info info);
+    static napi_value UnlinkSync(napi_env env, napi_callback_info info);
+    static napi_value FsyncSync(napi_env env, napi_callback_info info);
+    static napi_value WriteSync(napi_env env, napi_callback_info info);
+    static napi_value Access(napi_env env, napi_callback_info info);
+    static napi_value Unlink(napi_env env, napi_callback_info info);
+    static napi_value Mkdir(napi_env env, napi_callback_info info);
+    static napi_value Read(napi_env env, napi_callback_info info);
+    static napi_value Write(napi_env env, napi_callback_info info);
+    static UniError WriteExec(std::shared_ptr<AsyncIOWrtieArg> arg, void *buf, size_t len, int fd, size_t position);
+    bool Export() override;
+    std::string GetClassName() override;
+
+    PropNExporter(napi_env env, napi_value exports);
+    ~PropNExporter() = default;
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/rename.cpp b/interfaces/kits/js/src/mod_fileio/properties/rename.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..afb19cedc759e72536b3b7b5174be3c3f0b783c4
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/rename.cpp
@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+#include "rename.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.h>
+
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Rename::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, src, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid src");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, dest, useless] = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid dest");
+        return nullptr;
+    }
+
+    if (rename(src.get(), dest.get()) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Rename::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, src, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid src");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, dest, useless] = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid dest");
+        return nullptr;
+    }
+
+    auto cbExec = [opath = string(src.get()), npath = string(dest.get())](napi_env env) -> UniError {
+        int ret = rename(opath.c_str(), npath.c_str());
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplCallback = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIORename";
+    NVal thisVar(env, funcArg.GetThisVar());
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/rename.h b/interfaces/kits/js/src/mod_fileio/properties/rename.h
new file mode 100644
index 0000000000000000000000000000000000000000..0333170a66be1f5666ae5f17de6856d0bbf4e81c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/rename.h
@@ -0,0 +1,31 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_RENAME_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_RENAME_H
+
+#include "../../common/napi/n_val.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Rename final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/rmdir.cpp b/interfaces/kits/js/src/mod_fileio/properties/rmdir.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fcce9f3d5add18ec47ffaf71b5e8b3803106d3d3
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/rmdir.cpp
@@ -0,0 +1,94 @@
+/*
+ * 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.
+ */
+
+#include "rmdir.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.h>
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Rmdir::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    if (rmdir(path.get()) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Rmdir::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    auto cbExec = [path = string(path.get())](napi_env env) -> UniError {
+        int res = rmdir(path.c_str());
+        if (res == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    const string procedureName = "FileIORmdir";
+    NVal thisVar(env, funcArg.GetThisVar());
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/rmdir.h b/interfaces/kits/js/src/mod_fileio/properties/rmdir.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e6e7bffeeda510f10ff9a79a5d08a8d7b830c4c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/rmdir.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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_RMDIR_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_RMDIR_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Rmdir final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/stat.cpp b/interfaces/kits/js/src/mod_fileio/properties/stat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26cded63e7f0b65f08f5930b4974c8f16958c88d
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/stat.cpp
@@ -0,0 +1,128 @@
+/*
+ * 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.
+ */
+#include "stat.h"
+
+#include <memory>
+#include <tuple>
+
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_class.h"
+#include "../../common/napi/n_func_arg.h"
+#include "../../common/napi/n_val.h"
+#include "../../common/uni_error.h"
+
+#include "../class_stat/stat_entity.h"
+#include "../class_stat/stat_n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Stat::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    aut [resGetFirstArg, pathPtr, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "The first argument requires type string");
+        return nullptr;
+    }
+
+    struct stat buf;
+    int ret = stat(pathPtr.get(), &buf);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    napi_value objStat = NClass::InstantiateClass(env, StatNExporter::className_, {});
+    if (!objStat) {
+        return nullptr;
+    }
+
+    auto statEntity = NClass::GetEntityOf<StatEntity>(env, objStat);
+    if (!statEntity) {
+        return nullptr;
+    }
+
+    statEntity->stat_ = buf;
+    return objStat;
+}
+
+struct AsyncStatArg {
+    struct stat stat_;
+};
+
+napi_value Stat::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, tmp, unuse] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    string path = tmp.get();
+    auto arg = make_shared<AsyncStatArg>();
+    auto cbExec = [arg, path](napi_env env) -> UniError {
+        if (stat(path.c_str(), &arg->stat_)) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+
+        napi_value objStat = NClass::InstantiateClass(env, StatNExporter::className_, {});
+        if (!objStat) {
+            return { env, UniError(EIO).GetNapiErr(env) };
+        }
+
+        auto statEntity = NClass::GetEntityOf<StatEntity>(env, objStat);
+        if (!statEntity) {
+            return { env, UniError(EIO).GetNapiErr(env) };
+        }
+
+        statEntity->stat_ = arg->stat_;
+        return { env, objStat };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "fileioStatStat";
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/stat.h b/interfaces/kits/js/src/mod_fileio/properties/stat.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b16373e9b313c97cbfb9c3c21c06cf521edb82f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/stat.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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_STAT_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_STAT_H
+
+#include "../../common/napi/uni_header.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Stat final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/symlink.cpp b/interfaces/kits/js/src/mod_fileio/properties/symlink.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..98d4739455e0e36689b8b145bea92da6a1b70f05
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/symlink.cpp
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2021-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 "symlink.h"
+#include <cstring>
+#include <fcntl.h>
+#include <tuple>
+#include <unistd.h>
+
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static tuple<bool, string, string> GetSymlinkArg(napi_env env, const NFuncArg &funcArg)
+{
+    auto [resGetFirstArg, src, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid src");
+        return { false, "", "" };
+    }
+
+    auto [resGetSecondArg, dest, useless] = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid dest");
+        return { false, "", "" };
+    }
+
+    return { true, src.get(), dest.get() };
+}
+
+napi_value Symlink::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetSymlinkArg, oldPath, newPath] = GetSymlinkArg(env, funcArg);
+    if (!resGetSymlinkArg) {
+        return nullptr;
+    }
+
+    if (symlink(oldPath.c_str(), newPath.c_str()) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Symlink::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetSymlinkArg, oldPath, newPath] = GetSymlinkArg(env, funcArg);
+    if (!resGetSymlinkArg) {
+        return nullptr;
+    }
+
+    auto cbExec = [oldPath = move(oldPath), newPath = move(newPath)](napi_env env) -> UniError {
+        int ret = symlink(oldPath.c_str(), newPath.c_str());
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplCallback = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIOsymLink";
+    NVal thisVar(env, funcArg.GetThisVar());
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/symlink.h b/interfaces/kits/js/src/mod_fileio/properties/symlink.h
new file mode 100644
index 0000000000000000000000000000000000000000..b770a27e874c3392e3ae46e112a6342140ed06f7
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/symlink.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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_SYMLINK_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_SYMLINK_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Symlink final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/truncate.cpp b/interfaces/kits/js/src/mod_fileio/properties/truncate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b86f59279632123a08b8e0aa2b764ff5e9982515
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/truncate.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2021-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 "truncate.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.h>
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Truncate::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    int ret = -1;
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        ret = truncate(path.get(), 0);
+    } else {
+        auto [resGetSecondArg, len] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid len");
+        }
+        ret = truncate(path.get(), len);
+    }
+
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Truncate::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    int len = 0;
+    size_t argc = funcArg.GetArgc();
+    if (argc > NARG_CNT::ONE) {
+        auto [resGetSecondArg, length] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid len");
+            return nullptr;
+        }
+        len = length;
+    }
+
+    auto cbExec = [path = string(path.get()), len](napi_env env) -> UniError {
+        int ret = truncate(path.c_str(), len);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "FileIOTruncate";
+    if (argc == NARG_CNT::ONE || (argc == NARG_CNT::TWO && NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number))) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/truncate.h b/interfaces/kits/js/src/mod_fileio/properties/truncate.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4f32e0264947345ea5803bec3148181aabf347f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/truncate.h
@@ -0,0 +1,35 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_TRUNCATE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_TRUNCATE_H
+
+#include "../../common/log.h"
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Truncate final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/watcher.cpp b/interfaces/kits/js/src/mod_fileio/properties/watcher.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b822f9a3c6461034cb62979578c32354e451d672
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/watcher.cpp
@@ -0,0 +1,106 @@
+/*
+ * 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.
+ */
+
+#include "watcher.h"
+
+#include <cstring>
+#include <fcntl.h>
+#include <tuple>
+#include <unistd.h>
+
+#include "../../common/napi/n_async/n_ref.h"
+#include "../../common/napi/n_class.h"
+#include "../../common/napi/n_func_arg.h"
+#include "../../common/napi/n_val.h"
+#include "../../common/uni_error.h"
+
+#include "../class_watcher/watcher_entity.h"
+#include "../class_watcher/watcher_n_exporter.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+void Watcher::RunCommand(uv_fs_event_t *handle, const char *filename, int events, int status)
+{
+    WatcherInforArg *information = (WatcherInforArg *)handle->data;
+    uint32_t eventsFirst { events };
+    uint32_t eventsSecond { information->events };
+    if (eventsFirst & eventsSecond) {
+        napi_handle_scope scope = nullptr;
+        napi_open_handle_scope(information->env, &scope);
+        napi_value callback = nullptr;
+        napi_get_reference_value(information->env, information->ref, &callback);
+        vector<napi_value> argv;
+        argv.push_back(NVal::CreateInt64(information->env, events).val_);
+        napi_value global = nullptr;
+        napi_get_global(information->env, &global);
+        napi_value tmp = nullptr;
+        napi_call_function(information->env, global, callback, argv.size(), argv.data(), &tmp);
+    }
+}
+
+napi_value Watcher::CreateWatcher(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [succGetPath, filename, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!succGetPath) {
+        UniError(EINVAL).ThrowErr(env, "Invalid filename");
+        return nullptr;
+    }
+
+    auto [succGetEvent, event] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!succGetEvent) {
+        UniError(EINVAL).ThrowErr(env, "Invalid event");
+        return nullptr;
+    }
+
+    unique_ptr<WatcherInforArg> data = make_unique<WatcherInforArg>();
+    data->events = event;
+    data->env = env;
+    NVal val = NVal(env, funcArg[NARG_POS::THIRD]);
+    napi_create_reference(val.env_, val.val_, 1, &(data->ref));
+    uv_loop_s *loop = nullptr;
+    napi_get_uv_event_loop(env, &loop);
+    unique_ptr<uv_fs_event_t, WatcherHandleDeleter> fsEventReq(new uv_fs_event_t);
+    uv_fs_event_init(loop, fsEventReq.get());
+    fsEventReq->data = data.get();
+    uv_fs_event_start(fsEventReq.get(), RunCommand, filename.get(), UV_FS_EVENT_RECURSIVE);
+
+    napi_value objWatcher = NClass::InstantiateClass(env, WatcherNExporter::className_, {});
+    if (!objWatcher) {
+        UniError(EINVAL).ThrowErr(env, "objWatcher create failed");
+        return nullptr;
+    }
+
+    auto watcherEntity = NClass::GetEntityOf<WatcherEntity>(env, objWatcher);
+    if (!watcherEntity) {
+        UniError(EINVAL).ThrowErr(env, "watcherEntity get failed");
+        return nullptr;
+    }
+
+    watcherEntity->fsEventReq_ = std::move(fsEventReq);
+    watcherEntity->data_ = std::move(data);
+
+    return objWatcher;
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/watcher.h b/interfaces/kits/js/src/mod_fileio/properties/watcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..45c100cb21057e0a0711212df5ec9846985aebaf
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/watcher.h
@@ -0,0 +1,35 @@
+/*
+ * 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 INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_WATCHER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_WATCHER_H
+
+#include <uv.h>
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Watcher final {
+public:
+    static napi_value CreateWatcher(napi_env env, napi_callback_info info);
+
+private:
+    static void RunCommand(uv_fs_event_t *handle, const char *filename, int events, int status);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file