@dereekb/dbx-core 1.2.0 → 3.0.0

package/lib/action/directive/state/action.enforce.modified.directive.d.ts

@@ -0,0 +1,20 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+export declare const APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY = "dbx_action_enforce_modified";
+/**
+ * Directive that toggles disabling an action if the action is not marked modified.
+ */
+export declare class DbxActionEnforceModifiedDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance;
+    private _enabled;
+    constructor(source: DbxActionContextStoreSourceInstance);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get enabled(): boolean;
+    set enabled(enabled: Maybe<string | boolean>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": "dbxActionEnforceModified"; }, {}, never>;
+}

package/lib/action/directive/state/action.handler.directive.d.ts

@@ -1,6 +1,6 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { HandleActionFunction } from '../../action.handler';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
@@ -8,13 +8,13 @@ import * as i0 from "@angular/core";
  * Context used for defining a function that performs an action using the input function on ValueReady.
  */
 export declare class DbxActionHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private _handlerFunction;
     readonly handlerFunction$: import("rxjs").Observable<HandleActionFunction<T, O>>;
     get handlerFunction(): Maybe<HandleActionFunction<T, O>>;
     set handlerFunction(handlerFunction: Maybe<HandleActionFunction<T, O>>);
     private _delegate;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerDirective<any, any>, [{ host: true; }]>;

package/lib/action/directive/state/action.success.directive.d.ts

@@ -1,24 +1,16 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
 import { Maybe } from '@dereekb/util';
-import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { AbstractIfDirective } from '../../../view/if.directive';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
- * Performs the action on success.
+ * Structural directive that displays the content when the store has a success value.
  */
-export declare type SuccessActionFunction<O> = (value: O) => void;
-/**
- * Directive that executes a function on ActionContextStore Success.
- */
-export declare class DbxActionSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance;
-    private _successFunction;
-    readonly successFunction$: import("rxjs").Observable<SuccessActionFunction<O>>;
-    get successFunction(): Maybe<SuccessActionFunction<O>>;
-    set successFunction(successFunction: Maybe<SuccessActionFunction<O>>);
-    constructor(source: ActionContextStoreSourceInstance);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessDirective<any, any>, "[dbxActionSuccess]", never, { "successFunction": "dbxActionSuccess"; }, {}, never>;
+export declare class DbxActionHasSuccessDirective extends AbstractIfDirective implements OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance;
+    hideAfter?: Maybe<number> | '';
+    readonly show$: import("rxjs").Observable<boolean>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, source: DbxActionContextStoreSourceInstance);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHasSuccessDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": "dbxActionHasSuccess"; }, {}, never>;
 }

package/lib/action/directive/state/action.success.handler.directive.d.ts

@@ -0,0 +1,24 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Performs the action on success.
+ */
+export declare type DbxActionSuccessHandlerFunction<O> = (value: O) => void;
+/**
+ * Directive that executes a function on ActionContextStore Success.
+ */
+export declare class DbxActionSuccessHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    private _successFunction;
+    readonly successFunction$: import("rxjs").Observable<DbxActionSuccessHandlerFunction<O>>;
+    get successFunction(): Maybe<DbxActionSuccessHandlerFunction<O>>;
+    set successFunction(successFunction: Maybe<DbxActionSuccessHandlerFunction<O>>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessHandlerDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessHandlerDirective<any, any>, "[dbxActionSuccessHandler]", never, { "successFunction": "dbxActionSuccessHandler"; }, {}, never>;
+}

package/lib/action/directive/state/action.value.directive.d.ts

@@ -1,20 +1,20 @@
 import { OnInit } from '@angular/core';
-import { Maybe, ObjectOrGetter } from '@dereekb/util';
+import { Maybe, GetterOrValue } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Directive that provides a default value when triggered.
  *
- * No value is required, allowing the directive to automatically call readyValue with undefined.
+ * No value is required, allowing the directive to automatically call readyValue.
  */
 export declare class DbxActionValueDirective<T, O> extends AbstractSubscriptionDirective implements OnInit {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private _valueOrFunction;
-    readonly valueOrFunction$: import("rxjs").Observable<ObjectOrGetter<T>>;
-    get valueOrFunction(): Maybe<ObjectOrGetter<T>>;
-    set valueOrFunction(valueOrFunction: Maybe<ObjectOrGetter<T>>);
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    readonly valueOrFunction$: import("rxjs").Observable<GetterOrValue<T>>;
+    get valueOrFunction(): Maybe<GetterOrValue<T>>;
+    set valueOrFunction(valueOrFunction: Maybe<GetterOrValue<T>>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueDirective<any, any>, [{ host: true; }]>;

package/lib/action/directive/state/action.value.stream.directive.d.ts

@@ -0,0 +1,25 @@
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+import { OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { IsModifiedFunction } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Directive that watches a value observable for changes and sets the new value and modified states as necessary.
+ */
+export declare class dbxActionValueStreamDirective<T, O> implements OnInit, OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    private _valueObs;
+    private _isModifiedFn;
+    private _modifiedSub;
+    private _triggerSub;
+    set dbxActionValueStream(dbxActionValueStream: Observable<T>);
+    set dbxActionValueStreamIsNotEmpty(requireNonEmpty: any);
+    set dbxActionValueStreamModified(dbxActionValueStreamModified: IsModifiedFunction<T>);
+    readonly modifiedValue$: Observable<[boolean, T]>;
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<dbxActionValueStreamDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<dbxActionValueStreamDirective<any, any>, "[dbxActionValueStream]", never, { "dbxActionValueStream": "dbxActionValueStream"; "dbxActionValueStreamIsNotEmpty": "dbxActionValueStreamIsNotEmpty"; "dbxActionValueStreamModified": "dbxActionValueStreamModified"; }, {}, never>;
+}

package/lib/action/directive/state/action.value.trigger.directive.d.ts

@@ -0,0 +1,34 @@
+import { ElementRef, OnDestroy, OnInit } from "@angular/core";
+import { IsModifiedFunction } from "@dereekb/rxjs";
+import { Maybe } from "@dereekb/util";
+import { DbxActionContextStoreSourceInstance } from "../../action.store.source";
+import { DbxActionValueOnTriggerFunction } from "./action.value.trigger.instance";
+import * as i0 from "@angular/core";
+/**
+ * Abstract class for directives that may perform an action when trigger is called, and returns a value.
+ */
+export declare abstract class AbstractDbxActionValueOnTriggerDirective<T> {
+    readonly source: DbxActionContextStoreSourceInstance<T, any>;
+    private readonly _instance;
+    private _triggeredSub;
+    constructor(source: DbxActionContextStoreSourceInstance<T, any>, valueGetter?: Maybe<DbxActionValueOnTriggerFunction<T>>);
+    get valueGetter(): Maybe<DbxActionValueOnTriggerFunction<T>>;
+    set valueGetter(valueGetter: Maybe<DbxActionValueOnTriggerFunction<T>>);
+    get isModifiedFunction(): Maybe<IsModifiedFunction<T>>;
+    set isModifiedFunction(isModifiedFunction: Maybe<IsModifiedFunction<T>>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionValueOnTriggerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxActionValueOnTriggerDirective<any>, never, never, {}, {}, never>;
+}
+/**
+ * Action directive that is used to trigger/display a popover, then watches that popover for a value.
+ */
+export declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueOnTriggerDirective<T> implements OnInit, OnDestroy {
+    readonly elementRef: ElementRef;
+    set dbxActionValueOnTrigger(dbxActionValueTrigger: Maybe<DbxActionValueOnTriggerFunction<T>>);
+    set dbxActionValueTriggerModified(isModifiedFunction: Maybe<IsModifiedFunction>);
+    constructor(elementRef: ElementRef, source: DbxActionContextStoreSourceInstance<T, any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueTriggerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueTriggerDirective<any>, "[dbxActionValueOnTrigger]", ["dbxActionValueOnTrigger"], { "dbxActionValueOnTrigger": "dbxActionValueOnTrigger"; "dbxActionValueTriggerModified": "dbxActionValueTriggerModified"; }, {}, never>;
+}

package/lib/action/directive/state/action.value.trigger.instance.d.ts

@@ -0,0 +1,34 @@
+import { ObservableOrValue, IsModifiedFunction } from '@dereekb/rxjs';
+import { Destroyable, Initialized, Maybe } from '@dereekb/util';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+/**
+ * DbxActionValueOnTriggerInstance function. Returns an ObervableGetter that returns a value.
+ */
+export declare type DbxActionValueOnTriggerFunction<T> = () => ObservableOrValue<Maybe<T>>;
+export interface DbxActionValueOnTriggerResult<T = any> {
+    value?: Maybe<T>;
+    reject?: any;
+}
+/**
+ * DbxActionValueOnTriggerInstance configuration.
+ */
+export interface DbxActionValueOnTriggerInstanceConfig<T> {
+    readonly source: DbxActionContextStoreSourceInstance<T, any>;
+    readonly valueGetter?: Maybe<DbxActionValueOnTriggerFunction<T>>;
+    readonly isModifiedFunction?: Maybe<IsModifiedFunction<T>>;
+}
+/**
+ * Utility class that handles trigger events to retrieve a value.
+ */
+export declare class DbxActionValueOnTriggerInstance<T> implements Initialized, Destroyable {
+    private _valueGetter;
+    readonly valueGetter$: import("rxjs").Observable<DbxActionValueOnTriggerFunction<T>>;
+    readonly source: DbxActionContextStoreSourceInstance<T, any>;
+    isModifiedFunction?: Maybe<IsModifiedFunction<T>>;
+    private _triggeredSub;
+    constructor(config: DbxActionValueOnTriggerInstanceConfig<T>);
+    get valueGetter(): Maybe<DbxActionValueOnTriggerFunction<T>>;
+    set valueGetter(valueGetter: Maybe<DbxActionValueOnTriggerFunction<T>>);
+    init(): void;
+    destroy(): void;
+}

package/lib/action/directive/state/action.working.component.d.ts

@@ -1,12 +1,18 @@
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { AbstractIfDirective } from '../../../view/if.directive';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
- * Displays the input content when working is set.
+ * Structural directive that displays the content when the store is working.
+ *
+ * Can specify a period in milliseconds that shows how long to show up after working for a particular number of seconds.
  */
-export declare class DbxActionWorkingComponent {
-    readonly source: ActionContextStoreSourceInstance;
+export declare class DbxActionIsWorkingDirective extends AbstractIfDirective implements OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance;
+    showAfter?: Maybe<number> | '';
     readonly show$: import("rxjs").Observable<boolean>;
-    constructor(source: ActionContextStoreSourceInstance);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionWorkingComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxActionWorkingComponent, "dbx-action-working", never, {}, {}, never, ["*"]>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, source: DbxActionContextStoreSourceInstance);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionIsWorkingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionIsWorking]", never, { "showAfter": "dbxActionIsWorking"; }, {}, never>;
 }

package/lib/action/directive/state/index.d.ts

@@ -1,7 +1,9 @@
 export * from './action.disabled.directive';
-export * from './action.disabled.modified.directive';
 export * from './action.handler.directive';
-export * from './action.success.component';
 export * from './action.success.directive';
+export * from './action.success.handler.directive';
 export * from './action.value.directive';
 export * from './action.working.component';
+export * from './action.enforce.modified.directive';
+export * from './action.value.trigger.directive';
+export * from './action.value.trigger.instance';

package/lib/action/index.d.ts

@@ -1,9 +1,9 @@
 export * from './directive';
-export * from './snackbar';
 export * from './action.handler';
 export * from './action.holder';
 export * from './action.machine';
 export * from './action.module';
+export * from './action.reference';
 export * from './action.store.source';
 export * from './action.store';
 export * from './action';

package/lib/auth/auth.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./auth.role.has.directive";
+import * as i2 from "./auth.role.any.directive";
+export declare class DbxCoreAuthModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreAuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreAuthModule, [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective], never, [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreAuthModule>;
+}

package/lib/auth/auth.role.any.directive.d.ts

@@ -0,0 +1,20 @@
+import { AuthRole, ArrayOrValue } from '@dereekb/util';
+import { TemplateRef, ViewContainerRef, OnDestroy } from '@angular/core';
+import { DbxAuthService } from './service';
+import { Maybe } from '@dereekb/util';
+import { AbstractIfDirective } from '../view/if.directive';
+import * as i0 from "@angular/core";
+/**
+ * Structural decorator directive similar to ngIf that embeds content if the current auth user has any of the target role(s).
+ */
+export declare class DbxAuthHasAnyRoleDirective extends AbstractIfDirective implements OnDestroy {
+    private dbxAuthService;
+    private _targetRoles;
+    readonly targetRoles$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: import("rxjs").Observable<boolean>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, dbxAuthService: DbxAuthService);
+    ngOnDestroy(): void;
+    set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasAnyRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": "dbxAuthHasAnyRole"; }, {}, never>;
+}

package/lib/auth/auth.role.has.directive.d.ts

@@ -0,0 +1,20 @@
+import { AuthRole, ArrayOrValue } from '@dereekb/util';
+import { TemplateRef, ViewContainerRef, OnDestroy } from '@angular/core';
+import { DbxAuthService } from './service';
+import { Maybe } from '@dereekb/util';
+import { AbstractIfDirective } from '../view/if.directive';
+import * as i0 from "@angular/core";
+/**
+ * Structural decorator directive similar to ngIf that embeds content if the current auth user has all of the target role(s).
+ */
+export declare class DbxAuthHasRolesDirective extends AbstractIfDirective implements OnDestroy {
+    private dbxAuthService;
+    private _targetRoles;
+    readonly targetRoles$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: import("rxjs").Observable<boolean>;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, dbxAuthService: DbxAuthService);
+    ngOnDestroy(): void;
+    set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasRolesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": "dbxAuthHasRoles"; }, {}, never>;
+}

package/lib/auth/auth.state.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+import * as i2 from "@ngrx/effects";
+export declare class DbxAppAuthStateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppAuthStateModule, never, [typeof i1.StoreFeatureModule, typeof i2.EffectsFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxAppAuthStateModule>;
+}

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

@@ -0,0 +1,13 @@
+import { Store } from "@ngrx/store";
+import { DbxAppAuthFullState } from "./state/state";
+import * as i0 from "@angular/core";
+/**
+ * State for accessing the app's DbxAppAuthState defined within the DbxAppAuthFullState for the ngrx store.
+ */
+export declare class DbxAppAuthStateService {
+    readonly store: Store<DbxAppAuthFullState>;
+    readonly authStateUser$: import("rxjs").Observable<import("./state/reducer/user.reducer").DbxAppAuthStateUser>;
+    constructor(store: Store<DbxAppAuthFullState>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthStateService>;
+}

package/lib/auth/auth.user.d.ts

@@ -0,0 +1,28 @@
+import { Maybe } from "@dereekb/util";
+/**
+ * An application user state.
+ *
+ * Generic states that define the current state of the user:
+ * - none: the user is not logged in
+ * - anon: the user is logged in as an anonymous account
+ * - error: there was an error loading the correct user state
+ * - new: the user has a full account but has not completed onboarding/setup
+ * - user: the user has a full account and has completed setup
+ */
+export declare type AuthUserState = 'none' | 'anon' | 'new' | 'user' | 'error';
+/**
+ * Arbitrary identifier used to differentiate users.
+ */
+export declare type AuthUserIdentifier = string;
+export declare const NO_AUTH_USER_IDENTIFIER = "0";
+/**
+ * AuthUserIdentifier used to indicate that the user cannot be uniquely identifier.
+ */
+export declare type NoAuthUserIdentifier = typeof NO_AUTH_USER_IDENTIFIER;
+/**
+ * Creates an AuthUserIdentifier from the input. If the input is undefined, returns the NoAuthUserIdentifier.
+ *
+ * @param inputId
+ * @returns
+ */
+export declare function authUserIdentifier(inputId: Maybe<AuthUserIdentifier>): AuthUserIdentifier;

package/lib/auth/index.d.ts

@@ -0,0 +1,9 @@
+export * from './router';
+export * from './service';
+export * from './state';
+export * from './auth.user';
+export * from './auth.module';
+export * from './auth.role.any.directive';
+export * from './auth.role.has.directive';
+export * from './auth.state.module';
+export * from './auth.state.service';

package/lib/auth/router/auth.router.d.ts

@@ -0,0 +1,10 @@
+import { SegueRefOrSegueRefRouterLink } from '../../router/segue';
+/**
+ * Auth routes configurations for an app.
+ */
+export declare abstract class DbxAppAuthRoutes {
+    abstract readonly loginRef: SegueRefOrSegueRefRouterLink;
+    abstract readonly loggedOutRef?: SegueRefOrSegueRefRouterLink;
+    abstract readonly onboardRef?: SegueRefOrSegueRefRouterLink;
+    abstract readonly appRef: SegueRefOrSegueRefRouterLink;
+}

package/lib/auth/router/auth.router.module.d.ts

@@ -0,0 +1,9 @@
+import { ModuleWithProviders } from '@angular/core';
+import { DbxAppAuthRoutes } from './auth.router';
+import * as i0 from "@angular/core";
+export declare class DbxAppAuthRouterModule {
+    static forRoot(dbxAppAuthRoutes: DbxAppAuthRoutes): ModuleWithProviders<DbxAppAuthRouterModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthRouterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppAuthRouterModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxAppAuthRouterModule>;
+}

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

@@ -0,0 +1,38 @@
+import { DbxRouterService } from "../../router/router/service/router.service";
+import { DbxAppAuthRoutes } from "./auth.router";
+import * as i0 from "@angular/core";
+/**
+ * Helper service for navigating to important auth-related routes.
+ */
+export declare class DbxAppAuthRouterService {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxAppAuthRoutes: DbxAppAuthRoutes;
+    constructor(dbxRouterService: DbxRouterService, dbxAppAuthRoutes: DbxAppAuthRoutes);
+    get hasOnboardingState(): boolean;
+    /**
+     * Navigates to the login state.
+     *
+     * @returns
+     */
+    goToLogin(): Promise<boolean>;
+    /**
+     * Navigates to the logged out state, if it exists, otherwise navigates to the login state.
+     *
+     * @returns
+     */
+    goToLoggedOut(): Promise<boolean>;
+    /**
+     * Navigates to the onboarding state if it is available, otherwise navigates to the app.
+     *
+     * @returns
+     */
+    goToOnboarding(): Promise<boolean>;
+    /**
+     * Navigates to the app state.
+     *
+     * @returns
+     */
+    goToApp(): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthRouterService>;
+}

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

@@ -0,0 +1,5 @@
+export * from './provider/uirouter';
+export * from './state';
+export * from './auth.router';
+export * from './auth.router.service';
+export * from './auth.router.module';

package/lib/auth/router/provider/uirouter/auth.hook.d.ts

@@ -0,0 +1,18 @@
+import { TransitionService } from '@uirouter/core';
+import { AuthTransitionHookOptions } from './hook';
+export interface IsLoggedInHookConfig {
+    options: AuthTransitionHookOptions;
+}
+/**
+ * UIRouter State data with configuration for the hasAuthRoleHook.
+ */
+export interface IsLoggedInStateData {
+    /**
+     * Whether or not the user needs to be logged in for this state.
+     */
+    requiredLogIn: boolean;
+}
+/**
+ * This hook redirects to the configured default state when a user is not logged in for configured states.
+ */
+export declare function enableIsLoggedInHook(transitionService: TransitionService, config: IsLoggedInHookConfig): void;

package/lib/auth/router/provider/uirouter/hook.d.ts

@@ -0,0 +1,46 @@
+import { TransitionHookFn, Transition, UIInjector } from '@uirouter/core';
+import { Observable } from 'rxjs';
+import { SegueRef } from './../../../../router/segue';
+import { DbxAuthService } from '../../../service/auth.service';
+import { FactoryWithRequiredInput, Maybe } from '@dereekb/util';
+import { Injector } from '@angular/core';
+/**
+ * authTransitionHookFn() configuration. The values are handled as:
+ * - true: continue to the state.
+ * - false: redirect to the login page.
+ * - StateOrName: redirect to the target page instead.
+ */
+export declare type AuthTransitionDecision = true | false | SegueRef;
+export interface AuthTransitionDecisionGetterInput {
+    readonly transition: Transition;
+    readonly injector: Injector;
+    readonly authService: DbxAuthService;
+}
+export declare type AuthTransitionRedirectTargetGetter = FactoryWithRequiredInput<Observable<Maybe<SegueRef>>, AuthTransitionDecisionGetterInput>;
+export declare type AuthTransitionRedirectTargetOrGetter = Maybe<SegueRef> | AuthTransitionRedirectTargetGetter;
+export interface AuthTransitionHookOptions {
+    /**
+     * The state to redirect the user to when their auth fails.
+     */
+    defaultRedirectTarget: string;
+    /**
+     * The state to redirect the user to. Defaults to defaultRedirectTarget.
+     */
+    errorRedirectTarget?: string;
+}
+export interface AuthTransitionHookConfig extends AuthTransitionHookOptions {
+    /**
+     * Creates the decision observable for the transition that decides whether or not to redirect or continue.
+     */
+    makeDecisionsObs: (transition: Transition, authService: DbxAuthService, injector: UIInjector) => Observable<AuthTransitionDecision>;
+}
+export interface AuthTransitionStateData {
+    /**
+     * Optional getter/decision maker when a role needs to be
+     */
+    redirectTo?: AuthTransitionRedirectTargetOrGetter;
+}
+/**
+ * This generates a TransitionHookFn that can be used with redirecting routes.
+ */
+export declare function makeAuthTransitionHook(config: AuthTransitionHookConfig): TransitionHookFn;

package/lib/auth/router/provider/uirouter/index.d.ts

@@ -0,0 +1,5 @@
+export * from './hook';
+export * from './redirect';
+export * from './auth.hook';
+export * from './role.hook';
+export * from './state.hook';

package/lib/auth/router/provider/uirouter/redirect.d.ts

@@ -0,0 +1,9 @@
+import { ObjectMap } from "@dereekb/util";
+import { AuthTransitionRedirectTargetGetter, AuthTransitionRedirectTargetOrGetter } from "./hook";
+/**
+ * Creates a AuthTransitionRedirectTargetGetter that can redirect values based on the current authUserState.
+ *
+ * @param stateMap
+ * @returns
+ */
+export declare function redirectBasedOnAuthUserState(stateMap: ObjectMap<AuthTransitionRedirectTargetOrGetter>): AuthTransitionRedirectTargetGetter;

package/lib/auth/router/provider/uirouter/role.hook.d.ts

@@ -0,0 +1,26 @@
+import { AuthRole, SetIncludesMode, ArrayOrValue } from '@dereekb/util';
+import { TransitionService } from '@uirouter/core';
+import { AuthTransitionHookOptions, AuthTransitionStateData } from './hook';
+export interface HasAuthRoleHookConfig {
+    options: AuthTransitionHookOptions;
+}
+/**
+ * UIRouter State data with configuration for the hasAuthRoleHook.
+ */
+export interface HasAuthRoleStateData extends AuthTransitionStateData {
+    /**
+     * Auth roles marked for this state
+     */
+    authRoles: ArrayOrValue<AuthRole>;
+    /**
+     * How to use the above auth roles. This defaults to 'all' by default.
+     */
+    authRolesMode?: SetIncludesMode;
+}
+/**
+ * This hook redirects to the configured default state when a user:
+ *
+ * - does not have an allowed state
+ * - has a disallowed state
+ */
+export declare function enableHasAuthRoleHook(transitionService: TransitionService, config: HasAuthRoleHookConfig): void;

package/lib/auth/router/provider/uirouter/state.hook.d.ts

@@ -0,0 +1,31 @@
+import { ArrayOrValue } from '@dereekb/util';
+import { TransitionService } from '@uirouter/core';
+import { AuthUserState } from '../../../auth.user';
+import { AuthTransitionHookOptions } from './hook';
+export interface HasAuthStateHookConfig {
+    options: AuthTransitionHookOptions;
+}
+export declare type HasAuthStateConfig = ArrayOrValue<AuthUserState> | HasAuthStateObjectConfig;
+export interface HasAuthStateObjectConfig {
+    /**
+     * Whether or not this state or any child state is considered "secure", which requires the user to be logged in.
+     */
+    allowedStates?: ArrayOrValue<AuthUserState>;
+    /**
+     * States that are not allowed. If the current state is this state, a rejection is returned.
+     */
+    disallowedStates?: ArrayOrValue<AuthUserState>;
+}
+export interface HasAuthStateData {
+    /**
+     * Configuration for the hasAuthStateHook.
+     */
+    authStates: HasAuthStateConfig;
+}
+/**
+ * This hook redirects to the configured default state when a user:
+ *
+ * - does not have an allowed state
+ * - has a disallowed state
+ */
+export declare function enableHasAuthStateHook(transitionService: TransitionService, config: HasAuthStateHookConfig): void;

package/lib/auth/router/state/auth.router.state.module.d.ts

@@ -0,0 +1,14 @@
+import { ModuleWithProviders } from '@angular/core';
+import { ArrayOrValue } from '@dereekb/util';
+import { DbxAppContextState } from '../../../context';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+export interface DbxAppAuthRouterStateModuleConfig {
+    readonly activeRoutesToApplyEffects: ArrayOrValue<DbxAppContextState>;
+}
+export declare class DbxAppAuthRouterStateModule {
+    static forRoot(config: DbxAppAuthRouterStateModuleConfig): ModuleWithProviders<DbxAppAuthRouterStateModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthRouterStateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppAuthRouterStateModule, never, [typeof i1.EffectsFeatureModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxAppAuthRouterStateModule>;
+}