@dereekb/dbx-core 2.1.0 → 3.0.0

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>;
+}

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

@@ -0,0 +1,32 @@
+import { InjectionToken } from '@angular/core';
+import { ArrayOrValue, Maybe } from '@dereekb/util';
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { DbxAppContextState } from '../../../../context/context';
+import { AbstractOnDbxAppContextStateEffects } from '../../../../context/state/effect';
+import { fromDbxAppAuth } from '../../../state';
+import { DbxAppAuthRouterService } from '../../auth.router.service';
+import * as i0 from "@angular/core";
+/**
+ * Used by DbxAppAuthRouterEffects to configure the states that should be activve by default.
+ */
+export declare const DBX_APP_AUTH_ROUTER_EFFECTS_TOKEN: InjectionToken<unknown>;
+/**
+ * Set of ngrx effects that handle navigation in the app when the auth changes in certain ways.
+ *
+ * Is configurable via the DBX_APP_AUTH_ROUTER_EFFECTS_TOKEN to choose which states this effect is active or not. By default is equal to DBX_KNOWN_APP_CONTEXT_STATES.
+ */
+export declare class DbxAppAuthRouterEffects extends AbstractOnDbxAppContextStateEffects<fromDbxAppAuth.State> {
+    readonly dbxAppAuthRouterService: DbxAppAuthRouterService;
+    constructor(activeStates: Maybe<ArrayOrValue<DbxAppContextState>>, actions$: Actions, store: Store<fromDbxAppAuth.State>, dbxAppAuthRouterService: DbxAppAuthRouterService);
+    /**
+     * Effect to redirect to the login when logout occurs.
+     */
+    readonly redirectToLoginOnLogout: import("rxjs").Observable<boolean> & import("@ngrx/effects").CreateEffectMetadata;
+    /**
+     * Effect to redirect to the app when login occurs.
+     */
+    readonly redirectToOnboardOnLogIn: import("rxjs").Observable<boolean> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthRouterEffects, [{ optional: true; }, null, null, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthRouterEffects>;
+}

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

@@ -0,0 +1 @@
+export * from './auth.router.state.effect';

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

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

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

@@ -0,0 +1,46 @@
+import { Observable } from 'rxjs';
+import { AuthRoleSet } from '@dereekb/util';
+import { AuthUserIdentifier, AuthUserState } from '../auth.user';
+/**
+ * Client auth service used to retrieve info about the current state of client authentication and client roles they may have.
+ */
+export declare abstract class DbxAuthService {
+    /**
+     * Whether or not the user is logged in.
+     *
+     * This will only emit once the authentication has been determined, preventing issues with premature decision making.
+     *
+     * A user is considered logged in even if there is an anonymous user. For more detailed info, consider using authUserState$.
+     */
+    abstract readonly isLoggedIn$: Observable<boolean>;
+    /**
+     * Whether or not the user has finished onboarding.
+     *
+     * This will only emit once the onboarding status has been determined, preventing issues with premature decision making.
+     */
+    abstract readonly isOnboarded$: Observable<boolean>;
+    /**
+     * Emits an event every time the user logs in.
+     */
+    abstract readonly onLogIn$: Observable<void>;
+    /**
+     * Emits an event every time the user logs out.
+     */
+    abstract readonly onLogOut$: Observable<void>;
+    /**
+     * Current state of the user.
+     */
+    abstract readonly authUserState$: Observable<AuthUserState>;
+    /**
+     * Role set for the current user.
+     */
+    abstract readonly authRoles$: Observable<AuthRoleSet>;
+    /**
+     * Identifier for the current user.
+     */
+    abstract readonly userIdentifier$: Observable<AuthUserIdentifier>;
+    /**
+     * Performs the logout action.
+     */
+    abstract logOut(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+import { AuthRole, AuthRoleSet, Maybe } from '@dereekb/util';
+import { Observable, OperatorFunction } from 'rxjs';
+/**
+ * Convenience operator that emits events when the input observable goes from false to true.
+ *
+ * @param isLoggedInObs
+ * @returns
+ */
+export declare function loggedInObsFromIsLoggedIn(isLoggedInObs: Observable<boolean>): Observable<void>;
+/**
+ * Convenience operator that emits events when the input observable goes from true to false.
+ *
+ * @param isLoggedInObs
+ * @returns
+ */
+export declare function loggedOutObsFromIsLoggedIn(isLoggedInObs: Observable<boolean>): Observable<void>;
+export declare function authRolesSetContainsAllRolesFrom(roles: Observable<Maybe<Iterable<AuthRole>>>): OperatorFunction<AuthRoleSet, boolean>;
+export declare function authRolesSetContainsAnyRoleFrom(roles: Observable<Maybe<Iterable<AuthRole>>>): OperatorFunction<AuthRoleSet, boolean>;

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

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

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

@@ -0,0 +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">>;
+/**
+ * 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">>;
+/**
+ * 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">>;

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

@@ -0,0 +1,11 @@
+import * as DbxAppAuthActions from './auth.action';
+import * as DbxAppAuthUserActions from './user.action';
+export { 
+/**
+ * Actions related to the auth state.
+ */
+DbxAppAuthActions, 
+/**
+ * Actions related to the user.
+ */
+DbxAppAuthUserActions };

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

@@ -0,0 +1,34 @@
+import { AuthRole } from '@dereekb/util';
+import { AuthUserIdentifier, AuthUserState } from '../../auth.user';
+/**
+ * Sets the user's identifier in the auth.
+ */
+export declare const setUserIdentifier: import("@ngrx/store").ActionCreator<"[App/Auth] Set User Identifier", (props: {
+    id: AuthUserIdentifier;
+}) => {
+    id: AuthUserIdentifier;
+} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Identifier">>;
+/**
+ * Sets the user's state in the auth.
+ */
+export declare const setUserState: import("@ngrx/store").ActionCreator<"[App/Auth] Set User State", (props: {
+    state: AuthUserState;
+}) => {
+    state: AuthUserState;
+} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User State">>;
+/**
+ * Sets the user's roles in the auth.
+ */
+export declare const setUserRoles: import("@ngrx/store").ActionCreator<"[App/Auth] Set User Roles", (props: {
+    roles: AuthRole[];
+}) => {
+    roles: AuthRole[];
+} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Roles">>;
+/**
+ * Sets the user's onboarding state.
+ */
+export declare const setUserIsOnboarded: import("@ngrx/store").ActionCreator<"[App/Auth] Set User Is Onboarded", (props: {
+    isOnboarded: boolean;
+}) => {
+    isOnboarded: boolean;
+} & import("@ngrx/store/src/models").TypedAction<"[App/Auth] Set User Is Onboarded">>;

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

@@ -0,0 +1,31 @@
+import { Actions } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { DbxAuthService } from '../../service';
+import * as fromDbxAppAuth from '../reducer';
+import * as i0 from "@angular/core";
+/**
+ * Set of ngrx effects that repeat events from DbxAuthService.
+ */
+export declare class DbxAppAuthEffects {
+    private readonly actions$;
+    private readonly store;
+    private readonly dbxAuthService;
+    constructor(actions$: Actions, store: Store<fromDbxAppAuth.State>, dbxAuthService: DbxAuthService);
+    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 setUserIdentifier: import("rxjs").Observable<{
+        id: string;
+    } & import("@ngrx/store/src/models").TypedAction<"[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;
+    readonly setUserRoles: import("rxjs").Observable<{
+        roles: string[];
+    } & import("@ngrx/store/src/models").TypedAction<"[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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthEffects>;
+}

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

@@ -0,0 +1,12 @@
+import * as fromDbxAppAuth from './reducer';
+import * as onDbxAppAuth from './action';
+export * from './state';
+export { 
+/**
+ * Accessor for the DbxAppAuthFeatureState reducers.
+ */
+fromDbxAppAuth, 
+/**
+ * Accessor for the DbxAppAuthFeatureState actions.
+ */
+onDbxAppAuth };

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

@@ -0,0 +1,29 @@
+import { Action } from '@ngrx/store';
+import * as fromDbxAppAuthUserState from './user.reducer';
+/**
+ * Global feature key
+ */
+export declare const featureKey = "app.auth";
+export interface DbxAppAuthFeatureState {
+    [fromDbxAppAuthUserState.dbxAppAuthUserFeatureKey]: fromDbxAppAuthUserState.DbxAppAuthStateUser;
+}
+/**
+ * Interface typing extension for the DbxAppAuthFeatureState, and the typing information for how this feature extends the base state.
+ */
+export interface State {
+    [featureKey]: DbxAppAuthFeatureState;
+}
+/**
+ * Reducers mapping for the DbxAppAuthFeatureState
+ */
+export declare function reducers(state: DbxAppAuthFeatureState | undefined, action: Action): {
+    user: fromDbxAppAuthUserState.DbxAppAuthStateUser;
+};
+/**
+ * Selects the DbxAppAuthFeatureState feature context.
+ */
+export declare const selectAppAuthFeature: import("@ngrx/store").MemoizedSelector<object, DbxAppAuthFeatureState, import("@ngrx/store").DefaultProjectorFn<DbxAppAuthFeatureState>>;
+/**
+ * Selector to retrieve the state value from our DbxAppContextStateData in our DbxAppContextFeatureState.
+ */
+export declare const selectDbxAppAuthUser: import("@ngrx/store").MemoizedSelector<object, fromDbxAppAuthUserState.DbxAppAuthStateUser, import("@ngrx/store").DefaultProjectorFn<fromDbxAppAuthUserState.DbxAppAuthStateUser>>;

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

@@ -0,0 +1,11 @@
+import { AuthUserIdentifier, AuthUserState } from '../../auth.user';
+import { AuthRole } from '@dereekb/util';
+export declare const dbxAppAuthUserFeatureKey = "user";
+export interface DbxAppAuthStateUser {
+    userId: AuthUserIdentifier;
+    isOnboarded: boolean;
+    userState: AuthUserState;
+    userRoles: AuthRole[];
+}
+export declare const initialState: DbxAppAuthStateUser;
+export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppAuthStateUser, import("@ngrx/store").Action>;

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

@@ -0,0 +1,5 @@
+import * as fromDbxAppAuth from './reducer';
+/**
+ * Type that contains the dbx-core contextual ngrx state information for auth.
+ */
+export declare type DbxAppAuthFullState = fromDbxAppAuth.State;

package/lib/button/button.d.ts

@@ -13,13 +13,13 @@ export interface DbxButtonInterceptor {
     interceptButtonClick: () => Observable<boolean>;
 }
 export declare abstract class DbxButton {
-    abstract disabled$: Observable<boolean>;
-    abstract working$: Observable<boolean>;
+    abstract readonly disabled$: Observable<boolean>;
+    abstract readonly working$: Observable<boolean>;
     abstract disabled: Maybe<boolean>;
     abstract working: Maybe<boolean>;
     abstract icon?: Maybe<string>;
     abstract text?: Maybe<string>;
-    abstract clicked$: Observable<any>;
+    abstract readonly clicked$: Observable<any>;
     abstract setButtonInterceptor(interceptor: DbxButtonInterceptor): void;
     abstract clickButton(): void;
 }

package/lib/button/router/button.segue.directive.d.ts

@@ -13,6 +13,7 @@ export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirecti
     set segueRef(segueRef: Maybe<SegueRef>);
     constructor(dbxButton: DbxButton, dbxRouterService: DbxRouterService);
     ngOnInit(): void;
+    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": "dbxButtonSegue"; }, {}, never>;
 }

package/lib/context/context.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A contextual state identifier for a specific section of the app.
+ *
+ * Some examples are:
+ * - init: The default context that is initialized.
+ * - public: A public part of the app.
+ * - onboarding: The onboarding section of the app.
+ * - app: The main portion of the app.
+ *
+ * More complex apps may have more sub-sections or app portions that could each have their own context state.
+ */
+export declare type DbxAppContextState = string;
+export declare const DBX_INIT_APP_CONTEXT_STATE = "init";
+/**
+ *
+ */
+export declare const DBX_PUBLIC_APP_CONTEXT_STATE = "public";
+/**
+ *
+ */
+export declare const DBX_AUTH_APP_CONTEXT_STATE = "auth";
+/**
+ *
+ */
+export declare const DBX_ONBOARDING_APP_CONTEXT_STATE = "onboarding";
+/**
+ *
+ */
+export declare const DBX_APP_APP_CONTEXT_STATE = "app";
+/**
+ * Default AppContextStates.
+ *
+ * Your app may not use these, but this type is available for convenience.
+ */
+export declare type DbxKnownAppContextState = typeof DBX_INIT_APP_CONTEXT_STATE | typeof DBX_PUBLIC_APP_CONTEXT_STATE | typeof DBX_AUTH_APP_CONTEXT_STATE | typeof DBX_ONBOARDING_APP_CONTEXT_STATE | typeof DBX_APP_APP_CONTEXT_STATE;
+/**
+ * Array of all DbxKnownAppContextState values, minus the init state.
+ */
+export declare const DBX_KNOWN_APP_CONTEXT_STATES: DbxKnownAppContextState[];

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

@@ -0,0 +1,19 @@
+import { OnDestroy, OnInit } from "@angular/core";
+import { DbxAppContextService } from "./context.service";
+import { AbstractSubscriptionDirective } from '../subscription';
+import { DbxAppContextState } from './context';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Used to set the DbxAppContextState for an app to the input state using the DbxAppContextService.
+ */
+export declare class DbxAppContextStateDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxAppContextStateService: DbxAppContextService;
+    private _state;
+    constructor(dbxAppContextStateService: DbxAppContextService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    set state(state: Maybe<DbxAppContextState>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAppContextStateDirective, "[dbxAppContextState]", never, { "state": "dbxAppContextState"; }, {}, never>;
+}

package/lib/context/context.module.d.ts

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

package/lib/context/context.service.d.ts

@@ -0,0 +1,16 @@
+import { Store } from "@ngrx/store";
+import { DbxAppContextState } from './context';
+import { DbxAppContextFullState } from "./state/state";
+import * as i0 from "@angular/core";
+/**
+ * State for accessing the app's DbxAppContextState defined within the DbxAppContextFullState for the ngrx store.
+ */
+export declare class DbxAppContextService {
+    readonly store: Store<DbxAppContextFullState>;
+    readonly state$: import("rxjs").Observable<string>;
+    constructor(store: Store<DbxAppContextFullState>);
+    setState(state: DbxAppContextState): void;
+    resetState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppContextService>;
+}

package/lib/context/index.d.ts

@@ -0,0 +1,5 @@
+export * from './state';
+export * from './context';
+export * from './context.directive';
+export * from './context.module';
+export * from './context.service';

package/lib/context/state/action/data.action.d.ts

@@ -0,0 +1,13 @@
+import { DbxAppContextState } from '../../context';
+/**
+ * Action to set the current DbxAppContextState value.
+ */
+export declare const setState: import("@ngrx/store").ActionCreator<"[App/Context] Set State", (props: {
+    state: DbxAppContextState;
+}) => {
+    state: DbxAppContextState;
+} & import("@ngrx/store/src/models").TypedAction<"[App/Context] Set State">>;
+/**
+ * Resets the app back to the init context.
+ */
+export declare const resetState: import("@ngrx/store").ActionCreator<"[App/Context] Reset", () => import("@ngrx/store/src/models").TypedAction<"[App/Context] Reset">>;

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

@@ -0,0 +1,6 @@
+import * as DbxAppContextActions from './data.action';
+export { 
+/**
+ * Accessor for the DbxAppContextStateData in our DbxAppContextFeatureState.
+ */
+DbxAppContextActions };

package/lib/context/state/effect/index.d.ts

@@ -0,0 +1,39 @@
+import { OnRunEffects, Actions, EffectNotification } from '@ngrx/effects';
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import { DbxAppContextState } from '../../context';
+import { ArrayOrValue } from '@dereekb/util';
+/**
+ * Abstract effects class that only runs/allows effects when the DbxAppContextState in the ngrx state matches input activeState value.
+ */
+export declare abstract class AbstractOnDbxAppContextStateEffects<S = any> implements OnRunEffects {
+    /**
+     * ngrx Actions
+     */
+    protected readonly actions$: Actions;
+    /**
+     * ngrx Store
+     */
+    protected readonly store: Store<S>;
+    private _activeStatesSet;
+    constructor(
+    /**
+     * The state(s) to activate on.
+     */
+    activeStates: ArrayOrValue<DbxAppContextState>, 
+    /**
+     * ngrx Actions
+     */
+    actions$: Actions, 
+    /**
+     * ngrx Store
+     */
+    store: Store<S>);
+    /**
+     * Configures all actions of the sub-class to only activate when the DbxAppContextState in App
+     *
+     * @param resolvedEffects$
+     * @returns
+     */
+    ngrxOnRunEffects(resolvedEffects$: Observable<EffectNotification>): Observable<EffectNotification>;
+}

package/lib/context/state/index.d.ts

@@ -0,0 +1,12 @@
+import * as fromDbxAppContext from './reducer';
+import * as onDbxAppContext from './action';
+export * from './state';
+export { 
+/**
+ * Accessor for the DbxAppContextFeatureState reducers.
+ */
+fromDbxAppContext, 
+/**
+ * Accessor for the DbxAppContextFeatureState actions.
+ */
+onDbxAppContext };

package/lib/context/state/reducer/data.reducer.d.ts

@@ -0,0 +1,13 @@
+import { DbxAppContextState } from '../../context';
+/**
+ * The feature key for these items/reducers.
+ */
+export declare const dbxAppContextStateFeatureKey = "data";
+/**
+ * The typings for this feature.
+ */
+export interface DbxAppContextStateData {
+    state: DbxAppContextState;
+}
+export declare const initialState: DbxAppContextStateData;
+export declare const reducer: import("@ngrx/store").ActionReducer<DbxAppContextStateData, import("@ngrx/store").Action>;

package/lib/context/state/reducer/index.d.ts

@@ -0,0 +1,34 @@
+import { Action } from '@ngrx/store';
+import * as fromDbxAppContextState from './data.reducer';
+/**
+ * Global feature key for our app.
+ */
+export declare const featureKey = "app.context";
+/**
+ * This is a "feature state", which in this case is a single feature (our app state), but could include keys/states within this feature.
+ */
+export interface DbxAppContextFeatureState {
+    [fromDbxAppContextState.dbxAppContextStateFeatureKey]: fromDbxAppContextState.DbxAppContextStateData;
+}
+/**
+ * Interface typing extension for the DbxAppContextFeatureState, and the typing information for how this feature extends the base state.
+ */
+export interface State {
+    [featureKey]: DbxAppContextFeatureState;
+}
+/**
+ * Reducers mapping for the DbxAppContextFeatureState
+ */
+export declare function reducers(state: DbxAppContextFeatureState | undefined, action: Action): {
+    data: fromDbxAppContextState.DbxAppContextStateData;
+};
+/**
+ * Selects the DbxAppContextFeatureState feature context.
+ *
+ * Used by createSelector() to retrieve more specific data from the DbxAppContextFeatureState.
+ */
+export declare const selectAppContextFeature: import("@ngrx/store").MemoizedSelector<object, DbxAppContextFeatureState, import("@ngrx/store").DefaultProjectorFn<DbxAppContextFeatureState>>;
+/**
+ * Selector to retrieve the state value from our DbxAppContextStateData in our DbxAppContextFeatureState.
+ */
+export declare const selectDbxAppContextState: import("@ngrx/store").MemoizedSelector<object, string, import("@ngrx/store").DefaultProjectorFn<string>>;

package/lib/context/state/state.d.ts

@@ -0,0 +1,9 @@
+import * as fromDbxAppContext from './reducer';
+/**
+ * Type that contains the dbx-core contextual ngrx state information about an app's context.
+ *
+ * This is the "full state" of our DbxAppContext. It is the sum of the fromDbxContext.State interface.
+ *
+ * Sub-state types that need to be aware of this typeing may extend (via union) this type.
+ */
+export declare type DbxAppContextFullState = fromDbxAppContext.State;

package/lib/filter/filter.abstract.source.directive.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { OnDestroy, OnInit } from '@angular/core';
-import { FilterSource, FilterSourceInstance, ObservableGetter } from '@dereekb/rxjs';
+import { FilterSource, FilterSourceInstance, ObservableOrValue } from '@dereekb/rxjs';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
@@ -14,7 +14,7 @@ export declare abstract class AbstractFilterSourceDirective<F> implements Filter
     initWithFilter(filterObs: Observable<F>): void;
     setFilter(filter: F): void;
     resetFilter(): void;
-    protected makeDefaultFilter(): ObservableGetter<Maybe<F>>;
+    protected makeDefaultFilter(): ObservableOrValue<Maybe<F>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceDirective<any>, never, never, {}, {}, never>;
 }

package/lib/index.d.ts

@@ -1,9 +1,13 @@
 export * from './action';
+export * from './auth';
 export * from './button';
+export * from './context';
 export * from './router';
 export * from './pipe';
 export * from './filter';
-export * from './injected';
+export * from './injection';
+export * from './ngrx';
 export * from './storage';
 export * from './subscription';
 export * from './util';
+export * from './view';

package/lib/injection/index.d.ts

@@ -0,0 +1,8 @@
+export * from './injection.component.module';
+export * from './injection.component';
+export * from './injection.context.directive';
+export * from './injection.context.forward.directive';
+export * from './injection.context';
+export * from './injection.instance';
+export * from './injection.directive';
+export * from './injection';

package/lib/injection/injection.component.d.ts

@@ -0,0 +1,15 @@
+import { ViewContainerRef } from '@angular/core';
+import { DbxInjectionComponentConfig, DbxInjectionTemplateConfig } from './injection';
+import { AbstractDbxInjectionDirective } from './injection.directive';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Component that injects content based on the configuration into the view.
+ */
+export declare class DbxInjectionComponent<T> extends AbstractDbxInjectionDirective<T> {
+    set config(config: Maybe<DbxInjectionComponentConfig<T>>);
+    set template(template: Maybe<DbxInjectionTemplateConfig<T>>);
+    set content(content: Maybe<ViewContainerRef>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionComponent<any>, "dbx-injection, [dbxInjection], [dbx-injection]", never, { "config": "config"; "template": "template"; }, {}, never, never>;
+}

package/lib/injection/injection.component.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./injection.component";
+import * as i2 from "./injection.context.directive";
+import * as i3 from "@angular/common";
+export declare class DbxInjectionComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxInjectionComponentModule, [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionContextDirective], [typeof i3.CommonModule], [typeof i1.DbxInjectionComponent, typeof i2.DbxInjectionContextDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxInjectionComponentModule>;
+}