react-native-cloud-storage 2.3.0 → 3.0.0

package/ios/RCTCloudStorageLocalFileSystem.mm

@@ -0,0 +1,149 @@
+#import <Foundation/Foundation.h>
+
+#import <CloudStorageSpec/CloudStorageSpec.h>
+
+#if __has_include("react_native_cloud_storage-Swift.h")
+#import "react_native_cloud_storage-Swift.h"
+#elif __has_include(<react_native_cloud_storage/react_native_cloud_storage-Swift.h>)
+#import <react_native_cloud_storage/react_native_cloud_storage-Swift.h>
+#else
+#error "Unable to locate Swift compatibility header for react-native-cloud-storage."
+#endif
+
+@interface RCTCloudStorageLocalFileSystem : NSObject <NativeCloudStorageLocalFileSystemSpec>
+@end
+
+@implementation RCTCloudStorageLocalFileSystem {
+  CloudStorageLocalFileSystem *_cloudStorageLocalFileSystem;
+}
+
++ (NSString *)moduleName
+{
+  return @"CloudStorageLocalFileSystem";
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _cloudStorageLocalFileSystem = [CloudStorageLocalFileSystem new];
+  }
+
+  return self;
+}
+
+- (NSDictionary<NSString *, id> *)serializeDownloadOptions:
+    (JS::NativeCloudStorageLocalFileSystem::LocalFileSystemDownloadOptions &)options
+{
+  NSMutableDictionary<NSString *, id> *serializedOptions = [NSMutableDictionary new];
+
+  id<NSObject> headers = options.headers();
+  if (headers != nil) {
+    serializedOptions[@"headers"] = headers;
+  }
+
+  return serializedOptions;
+}
+
+- (NSDictionary<NSString *, id> *)serializeUploadOptions:
+    (JS::NativeCloudStorageLocalFileSystem::LocalFileSystemUploadOptions &)options
+{
+  NSMutableDictionary<NSString *, id> *serializedOptions = [NSMutableDictionary new];
+
+  id<NSObject> headers = options.headers();
+  if (headers != nil) {
+    serializedOptions[@"headers"] = headers;
+  }
+
+  NSString *method = options.method();
+  if (method != nil) {
+    serializedOptions[@"method"] = method;
+  }
+
+  NSString *uploadType = options.uploadType();
+  if (uploadType != nil) {
+    serializedOptions[@"uploadType"] = uploadType;
+  }
+
+  NSString *fieldName = options.fieldName();
+  if (fieldName != nil) {
+    serializedOptions[@"fieldName"] = fieldName;
+  }
+
+  id<NSObject> parameters = options.parameters();
+  if (parameters != nil) {
+    serializedOptions[@"parameters"] = parameters;
+  }
+
+  return serializedOptions;
+}
+
+- (facebook::react::ModuleConstants<JS::NativeCloudStorageLocalFileSystem::Constants::Builder>)constantsToExport
+{
+  return (facebook::react::ModuleConstants<JS::NativeCloudStorageLocalFileSystem::Constants::Builder>)[self getConstants];
+}
+
+- (facebook::react::ModuleConstants<JS::NativeCloudStorageLocalFileSystem::Constants::Builder>)getConstants
+{
+  NSDictionary<NSString *, id> *constants = [_cloudStorageLocalFileSystem constantsToExport];
+  NSString *temporaryDirectory = constants[@"temporaryDirectory"];
+
+  return facebook::react::typedConstants<JS::NativeCloudStorageLocalFileSystem::Constants::Builder>({
+      .temporaryDirectory = temporaryDirectory ?: NSTemporaryDirectory(),
+  });
+}
+
+- (void)createFile:(NSString *)path
+              data:(NSString *)data
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageLocalFileSystem createFile:path withData:data withResolver:resolve withRejecter:reject];
+}
+
+- (void)readFile:(NSString *)path
+         resolve:(RCTPromiseResolveBlock)resolve
+          reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageLocalFileSystem readFile:path withResolver:resolve withRejecter:reject];
+}
+
+- (void)downloadFile:(NSString *)remoteUri
+           localPath:(NSString *)localPath
+             options:(JS::NativeCloudStorageLocalFileSystem::LocalFileSystemDownloadOptions &)options
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageLocalFileSystem
+      downloadFile:remoteUri
+     withLocalPath:localPath
+       withOptions:[self serializeDownloadOptions:options]
+      withResolver:resolve
+      withRejecter:reject];
+}
+
+- (void)uploadFile:(NSString *)localPath
+         remoteUri:(NSString *)remoteUri
+           options:(JS::NativeCloudStorageLocalFileSystem::LocalFileSystemUploadOptions &)options
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_cloudStorageLocalFileSystem
+      uploadFile:localPath
+     withRemoteUri:remoteUri
+       withOptions:[self serializeUploadOptions:options]
+      withResolver:resolve
+      withRejecter:reject];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeCloudStorageLocalFileSystemSpecJSI>(params);
+}
+
+@end

package/ios/Utils/CloudKitUtils.swift

@@ -42,10 +42,10 @@ enum CloudKitUtils {
   }
 
   /**
-     Returns the iCloud directory URL for the given scope.
+     Returns the directory URL for the given scope.
 
      - Parameter scope: The scope of the directory.
-     - Returns: The URL of the iCloud directory, or nil if no directory is found.
+     - Returns: The URL of the scope directory, or nil if no directory is found.
    */
   private static func getScopeDirectory(scope: DirectoryScope) -> URL? {
     switch scope {
@@ -53,6 +53,8 @@ enum CloudKitUtils {
       appDataDirectory
     case .documents:
       documentsDirectory
+    case .documentsLegacy:
+      legacyDocumentsDirectory
     }
   }
 
@@ -107,6 +109,10 @@ enum CloudKitUtils {
   }
 
   static var documentsDirectory: URL? {
+    fileManager.url(forUbiquityContainerIdentifier: nil)?.appendingPathComponent("Documents")
+  }
+
+  static var legacyDocumentsDirectory: URL? {
     fileManager.urls(for: .documentDirectory, in: .userDomainMask).first
   }
 }

package/ios/Utils/FileUtils.swift

@@ -28,8 +28,7 @@ enum FileUtils {
     }
 
     do {
-      let fileContents = try String(contentsOf: fileUrl, encoding: .utf8)
-      return fileContents
+      return try String(contentsOf: fileUrl, encoding: .utf8)
     } catch {
       throw CloudStorageError.readError(path: fileUrl.path)
     }
@@ -73,8 +72,7 @@ enum FileUtils {
    */
   static func listFiles(directoryUrl: URL) throws -> [String] {
     do {
-      let fileUrls = try fileManager.contentsOfDirectory(atPath: directoryUrl.path)
-      return fileUrls
+      return try fileManager.contentsOfDirectory(atPath: directoryUrl.path)
     } catch {
       throw CloudStorageError.readError(path: directoryUrl.path)
     }

package/ios/Utils/Promise.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import React
 
 // MARK: - Promise
 

package/ios/Utils/Types.swift

@@ -20,6 +20,7 @@ enum UploadType: String {
 enum DirectoryScope: String {
   case appData = "app_data"
   case documents
+  case documentsLegacy = "documents_legacy"
 }
 
 // MARK: - FileStat

package/ios/react_native_cloud_storage.h

@@ -0,0 +1,6 @@
+#ifndef REACT_NATIVE_CLOUD_STORAGE_H
+#define REACT_NATIVE_CLOUD_STORAGE_H
+
+#import <Foundation/Foundation.h>
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-cloud-storage",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "☁️ Save to & read from iCloud and Google Drive using React Native",
   "main": "dist/commonjs/index",
   "module": "dist/module/index",
@@ -37,11 +37,12 @@
   ],
   "scripts": {
     "clean": "del-cli android/build ios/build dist",
-    "build": "yarn clean && bob build && rm -f dist/commonjs/package.json",
-    "test": "jest",
+    "build": "pnpm clean && bob build && rm -f dist/commonjs/package.json",
+    "codegen": "pnpm run codegen:clean && pnpm run codegen:ios && pnpm run codegen:android",
+    "codegen:clean": "del-cli android/generated ios/generated",
+    "codegen:ios": "node ../../node_modules/react-native/scripts/generate-codegen-artifacts.js --path . --targetPlatform ios --outputPath ios/generated",
+    "codegen:android": "node ../../node_modules/react-native/scripts/generate-codegen-artifacts.js --path . --targetPlatform android --outputPath android/generated",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src/**/*.ts",
-    "format": "prettier --write . && ./scripts/swiftformat.sh",
     "release": "release-it",
     "prepack": "cp ../../README.md ./README.md",
     "postpack": "rm ./README.md"
@@ -56,36 +57,30 @@
     "url": "https://github.com/kuatsu/react-native-cloud-storage/issues"
   },
   "homepage": "https://github.com/kuatsu/react-native-cloud-storage#readme",
-  "packageManager": "yarn@3.6.1",
+  "packageManager": "pnpm@10.28.2",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
     "@expo/config-plugins": "^10.0.2",
     "@release-it/conventional-changelog": "^5.0.0",
-    "@types/react": "~19.0.10",
-    "react": "19.0.0",
-    "react-native": "0.79.3",
+    "@types/react": "~19.2.14",
+    "react": "19.2.0",
+    "react-native": "0.83.2",
     "react-native-builder-bob": "^0.30.2",
     "release-it": "^15.0.0",
-    "typescript": "~5.8.3"
+    "typescript": "~5.9.3"
   },
   "peerDependencies": {
     "expo": ">=48.0.0",
     "react": "*",
-    "react-native": "*"
+    "react-native": ">=0.76"
   },
   "peerDependenciesMeta": {
     "expo": {
       "optional": true
     }
   },
-  "jest": {
-    "preset": "react-native",
-    "modulePathIgnorePatterns": [
-      "<rootDir>/dist/"
-    ]
-  },
   "release-it": {
     "git": {
       "commitMessage": "chore: release ${version}",
@@ -122,5 +117,23 @@
         }
       ]
     ]
+  },
+  "codegenConfig": {
+    "name": "CloudStorageSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/specs",
+    "android": {
+      "javaPackageName": "com.cloudstorage"
+    },
+    "ios": {
+      "modules": {
+        "CloudStorageCloudKit": {
+          "className": "RCTCloudStorageCloudKit"
+        },
+        "CloudStorageLocalFileSystem": {
+          "className": "RCTCloudStorageLocalFileSystem"
+        }
+      }
+    }
   }
 }

package/react-native-cloud-storage.podspec

@@ -15,6 +15,8 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/Kuatsu/react-native-cloud-storage.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.exclude_files = "ios/generated/**/*"
+  s.public_header_files = "ios/react_native_cloud_storage.h"
 
   # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
   # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.

package/src/cloud-storage.ts

@@ -5,11 +5,11 @@ import {
   type CloudStorageProviderOptions,
   type DeepRequired,
 } from './types/main';
-import { NativeCloudStorageErrorCode, type NativeStorage } from './types/native';
+import { NativeCloudStorageErrorCode, type NativeStorage, type NativeStorageScope } from './types/native';
 import { isProviderSupported } from './utils/helpers';
-import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import { Platform, type EventSubscription } from 'react-native';
 import GoogleDrive from './storages/google-drive';
-import { NativeCloudKit } from './storages/cloudkit';
+import { NativeCloudKit, NativeCloudKitModule, type NativeCloudStorageCloudKitTurboModule } from './storages/cloudkit';
 import { DEFAULT_PROVIDER_OPTIONS, LINKING_ERROR } from './utils/constants';
 import CloudStorageError from './utils/cloud-storage-error';
 
@@ -20,6 +20,7 @@ export default class RNCloudStorage {
     options: (typeof DEFAULT_PROVIDER_OPTIONS)[keyof typeof DEFAULT_PROVIDER_OPTIONS];
   };
   private cloudAvailabilityListeners: ((available: boolean) => void)[] = [];
+  private cloudAvailabilitySubscription: EventSubscription | null = null;
 
   //#region Constructor and configuration
   /**
@@ -97,6 +98,49 @@ export default class RNCloudStorage {
     return this.provider.provider;
   }
 
+  private notifyCloudAvailabilityListeners(available: boolean): void {
+    for (const listener of this.cloudAvailabilityListeners) {
+      listener(available);
+    }
+  }
+
+  private refreshCloudAvailability(): void {
+    this.nativeStorage
+      .isCloudAvailable()
+      .then((available) => {
+        this.notifyCloudAvailabilityListeners(available);
+      })
+      .catch(() => {
+        // ignore errors when refreshing availability after provider changes
+      });
+  }
+
+  private getNativeCloudKitModule(): NativeCloudStorageCloudKitTurboModule | null {
+    return this.provider.provider === CloudStorageProvider.ICloud ? NativeCloudKitModule : null;
+  }
+
+  private removeCloudAvailabilitySubscription(): void {
+    this.cloudAvailabilitySubscription?.remove();
+    this.cloudAvailabilitySubscription = null;
+  }
+
+  private configureCloudAvailabilitySubscription(): void {
+    this.removeCloudAvailabilitySubscription();
+
+    if (this.cloudAvailabilityListeners.length === 0) {
+      return;
+    }
+
+    const nativeCloudKitModule = this.getNativeCloudKitModule();
+    if (!nativeCloudKitModule) {
+      return;
+    }
+
+    this.cloudAvailabilitySubscription = nativeCloudKitModule.onCloudAvailabilityChanged((event) => {
+      this.notifyCloudAvailabilityListeners(event.available);
+    });
+  }
+
   /**
    * Sets the current CloudStorageProvider.
    * @param provider The provider to set.
@@ -111,22 +155,8 @@ export default class RNCloudStorage {
       options: DEFAULT_PROVIDER_OPTIONS[provider],
     };
 
-    // Emit an event to notify useIsCloudAvailable() hook consumers of the new cloud availability status
-    this.nativeStorage.isCloudAvailable().then((available) => {
-      for (const listener of this.cloudAvailabilityListeners) {
-        listener(available);
-      }
-    });
-
-    if (provider === CloudStorageProvider.ICloud) {
-      // Listen to native cloud availability change events
-      const eventEmitter = new NativeEventEmitter(NativeModules.CloudStorageEventEmitter);
-      eventEmitter.addListener('RNCloudStorage.cloud.availability-changed', (event: { available: boolean }) => {
-        for (const listener of this.cloudAvailabilityListeners) {
-          listener(event.available);
-        }
-      });
-    }
+    this.refreshCloudAvailability();
+    this.configureCloudAvailabilitySubscription();
   }
 
   /**
@@ -150,20 +180,44 @@ export default class RNCloudStorage {
 
     if (this.provider.provider === CloudStorageProvider.GoogleDrive && 'accessToken' in newOptions) {
       // Emit an event to notify useIsCloudAvailable() hook consumers of the new cloud availability status
-      for (const listener of this.cloudAvailabilityListeners) {
-        listener(
-          !!(newOptions as Required<CloudStorageProviderOptions[CloudStorageProvider.GoogleDrive]>).accessToken?.length
-        );
-      }
+      this.notifyCloudAvailabilityListeners(
+        !!(newOptions as Required<CloudStorageProviderOptions[CloudStorageProvider.GoogleDrive]>).accessToken?.length
+      );
     }
   }
 
   subscribeToCloudAvailability(listener: (available: boolean) => void): void {
     this.cloudAvailabilityListeners.push(listener);
+
+    if (this.cloudAvailabilityListeners.length === 1) {
+      this.configureCloudAvailabilitySubscription();
+      this.refreshCloudAvailability();
+    }
   }
 
   unsubscribeFromCloudAvailability(listener: (available: boolean) => void): void {
     this.cloudAvailabilityListeners = this.cloudAvailabilityListeners.filter((l) => l !== listener);
+
+    if (this.cloudAvailabilityListeners.length === 0) {
+      this.removeCloudAvailabilitySubscription();
+    }
+  }
+
+  private resolveNativeScope(scope?: CloudStorageScope): NativeStorageScope {
+    const resolvedScope = scope ?? this.provider.options.scope;
+
+    if (this.provider.provider !== CloudStorageProvider.ICloud || resolvedScope !== CloudStorageScope.Documents) {
+      return resolvedScope;
+    }
+
+    const iCloudOptions = this.provider.options as DeepRequired<
+      CloudStorageProviderOptions[CloudStorageProvider.ICloud]
+    >;
+    if (iCloudOptions.documentsMode === 'legacy_sandbox') {
+      return 'documents_legacy';
+    }
+
+    return resolvedScope;
   }
   //#endregion
 
@@ -185,7 +239,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves when the data has been appended.
    */
   appendFile(path: string, data: string, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.appendToFile(path, data, scope ?? this.provider.options.scope);
+    return this.nativeStorage.appendToFile(path, data, this.resolveNativeScope(scope));
   }
 
   /**
@@ -195,7 +249,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves to true if the path exists, false otherwise.
    */
   exists(path: string, scope?: CloudStorageScope): Promise<boolean> {
-    return this.nativeStorage.fileExists(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.fileExists(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -206,7 +260,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves when the file has been written.
    */
   writeFile(path: string, data: string, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.createFile(path, data, scope ?? this.provider.options.scope, true);
+    return this.nativeStorage.createFile(path, data, this.resolveNativeScope(scope), true);
   }
 
   /**
@@ -216,7 +270,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves when the directory has been created.
    */
   mkdir(path: string, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.createDirectory(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.createDirectory(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -226,7 +280,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves to an array of file names, excluding '.' and '..'.
    */
   readdir(path: string, scope?: CloudStorageScope): Promise<string[]> {
-    return this.nativeStorage.listFiles(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.listFiles(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -236,7 +290,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves to the contents of the file.
    */
   readFile(path: string, scope?: CloudStorageScope): Promise<string> {
-    return this.nativeStorage.readFile(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.readFile(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -246,7 +300,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves once the synchronization has been triggered.
    */
   triggerSync(path: string, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.triggerSync(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.triggerSync(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -263,13 +317,7 @@ export default class RNCloudStorage {
     options: { mimeType: string },
     scope?: CloudStorageScope
   ): Promise<void> {
-    return this.nativeStorage.uploadFile(
-      remotePath,
-      localPath,
-      options.mimeType,
-      scope ?? this.provider.options.scope,
-      true
-    );
+    return this.nativeStorage.uploadFile(remotePath, localPath, options.mimeType, this.resolveNativeScope(scope), true);
   }
 
   /**
@@ -301,7 +349,7 @@ export default class RNCloudStorage {
     if (!localPathOrScope) {
       throw new CloudStorageError('Invalid arguments provided to downloadFile', NativeCloudStorageErrorCode.UNKNOWN);
     }
-    return this.nativeStorage.downloadFile(remotePathOrPath, localPathOrScope, scope ?? this.provider.options.scope);
+    return this.nativeStorage.downloadFile(remotePathOrPath, localPathOrScope, this.resolveNativeScope(scope));
   }
 
   /**
@@ -311,7 +359,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves when the file has been deleted.
    */
   unlink(path: string, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.deleteFile(path, scope ?? this.provider.options.scope);
+    return this.nativeStorage.deleteFile(path, this.resolveNativeScope(scope));
   }
 
   /**
@@ -322,7 +370,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves when the directory has been deleted.
    */
   rmdir(path: string, options?: { recursive?: boolean }, scope?: CloudStorageScope): Promise<void> {
-    return this.nativeStorage.deleteDirectory(path, options?.recursive ?? false, scope ?? this.provider.options.scope);
+    return this.nativeStorage.deleteDirectory(path, options?.recursive ?? false, this.resolveNativeScope(scope));
   }
 
   /**
@@ -332,7 +380,7 @@ export default class RNCloudStorage {
    * @returns A promise that resolves to the CloudStorageFileStat object.
    */
   async stat(path: string, scope?: CloudStorageScope): Promise<CloudStorageFileStat> {
-    const native = await this.nativeStorage.statFile(path, scope ?? this.provider.options.scope);
+    const native = await this.nativeStorage.statFile(path, this.resolveNativeScope(scope));
 
     return {
       ...native,

package/src/specs/NativeCloudStorageCloudKitIOS.ts

@@ -0,0 +1,33 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type CloudStorageFileStat = {
+  size: number;
+  birthtimeMs: number;
+  mtimeMs: number;
+  isDirectory: boolean;
+  isFile: boolean;
+};
+
+export type CloudAvailabilityChangedEvent = {
+  available: boolean;
+};
+
+export interface Spec extends TurboModule {
+  fileExists(path: string, scope: string): Promise<boolean>;
+  appendToFile(path: string, data: string, scope: string): Promise<void>;
+  createFile(path: string, data: string, scope: string, overwrite: boolean): Promise<void>;
+  createDirectory(path: string, scope: string): Promise<void>;
+  listFiles(path: string, scope: string): Promise<Array<string>>;
+  readFile(path: string, scope: string): Promise<string>;
+  triggerSync(path: string, scope: string): Promise<void>;
+  deleteFile(path: string, scope: string): Promise<void>;
+  deleteDirectory(path: string, recursive: boolean, scope: string): Promise<void>;
+  statFile(path: string, scope: string): Promise<CloudStorageFileStat>;
+  downloadFile(remotePath: string, localPath: string, scope: string): Promise<void>;
+  uploadFile(remotePath: string, localPath: string, mimeType: string, scope: string, overwrite: boolean): Promise<void>;
+  isCloudAvailable(): Promise<boolean>;
+  readonly onCloudAvailabilityChanged: CodegenTypes.EventEmitter<CloudAvailabilityChangedEvent>;
+}
+
+export default TurboModuleRegistry.get<Spec>('CloudStorageCloudKit');

package/src/specs/NativeCloudStorageLocalFileSystem.ts

@@ -0,0 +1,28 @@
+import type { CodegenTypes, TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export type LocalFileSystemConstants = {
+  temporaryDirectory: string;
+};
+
+export type LocalFileSystemDownloadOptions = {
+  headers?: CodegenTypes.UnsafeObject;
+};
+
+export type LocalFileSystemUploadOptions = {
+  headers?: CodegenTypes.UnsafeObject;
+  method?: string;
+  uploadType?: string;
+  fieldName?: string;
+  parameters?: CodegenTypes.UnsafeObject;
+};
+
+export interface Spec extends TurboModule {
+  getConstants(): LocalFileSystemConstants;
+  createFile(path: string, data: string): Promise<string>;
+  readFile(path: string): Promise<string>;
+  downloadFile(remoteUri: string, localPath: string, options?: LocalFileSystemDownloadOptions): Promise<void>;
+  uploadFile(localPath: string, remoteUri: string, options: LocalFileSystemUploadOptions): Promise<void>;
+}
+
+export default TurboModuleRegistry.get<Spec>('CloudStorageLocalFileSystem');

package/src/storages/cloudkit.ts

@@ -1,5 +1,13 @@
-import { NativeModules } from 'react-native';
+import NativeCloudStorageCloudKitIOS, {
+  type Spec as NativeCloudStorageCloudKitTurboModule,
+} from '../specs/NativeCloudStorageCloudKitIOS';
 import { NativeStorage } from '../types/native';
 import { createProxiedNativeModule } from '../utils/native';
 
-export const NativeCloudKit = createProxiedNativeModule<NativeStorage>(NativeModules.CloudStorageCloudKit);
+export const NativeCloudKitModule = NativeCloudStorageCloudKitIOS;
+
+export const NativeCloudKit = createProxiedNativeModule<NativeStorage>(
+  NativeCloudStorageCloudKitIOS as unknown as NativeStorage | null
+);
+
+export type { NativeCloudStorageCloudKitTurboModule };