diff --git a/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.cpp b/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31ff9ec263797ba2f333c5a252a4b5a4daba373e
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2025 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 "stream_wrapper.h"
+
+#include <string>
+
+#include "ani_helper.h"
+#include "filemgmt_libhilog.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+using namespace OHOS::FileManagement::ModuleFileIO;
+using namespace std;
+
+FsStream *StreamWrapper::Unwrap(ani_env *env, ani_object object)
+{
+    ani_long nativePtr;
+    auto ret = env->Object_GetFieldByName_Long(object, "nativePtr", &nativePtr);
+    if (ret != ANI_OK) {
+        HILOGE("Unwrap fsFile err: %{private}d", ret);
+        return nullptr;
+    }
+    uintptr_t ptrValue = static_cast<uintptr_t>(nativePtr);
+    FsStream *stream = reinterpret_cast<FsStream *>(ptrValue);
+    return stream;
+}
+
+ani_object StreamWrapper::Wrap(ani_env *env, const FsStream *stream)
+{
+    static const char *className = "L@ohos/file/fs/StreamInner;";
+    ani_class cls;
+    if (ANI_OK != env->FindClass(className, &cls)) {
+        HILOGE("Cannot find class %s", className);
+        return nullptr;
+    }
+    ani_method ctor;
+    if (ANI_OK != env->Class_FindMethod(cls, "<ctor>", "J:V", &ctor)) {
+        HILOGE("Cannot find constructor method for class %s", className);
+        return nullptr;
+    }
+    ani_long ptr = static_cast<ani_long>(reinterpret_cast<std::uintptr_t>(stream));
+    ani_object obj;
+    if (ANI_OK != env->Object_New(cls, ctor, &obj, ptr)) {
+        HILOGE("New %s obj Failed!", className);
+        return nullptr;
+    }
+
+    return obj;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.h b/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.h
new file mode 100644
index 0000000000000000000000000000000000000000..a99f6d4ad2c85500c8193730d661693d83a2044c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_stream/ani/stream_wrapper.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025 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_FS_STREAM_WRAPPER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_STREAM_WRAPPER_H
+
+#include <ani.h>
+#include "fs_stream.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+class StreamWrapper final {
+public:
+    static FsStream *Unwrap(ani_env *env, ani_object object);
+    static ani_object Wrap(ani_env *env, const FsStream *stream);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_STREAM_WRAPPER_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.cpp b/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e28dfa77ce4a984cdf93ce3a48b12c84e9882978
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.cpp
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2025 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 "stream_instantiator.h"
+
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "stream_entity.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<FsStream *> StreamInstantiator::InstantiateStream(FILE *file)
+{
+    FsResult<FsStream *> result = FsStream::Constructor();
+    if (!result.IsSuccess()) {
+        HILOGE("Failed to instantiate class");
+        int ret = fclose(file);
+        if (ret < 0) {
+            HILOGE("Failed to close file");
+        }
+        return FsResult<FsStream *>::Error(EIO);
+    }
+
+    const FsStream *objStream = result.GetData().value();
+    if (!objStream) {
+        HILOGE("Failed to get FsStream");
+        int ret = fclose(file);
+        if (ret < 0) {
+            HILOGE("Failed to close file");
+        }
+        return FsResult<FsStream *>::Error(EIO);
+    }
+
+    auto *streamEntity = objStream->GetStreamEntity();
+    if (!streamEntity) {
+        HILOGE("Failed to get streamEntity");
+        int ret = fclose(file);
+        if (ret < 0) {
+            HILOGE("Failed to close file");
+        }
+        delete objStream;
+        objStream = nullptr;
+        return FsResult<FsStream *>::Error(EIO);
+    }
+
+    auto fp = std::shared_ptr<FILE>(file, fclose);
+    if (fp == nullptr) {
+        HILOGE("Failed to request heap memory.");
+        int ret = fclose(file);
+        if (ret < 0) {
+            HILOGE("Failed to close file");
+        }
+        delete objStream;
+        objStream = nullptr;
+        return FsResult<FsStream *>::Error(ENOMEM);
+    }
+
+    streamEntity->fp.swap(fp);
+    return result;
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.h b/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf98d7b5305804dc460e210491fcd66ab79ffe96
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/class_stream/stream_instantiator.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 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_FS_CLASS_STREAM_INSTANTIATOR_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_STREAM_INSTANTIATOR_H
+
+#include "filemgmt_libfs.h"
+#include "fs_stream.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+class StreamInstantiator {
+public:
+    static FsResult<FsStream *> InstantiateStream(FILE *file);
+};
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_CLASS_STREAM_INSTANTIATOR_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8fd35e59b2a16b0ba877b96c815d090b6b07d74
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2025 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 "create_stream_ani.h"
+
+#include "create_stream_core.h"
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "stream_wrapper.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+ani_object CreateStreamAni::CreateStreamSync(
+    ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string mode)
+{
+    auto [succPath, srcPath] = TypeConverter::ToUTF8String(env, path);
+    if (!succPath) {
+        HILOGE("Invalid path");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    auto [succMode, openMode] = TypeConverter::ToUTF8String(env, mode);
+    if (!succMode) {
+        HILOGE("Invalid mode");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    FsResult<FsStream *> ret = CreateStreamCore::DoCreateStream(srcPath, openMode);
+    if (!ret.IsSuccess()) {
+        HILOGE("create stream failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return nullptr;
+    }
+
+    const FsStream *stream = ret.GetData().value();
+    auto result = StreamWrapper::Wrap(env, move(stream));
+    if (result == nullptr) {
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+    return result;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..2052b6b4d07e5705439f08de2b3c401bf3febfdb
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/create_stream_ani.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025 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_FS_PROPERTIES_CREATE_STREAM_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_CREATE_STREAM_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+class CreateStreamAni final {
+public:
+    static ani_object CreateStreamSync(
+        ani_env *env, [[maybe_unused]] ani_class clazz, ani_string path, ani_string mode);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_CREATE_STREAM_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bc6e8d27415910d8118119f59264400d58283398
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.cpp
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2025 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 "fdopen_stream_ani.h"
+
+#include "error_handler.h"
+#include "filemgmt_libhilog.h"
+#include "fdopen_stream_core.h"
+#include "stream_wrapper.h"
+#include "type_converter.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+
+using namespace std;
+using namespace OHOS::FileManagement::ModuleFileIO;
+
+ani_object FdopenStreamAni::FdopenStreamSync(
+    ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_string mode)
+{
+    auto [succMode, openMode] = TypeConverter::ToUTF8String(env, mode);
+    if (!succMode) {
+        HILOGE("Invalid mode");
+        ErrorHandler::Throw(env, EINVAL);
+        return nullptr;
+    }
+
+    FsResult<FsStream *> ret = FdopenStreamCore::DoFdopenStream(static_cast<int32_t>(fd), openMode);
+    if (!ret.IsSuccess()) {
+        HILOGE("fdopen stream failed");
+        const auto &err = ret.GetError();
+        ErrorHandler::Throw(env, err);
+        return nullptr;
+    }
+
+    const FsStream *stream = ret.GetData().value();
+    auto result = StreamWrapper::Wrap(env, move(stream));
+    if (result == nullptr) {
+        ErrorHandler::Throw(env, UNKNOWN_ERR);
+        return nullptr;
+    }
+    return result;
+}
+
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h
new file mode 100644
index 0000000000000000000000000000000000000000..81f0fde31b630e1e90a6243ba335cd8b5c254215
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/ani/fdopen_stream_ani.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 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_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
+
+#include <ani.h>
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+namespace ANI {
+class FdopenStreamAni final {
+public:
+    static ani_object FdopenStreamSync(ani_env *env, [[maybe_unused]] ani_class clazz, ani_double fd, ani_string mode);
+};
+} // namespace ANI
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_ANI_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/create_stream_core.cpp b/interfaces/kits/js/src/mod_fs/properties/create_stream_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e17d5a1ba01ff3880d99d8cabe5a96dcd5f962e6
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/create_stream_core.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025 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 "create_stream_core.h"
+
+#include <memory>
+
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "fs_utils.h"
+#include "stream_instantiator.h"
+#include "stream_entity.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<FsStream *> CreateStreamCore::DoCreateStream(const std::string &path, const std::string &mode)
+{
+    FILE *file = fopen(path.c_str(), mode.c_str());
+    if (!file) {
+        HILOGE("Failed to fopen file by path");
+        return FsResult<FsStream *>::Error(errno);
+    }
+
+    return StreamInstantiator::InstantiateStream(move(file));
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/create_stream_core.h b/interfaces/kits/js/src/mod_fs/properties/create_stream_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c0a2aade48bf44ad726e580d500a099d2ad086c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/create_stream_core.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 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_FS_PROPERTIES_CREATE_STREAM_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_CREATE_STREAM_CORE_H
+
+#include "filemgmt_libfs.h"
+#include "fs_stream.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+
+class CreateStreamCore final {
+public:
+    static FsResult<FsStream *> DoCreateStream(const std::string &path, const std::string &mode);
+};
+
+struct AsyncCreateStreamArg {
+    std::shared_ptr<FILE> fp { nullptr };
+};
+
+const std::string PROCEDURE_CREATESTREAM_NAME = "FileIOCreateStream";
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_CREATE_STREAM_CORE_H
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4337cd766b644ce8949f7643ff2816c8013f386d
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 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 "fdopen_stream_core.h"
+
+#include <memory>
+
+#include "file_utils.h"
+#include "filemgmt_libhilog.h"
+#include "fs_utils.h"
+#include "stream_instantiator.h"
+#include "stream_entity.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+using namespace std;
+
+FsResult<FsStream *> FdopenStreamCore::DoFdopenStream(const int &fd, const string &mode)
+{
+    if (fd < 0) {
+        HILOGE("Invalid fd");
+        return FsResult<FsStream *>::Error(EINVAL);
+    }
+
+    FILE *file = fdopen(fd, mode.c_str());
+    if (!file) {
+        HILOGE("Failed to fopen file by fd");
+        return FsResult<FsStream *>::Error(errno);
+    }
+
+    return StreamInstantiator::InstantiateStream(move(file));
+}
+
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h
new file mode 100644
index 0000000000000000000000000000000000000000..a319480fdd0c2aad52dc938f1b0512cc529776e6
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fs/properties/fdopen_stream_core.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 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_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
+
+#include "filemgmt_libfs.h"
+#include "fs_stream.h"
+
+namespace OHOS {
+namespace FileManagement {
+namespace ModuleFileIO {
+
+class FdopenStreamCore final {
+public:
+    static FsResult<FsStream *> DoFdopenStream(const int &fd, const string &mode);
+};
+
+struct AsyncFdopenStreamArg {
+    std::shared_ptr<FILE> fp { nullptr };
+};
+
+const std::string PROCEDURE_FDOPENSTREAM_NAME = "FileIOFdopenStream";
+} // namespace ModuleFileIO
+} // namespace FileManagement
+} // namespace OHOS
+#endif // INTERFACES_KITS_JS_SRC_MOD_FS_PROPERTIES_FDOPEN_STREAM_CORE_H
\ No newline at end of file