@dereekb/dbx-core 2.1.0 → 3.0.0

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

@@ -1,81 +1,13 @@
-import { Observable } from 'rxjs';
 import { DbxActionContextStoreSourceInstance } from './action.store.source';
-import { Maybe, Destroyable } from '@dereekb/util';
-export interface WorkHandlerContextDelegate<O = any> {
-    startWorking(): void;
-    success(result?: Maybe<O>): void;
-    reject(error?: Maybe<any>): void;
-}
+import { Work, WorkInstanceDelegate } from '@dereekb/rxjs';
 /**
- * WorkHandlerContextDelegate implementation using an DbxActionContextStoreSourceInstance.
+ * WorkInstanceDelegate implementation using an DbxActionContextStoreSourceInstance.
  */
-export declare class WorkHandlerContextSourceDelegate<T = any, O = any> implements WorkHandlerContextDelegate<O> {
+export declare class DbxActionWorkInstanceDelegate<T = any, O = any> implements WorkInstanceDelegate<O> {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     startWorking(): void;
     success(result: O): void;
     reject(error: any): void;
 }
-/**
- * Used by DbxActionHandlerDirective when handling a function.
- */
-export declare class WorkHandlerContext<T = any, O = any> implements Destroyable {
-    readonly value: T;
-    readonly delegate: WorkHandlerContextDelegate<O>;
-    private _done;
-    private _doneActionBegan;
-    private _actionBegan;
-    private _isComplete;
-    constructor(value: T, delegate: WorkHandlerContextDelegate<O>);
-    get actionBegan(): boolean;
-    get actionBegan$(): Observable<boolean>;
-    get isComplete(): boolean;
-    get isComplete$(): Observable<boolean>;
-    /**
-     * Begins working using an observable.
-     */
-    startWorkingWithObservable(actionObs: Observable<O>): void;
-    /**
-     * Notifies the system that the action has begun.
-     */
-    startWorking(): void;
-    /**
-     * Sets success on the action.
-     */
-    success(result?: O): void;
-    /**
-     * Sets rejected on the action.
-     */
-    reject(error?: any): void;
-    destroy(): void;
-    private _setWorking;
-    private _setComplete;
-}
-export declare type HandleActionFunctionConfigFn<T, O> = (value: T) => HandleWorkValueReadyConfig<T, O>;
-/**
- * Creates a function that uses a provider to always handle new values.
- */
-export declare function handleWorkValueReadyWithConfigFn<T, O>(providerFn: HandleActionFunctionConfigFn<T, O>): (value: T) => Maybe<WorkHandlerContext<T, O>>;
-/**
- * Config for handleWorkValueReadyFn().
- */
-export interface HandleWorkValueReadyConfig<T, O> {
-    handlerFunction: HandleActionFunction<T, O>;
-    delegate: WorkHandlerContextDelegate<O>;
-}
-/**
- * Performs the action using the value and returns an observable.
- */
-export declare type HandleActionUsingObservable<T = any, O = any> = (value: T) => Observable<O>;
-/**
- * Performs the action that uses the context handler to handle the event.
- */
-export declare type HandleActionUsingContext<T = any, O = any> = (value: T, context: WorkHandlerContext<T, O>) => void;
-/**
- * Performs the action. Can either return an observable that will use the handler, or can use the handler itself.
- */
-export declare type HandleActionFunction<T = any, O = any> = HandleActionUsingObservable<T, O> | HandleActionUsingContext<T, O>;
-/**
- * Creates a function that handles the incoming value and creates a WorkHandlerContext.
- */
-export declare function handleWorkValueReadyFn<T, O>({ handlerFunction, delegate }: HandleWorkValueReadyConfig<T, O>): (value: T) => Maybe<WorkHandlerContext<T, O>>;
+export declare type HandleActionFunction<T = any, O = any> = Work<T, O>;

package/lib/action/action.module.d.ts

@@ -13,12 +13,12 @@ import * as i11 from "./directive/state/action.value.stream.directive";
 import * as i12 from "./directive/auto/action.automodify.directive";
 import * as i13 from "./directive/state/action.value.directive";
 import * as i14 from "./directive/debug/action.logger.directive";
-import * as i15 from "./directive/state/action.success.component";
-import * as i16 from "./directive/state/action.success.directive";
+import * as i15 from "./directive/state/action.success.directive";
+import * as i16 from "./directive/state/action.success.handler.directive";
 import * as i17 from "./directive/state/action.working.component";
 import * as i18 from "@angular/common";
 export declare class DbxCoreActionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreActionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreActionModule, [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent], [typeof i18.CommonModule], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreActionModule, [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionHasSuccessDirective, typeof i16.DbxActionSuccessHandlerDirective, typeof i17.DbxActionIsWorkingDirective], [typeof i18.CommonModule], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionHasSuccessDirective, typeof i16.DbxActionSuccessHandlerDirective, typeof i17.DbxActionIsWorkingDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreActionModule>;
 }

package/lib/action/directive/auto/action.automodify.directive.d.ts

@@ -7,7 +7,7 @@ export declare class DbxActionAutoModifyDirective<T, O> extends AbstractSubscrip
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private readonly _autoModifyEnabled;
     get autoModifyEnabled(): boolean;
-    set autoModifyEnabled(autoModifyEnabled: Maybe<any>);
+    set autoModifyEnabled(autoModifyEnabled: Maybe<boolean | ''>);
     constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;

package/lib/action/directive/auto/action.autotrigger.directive.d.ts

@@ -9,7 +9,9 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private _triggerEnabled;
+    private readonly _triggerEnabled;
+    private readonly _triggerLimit;
+    private readonly _trigger;
     /**
      * How much to throttle the auto-triggering.
      */
@@ -33,8 +35,6 @@ export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscri
     set instantTrigger(instantTrigger: any);
     get triggerLimit(): Maybe<number>;
     set triggerLimit(triggerLimit: Maybe<number>);
-    private readonly _triggerLimit;
-    private readonly _trigger;
     private _triggerCount;
     readonly _errorCount$: Observable<number>;
     readonly _triggerCount$: Observable<number>;

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

@@ -15,7 +15,7 @@ export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscripti
     ngOnInit(): void;
     ngOnDestroy(): void;
     get disabled(): boolean;
-    set disabled(disabled: Maybe<any>);
+    set disabled(disabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, [{ host: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": "dbxActionDisabled"; }, {}, never>;
 }

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

@@ -1,4 +1,5 @@
 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";
@@ -13,7 +14,7 @@ export declare class DbxActionEnforceModifiedDirective extends AbstractSubscript
     ngOnInit(): void;
     ngOnDestroy(): void;
     get enabled(): boolean;
-    set enabled(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>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": "dbxActionEnforceModified"; }, {}, never>;
 }

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 { 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 {
+export declare class DbxActionHasSuccessDirective extends AbstractIfDirective implements OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance;
-    private _successFunction;
-    readonly successFunction$: import("rxjs").Observable<SuccessActionFunction<O>>;
-    get successFunction(): Maybe<SuccessActionFunction<O>>;
-    set successFunction(successFunction: Maybe<SuccessActionFunction<O>>);
-    constructor(source: DbxActionContextStoreSourceInstance);
-    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>;
+    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,19 +1,19 @@
 import { OnInit } from '@angular/core';
-import { Maybe, ObjectOrGetter } from '@dereekb/util';
+import { Maybe, GetterOrValue } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 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: DbxActionContextStoreSourceInstance<T, O>;
     private _valueOrFunction;
-    readonly valueOrFunction$: import("rxjs").Observable<ObjectOrGetter<T>>;
-    get valueOrFunction(): Maybe<ObjectOrGetter<T>>;
-    set valueOrFunction(valueOrFunction: Maybe<ObjectOrGetter<T>>);
+    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;

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

@@ -1,10 +1,10 @@
-import { ObservableGetter, IsModifiedFunction } from '@dereekb/rxjs';
+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> = () => ObservableGetter<Maybe<T>>;
+export declare type DbxActionValueOnTriggerFunction<T> = () => ObservableOrValue<Maybe<T>>;
 export interface DbxActionValueOnTriggerResult<T = any> {
     value?: Maybe<T>;
     reject?: any;

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

@@ -1,12 +1,18 @@
+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 {
+export declare class DbxActionIsWorkingDirective extends AbstractIfDirective implements OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance;
+    showAfter?: Maybe<number> | '';
     readonly show$: import("rxjs").Observable<boolean>;
-    constructor(source: DbxActionContextStoreSourceInstance);
-    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,7 @@
 export * from './action.disabled.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';

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;