@react-native-firebase/storage 24.1.0 → 25.0.0

package/lib/StorageUploadTask.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+import StorageTask from './StorageTask';
+import type { StorageReference, TaskSnapshot } from './types/storage';
+
+const UPLOAD_TASK = 'upload';
+
+export default class StorageUploadTask extends StorageTask {
+  constructor(
+    storageRef: StorageReference,
+    beginTaskFn: (task: StorageTask) => Promise<TaskSnapshot>,
+  ) {
+    super(UPLOAD_TASK, storageRef, beginTaskFn);
+  }
+}

package/lib/index.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+// Export modular types from types/storage
+export type * from './types/storage';
+
+// Export modular API functions
+export * from './modular';
+
+// Export namespaced API
+export type { FirebaseStorageTypes } from './types/namespaced';
+export * from './namespaced';
+export { default } from './namespaced';

package/lib/modular.ts

@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+import { getApp } from '@react-native-firebase/app';
+import { MODULAR_DEPRECATION_ARG } from '@react-native-firebase/app/dist/module/common';
+import type { FirebaseApp } from '@react-native-firebase/app';
+import type {
+  FirebaseStorage,
+  StorageReference,
+  FullMetadata,
+  ListResult,
+  ListOptions,
+  TaskResult,
+  Task,
+  SettableMetadata,
+  UploadMetadata,
+  EmulatorMockTokenOptions,
+} from './types/storage';
+import type { StorageReferenceInternal, StorageInternal } from './types/internal';
+
+type WithModularDeprecationArg<F> = F extends (...args: infer P) => infer R
+  ? (...args: [...P, typeof MODULAR_DEPRECATION_ARG]) => R
+  : never;
+
+function isUrl(path?: string): boolean {
+  if (typeof path !== 'string') {
+    return false;
+  }
+
+  return /^[A-Za-z]+:\/\//.test(decodeURIComponent(path));
+}
+
+/**
+ * Returns a Storage instance for the given app.
+ * @param app - FirebaseApp. Optional.
+ * @param bucketUrl - Storage bucket URL. Optional.
+ * @returns {Storage}
+ */
+export function getStorage(app?: FirebaseApp, bucketUrl?: string): FirebaseStorage {
+  if (app) {
+    if (bucketUrl != null) {
+      return getApp(app.name).storage(bucketUrl);
+    }
+
+    return getApp(app.name).storage();
+  }
+
+  if (bucketUrl != null) {
+    return getApp().storage(bucketUrl);
+  }
+
+  return getApp().storage();
+}
+
+/**
+ * Modify this Storage instance to communicate with the Firebase Storage emulator.
+ * @param storage - Storage instance.
+ * @param host - emulator host (e.g. - 'localhost')
+ * @param port - emulator port (e.g. -  9199)
+ * @param options - `EmulatorMockTokenOptions` instance. Optional. Web only.
+ * @returns {void}
+ */
+export function connectStorageEmulator(
+  storage: FirebaseStorage,
+  host: string,
+  port: number,
+  options?: EmulatorMockTokenOptions,
+): void {
+  return (
+    (storage as StorageInternal).useEmulator as WithModularDeprecationArg<
+      StorageInternal['useEmulator']
+    >
+  ).call(storage, host, port, options, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Returns a StorageReference for the given URL or path in the default bucket.
+ * @param storage - FirebaseStorage instance.
+ * @param url - Optional gs:// or https:// URL, or path. If empty, returns root reference.
+ * @returns {StorageReference}
+ */
+export function ref(storage: FirebaseStorage, url?: string): StorageReference;
+/**
+ * Returns a StorageReference for the given path, or the same reference if path is omitted.
+ * @param storageRef - StorageReference instance.
+ * @param path - Optional child path. If omitted, returns the same reference.
+ * @returns {StorageReference}
+ */
+export function ref(storageRef: StorageReference, path?: string): StorageReference;
+export function ref(
+  storageOrRef: FirebaseStorage | StorageReference,
+  path?: string,
+): StorageReference {
+  // ref(parentRef, path) → child reference; ref(parentRef) → same reference (firebase-js-sdk overload)
+  if (typeof (storageOrRef as StorageReference).fullPath === 'string') {
+    if (path === undefined) {
+      return storageOrRef as StorageReference;
+    }
+    return (
+      (storageOrRef as StorageReferenceInternal).child as WithModularDeprecationArg<
+        StorageReferenceInternal['child']
+      >
+    ).call(storageOrRef, path, MODULAR_DEPRECATION_ARG);
+  }
+
+  const storage = storageOrRef as FirebaseStorage;
+
+  if (path != null && isUrl(path)) {
+    return (
+      (storage as StorageInternal).refFromURL as WithModularDeprecationArg<
+        StorageInternal['refFromURL']
+      >
+    ).call(storage, path, MODULAR_DEPRECATION_ARG);
+  }
+  return (
+    (storage as StorageInternal).ref as WithModularDeprecationArg<StorageInternal['ref']>
+  ).call(storage, path, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Deletes the object at this reference's location.
+ * @param storageRef - Storage `Reference` instance.
+ * @returns {Promise<void>}
+ */
+export function deleteObject(storageRef: StorageReference): Promise<void> {
+  return (
+    (storageRef as StorageReferenceInternal).delete as WithModularDeprecationArg<
+      StorageReferenceInternal['delete']
+    >
+  ).call(storageRef, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Downloads the data at the object's location. Returns an error if the object is not found.
+ * @param _storageRef - Storage `Reference` instance.
+ * @param _maxDownloadSizeBytes - The maximum allowed size in bytes to retrieve. Web only.
+ * @returns {Promise<Blob>}
+ */
+export function getBlob(
+  _storageRef: StorageReference,
+  _maxDownloadSizeBytes?: number,
+): Promise<Blob> {
+  throw new Error('`getBlob()` is not implemented');
+}
+
+/**
+ * Downloads the data at the object's location. Returns an error if the object is not found.
+ * @param _storageRef - Storage `Reference` instance.
+ * @param _maxDownloadSizeBytes - The maximum allowed size in bytes to retrieve. Web only.
+ * @returns {Promise<ArrayBuffer>}
+ */
+export function getBytes(
+  _storageRef: StorageReference,
+  _maxDownloadSizeBytes?: number,
+): Promise<ArrayBuffer> {
+  throw new Error('`getBytes()` is not implemented');
+}
+
+/**
+ * Deletes the object at this reference's location.
+ * @param storageRef - Storage `Reference` instance.
+ * @returns {Promise<string>}
+ */
+export function getDownloadURL(storageRef: StorageReference): Promise<string> {
+  return (
+    (storageRef as StorageReferenceInternal).getDownloadURL as WithModularDeprecationArg<
+      StorageReferenceInternal['getDownloadURL']
+    >
+  ).call(storageRef, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Fetches metadata for the object at this location, if one exists.
+ * @param storageRef - Storage `Reference` instance.
+ * @returns {Promise<FullMetadata>}
+ */
+export function getMetadata(storageRef: StorageReference): Promise<FullMetadata> {
+  return (
+    (storageRef as StorageReferenceInternal).getMetadata as WithModularDeprecationArg<
+      StorageReferenceInternal['getMetadata']
+    >
+  ).call(storageRef, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Downloads the data at the object's location. This API is only available in Nodejs.
+ * @param _storageRef - Storage `Reference` instance.
+ * @param _maxDownloadSizeBytes - The maximum allowed size in bytes to retrieve. Web only.
+ * @returns {NodeJS.ReadableStream;}
+ */
+export function getStream(
+  _storageRef: StorageReference,
+  _maxDownloadSizeBytes?: number,
+): NodeJS.ReadableStream {
+  throw new Error('`getStream()` is not implemented');
+}
+
+/**
+ * List items (files) and prefixes (folders) under this storage reference
+ * @param storageRef - Storage `Reference` instance.
+ * @param options - Storage `ListOptions` instance. The options list() accepts.
+ * @returns {Promise<ListResult>}
+ */
+export async function list(
+  storageRef: StorageReference,
+  options?: ListOptions,
+): Promise<ListResult> {
+  const result = await (
+    (storageRef as StorageReferenceInternal).list as WithModularDeprecationArg<
+      StorageReferenceInternal['list']
+    >
+  ).call(storageRef, options, MODULAR_DEPRECATION_ARG);
+
+  if (result.nextPageToken === null) {
+    delete result.nextPageToken;
+  }
+  return result;
+}
+
+/**
+ * List all items (files) and prefixes (folders) under this storage reference.
+ * @param storageRef - Storage `Reference` instance.
+ * @returns {Promise<ListResult>}
+ */
+export async function listAll(storageRef: StorageReference): Promise<ListResult> {
+  const result = await (
+    (storageRef as StorageReferenceInternal).listAll as WithModularDeprecationArg<
+      StorageReferenceInternal['listAll']
+    >
+  ).call(storageRef, MODULAR_DEPRECATION_ARG);
+
+  if (result.nextPageToken === null) {
+    delete result.nextPageToken;
+  }
+  return result;
+}
+
+/**
+ * Updates the metadata for this object.
+ * @param storageRef - Storage `Reference` instance.
+ * @param metadata - A Storage `SettableMetadata` instance to update.
+ * @returns {Promise<FullMetadata>}
+ */
+export function updateMetadata(
+  storageRef: StorageReference,
+  metadata: SettableMetadata,
+): Promise<FullMetadata> {
+  return (
+    (storageRef as StorageReferenceInternal).updateMetadata as WithModularDeprecationArg<
+      StorageReferenceInternal['updateMetadata']
+    >
+  ).call(storageRef, metadata, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Uploads data to this object's location. The upload is not resumable.
+ * @param _storageRef - Storage `Reference` instance.
+ * @param _data - The data (Blob | Uint8Array | ArrayBuffer) to upload to the storage bucket at the reference location.
+ * @param _metadata - A Storage `UploadMetadata` instance to update. Optional.
+ * @returns {Promise<TaskResult>}
+ */
+export async function uploadBytes(
+  _storageRef: StorageReference,
+  _data: Blob | Uint8Array | ArrayBuffer,
+  _metadata?: UploadMetadata,
+): Promise<TaskResult> {
+  throw new Error('`uploadBytes()` is not implemented');
+}
+
+/**
+ * Uploads data to this object's location. The upload is not resumable.
+ * @param storageRef - Storage `Reference` instance.
+ * @param data - The data (Blob | Uint8Array | ArrayBuffer) to upload to the storage bucket at the reference location.
+ * @param metadata - A Storage `UploadMetadata` instance to update. Optional.
+ * @returns {Task}
+ */
+export function uploadBytesResumable(
+  storageRef: StorageReference,
+  data: Blob | Uint8Array | ArrayBuffer,
+  metadata?: UploadMetadata,
+): Task {
+  return (
+    (storageRef as StorageReferenceInternal).put as WithModularDeprecationArg<
+      StorageReferenceInternal['put']
+    >
+  ).call(storageRef, data, metadata, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Uploads data to this object's location. The upload is not resumable.
+ * @param storageRef - Storage `Reference` instance.
+ * @param data - The string to upload.
+ * @param format - The format of the string to upload ('raw' | 'base64' | 'base64url' | 'data_url'). Optional.
+ * @param metadata - A Storage `UploadMetadata` instance to update. Optional.
+ * @returns {Task}
+ */
+export function uploadString(
+  storageRef: StorageReference,
+  data: string,
+  format?: 'raw' | 'base64' | 'base64url' | 'data_url',
+  metadata?: UploadMetadata,
+): Task {
+  return (
+    (storageRef as StorageReferenceInternal).putString as WithModularDeprecationArg<
+      StorageReferenceInternal['putString']
+    >
+  ).call(storageRef, data, format, metadata, MODULAR_DEPRECATION_ARG);
+}
+
+// Methods not on the Firebase JS SDK below
+
+/**
+ * Sets the maximum time in milliseconds to retry a download if a failure occurs.. android & iOS only.
+ * @param storage - Storage instance.
+ * @param time - The new maximum operation retry time in milliseconds.
+ * @returns {Promise<void>}
+ */
+export function setMaxOperationRetryTime(storage: FirebaseStorage, time: number): Promise<void> {
+  return (
+    (storage as StorageInternal).setMaxOperationRetryTime as WithModularDeprecationArg<
+      StorageInternal['setMaxOperationRetryTime']
+    >
+  ).call(storage, time, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Sets the maximum time in milliseconds to retry an upload if a failure occurs. android & iOS only.
+ * @param storage - Storage instance.
+ * @param time - The new maximum operation retry time in milliseconds.
+ * @returns {Promise<void>}
+ */
+export function setMaxUploadRetryTime(storage: FirebaseStorage, time: number): Promise<void> {
+  return (
+    (storage as StorageInternal).setMaxUploadRetryTime as WithModularDeprecationArg<
+      StorageInternal['setMaxUploadRetryTime']
+    >
+  ).call(storage, time, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Puts a file from local disk onto the storage bucket.
+ * @param storageRef - Storage Reference instance.
+ * @param filePath The local file path to upload to the bucket at the reference location.
+ * @param metadata Any additional `UploadMetadata` for this task.
+ * @returns {Task}
+ */
+export function putFile(
+  storageRef: StorageReference,
+  filePath: string,
+  metadata?: UploadMetadata,
+): Task {
+  return (
+    (storageRef as StorageReferenceInternal).putFile as WithModularDeprecationArg<
+      StorageReferenceInternal['putFile']
+    >
+  ).call(storageRef, filePath, metadata, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Downloads a file to the specified local file path on the device.
+ * @param storageRef - Storage Reference instance.
+ * @param filePath The local file path to upload to on the device.
+ * @returns {Task}
+ */
+export function writeToFile(storageRef: StorageReference, filePath: string): Task {
+  return (
+    (storageRef as StorageReferenceInternal).writeToFile as WithModularDeprecationArg<
+      StorageReferenceInternal['writeToFile']
+    >
+  ).call(storageRef, filePath, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Sets the maximum time in milliseconds to retry a download if a failure occurs.
+ * @param storage - Storage instance.
+ * @param time - The new maximum download retry time in milliseconds.
+ * @returns {Promise<void>}
+ */
+export function setMaxDownloadRetryTime(storage: FirebaseStorage, time: number): Promise<void> {
+  return (
+    (storage as StorageInternal).setMaxDownloadRetryTime as WithModularDeprecationArg<
+      StorageInternal['setMaxDownloadRetryTime']
+    >
+  ).call(storage, time, MODULAR_DEPRECATION_ARG);
+}
+
+export { StringFormat, TaskEvent, TaskState } from './StorageStatics';

package/lib/{index.js → namespaced.ts}

@@ -27,14 +27,17 @@ import {
   createModuleNamespace,
   FirebaseModule,
   getFirebaseRoot,
+  type ModuleConfig,
 } from '@react-native-firebase/app/dist/module/internal';
-import StorageReference from './StorageReference';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+import Reference from './StorageReference';
 import { StringFormat, TaskEvent, TaskState } from './StorageStatics';
 import { getGsUrlParts, getHttpUrlParts, handleStorageEvent } from './utils';
-import version from './version';
+import { version } from './version';
 import fallBackModule from './web/RNFBStorageModule';
+import type { StorageInternal } from './types/internal';
+import type { FirebaseStorageTypes } from './types/namespaced';
 
-// import { STATICS } from '@react-native-firebase/storage';
 const statics = {
   StringFormat,
   TaskEvent,
@@ -45,10 +48,20 @@ const namespace = 'storage';
 const nativeEvents = ['storage_event'];
 const nativeModuleName = 'RNFBStorageModule';
 
-class FirebaseStorageModule extends FirebaseModule {
-  constructor(app, config, bucketUrl) {
-    super(app, config, bucketUrl);
-    if (bucketUrl === undefined) {
+class FirebaseStorageModule extends FirebaseModule<typeof nativeModuleName> {
+  emulatorHost: string | undefined;
+  emulatorPort: number;
+  _maxUploadRetryTime: number;
+  _maxDownloadRetryTime: number;
+  _maxOperationRetryTime: number;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    bucketUrl?: string | null,
+  ) {
+    super(app, config, bucketUrl ?? undefined);
+    if (bucketUrl == null) {
       this._customUrlOrRegion = `gs://${app.options.storageBucket}`;
     } else if (!isString(bucketUrl) || !bucketUrl.startsWith('gs://')) {
       throw new Error(
@@ -56,8 +69,14 @@ class FirebaseStorageModule extends FirebaseModule {
       );
     }
 
+    const storageEvent = nativeEvents[0];
+
+    if (!storageEvent) {
+      throw new Error('storage_event is not defined in nativeEvents');
+    }
+
     this.emitter.addListener(
-      this.eventNameForApp(nativeEvents[0]),
+      this.eventNameForApp(storageEvent),
       handleStorageEvent.bind(null, this),
     );
 
@@ -72,46 +91,46 @@ class FirebaseStorageModule extends FirebaseModule {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#setmaxuploadretrytime
    */
-  get maxUploadRetryTime() {
+  get maxUploadRetryTime(): number {
     return this._maxUploadRetryTime;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#setmaxdownloadretrytime
    */
-  get maxDownloadRetryTime() {
+  get maxDownloadRetryTime(): number {
     return this._maxDownloadRetryTime;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#maxoperationretrytime
    */
-  get maxOperationRetryTime() {
+  get maxOperationRetryTime(): number {
     return this._maxOperationRetryTime;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#ref
    */
-  ref(path = '/') {
+  ref(path: string = '/'): Reference {
     if (!isString(path)) {
       throw new Error("firebase.storage().ref(*) 'path' must be a string value.");
     }
-    return createDeprecationProxy(new StorageReference(this, path));
+    return createDeprecationProxy(new Reference(this, path)) as Reference;
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#refFromURL
    */
-  refFromURL(url) {
+  refFromURL(url: string): Reference {
     if (!isString(url) || (!url.startsWith('gs://') && !url.startsWith('http'))) {
       throw new Error(
         "firebase.storage().refFromURL(*) 'url' must be a string value and begin with 'gs://' or 'https://'.",
       );
     }
 
-    let path;
-    let bucket;
+    let path: string;
+    let bucket: string;
 
     if (url.startsWith('http')) {
       const parts = getHttpUrlParts(url);
@@ -126,13 +145,13 @@ class FirebaseStorageModule extends FirebaseModule {
     }
 
     const storageInstance = this.app.storage(bucket);
-    return new StorageReference(storageInstance, path);
+    return new Reference(storageInstance as unknown as StorageInternal, path);
   }
 
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#setMaxOperationRetryTime
    */
-  setMaxOperationRetryTime(time) {
+  setMaxOperationRetryTime(time: number): Promise<void> {
     if (!isNumber(time)) {
       throw new Error(
         "firebase.storage().setMaxOperationRetryTime(*) 'time' must be a number value.",
@@ -146,7 +165,7 @@ class FirebaseStorageModule extends FirebaseModule {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#setMaxUploadRetryTime
    */
-  setMaxUploadRetryTime(time) {
+  setMaxUploadRetryTime(time: number): Promise<void> {
     if (!isNumber(time)) {
       throw new Error("firebase.storage().setMaxUploadRetryTime(*) 'time' must be a number value.");
     }
@@ -158,7 +177,7 @@ class FirebaseStorageModule extends FirebaseModule {
   /**
    * @url https://firebase.google.com/docs/reference/js/firebase.storage.Storage#setMaxDownloadRetryTime
    */
-  setMaxDownloadRetryTime(time) {
+  setMaxDownloadRetryTime(time: number): Promise<void> {
     if (!isNumber(time)) {
       throw new Error(
         "firebase.storage().setMaxDownloadRetryTime(*) 'time' must be a number value.",
@@ -169,7 +188,11 @@ class FirebaseStorageModule extends FirebaseModule {
     return this.native.setMaxDownloadRetryTime(time);
   }
 
-  useEmulator(host, port) {
+  useEmulator(
+    host: string,
+    port: number,
+    _options?: FirebaseStorageTypes.EmulatorMockTokenOptions,
+  ): void {
     if (!host || !isString(host) || !port || !isNumber(port)) {
       throw new Error('firebase.storage().useEmulator() takes a non-empty host and port');
     }
@@ -191,16 +214,15 @@ class FirebaseStorageModule extends FirebaseModule {
     this.emulatorHost = host;
     this.emulatorPort = port;
     this.native.useEmulator(_host, port, this._customUrlOrRegion);
-    return [_host, port]; // undocumented return, just used to unit test android host remapping
+    // @ts-ignore undocumented return, just used to unit test android host remapping
+    return [_host, port];
   }
 }
 
 // import { SDK_VERSION } from '@react-native-firebase/storage';
 export const SDK_VERSION = version;
 
-// import storage from '@react-native-firebase/storage';
-// storage().X(...);
-export default createModuleNamespace({
+const storageNamespace = createModuleNamespace({
   statics,
   version,
   namespace,
@@ -212,11 +234,31 @@ export default createModuleNamespace({
   ModuleClass: FirebaseStorageModule,
 });
 
+type StorageNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+  FirebaseStorageTypes.Module,
+  FirebaseStorageTypes.Statics
+> & {
+  storage: ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+    FirebaseStorageTypes.Module,
+    FirebaseStorageTypes.Statics
+  >;
+  firebase: ReactNativeFirebase.Module;
+  app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+
+// import storage from '@react-native-firebase/storage';
+// storage().X(...);
+export default storageNamespace as unknown as StorageNamespace;
+
 // import storage, { firebase } from '@react-native-firebase/storage';
 // storage().X(...);
 // firebase.storage().X(...);
-export const firebase = getFirebaseRoot();
-
-export * from './modular';
+export const firebase =
+  getFirebaseRoot() as unknown as ReactNativeFirebase.FirebaseNamespacedExport<
+    'storage',
+    FirebaseStorageTypes.Module,
+    FirebaseStorageTypes.Statics,
+    true
+  >;
 
 setReactNativeModule(nativeModuleName, fallBackModule);