// Type definitions for React Native Firebase v1.0.0-alpha7 // Project: https://github.com/invertase/react-native-firebase // Definitions by: Tal // TypeScript Version: 2.1 declare module "react-native-firebase" { /** 3rd party provider Credentials */ type AuthCredential = { providerId: string, token: string, secret: string } type FirebaseModuleAndStatics = { (): M; nativeModuleExists: boolean; } & S // Modules commented-out do not currently have type definitions export class Firebase { private constructor(); // admob: FirebaseModuleAndStatics; analytics: FirebaseModuleAndStatics; auth: FirebaseModuleAndStatics; // config: FirebaseModule; crash: FirebaseModuleAndStatics; crashlytics: FirebaseModuleAndStatics; database: FirebaseModuleAndStatics; firestore: FirebaseModuleAndStatics; iid: FirebaseModuleAndStatics // invites: FirebaseModuleAndStatics links: FirebaseModuleAndStatics; messaging: FirebaseModuleAndStatics; notifications: FirebaseModuleAndStatics; // perf: FirebaseModuleAndStatics; storage: FirebaseModuleAndStatics; // utils: FirebaseModuleAndStatics; initializeApp(options: Firebase.Options, name: string): App; app(name?: string): App; readonly apps: App[]; readonly SDK_VERSION: string; } namespace Firebase { interface Options { apiKey: string; appId: string; databaseURL: string; messagingSenderId: string; projectId: string; storageBucket: string; } } const firebase: Firebase; export default firebase; // Modules commented-out do not currently have type definitions export class App { private constructor(); // admob(): RNFirebase.admob.AdMob; analytics(): RNFirebase.Analytics; auth(): RNFirebase.auth.Auth; // config(): RNFirebase.config.Config; crash(): RNFirebase.crash.Crash; crashlytics(): RNFirebase.crashlytics.Crashlytics; database(): RNFirebase.database.Database; firestore(): RNFirebase.firestore.Firestore; iid(): RNFirebase.iid.InstanceId; // invites(): RNFirebase.invites.Invites; links(): RNFirebase.links.Links; messaging(): RNFirebase.messaging.Messaging; notifications(): RNFirebase.notifications.Notifications; // perf(): RNFirebase.perf.Performance; storage(): RNFirebase.storage.Storage; // utils(): RNFirebase.utils.Utils; readonly name: string; readonly options: Firebase.Options; onReady: () => Promise; } export namespace RNFirebase { interface RnError extends Error { code?: string; } type GoogleApiAvailabilityType = { status: number, isAvailable: boolean, isUserResolvableError?: boolean, error?: string }; /** * pass custom options by passing an object with configuration options. * The configuration object will be generated first by the native configuration object, if set and then will be overridden if passed in JS. * That is, all of the following key/value pairs are optional if the native configuration is set. */ interface configurationOptions { /** * default false * When set to true, RNFirebase will log messages to the console and fire debug events we can listen to in js * @usage * firebase.on('debug', msg => console.log('Received debug message', msg)) */ debug?: boolean; /** * default false * When set to true, database persistence will be enabled. */ persistence?: boolean; /** * Default from app [NSBundle mainBundle] The bundle ID for the app to be bundled with */ bundleID?: string; /** * defualt "" * The Google App ID that is used to uniquely identify an instance of an app. */ googleAppID?: string; /** * deufalt "" * The database root (i.e. https://my-app.firebaseio.com) */ databaseURL?: string; /** * defualt "" * URL scheme to set up durable deep link service */ deepLinkURLScheme?: string; /** * defualt "" * The Google Cloud storage bucket name */ storageBucket?: string; /** * default "" * The Android client ID used in Google AppInvite when an iOS app has it's android version */ androidClientID?: string; /** * default "" * The Project number from the Google Developer's console used to configure Google Cloud Messaging */ GCMSenderID?: string; /** * default "" * The tracking ID for Google Analytics */ trackingID?: string; /** * default "" * The OAuth2 client ID for iOS application used to authenticate Google Users for signing in with Google */ clientID?: string; /** * defualt "" * The secret iOS API key used for authenticating requests from our app */ APIKey?: string } namespace storage { interface StorageTask extends Promise { on(event: TaskEvent, nextOrObserver: (snapshot: any) => any, error: (error: RnError) => any, complete: (complete: any) => any): any /** * is not currently supported by react-native-firebase */ pause(): void /** * is not currently supported by react-native-firebase */ resume(): void /** * is not currently supported by react-native-firebase */ cancel(): void } interface RNStorage extends Reference { /** * Downloads a reference to the device * @param {String} filePath Where to store the file * @return {Promise} * */ downloadFile(filePath: string): StorageTask; /** * Upload a file path * @returns {Promise} */ putFile(filePath: string, metadata?: any): StorageTask; setMaxDownloadRetryTime(time: number): void [key: string]: any; } interface Storage { maxOperationRetryTime: number; maxUploadRetryTime: number; ref(path?: string): storage.RNStorage; refFromURL(url: string): storage.RNStorage; setMaxOperationRetryTime(time: number): any; setMaxUploadRetryTime(time: number): any; } interface Reference { bucket: string; child(path: string): storage.Reference; delete(): Promise; fullPath: string; getDownloadURL(): Promise; getMetadata(): Promise; name: string; parent: storage.Reference | null; put(data: any | Uint8Array | ArrayBuffer, metadata?: storage.UploadMetadata): storage.UploadTask; putString(data: string, format?: storage.StringFormat, metadata?: storage.UploadMetadata): storage.UploadTask; root: storage.Reference; storage: storage.Storage; toString(): string; updateMetadata(metadata: storage.SettableMetadata): Promise; } interface UploadMetadata extends storage.SettableMetadata { md5Hash?: string | null; } interface SettableMetadata { cacheControl?: string | null; contentDisposition?: string | null; contentEncoding?: string | null; contentLanguage?: string | null; contentType?: string | null; customMetadata?: { [/* warning: coerced from ? */ key: string]: string } | null; } type StringFormat = string; var StringFormat: { BASE64: StringFormat, BASE64URL: StringFormat, DATA_URL: StringFormat, RAW: StringFormat, } interface UploadTask { cancel(): boolean; catch(onRejected: (a: RnError) => any): Promise; on(event: storage.TaskEvent, nextOrObserver?: null | Object, error?: ((a: RnError) => any) | null, complete?: (() => any) | null): Function; pause(): boolean; resume(): boolean; snapshot: storage.UploadTaskSnapshot; then(onFulfilled?: ((a: storage.UploadTaskSnapshot) => any) | null, onRejected?: ((a: RnError) => any) | null): Promise; } interface UploadTaskSnapshot { bytesTransferred: number; downloadURL: string | null; metadata: storage.FullMetadata; ref: storage.Reference; state: storage.TaskState; task: storage.UploadTask; totalBytes: number; } interface FullMetadata extends storage.UploadMetadata { bucket: string; downloadURLs: string[]; fullPath: string; generation: string; metageneration: string; name: string; size: number; timeCreated: string; updated: string; } type TaskEvent = string; var TaskEvent: { STATE_CHANGED: TaskEvent, }; type TaskState = string; var TaskState: { CANCELED: TaskState, ERROR: TaskState, PAUSED: TaskState, RUNNING: TaskState, SUCCESS: TaskState, }; } namespace database { interface Database { /** * Returns a new firebase reference instance * */ ref(path?: string): RnReference /** * register listener */ on(path: string, modifiersString: string, modifiers: Array, eventName: string, cb: () => void, errorCb: () => void): any /** * unregister listener */ off(path: string, modifiersString: string, eventName?: string, origCB?: () => void): any /** * Removes all event handlers and their native subscriptions */ cleanup(): Promise /** * connect to firebase backend */ goOnline(): void /** * disconnect to firebase backend */ goOffline(): void [key: string]: any; } interface RnReference extends Reference { keepSynced(bool: boolean): any filter(name: string, value: any, key?: string): any; [key: string]: any; } type QueryEventType = "value" | "child_added" | "child_removed" | "child_changed" | "child_moved"; type QuerySuccessCallback = (snapshot: DataSnapshot, previousChildId?: string | null) => void; type QueryErrorCallback = (e: Error) => void; interface Query { endAt(value: number | string | boolean | null, key?: string): database.Query; equalTo(value: number | string | boolean | null, key?: string): database.Query; isEqual(other: database.Query | null): boolean; limitToFirst(limit: number): database.Query; limitToLast(limit: number): database.Query; off(eventType?: QueryEventType, callback?: QuerySuccessCallback, context?: Object): void; on(eventType: QueryEventType, callback: QuerySuccessCallback, cancelCallbackOrContext?: QueryErrorCallback, context?: Object): (a: database.DataSnapshot | null, b?: string) => QuerySuccessCallback; once(eventType: QueryEventType, successCallback?: QuerySuccessCallback, failureCallbackOrContext?: QueryErrorCallback, context?: Object): Promise; orderByChild(path: string): database.Query; orderByKey(): database.Query; orderByPriority(): database.Query; orderByValue(): database.Query; ref: database.Reference; startAt(value: number | string | boolean | null, key?: string): database.Query; toJSON(): Object; toString(): string; } interface DataSnapshot { child(path: string): database.DataSnapshot; exists(): boolean; exportVal(): any; forEach(action: (a: database.DataSnapshot) => boolean): boolean; getPriority(): string | number | null; hasChild(path: string): boolean; hasChildren(): boolean; key: string | null; numChildren(): number; ref: database.Reference; toJSON(): Object | null; val(): any; } interface ThenableReference extends Promise { } interface ThenableReference extends Reference { } interface Reference extends database.Query { child(path: string): database.Reference; key: string | null; onDisconnect(): any; parent: database.Reference | null; push(value?: any, onComplete?: (a: RnError | null) => any): ThenableReference remove(onComplete?: (a: RnError | null) => any): Promise; root: database.Reference; set(value: any, onComplete?: (a: RnError | null) => any): Promise; setPriority(priority: string | number | null, onComplete: (a: RnError | null) => any): Promise; setWithPriority(newVal: any, newPriority: string | number | null, onComplete?: (a: RnError | null) => any): Promise; transaction(transactionUpdate: (a: any) => any, onComplete?: (a: RnError | null, b: boolean, c: database.DataSnapshot | null) => any, applyLocally?: boolean): Promise; update(values: Object, onComplete?: (a: RnError | null) => any): Promise; } interface DatabaseStatics { /** @see https://www.firebase.com/docs/java-api/javadoc/com/firebase/client/ServerValue.html#TIMESTAMP */ ServerValue: { TIMESTAMP: { [key: string]: string } } } } /** * firebase Analytics */ interface Analytics { /**Log a custom event with optional params. */ logEvent(event: string, params?: Object): void /** Sets whether analytics collection is enabled for this app on this device. */ setAnalyticsCollectionEnabled(enabled: boolean): void /** * Sets the current screen name, which specifies the current visual context in your app. * Whilst screenClassOverride is optional, * it is recommended it is always sent as your current class name, * for example on Android it will always show as 'MainActivity' if not specified. */ setCurrentScreen(screenName: string | null, screenClassOverride?: string): void /** * Sets the minimum engagement time required before starting a session. * The default value is 10000 (10 seconds) */ setMinimumSessionDuration(miliseconds: number): void /** * Sets the duration of inactivity that terminates the current session. * The default value is 1800000 (30 minutes). */ setSessionTimeoutDuration(miliseconds: number): void /** * Gives a user a uniqiue identificaition. * @example * const id = firebase.auth().currentUser.uid; * * firebase.analytics().setUserId(id); */ setUserId(id: string | null): void /** * Sets a key/value pair of data on the current user. */ setUserProperty(name: string, value: string | null): void; [key: string]: any; } type AdditionalUserInfo = { isNewUser: boolean, profile?: Object, providerId: string, username?: string, } type UserCredential = { additionalUserInfo?: AdditionalUserInfo, user: User, } type UserInfo = { displayName?: string, email?: string, phoneNumber?: string, photoURL?: string, providerId: string, uid: string, } type UpdateProfile = { displayName?: string, photoURL?: string, } type UserMetadata = { creationTime?: string, lastSignInTime?: string, } interface User { /** * The user's display name (if available). */ displayName: string | null /** * - The user's email address (if available). */ email: string | null /** * - True if the user's email address has been verified. */ emailVerified: boolean /** * */ isAnonymous: boolean metadata: UserMetadata phoneNumber: string | null /** * - The URL of the user's profile picture (if available). */ photoURL: string | null /** * - Additional provider-specific information about the user. */ providerData: Array /** * - The authentication provider ID for the current user. * For example, 'facebook.com', or 'google.com'. */ providerId: string /** * - The user's unique ID. */ uid: string /** * Delete the current user. */ delete(): Promise /** * Returns the users authentication token. * * @param forceRefresh: boolean - default to false */ getIdToken(forceRefresh?: boolean): Promise getToken(forceRefresh?: boolean): Promise linkAndRetrieveDataWithCredential(credential: AuthCredential): Promise /** * Link the user with a 3rd party credential provider. */ linkWithCredential(credential: AuthCredential): Promise reauthenticateAndRetrieveDataWithCredential(credential: AuthCredential): Promise /** * Re-authenticate a user with a third-party authentication provider */ reauthenticateWithCredential(credential: AuthCredential): Promise /** * Refreshes the current user. */ reload(): Promise /** * Sends a verification email to a user. * This will Promise reject is the user is anonymous. */ sendEmailVerification(actionCodeSettings?: ActionCodeSettings): Promise toJSON(): object unlink(providerId: string): Promise /** * Updates the user's email address. * See Firebase docs for more information on security & email validation. * This will Promise reject is the user is anonymous. */ updateEmail(email: string): Promise /** * Important: this is a security sensitive operation that requires the user to have recently signed in. * If this requirement isn't met, ask the user to authenticate again and then call firebase.User#reauthenticate. * This will Promise reject is the user is anonymous. */ updatePassword(password: string): Promise /** * Updates a user's profile data. * Profile data should be an object of fields to update: */ updateProfile(updates: UpdateProfile): Promise } type ActionCodeSettings = { android: { installApp?: boolean, minimumVersion?: string, packageName: string, }, handleCodeInApp?: boolean, iOS: { bundleId?: string, }, url: string, } interface ActionCodeInfo { data: { email?: string, fromEmail?: string }, operation: 'PASSWORD_RESET' | 'VERIFY_EMAIL' | 'RECOVER_EMAIL' } interface ConfirmationResult { confirm(verificationCode: string): Promise; verificationId: string | null; } type PhoneAuthSnapshot = { state: 'sent' | 'timeout' | 'verified' | 'error', verificationId: string, code: string | null, error: Error | null, }; type PhoneAuthError = { code: string | null, verificationId: string, message: string | null, stack: string | null, }; interface PhoneAuthListener { on(event: string, observer: () => PhoneAuthSnapshot, errorCb?: () => PhoneAuthError, successCb?: () => PhoneAuthSnapshot): PhoneAuthListener; then(fn: () => PhoneAuthSnapshot): Promise catch(fn: () => Error): Promise } namespace auth { type AuthResult = { authenticated: boolean, user: object | null } | null; type AuthProvider = { PROVIDER_ID: string, credential: (token: string, secret?: string) => AuthCredential, }; interface Auth { readonly app: App; /** * Returns the current Firebase authentication state. */ authResult: AuthResult | null; /** * Returns the currently signed-in user (or null). See the User class documentation for further usage. */ currentUser: User | null /** * Gets/Sets the language for the app instance */ languageCode: string | null; /** * Listen for changes in the users auth state (logging in and out). * This method returns a unsubscribe function to stop listening to events. * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use. */ onAuthStateChanged(listener: Function): () => void; /** * Listen for changes in id token. * This method returns a unsubscribe function to stop listening to events. * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use. */ onIdTokenChanged(listener: Function): () => void; /** * Listen for changes in the user. * This method returns a unsubscribe function to stop listening to events. * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use. */ onUserChanged(listener: Function): () => void; signOut(): Promise signInAnonymouslyAndRetrieveData(): Promise /** * Sign an anonymous user. * If the user has already signed in, that user will be returned */ signInAnonymously(): Promise createUserAndRetrieveDataWithEmailAndPassword(email: string, password: string): Promise /** * We can create a user by calling the createUserWithEmailAndPassword() function. * The method accepts two parameters, an email and a password. */ createUserWithEmailAndPassword(email: string, password: string): Promise signInAndRetrieveDataWithEmailAndPassword(email: string, password: string): Promise /** * To sign a user in with their email and password, use the signInWithEmailAndPassword() function. * It accepts two parameters, the user's email and password: */ signInWithEmailAndPassword(email: string, password: string): Promise signInAndRetrieveDataWithCustomToken(token: string): Promise /** * Sign a user in with a self-signed JWT token. * To sign a user using a self-signed custom token, * use the signInWithCustomToken() function. * It accepts one parameter, the custom token: */ signInWithCustomToken(token: string): Promise signInAndRetrieveDataWithCredential(credential: AuthCredential): Promise /** * Sign in the user with a 3rd party credential provider. * credential requires the following properties: */ signInWithCredential(credential: AuthCredential): Promise /** * Asynchronously signs in using a phone number. */ signInWithPhoneNumber(phoneNumber: string): Promise /** * Returns a PhoneAuthListener to listen to phone verification events, * on the final completion event a PhoneAuthCredential can be generated for * authentication purposes. */ verifyPhoneNumber(phoneNumber: string, autoVerifyTimeout?: number): PhoneAuthListener /** * Sends a password reset email to the given email address. * Unlike the web SDK, * the email will contain a password reset link rather than a code. */ sendPasswordResetEmail(email: string, actionCodeSettings?: ActionCodeSettings): Promise /** * Completes the password reset process, given a confirmation code and new password. */ confirmPasswordReset(code: string, newPassword: string): Promise /** * Applies a verification code sent to the user by email or other out-of-band mechanism. */ applyActionCode(code: string): Promise /** * Checks a verification code sent to the user by email or other out-of-band mechanism. */ checkActionCode(code: string): Promise /** * Returns a list of authentication providers that can be used to sign in a given user (identified by its main email address). */ fetchProvidersForEmail(email: string): Promise> verifyPasswordResetCode(code: string): Promise [key: string]: any; } interface AuthStatics { EmailAuthProvider: AuthProvider; PhoneAuthProvider: AuthProvider; GoogleAuthProvider: AuthProvider; GithubAuthProvider: AuthProvider; OAuthProvider: AuthProvider; TwitterAuthProvider: AuthProvider; FacebookAuthProvider: AuthProvider; PhoneAuthState: { CODE_SENT: string; AUTO_VERIFY_TIMEOUT: string; AUTO_VERIFIED: string; ERROR: string; }; } } namespace messaging { interface Messaging { /** * Returns the devices FCM token. */ getToken(): Promise /** * On a new message, * the payload object is passed to the listener callback. * This method is only triggered when the app is running. */ onMessage(listener: (message: any) => any): () => any /** * On the event a devices FCM token is refreshed by Google, * the new token is returned in a callback listener. */ onTokenRefresh(listener: (token: string) => any): () => any /** * Requests app notification permissions in an Alert dialog. */ requestPermission(): Promise; /** * Checks if the app has notification permissions. */ hasPermission(): Promise; /** * Send an upstream message */ sendMessage(remoteMessage: RemoteMessage): Promise /** * Subscribes the device to a topic. */ subscribeToTopic(topic: string): void /** * Unsubscribes the device from a topic. */ unsubscribeFromTopic(topic: string): void } class RemoteMessage { collapseKey?: string data: Object from?: string messageId?: string messageType: string sentTime?: number to?: string ttl?: number constructor(); setCollapseKey(collapseKey: string): RemoteMessage setData(data: Object): RemoteMessage setMessageId(messageId: string): RemoteMessage setMessageType(messageType: string): RemoteMessage setTo(to: string): RemoteMessage setTtl(ttl: number): RemoteMessage } interface MessagingStatics { RemoteMessage: RemoteMessage; } } namespace iid { interface InstanceId { delete(): Promise get(): Promise } } namespace notifications { interface AndroidNotifications { createChannel(channel: Android.Channel): Promise createChannelGroup(channelGroup: Android.ChannelGroup): Promise createChannelGroups(channelGroups: Android.ChannelGroup[]): Promise createChannels(channels: Android.Channel[]): Promise } interface Notifications { android: AndroidNotifications /** * Cancels all notifications */ cancelAllNotifications(): void /** * Cancels a notification by ID */ cancelNotification(notificationId: string): void displayNotification(notification: Notification): Promise /** * Returns the current badge number on the app icon. */ getBadge(): Promise getInitialNotification(): Promise getScheduledNotifications(): Promise onNotification(listener: (notification: Notification) => any): () => any onNotificationDisplayed(listener: (notification: Notification) => any): () => any onNotificationOpened(listener: (notificationOpen: NotificationOpen) => any): () => any removeAllDeliveredNotifications(): void removeDeliveredNotification(notificationId: string): void /** * Schedule a local notification to be shown on the device. */ scheduleNotification(notification: Notification, schedule: any): any /** * Sets the badge number on the iOS app icon. */ setBadge(badge: number): void } class Notification { android: AndroidNotification ios: IOSNotification body: string data: any notificationId: string sound?: string subtitle?: string title: string constructor(); setBody(body: string): Notification setData(data: any): Notification setNotificationId(notificationId: string): Notification setSound(sound: string): Notification setSubtitle(subtitle: string): Notification setTitle(title: string): Notification } class NotificationOpen { action: string notification: Notification results?: any } class AndroidNotification { actions?: Android.Action[] autoCancel?: boolean badgeIconType?: Android.BadgeIconType bigPicture?: any bigText?: any category?: Android.Category channelId?: string clickAction?: string color?: string colorized?: boolean contentInfo?: string defaults?: Android.Defaults[] group?: string groupAlertBehaviour?: Android.GroupAlert groupSummary?: boolean largeIcon?: string lights?: Android.Lights localOnly?: boolean number?: number ongoing?: boolean onlyAlertOnce?: boolean people?: string[] priority?: Android.Priority progress?: Android.Progress remoteInputHistory?: string[] shortcutId?: string showWhen?: boolean smallIcon?: any sortKey?: string ticker?: string timeoutAfter?: number usesChronometer?: boolean vibrate?: number[] visibility?: Android.Visibility when?: number addAction(action: Android.Action): Notification addPerson(person: string): Notification setAutoCancel(autoCancel: boolean): Notification setBadgeIconType(badgeIconType: Android.BadgeIconType): Notification setBigPicture(picture: string, largeIcon?: string, contentTitle?: string, summaryText?: string): Notification setBigText(text: string, contentTitle?: string, summaryText?: string): Notification setCategory(category: Android.Category): Notification setChannelId(channelId: string): Notification setClickAction(clickAction: string): Notification setColor(color: string): Notification setColorized(colorized: boolean): Notification setContentInfo(contentInfo: string): Notification setDefaults(defaults: Android.Defaults[]): Notification setGroup(group: string): Notification setGroupAlertBehaviour(groupAlertBehaviour: Android.GroupAlert): Notification setGroupSummary(groupSummary: boolean): Notification setLargeIcon(largeIcon: string): Notification setLights(argb: number, onMs: number, offMs: number): Notification setLocalOnly(localOnly: boolean): Notification setNumber(number: number): Notification setOngoing(ongoing: boolean): Notification setOnlyAlertOnce(onlyAlertOnce: boolean): Notification setPriority(priority: Android.Priority): Notification setProgress(max: number, progress: number, indeterminate: boolean): Notification //setPublicVersion(publicVersion: Notification): Notification setRemoteInputHistory(remoteInputHistory: string[]): Notification setShortcutId(shortcutId: string): Notification setShowWhen(showWhen: boolean): Notification setSmallIcon(icon: string, level?: number): Notification setSortKey(sortKey: string): Notification setTicker(ticker: string): Notification setTimeoutAfter(timeoutAfter: number): Notification setUsesChronometer(usesChronometer: boolean): Notification setVibrate(vibrate: number[]): Notification setVisibility(visibility: Android.Visibility): Notification setWhen(when: number): Notification } namespace Android { class Action { action: string allowGeneratedReplies: boolean icon: string remoteInputs: RemoteInput[] semanticAction?: SemanticAction showUserInterface?: boolean title: string constructor(action: string, icon: string, title: string); addRemoteInput(remoteInput: RemoteInput): Action setAllowGenerateReplies(allowGeneratedReplies: boolean): Action setSemanticAction(semanticAction: SemanticAction): Action setShowUserInterface(showUserInterface: boolean): Action } class RemoteInput { allowedDataTypes: any[] allowFreeFormInput?: boolean choices: string[] label?: string resultKey: string constructor(resultKey: string); setAllowDataType(mimeType: string, allow: boolean): RemoteInput setAllowFreeFormInput(allowFreeFormInput: boolean): RemoteInput setChoices(choices: string[]): RemoteInput; setLabel(label: string): RemoteInput; } class Channel { channelId: string name: string importance: Importance bypassDnd?: boolean description?: string group?: string lightColor?: string lightsEnabled?: boolean lockScreenVisibility?: Visibility showBadge?: boolean sound?: string vibrationEnabled?: boolean vibrationPattern?: number[] constructor(channelId: string, name: string, importance: Importance) enableLights(lightsEnabled: boolean): Channel enableVibration(vibrationEnabled: boolean): Channel setBypassDnd(bypassDnd: boolean): Channel setDescription(description: string): Channel setGroup(groupId: string): Channel setLightColor(lightColor: string): Channel setLockScreenVisibility(lockScreenVisibility: Visibility): Channel setShowBadge(showBadge: boolean): Channel setSound(sound: string): Channel setVibrationPattern(vibrationPattern: number[]): Channel } class ChannelGroup { groupId: string name: string constructor(groupId: string, name: string) } export enum BadgeIconType { Large = 2, None = 0, Small = 1 } export type Category = 'alarm' | 'call' | 'email' | 'err' | 'event' | 'msg' | 'progress' | 'promo' | 'recommendation' | 'reminder' | 'service' | 'social' | 'status' | 'system' | 'transport' export enum Defaults { All = -1, Lights = 4, Sound = 1, Vibrate = 2 } export enum GroupAlert { All = 0, Children = 2, Summary = 1 } export enum Importance { Default = 3, High = 4, Low = 2, Max = 5, Min = 1, None = 3, Unspecified = -1000 } export enum Priority { Default = 0, High = 1, Low = -1, Max = 2, Min = -2 } export enum SemanticAction { Archive = 5, Call = 10, Delete = 4, MarkAsRead = 2, MarkAsUnread = 3, Mute = 6, None = 0, Reply = 1, ThumbsDown = 9, ThumbsUp = 8, Unmute = 7 } export enum Visibility { Private = 0, Public = 1, Secret = -1 } class Lights { argb: number; offMs: number; onMs: number; } class Progress { indeterminate: boolean; max: number; progress: number; } } class IOSNotification { alertAction?: string attachments: IOSAttachment[] badge?: string category?: string hasAction?: boolean launchImage?: string threadIdentifier?: string addAttachment(identifier: string, url: string, options: IOSAttachmentOptions): Notification setAlertAction(alertAction: string): Notification setBadge(badge:string): Notification setCategory(category: string): Notification setHasAction(hasAction: boolean): Notification setLaunchImage(launchImage: string): Notification setThreadIdentifier(threadIdentifier: string): Notification } class IOSAttachment { identifier: string options: IOSAttachmentOptions url: string } class IOSAttachmentOptions { typeHint: string thumbnailHidden: boolean thumbnailClippingRect: any thumbnailTime: string } interface NotificationsStatics { Android: { Action: Android.Action, BadgeIconType: Android.BadgeIconType, Category: Android.Category, Channel: Android.Channel, ChannelGroup: Android.ChannelGroup, Defaults: Android.Defaults, GroupAlert: Android.GroupAlert, Importance: Android.Importance, Priority: Android.Priority, RemoteInput: Android.RemoteInput, SemanticAction: Android.SemanticAction, Visibility: Android.Visibility, }; Notification: Notification; } } namespace crash { interface Crash { /** Logs a message that will appear in a subsequent crash report. */ log(message: string): void /** * Android: Logs a message that will appear in a subsequent crash report as well as in logcat. * iOS: Logs the message in the subsequest crash report only (same as log). */ logcat(level: number, tag: string, message: string): void /** * Files a crash report, along with any previous logs to Firebase. * An Error object must be passed into the report method. */ report(error: RnError, maxStackSize: Number): void [key: string]: any; } } namespace crashlytics { interface Crashlytics { /** * Forces a crash. Useful for testing your application is set up correctly. */ crash(): void; /** * Logs a message that will appear in any subsequent crash reports. */ log(message: string): void; /** * Logs a non fatal exception. */ recordError(code: number, message: string): void; /** * Set a boolean value to show alongside any subsequent crash reports. */ setBoolValue(key: string, value: boolean): void; /** * Set a float value to show alongside any subsequent crash reports. */ setFloatValue(key: string, value: number): void; /** * Set an integer value to show alongside any subsequent crash reports. */ setIntValue(key: string, value: number): void; /** * Set a string value to show alongside any subsequent crash reports. */ setStringValue(key: string, value: string): void; /** * Set the user ID to show alongside any subsequent crash reports. */ setUserIdentifier(userId: string): void; } } namespace links { interface Links { /** Creates a standard dynamic link. */ createDynamicLink(dynamicLink: DynamicLink): Promise; /** Creates a short dynamic link. */ createShortDynamicLink(type: 'SHORT' | 'UNGUESSABLE'): Promise; /** * Returns the URL that the app has been launched from. If the app was * not launched from a URL the return value will be null. */ getInitialLink(): Promise; /** * Subscribe to URL open events while the app is still running. * The listener is called from URL open events whilst the app is still * running, use getInitialLink for URLs which cause the app to open * from a previously closed / not running state. * Returns an unsubscribe function, call the returned function to * unsubscribe from all future events. */ onLink(listener: (url: string) => void): () => void; } class DynamicLink { analytics: AnalyticsParameters android: AndroidParameters ios: IOSParameters itunes: ITunesParameters navigation: NavigationParameters social: SocialParameters constructor(link: string, dynamicLinkDomain: string); } interface AnalyticsParameters { setCampaign(campaign: string): DynamicLink setContent(content: string): DynamicLink setMedium(medium: string): DynamicLink setSource(source: string): DynamicLink setTerm(term: string): DynamicLink } interface AndroidParameters { setFallbackUrl(fallbackUrl: string): DynamicLink setMinimumVersion(minimumVersion: number): DynamicLink setPackageName(packageName: string): DynamicLink } interface IOSParameters { setAppStoreId(appStoreId: string): DynamicLink setBundleId(bundleId: string): DynamicLink setCustomScheme(customScheme: string): DynamicLink setFallbackUrl(fallbackUrl: string): DynamicLink setIPadBundleId(iPadBundleId: string): DynamicLink setIPadFallbackUrl(iPadFallbackUrl: string): DynamicLink setMinimumVersion(minimumVersion: string): DynamicLink } interface ITunesParameters { setAffiliateToken(affiliateToken: string): DynamicLink setCampaignToken(campaignToken: string): DynamicLink setProviderToken(providerToken: string): DynamicLink } interface NavigationParameters { setForcedRedirectEnabled(forcedRedirectEnabled: boolean): DynamicLink } interface SocialParameters { setDescriptionText(descriptionText: string): DynamicLink setImageUrl(imageUrl: string): DynamicLink setTitle(title: string): DynamicLink } interface LinksStatics { DynamicLink: DynamicLink; } } namespace firestore { interface Firestore { readonly app: App; batch(): WriteBatch; collection(collectionPath: string): CollectionReference; disableNetwork(): Promise doc(documentPath: string): DocumentReference; enableNetwork(): Promise; enablePersistence(enabled: boolean): Promise; runTransaction(updateFunction: (transaction: Transaction) => Promise): Promise; settings(settings: Settings): Promise; } interface FirestoreStatics { FieldPath: typeof FieldPath; FieldValue: typeof FieldValue; GeoPoint: typeof GeoPoint; enableLogging(enabled: boolean): void; setLogLevel(logLevel: 'debug' | 'error' | 'silent'): void; } interface CollectionReference { readonly firestore: Firestore; readonly id: string; readonly parent: DocumentReference; add(data: object): Promise; doc(documentPath?: string): DocumentReference; endAt(snapshot: DocumentSnapshot): Query; endAt(...varargs: any[]): Query; endBefore(snapshot: DocumentSnapshot): Query; endBefore(...varargs: any[]): Query; get(): Promise; limit(limit: number): Query; onSnapshot(onNext: Query.ObserverOnNext, onError?: Query.ObserverOnError): () => void; onSnapshot(observer: Query.Observer): () => void; onSnapshot(queryListenOptions: Query.QueryListenOptions, onNext: Query.ObserverOnNext, onError?: Query.ObserverOnError): () => void; onSnapshot(queryListenOptions: Query.QueryListenOptions, observer: Query.Observer): () => void; orderBy(fieldPath: string | FieldPath, directionStr?: Types.QueryDirection): Query; startAfter(snapshot: DocumentSnapshot): Query; startAfter(...varargs: any[]): Query; startAt(snapshot: DocumentSnapshot): Query; startAt(...varargs: any[]): Query; where(fieldPath: string, op: Types.QueryOperator, value: any): Query; } interface DocumentChange { readonly doc: DocumentSnapshot; readonly newIndex: number; readonly oldIndex: number; readonly type: string; } interface DocumentReference { readonly firestore: Firestore; readonly id: string | null; readonly parent: CollectionReference; readonly path: string; collection(collectionPath: string): CollectionReference; delete(): Promise; get(): Promise; onSnapshot(onNext: DocumentReference.ObserverOnNext, onError?: DocumentReference.ObserverOnError): () => void; onSnapshot(observer: DocumentReference.Observer): () => void; onSnapshot(documentListenOptions: DocumentReference.DocumentListenOptions, onNext: DocumentReference.ObserverOnNext, onError?: DocumentReference.ObserverOnError): () => void; onSnapshot(documentListenOptions: DocumentReference.DocumentListenOptions, observer: DocumentReference.Observer): () => void; set(data: object, writeOptions?: Types.WriteOptions): Promise; update(obj: object): Promise; update(key1: Types.UpdateKey, val1: any): Promise; update(key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any): Promise; update(key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any): Promise; update(key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any): Promise; update(key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any, key5: Types.UpdateKey, val5: any): Promise; } namespace DocumentReference { interface DocumentListenOptions { includeMetadataChanges: boolean; } type ObserverOnNext = (documentSnapshot: DocumentSnapshot) => void; type ObserverOnError = (err: object) => void; interface Observer { next: ObserverOnNext; error?: ObserverOnError; } } interface DocumentSnapshot { readonly exists: boolean; readonly id: string | null; readonly metadata: Types.SnapshotMetadata; readonly ref: DocumentReference; data(): object | void; get(fieldPath: string | FieldPath): any | undefined; } class FieldPath { static documentId(): FieldPath; constructor(...segments: string[]); } class FieldValue { static delete(): FieldValue; static serverTimestamp(): FieldValue; } class GeoPoint { constructor(latitude: number, longitude: number); readonly latitude: number; readonly longitude: number; } class Path { static fromName(name: string): Path; constructor(pathComponents: string[]); readonly id: string | null; readonly isDocument: boolean; readonly isCollection: boolean; readonly relativeName: string; child(relativePath: string): Path; parent(): Path | null; } interface Query { readonly firestore: Firestore; endAt(snapshot: DocumentSnapshot): Query; endAt(...varargs: any[]): Query; endBefore(snapshot: DocumentSnapshot): Query; endBefore(...varargs: any[]): Query; get(): Promise; limit(limit: number): Query; onSnapshot(onNext: Query.ObserverOnNext, onError?: Query.ObserverOnError): () => void; onSnapshot(observer: Query.Observer): () => void; onSnapshot(queryListenOptions: Query.QueryListenOptions, onNext: Query.ObserverOnNext, onError?: Query.ObserverOnError): () => void; onSnapshot(queryListenOptions: Query.QueryListenOptions, observer: Query.Observer): () => void; orderBy(fieldPath: string | FieldPath, directionStr?: Types.QueryDirection): Query; startAfter(snapshot: DocumentSnapshot): Query; startAfter(...varargs: any[]): Query; startAt(snapshot: DocumentSnapshot): Query; startAt(...varargs: any[]): Query; where(fieldPath: string, op: Types.QueryOperator, value: any): Query; } namespace Query { interface NativeFieldPath { elements?: string[]; string?: string; type: 'fieldpath' | 'string'; } interface FieldFilter { fieldPath: NativeFieldPath; operator: string; value: any; } interface FieldOrder { direction: string; fieldPath: NativeFieldPath; } interface QueryOptions { endAt?: any[]; endBefore?: any[]; limit?: number; offset?: number; selectFields?: string[]; startAfter?: any[]; startAt?: any[]; } // The JS code expects at least one of 'includeDocumentMetadataChanges' // or 'includeQueryMetadataChanges' to be defined. interface _IncludeDocumentMetadataChanges { includeDocumentMetadataChanges: boolean; } interface _IncludeQueryMetadataChanges { includeQueryMetadataChanges: boolean; } type QueryListenOptions = _IncludeDocumentMetadataChanges | _IncludeQueryMetadataChanges | (_IncludeDocumentMetadataChanges & _IncludeQueryMetadataChanges); type ObserverOnNext = (querySnapshot: QuerySnapshot) => void; type ObserverOnError = (err: object) => void; interface Observer { next: ObserverOnNext; error?: ObserverOnError; } } interface QuerySnapshot { readonly docChanges: DocumentChange[]; readonly docs: DocumentSnapshot[]; readonly empty: boolean; readonly metadata: Types.SnapshotMetadata; readonly query: Query; readonly size: number; forEach(callback: (snapshot: DocumentSnapshot) => any): void; } namespace QuerySnapshot { interface NativeData { changes: Types.NativeDocumentChange[]; documents: Types.NativeDocumentSnapshot[]; metadata: Types.SnapshotMetadata; } } interface Settings { host?: string; persistence?: boolean; ssl?: boolean; timestampsInSnapshots?: boolean; } interface Transaction { delete(docRef: DocumentReference): WriteBatch; get(documentRef: DocumentReference): Promise; set(documentRef: DocumentReference, data: Object, options?: Types.WriteOptions): Transaction // multiple overrides for update() to allow strong-typed var_args update(docRef: DocumentReference, obj: object): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any, key5: Types.UpdateKey, val5: any): WriteBatch; } interface WriteBatch { commit(): Promise; delete(docRef: DocumentReference): WriteBatch; set(docRef: DocumentReference, data: object, options?: Types.WriteOptions): WriteBatch; // multiple overrides for update() to allow strong-typed var_args update(docRef: DocumentReference, obj: object): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any): WriteBatch; update(docRef: DocumentReference, key1: Types.UpdateKey, val1: any, key2: Types.UpdateKey, val2: any, key3: Types.UpdateKey, val3: any, key4: Types.UpdateKey, val4: any, key5: Types.UpdateKey, val5: any): WriteBatch; } namespace Types { interface NativeDocumentChange { document: NativeDocumentSnapshot; newIndex: number; oldIndex: number; type: string; } interface NativeDocumentSnapshot { data: { [key: string]: TypeMap; }; metadata: SnapshotMetadata; path: string; } interface SnapshotMetadata { fromCache: boolean; hasPendingWrites: boolean; } type QueryDirection = 'asc' | 'ASC' | 'desc' | 'DESC'; type QueryOperator = '=' | '==' | '>' | '>=' | '<' | '<='; interface TypeMap { type: 'array' | 'boolean' | 'date' | 'documentid' | 'fieldvalue' | 'geopoint' | 'null' | 'number' | 'object' | 'reference' | 'string'; value: any; } /** The key in update() function for DocumentReference and WriteBatch. */ type UpdateKey = string | FieldPath interface WriteOptions { merge?: boolean; } } } } }