Realtime Database

/**
 * Provides Firebase Realtime Database instance using standalone API
 * @param fn - Function that returns initialized Database instance
 * @returns Environment providers for dependency injection
 */
export function provideDatabase(fn: () => Database): EnvironmentProviders;

/**
 * Get Firebase Realtime Database instance
 * @param app - Optional Firebase app instance
 * @returns Firebase Realtime Database instance
 */
export function getDatabase(app?: FirebaseApp): Database;

/**
 * Firebase Realtime Database NgModule for traditional module-based setup
 */
export class DatabaseModule {
  static forRoot(): ModuleWithProviders<DatabaseModule>;
}

/**
 * Injectable service providing access to Firebase Realtime Database instance
 */
export class Database extends Database {}

/**
 * Collection of all Firebase Realtime Database instances
 */
export class DatabaseInstances extends Array<Database> {}

/**
 * Observable stream of Firebase Realtime Database instances
 */
export const databaseInstance$: Observable<Database>;

/**
 * Get database reference for a path
 * @param database - Database instance
 * @param path - Optional path to reference
 * @returns Database reference
 */
export function ref(database: Database, path?: string): DatabaseReference;

/**
 * Set data at reference
 * @param ref - Database reference
 * @param value - Data to set
 * @returns Promise that resolves when data is set
 */
export function set(ref: DatabaseReference, value: any): Promise<void>;

/**
 * Update data at reference
 * @param ref - Database reference
 * @param values - Object with key-value pairs to update
 * @returns Promise that resolves when data is updated
 */
export function update(ref: DatabaseReference, values: object): Promise<void>;

/**
 * Remove data at reference
 * @param ref - Database reference
 * @returns Promise that resolves when data is removed
 */
export function remove(ref: DatabaseReference): Promise<void>;

/**
 * Push data to reference (generates unique key)
 * @param ref - Database reference
 * @param value - Data to push
 * @returns Promise resolving to reference of pushed data
 */
export function push(ref: DatabaseReference, value?: any): Promise<DatabaseReference>;

/**
 * Get data from reference once
 * @param ref - Database reference
 * @returns Promise resolving to data snapshot
 */
export function get(ref: DatabaseReference): Promise<DataSnapshot>;

/**
 * Listen to value changes at reference
 * @param ref - Database reference
 * @param callback - Callback function for data changes
 * @param cancelCallback - Optional callback for listen cancellation
 * @returns Unsubscribe function
 */
export function on(
  ref: DatabaseReference,
  eventType: EventType,
  callback: (snapshot: DataSnapshot) => void,
  cancelCallback?: (error: Error) => void
): Unsubscribe;

/**
 * Stop listening to reference
 * @param ref - Database reference
 * @param callback - Optional specific callback to remove
 */
export function off(
  ref: DatabaseReference,
  eventType?: EventType,
  callback?: (snapshot: DataSnapshot) => void
): void;

/**
 * Listen to value changes once
 * @param ref - Database reference
 * @param callback - Callback function for data
 * @param cancelCallback - Optional callback for errors
 * @returns Promise resolving to data snapshot
 */
export function once(
  ref: DatabaseReference,
  eventType: EventType,
  callback?: (snapshot: DataSnapshot) => void,
  cancelCallback?: (error: Error) => void
): Promise<DataSnapshot>;

/**
 * Observable of object value at reference
 * @param ref - Database reference
 * @returns Observable stream of object value or null
 */
export function objectVal<T>(ref: DatabaseReference): Observable<T | null>;

/**
 * Observable of list values at reference
 * @param ref - Database reference
 * @returns Observable stream of array values
 */
export function listVal<T>(ref: DatabaseReference): Observable<T[]>;

/**
 * Observable of audit trail changes
 * @param ref - Database reference
 * @returns Observable stream of change records
 */
export function auditTrail<T>(ref: DatabaseReference): Observable<AuditTrail<T>[]>;

/**
 * Observable of state changes (added, removed, changed, moved)
 * @param ref - Database reference
 * @param events - Array of event types to listen for
 * @returns Observable stream of state changes
 */
export function stateChanges<T>(
  ref: DatabaseReference,
  events?: ChildEvent[]
): Observable<StateChange<T>>;

/**
 * Order by child key
 * @param ref - Database reference
 * @param path - Child path to order by
 * @returns Ordered query reference
 */
export function orderByChild(ref: DatabaseReference, path: string): DatabaseReference;

/**
 * Order by key
 * @param ref - Database reference
 * @returns Ordered query reference
 */
export function orderByKey(ref: DatabaseReference): DatabaseReference;

/**
 * Order by value
 * @param ref - Database reference
 * @returns Ordered query reference
 */
export function orderByValue(ref: DatabaseReference): DatabaseReference;

/**
 * Limit to first N items
 * @param ref - Database reference
 * @param limit - Number of items to limit to
 * @returns Limited query reference
 */
export function limitToFirst(ref: DatabaseReference, limit: number): DatabaseReference;

/**
 * Limit to last N items
 * @param ref - Database reference
 * @param limit - Number of items to limit to
 * @returns Limited query reference
 */
export function limitToLast(ref: DatabaseReference, limit: number): DatabaseReference;

/**
 * Start at value
 * @param ref - Database reference
 * @param value - Value to start at
 * @param key - Optional key to start at
 * @returns Filtered query reference
 */
export function startAt(ref: DatabaseReference, value: any, key?: string): DatabaseReference;

/**
 * End at value
 * @param ref - Database reference
 * @param value - Value to end at
 * @param key - Optional key to end at
 * @returns Filtered query reference
 */
export function endAt(ref: DatabaseReference, value: any, key?: string): DatabaseReference;

/**
 * Equal to value
 * @param ref - Database reference
 * @param value - Value to match
 * @param key - Optional key to match
 * @returns Filtered query reference
 */
export function equalTo(ref: DatabaseReference, value: any, key?: string): DatabaseReference;

/**
 * Firebase Realtime Database instance
 */
interface Database {
  readonly app: FirebaseApp;
}

/**
 * Database reference
 */
interface DatabaseReference {
  readonly key: string | null;
  readonly parent: DatabaseReference | null;
  readonly ref: DatabaseReference;
  readonly root: DatabaseReference;
}

/**
 * Data snapshot
 */
interface DataSnapshot {
  readonly key: string | null;
  readonly ref: DatabaseReference;
  readonly size: number;
  exists(): boolean;
  val(): any;
  child(path: string): DataSnapshot;
  hasChild(path: string): boolean;
  hasChildren(): boolean;
  numChildren(): number;
  forEach(action: (child: DataSnapshot) => boolean | void): boolean;
}

/**
 * Event types for database listeners
 */
type EventType = 'value' | 'child_added' | 'child_changed' | 'child_removed' | 'child_moved';

/**
 * Child event types
 */
type ChildEvent = 'added' | 'removed' | 'changed' | 'moved';

/**
 * State change interface
 */
interface StateChange<T> {
  type: ChildEvent;
  payload: T;
  prevKey?: string | null;
  key?: string | null;
}

/**
 * Audit trail entry
 */
interface AuditTrail<T> {
  key: string;
  action: string;
  payload: T;
  timestamp: number;
}

import { Component, inject } from '@angular/core';
import { Database, ref, set, get, update, remove } from '@angular/fire/database';

@Component({
  selector: 'app-database-basic',
  template: `...`,
})
export class DatabaseBasicComponent {
  private database = inject(Database);

  async createUser(userId: string, userData: any) {
    const userRef = ref(this.database, `users/${userId}`);
    await set(userRef, userData);
    console.log('User created');
  }

  async getUser(userId: string) {
    const userRef = ref(this.database, `users/${userId}`);
    const snapshot = await get(userRef);
    
    if (snapshot.exists()) {
      return snapshot.val();
    } else {
      return null;
    }
  }

  async updateUser(userId: string, updates: any) {
    const userRef = ref(this.database, `users/${userId}`);
    await update(userRef, updates);
    console.log('User updated');
  }

  async deleteUser(userId: string) {
    const userRef = ref(this.database, `users/${userId}`);
    await remove(userRef);
    console.log('User deleted');
  }
}

import { Component, inject } from '@angular/core';
import { Database, ref, objectVal, listVal } from '@angular/fire/database';

@Component({
  selector: 'app-realtime-data',
  template: `
    <div *ngIf="user$ | async as user">
      <h2>{{ user.name }}</h2>
      <p>Status: {{ user.status }}</p>
    </div>
    
    <div *ngFor="let message of messages$ | async">
      <p>{{ message.text }} - {{ message.timestamp | date }}</p>
    </div>
  `,
})
export class RealtimeDataComponent {
  private database = inject(Database);

  // Observable of single user object
  user$ = objectVal(ref(this.database, 'users/user123'));

  // Observable of messages list
  messages$ = listVal(ref(this.database, 'messages'));
}