export namespace firebase {
	/**
	 * The allowed values for LoginOptions.type.
	 */
	export enum LoginType {
		/**
		 * No further data is required.
		 */
		ANONYMOUS,
		/**
		 * This requires you to pass in the 'passwordOptions' as well.
		 */
		PASSWORD,
		/**
		 * This requires you to add the 'phoneOptions' as well.
		 */
		PHONE,
		/**
		 * This requires you to pass either an authentication token generated by your backend server
		 * or the tokenProviderFn function that returns a promise to provide the token (see 'customOptions').
		 * See: https://firebase.google.com/docs/auth/server
		 */
		CUSTOM,
		/**
		 * This requires you to setup Facebook Auth in the Firebase console,
		 * as well as uncommenting the SDK includes in include.gradle (Android) and Podfile (iOS).
		 * You can pass in an optional 'facebookOptions' object to override the default scopes.
		 */
		FACEBOOK,
		/**
		 * This requires you to setup Google Sign In in the Firebase console,
		 * as well as uncommenting the SDK includes in include.gradle (Android) and Podfile (iOS).
		 * You can pass in an optional 'googleOptions' object to set a 'hostedDomain'.
		 */
		GOOGLE,
		/**
		 * This requires you to pass in the 'emailLinkOptions' as well.
		 * Note that 'Firebase Dynamic Links' must be enabled for this login type to work.
		 */
		EMAIL_LINK,
		/**
		 * Apple
		 */
		APPLE,
	}

	export enum LogComplexEventTypeParameter {
		STRING,
		INT,
		FLOAT,
		DOUBLE,
		LONG,
		ARRAY,
		BOOLEAN,
	}

	/**
	 * The allowed values for QueryOptions.orderBy.type.
	 */
	export enum QueryOrderByType {
		KEY,
		VALUE,
		CHILD,
		PRIORITY,
	}

	/**
	 * The allowed values for QueryOptions.range.type.
	 */
	export enum QueryRangeType {
		START_AT,
		END_AT,
		EQUAL_TO,
	}

	/**
	 * The allowed values for QueryOptions.limit.type.
	 */
	export enum QueryLimitType {
		FIRST,
		LAST,
	}

	export enum ServerValue {
		/**
		 * When for instance using setValue you can set a timestamp property to this placeholder value.
		 * Example:
		 *   updateTs: firebase.ServerValue.TIMESTAMP
		 */
		TIMESTAMP,
	}

	export interface MessagingOptions {
		/**
		 * For Messaging, either pass in this callback function here, or use addOnMessageReceivedCallback.
		 */
		onPushTokenReceivedCallback?: (token: string) => void;

		/**
		 * For Messaging, either pass in this callback function here, or use addOnPushTokenReceivedCallback.
		 */
		onMessageReceivedCallback?: (message: Message) => void;

		/**
		 * For Messaging (Push Notifications). Whether you want this plugin to automatically display the notifications or just notify the callback.
		 * Currently used on iOS only. Default true.
		 */
		showNotifications?: boolean;

		/**
		 * For Messaging (Push Notifications). Whether you want this plugin to always handle the notifications when the app is in foreground.
		 * Currently used on iOS only. Default false.
		 */
		showNotificationsWhenInForeground?: boolean;

		/**
		 * Automatically clear the badges on starting.
		 * Currently used on iOS only. Default true.
		 */
		autoClearBadge?: boolean;
	}

	/**
	 * The options object passed into the init function.
	 */
	export interface InitOptions extends MessagingOptions {
		/**
		 * Allow the app to send analytics data to Firebase.
		 * Can also be set later with analytics.setAnalyticsCollectionEnabled.
		 * Default true.
		 */
		analyticsCollectionEnabled?: boolean;

		/**
		 * Allow the app to collect Crashlytics data and send it to Firebase.
		 * Can also be set later with crashlytics.setCrashReportingEnabled.
		 * Only useful in case it was disabled in AndroidManfifest.xml and/or Info.plist,
		 * see https://firebase.google.com/docs/crashlytics/customize-crash-reports
		 */
		crashlyticsCollectionEnabled?: boolean;

		/**
		 * Allow disk persistence. Default true for Firestore, false for regular Firebase DB.
		 */
		persist?: boolean;

		/**
		 * Get notified when the user is logged in.
		 */
		onAuthStateChanged?: (data: AuthStateData) => void;

		/**
		 * Attempt to sign out before initializing, useful in case previous
		 * project token is cached which leads to following type of error:
		 *   "[FirebaseDatabase] Authentication failed: invalid_token ..."
		 * Default false.
		 */
		iOSEmulatorFlush?: boolean;

		/**
		 * For Firebase Storage you can pass in something like 'gs://n-plugin-test.appspot.com'
		 * here so we can cache it. Otherwise pass in the 'bucket' param when using Storage features.
		 * Can be found in the firebase console.
		 */
		storageBucket?: string;

		/**
		 * Get notified when a dynamic link was used to launch the app. Alternatively use addOnDynamicLinkReceivedCallback.
		 * TODO iOS seems to return an object; not a string
		 */
		onDynamicLinkCallback?: (data: DynamicLinkData) => void;
	}

	export interface QueryRangeOption {
		type: QueryRangeType;
		value: any;
	}

	/**
	 * The options object passed into the query function.
	 */
	export interface QueryOptions {
		/**
		 * How you'd like to sort the query result.
		 */
		orderBy: {
			type: QueryOrderByType;
			/**
			 * mandatory when type is QueryOrderByType.CHILD
			 */
			value?: string;
		};

		/**
		 * You can further restrict the returned results by specifying restrictions.
		 * Need more than one range restriction? Use 'ranges' instead.
		 */
		range?: QueryRangeOption;

		/**
		 * Same as 'range', but for a 'chain of ranges'.
		 * You can further restrict the returned results by specifying restrictions.
		 */
		ranges?: QueryRangeOption[];

		/**
		 * You can limit the number of returned rows if you want to.
		 */
		limit?: {
			type: QueryLimitType;
			value: number;
		};

		/**
		 * Set this to true if you don't want to listen for any future updates,
		 * but just want to retrieve the current value.
		 * You can also use this to check if certain data is in the database.
		 * Default false.
		 */
		singleEvent?: boolean;
	}

	export interface GetAuthTokenOptions {
		/**
		 * Default false.
		 */
		forceRefresh?: boolean;
	}

	export interface IdTokenResult {
		token: string;
		claims: { [key: string]: any };
		signInProvider: string;
		expirationTime: number;
		issuedAtTime: number;
		authTime: number;
	}

	export interface Provider {
		id: string;
		token?: string;
	}

	export interface FirebasePasswordLoginOptions {
		email: string;
		password: string;
	}

	export interface FirebaseEmailLinkActionCodeSettings {
		url: string;
		iOS?: {
			bundleId: string;
		};
		android?: {
			packageName: string;
			installApp?: false;
			minimumVersion?: string;
		};
	}

	export interface FirebaseEmailLinkLoginOptions extends FirebaseEmailLinkActionCodeSettings {
		email: string;
	}

	export interface FirebasePhoneLoginOptions {
		phoneNumber: string;
		/**
		 * The message show to the user that prompts him to enter the received verification code.
		 * Default: "Verification code".
		 */
		verificationPrompt?: string;
		android?: {
			/**
			 * The maximum amount of time you are willing to wait for SMS auto-retrieval to be completed by the library. Maximum allowed value is 2 minutes. Use 0 to disable SMS-auto-retrieval. If you specified a positive value less than 30 seconds, library will default to 30 seconds.
			 * Default: 60 (seconds)
			 * See: https://firebase.google.com/docs/reference/android/com/google/firebase/auth/PhoneAuthProvider
			 */
			timeout: number;
		};
	}

	export interface FirebaseGoogleLoginOptions {
		hostedDomain?: string;
		/**
		 * You can add scopes like "https://www.googleapis.com/auth/contacts.readonly" and "https://www.googleapis.com/auth/user.birthday.read"
		 *
		 * Default: ["profile", "email"]
		 */
		scopes?: Array<string>;
	}

	export interface FirebaseFacebookLoginOptions {
		/**
		 * Default: ["public_profile", "email"]
		 */
		scopes?: Array<string>;
	}

	export type AppleLoginScope = 'name' | 'email';

	export interface AppleLoginOptions {
		/**
		 * Default: ["name", "email"]
		 */
		scopes?: Array<AppleLoginScope>;
		/**
		 * Android only.
		 * Supported locales: https://developer.apple.com/documentation/signinwithapplejs/incorporating_sign_in_with_apple_into_other_platforms#3332112
		 * Default: "en".
		 */
		locale?: string;
	}

	export interface FirebaseCustomLoginOptions {
		/**
		 * The JSON Web Token (JWT) to use for authentication.
		 * Either specify this, or 'tokenProviderFn'.
		 * See: https://firebase.google.com/docs/auth/server
		 */
		token?: string;
		/**
		 * A function that returns a promise with the  JSON Web Token (JWT) to use for authentication.
		 * Either specify this, or 'token'.
		 * See: https://firebase.google.com/docs/auth/server
		 */
		tokenProviderFn?: () => Promise<String>;
	}

	export interface LoginIOSOptions {
		controller?: any;
	}

	/**
	 * The options object passed into the login function.
	 */
	export interface LoginOptions {
		type: LoginType;
		passwordOptions?: FirebasePasswordLoginOptions;
		emailLinkOptions?: FirebaseEmailLinkLoginOptions;
		phoneOptions?: FirebasePhoneLoginOptions;
		googleOptions?: FirebaseGoogleLoginOptions;
		facebookOptions?: FirebaseFacebookLoginOptions;
		appleOptions?: AppleLoginOptions;
		customOptions?: FirebaseCustomLoginOptions;
		ios?: LoginIOSOptions;

		/**
		 * @deprecated Please use the 'passwordOptions?: FirebasePasswordLoginOptions' object instead.
		 */
		email?: string;
		/**
		 * @deprecated Please use the 'passwordOptions?: FirebasePasswordLoginOptions' object instead.
		 */
		password?: string;
		/**
		 * @deprecated Please use the 'customOptions?: FirebaseCustomLoginOptions' object instead.
		 */
		token?: string;
		/**
		 * @deprecated Please use the 'customOptions?: FirebaseCustomLoginOptions' object instead.
		 */
		tokenProviderFn?: () => Promise<String>;
		/**
		 * @deprecated Please use the 'facebookOptions?: FirebaseFacebookLoginOptions' object instead.
		 */
		scope?: string[];
	}

	export interface ReauthenticateOptions {
		type: LoginType;
		passwordOptions?: FirebasePasswordLoginOptions;
		/**
		 * @deprecated Please use the 'passwordOptions?: FirebasePasswordLoginOptions' object instead.
		 */
		email?: string;
		/**
		 * @deprecated Please use the 'passwordOptions?: FirebasePasswordLoginOptions' object instead.
		 */
		password?: string;
	}

	type ActionCodeSettings = {
		url: string;
		handleCodeInApp?: boolean;
		android?: {
			installApp?: boolean;
			minimumVersion?: string;
			packageName: string;
		};
		iOS?: {
			bundleId: string;
			dynamicLinkDomain?: string;
		};
	};

	/**
	 * The returned object from the login function.
	 */
	export interface User {
		uid: string;
		email?: string;
		emailVerified: boolean;
		displayName?: string;
		phoneNumber?: string;
		anonymous: boolean;
		isAnonymous: boolean; // This is used by the web API
		providers: Array<Provider>;
		photoURL?: string;
		metadata: UserMetadata;
		additionalUserInfo?: AdditionalUserInfo;

		/** iOS only */
		refreshToken?: string;

		getIdToken(forceRefresh?: boolean): Promise<string>;

		getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;

		sendEmailVerification(actionCodeSettings?: ActionCodeSettings): Promise<void>;
	}

	/**
	 * The metadata of the user
	 */
	export interface UserMetadata {
		creationTimestamp: Date;
		lastSignInTimestamp: Date;
	}

	/**
	 * Contains additional user information
	 */
	export interface AdditionalUserInfo {
		profile: Map<string, any>;
		providerId: string;
		username: string;
		isNewUser: boolean;
	}

	/**
	 * The returned object from the push function.
	 */
	export interface PushResult {
		key: string;
	}

	/**
	 * The returned object from the addEventListener functions.
	 */
	export interface AddEventListenerResult {
		path: string;
		listeners: Array<any>;
	}

	/**
	 * The options object passed into the createUser function.
	 */
	export interface CreateUserOptions {
		email: string;
		password: string;
	}

	/**
	 * The options object passed into the updateProfile function.
	 */
	export interface UpdateProfileOptions {
		displayName?: string;
		photoURL?: string;
	}

	/**
	 * The returned object in the callback handlers
	 * of the addChildEventListener and addValueEventListener functions.
	 */
	export interface FBData {
		type: string;
		key: string;
		value: any;
	}

	export interface FBDataSingleEvent extends FBData {
		children?: Array<any>;
	}

	export interface FBErrorData {
		error: string;
	}

	export interface AuthStateData {
		loggedIn?: boolean;
		user?: User;
	}

	export interface AuthStateChangeListener {
		onAuthStateChanged: (data: AuthStateData) => void;
		thisArg?: any;
	}

	export interface RemoteConfigProperty {
		key: string;
		default: any;
	}

	export interface GetRemoteConfigOptions {
		/**
		 * Fetch new results from the server more often.
		 * Default false.
		 */
		developerMode?: boolean;
		/**
		 * The number of seconds before retrieving fresh state from the server.
		 * Default 12 hours.
		 */
		cacheExpirationSeconds?: number;
		/**
		 * The configuration properties to retrieve for your app. Specify as:
		 *  properties: [{
		 *    key: "holiday_promo_enabled",
		 *    default: false
		 *  }, ..]
		 */
		properties: Array<RemoteConfigProperty>;
	}

	/**
	 * The returned object from the getRemoteConfig function.
	 */
	export interface GetRemoteConfigResult {
		/**
		 * The date the data was last refreshed from the server.
		 * Should honor the 'cacheExpirationSeconds' you passed in previously.
		 */
		lastFetch: Date;
		/**
		 * The result may be throttled when retrieved from the server.
		 * Even when the cache has expired. And it's just FYI really.
		 */
		throttled: boolean;
		/**
		 * A JS Object with properties and values.
		 * If you previously requested keys ["foo", "is_enabled"] then this will be like:
		 *   properties: {
		 *     foo: "bar",
		 *     is_enabled: true
		 *   }
		 */
		properties: Object;
	}

	export interface DynamicLinkData {
		url: string;
		minimumAppVersion: string;
	}

	/**
	 * The returned object in the callback handler of the addOnMessageReceivedCallback function.
	 *
	 * Note that any custom data you send from your server will be available as
	 * key/value properties on the Message object as well.
	 */
	export interface Message {
		/**
		 * Indicated whether or not the notification was received while the app was in the foreground.
		 */
		foreground: boolean;
		/**
		 * The main text shown in the notificiation.
		 * Not available on Android when the notification was received in the background.
		 */
		body?: string;
		/**
		 * Optional title, shown above the body in the notification.
		 * Not available on Android when the notification was received in the background.
		 */
		title?: string;
		/**
		 * Any other data you may have added to the notification.
		 */
		data: any;
		/**
		 * Indicates whether or not the notification was tapped.
		 * iOS only.
		 */
		notificationTapped?: boolean;
	}

	export function init(options?: InitOptions): Promise<any>;

	// Database
	export interface OnDisconnect {
		cancel(): Promise<any>;

		remove(): Promise<any>;

		set(value: any): Promise<any>;

		setWithPriority(value: any, priority: number | string): Promise<any>;

		update(values: Object): Promise<any>;
	}

	export interface DataSnapshot {
		key: string;
		ref: any; // TODO: Type it so that it returns a databaseReference.
		child(path: string): DataSnapshot;

		exists(): boolean;

		forEach(action: (snapshot: DataSnapshot) => any): boolean;

		getPriority(): string | number | null;

		hasChild(path: string): boolean;

		hasChildren(): boolean;

		numChildren(): number;

		toJSON(): Object;

		val(): any;
	}

	export interface FirebaseQueryResult {
		type: string;
		key: string;
		value: any;
	}

	export type Unsubscribe = () => void;

	export namespace dynamicLinks {
		export enum MATCH_CONFIDENCE {
			WEAK,
			STRONG,
		}

		export interface DynamicLinkCallbackData {
			url: string;
			matchConfidence?: MATCH_CONFIDENCE;
			minimumAppVersion?: string;
		}
	}
	// Auth
	export function login(options: LoginOptions): Promise<User>;

	export function reauthenticate(options: ReauthenticateOptions): Promise<User>;

	export function reloadUser(): Promise<void>;

	export function getAuthToken(option: GetAuthTokenOptions): Promise<IdTokenResult>;

	export function logout(): Promise<any>;

	export function unlink(providerId: string): Promise<User>;

	export function fetchSignInMethodsForEmail(email: string): Promise<Array<string>>;

	export function sendEmailVerification(actionCodeSettings?: ActionCodeSettings): Promise<any>;

	export function createUser(options: CreateUserOptions): Promise<User>;

	export function deleteUser(): Promise<any>;

	export function updateProfile(options: UpdateProfileOptions): Promise<any>;

	export function sendPasswordResetEmail(email: string): Promise<void>;

	export function updateEmail(newEmail: string): Promise<void>;

	export function updatePassword(newPassword: string): Promise<void>;

	export function addAuthStateListener(listener: AuthStateChangeListener): boolean;

	export function removeAuthStateListener(listener: AuthStateChangeListener): boolean;

	export function hasAuthStateListener(listener: AuthStateChangeListener): boolean;

	export function getCurrentUser(): Promise<User>;

	// Messaging
	export function addOnMessageReceivedCallback(onMessageReceived: (data: Message) => void): Promise<any>;

	export function addOnPushTokenReceivedCallback(onPushTokenReceived: (data: string) => void): Promise<any>;

	export function registerForInteractivePush(model: any): void;

	export function getCurrentPushToken(): Promise<string>;

	export function registerForPushNotifications(options?: MessagingOptions): Promise<void>;

	export function unregisterForPushNotifications(): Promise<void>;

	export function subscribeToTopic(topicName): Promise<any>;

	export function unsubscribeFromTopic(topicName): Promise<any>;

	export function areNotificationsEnabled(): boolean;

	// dynamic links
	export function addOnDynamicLinkReceivedCallback(onDynamicLinkReceived: (callBackData: dynamicLinks.DynamicLinkCallbackData) => void): Promise<any>;

	// remote config
	export function getRemoteConfig(options: GetRemoteConfigOptions): Promise<GetRemoteConfigResult>;

	export function transaction(path: string, transactionUpdate: (a: any) => any, onComplete?: (error: Error | null, committed: boolean, dataSnapshot: DataSnapshot) => any): Promise<any>;

	export function push(path: string, value: any): Promise<PushResult>;

	export function getValue(path: string): Promise<any>;

	export function setValue(path: string, value: any): Promise<any>;

	export function update(path: string, value: any): Promise<any>;

	export function remove(path: string): Promise<any>;

	export function query(onValueEvent: (data: FBData | FBErrorData) => void, path: string, options: QueryOptions): Promise<any>;

	export function addChildEventListener(onChildEvent: (data: FBData) => void, path: string): Promise<AddEventListenerResult>;

	export function addValueEventListener(onValueEvent: (data: FBData) => void, path: string): Promise<AddEventListenerResult>;

	export function removeEventListeners(listeners: Array<any>, path: string): Promise<any>;

	export function onDisconnect(path: string): OnDisconnect;

	export function enableLogging(logger?: boolean | ((a: string) => any), persistent?: boolean);

	/**
	 * Tells the client to keep its local cache in sync with the server automatically.
	 */
	export function keepInSync(path: string, switchOn: boolean): Promise<any>;
}

export namespace firestore {
	export type DocumentData = { [field: string]: any };
	export type WhereFilterOp = '<' | '<=' | '==' | '>=' | '>' | 'in' | 'array-contains' | 'array-contains-any';
	export type OrderByDirection = 'desc' | 'asc';

	export interface GeoPoint {
		longitude: number;
		latitude: number;
	}

	export function GeoPoint(latitude: number, longitude: number): GeoPoint;

	export interface Settings {
		/** The hostname to connect to. */
		host?: string;
		/** Whether to use SSL when connecting. */
		ssl?: boolean;

		/**
		 * Specifies whether to use `Timestamp` objects for timestamp fields in
		 * `DocumentSnapshot`s. This is enabled by default and should not be
		 * disabled.
		 *
		 * Previously, Firestore returned timestamp fields as `Date` but `Date`
		 * only supports millisecond precision, which leads to truncation and
		 * causes unexpected behavior when using a timestamp from a snapshot as a
		 * part of a subsequent query.
		 *
		 * So now Firestore returns `Timestamp` values instead of `Date`, avoiding
		 * this kind of problem.
		 *
		 * To opt into the old behavior of returning `Date` objects, you can
		 * temporarily set `timestampsInSnapshots` to false.
		 *
		 * @deprecated This setting will be removed in a future release. You should
		 * update your code to expect `Timestamp` objects and stop using the
		 * `timestampsInSnapshots` setting.
		 */
		timestampsInSnapshots?: boolean;

		/**
		 * An approximate cache size threshold for the on-disk data. If the cache grows beyond this
		 * size, Firestore will start removing data that hasn't been recently used. The size is not a
		 * guarantee that the cache will stay below that size, only that if the cache exceeds the given
		 * size, cleanup will be attempted.
		 *
		 * The default value is 40 MB. The threshold must be set to at least 1 MB, and can be set to
		 * CACHE_SIZE_UNLIMITED to disable garbage collection.
		 */
		cacheSizeBytes?: number;
	}

	/**
	 * Specifies custom settings to be used to configure the `Firestore`
	 * instance. Must be set before invoking any other methods.
	 *
	 * @param settings The settings to use.
	 */
	export function settings(settings: Settings): void;

	export interface SetOptions {
		merge?: boolean;
	}

	export interface SnapshotMetadata {
		/**
		 * True if the snapshot contains the result of local writes (e.g. set() or
		 * update() calls) that have not yet been committed to the backend.
		 * If your listener has opted into metadata updates (via
		 * `DocumentListenOptions` or `QueryListenOptions`) you will receive another
		 * snapshot with `hasPendingWrites` equal to false once the writes have been
		 * committed to the backend.
		 */
		readonly hasPendingWrites: boolean;

		/**
		 * True if the snapshot was created from cached data rather than
		 * guaranteed up-to-date server data. If your listener has opted into
		 * metadata updates (via `DocumentListenOptions` or `QueryListenOptions`)
		 * you will receive another snapshot with `fromCache` equal to false once
		 * the client has received up-to-date data from the backend.
		 */
		readonly fromCache: boolean;
	}

	export interface DocumentSnapshot {
		ios?: any;
		/* FIRDocumentSnapshot */
		android?: any;
		/* com.google.firebase.firestore.DocumentSnapshot */
		id: string;
		exists: boolean;
		ref: DocumentReference;

		/**
		 * Included when includeMetadataChanges is true.
		 */
		readonly metadata?: SnapshotMetadata;

		data(): DocumentData;
	}

	export interface SnapshotListenOptions {
		/**
		 * Include a change even if only the metadata of the query or of a document changed.
		 * Default false.
		 */
		readonly includeMetadataChanges?: boolean;
	}

	export interface GetOptions {
		/**
		 * Describes whether we should get from server or cache.
		 *
		 * Setting to 'default' (or not setting at all), causes Firestore to try to
		 * retrieve an up-to-date (server-retrieved) snapshot, but fall back to
		 * returning cached data if the server can't be reached.
		 *
		 * Setting to 'server' causes Firestore to avoid the cache, generating an
		 * error if the server cannot be reached. Note that the cache will still be
		 * updated if the server request succeeds. Also note that latency-compensation
		 * still takes effect, so any pending write operations will be visible in the
		 * returned data (merged into the server-provided data).
		 *
		 * Setting to 'cache' causes Firestore to immediately return a value from the
		 * cache, ignoring the server completely (implying that the returned value
		 * may be stale with respect to the value on the server.) If there is no data
		 * in the cache to satisfy the `get()` call, `DocumentReference.get()` will
		 * return an error and `QuerySnapshot.get()` will return an empty
		 * `QuerySnapshot` with no documents.
		 */
		source?: 'default' | 'server' | 'cache';
	}

	export interface DocumentReference {
		readonly discriminator: 'docRef';

		readonly id: string;

		/**
		 * A reference to the Collection to which this DocumentReference belongs.
		 */
		readonly parent: CollectionReference;

		readonly path: string;

		readonly firestore: any;

		collection: (collectionPath: string) => CollectionReference;

		set: (document: any, options?: SetOptions) => Promise<void>;

		get: (options?: GetOptions) => Promise<DocumentSnapshot>;

		update: (document: any) => Promise<void>;

		delete: () => Promise<void>;

		onSnapshot(optionsOrCallback: SnapshotListenOptions | ((snapshot: DocumentSnapshot) => void), callbackOrOnError?: (snapshot: DocumentSnapshot | Error) => void, onError?: (error: Error) => void): () => void;

		android?: any;

		ios?: any;
	}

	export interface Query {
		readonly firestore: any;

		get(options?: GetOptions): Promise<QuerySnapshot>;

		where(fieldPath: string, opStr: WhereFilterOp, value: any): Query;

		orderBy(fieldPath: string, directionStr: firestore.OrderByDirection): Query;

		limit(limit: number): Query;

		onSnapshot(optionsOrCallback: SnapshotListenOptions | ((snapshot: QuerySnapshot) => void), callbackOrOnError?: (snapshotOrError: QuerySnapshot | Error) => void, onError?: (error: Error) => void): () => void;

		startAt(snapshot: DocumentSnapshot): Query;

		startAt(...fieldValues: any[]): Query;

		startAfter(snapshot: DocumentSnapshot): Query;

		startAfter(...fieldValues: any[]): Query;

		endAt(snapshot: DocumentSnapshot): Query;

		endAt(...fieldValues: any[]): Query;

		endBefore(snapshot: DocumentSnapshot): Query;

		endBefore(...fieldValues: any[]): Query;
	}

	export interface CollectionGroup {
		where(fieldPath: string, opStr: WhereFilterOp, value: any): Query;
	}

	export interface CollectionReference extends Query {
		readonly id: string;

		/**
		 * A reference to the containing Document if this is a subcollection, else null.
		 */
		readonly parent: DocumentReference | null;

		doc(documentPath?: string): DocumentReference;

		add(data: DocumentData): Promise<DocumentReference>;
	}

	export type UpdateData = { [fieldPath: string]: any };

	export class FieldPath {
		/**
		 * Creates a FieldPath from the provided field names. If more than one field
		 * name is provided, the path will point to a nested field in a document.
		 *
		 * @param fieldNames A list of field names.
		 */
		constructor(...fieldNames: string[]);

		/**
		 * Returns a special sentinel FieldPath to refer to the ID of a document.
		 * It can be used in queries to sort or filter by the document ID.
		 */
		static documentId(): FieldPath;
	}

	export interface Transaction {
		get(documentRef: DocumentReference): DocumentSnapshot;

		set(documentRef: DocumentReference, data: DocumentData, options?: SetOptions): Transaction;

		update(documentRef: DocumentReference, data: UpdateData): Transaction;

		update(documentRef: DocumentReference, field: string | FieldPath, value: any, ...moreFieldsAndValues: any[]): Transaction;

		delete(documentRef: DocumentReference): Transaction;
	}

	export interface WriteBatch {
		set(documentRef: DocumentReference, data: DocumentData, options?: SetOptions): WriteBatch;

		update(documentRef: DocumentReference, data: UpdateData): WriteBatch;

		update(documentRef: DocumentReference, field: string | FieldPath, value: any, ...moreFieldsAndValues: any[]): WriteBatch;

		delete(documentRef: DocumentReference): WriteBatch;

		commit(): Promise<void>;
	}

	export type FieldValueType = 'ARRAY_UNION' | 'ARRAY_REMOVE' | 'INCREMENT';

	export class FieldValue {
		constructor(type: FieldValueType, value: any);

		static serverTimestamp: () => 'SERVER_TIMESTAMP';
		static delete: () => 'DELETE_FIELD';
		static arrayUnion: (...elements: any[]) => FieldValue;
		static arrayRemove: (...elements: any[]) => FieldValue;
		static increment: (n: number) => FieldValue;
	}

	export interface SnapshotListenOptions {
		readonly includeMetadataChanges?: boolean;
	}

	export interface SnapshotOptions {
		/**
		 * If set, controls the return value for server timestamps that have not yet
		 * been set to their final value.
		 *
		 * By specifying 'estimate', pending server timestamps return an estimate
		 * based on the local clock. This estimate will differ from the final value
		 * and cause these values to change once the server result becomes available.
		 *
		 * By specifying 'previous', pending timestamps will be ignored and return
		 * their previous value instead.
		 *
		 * If omitted or set to 'none', `null` will be returned by default until the
		 * server value becomes available.
		 */
		readonly serverTimestamps?: 'estimate' | 'previous' | 'none';
	}

	export interface QueryDocumentSnapshot extends firestore.DocumentSnapshot {
		/**
		 * Retrieves all fields in the document as an Object.
		 *
		 * By default, `FieldValue.serverTimestamp()` values that have not yet been
		 * set to their final value will be returned as `null`. You can override
		 * this by passing an options object.
		 *
		 * @override
		 * @param options An options object to configure how data is retrieved from
		 * the snapshot (e.g. the desired behavior for server timestamps that have
		 * not yet been set to their final value).
		 * @return An Object containing all fields in the document.
		 */
		data(options?: SnapshotOptions): DocumentData;
	}

	export type DocumentChangeType = 'added' | 'removed' | 'modified';

	export interface DocumentChange {
		readonly type: DocumentChangeType;

		/** The document affected by this change. */
		readonly doc: QueryDocumentSnapshot;

		/**
		 * The index of the changed document in the result set immediately prior to
		 * this DocumentChange (i.e. supposing that all prior DocumentChange objects
		 * have been applied). Is -1 for 'added' events.
		 */
		readonly oldIndex: number;

		/**
		 * The index of the changed document in the result set immediately after
		 * this DocumentChange (i.e. supposing that all prior DocumentChange
		 * objects and the current DocumentChange object have been applied).
		 * Is -1 for 'removed' events.
		 */
		readonly newIndex: number;
	}

	export interface QuerySnapshot {
		docSnapshots: firestore.DocumentSnapshot[];
		docs: firestore.QueryDocumentSnapshot[];

		/**
		 * Included when includeMetadataChanges is true.
		 */
		readonly metadata: SnapshotMetadata;

		docChanges(options?: SnapshotListenOptions): DocumentChange[];

		forEach(callback: (result: DocumentSnapshot) => void, thisArg?: any): void;
	}

	function collection(collectionPath: string): CollectionReference;

	function collectionGroup(id: string): CollectionGroup;

	function doc(collectionPath: string, documentPath?: string): DocumentReference;

	function docRef(documentPath: string): DocumentReference;

	function add(collectionPath: string, documentData: any): Promise<DocumentReference>;

	function set(collectionPath: string, documentPath: string, document: any, options?: any): Promise<void>;

	function getCollection(collectionPath: string, options?: GetOptions): Promise<QuerySnapshot>;

	function getDocument(collectionPath: string, documentPath: string, options?: GetOptions): Promise<DocumentSnapshot>;

	function update(collectionPath: string, documentPath: string, document: any): Promise<void>;

	function runTransaction(updateFunction: (transaction: firestore.Transaction) => Promise<any>): Promise<void>;

	function batch(): firestore.WriteBatch;

	function clearPersistence(): Promise<void>;
}

export namespace functions {
	export type SupportedRegions = 'us-central1' | 'us-east1' | 'us-east4' | 'europe-west1' | 'europe-west2' | 'asia-east2' | 'asia-northeast1';

	export type HttpsCallable<I, O> = (callableData: I) => Promise<O>;

	export function httpsCallable<I, O>(callableFunctionName: string, region?: SupportedRegions): HttpsCallable<I, O>;

	export function useFunctionsEmulator(origin: string): void;
}