@dereekb/dbx-core 11.1.8 → 12.0.1

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

@@ -1,23 +1,23 @@
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { Observable } from 'rxjs';
 import { OnInit, OnDestroy } from '@angular/core';
-import { IsModifiedFunction } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
+import { IsEqualFunction, 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 {
+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: unknown);
-    set dbxActionValueStreamModified(dbxActionValueStreamModified: IsModifiedFunction<T>);
+    readonly dbxActionValueStream: import("@angular/core").InputSignal<Observable<T>>;
+    readonly dbxActionValueStreamIsEqualValue: import("@angular/core").InputSignal<Maybe<IsEqualFunction<T>>>;
+    readonly dbxActionValueStreamIsModifiedValue: import("@angular/core").InputSignal<Maybe<IsModifiedFunction<T>>>;
+    private readonly _modifiedSub;
+    private readonly _triggerSub;
+    readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
     readonly modifiedValue$: Observable<[boolean, T]>;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<dbxActionValueStreamDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<dbxActionValueStreamDirective<any, any>, "[dbxActionValueStream]", never, { "dbxActionValueStream": { "alias": "dbxActionValueStream"; "required": false; }; "dbxActionValueStreamIsNotEmpty": { "alias": "dbxActionValueStreamIsNotEmpty"; "required": false; }; "dbxActionValueStreamModified": { "alias": "dbxActionValueStreamModified"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueStreamDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueStreamDirective<any, any>, "[dbxActionValueStream]", never, { "dbxActionValueStream": { "alias": "dbxActionValueStream"; "required": false; "isSignal": true; }; "dbxActionValueStreamIsEqualValue": { "alias": "dbxActionValueStreamIsEqualValue"; "required": false; "isSignal": true; }; "dbxActionValueStreamIsModifiedValue": { "alias": "dbxActionValueStreamIsModifiedValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,33 +1,39 @@
-import { ElementRef, OnDestroy, OnInit } from '@angular/core';
-import { IsModifiedFunction } from '@dereekb/rxjs';
+import { OnDestroy, OnInit, Signal } from '@angular/core';
+import { IsEqualFunction, IsModifiedFunction } from '@dereekb/rxjs';
 import { type Maybe } from '@dereekb/util';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
-import { DbxActionValueOnTriggerFunction } from './action.value.trigger.instance';
+import { DbxActionValueGetterValueGetterFunction } from './action.value.trigger.instance';
 import * as i0 from "@angular/core";
+export interface DbxActionValueGetterDirectiveComputeInputsConfig<T> {
+    readonly valueGetterSignal?: Signal<Maybe<DbxActionValueGetterValueGetterFunction<T>>>;
+    readonly isModifiedSignal?: Signal<Maybe<IsModifiedFunction>>;
+    readonly isEqualSignal?: Signal<Maybe<IsEqualFunction>>;
+}
 /**
  * Abstract class for directives that may perform an action when trigger is called, and returns a value.
  */
-export declare abstract class AbstractDbxActionValueOnTriggerDirective<T> implements OnInit, OnDestroy {
+export declare abstract class AbstractDbxActionValueGetterDirective<T> implements OnInit, OnDestroy {
+    private readonly _injector;
     readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
     private readonly _triggerInstance;
-    private _triggeredSub;
-    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, never, false, never>;
+    setValueGetterFunction(valueGetterFunction: Maybe<DbxActionValueGetterValueGetterFunction<T>>): void;
+    protected configureInputs(config: DbxActionValueGetterDirectiveComputeInputsConfig<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionValueGetterDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxActionValueGetterDirective<any>, never, never, {}, {}, never, never, false, never>;
 }
 /**
- * Action directive that is used to trigger/display a popover, then watches that popover for a value.
+ * Action directive that uses a getter function instead and waits for the trigger to be called before calling the function.
+ *
+ * Similar to DbxActionValueDirective, but the getter is called when a trigger is activated.
+ * The DbxActionValueDirective always pipes the latests value while waiting for a trigger, and does not allow using a getter.
  */
-export declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueOnTriggerDirective<T> implements OnInit, OnDestroy {
-    readonly elementRef: ElementRef<any>;
-    set dbxActionValueOnTrigger(dbxActionValueTrigger: Maybe<DbxActionValueOnTriggerFunction<T>>);
-    set dbxActionValueTriggerModified(isModifiedFunction: Maybe<IsModifiedFunction>);
+export declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueGetterDirective<T> implements OnDestroy {
+    readonly dbxActionValueGetter: import("@angular/core").InputSignal<Maybe<DbxActionValueGetterValueGetterFunction<T>>>;
+    readonly dbxActionValueGetterIsModified: import("@angular/core").InputSignal<Maybe<IsModifiedFunction>>;
+    readonly dbxActionValueGetterIsEqual: import("@angular/core").InputSignal<Maybe<IsEqualFunction>>;
     constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueTriggerDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueTriggerDirective<any>, "[dbxActionValueOnTrigger]", ["dbxActionValueOnTrigger"], { "dbxActionValueOnTrigger": { "alias": "dbxActionValueOnTrigger"; "required": false; }; "dbxActionValueTriggerModified": { "alias": "dbxActionValueTriggerModified"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueTriggerDirective<any>, "[dbxActionValueGetter]", ["dbxActionValueGetter"], { "dbxActionValueGetter": { "alias": "dbxActionValueGetter"; "required": false; "isSignal": true; }; "dbxActionValueGetterIsModified": { "alias": "dbxActionValueGetterIsModified"; "required": false; "isSignal": true; }; "dbxActionValueGetterIsEqual": { "alias": "dbxActionValueGetterIsEqual"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,34 +1,45 @@
 import { Destroyable, Initialized, Maybe, ReadableError } from '@dereekb/util';
-import { ObservableOrValue, IsModifiedFunction } from '@dereekb/rxjs';
+import { Observable } from 'rxjs';
+import { ObservableOrValue, IsModifiedFunction, IsEqualFunction } from '@dereekb/rxjs';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 /**
- * DbxActionValueOnTriggerInstance function. Returns an ObervableGetter that returns a value.
+ * DbxActionValueGetterInstance function. Returns an ObervableGetter that returns a value.
  */
-export type DbxActionValueOnTriggerFunction<T> = () => ObservableOrValue<Maybe<T>>;
-export interface DbxActionValueOnTriggerResult<T = unknown> {
-    value?: Maybe<T>;
-    reject?: Maybe<ReadableError>;
+export type DbxActionValueGetterValueGetterFunction<T> = () => ObservableOrValue<Maybe<T>>;
+export interface DbxActionValueGetterResult<T = unknown> {
+    /**
+     * The value to trigger with
+     */
+    readonly value?: Maybe<T>;
+    /**
+     * The error to reject with
+     */
+    readonly reject?: Maybe<ReadableError>;
 }
 /**
- * DbxActionValueOnTriggerInstance configuration.
+ * DbxActionValueGetterInstance configuration.
  */
-export interface DbxActionValueOnTriggerInstanceConfig<T> {
+export interface DbxActionValueGetterInstanceConfig<T> {
     readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
-    readonly valueGetter?: Maybe<DbxActionValueOnTriggerFunction<T>>;
+    readonly valueGetter?: Maybe<DbxActionValueGetterValueGetterFunction<T>>;
+    readonly isEqualFunction?: Maybe<IsEqualFunction<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>>;
+export declare class DbxActionValueGetterInstance<T> implements Initialized, Destroyable {
+    private readonly _valueGetterFunction;
+    readonly valueGetterFunction$: Observable<DbxActionValueGetterValueGetterFunction<T>>;
+    private readonly _isModifiedFunction;
+    private readonly _isEqualFunction;
+    readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
     readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
-    isModifiedFunction?: Maybe<IsModifiedFunction<T>>;
-    private _triggeredSub;
-    constructor(config: DbxActionValueOnTriggerInstanceConfig<T>);
-    get valueGetter(): Maybe<DbxActionValueOnTriggerFunction<T>>;
-    set valueGetter(valueGetter: Maybe<DbxActionValueOnTriggerFunction<T>>);
+    private readonly _triggeredSub;
+    constructor(config: DbxActionValueGetterInstanceConfig<T>);
+    setValueGetterFunction(valueGetterFunction: Maybe<DbxActionValueGetterValueGetterFunction<T>>): void;
+    setIsModifiedFunction(isModifiedFunction: Maybe<IsModifiedFunction<T>>): void;
+    setIsEqualFunction(isEqualFunction: Maybe<IsEqualFunction<T>>): void;
     init(): void;
     destroy(): void;
 }

package/lib/action/directive/state/{action.working.component.d.ts → action.working.directive.d.ts}

@@ -11,5 +11,5 @@ export declare class DbxActionIsWorkingDirective extends AbstractIfDirective imp
     showAfter?: Maybe<number> | '';
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionIsWorkingDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionIsWorking]", never, { "showAfter": { "alias": "dbxActionIsWorking"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionIsWorking]", never, { "showAfter": { "alias": "dbxActionIsWorking"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -6,7 +6,8 @@ export * from './action.presuccess.directive';
 export * from './action.success.directive';
 export * from './action.success.handler.directive';
 export * from './action.value.directive';
-export * from './action.working.component';
+export * from './action.working.directive';
 export * from './action.enforce.modified.directive';
 export * from './action.value.trigger.directive';
 export * from './action.value.trigger.instance';
+export * from './action.value.stream.directive';

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

@@ -2,8 +2,15 @@ import * as i0 from "@angular/core";
 import * as i1 from "./auth.role.has.directive";
 import * as i2 from "./auth.role.any.directive";
 import * as i3 from "./auth.role.not.directive";
+/**
+ * @deprecated import the directives directly instead of using this module.
+ *
+ * @see DbxAuthHasRolesDirective
+ * @see DbxAuthHasAnyRoleDirective
+ * @see DbxAuthNotAnyRoleDirective
+ */
 export declare class DbxCoreAuthModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreAuthModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreAuthModule, [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective, typeof i3.DbxAuthNotAnyRoleDirective], never, [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective, typeof i3.DbxAuthNotAnyRoleDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreAuthModule, never, [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective, typeof i3.DbxAuthNotAnyRoleDirective], [typeof i1.DbxAuthHasRolesDirective, typeof i2.DbxAuthHasAnyRoleDirective, typeof i3.DbxAuthNotAnyRoleDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreAuthModule>;
 }

package/lib/auth/auth.providers.d.ts

@@ -0,0 +1,12 @@
+import { EnvironmentProviders } from '@angular/core';
+import { ProvideDbxAppAuthRouterConfig } from './router/auth.router.providers';
+import { ProvideDbxAppAuthRouterStateConfig } from './router/state/auth.router.state.providers';
+export interface ProvideDbxAppAuthConfig extends ProvideDbxAppAuthRouterConfig, ProvideDbxAppAuthRouterStateConfig {
+}
+/**
+ * The "all-in-one" provider for an app's dbx-core auth providers.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+export declare function provideDbxAppAuth(config: ProvideDbxAppAuthConfig): EnvironmentProviders;

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

@@ -1,16 +1,16 @@
 import { AuthRole, ArrayOrValue, type Maybe } from '@dereekb/util';
-import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
 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 _targetRoles;
-    readonly targetRoles$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
-    readonly show$: import("rxjs").Observable<boolean>;
-    ngOnDestroy(): void;
+export declare class DbxAuthHasAnyRoleDirective extends AbstractIfDirective {
+    private readonly _targetRoles;
+    private readonly _authService;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
     set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasAnyRoleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": { "alias": "dbxAuthHasAnyRole"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": { "alias": "dbxAuthHasAnyRole"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -1,16 +1,16 @@
 import { Maybe, AuthRole, ArrayOrValue } from '@dereekb/util';
-import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
 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 _targetRoles;
-    readonly targetRoles$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
-    readonly show$: import("rxjs").Observable<boolean>;
-    ngOnDestroy(): void;
+export declare class DbxAuthHasRolesDirective extends AbstractIfDirective {
+    private readonly _targetRoles;
+    private readonly _authService;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
     set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasRolesDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": { "alias": "dbxAuthHasRoles"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": { "alias": "dbxAuthHasRoles"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -1,16 +1,16 @@
 import { Maybe, AuthRole, ArrayOrValue } from '@dereekb/util';
-import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
 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 none of the target role(s).
  */
-export declare class DbxAuthNotAnyRoleDirective extends AbstractIfDirective implements OnDestroy {
-    private _targetRoles;
-    readonly targetRoles$: import("rxjs").Observable<Maybe<ArrayOrValue<string>>>;
-    readonly show$: import("rxjs").Observable<boolean>;
-    ngOnDestroy(): void;
+export declare class DbxAuthNotAnyRoleDirective extends AbstractIfDirective {
+    private readonly _targetRoles;
+    private readonly _authService;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
     set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthNotAnyRoleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthNotAnyRoleDirective, "[dbxAuthNotAnyRole]", never, { "targetRoles": { "alias": "dbxAuthNotAnyRole"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthNotAnyRoleDirective, "[dbxAuthNotAnyRole]", never, { "targetRoles": { "alias": "dbxAuthNotAnyRole"; "required": false; }; }, {}, never, never, true, never>;
 }

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

@@ -0,0 +1,7 @@
+import { EnvironmentProviders } from '@angular/core';
+/**
+ * Creates EnvironmentProviders for providing the DbxAppAuth state and effects.
+ *
+ * @returns EnvironmentProviders
+ */
+export declare function provideDbxAppAuthState(): EnvironmentProviders;

package/lib/auth/index.d.ts

@@ -3,8 +3,9 @@ export * from './service';
 export * from './state';
 export * from './auth.user';
 export * from './auth.module';
+export * from './auth.providers';
 export * from './auth.role.any.directive';
 export * from './auth.role.has.directive';
 export * from './auth.role.not.directive';
-export * from './auth.state.module';
+export * from './auth.state.providers';
 export * from './auth.state.service';

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

@@ -0,0 +1,18 @@
+import { EnvironmentProviders } from '@angular/core';
+import { DbxAppAuthRoutes } from './auth.router';
+/**
+ * Configuration for provideDbxAppAuthRouter().
+ */
+export interface ProvideDbxAppAuthRouterConfig {
+    /**
+     * DbxAppAuthRoutes configuration.
+     */
+    readonly dbxAppAuthRoutes: DbxAppAuthRoutes;
+}
+/**
+ * Creates EnvironmentProviders for providing DbxAppAuthRoutes configuration.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+export declare function provideDbxAppAuthRouter(config: ProvideDbxAppAuthRouterConfig): EnvironmentProviders;

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

@@ -3,3 +3,4 @@ export * from './state';
 export * from './auth.router';
 export * from './auth.router.service';
 export * from './auth.router.module';
+export * from './auth.router.providers';

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

@@ -2,13 +2,15 @@ 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>;
 }
+/**
+ * @deprecated Use provideDbxAppAuthRouterState() instead.
+ */
 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 ɵmod: i0.ɵɵNgModuleDeclaration<DbxAppAuthRouterStateModule, never, never, never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxAppAuthRouterStateModule>;
 }

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

@@ -0,0 +1,19 @@
+import { EnvironmentProviders } from '@angular/core';
+import { ArrayOrValue } from '@dereekb/util';
+import { DbxAppContextState } from '../../../context';
+/**
+ * Configuration for provideDbxAppAuthRouterState().
+ */
+export interface ProvideDbxAppAuthRouterStateConfig {
+    /**
+     * Active routes to apply effects to.
+     */
+    readonly activeRoutesToApplyEffects: ArrayOrValue<DbxAppContextState>;
+}
+/**
+ * Creates EnvironmentProviders for providing DbxAppAuthRouterState configuration and effects.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+export declare function provideDbxAppAuthRouterState(config: ProvideDbxAppAuthRouterStateConfig): EnvironmentProviders;

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

@@ -1,2 +1,3 @@
 export * from './auth.router.state.module';
+export * from './auth.router.state.providers';
 export * from './effect';

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

@@ -1,12 +1,12 @@
 /**
  * Action for when the user has logged in.
  */
-export declare const loggedIn: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logged In", () => import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logged In">>;
+export declare const loggedIn: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logged In", () => import("@ngrx/store").Action<"[App/Auth] Auth Logged In">>;
 /**
  * Action for when the user has logged out.
  */
-export declare const loggedOut: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logged Out", () => import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logged Out">>;
+export declare const loggedOut: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logged Out", () => import("@ngrx/store").Action<"[App/Auth] Auth Logged Out">>;
 /**
  * Action to log the user out.
  */
-export declare const logout: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logout", () => import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logout">>;
+export declare const logout: import("@ngrx/store").ActionCreator<"[App/Auth] Auth Logout", () => import("@ngrx/store").Action<"[App/Auth] Auth Logout">>;

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

@@ -7,7 +7,7 @@ export declare const setUserIdentifier: import("@ngrx/store").ActionCreator<"[Ap
     id: AuthUserIdentifier;
 }) => {
     id: AuthUserIdentifier;
-} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Identifier">>;
+} & import("@ngrx/store").Action<"[App/Auth] Set User Identifier">>;
 /**
  * Sets the user's state in the auth.
  */
@@ -15,7 +15,7 @@ export declare const setUserState: import("@ngrx/store").ActionCreator<"[App/Aut
     state: AuthUserState;
 }) => {
     state: AuthUserState;
-} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User State">>;
+} & import("@ngrx/store").Action<"[App/Auth] Set User State">>;
 /**
  * Sets the user's roles in the auth.
  */
@@ -23,7 +23,7 @@ export declare const setUserRoles: import("@ngrx/store").ActionCreator<"[App/Aut
     roles: AuthRole[];
 }) => {
     roles: AuthRole[];
-} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Roles">>;
+} & import("@ngrx/store").Action<"[App/Auth] Set User Roles">>;
 /**
  * Sets the user's onboarding state.
  */
@@ -31,4 +31,4 @@ export declare const setUserIsOnboarded: import("@ngrx/store").ActionCreator<"[A
     isOnboarded: boolean;
 }) => {
     isOnboarded: boolean;
-} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Is Onboarded">>;
+} & import("@ngrx/store").Action<"[App/Auth] Set User Is Onboarded">>;

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

@@ -8,21 +8,21 @@ export declare class DbxAppAuthEffects {
     private readonly dbxAuthService;
     protected readonly actions$: Actions<any>;
     protected readonly store: Store<any>;
-    readonly emitLoggedIn: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logged In">> & import("@ngrx/effects").CreateEffectMetadata;
-    readonly emitLoggedOut: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logged Out">> & import("@ngrx/effects").CreateEffectMetadata;
-    readonly forwardLogoutToAuthService: import("rxjs").Observable<import("@ngrx/store/src/models").TypedAction<"[App/Auth] Auth Logout">> & import("@ngrx/effects").CreateEffectMetadata;
+    readonly emitLoggedIn: import("rxjs").Observable<import("@ngrx/store").Action<"[App/Auth] Auth Logged In">> & import("@ngrx/effects").CreateEffectMetadata;
+    readonly emitLoggedOut: import("rxjs").Observable<import("@ngrx/store").Action<"[App/Auth] Auth Logged Out">> & import("@ngrx/effects").CreateEffectMetadata;
+    readonly forwardLogoutToAuthService: import("rxjs").Observable<import("@ngrx/store").Action<"[App/Auth] Auth Logout">> & import("@ngrx/effects").CreateEffectMetadata;
     readonly setUserIdentifier: import("rxjs").Observable<{
-        id: string;
-    } & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Identifier">> & import("@ngrx/effects").CreateEffectMetadata;
+        id: import("@dereekb/dbx-core").AuthUserIdentifier;
+    } & import("@ngrx/store").Action<"[App/Auth] Set User Identifier">> & import("@ngrx/effects").CreateEffectMetadata;
     readonly setUserState: import("rxjs").Observable<{
         state: import("@dereekb/dbx-core").AuthUserState;
-    } & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User State">> & import("@ngrx/effects").CreateEffectMetadata;
+    } & import("@ngrx/store").Action<"[App/Auth] Set User State">> & import("@ngrx/effects").CreateEffectMetadata;
     readonly setUserRoles: import("rxjs").Observable<{
-        roles: string[];
-    } & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Roles">> & import("@ngrx/effects").CreateEffectMetadata;
+        roles: import("dist/packages/util/src").AuthRole[];
+    } & import("@ngrx/store").Action<"[App/Auth] Set User Roles">> & import("@ngrx/effects").CreateEffectMetadata;
     readonly setUserIsOnboarded: import("rxjs").Observable<{
         isOnboarded: boolean;
-    } & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Is Onboarded">> & import("@ngrx/effects").CreateEffectMetadata;
+    } & import("@ngrx/store").Action<"[App/Auth] Set User Is Onboarded">> & import("@ngrx/effects").CreateEffectMetadata;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthEffects, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthEffects>;
 }

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

@@ -8,4 +8,4 @@ export interface DbxAppAuthStateUser {
     userRoles: AuthRole[];
 }
 export declare const initialState: DbxAppAuthStateUser;
-export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppAuthStateUser, import("@ngrx/store").Action>;
+export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppAuthStateUser, import("@ngrx/store").Action<string>>;

package/lib/button/action/action.button.directive.d.ts

@@ -5,11 +5,10 @@ import * as i0 from "@angular/core";
  * Context used for linking a button to an ActionContext.
  */
 export declare class DbxActionButtonDirective extends DbxActionButtonTriggerDirective implements OnInit, OnDestroy {
-    private readonly cdRef;
-    private _workingSub;
-    private _disabledSub;
+    private readonly _workingSub;
+    private readonly _disabledSub;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never, never, true, never>;
 }

package/lib/button/action/action.button.trigger.directive.d.ts

@@ -1,5 +1,5 @@
 import { OnInit } from '@angular/core';
-import { AbstractSubscriptionDirective } from '../../subscription';
+import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxButton } from '../button';
 import { DbxActionContextStoreSourceInstance } from '../../action/action.store.source';
 import * as i0 from "@angular/core";
@@ -12,5 +12,5 @@ export declare class DbxActionButtonTriggerDirective extends AbstractSubscriptio
     ngOnInit(): void;
     protected _buttonClicked(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never, never, true, never>;
 }

package/lib/button/button.d.ts

@@ -15,44 +15,85 @@ export interface DbxButtonInterceptor {
 /**
  * Text and icon display content for a button.
  */
-export interface DbxButtonDisplayContent {
+export interface DbxButtonDisplay {
     /**
      * button Icon, if applicable
      */
-    icon?: Maybe<string>;
+    readonly icon?: Maybe<string>;
     /**
      * button text, if applicable
      */
-    text?: Maybe<string>;
+    readonly text?: Maybe<string>;
 }
-export declare abstract class DbxButton implements DbxButtonDisplayContent {
+export declare abstract class DbxButton {
+    /**
+     * Observable of the disabled state of the button.
+     */
     abstract readonly disabled$: Observable<boolean>;
+    /**
+     * Observable of the working state of the button.
+     */
     abstract readonly working$: Observable<boolean>;
-    abstract disabled: Maybe<boolean>;
-    abstract working: Maybe<boolean>;
-    abstract icon?: Maybe<string>;
-    abstract text?: Maybe<string>;
+    /**
+     * Observable of the clicked event of the button.
+     */
     abstract readonly clicked$: Observable<unknown>;
+    /**
+     * Observable of the display content of the button.
+     */
+    abstract readonly display$: Observable<DbxButtonDisplay>;
+    /**
+     * Sets the disabled state of the button. If null/undefined the button will be disabled.
+     *
+     * @param disabled
+     */
+    abstract setDisabled(disabled?: Maybe<boolean>): void;
+    /**
+     * Sets the working state of the button. IF null/undefined the button will be marked as working.
+     *
+     * @param working
+     */
+    abstract setWorking(working?: Maybe<boolean>): void;
+    /**
+     * Sets the display content of the button.
+     *
+     * @param content
+     */
+    abstract setDisplayContent(content: DbxButtonDisplay): void;
+    /**
+     * Sets the button interceptor. If any interceptor is already set, it is replaced.
+     *
+     * @param interceptor
+     */
     abstract setButtonInterceptor(interceptor: DbxButtonInterceptor): void;
+    /**
+     * Main function to use for handling clicks on the button.
+     */
     abstract clickButton(): void;
 }
 export declare function provideDbxButton<S extends DbxButton>(sourceType: Type<S>): Provider[];
-export type DbxButtonDisplayContentType = 'text_button' | 'icon_button';
 /**
- * Delegate class used for retrieving the DbxButtonDisplayContent given an input value.
+ * The display type of a button.
+ *
+ * text_button: A text button has text or is empty.
+ * icon_button: An icon button only has an icon and no text.
+ */
+export type DbxButtonDisplayType = 'text_button' | 'icon_button';
+/**
+ * Delegate class used for retrieving the DbxButtonDisplay given an input value.
  */
 export interface DbxButtonDisplayDelegate<T> {
     /**
-     * Returns the DbxButtonDisplayContent for the input value.
+     * Returns the DbxButtonDisplay for the input value.
      *
      * @param value
      */
-    buttonDisplayContentForValue(value: T): DbxButtonDisplayContent;
+    buttonDisplayContentForValue(value: T): DbxButtonDisplay;
 }
 /**
- * Returns the DbxButtonDisplayContentType given the input content.
+ * Returns the DbxButtonDisplayType given the input content.
  *
  * @param content
  * @returns
  */
-export declare function dbxButtonDisplayContentType(content: DbxButtonDisplayContent): DbxButtonDisplayContentType;
+export declare function dbxButtonDisplayType(content: DbxButtonDisplay): DbxButtonDisplayType;