@dereekb/dbx-firebase 2.1.0 → 3.0.0

package/lib/auth/login/login.apple.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginAppleComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "apple";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginAppleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginAppleComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.button.component.d.ts

@@ -0,0 +1,51 @@
+import { OnInit } from "@angular/core";
+import { HandleActionFunction } from "@dereekb/dbx-core";
+import { Maybe } from "@dereekb/util";
+import { DbxFirebaseAuthService } from "../service/firebase.auth.service";
+import { FirebaseLoginMethodType } from "./login";
+import { DbxFirebaseAuthLoginService } from "./login.service";
+import { DbxFirebaseLoginContext } from './login.context';
+import * as i0 from "@angular/core";
+export interface DbxFirebaseLoginButtonConfig {
+    text: string;
+    iconUrl?: string;
+    icon?: string;
+    buttonColor?: string;
+    buttonTextColor?: string;
+    handleLogin: () => Promise<void>;
+}
+/**
+ * Login button and action.
+ */
+export declare class DbxFirebaseLoginButtonComponent {
+    config: Maybe<DbxFirebaseLoginButtonConfig>;
+    get iconUrl(): string | undefined;
+    get icon(): string | undefined;
+    get text(): string | undefined;
+    get buttonColor(): string;
+    get buttonTextColor(): string | undefined;
+    readonly handleAction: HandleActionFunction;
+    onActionSuccess: (value: any) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginButtonComponent, "dbx-firebase-login-button", never, { "config": "config"; }, {}, never, never>;
+}
+export declare class DbxFirebaseLoginButtonContainerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginButtonContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginButtonContainerComponent, "dbx-firebase-login-button-container", never, {}, {}, never, ["*"]>;
+}
+export declare const DEFAULT_CONFIGURED_DBX_FIREBASE_LOGIN_BUTTON_TEMPLATE = "\n  <dbx-firebase-login-button-container>\n    <dbx-firebase-login-button [config]=\"config\"></dbx-firebase-login-button>\n  </dbx-firebase-login-button-container>\n";
+export declare abstract class AbstractConfiguredDbxFirebaseLoginButtonDirective implements OnInit {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    readonly dbxFirebaseLoginContext: DbxFirebaseLoginContext;
+    private _config;
+    abstract readonly loginProvider: FirebaseLoginMethodType;
+    constructor(dbxFirebaseAuthService: DbxFirebaseAuthService, dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService, dbxFirebaseLoginContext: DbxFirebaseLoginContext);
+    ngOnInit(): void;
+    abstract handleLogin(): Promise<any>;
+    get providerConfig(): Maybe<import("./login.service").DbxFirebaseAuthLoginProvider<any>>;
+    get assetConfig(): import("./login.service").DbxFirebaseAuthLoginProviderAssets;
+    get config(): DbxFirebaseLoginButtonConfig;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractConfiguredDbxFirebaseLoginButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractConfiguredDbxFirebaseLoginButtonDirective, never, never, {}, {}, never>;
+}

package/lib/auth/login/login.component.d.ts

@@ -0,0 +1,14 @@
+import { DbxFirebaseLoginMode, FirebaseLoginMethodCategory, FirebaseLoginMethodType } from './login';
+import { ArrayOrValue, Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Pre-configured login component that displays all configured login types.
+ */
+export declare class DbxFirebaseLoginComponent {
+    loginMode: DbxFirebaseLoginMode;
+    providerTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>;
+    omitProviderTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>;
+    providerCategories: Maybe<ArrayOrValue<FirebaseLoginMethodCategory>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginComponent, "dbx-firebase-login", never, { "loginMode": "loginMode"; "providerTypes": "providerTypes"; "omitProviderTypes": "omitProviderTypes"; "providerCategories": "providerCategories"; }, {}, never, never>;
+}

package/lib/auth/login/login.context.back.component.d.ts

@@ -0,0 +1,9 @@
+import { ClickableAnchor } from '@dereekb/dbx-core';
+import { EventEmitter } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginContextBackButtonComponent {
+    readonly onCancel: EventEmitter<void>;
+    readonly anchor: ClickableAnchor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginContextBackButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginContextBackButtonComponent, "dbx-firebase-login-context-back-button", never, {}, { "onCancel": "onCancel"; }, never, never>;
+}

package/lib/auth/login/login.context.d.ts

@@ -0,0 +1,6 @@
+import { DbxInjectionContext } from "@dereekb/dbx-core";
+/**
+ * Injection token for a DbxInjectionContext for DbxFirebaseLoginContext.
+ */
+export declare abstract class DbxFirebaseLoginContext extends DbxInjectionContext {
+}

package/lib/auth/login/login.context.directive.d.ts

@@ -0,0 +1,10 @@
+import { AbstractForwardDbxInjectionContextDirective } from "@dereekb/dbx-core";
+import { DbxFirebaseLoginContext } from "./login.context";
+import * as i0 from "@angular/core";
+/**
+ * DbxFirebaseLoginContext implementation.
+ */
+export declare class DbxFirebaseLoginContextDirective extends AbstractForwardDbxInjectionContextDirective implements DbxFirebaseLoginContext {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFirebaseLoginContextDirective, "[dbxFirebaseLoginContext]", never, {}, {}, never>;
+}

package/lib/auth/login/login.d.ts

@@ -0,0 +1,7 @@
+export declare type FirebaseLoginMethodType = string;
+export declare type FirebaseLoginMethodCategory = string;
+export declare type KnownFirebaseLoginMethodType = 'email' | 'phone' | 'google' | 'facebook' | 'github' | 'twitter' | 'apple' | 'microsoft' | 'anonymous';
+export declare const DEFAULT_FIREBASE_LOGIN_METHOD_CATEGORY = "default";
+export declare const OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY = "oauth";
+export declare type KnownFirebaseLoginMethodCategory = typeof DEFAULT_FIREBASE_LOGIN_METHOD_CATEGORY | typeof OAUTH_FIREBASE_LOGIN_METHOD_CATEGORY;
+export declare type DbxFirebaseLoginMode = 'login' | 'register';

package/lib/auth/login/login.email.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginEmailComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "email";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginEmailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginEmailComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.email.content.component.d.ts

@@ -0,0 +1,39 @@
+import { DbxFirebaseEmailRecoveryFormValue } from './login.email.recovery.form.component';
+import { HandleActionFunction, ClickableAnchor } from '@dereekb/dbx-core';
+import { DbxFirebaseAuthService } from './../service/firebase.auth.service';
+import { EventEmitter, OnDestroy } from "@angular/core";
+import { DbxFirebaseLoginContext } from "./login.context";
+import { DbxFirebaseEmailFormValue, DbxFirebaseEmailFormConfig } from './login.email.form.component';
+import { DbxFirebaseLoginMode } from './login';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface DbxFirebaseLoginEmailContentComponentConfig extends DbxFirebaseEmailFormConfig {
+    loginMode: DbxFirebaseLoginMode;
+}
+export declare type DbxFirebaseLoginEmailContentMode = 'login' | 'recover' | 'recovering';
+export declare class DbxFirebaseLoginEmailContentComponent implements OnDestroy {
+    readonly dbxFirebaseAuthService: DbxFirebaseAuthService;
+    readonly config: DbxFirebaseLoginEmailContentComponentConfig;
+    readonly formConfig: DbxFirebaseEmailFormConfig;
+    emailFormValue: Maybe<DbxFirebaseEmailFormValue>;
+    recoveryFormValue: Maybe<DbxFirebaseEmailRecoveryFormValue>;
+    private _emailMode;
+    readonly emailMode$: import("rxjs").Observable<DbxFirebaseLoginEmailContentMode>;
+    readonly forgotAnchor: ClickableAnchor;
+    readonly doneOrCancelled: EventEmitter<boolean>;
+    constructor(dbxFirebaseAuthService: DbxFirebaseAuthService, config: DbxFirebaseLoginEmailContentComponentConfig);
+    ngOnDestroy(): void;
+    static openEmailLoginContext(dbxFirebaseLoginContext: DbxFirebaseLoginContext, config: DbxFirebaseLoginEmailContentComponentConfig): Promise<boolean>;
+    get loginMode(): DbxFirebaseLoginMode;
+    get isLoginMode(): boolean;
+    get isRegisterMode(): boolean;
+    get buttonText(): "Register" | "Log In";
+    readonly handleLoginAction: HandleActionFunction;
+    openRecovery(): void;
+    readonly handleRecoveryAction: HandleActionFunction;
+    onRecoveringSuccess(): void;
+    onCancel(): void;
+    onCancelReset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginEmailContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginEmailContentComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.email.form.component.d.ts

@@ -0,0 +1,21 @@
+import { OnDestroy } from "@angular/core";
+import { TextPasswordFieldConfig, AbstractAsyncFormlyFormDirective, DefaultUsernameLoginFieldsValue } from "@dereekb/dbx-form";
+import { Maybe } from "@dereekb/util";
+import { FormlyFieldConfig } from "@ngx-formly/core";
+import { Observable } from "rxjs";
+import { DbxFirebaseLoginMode } from "./login";
+import * as i0 from "@angular/core";
+export interface DbxFirebaseEmailFormValue extends DefaultUsernameLoginFieldsValue {
+}
+export interface DbxFirebaseEmailFormConfig {
+    loginMode: DbxFirebaseLoginMode;
+    passwordConfig?: TextPasswordFieldConfig;
+}
+export declare class DbxFirebaseEmailFormComponent extends AbstractAsyncFormlyFormDirective<DbxFirebaseEmailFormValue> implements OnDestroy {
+    private _config;
+    readonly fields$: Observable<Maybe<FormlyFieldConfig[]>>;
+    set config(config: DbxFirebaseEmailFormConfig);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmailFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseEmailFormComponent, "dbx-firebase-email-form", never, { "config": "config"; }, {}, never, never>;
+}

package/lib/auth/login/login.email.recovery.form.component.d.ts

@@ -0,0 +1,11 @@
+import { AbstractSyncFormlyFormDirective } from "@dereekb/dbx-form";
+import { FormlyFieldConfig } from "@ngx-formly/core";
+import * as i0 from "@angular/core";
+export interface DbxFirebaseEmailRecoveryFormValue {
+    email: string;
+}
+export declare class DbxFirebaseEmailRecoveryFormComponent extends AbstractSyncFormlyFormDirective<DbxFirebaseEmailRecoveryFormValue> {
+    readonly fields: FormlyFieldConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmailRecoveryFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseEmailRecoveryFormComponent, "dbx-firebase-email-recovery-form", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.facebook.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginFacebookComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "facebook";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginFacebookComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginFacebookComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.github.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginGitHubComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "github";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginGitHubComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginGitHubComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.google.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginGoogleComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "google";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginGoogleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginGoogleComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.list.component.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { DbxFirebaseAuthLoginProvider, DbxFirebaseAuthLoginService } from './login.service';
+import { DbxFirebaseLoginMode, FirebaseLoginMethodType, FirebaseLoginMethodCategory } from './login';
+import { OnDestroy } from "@angular/core";
+import { Maybe, ArrayOrValue } from '@dereekb/util';
+import { DbxInjectionComponentConfig } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Pre-configured login component that displays all configured login types.
+ */
+export declare class DbxFirebaseLoginListComponent implements OnDestroy {
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    private _loginMode;
+    private _inputProviderCategories;
+    private _omitProviderTypes;
+    private _inputProviderTypes;
+    readonly providerTypes$: Observable<string[]>;
+    readonly providers$: Observable<DbxFirebaseAuthLoginProvider<any>[]>;
+    readonly providerInjectionConfigs$: Observable<DbxInjectionComponentConfig[]>;
+    constructor(dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService);
+    ngOnDestroy(): void;
+    set loginMode(loginMode: DbxFirebaseLoginMode);
+    set providerTypes(providerTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>);
+    set omitProviderTypes(providerTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>);
+    set providerCategories(providerCategories: Maybe<ArrayOrValue<FirebaseLoginMethodCategory>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginListComponent, "dbx-firebase-login-list", never, { "loginMode": "loginMode"; "providerTypes": "providerTypes"; "omitProviderTypes": "omitProviderTypes"; "providerCategories": "providerCategories"; }, {}, never, never>;
+}

package/lib/auth/login/login.microsoft.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginMicrosoftComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "microsoft";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginMicrosoftComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginMicrosoftComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.password.d.ts

@@ -0,0 +1,4 @@
+import { TextPasswordFieldPasswordParameters } from "@dereekb/dbx-form";
+export interface DbxFirebaseAuthLoginPasswordConfig extends TextPasswordFieldPasswordParameters {
+}
+export declare const DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG: DbxFirebaseAuthLoginPasswordConfig;

package/lib/auth/login/login.service.d.ts

@@ -0,0 +1,115 @@
+import { Maybe, ArrayOrValue } from "@dereekb/util";
+import { InjectionToken, Type } from "@angular/core";
+import { FirebaseLoginMethodCategory, FirebaseLoginMethodType, KnownFirebaseLoginMethodType } from "./login";
+import { DbxFirebaseAuthLoginPasswordConfig } from "./login.password";
+import * as i0 from "@angular/core";
+/**
+ * Default providers to inject.
+ */
+export declare const DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN: InjectionToken<unknown>;
+export declare const DEFAULT_FIREBASE_AUTH_LOGIN_TERMS_COMPONENT_CLASS_TOKEN: InjectionToken<unknown>;
+export declare const DEFAULT_FIREBASE_AUTH_LOGIN_PASSWORD_CONFIG_TOKEN: InjectionToken<unknown>;
+export interface DbxFirebaseAuthLoginProvider<D = any> {
+    /**
+     * Category for this login method.
+     */
+    readonly category?: FirebaseLoginMethodCategory;
+    /**
+     * Login method key for this type.
+     */
+    readonly loginMethodType: KnownFirebaseLoginMethodType | FirebaseLoginMethodType;
+    /**
+     * Login/Registration class to use.
+     */
+    readonly componentClass: Type<any>;
+    /**
+     * Custom registration type to use instead. If false, registration is not allowd for this type.
+     */
+    readonly registrationComponentClass?: Type<any> | false;
+    /**
+     * Custom data available to the components.
+     *
+     * Components are responsible for knowing the typing information of this data.
+     */
+    readonly componentData?: D;
+    /**
+     * Asset configuration for this type.
+     */
+    readonly assets: DbxFirebaseAuthLoginProviderAssets;
+}
+/**
+ * Asset configurations for a provider.
+ */
+export interface DbxFirebaseAuthLoginProviderAssets {
+    /**
+     * URL of the logo to use.
+     */
+    readonly logoUrl?: string;
+    /**
+     * Icon to use in place of the logo.
+     */
+    readonly loginIcon?: string;
+    /**
+     * Log in text to display next to the logo.
+     */
+    readonly loginText?: string;
+    /**
+     * Optional background color to apply.
+     */
+    readonly backgroundColor?: string;
+    /**
+     * Optional background color to apply.
+     */
+    readonly textColor?: string;
+}
+/**
+ * Service used for registering components used for logging in.
+ *
+ * Default providers can be configured by the DEFAULT_FIREBASE_AUTH_LOGIN_PROVIDERS_TOKEN injectable value.
+ */
+export declare class DbxFirebaseAuthLoginService {
+    readonly termsComponentClass: Type<any>;
+    private _enableAll;
+    private _passwordConfig;
+    private _providers;
+    private _assets;
+    private _enabled;
+    constructor(defaultProviders: DbxFirebaseAuthLoginProvider[], passwordConfig: DbxFirebaseAuthLoginPasswordConfig, termsComponentClass?: Type<any>);
+    /**
+     * Used to register a provider. If a provider is already registered, this will override it by default.
+     *
+     * @param provider
+     * @param override
+     */
+    register(provider: DbxFirebaseAuthLoginProvider, override?: boolean): boolean;
+    /**
+     * Updates the assets for a provider type.
+     *
+     * @param type
+     * @param assets
+     */
+    updateAssetsForProvider(type: FirebaseLoginMethodType, assets: Partial<DbxFirebaseAuthLoginProviderAssets>): void;
+    /**
+     * Enables all providers and any providers that will be registered.
+     */
+    setEnableAll(enableAll?: boolean): void;
+    clearEnabled(): void;
+    /**
+     * Enables all of the specified types.
+     *
+     * @param types
+     */
+    enable(types: ArrayOrValue<FirebaseLoginMethodType>): void;
+    disable(types: ArrayOrValue<FirebaseLoginMethodType>): void;
+    getRegisteredTypes(): FirebaseLoginMethodType[];
+    getEnabledTypes(): FirebaseLoginMethodType[];
+    getLoginProvider(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProvider>;
+    getLoginProviders(types: Iterable<FirebaseLoginMethodType>): DbxFirebaseAuthLoginProvider[];
+    getRegisterProvider(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProvider>;
+    getRegisterProviders(types: Iterable<FirebaseLoginMethodType>): DbxFirebaseAuthLoginProvider[];
+    getProviderAssets(type: FirebaseLoginMethodType): Maybe<DbxFirebaseAuthLoginProviderAssets>;
+    getPasswordConfig(): DbxFirebaseAuthLoginPasswordConfig;
+    setPasswordConfig(passwordConfig: DbxFirebaseAuthLoginPasswordConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAuthLoginService, [{ optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAuthLoginService>;
+}

package/lib/auth/login/login.terms.component.d.ts

@@ -0,0 +1,10 @@
+import { DbxInjectionComponentConfig } from '@dereekb/dbx-core';
+import { DbxFirebaseAuthLoginService } from "./login.service";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginTermsComponent {
+    readonly dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService;
+    readonly config: DbxInjectionComponentConfig;
+    constructor(dbxFirebaseAuthLoginService: DbxFirebaseAuthLoginService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTermsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTermsComponent, "dbx-firebase-login-terms", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.terms.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class DbxFirebaseLoginTermsConfig {
+    abstract readonly tosUrl: string;
+    abstract readonly privacyUrl: string;
+}

package/lib/auth/login/login.terms.simple.component.d.ts

@@ -0,0 +1,11 @@
+import { ClickableAnchor } from '@dereekb/dbx-core';
+import { DbxFirebaseLoginTermsConfig } from './login.terms';
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginTermsSimpleComponent {
+    readonly dbxFirebaseLoginTermsConfig: DbxFirebaseLoginTermsConfig;
+    readonly tosAnchor: ClickableAnchor;
+    readonly privacyAnchor: ClickableAnchor;
+    constructor(dbxFirebaseLoginTermsConfig: DbxFirebaseLoginTermsConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTermsSimpleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTermsSimpleComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/login.twitter.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseLoginTwitterComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "twitter";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseLoginTwitterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseLoginTwitterComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/login/register.component.d.ts

@@ -0,0 +1,13 @@
+import { FirebaseLoginMethodCategory, FirebaseLoginMethodType } from './login';
+import { ArrayOrValue, Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Pre-configured register component that displays all configured login types and their registration components.
+ */
+export declare class DbxFirebaseRegisterComponent {
+    providerTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>;
+    omitProviderTypes: Maybe<ArrayOrValue<FirebaseLoginMethodType>>;
+    providerCategories: Maybe<ArrayOrValue<FirebaseLoginMethodCategory>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseRegisterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseRegisterComponent, "dbx-firebase-register", never, { "providerTypes": "providerTypes"; "omitProviderTypes": "omitProviderTypes"; "providerCategories": "providerCategories"; }, {}, never, never>;
+}

package/lib/auth/login/register.email.component.d.ts

@@ -0,0 +1,8 @@
+import { AbstractConfiguredDbxFirebaseLoginButtonDirective } from "./login.button.component";
+import * as i0 from "@angular/core";
+export declare class DbxFirebaseRegisterEmailComponent extends AbstractConfiguredDbxFirebaseLoginButtonDirective {
+    readonly loginProvider = "email";
+    handleLogin(): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseRegisterEmailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxFirebaseRegisterEmailComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/auth/service/firebase.auth.rxjs.d.ts

@@ -0,0 +1,21 @@
+import { AuthUserState } from '@dereekb/dbx-core';
+import { IdTokenResult } from 'firebase/auth';
+import { Observable } from 'rxjs';
+import { DbxFirebaseAuthService } from "./firebase.auth.service";
+/**
+ * Derives a user state from the input firebase auth service.
+ *
+ * @param dbxFirebaseAuthService
+ * @param stateForLoggedInUser Optional function that returns an observable for the user's state if they are logged in and not an anonymous user.
+ * @returns
+ */
+export declare function authUserStateFromFirebaseAuthService(dbxFirebaseAuthService: DbxFirebaseAuthService, stateForLoggedInUser?: (dbxFirebaseAuthService: DbxFirebaseAuthService) => Observable<AuthUserState>): Observable<AuthUserState>;
+/**
+ * Convenience function to read a value from an IdTokenResult off of the current user.
+ *
+ * @param dbxFirebaseAuthService
+ * @param readBooleanFromIdToken
+ * @param defaultValue
+ * @returns
+ */
+export declare function readValueFromIdToken<T>(dbxFirebaseAuthService: DbxFirebaseAuthService, readBooleanFromIdToken: (idToken: IdTokenResult) => Observable<T>, defaultValue: T): Observable<T>;

package/lib/auth/service/firebase.auth.service.d.ts

@@ -0,0 +1,49 @@
+import { AuthUserState, DbxAuthService, AuthUserIdentifier } from "@dereekb/dbx-core";
+import { Auth, User, IdTokenResult, ParsedToken, AuthProvider, PopupRedirectResolver, UserCredential } from '@angular/fire/auth';
+import { Observable } from "rxjs";
+import { AuthRoleSet, Maybe } from "@dereekb/util";
+import { AuthUserInfo } from '../auth';
+import * as i0 from "@angular/core";
+export declare abstract class DbxFirebaseAuthServiceDelegate {
+    abstract authUserStateObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthUserState>;
+    abstract authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet>;
+    abstract isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean>;
+}
+export declare const DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE: DbxFirebaseAuthServiceDelegate;
+export declare class DbxFirebaseAuthService implements DbxAuthService {
+    readonly firebaseAuth: Auth;
+    private readonly _authState$;
+    readonly currentAuthUser$: Observable<Maybe<User>>;
+    readonly currentAuthUserInfo$: Observable<Maybe<AuthUserInfo>>;
+    readonly authUser$: Observable<User>;
+    readonly authUserInfo$: Observable<AuthUserInfo>;
+    readonly hasAuthUser$: Observable<boolean>;
+    readonly isAnonymousUser$: Observable<boolean>;
+    readonly isNotAnonymousUser$: Observable<boolean>;
+    readonly isLoggedIn$: Observable<boolean>;
+    readonly isNotLoggedIn$: Observable<boolean>;
+    readonly onLogIn$: Observable<void>;
+    readonly onLogOut$: Observable<void>;
+    readonly userIdentifier$: Observable<AuthUserIdentifier>;
+    readonly idTokenResult$: Observable<IdTokenResult>;
+    readonly claims$: Observable<ParsedToken>;
+    readonly authUserState$: Observable<AuthUserState>;
+    readonly authRoles$: Observable<AuthRoleSet>;
+    readonly isOnboarded$: Observable<boolean>;
+    constructor(firebaseAuth: Auth, delegate: DbxFirebaseAuthServiceDelegate);
+    logInWithGoogle(): Promise<UserCredential>;
+    logInWithFacebook(): Promise<UserCredential>;
+    logInWithTwitter(): Promise<UserCredential>;
+    logInWithGithub(): Promise<UserCredential>;
+    logInWithApple(): Promise<UserCredential>;
+    logInWithMicrosoft(): Promise<UserCredential>;
+    logInWithPhone(): Promise<UserCredential>;
+    logInWithPopup(provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential>;
+    registerWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    sendPasswordResetEmail(email: string): Promise<void>;
+    logInWithEmailAndPassword(email: string, password: string): Promise<UserCredential>;
+    logInAsAnonymous(): Promise<UserCredential>;
+    logOut(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseAuthService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxFirebaseAuthService>;
+}

package/lib/auth/service/index.d.ts

@@ -0,0 +1,2 @@
+export * from './firebase.auth.rxjs';
+export * from './firebase.auth.service';

package/lib/firebase/emulators.d.ts

@@ -0,0 +1,52 @@
+export interface DbxFirebaseEmulatorConfig {
+    /**
+     * Port to target.
+     */
+    port: number;
+    /**
+     * Defaults to localhost if not provided.
+     */
+    host?: string;
+}
+export interface DbxFirebaseEmulatorsConfig {
+    /**
+     * Whether or not to enable the emulators.
+     */
+    useEmulators?: boolean;
+    /**
+     * Default host to target. Defaults to localhost if not provided.
+     */
+    host?: string;
+    /**
+     * emulator UI configuration
+     */
+    ui?: DbxFirebaseEmulatorConfig;
+    /**
+     * Auth emulator configuration
+     */
+    auth?: DbxFirebaseEmulatorConfig;
+    /**
+     * Firestore emulator configuration
+     */
+    firestore?: DbxFirebaseEmulatorConfig;
+    /**
+     * Firestore emulator configuration
+     */
+    storage?: DbxFirebaseEmulatorConfig;
+    /**
+     * Functions emulator configuration
+     */
+    functions?: DbxFirebaseEmulatorConfig;
+    /**
+     * Database emulator configuration
+     */
+    database?: DbxFirebaseEmulatorConfig;
+}
+export declare abstract class DbxFirebaseParsedEmulatorsConfig implements DbxFirebaseEmulatorsConfig {
+    useEmulators?: boolean;
+    auth?: Required<DbxFirebaseEmulatorConfig>;
+    firestore?: Required<DbxFirebaseEmulatorConfig>;
+    storage?: Required<DbxFirebaseEmulatorConfig>;
+    functions?: Required<DbxFirebaseEmulatorConfig>;
+    database?: Required<DbxFirebaseEmulatorConfig>;
+}

package/lib/firebase/firebase.emulator.module.d.ts

@@ -0,0 +1,12 @@
+import { ModuleWithProviders } from '@angular/core';
+import { DbxFirebaseEmulatorsConfig } from './emulators';
+import * as i0 from "@angular/core";
+/**
+ * Used to configure the DbxFirebaseEmulatorsConfig provider.
+ */
+export declare class DbxFirebaseEmulatorModule {
+    static forRoot(config: DbxFirebaseEmulatorsConfig): ModuleWithProviders<DbxFirebaseEmulatorModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFirebaseEmulatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFirebaseEmulatorModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFirebaseEmulatorModule>;
+}