@react-native-firebase/database 25.1.0 → 26.1.0

package/lib/DatabaseQuery.ts

@@ -16,7 +16,6 @@
  */
 
 import {
-  createDeprecationProxy,
   isBoolean,
   isFunction,
   isNull,
@@ -24,7 +23,6 @@ import {
   isObject,
   isString,
   isUndefined,
-  MODULAR_DEPRECATION_ARG,
   pathIsEmpty,
   pathToUrlEncodedString,
   ReferenceBase,
@@ -37,7 +35,7 @@ import type {
   DatabaseInternal,
   DatabaseListenPropsInternal,
 } from './types/internal';
-import type { FirebaseDatabaseTypes } from './types/namespaced';
+import type { DatabaseReference, DataSnapshot, EventType, Query } from './types/database';
 
 const eventTypes = [
   'value',
@@ -50,20 +48,7 @@ const eventTypes = [
 type DatabaseReferenceConstructor = new (
   database: DatabaseInternal,
   path: string,
-) => FirebaseDatabaseTypes.Reference;
-
-type QueryWithDeprecationArgInternal = FirebaseDatabaseTypes.Query & {
-  startAt(
-    value: number | string | boolean | null,
-    key?: string,
-    deprecationArg?: string,
-  ): FirebaseDatabaseTypes.Query;
-  endAt(
-    value: number | string | boolean | null,
-    key?: string,
-    deprecationArg?: string,
-  ): FirebaseDatabaseTypes.Query;
-};
+) => DatabaseReference;
 
 let DatabaseReferenceClass: DatabaseReferenceConstructor | null = null;
 
@@ -71,26 +56,17 @@ export function provideReferenceClass(databaseReference: DatabaseReferenceConstr
   DatabaseReferenceClass = databaseReference;
 }
 
-function ap(query: FirebaseDatabaseTypes.Query): QueryWithDeprecationArgInternal {
-  return query as QueryWithDeprecationArgInternal;
-}
-
-function createReference(
-  database: DatabaseInternal,
-  path: string,
-): FirebaseDatabaseTypes.Reference {
+function createReference(database: DatabaseInternal, path: string): DatabaseReference {
   if (!DatabaseReferenceClass) {
     throw new Error('DatabaseReference class has not been provided.');
   }
 
-  return createDeprecationProxy(
-    new DatabaseReferenceClass(database, path),
-  ) as FirebaseDatabaseTypes.Reference;
+  return new DatabaseReferenceClass(database, path);
 }
 
 let listeners = 0;
 
-export default class DatabaseQuery extends ReferenceBase implements FirebaseDatabaseTypes.Query {
+export default class DatabaseQuery extends ReferenceBase implements Query {
   _database: DatabaseInternal;
   _modifiers: DatabaseQueryModifiers;
 
@@ -100,11 +76,11 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     this._modifiers = modifiers;
   }
 
-  get ref(): FirebaseDatabaseTypes.Reference {
+  get ref(): DatabaseReference {
     return createReference(this._database, this.path);
   }
 
-  endAt(value: number | string | boolean | null, key?: string): FirebaseDatabaseTypes.Query {
+  endAt(value: number | string | boolean | null, key?: string): Query {
     if (!isNumber(value) && !isString(value) && !isBoolean(value) && !isNull(value)) {
       throw new Error(
         "firebase.database().ref().endAt(*) 'value' must be a number, string, boolean or null value.",
@@ -126,10 +102,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().endAt(value, key);
     modifiers.validateModifiers('firebase.database().ref().endAt()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
-  equalTo(value: number | string | boolean | null, key?: string): FirebaseDatabaseTypes.Query {
+  equalTo(value: number | string | boolean | null, key?: string): Query {
     if (!isNumber(value) && !isString(value) && !isBoolean(value) && !isNull(value)) {
       throw new Error(
         "firebase.database().ref().equalTo(*) 'value' must be a number, string, boolean or null value.",
@@ -154,14 +130,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
       );
     }
 
-    return ap(ap(this).startAt.call(this, value, key, MODULAR_DEPRECATION_ARG)).endAt.call(
-      this,
-      value,
-      MODULAR_DEPRECATION_ARG,
-    );
+    return (this.startAt(value, key) as DatabaseQuery).endAt(value, key);
   }
 
-  isEqual(other: FirebaseDatabaseTypes.Query): boolean {
+  isEqual(other: Query): boolean {
     if (!(other instanceof DatabaseQuery)) {
       throw new Error("firebase.database().ref().isEqual(*) 'other' must be an instance of Query.");
     }
@@ -173,7 +145,7 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     return sameApp && sameDatabasePath && sameModifiers;
   }
 
-  limitToFirst(limit: number): FirebaseDatabaseTypes.Query {
+  limitToFirst(limit: number): Query {
     if (this._modifiers.isValidLimit(limit)) {
       throw new Error(
         "firebase.database().ref().limitToFirst(*) 'limit' must be a positive integer value.",
@@ -186,12 +158,14 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
       );
     }
 
-    return createDeprecationProxy(
-      new DatabaseQuery(this._database, this.path, this._modifiers._copy().limitToFirst(limit)),
-    ) as FirebaseDatabaseTypes.Query;
+    return new DatabaseQuery(
+      this._database,
+      this.path,
+      this._modifiers._copy().limitToFirst(limit),
+    );
   }
 
-  limitToLast(limit: number): FirebaseDatabaseTypes.Query {
+  limitToLast(limit: number): Query {
     if (this._modifiers.isValidLimit(limit)) {
       throw new Error(
         "firebase.database().ref().limitToLast(*) 'limit' must be a positive integer value.",
@@ -204,14 +178,12 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
       );
     }
 
-    return createDeprecationProxy(
-      new DatabaseQuery(this._database, this.path, this._modifiers._copy().limitToLast(limit)),
-    ) as FirebaseDatabaseTypes.Query;
+    return new DatabaseQuery(this._database, this.path, this._modifiers._copy().limitToLast(limit));
   }
 
   off(
-    eventType?: FirebaseDatabaseTypes.EventType,
-    callback?: (a: FirebaseDatabaseTypes.DataSnapshot, b?: string | null) => void,
+    eventType?: EventType,
+    callback?: (a: DataSnapshot, b?: string | null) => void,
     context?: Record<string, any>,
   ): void {
     if (arguments.length === 0) {
@@ -261,11 +233,11 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
   }
 
   on(
-    eventType: FirebaseDatabaseTypes.EventType,
-    callback: (data: FirebaseDatabaseTypes.DataSnapshot, previousChildKey?: string | null) => void,
+    eventType: EventType,
+    callback: (data: DataSnapshot, previousChildKey?: string | null) => void,
     cancelCallbackOrContext?: ((a: Error) => void) | Record<string, any> | null,
     context?: Record<string, any> | null,
-  ): (a: FirebaseDatabaseTypes.DataSnapshot | null, b?: string | null) => void {
+  ): (a: DataSnapshot | null, b?: string | null) => void {
     if (!eventTypes.includes(eventType)) {
       throw new Error(
         `firebase.database().ref().on(*) 'eventType' must be one of ${eventTypes.join(', ')}.`,
@@ -341,15 +313,15 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
 
     listeners += 1;
 
-    return callback as (a: FirebaseDatabaseTypes.DataSnapshot | null, b?: string | null) => void;
+    return callback as (a: DataSnapshot | null, b?: string | null) => void;
   }
 
   once(
-    eventType: FirebaseDatabaseTypes.EventType,
-    successCallBack?: (a: FirebaseDatabaseTypes.DataSnapshot, b?: string | null) => any,
+    eventType: EventType,
+    successCallBack?: (a: DataSnapshot, b?: string | null) => any,
     failureCallbackOrContext?: ((a: Error) => void) | Record<string, any> | null,
     context?: Record<string, any>,
-  ): Promise<FirebaseDatabaseTypes.DataSnapshot> {
+  ): Promise<DataSnapshot> {
     if (!eventTypes.includes(eventType)) {
       throw new Error(
         `firebase.database().ref().once(*) 'eventType' must be one of ${eventTypes.join(', ')}.`,
@@ -381,21 +353,17 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     return this._database.native
       .once(this.path, modifiers, eventType)
       .then(result => {
-        let dataSnapshot: FirebaseDatabaseTypes.DataSnapshot;
+        let dataSnapshot: DataSnapshot;
         let previousChildName: string | null | undefined;
 
         if (eventType === 'value') {
-          dataSnapshot = createDeprecationProxy(
-            new DatabaseDataSnapshot(
-              this.ref,
-              result as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
-            ),
-          ) as FirebaseDatabaseTypes.DataSnapshot;
+          dataSnapshot = new DatabaseDataSnapshot(
+            this.ref,
+            result as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
+          );
         } else {
           const childResult = result as DatabaseChildSnapshotResultInternal;
-          dataSnapshot = createDeprecationProxy(
-            new DatabaseDataSnapshot(this.ref, childResult.snapshot),
-          ) as FirebaseDatabaseTypes.DataSnapshot;
+          dataSnapshot = new DatabaseDataSnapshot(this.ref, childResult.snapshot);
           previousChildName = childResult.previousChildName;
         }
 
@@ -419,7 +387,7 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
       });
   }
 
-  orderByChild(path: string): FirebaseDatabaseTypes.Query {
+  orderByChild(path: string): Query {
     if (!isString(path)) {
       throw new Error("firebase.database().ref().orderByChild(*) 'path' must be a string value.");
     }
@@ -439,10 +407,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().orderByChild(path);
     modifiers.validateModifiers('firebase.database().ref().orderByChild()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
-  orderByKey(): FirebaseDatabaseTypes.Query {
+  orderByKey(): Query {
     if (this._modifiers.hasOrderBy()) {
       throw new Error(
         "firebase.database().ref().orderByKey() You can't combine multiple orderBy calls.",
@@ -452,10 +420,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().orderByKey();
     modifiers.validateModifiers('firebase.database().ref().orderByKey()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
-  orderByPriority(): FirebaseDatabaseTypes.Query {
+  orderByPriority(): Query {
     if (this._modifiers.hasOrderBy()) {
       throw new Error(
         "firebase.database().ref().orderByPriority() You can't combine multiple orderBy calls.",
@@ -465,10 +433,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().orderByPriority();
     modifiers.validateModifiers('firebase.database().ref().orderByPriority()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
-  orderByValue(): FirebaseDatabaseTypes.Query {
+  orderByValue(): Query {
     if (this._modifiers.hasOrderBy()) {
       throw new Error(
         "firebase.database().ref().orderByValue() You can't combine multiple orderBy calls.",
@@ -478,10 +446,10 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().orderByValue();
     modifiers.validateModifiers('firebase.database().ref().orderByValue()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
-  startAt(value: number | string | boolean | null, key?: string): FirebaseDatabaseTypes.Query {
+  startAt(value: number | string | boolean | null, key?: string): Query {
     if (!isNumber(value) && !isString(value) && !isBoolean(value) && !isNull(value)) {
       throw new Error(
         "firebase.database().ref().startAt(*) 'value' must be a number, string, boolean or null value.",
@@ -503,7 +471,7 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     const modifiers = this._modifiers._copy().startAt(value, key);
     modifiers.validateModifiers('firebase.database().ref().startAt()');
 
-    return createDeprecationProxy(new DatabaseQuery(this._database, this.path, modifiers));
+    return new DatabaseQuery(this._database, this.path, modifiers);
   }
 
   toJSON(): string {
@@ -535,7 +503,7 @@ export default class DatabaseQuery extends ReferenceBase implements FirebaseData
     }$${this._modifiers.toString()}`;
   }
 
-  _generateQueryEventKey(eventType: FirebaseDatabaseTypes.EventType): string {
+  _generateQueryEventKey(eventType: EventType): string {
     return `${this._generateQueryKey()}$${listeners}$${eventType}`;
   }
 }

package/lib/DatabaseReference.ts

@@ -16,7 +16,6 @@
  */
 
 import {
-  createDeprecationProxy,
   generateDatabaseId,
   isBoolean,
   isFunction,
@@ -26,7 +25,6 @@ import {
   isString,
   isUndefined,
   isValidPath,
-  MODULAR_DEPRECATION_ARG,
   pathChild,
   pathParent,
   promiseWithOptionalCallback,
@@ -40,35 +38,18 @@ import DatabaseQueryModifiers from './DatabaseQueryModifiers';
 import DatabaseThenableReference, {
   provideReferenceClass as provideReferenceClassForThenable,
 } from './DatabaseThenableReference';
-import type { DatabaseInternal } from './types/internal';
-import type { FirebaseDatabaseTypes } from './types/namespaced';
+import type { DatabaseInternal, DatabaseReferenceWithMethodsInternal } from './types/internal';
+import type {
+  DatabaseReference as DatabaseReferenceType,
+  DataSnapshot,
+  OnDisconnect,
+  ThenableReference,
+  TransactionResult,
+} from './types/database';
 
 const internalRefs = ['.info/connected', '.info/serverTimeOffset'] as const;
 
-type ReferenceWithChildInternal = FirebaseDatabaseTypes.Reference & {
-  child(path: string, deprecationArg?: string): FirebaseDatabaseTypes.Reference;
-};
-
-type ReferenceWithSetInternal = FirebaseDatabaseTypes.Reference & {
-  set(
-    value: unknown,
-    onComplete?: (error: Error | null) => void,
-    deprecationArg?: string,
-  ): Promise<void>;
-};
-
-function apChild(reference: FirebaseDatabaseTypes.Reference): ReferenceWithChildInternal {
-  return reference as ReferenceWithChildInternal;
-}
-
-function apSet(reference: FirebaseDatabaseTypes.Reference): ReferenceWithSetInternal {
-  return reference as ReferenceWithSetInternal;
-}
-
-export default class DatabaseReference
-  extends DatabaseQuery
-  implements FirebaseDatabaseTypes.Reference
-{
+export default class DatabaseReference extends DatabaseQuery implements DatabaseReferenceType {
   readonly _database: DatabaseInternal;
 
   constructor(database: DatabaseInternal, path: string) {
@@ -82,29 +63,23 @@ export default class DatabaseReference
     this._database = database;
   }
 
-  get parent(): FirebaseDatabaseTypes.Reference | null {
+  get parent(): DatabaseReferenceType | null {
     const parentPath = pathParent(this.path);
     if (parentPath === null) {
       return null;
     }
-    return createDeprecationProxy(
-      new DatabaseReference(this._database, parentPath),
-    ) as FirebaseDatabaseTypes.Reference;
+    return new DatabaseReference(this._database, parentPath);
   }
 
-  get root(): FirebaseDatabaseTypes.Reference {
-    return createDeprecationProxy(
-      new DatabaseReference(this._database, '/'),
-    ) as FirebaseDatabaseTypes.Reference;
+  get root(): DatabaseReferenceType {
+    return new DatabaseReference(this._database, '/');
   }
 
-  child(path: string): FirebaseDatabaseTypes.Reference {
+  child(path: string): DatabaseReferenceType {
     if (!isString(path)) {
       throw new Error("firebase.database().ref().child(*) 'path' must be a string value.");
     }
-    return createDeprecationProxy(
-      new DatabaseReference(this._database, pathChild(this.path, path)),
-    ) as FirebaseDatabaseTypes.Reference;
+    return new DatabaseReference(this._database, pathChild(this.path, path));
   }
 
   set(value: any, onComplete?: (error: Error | null) => void): Promise<void> {
@@ -195,10 +170,10 @@ export default class DatabaseReference
     onComplete?: (
       error: Error | null,
       committed: boolean,
-      finalResult: FirebaseDatabaseTypes.DataSnapshot | null,
+      finalResult: DataSnapshot | null,
     ) => void,
     applyLocally?: boolean,
-  ): Promise<FirebaseDatabaseTypes.TransactionResult> {
+  ): Promise<TransactionResult> {
     if (!isFunction(transactionUpdate)) {
       throw new Error(
         "firebase.database().ref().transaction(*) 'transactionUpdate' must be a function.",
@@ -230,12 +205,10 @@ export default class DatabaseReference
             onComplete(
               null,
               committed,
-              createDeprecationProxy(
-                new DatabaseDataSnapshot(
-                  this,
-                  snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
-                ),
-              ) as FirebaseDatabaseTypes.DataSnapshot,
+              new DatabaseDataSnapshot(
+                this,
+                snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
+              ),
             );
           }
         }
@@ -245,14 +218,17 @@ export default class DatabaseReference
           return;
         }
 
+        const snapshot = new DatabaseDataSnapshot(
+          this,
+          snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
+        );
+
         resolve({
           committed,
-          snapshot: createDeprecationProxy(
-            new DatabaseDataSnapshot(
-              this,
-              snapshotData as ConstructorParameters<typeof DatabaseDataSnapshot>[1],
-            ),
-          ) as FirebaseDatabaseTypes.DataSnapshot,
+          snapshot,
+          toJSON() {
+            return { committed, snapshot: snapshot.toJSON() };
+          },
         });
       };
 
@@ -282,10 +258,7 @@ export default class DatabaseReference
     );
   }
 
-  push(
-    value?: any,
-    onComplete?: (error: Error | null) => void,
-  ): FirebaseDatabaseTypes.ThenableReference {
+  push(value?: any, onComplete?: (error: Error | null) => void): ThenableReference {
     if (!isUndefined(onComplete) && !isFunction(onComplete)) {
       throw new Error(
         "firebase.database().ref().push(_, *) 'onComplete' must be a function if provided.",
@@ -298,15 +271,13 @@ export default class DatabaseReference
       return new DatabaseThenableReference(
         this._database,
         pathChild(this.path, id),
-        Promise.resolve(apChild(this).child.call(this, id, MODULAR_DEPRECATION_ARG)),
-      ) as unknown as FirebaseDatabaseTypes.ThenableReference;
+        Promise.resolve(this.child(id)),
+      ) as unknown as ThenableReference;
     }
 
-    const pushRef = apChild(this).child.call(this, id, MODULAR_DEPRECATION_ARG);
+    const pushRef = this.child(id) as DatabaseReferenceWithMethodsInternal;
 
-    const promise = apSet(pushRef)
-      .set.call(pushRef, value, onComplete, MODULAR_DEPRECATION_ARG)
-      .then(() => pushRef);
+    const promise = pushRef.set(value, onComplete).then(() => pushRef);
 
     if (onComplete) {
       promise.catch(() => {});
@@ -316,10 +287,10 @@ export default class DatabaseReference
       this._database,
       pathChild(this.path, id),
       promise,
-    ) as unknown as FirebaseDatabaseTypes.ThenableReference;
+    ) as unknown as ThenableReference;
   }
 
-  onDisconnect(): FirebaseDatabaseTypes.OnDisconnect {
+  onDisconnect(): OnDisconnect {
     return new DatabaseOnDisconnect(this);
   }
 }

package/lib/DatabaseSyncTree.ts

@@ -15,7 +15,7 @@
  *
  */
 
-import { createDeprecationProxy, isString } from '@react-native-firebase/app/dist/module/common';
+import { isString } from '@react-native-firebase/app/dist/module/common';
 import NativeError from '@react-native-firebase/app/dist/module/internal/NativeFirebaseError';
 import SharedEventEmitter from '@react-native-firebase/app/dist/module/internal/SharedEventEmitter';
 import { getReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
@@ -26,11 +26,11 @@ import type {
   DatabaseSnapshotInternal,
   RNFBDatabaseModule,
 } from './types/internal';
-import type { FirebaseDatabaseTypes } from './types/namespaced';
+import type { DatabaseReference, DataSnapshot } from './types/database';
 
 interface DatabaseSyncTreeRegistration {
   eventType: string;
-  ref: FirebaseDatabaseTypes.Reference;
+  ref: DatabaseReference;
   path: string;
   key: string;
   appName: string;
@@ -79,7 +79,8 @@ class DatabaseSyncTree {
   }
 
   private get native(): RNFBDatabaseModule {
-    return getReactNativeModule('RNFBDatabaseQueryModule') as unknown as RNFBDatabaseModule;
+    // NewArch-AD-18 E9: query host for sync tree off(); merged surface exposes off via composite.
+    return getReactNativeModule('NativeRNFBTurboDatabaseQuery') as unknown as RNFBDatabaseModule;
   }
 
   private _allocate(
@@ -145,7 +146,7 @@ class DatabaseSyncTree {
       return;
     }
 
-    let snapshot: FirebaseDatabaseTypes.DataSnapshot;
+    let snapshot: DataSnapshot;
     let previousChildName: string | null | undefined;
 
     if (!event.data) {
@@ -153,14 +154,10 @@ class DatabaseSyncTree {
     }
 
     if (event.eventType === 'value') {
-      snapshot = createDeprecationProxy(
-        new DatabaseDataSnapshot(registration.ref, event.data as DatabaseSnapshotInternal),
-      ) as FirebaseDatabaseTypes.DataSnapshot;
+      snapshot = new DatabaseDataSnapshot(registration.ref, event.data as DatabaseSnapshotInternal);
     } else {
       const childData = event.data as DatabaseChildSnapshotResultInternal;
-      snapshot = createDeprecationProxy(
-        new DatabaseDataSnapshot(registration.ref, childData.snapshot),
-      ) as FirebaseDatabaseTypes.DataSnapshot;
+      snapshot = new DatabaseDataSnapshot(registration.ref, childData.snapshot);
       previousChildName = childData.previousChildName;
     }
 

package/lib/DatabaseThenableReference.ts

@@ -15,15 +15,13 @@
  *
  */
 
-import { createDeprecationProxy } from '@react-native-firebase/app/dist/module/common';
-
 import type { DatabaseInternal } from './types/internal';
-import type { FirebaseDatabaseTypes } from './types/namespaced';
+import type { DatabaseReference } from './types/database';
 
 type DatabaseReferenceConstructor = new (
   database: DatabaseInternal,
   path: string,
-) => FirebaseDatabaseTypes.Reference;
+) => DatabaseReference;
 
 let DatabaseReferenceClass: DatabaseReferenceConstructor | null = null;
 
@@ -32,24 +30,18 @@ export function provideReferenceClass(databaseReference: DatabaseReferenceConstr
 }
 
 export default class DatabaseThenableReference implements Pick<
-  Promise<FirebaseDatabaseTypes.Reference>,
+  Promise<DatabaseReference>,
   'then' | 'catch'
 > {
-  _ref: FirebaseDatabaseTypes.Reference;
-  _promise: Promise<FirebaseDatabaseTypes.Reference>;
+  _ref: DatabaseReference;
+  _promise: Promise<DatabaseReference>;
 
-  constructor(
-    database: DatabaseInternal,
-    path: string,
-    promise: Promise<FirebaseDatabaseTypes.Reference>,
-  ) {
+  constructor(database: DatabaseInternal, path: string, promise: Promise<DatabaseReference>) {
     if (!DatabaseReferenceClass) {
       throw new Error('DatabaseReference class has not been provided.');
     }
 
-    this._ref = createDeprecationProxy(
-      new DatabaseReferenceClass(database, path),
-    ) as FirebaseDatabaseTypes.Reference;
+    this._ref = new DatabaseReferenceClass(database, path);
     this._promise = promise;
 
     return new Proxy(this, {
@@ -63,11 +55,11 @@ export default class DatabaseThenableReference implements Pick<
     }) as unknown as DatabaseThenableReference;
   }
 
-  get then(): Promise<FirebaseDatabaseTypes.Reference>['then'] {
+  get then(): Promise<DatabaseReference>['then'] {
     return this._promise.then.bind(this._promise);
   }
 
-  get catch(): Promise<FirebaseDatabaseTypes.Reference>['catch'] {
+  get catch(): Promise<DatabaseReference>['catch'] {
     return this._promise.catch.bind(this._promise);
   }
 }