@dereekb/dbx-core 12.6.21 → 13.0.0

package/types/dereekb-dbx-core.d.ts

@@ -0,0 +1,3633 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, Signal, OnInit, Type, Provider, Injector, EnvironmentProviders, InjectionToken, StaticProvider, NgModuleRef, TemplateRef, ViewRef, ModuleWithProviders, NgZone, PipeTransform, ViewContainerRef, ComponentRef, AbstractType, ElementRef, ChangeDetectorRef } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, OperatorFunction, Subject, BehaviorSubject, MonoTypeOperatorFunction, Unsubscribable } from 'rxjs';
+import * as _dereekb_rxjs from '@dereekb/rxjs';
+import { LoadingStateType, LoadingState, LockSet, MaybeObservableOrValue, IsCheckFunction, ObservableOrValue, Work, IsModifiedFunction, IsEqualFunction, WorkInstanceDelegate, LoadingContext, MaybeObservableOrValueGetter, SwitchMapToDefaultFilterFunction, ObservableOrValueGetter, FilterSourceConnector, FilterSource, FilterSourceInstance, FilterMap, FilterMapKey, FilterWithPreset, FilterPresetStringRef, FilterWithPresetOptional, DestroyOnNextUnlockConfig, SubscriptionObject, ListLoadingState, ListLoadingStateContextInput, MutableListLoadingStateContext, LoadingContextEvent, LoadingStateContextInput, MutableLoadingStateContext } from '@dereekb/rxjs';
+import * as _dereekb_util from '@dereekb/util';
+import { PercentNumber, Maybe, ReadableError, BooleanStringKeyArray, Destroyable, Initialized, GetterOrValue, FactoryWithInput, ArrayOrValue, AuthRoleSet, Milliseconds, FactoryWithRequiredInput, ObjectMap, AuthRole, SetIncludesMode, IterableOrValue, WebsiteUrl, MailToUrlInput, PhoneNumber, E164PhoneNumberWithOptionalExtension, TreeNode, ExpandTreeFunction, FlattenTreeFunction, ModelKey, DateOrDateString, TimezoneString, EmptyObject, ModelKeyRef, StoredDataString, ReadStoredData, StoredData, StoredDataStorageKey, FullStorageObject, StorageObject, DestroyFunction, DestroyFunctionObject } from '@dereekb/util';
+import { ComponentStore } from '@ngrx/component-store';
+import * as _dereekb_dbx_core from '@dereekb/dbx-core';
+import * as _uirouter_core from '@uirouter/core';
+import { Transition, UIInjector, TransitionHookFn, TransitionService, HookMatchCriteria, StateService, UIRouterGlobals, TransitionOptions } from '@uirouter/core';
+import * as _ngrx_effects from '@ngrx/effects';
+import { OnRunEffects, Actions, EffectNotification } from '@ngrx/effects';
+import * as _ngrx_store from '@ngrx/store';
+import { Action, Store } from '@ngrx/store';
+import { Router, ActivatedRoute, NavigationExtras, NavigationBehaviorOptions } from '@angular/router';
+import { DateRange, FormatDateRangeDistanceFunctionConfig } from '@dereekb/date';
+
+/**
+ * Used to denote the percent progress of a working action.
+ *
+ * This is a PercentNumber, a number between 0 and 100.
+ */
+type DbxActionWorkProgress = PercentNumber;
+/**
+ * Used for denoting working state or progress.
+ *
+ * True is working, but no progress level.
+ */
+type DbxActionWorkOrWorkProgress = boolean | DbxActionWorkProgress;
+/**
+ * Creates a working progress value from an array of working progress values.
+ *
+ * @param workOrWorkProgress The array of working progress values to use.
+ * @param progressPercent An optional progress percent value to use if the working progress is a boolean.
+ * @returns The working progress value.
+ */
+declare function dbxActionWorkProgress(workOrWorkProgress: Maybe<DbxActionWorkOrWorkProgress>[], progressPercent?: Maybe<DbxActionWorkProgress>): number | boolean;
+/**
+ * Used by ActionContextState to denote what state the action is in.
+ */
+declare enum DbxActionState {
+    /**
+     * No action in progress. Waiting for the trigger.
+     */
+    IDLE = "idle",
+    /**
+     * Idle state that can be set to show that the source is not yet ready.
+     */
+    DISABLED = "disabled",
+    /**
+     * The action was triggered. We wait (and allow) the value to be updated.
+     */
+    TRIGGERED = "triggered",
+    /**
+     * The trigger was accepted and the value is updated. It should begin working immediately.
+     *
+     * ValueReady cannot be set until triggered is set.
+     */
+    VALUE_READY = "valueReady",
+    /**
+     * The action is in progress.
+     */
+    WORKING = "working",
+    /**
+     * The trigger, action, or value was rejected due to an error or other issue.
+     *
+     * An error may be specified optionally.
+     */
+    REJECTED = "rejected",
+    /**
+     * The action resolved without issue.
+     */
+    RESOLVED = "resolved"
+}
+/**
+ * Contains the input value and the output result from a DbxAction.
+ */
+interface DbxActionSuccessPair<T, O> {
+    readonly value: T;
+    readonly result: Maybe<O>;
+}
+/**
+ * Contains the input value and the output error from a DbxAction.
+ */
+interface DbxActionRejectedPair<T> {
+    readonly value: T;
+    readonly error: unknown;
+}
+/**
+ * Unique key for disabling/enabling.
+ */
+type DbxActionDisabledKey = string;
+declare const DEFAULT_ACTION_DISABLED_KEY = "dbx_action_disabled";
+declare function isIdleActionState(actionState: DbxActionState): boolean;
+declare function loadingStateTypeForActionState(actionState: DbxActionState): LoadingStateType;
+
+declare function isActionContextEnabled(state: ActionContextState): boolean;
+declare function isActionContextDisabled(state: ActionContextState): boolean;
+declare function isDisabledActionContextState(state: ActionContextState): boolean;
+declare function isWorkingActionState(actionState: DbxActionState): boolean;
+declare function canTriggerActionState(actionState: DbxActionState): boolean;
+declare function canTriggerAction(state: ActionContextState): boolean;
+declare function canReadyValue(state: ActionContextState): boolean;
+declare function actionContextIsModifiedAndCanTrigger(state: ActionContextState): boolean;
+declare function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state: ActionContextState): boolean;
+declare function loadingStateForActionContextState<O = unknown>(state: ActionContextState<unknown, O>): LoadingState<O>;
+declare function loadingStateTypeForActionContextState(state: ActionContextState): LoadingStateType;
+interface ActionContextState<T = unknown, O = unknown> {
+    readonly actionState: DbxActionState;
+    /**
+     * Whether or not this action is flagged as having been modified.
+     */
+    readonly isModified: boolean;
+    /**
+     * The working progress of the action.
+     *
+     * Is reset to null when triggered/ready value is set.
+     */
+    readonly workProgress?: Maybe<DbxActionWorkProgress>;
+    /**
+     * Value that is set after a triggered action. Not to be confused with result.
+     */
+    readonly value?: Maybe<T>;
+    /**
+     * Resolved result value.
+     */
+    readonly result?: Maybe<O>;
+    /**
+     * Rejected error, if available.
+     */
+    readonly error?: Maybe<ReadableError>;
+    /**
+     * Current disabled state.
+     */
+    readonly disabled?: BooleanStringKeyArray;
+    /**
+     * Number of consecutive errors that have occured.
+     */
+    readonly errorCount?: number;
+}
+declare class ActionContextStore<T = unknown, O = unknown> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {
+    readonly lockSet: _dereekb_rxjs.LockSet;
+    constructor();
+    readonly actionState$: Observable<DbxActionState>;
+    /**
+     * Returns the current disabled reasons/keys.
+     */
+    readonly disabledKeys$: Observable<string[]>;
+    /**
+     * Current value of the state.
+     */
+    readonly currentValue$: Observable<Maybe<T>>;
+    /**
+     * Maps the current state to true or not when the action state changes to/from disabled.
+     */
+    readonly isDisabled$: Observable<boolean>;
+    /**
+     * Pipes when idle but modified.
+     */
+    readonly isModified$: Observable<boolean>;
+    /**
+     * Pipes true when idle.
+     */
+    readonly idle$: Observable<boolean>;
+    /**
+     * Pipes true when triggered.
+     */
+    readonly triggered$: Observable<boolean>;
+    /**
+     * Pipes the readied value on ValueReady.
+     */
+    readonly valueReady$: Observable<T>;
+    /**
+     * Pipes the working progress on the working state.
+     */
+    readonly workProgress$: Observable<Maybe<number>>;
+    /**
+     * Pipes the error on the rejection state.
+     */
+    readonly rejected$: Observable<Maybe<ReadableError>>;
+    /**
+     * Pipes the result when the ActionState becomes rejected.
+     */
+    readonly rejectedPair$: Observable<DbxActionRejectedPair<T>>;
+    /**
+     * Pipes the result when the ActionState becomes working.
+     */
+    readonly working$: Observable<boolean>;
+    /**
+     * Whether or not it is currently in a working state.
+     */
+    readonly isWorking$: Observable<boolean>;
+    /**
+     * Pipes the current work or work progress.
+     */
+    readonly isWorkingOrWorkProgress$: Observable<DbxActionWorkOrWorkProgress>;
+    /**
+     * Pipes the current error.
+     */
+    readonly error$: Observable<Maybe<ReadableError>>;
+    /**
+     * Pipes the result when the ActionState becomes success.
+     */
+    readonly success$: Observable<Maybe<O>>;
+    /**
+     * Pipes the result when the ActionState becomes success.
+     */
+    readonly successPair$: Observable<DbxActionSuccessPair<T, O>>;
+    /**
+     * Whether or not it is currently in a success state.
+     */
+    readonly isSuccess$: Observable<boolean>;
+    /**
+     * Returns a loading state based on the current state.
+     */
+    readonly loadingState$: Observable<LoadingState<O>>;
+    /**
+     * Returns the current LoadingStateType based on the current state.
+     */
+    readonly loadingStateType$: Observable<LoadingStateType>;
+    /**
+     * Number of errors since last success.
+     */
+    readonly errorCountSinceLastSuccess$: Observable<number>;
+    /**
+     * Whether or not the state can be triggered.
+     */
+    readonly canTrigger$: Observable<boolean>;
+    /**
+     * Pipe that maps whether or not this is modified and can be triggered.
+     *
+     * Updates every state update instead of when the value changes.
+     */
+    readonly isModifiedAndCanTriggerUpdates$: Observable<boolean>;
+    /**
+     * Whether or not it can be triggered and modified.
+     */
+    readonly isModifiedAndCanTrigger$: Observable<boolean>;
+    readonly hasNoErrorAndIsModifiedAndCanTrigger$: Observable<boolean>;
+    /**
+     * Adds a disabled reason.
+     */
+    readonly disable: (() => void) | ((observableOrValue: string | void | Observable<string | void | undefined> | undefined) => rxjs.Subscription);
+    /**
+     * Removes a disabled reason.
+     */
+    readonly enable: (() => void) | ((observableOrValue: string | void | Observable<string | void | undefined> | undefined) => rxjs.Subscription);
+    /**
+     * Triggers the modified state, if not disabled.
+     *
+     * Equivalent to calling setIsModified() with opposite input.
+     */
+    readonly setIsSame: (() => void) | ((observableOrValue: boolean | void | Observable<boolean | void>) => rxjs.Subscription);
+    /**
+     * Triggers the modified state, if not disabled.
+     */
+    readonly setIsModified: (() => void) | ((observableOrValue: boolean | void | Observable<boolean | void>) => rxjs.Subscription);
+    /**
+     * Triggers the action if the state is currently not idle. The current state is cleared, but the error is retained (as we may need the error from the previous attempt).
+     *
+     * Will not fire if the action is disabled.
+     */
+    readonly trigger: () => void;
+    /**
+     * Updates the value, setting value ready. The current result is cleared.
+     */
+    readonly readyValue: T extends void ? () => void : (observableOrValue: T | Observable<T>) => rxjs.Subscription;
+    /**
+     * Notifys the context that the action is in progress.
+     */
+    readonly startWorking: () => void;
+    /**
+     * Updates the working progress.
+     */
+    readonly setWorkProgress: (() => void) | ((observableOrValue: Maybe<number> | Observable<Maybe<number>>) => rxjs.Subscription);
+    /**
+     * Triggers rejection of the action. The value is cleared.
+     */
+    readonly reject: (() => void) | ((observableOrValue: Maybe<ReadableError> | Observable<Maybe<ReadableError>>) => rxjs.Subscription);
+    /**
+     * Updates the state to success, and optionally sets a result.
+     *
+     * Clears modified state, and any errors.
+     */
+    readonly resolve: (() => void) | ((observableOrValue: Maybe<O> | Observable<Maybe<O>>) => rxjs.Subscription) | (O extends void ? () => void : (observableOrValue: Maybe<O> | Observable<Maybe<O>>) => rxjs.Subscription);
+    /**
+     * Completely resets the store.
+     */
+    readonly reset: () => void;
+    afterDistinctBoolean(fromState: (state: ActionContextState<T, O>) => boolean): Observable<boolean>;
+    afterDistinctActionState<X>(actionState: DbxActionState, fromState: (state: ActionContextState<T, O>) => X): Observable<X>;
+    afterDistinctActionStateChange(): Observable<ActionContextState<T, O>>;
+    afterDistinctLoadingStateTypeChange(): Observable<ActionContextState<T, O>>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionContextStore<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ActionContextStore<any, any>>;
+}
+
+/**
+ * Source that provides a ActionContextStore observable.
+ */
+declare abstract class ActionContextStoreSource<T = unknown, O = unknown> {
+    /**
+     * Observable referencing the ActionContextStore.
+     *
+     * This observable by design is pre-filtered to not return null values.
+     */
+    abstract readonly store$: Observable<ActionContextStore<T, O>>;
+}
+/**
+ * Secondary source. Used by DbxActionContextComponent to find secondary sources.
+ */
+declare abstract class SecondaryActionContextStoreSource<T = unknown, O = unknown> extends ActionContextStoreSource<T, O> {
+}
+declare function actionContextStoreSourcePipe<T, O>(obs: Observable<Maybe<ActionContextStore<T, O>>>): Observable<ActionContextStore<T, O>>;
+type PipeActionStoreFunction<R, T, O> = (store: ActionContextStore<T, O>) => Observable<R>;
+declare function pipeActionStore<R = unknown, T = unknown, O = unknown>(source: ActionContextStoreSource<T, O>, pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R>;
+type UseActionStoreFunction<T, O> = (store: ActionContextStore<T, O>) => void;
+/**
+ * Convenience function for subscribing to the input source once and using the provided store.
+ */
+declare function useActionStore<T = unknown, O = unknown>(source: ActionContextStoreSource<T, O>, useFn: UseActionStoreFunction<T, O>): Subscription;
+/**
+ * Service that wraps a ActionContextStoreSource.
+ */
+declare class DbxActionContextStoreSourceInstance<T = unknown, O = unknown> implements ActionContextStoreSource<T, O>, Destroyable {
+    readonly lockSet: LockSet;
+    private readonly _source;
+    constructor(source: ActionContextStoreSource<T, O>);
+    get source(): ActionContextStoreSource<T, O>;
+    destroy(): void;
+    get store$(): Observable<ActionContextStore<T, O>>;
+    pipeStore<R>(pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R>;
+    useStore(useFn: UseActionStoreFunction<T, O>): Subscription;
+    get state$(): Observable<ActionContextState<T, O>>;
+    get idle$(): Observable<boolean>;
+    get triggered$(): Observable<boolean>;
+    get valueReady$(): Observable<T>;
+    get success$(): Observable<Maybe<O>>;
+    get successPair$(): Observable<DbxActionSuccessPair<T, O>>;
+    get workProgress$(): Observable<Maybe<DbxActionWorkProgress>>;
+    get error$(): Observable<Maybe<ReadableError>>;
+    get rejected$(): Observable<Maybe<ReadableError>>;
+    get rejectedPair$(): Observable<DbxActionRejectedPair<T>>;
+    get isModified$(): Observable<boolean>;
+    get canTrigger$(): Observable<boolean>;
+    get isModifiedAndCanTriggerUpdates$(): Observable<boolean>;
+    get isModifiedAndCanTrigger$(): Observable<boolean>;
+    get actionState$(): Observable<DbxActionState>;
+    get loadingState$(): Observable<LoadingState<O>>;
+    get loadingStateType$(): Observable<LoadingStateType>;
+    get isWorking$(): Observable<boolean>;
+    get isWorkingOrWorkProgress$(): Observable<DbxActionWorkOrWorkProgress>;
+    get isSuccess$(): Observable<boolean>;
+    get disabledKeys$(): Observable<string[]>;
+    get isDisabled$(): Observable<boolean>;
+    get errorCountSinceLastSuccess$(): Observable<number>;
+    enable(key?: DbxActionDisabledKey, enable?: boolean): void;
+    disable(key?: DbxActionDisabledKey, disable?: boolean): void;
+    setIsSame(isSame?: boolean | Observable<boolean> | Observable<void>): void;
+    setIsModified(isModified?: boolean | Observable<boolean> | Observable<void>): void;
+    setWorkProgress(workProgress: MaybeObservableOrValue<DbxActionWorkProgress>): void;
+    trigger(): void;
+    triggerWithValue(value: T | Observable<T>): void;
+    readyValue(value: T | Observable<T>): void;
+    startWorking(): void;
+    reject(error: Maybe<ReadableError | Observable<ReadableError>>): void;
+    resolve(value: O | Observable<O>): void;
+    reset(): void;
+}
+
+declare class DbxActionAutoModifyDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly autoModifyEnabled: i0.InputSignalWithTransform<boolean, string | boolean>;
+    readonly markAsModified$: Observable<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoModifyDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoModifyDirective<any, any>, "dbxActionAutoModify, [dbxActionAutoModify]", never, { "autoModifyEnabled": { "alias": "dbxActionAutoModify"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that automatically triggers the action periodically when it is in a modified state.
+ *
+ * When using auto triggers be sure to make sure that the action is not triggering too often due to misconfiguration.
+ */
+declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly triggerDebounce: i0.InputSignal<Maybe<number>>;
+    readonly triggerThrottle: i0.InputSignal<Maybe<number>>;
+    readonly triggerErrorThrottle: i0.InputSignalWithTransform<number, Maybe<number>>;
+    readonly maxErrorsForThrottle: i0.InputSignalWithTransform<number, Maybe<number>>;
+    readonly triggerLimit: i0.InputSignal<Maybe<number>>;
+    readonly triggerEnabled: i0.InputSignalWithTransform<boolean, Maybe<string | boolean>>;
+    readonly useFastTriggerPreset: i0.InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly useInstantTriggerPreset: i0.InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly triggerDebounceSignal: Signal<number>;
+    readonly triggerThrottleSignal: Signal<number>;
+    readonly triggerCountSignal: i0.WritableSignal<number>;
+    readonly _errorCount$: Observable<number>;
+    readonly _triggerCount$: Observable<number>;
+    /**
+     * Observable for the trigger mechanism.
+     */
+    readonly triggerCount$: Observable<number>;
+    private readonly _isTriggerLimited$;
+    readonly isTriggerAllowedToRun$: Observable<boolean>;
+    readonly automaticTrigger$: Observable<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoTriggerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoTriggerDirective<any, any>, "dbxActionAutoTrigger,[dbxActionAutoTrigger]", never, { "triggerDebounce": { "alias": "triggerDebounce"; "required": false; "isSignal": true; }; "triggerThrottle": { "alias": "triggerThrottle"; "required": false; "isSignal": true; }; "triggerErrorThrottle": { "alias": "triggerErrorThrottle"; "required": false; "isSignal": true; }; "maxErrorsForThrottle": { "alias": "maxErrorsForThrottle"; "required": false; "isSignal": true; }; "triggerLimit": { "alias": "triggerLimit"; "required": false; "isSignal": true; }; "triggerEnabled": { "alias": "dbxActionAutoTrigger"; "required": false; "isSignal": true; }; "useFastTriggerPreset": { "alias": "useFastTriggerPreset"; "required": false; "isSignal": true; }; "useInstantTriggerPreset": { "alias": "useInstantTriggerPreset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract class that can either use SecondaryActionContextStoreSource or create it's own.
+ */
+declare abstract class DbxActionContextBaseSource<T = unknown, O = unknown> implements ActionContextStoreSource<T, O>, Destroyable {
+    private readonly _inputSource;
+    private readonly _store?;
+    private readonly _store$;
+    private readonly _instance;
+    readonly isModified$: Observable<boolean>;
+    readonly triggered$: Observable<boolean>;
+    readonly success$: Observable<Maybe<O>>;
+    constructor(inputSource?: Maybe<SecondaryActionContextStoreSource<T, O>>);
+    destroy(): void;
+    get inputSource(): Maybe<SecondaryActionContextStoreSource<T, O>>;
+    get lockSet(): LockSet;
+    get sourceInstance(): DbxActionContextStoreSourceInstance<T, O>;
+    get store$(): Observable<ActionContextStore<T, O>>;
+    /**
+     * Use to trigger the action directly.
+     */
+    trigger(): void;
+    readyValue(value: T | Observable<T>): void;
+    /**
+     * Triggers the context and then readies the value.
+     * @param value
+     */
+    triggerWithValue(value: T | Observable<T>): void;
+    reset(): void;
+    enable(key?: DbxActionDisabledKey, enable?: boolean): void;
+    disable(key?: DbxActionDisabledKey, disable?: boolean): void;
+    setIsModified(isModified?: boolean): void;
+}
+
+/**
+ * Provides an DbxAction/DbxActionContext.
+ */
+declare class DbxActionDirective<T = unknown, O = unknown> extends DbxActionContextBaseSource<T, O> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction]", ["action", "dbxAction"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that provides a DbxActionSourceDirective that is passed in.
+ */
+declare class DbxActionSourceDirective implements SecondaryActionContextStoreSource {
+    readonly dbxActionSource: i0.InputSignal<Maybe<ActionContextStoreSource<unknown, unknown>>>;
+    readonly store$: rxjs.Observable<_dereekb_dbx_core.ActionContextStore<unknown, unknown>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSourceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSourceDirective, "[dbxActionSource]", never, { "dbxActionSource": { "alias": "dbxActionSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Prints out the current state to the console. Useful for debugging.
+ */
+declare class DbxActionContextLoggerDirective {
+    readonly source: DbxActionContextStoreSourceInstance<any, any>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextLoggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextLoggerDirective, "[dbxActionLogger],[dbxActionContextLogger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Arbitrary string used to identify an action.
+ */
+type ActionKey = string;
+/**
+ * Map that returns sources for ActionKey values.
+ */
+declare abstract class ActionContextStoreSourceMap<T = unknown, O = unknown> implements Destroyable {
+    /**
+     * Returns the read-only map of action keys to sources.
+     */
+    abstract readonly actionKeySourceMap$: Observable<Map<ActionKey, ActionContextStoreSource<T, O>>>;
+    /**
+     * Returns a ActionContextStoreSource for the input action key.
+     *
+     * @param key Action key to retrieve the source for.
+     */
+    abstract sourceForKey(key: ActionKey): ActionContextStoreSource<T, O>;
+    /**
+     * Adds the store source for the input key.
+     * @param key Action key to add the source for.
+     * @param source Store source to add.
+     */
+    abstract addStoreSource(key: ActionKey, source: ActionContextStoreSource<T, O>): void;
+    /**
+     * Removes the store source for the input key.
+     * @param key Action key to remove the source for.
+     */
+    abstract removeStoreSource(key: ActionKey): void;
+    /**
+     * Destroys the map.
+     */
+    abstract destroy(): void;
+}
+/**
+ * Creates a new ActionContextStoreSourceMap.
+ *
+ * @returns A new ActionContextStoreSourceMap.
+ */
+declare function actionContextStoreSourceMap<T = unknown, O = unknown>(): ActionContextStoreSourceMap<T, O>;
+
+/**
+ * Context used for providing actions based on the action key.
+ *
+ * This is useful for passing action contexts around via the providers instead of explicit injection.
+ */
+declare class DbxActionContextMapDirective {
+    readonly actionContextStoreSourceMap: ActionContextStoreSourceMap<any, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that provides a ActionContextStoreSource using the input key and DbxActionContextMapDirective.
+ */
+declare class DbxActionFromMapDirective implements SecondaryActionContextStoreSource {
+    private readonly _actionContextStoreSourceMap;
+    readonly key: i0.InputSignal<Maybe<string>>;
+    readonly key$: rxjs.Observable<Maybe<string>>;
+    readonly store$: rxjs.Observable<_dereekb_dbx_core.ActionContextStore<any, any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFromMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": { "alias": "dbxActionFromMap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Used to communicate with an dbxActionMap and set the ActionContextStore to the store based on the key.
+ */
+declare class DbxActionMapSourceDirective implements OnDestroy {
+    private readonly _actionContextStoreSourceMap;
+    readonly source: ActionContextStoreSource<any, any>;
+    readonly key: i0.InputSignal<Maybe<string>>;
+    private _currentKey;
+    protected readonly _keyEffect: i0.EffectRef;
+    ngOnDestroy(): void;
+    private _addToStore;
+    private _removeFromToStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapSourceDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": { "alias": "dbxActionMapSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Utility interface that provides a set of functions to read from an ActionContextStoreSourceMap.
+ */
+interface ActionContextStoreSourceMapReader<T = unknown, O = unknown> {
+    /**
+     * The input key source map.
+     */
+    readonly actionKeySourceMap$: Observable<Map<ActionKey, ActionContextStoreSource<T, O>>>;
+    /**
+     * Checks if any of the stores in the map match the input checkFunction.
+     *
+     * @param checkFunction Function to apply to each store.
+     * @param emptyArrayValue Value to return if the map is empty.
+     */
+    checkAny(checkFunction: IsCheckFunction<ActionContextStore<T, O>>, emptyArrayValue?: boolean): Observable<boolean>;
+    /**
+     * Reduces a value from all stores in the map.
+     *
+     * @param mapFn Function to apply to each store.
+     * @param reduceFn Function to apply to the results of the mapFn.
+     */
+    reduceFromAllSources<X, Y>(mapFn: (input: ActionContextStore<T, O>) => Observable<X>, reduceFn: (values: X[]) => Y): Observable<Y>;
+    /**
+     * Reads a value from each store in the map and returns an array of the results.
+     *
+     * @param mapFn Function to apply to each store.
+     */
+    fromAllSources<Y>(mapFn: (input: ActionContextStore<T, O>) => Observable<Y>): Observable<Y[]>;
+}
+/**
+ * Creates a new ActionContextStoreSourceMapReader from the input.
+ 
+ * @param actionKeySourceMap$
+ */
+declare function actionContextStoreSourceMapReader<T = unknown, O = unknown>(actionKeySourceMap$: ObservableOrValue<Map<ActionKey, ActionContextStoreSource<T, O>>>): ActionContextStoreSourceMapReader<T, O>;
+/**
+ * Returns an Observable of the results of the mapFn for each source in the actionKeySourceMap$.
+ *
+ * @param actionKeySourceMap$ Observable of the action key source map.
+ * @param mapFn Function to apply to each source.
+ * @returns Observable of the results of the mapFn for each source.
+ */
+declare function fromAllActionContextStoreSourceMapSources<O>(actionKeySourceMap$: ObservableOrValue<ActionContextStoreSourceMap>, mapFn: (input: ActionContextStore) => Observable<O>): Observable<O[]>;
+
+declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "action_map_working_disable";
+/**
+ * Used to communicate with an dbxActionMap and set the ActionContextStore to be disabled if any other element in the map is working.
+ */
+declare class DbxActionMapWorkingDisableDirective {
+    private readonly _actionContextStoreSourceMap;
+    readonly source: DbxActionContextStoreSourceInstance<any, any>;
+    readonly disabledKey: i0.InputSignal<Maybe<string>>;
+    readonly areAnySourcesWorking$: rxjs.Observable<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapWorkingDisableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": { "alias": "dbxActionMapWorkingDisable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const APP_ACTION_DISABLED_DIRECTIVE_KEY = "dbx_action_disabled";
+/**
+ * Directive that allows disabling an action using the inputs.
+ */
+declare class DbxActionDisabledDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly disabled$: rxjs.Observable<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY = "dbx_action_disabled_on_success";
+/**
+ * Directive that will disable the action after the action completes successfully.
+ */
+declare class DbxActionDisabledOnSuccessDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly disabledOnSuccess: i0.InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly disabledOnSuccess$: rxjs.Observable<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabledOnSuccess": { "alias": "dbxActionDisabledOnSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const DBX_ACTION_HANDLER_LOCK_KEY = "dbxActionHandler";
+/**
+ * Context used for defining a function that performs an action using the input function to handle valueReady$ events from an action context.
+ */
+declare class DbxActionHandlerInstance<T = unknown, O = unknown> implements Initialized, Destroyable {
+    private readonly _delegate;
+    private readonly _sub;
+    private readonly _handlerFunction;
+    private readonly _handlerValue;
+    readonly handlerFunction$: rxjs.Observable<Work<T, O>>;
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
+    get source(): DbxActionContextStoreSourceInstance<T, O>;
+    get handlerFunction(): Maybe<Work<T, O>>;
+    get handlerValue(): Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>;
+    setHandlerFunction(handlerFunction: Maybe<Work<T, O>>): void;
+    setHandlerValue(handlerValue: Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>): void;
+    init(): void;
+    destroy(): void;
+}
+
+/**
+ * Abstract directive that wraps and handles a DbxActionHandlerInstance lifecycle.
+ */
+declare abstract class AbstractDbxActionHandlerDirective<T = unknown, O = unknown> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    protected readonly _dbxActionHandlerInstance: DbxActionHandlerInstance<T, O>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionHandlerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxActionHandlerDirective<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive that passes a Work function to handle a valueReady$ event from an action context.
+ */
+declare class DbxActionHandlerDirective<T = unknown, O = unknown> extends AbstractDbxActionHandlerDirective<T, O> {
+    readonly handlerFunction: i0.InputSignal<Maybe<Work<T, O>>>;
+    protected readonly _handlerFunctionEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": { "alias": "dbxActionHandler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Directive that passes a value to handle a valueReady$ event from an action context.
+ */
+declare class DbxActionHandlerValueDirective<T = unknown, O = unknown> extends AbstractDbxActionHandlerDirective<T, O> {
+    readonly handlerValue: i0.InputSignal<Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>>;
+    protected readonly _handlerValueEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerValueDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerValueDirective<any, any>, "[dbxActionHandlerValue]", never, { "handlerValue": { "alias": "dbxActionHandlerValue"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive class that watches a show$ observable and behaves like *ngIf.
+ */
+declare abstract class AbstractIfDirective implements OnInit {
+    private readonly _templateRef;
+    private readonly _viewContainer;
+    /**
+     * Observable that is watched for showing/hiding.
+     */
+    abstract readonly show$: Observable<boolean>;
+    private readonly _sub;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractIfDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractIfDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive that displays the content before the store has success.
+ *
+ * Can be configured to hide for a temporary period.
+ */
+declare class DbxActionIdleDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly hideAfter: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly show$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionIdleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIdleDirective, "[dbxActionIdle]", never, { "hideAfter": { "alias": "dbxActionIdle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive that displays the content before the store has success.
+ *
+ * Can be configured to hide for a temporary period.
+ */
+declare class DbxActionPreSuccessDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly hideFor: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly show$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionPreSuccessDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPreSuccessDirective, "[dbxActionPreSuccess]", never, { "hideFor": { "alias": "dbxActionPreSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural directive that displays the content when the store has a success value.
+ *
+ * Can be configured to show for a temporary period.
+ */
+declare class DbxActionHasSuccessDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly hideAfter: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly show$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHasSuccessDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": { "alias": "dbxActionHasSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Performs the action on success.
+ */
+type DbxActionSuccessHandlerFunction<O = unknown> = (value: O) => void;
+/**
+ * Directive that executes a function on ActionContextStore Success.
+ */
+declare class DbxActionSuccessHandlerDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly dbxActionSuccessHandler: i0.InputSignal<Maybe<DbxActionSuccessHandlerFunction<O>>>;
+    readonly successFunction$: rxjs.Observable<DbxActionSuccessHandlerFunction<O>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessHandlerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessHandlerDirective<any, any>, "[dbxActionSuccessHandler]", never, { "dbxActionSuccessHandler": { "alias": "dbxActionSuccessHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Performs the action on error.
+ */
+type DbxActionErrorHandlerFunction = (error?: Maybe<ReadableError>) => void;
+/**
+ * Directive that executes a function on ActionContextStore error.
+ */
+declare class DbxActionErrorHandlerDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly dbxActionErrorHandler: i0.InputSignal<Maybe<DbxActionErrorHandlerFunction>>;
+    readonly errorFunction$: rxjs.Observable<DbxActionErrorHandlerFunction>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionErrorHandlerDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionErrorHandlerDirective<any, any>, "[dbxActionErrorHandler]", never, { "dbxActionErrorHandler": { "alias": "dbxActionErrorHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that provides a default value when triggered.
+ *
+ * No value is required, allowing the directive to automatically call readyValue.
+ *
+ * The valueOrFunction will filter on null/undefined input and wait until the input value is non-null.
+ *
+ * Use a getter if null/undefined values should be passed to the action.
+ */
+declare class DbxActionValueDirective<T, O> {
+    readonly valueOrFunction: i0.InputSignal<Maybe<"" | GetterOrValue<T>>>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    private readonly _valueOrFunctionOverride;
+    readonly valueOrFunction$: Observable<GetterOrValue<T>>;
+    constructor();
+    setValueOrFunction(value: Maybe<GetterOrValue<T>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueDirective<any, any>, "dbxActionValue,[dbxActionValue]", never, { "valueOrFunction": { "alias": "dbxActionValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 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.
+ */
+declare class DbxActionIsWorkingDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly hideAfter: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly hideAfterIsWorking: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly hideAfterSignal: i0.Signal<Maybe<number>>;
+    readonly show$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionIsWorkingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionWorking],[dbxActionIsWorking]", never, { "hideAfter": { "alias": "dbxActionWorking"; "required": false; "isSignal": true; }; "hideAfterIsWorking": { "alias": "dbxActionIsWorking"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY = "dbx_action_enforce_modified";
+/**
+ * Directive that toggles disabling an action if the action is not marked modified.
+ */
+declare class DbxActionEnforceModifiedDirective {
+    readonly source: DbxActionContextStoreSourceInstance<any, any>;
+    readonly enabled: i0.InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly enabled$: rxjs.Observable<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * DbxActionValueGetterInstance function. Returns an ObervableGetter that returns a value.
+ */
+type DbxActionValueGetterValueGetterFunction<T> = () => ObservableOrValue<Maybe<T>>;
+interface DbxActionValueGetterResult<T = unknown> {
+    /**
+     * The value to trigger with
+     */
+    readonly value?: Maybe<T>;
+    /**
+     * The error to reject with
+     */
+    readonly reject?: Maybe<ReadableError>;
+}
+/**
+ * DbxActionValueGetterInstance configuration.
+ */
+interface DbxActionValueGetterInstanceConfig<T> {
+    readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
+    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.
+ */
+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>;
+    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;
+}
+
+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.
+ */
+declare abstract class AbstractDbxActionValueGetterDirective<T> {
+    private readonly _injector;
+    readonly source: DbxActionContextStoreSourceInstance<T, unknown>;
+    private readonly _triggerInstance;
+    constructor();
+    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, true, never>;
+}
+/**
+ * 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.
+ */
+declare class DbxActionValueTriggerDirective<T = object> extends AbstractDbxActionValueGetterDirective<T> {
+    readonly dbxActionValueGetter: i0.InputSignal<Maybe<DbxActionValueGetterValueGetterFunction<T>>>;
+    readonly dbxActionValueGetterIsModified: i0.InputSignal<Maybe<IsModifiedFunction>>;
+    readonly dbxActionValueGetterIsEqual: i0.InputSignal<Maybe<IsEqualFunction>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueTriggerDirective<any>, 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>;
+}
+
+/**
+ * Directive that watches a value observable for changes and sets the new value and modified states as necessary.
+ */
+declare class DbxActionValueStreamDirective<T, O> {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly dbxActionValueStream: i0.InputSignal<Observable<T>>;
+    readonly dbxActionValueStreamIsEqualValue: i0.InputSignal<Maybe<IsEqualFunction<T>>>;
+    readonly dbxActionValueStreamIsModifiedValue: i0.InputSignal<Maybe<IsModifiedFunction<T>>>;
+    readonly isModifiedFunction$: Observable<IsModifiedFunction<T>>;
+    readonly modifiedValue$: Observable<[boolean, T]>;
+    constructor();
+    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>;
+}
+
+/**
+ * Structural directive that displays the content when the store has been triggered.
+ *
+ * Can be configured to hide for a temporary period.
+ */
+declare class DbxActionTriggeredDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly hideAfter: i0.InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
+    readonly show$: rxjs.Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionTriggeredDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionTriggeredDirective, "[dbxActionTriggered]", never, { "hideAfter": { "alias": "dbxActionTriggered"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * WorkInstanceDelegate implementation using an DbxActionContextStoreSourceInstance.
+ */
+declare class DbxActionWorkInstanceDelegate<T = unknown, O = unknown> implements WorkInstanceDelegate<O> {
+    private _source;
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
+    get source(): DbxActionContextStoreSourceInstance<T, O>;
+    startWorking(): void;
+    success(result: O): void;
+    reject(error: Maybe<ReadableError | Observable<ReadableError>>): void;
+}
+
+/**
+ * Acts as a reference to a DbxActionContextStoreSourceInstance that can be destroyed.
+ *
+ * This is used in cases where the action is passed around and the context it is passed to needs to clean up.
+ */
+interface DbxActionContextSourceReference<T = unknown, O = unknown> extends Destroyable {
+    readonly sourceInstance: DbxActionContextStoreSourceInstance<T, O>;
+}
+declare function makeDbxActionContextSourceReference<T, O>(sourceInstance: DbxActionContextStoreSourceInstance<T, O>): DbxActionContextSourceReference<T, O>;
+
+/**
+ * DbxActionContextMachine configuration.
+ */
+interface DbxActionContextMachineConfig<T = unknown, O = unknown> {
+    /**
+     * Whether or not the machine should clean itself up after being triggered once.
+     */
+    oneTimeUse: boolean;
+    /**
+     * Function to handle any valueReady events.
+     *
+     * If false, will not subscribe/handle valueReady$ events.
+     */
+    handleValueReady: Work<T, O> | false;
+    /**
+     * Optional function to execute after the action has succeeded.
+     */
+    onSuccess?: (value: Maybe<O>) => void;
+}
+/**
+ * Configurable machine that handles components of the ActionContextStore lifecycle.
+ *
+ * It can be configured to activate only once before cleaning itself up. It can be used directly as a DbxActionContextSourceReference in cases where it is created as a one-off action.
+ */
+declare class DbxActionContextMachine<T = unknown, O = unknown> extends DbxActionContextBaseSource<T, O> implements DbxActionContextSourceReference<T, O>, Destroyable {
+    private _isShutdown;
+    private readonly _config;
+    private readonly _handleValueReadySub;
+    private readonly _successSub;
+    constructor(config: DbxActionContextMachineConfig<T, O>, source?: ActionContextStoreSource<T, O>);
+    destroy(): void;
+    get config(): DbxActionContextMachineConfig<T, O>;
+    get isShutdown(): boolean;
+}
+/**
+ * DbxActionContextMachine configured for use as a Service/Injectable.
+ */
+declare class DbxActionContextMachineAsService<T = unknown, O = unknown> extends DbxActionContextMachine<T, O> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMachineAsService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxActionContextMachineAsService<any, any>>;
+}
+
+/**
+ * Contains all base DbxAction components.
+ */
+declare class DbxCoreActionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreActionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreActionModule, never, [typeof DbxActionDirective, typeof DbxActionContextMapDirective, typeof DbxActionFromMapDirective, typeof DbxActionMapSourceDirective, typeof DbxActionMapWorkingDisableDirective, typeof DbxActionSourceDirective, typeof DbxActionHandlerDirective, typeof DbxActionHandlerValueDirective, typeof DbxActionDisabledDirective, typeof DbxActionDisabledOnSuccessDirective, typeof DbxActionEnforceModifiedDirective, typeof DbxActionAutoTriggerDirective, typeof DbxActionValueStreamDirective, typeof DbxActionAutoModifyDirective, typeof DbxActionValueDirective, typeof DbxActionContextLoggerDirective, typeof DbxActionIdleDirective, typeof DbxActionPreSuccessDirective, typeof DbxActionHasSuccessDirective, typeof DbxActionSuccessHandlerDirective, typeof DbxActionErrorHandlerDirective, typeof DbxActionIsWorkingDirective], [typeof DbxActionDirective, typeof DbxActionContextMapDirective, typeof DbxActionFromMapDirective, typeof DbxActionMapSourceDirective, typeof DbxActionMapWorkingDisableDirective, typeof DbxActionSourceDirective, typeof DbxActionHandlerDirective, typeof DbxActionHandlerValueDirective, typeof DbxActionDisabledDirective, typeof DbxActionDisabledOnSuccessDirective, typeof DbxActionEnforceModifiedDirective, typeof DbxActionAutoTriggerDirective, typeof DbxActionValueStreamDirective, typeof DbxActionAutoModifyDirective, typeof DbxActionValueDirective, typeof DbxActionContextLoggerDirective, typeof DbxActionIdleDirective, typeof DbxActionPreSuccessDirective, typeof DbxActionHasSuccessDirective, typeof DbxActionSuccessHandlerDirective, typeof DbxActionErrorHandlerDirective, typeof DbxActionIsWorkingDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreActionModule>;
+}
+
+/**
+ * Provides an ActionContextStoreSource, as well as an DbxActionContextStoreSourceInstance.
+ */
+declare function provideActionStoreSource<S extends ActionContextStoreSource>(sourceType: Type<S> | null): Provider[];
+declare function provideSecondaryActionStoreSource<S extends SecondaryActionContextStoreSource>(sourceType: Type<S>): Provider[];
+
+type SegueRefRouterLink = string | ArrayOrValue<object>;
+interface SegueRefRawSegueParams {
+    [key: string]: unknown;
+}
+interface SegueRefOptions<O = object> {
+    /**
+     * Raw parameters
+     */
+    refParams?: SegueRefRawSegueParams;
+    /**
+     * Custom Transition Options.
+     *
+     * For UIRouter, this is TransitionOptions.
+     */
+    refOptions?: O;
+}
+/**
+ * Represents a segue ref
+ */
+interface SegueRef<O = object> extends SegueRefOptions<O> {
+    /**
+     * Ref path value.
+     */
+    ref: SegueRefRouterLink;
+}
+/**
+ * A SegueRef object or a different router link representation.
+ */
+type SegueRefOrSegueRefRouterLink<O = object> = SegueRef<O> | SegueRefRouterLink;
+declare function isSegueRef<O = object>(input: Maybe<SegueRefOrSegueRefRouterLink<O>>): input is SegueRef<O>;
+declare function asSegueRef<O = object>(input: SegueRefOrSegueRefRouterLink<O>): SegueRef<O>;
+declare function asSegueRef<O = object>(input: Maybe<SegueRefOrSegueRefRouterLink<O>>): Maybe<SegueRef<O>>;
+declare function asSegueRefString<O = object>(input: SegueRefOrSegueRefRouterLink<O> | string): string;
+declare function asSegueRefString<O = object>(input: Maybe<SegueRefOrSegueRefRouterLink<O> | string>): Maybe<string>;
+declare function refStringToSegueRef<O = object>(ref: string, options?: SegueRefOptions<O>): SegueRef<O>;
+declare function mapRefStringObsToSegueRefObs<O = object>(obs: Observable<string>, options?: SegueRefOptions<O>): Observable<SegueRef<O>>;
+
+/**
+ * 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
+ */
+type AuthUserState = 'none' | 'anon' | 'new' | 'user' | 'error';
+/**
+ * Arbitrary identifier used to differentiate users.
+ */
+type AuthUserIdentifier = string;
+declare const NO_AUTH_USER_IDENTIFIER = "0";
+/**
+ * AuthUserIdentifier used to indicate that the user cannot be uniquely identifier.
+ */
+type NoAuthUserIdentifier = typeof NO_AUTH_USER_IDENTIFIER;
+/**
+ * Creates an AuthUserIdentifier from the input. If the input is undefined, returns the NoAuthUserIdentifier.
+ *
+ * @param inputId
+ * @returns
+ */
+declare function authUserIdentifier(inputId: Maybe<AuthUserIdentifier>): AuthUserIdentifier;
+
+/**
+ * Client auth service used to retrieve info about the current state of client authentication and client roles they may have.
+ */
+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>;
+}
+
+/**
+ * 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.
+ */
+type AuthTransitionDecision = true | false | SegueRefOrSegueRefRouterLink;
+interface AuthTransitionDecisionGetterInput {
+    readonly transition: Transition;
+    readonly injector: Injector;
+    readonly authService: DbxAuthService;
+}
+type AuthTransitionRedirectTarget = Observable<Maybe<SegueRefOrSegueRefRouterLink>>;
+type AuthTransitionRedirectTargetGetter = FactoryWithRequiredInput<AuthTransitionRedirectTarget, AuthTransitionDecisionGetterInput>;
+type AuthTransitionRedirectTargetOrGetter = Maybe<SegueRefOrSegueRefRouterLink> | AuthTransitionRedirectTargetGetter;
+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;
+    /**
+     * Timeout time for the decision obs. Defaults to 1000ms.
+     */
+    timeoutTime?: Milliseconds;
+}
+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>;
+}
+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.
+ */
+declare function makeAuthTransitionHook(config: AuthTransitionHookConfig): TransitionHookFn;
+
+/**
+ * Creates a AuthTransitionRedirectTargetGetter that can redirect values based on the current authUserState.
+ *
+ * @param stateMap
+ * @returns
+ */
+declare function redirectBasedOnAuthUserState(stateMap: ObjectMap<AuthTransitionRedirectTargetOrGetter>): AuthTransitionRedirectTargetGetter;
+
+interface IsLoggedInHookConfig {
+    options: AuthTransitionHookOptions;
+}
+/**
+ * UIRouter State data with configuration for the hasAuthRoleHook.
+ */
+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.
+ */
+declare function enableIsLoggedInHook(transitionService: TransitionService, config: IsLoggedInHookConfig): void;
+
+interface HasAuthRoleHookConfig {
+    readonly options: AuthTransitionHookOptions;
+}
+interface HasAuthRoleStateRoleConfig {
+    /**
+     * Auth roles marked for this state
+     */
+    readonly authRoles: ArrayOrValue<AuthRole>;
+    /**
+     * How to use the above auth roles. This defaults to 'all' by default.
+     */
+    readonly authRolesMode?: SetIncludesMode;
+}
+interface ParsedHasAuthRoleStateRoleConfig {
+    /**
+     * Auth roles marked for this state
+     */
+    readonly requiredRoles: Set<AuthRole>;
+    /**
+     * How to use the above auth roles. This defaults to 'all' by default.
+     */
+    readonly authRolesMode?: SetIncludesMode;
+}
+/**
+ * UIRouter State data with configuration for the hasAuthRoleHook.
+ */
+interface HasAuthRoleStateData extends AuthTransitionStateData, Pick<HasAuthRoleStateRoleConfig, 'authRolesMode'> {
+    /**
+     * Auth roles configuration for this state.
+     */
+    readonly authRoles: ArrayOrValue<AuthRole | HasAuthRoleStateRoleConfig>;
+}
+/**
+ * This hook redirects to the configured default state when a user:
+ *
+ * - does not have an allowed state
+ * - has a disallowed state
+ */
+declare function enableHasAuthRoleHook(transitionService: TransitionService, config: HasAuthRoleHookConfig): void;
+declare function hasAuthRoleDecisionPipe(stateData: HasAuthRoleStateData): OperatorFunction<AuthRoleSet, boolean>;
+
+interface HasAuthStateHookConfig {
+    options: AuthTransitionHookOptions;
+}
+type HasAuthStateConfig = ArrayOrValue<AuthUserState> | HasAuthStateObjectConfig;
+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>;
+}
+interface HasAuthStateData extends AuthTransitionStateData {
+    /**
+     * 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
+ */
+declare function enableHasAuthStateHook(transitionService: TransitionService, config: HasAuthStateHookConfig): void;
+
+/**
+ * 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.
+ */
+type DbxAppContextState = string;
+/**
+ * The init state of an app after the default context has been initialized.
+ */
+declare const DBX_INIT_APP_CONTEXT_STATE = "init";
+/**
+ * The public state of an app, typically when a user opens up the site to a public page.
+ */
+declare const DBX_PUBLIC_APP_CONTEXT_STATE = "public";
+/**
+ * The auth state of an app, typically when a user has not finished logging in.
+ */
+declare const DBX_AUTH_APP_CONTEXT_STATE = "auth";
+/**
+ * The onboarding state of an app, typically when a user has completed auth but not finished setting up their account.
+ */
+declare const DBX_ONBOARD_APP_CONTEXT_STATE = "onboard";
+/**
+ * The app state of an app, typically when a user has completed auth and onboarding.
+ */
+declare const DBX_APP_APP_CONTEXT_STATE = "app";
+/**
+ * Default AppContextStates.
+ *
+ * Your app may not use these, but this type is available for convenience.
+ */
+type DbxKnownAppContextState = typeof DBX_INIT_APP_CONTEXT_STATE | typeof DBX_PUBLIC_APP_CONTEXT_STATE | typeof DBX_AUTH_APP_CONTEXT_STATE | typeof DBX_ONBOARD_APP_CONTEXT_STATE | typeof DBX_APP_APP_CONTEXT_STATE;
+/**
+ * Array of all DbxKnownAppContextState values, minus the init state.
+ */
+declare const DBX_KNOWN_APP_CONTEXT_STATES: DbxKnownAppContextState[];
+
+/**
+ * The feature key for these items/reducers.
+ */
+declare const dbxAppContextStateFeatureKey = "data";
+/**
+ * The typings for this feature.
+ */
+interface DbxAppContextStateData {
+    state: DbxAppContextState;
+}
+
+/**
+ * Global feature key for our app.
+ */
+declare const featureKey$1 = "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.
+ */
+interface DbxAppContextFeatureState {
+    [dbxAppContextStateFeatureKey]: DbxAppContextStateData;
+}
+/**
+ * Interface typing extension for the DbxAppContextFeatureState, and the typing information for how this feature extends the base state.
+ */
+interface State$1 {
+    [featureKey$1]: DbxAppContextFeatureState;
+}
+/**
+ * Reducers mapping for the DbxAppContextFeatureState
+ */
+declare function reducers$1(state: DbxAppContextFeatureState | undefined, action: Action): {
+    data: DbxAppContextStateData;
+};
+/**
+ * Selects the DbxAppContextFeatureState feature context.
+ *
+ * Used by createSelector() to retrieve more specific data from the DbxAppContextFeatureState.
+ */
+declare const selectAppContextFeature: _ngrx_store.MemoizedSelector<object, DbxAppContextFeatureState, _ngrx_store.DefaultProjectorFn<DbxAppContextFeatureState>>;
+/**
+ * Selector to retrieve the state value from our DbxAppContextStateData in our DbxAppContextFeatureState.
+ */
+declare const selectDbxAppContextState: _ngrx_store.MemoizedSelector<object, string, (s1: DbxAppContextFeatureState) => string>;
+
+type index_d$3_DbxAppContextFeatureState = DbxAppContextFeatureState;
+declare const index_d$3_selectAppContextFeature: typeof selectAppContextFeature;
+declare const index_d$3_selectDbxAppContextState: typeof selectDbxAppContextState;
+declare namespace index_d$3 {
+  export { featureKey$1 as featureKey, reducers$1 as reducers, index_d$3_selectAppContextFeature as selectAppContextFeature, index_d$3_selectDbxAppContextState as selectDbxAppContextState };
+  export type { index_d$3_DbxAppContextFeatureState as DbxAppContextFeatureState, State$1 as State };
+}
+
+/**
+ * Action to set the current DbxAppContextState value.
+ */
+declare const setState: _ngrx_store.ActionCreator<"[App/Context] Set State", (props: {
+    state: DbxAppContextState;
+}) => {
+    state: DbxAppContextState;
+} & _ngrx_store.Action<"[App/Context] Set State">>;
+/**
+ * Resets the app back to the init context.
+ */
+declare const resetState: _ngrx_store.ActionCreator<"[App/Context] Reset", () => _ngrx_store.Action<"[App/Context] Reset">>;
+
+declare const data_action_d_resetState: typeof resetState;
+declare const data_action_d_setState: typeof setState;
+declare namespace data_action_d {
+  export {
+    data_action_d_resetState as resetState,
+    data_action_d_setState as setState,
+  };
+}
+
+declare namespace index_d$2 {
+  export {
+    data_action_d as DbxAppContextActions,
+  };
+}
+
+/**
+ * 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.
+ */
+type DbxAppContextFullState = State$1;
+
+/**
+ * State for accessing the app's DbxAppContextState defined within the DbxAppContextFullState for the ngrx store.
+ */
+declare class DbxAppContextService {
+    readonly store: Store<any>;
+    readonly state$: rxjs.Observable<string>;
+    setState(state: DbxAppContextState): void;
+    resetState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppContextService>;
+}
+
+/**
+ * Used to set the DbxAppContextState for an app to the input state using the DbxAppContextService.
+ */
+declare class DbxAppContextStateDirective {
+    readonly dbxAppContextStateService: DbxAppContextService;
+    readonly state: i0.InputSignal<Maybe<string>>;
+    protected readonly _stateEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppContextStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAppContextStateDirective, "[dbxAppContextState]", never, { "state": { "alias": "dbxAppContextState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Creates EnvironmentProviders for providing the DbxAppContext state.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxAppContextState(): EnvironmentProviders;
+
+/**
+ * Configuration for provideDbxAppAuthRouterState().
+ */
+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
+ */
+declare function provideDbxAppAuthRouterState(config: ProvideDbxAppAuthRouterStateConfig): EnvironmentProviders;
+
+/**
+ * Abstract effects class that only runs/allows effects when the DbxAppContextState in the ngrx state matches input activeState value.
+ */
+declare abstract class AbstractOnDbxAppContextStateEffects<S = unknown> implements OnRunEffects {
+    protected readonly actions$: Actions<any>;
+    protected readonly store: Store<any>;
+    /**
+     * The set of state(s) to activate on.
+     */
+    private _activeStatesSet;
+    constructor(activeStates: IterableOrValue<DbxAppContextState>);
+    /**
+     * Configures all actions of the sub-class to only activate when the DbxAppContextState in App
+     *
+     * @param resolvedEffects$
+     * @returns
+     */
+    ngrxOnRunEffects(resolvedEffects$: Observable<EffectNotification>): Observable<EffectNotification>;
+}
+
+declare const dbxAppAuthUserFeatureKey = "user";
+interface DbxAppAuthStateUser {
+    userId: AuthUserIdentifier;
+    isOnboarded: boolean;
+    userState: AuthUserState;
+    userRoles: AuthRole[];
+}
+
+/**
+ * Global feature key
+ */
+declare const featureKey = "app.auth";
+interface DbxAppAuthFeatureState {
+    [dbxAppAuthUserFeatureKey]: DbxAppAuthStateUser;
+}
+/**
+ * Interface typing extension for the DbxAppAuthFeatureState, and the typing information for how this feature extends the base state.
+ */
+interface State {
+    [featureKey]: DbxAppAuthFeatureState;
+}
+/**
+ * Reducers mapping for the DbxAppAuthFeatureState
+ */
+declare function reducers(state: DbxAppAuthFeatureState | undefined, action: Action): {
+    user: DbxAppAuthStateUser;
+};
+/**
+ * Selects the DbxAppAuthFeatureState feature context.
+ */
+declare const selectAppAuthFeature: _ngrx_store.MemoizedSelector<object, DbxAppAuthFeatureState, _ngrx_store.DefaultProjectorFn<DbxAppAuthFeatureState>>;
+/**
+ * Selector to retrieve the state value from our DbxAppContextStateData in our DbxAppContextFeatureState.
+ */
+declare const selectDbxAppAuthUser: _ngrx_store.MemoizedSelector<object, DbxAppAuthStateUser, (s1: DbxAppAuthFeatureState) => DbxAppAuthStateUser>;
+
+type index_d$1_DbxAppAuthFeatureState = DbxAppAuthFeatureState;
+type index_d$1_State = State;
+declare const index_d$1_featureKey: typeof featureKey;
+declare const index_d$1_reducers: typeof reducers;
+declare const index_d$1_selectAppAuthFeature: typeof selectAppAuthFeature;
+declare const index_d$1_selectDbxAppAuthUser: typeof selectDbxAppAuthUser;
+declare namespace index_d$1 {
+  export { index_d$1_featureKey as featureKey, index_d$1_reducers as reducers, index_d$1_selectAppAuthFeature as selectAppAuthFeature, index_d$1_selectDbxAppAuthUser as selectDbxAppAuthUser };
+  export type { index_d$1_DbxAppAuthFeatureState as DbxAppAuthFeatureState, index_d$1_State as State };
+}
+
+/**
+ * Action for when the user has logged in.
+ */
+declare const loggedIn: _ngrx_store.ActionCreator<"[App/Auth] Auth Logged In", () => _ngrx_store.Action<"[App/Auth] Auth Logged In">>;
+/**
+ * Action for when the user has logged out.
+ */
+declare const loggedOut: _ngrx_store.ActionCreator<"[App/Auth] Auth Logged Out", () => _ngrx_store.Action<"[App/Auth] Auth Logged Out">>;
+/**
+ * Action to log the user out.
+ */
+declare const logout: _ngrx_store.ActionCreator<"[App/Auth] Auth Logout", () => _ngrx_store.Action<"[App/Auth] Auth Logout">>;
+
+declare const auth_action_d_loggedIn: typeof loggedIn;
+declare const auth_action_d_loggedOut: typeof loggedOut;
+declare const auth_action_d_logout: typeof logout;
+declare namespace auth_action_d {
+  export {
+    auth_action_d_loggedIn as loggedIn,
+    auth_action_d_loggedOut as loggedOut,
+    auth_action_d_logout as logout,
+  };
+}
+
+/**
+ * Sets the user's identifier in the auth.
+ */
+declare const setUserIdentifier: _ngrx_store.ActionCreator<"[App/Auth] Set User Identifier", (props: {
+    id: AuthUserIdentifier;
+}) => {
+    id: AuthUserIdentifier;
+} & _ngrx_store.Action<"[App/Auth] Set User Identifier">>;
+/**
+ * Sets the user's state in the auth.
+ */
+declare const setUserState: _ngrx_store.ActionCreator<"[App/Auth] Set User State", (props: {
+    state: AuthUserState;
+}) => {
+    state: AuthUserState;
+} & _ngrx_store.Action<"[App/Auth] Set User State">>;
+/**
+ * Sets the user's roles in the auth.
+ */
+declare const setUserRoles: _ngrx_store.ActionCreator<"[App/Auth] Set User Roles", (props: {
+    roles: AuthRole[];
+}) => {
+    roles: AuthRole[];
+} & _ngrx_store.Action<"[App/Auth] Set User Roles">>;
+/**
+ * Sets the user's onboarding state.
+ */
+declare const setUserIsOnboarded: _ngrx_store.ActionCreator<"[App/Auth] Set User Is Onboarded", (props: {
+    isOnboarded: boolean;
+}) => {
+    isOnboarded: boolean;
+} & _ngrx_store.Action<"[App/Auth] Set User Is Onboarded">>;
+
+declare const user_action_d_setUserIdentifier: typeof setUserIdentifier;
+declare const user_action_d_setUserIsOnboarded: typeof setUserIsOnboarded;
+declare const user_action_d_setUserRoles: typeof setUserRoles;
+declare const user_action_d_setUserState: typeof setUserState;
+declare namespace user_action_d {
+  export {
+    user_action_d_setUserIdentifier as setUserIdentifier,
+    user_action_d_setUserIsOnboarded as setUserIsOnboarded,
+    user_action_d_setUserRoles as setUserRoles,
+    user_action_d_setUserState as setUserState,
+  };
+}
+
+declare namespace index_d {
+  export {
+    auth_action_d as DbxAppAuthActions,
+    user_action_d as DbxAppAuthUserActions,
+  };
+}
+
+/**
+ * Type that contains the dbx-core contextual ngrx state information for auth.
+ */
+type DbxAppAuthFullState = State;
+
+declare enum DbxRouterTransitionEventType {
+    /**
+     * A transition started.
+     */
+    START = "start",
+    /**
+     * A transition ended.
+     */
+    SUCCESS = "success"
+}
+interface DbxRouterTransitionEvent {
+    type: DbxRouterTransitionEventType;
+}
+
+/**
+ * Router service definition that provides high level information about router transitions.
+ */
+declare abstract class DbxRouterTransitionService {
+    /**
+     * Observable that emits DbxRouterTransitionEvent values as transitions occur.
+     */
+    abstract readonly transitions$: Observable<DbxRouterTransitionEvent>;
+}
+
+/**
+ * Router service definition that can route the app and provide routing details.
+ */
+declare abstract class DbxRouterService extends DbxRouterTransitionService {
+    /**
+     * Params of the current successfully loaded route.
+     */
+    abstract readonly params$: Observable<SegueRefRawSegueParams>;
+    /**
+     * Navigates to the target SegueRef.
+     *
+     * @param segueRef
+     */
+    abstract go(segueRef: ObservableOrValue<SegueRefOrSegueRefRouterLink>): Promise<boolean>;
+    /**
+     * Navigates to the current url with updated parameters. Will be merged with the existing parameters.
+     *
+     * The new state will replace the current state in the history.
+     *
+     * @param segueRef
+     */
+    abstract updateParams(params: ObservableOrValue<SegueRefRawSegueParams>): Promise<boolean>;
+    /**
+     * Returns true if the input segue ref is considered active.
+     *
+     * @param segueRef
+     */
+    abstract isActive(segueRef: SegueRefOrSegueRefRouterLink): boolean;
+    /**
+     * Returns true if the input segue ref is considered active exactly.
+     *
+     * @param segueRef
+     */
+    abstract isActiveExactly(segueRef: SegueRefOrSegueRefRouterLink): boolean;
+    /**
+     * Compares the two refs for precision for a certain route.
+     *
+     * For example, if the parent route is input with a child route, the child route is
+     * considered more precise.
+     *
+     * @param a
+     * @param b
+     */
+    abstract comparePrecision(a: SegueRefOrSegueRefRouterLink, b: SegueRefOrSegueRefRouterLink): number;
+}
+
+/**
+ * Auth routes configurations for an app.
+ */
+declare abstract class DbxAppAuthRoutes {
+    abstract readonly loginRef: SegueRefOrSegueRefRouterLink;
+    abstract readonly loggedOutRef?: SegueRefOrSegueRefRouterLink;
+    abstract readonly onboardRef?: SegueRefOrSegueRefRouterLink;
+    abstract readonly appRef: SegueRefOrSegueRefRouterLink;
+}
+
+/**
+ * Helper service for navigating to important auth-related routes.
+ */
+declare class DbxAppAuthRouterService implements OnDestroy {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxAppAuthRoutes: DbxAppAuthRoutes;
+    private _isAuthRouterEffectsEnabled;
+    readonly isAuthRouterEffectsEnabled$: rxjs.Observable<boolean>;
+    ngOnDestroy(): void;
+    get hasOnboardingState(): boolean;
+    /**
+     * Whether or not DbxAppAuthRouterEffects are enabled.
+     */
+    get isAuthRouterEffectsEnabled(): boolean;
+    set isAuthRouterEffectsEnabled(enabled: 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>;
+}
+
+/**
+ * Used by DbxAppAuthRouterEffects to configure the states that should be activve by default.
+ */
+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.
+ */
+declare class DbxAppAuthRouterEffects extends AbstractOnDbxAppContextStateEffects<State> {
+    readonly dbxAppAuthRouterService: DbxAppAuthRouterService;
+    constructor();
+    /**
+     * Effect to redirect to the login when logout occurs.
+     */
+    readonly redirectToLoginOnLogout: rxjs.Observable<boolean> & _ngrx_effects.CreateEffectMetadata;
+    /**
+     * Effect to redirect to the app when login occurs.
+     */
+    readonly redirectToOnboardOnLogIn: rxjs.Observable<boolean> & _ngrx_effects.CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthRouterEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthRouterEffects>;
+}
+
+/**
+ * Configuration for provideDbxAppAuthRouter().
+ */
+interface ProvideDbxAppAuthRouterConfig {
+    /**
+     * DbxAppAuthRoutes configuration.
+     */
+    readonly dbxAppAuthRoutes: DbxAppAuthRoutes;
+}
+/**
+ * Creates EnvironmentProviders for providing DbxAppAuthRoutes configuration.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxAppAuthRouter(config: ProvideDbxAppAuthRouterConfig): EnvironmentProviders;
+
+/**
+ * Convenience operator that emits events when the input observable goes from false to true.
+ *
+ * @param isLoggedInObs
+ * @returns
+ */
+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
+ */
+declare function loggedOutObsFromIsLoggedIn(isLoggedInObs: Observable<boolean>): Observable<void>;
+declare function authRolesSetContainsAllRolesFrom(roles: Observable<Maybe<Iterable<AuthRole>>>): OperatorFunction<AuthRoleSet, boolean>;
+declare function authRolesSetContainsAnyRoleFrom(roles: Observable<Maybe<Iterable<AuthRole>>>): OperatorFunction<AuthRoleSet, boolean>;
+declare function authRolesSetContainsNoRolesFrom(roles: Observable<Maybe<Iterable<AuthRole>>>): OperatorFunction<AuthRoleSet, boolean>;
+
+interface ProvideDbxAppAuthConfig extends ProvideDbxAppAuthRouterConfig, ProvideDbxAppAuthRouterStateConfig {
+}
+/**
+ * The "all-in-one" provider for an app's dbx-core auth providers.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxAppAuth(config: ProvideDbxAppAuthConfig): EnvironmentProviders;
+
+/**
+ * Structural decorator directive similar to ngIf that embeds content if the current auth user has any of the target role(s).
+ */
+declare class DbxAuthHasAnyRoleDirective extends AbstractIfDirective {
+    private readonly _authService;
+    readonly targetRoles: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasAnyRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": { "alias": "dbxAuthHasAnyRole"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural decorator directive similar to ngIf that embeds content if the current auth user has all of the target role(s).
+ */
+declare class DbxAuthHasRolesDirective extends AbstractIfDirective {
+    private readonly _authService;
+    readonly targetRoles: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasRolesDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": { "alias": "dbxAuthHasRoles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Structural decorator directive similar to ngIf that embeds content if the current auth user has none of the target role(s).
+ */
+declare class DbxAuthNotAnyRoleDirective extends AbstractIfDirective {
+    private readonly _authService;
+    readonly targetRoles: i0.InputSignal<Maybe<ArrayOrValue<string>>>;
+    readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
+    readonly show$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthNotAnyRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthNotAnyRoleDirective, "[dbxAuthNotAnyRole]", never, { "targetRoles": { "alias": "dbxAuthNotAnyRole"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Creates EnvironmentProviders for providing the DbxAppAuth state and effects.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxAppAuthState(): EnvironmentProviders;
+
+/**
+ * State for accessing the app's DbxAppAuthState defined within the DbxAppAuthFullState for the ngrx store.
+ */
+declare class DbxAppAuthStateService {
+    readonly store: Store<any>;
+    readonly authStateUser$: rxjs.Observable<DbxAppAuthStateUser>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppAuthStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppAuthStateService>;
+}
+
+type DbxButtonWorkingProgress = DbxActionWorkProgress;
+/**
+ * Working state for a button.
+ *
+ * Can be a boolean or a number.
+ *
+ * True is treated as an indeterminate progress.
+ */
+type DbxButtonWorking = DbxActionWorkOrWorkProgress;
+/**
+ * Used for intercepting button click events.
+ *
+ * Can be used to delay/modify trigger/click behaviors.
+ */
+interface DbxButtonInterceptor {
+    /**
+     * Handles a button click event. Returns an observable that will say whether or not to continue the click event.
+     */
+    interceptButtonClick: () => Observable<boolean>;
+}
+/**
+ * Text and icon display content for a button.
+ */
+interface DbxButtonDisplay {
+    /**
+     * button Icon, if applicable
+     */
+    readonly icon?: Maybe<string>;
+    /**
+     * button text, if applicable
+     */
+    readonly text?: Maybe<string>;
+}
+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<DbxButtonWorking>;
+    /**
+     * 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 a number is passed, then it is treated as a progress percentage.
+     *
+     * If true is passed, then it is treated as an indeterminate progress.
+     *
+     * If null/undefined is passed, then the button will not be working.
+     */
+    abstract setWorking(working?: Maybe<DbxButtonWorking>): 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;
+}
+declare function provideDbxButton<S extends DbxButton>(sourceType: Type<S>): Provider[];
+/**
+ * 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.
+ */
+type DbxButtonDisplayType = 'text_button' | 'icon_button';
+/**
+ * Delegate class used for retrieving the DbxButtonDisplay given an input value.
+ */
+interface DbxButtonDisplayDelegate<T> {
+    /**
+     * Returns the DbxButtonDisplay for the input value.
+     *
+     * @param value
+     */
+    buttonDisplayContentForValue(value: T): DbxButtonDisplay;
+}
+/**
+ * Returns the DbxButtonDisplayType given the input content.
+ *
+ * @param content
+ * @returns
+ */
+declare function dbxButtonDisplayType(content: DbxButtonDisplay): DbxButtonDisplayType;
+
+/**
+ * Context used for linking a button to an ActionContext and only look for triggers.
+ */
+declare class DbxActionButtonTriggerDirective {
+    readonly dbxButton: DbxButton;
+    readonly source: DbxActionContextStoreSourceInstance<any, any>;
+    constructor();
+    protected _buttonClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Context used for linking a button to an ActionContext.
+ */
+declare class DbxActionButtonDirective extends DbxActionButtonTriggerDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxButtonSegueDirective {
+    readonly dbxButton: DbxButton;
+    readonly dbxRouterService: DbxRouterService;
+    readonly segueRef: i0.InputSignal<Maybe<SegueRef<object>>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": { "alias": "dbxButtonSegue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract button component.
+ */
+declare abstract class AbstractDbxButtonDirective implements DbxButton {
+    /**
+     * Pre-interceptor button click.
+     */
+    protected readonly _buttonClick: Subject<void>;
+    protected readonly _buttonInterceptor: BehaviorSubject<Maybe<DbxButtonInterceptor>>;
+    readonly buttonClick: i0.OutputEmitterRef<void>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, Maybe<boolean>>;
+    readonly working: i0.InputSignalWithTransform<_dereekb_dbx_core.DbxActionWorkOrWorkProgress, Maybe<_dereekb_dbx_core.DbxActionWorkOrWorkProgress>>;
+    readonly buttonDisplay: i0.InputSignal<Maybe<DbxButtonDisplay>>;
+    private readonly _disabledSignal;
+    private readonly _workingSignal;
+    private readonly _buttonDisplayContentSignal;
+    readonly disabledSignal: Signal<boolean>;
+    readonly workingSignal: Signal<_dereekb_dbx_core.DbxActionWorkOrWorkProgress>;
+    readonly isWorkingSignal: Signal<boolean>;
+    readonly icon: i0.InputSignal<Maybe<string>>;
+    readonly text: i0.InputSignal<Maybe<string>>;
+    readonly buttonDisplayContentSignal: Signal<DbxButtonDisplay>;
+    readonly buttonDisplayTypeSignal: Signal<DbxButtonDisplayType>;
+    readonly iconSignal: Signal<Maybe<string>>;
+    readonly textSignal: Signal<Maybe<string>>;
+    readonly disabled$: rxjs.Observable<boolean>;
+    readonly working$: rxjs.Observable<_dereekb_dbx_core.DbxActionWorkOrWorkProgress>;
+    readonly display$: rxjs.Observable<DbxButtonDisplay>;
+    readonly clicked$: rxjs.Observable<void>;
+    constructor();
+    setDisabled(disabled?: Maybe<boolean>): void;
+    setWorking(working?: Maybe<DbxButtonWorking>): void;
+    setDisplayContent(content: DbxButtonDisplay): void;
+    /**
+     * Sets the button interceptor. If any interceptor is already set, it is replaced.
+     */
+    setButtonInterceptor(interceptor: DbxButtonInterceptor): void;
+    /**
+     * Main function to use for handling clicks on the button.
+     */
+    clickButton(): void;
+    /**
+     * Forces a button click. Skips the interceptors if any are configured.
+     */
+    protected _forceButtonClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxButtonDirective, never, never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "working": { "alias": "working"; "required": false; "isSignal": true; }; "buttonDisplay": { "alias": "buttonDisplay"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+/**
+ * Provides an DbxButton directive.
+ */
+declare class DbxButtonDirective extends AbstractDbxButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Context used for linking a button to a LoadingContext.
+ *
+ * It will be set working when the context is set loading.
+ */
+declare class DbxLoadingButtonDirective {
+    readonly dbxButton: DbxButton;
+    readonly context: i0.InputSignal<MaybeObservableOrValue<LoadingContext<_dereekb_rxjs.LoadingContextEvent>>>;
+    readonly context$: rxjs.Observable<_dereekb_util.Maybe<LoadingContext<_dereekb_rxjs.LoadingContextEvent>>>;
+    readonly contextSignal: i0.Signal<_dereekb_util.Maybe<LoadingContext<_dereekb_rxjs.LoadingContextEvent>>>;
+    protected readonly _loadingEffectSub: _dereekb_rxjs.SubscriptionObject<rxjs.Unsubscribable>;
+    protected readonly _loadingEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxLoadingButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": { "alias": "dbxLoadingButton"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Exports the following directives:
+ * - DbxButtonDirective
+ * - DbxLoadingButtonDirective
+ * - DbxActionButtonTriggerDirective
+ * - DbxActionButtonDirective
+ * - DbxButtonSegueDirective
+ */
+declare class DbxCoreButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreButtonModule, never, [typeof DbxButtonDirective, typeof DbxLoadingButtonDirective, typeof DbxActionButtonTriggerDirective, typeof DbxActionButtonDirective, typeof DbxButtonSegueDirective], [typeof DbxButtonDirective, typeof DbxLoadingButtonDirective, typeof DbxActionButtonTriggerDirective, typeof DbxActionButtonDirective, typeof DbxButtonSegueDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreButtonModule>;
+}
+
+/**
+ * App environment details
+ */
+declare abstract class DbxAppEnviroment {
+    /**
+     * Whether or not this is a production environment.
+     */
+    abstract production: boolean;
+    /**
+     * Whether or not this is a testing environment.
+     *
+     * Generally "production" is false when this is true.
+     */
+    abstract testing?: boolean;
+    /**
+     * Whether or not this is a staging environment.
+     *
+     * Generally "production" is true when this is true.
+     */
+    abstract staging?: boolean;
+}
+
+/**
+ * Service for accessing the app's environment details.
+ */
+declare class DbxAppEnviromentService {
+    readonly environment: DbxAppEnviroment;
+    get isProduction(): boolean;
+    get isStaging(): boolean;
+    get isTesting(): boolean;
+    /**
+     * Returns the environment, typed as a specific type.
+     */
+    getEnvironment<T extends DbxAppEnviroment>(): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAppEnviromentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAppEnviromentService>;
+}
+
+/**
+ * Provides the DbxAppEnviromentService and DbxAppEnviroment.
+ *
+ * @param environment
+ */
+declare function provideDbxAppEnviroment(environment: DbxAppEnviroment): EnvironmentProviders;
+
+type MouseEventType = 'enter' | 'leave';
+interface MouseEventPair<T> {
+    readonly type: MouseEventType;
+    readonly data: T;
+}
+interface MousableFunction {
+    onMouse?: (type: MouseEventType, event?: Maybe<MouseEvent>) => void;
+}
+
+interface ClickableFunction {
+    readonly onClick?: (event?: Maybe<MouseEvent>) => void;
+}
+/**
+ * Represents a clickable href/url configuration.
+ */
+interface ClickableUrl {
+    /**
+     * href url
+     */
+    readonly url?: string;
+    /**
+     * href target attribute.
+     */
+    readonly target?: string;
+}
+declare function clickableUrlInNewTab(url: string | WebsiteUrl): ClickableUrl;
+declare function clickableUrlMailTo(mailTo: MailToUrlInput): ClickableUrl;
+declare function clickableUrlTel(tel: PhoneNumber | E164PhoneNumberWithOptionalExtension): ClickableUrl;
+
+declare const DBX_INJECTION_COMPONENT_DATA: InjectionToken<unknown>;
+interface DbxInjectionComponentConfig<T = unknown> {
+    /**
+     * Type of Component to initialize.
+     */
+    readonly componentClass: Type<T>;
+    /**
+     * (Optional) providers to provide to the existing injector.
+     */
+    readonly providers?: Maybe<StaticProvider[]>;
+    /**
+     * (Optional) Custom parent injector to use when creating the component.
+     */
+    readonly injector?: Maybe<Injector>;
+    /**
+     * (Optional) Module ref to use when creating the component.
+     */
+    readonly ngModuleRef?: NgModuleRef<unknown>;
+    /**
+     * (Optional) Custom initialization code when an instance is created.
+     *
+     * This is called in an Angular injection context of the created component, so that inject() is available and will be destroyed when the created component is destroyed.
+     */
+    readonly init?: Maybe<(instance: T) => void>;
+    /**
+     * unknown optional data to inject into the component.
+     */
+    readonly data?: Maybe<unknown>;
+}
+/**
+ * The injector may be important to where the dbxInjection is getting injected at. Some types may disallow setting a custom parent injector.
+ */
+type DbxInjectionComponentConfigWithoutInjector<T = unknown> = Omit<DbxInjectionComponentConfig<T>, 'injector'>;
+type DbxInjectionComponentConfigFactory<I, T = unknown> = FactoryWithRequiredInput<DbxInjectionComponentConfig<T>, I>;
+interface DbxInjectionTemplateConfig<T = unknown> {
+    /**
+     * Template ref to display.
+     */
+    readonly templateRef?: Maybe<TemplateRef<T>>;
+    /**
+     * View ref to inject.
+     */
+    readonly viewRef?: Maybe<ViewRef>;
+}
+/**
+ * Merges multiple configurations into a single configuration.
+ *
+ * @param configs
+ * @returns
+ */
+declare function mergeDbxInjectionComponentConfigs<T = unknown>(configs: Maybe<Partial<DbxInjectionComponentConfig<T>>>[]): Partial<DbxInjectionComponentConfig<T>>;
+
+interface ClickableAnchor extends ClickableFunction, MousableFunction, ClickableUrl, Partial<SegueRef> {
+    readonly disabled?: boolean;
+    readonly selected?: boolean;
+}
+/**
+ * Title and an optional icon.
+ */
+interface IconAndTitle {
+    readonly title: string;
+    readonly icon?: Maybe<string>;
+}
+interface ClickableAnchorLink extends ClickableAnchor, IconAndTitle {
+    /**
+     * Optional detail string/content.
+     */
+    readonly hint?: string;
+    /**
+     * Custom injection content for this link.
+     */
+    readonly content?: DbxInjectionComponentConfig;
+}
+/**
+ * ClickableAnchorLink that definitely has a SegueRef
+ */
+type ClickableAnchorLinkSegueRef = ClickableAnchorLink & SegueRef;
+interface ClickableIconAnchorLink extends Omit<ClickableAnchorLink, 'title'> {
+    readonly icon: string;
+}
+interface ClickableAnchorLinkTree extends ClickableAnchorLink {
+    readonly children?: ClickableAnchorLinkTree[];
+}
+type ExpandedClickableAnchorLinkTree = TreeNode<ClickableAnchorLinkTree>;
+declare const expandClickableAnchorLinkTreeNode: ExpandTreeFunction<ClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
+declare const flattenExpandedClickableAnchorLinkTree: FlattenTreeFunction<ExpandedClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
+declare const flattenExpandedClickableAnchorLinkTreeToLinks: FlattenTreeFunction<ExpandedClickableAnchorLinkTree, ClickableAnchorLinkTree>;
+/**
+ * Fully expands the given parent link and flattens the tree to a single parent link.
+ *
+ * @param link
+ * @returns
+ */
+declare function expandClickableAnchorLinkTree(link: ClickableAnchorLinkTree): ExpandedClickableAnchorLinkTree[];
+/**
+ * Expands an array of links into an array of ExpandedClickableAnchorLinkTree tree values.
+ */
+declare const expandClickableAnchorLinkTrees: _dereekb_util.ExpandFlattenTreeFunction<ClickableAnchorLinkTree, ExpandedClickableAnchorLinkTree>;
+/**
+ * Describes the Anchor type given a ClickableAnchor.
+ *
+ * - plain: When the anchor has no specific content but is not disabled. It is a passthrough for the content.
+ * - clickable: When the anchor has a click handler
+ * - sref: When the anchor has a SegueRef
+ * - href: When the anchor has a URL
+ * - disabled: When the anchor is disabled.
+ */
+type ClickableAnchorType = 'plain' | 'clickable' | 'sref' | 'href' | 'disabled';
+declare function anchorTypeForAnchor(anchor: Maybe<ClickableAnchor>, disabled?: Maybe<boolean>): ClickableAnchorType;
+declare abstract class DbxAnchor<T extends ClickableAnchor = ClickableAnchor> {
+    abstract readonly disabled$: Observable<Maybe<boolean>>;
+    abstract readonly selected$: Observable<Maybe<boolean>>;
+    abstract readonly anchor$: Observable<Maybe<T>>;
+    abstract readonly type$: Observable<ClickableAnchorType>;
+}
+declare function provideDbxAnchor<S extends DbxAnchor>(sourceType: Type<S>): Provider[];
+
+/**
+ * Abstract anchor directive.
+ */
+declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor {
+    readonly ref: i0.ModelSignal<Maybe<SegueRefOrSegueRefRouterLink>>;
+    readonly anchor: i0.ModelSignal<Maybe<T>>;
+    readonly disabled: i0.ModelSignal<Maybe<boolean>>;
+    readonly selected: i0.ModelSignal<Maybe<boolean>>;
+    readonly anchorSignal: i0.Signal<Maybe<T>>;
+    readonly selectedSignal: i0.Signal<boolean | undefined>;
+    readonly typeSignal: i0.Signal<ClickableAnchorType>;
+    readonly disabledSignal: i0.Signal<boolean | undefined>;
+    readonly urlSignal: i0.Signal<string | undefined>;
+    readonly targetSignal: i0.Signal<string | undefined>;
+    readonly anchor$: Observable<Maybe<T>>;
+    readonly disabled$: Observable<Maybe<boolean>>;
+    readonly selected$: Observable<Maybe<boolean>>;
+    readonly type$: Observable<ClickableAnchorType>;
+    setRef(ref: Maybe<SegueRefOrSegueRefRouterLink>): void;
+    setAnchor(anchor: Maybe<T>): void;
+    setDisabled(disabled: Maybe<boolean>): void;
+    setSelected(selected: Maybe<boolean>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxAnchorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxAnchorDirective<any>, never, never, { "ref": { "alias": "ref"; "required": false; "isSignal": true; }; "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "ref": "refChange"; "anchor": "anchorChange"; "disabled": "disabledChange"; "selected": "selectedChange"; }, never, never, true, never>;
+}
+
+declare const DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_VALUE = "0";
+declare const DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_KEY = "id";
+interface RedirectForIdentifierParamHookInput {
+    /**
+     * Factory that returns an observable that sends the default allowed identifier to use when accessing the resource.
+     */
+    readonly defaultAllowedValue: (authService: DbxAuthService, injector: Injector, transition: Transition) => Observable<ModelKey>;
+    /**
+     * Route parameter to use.
+     *
+     * Defaults to "uid"
+     */
+    readonly idParam?: string;
+    /**
+     * The default param value to check against.
+     *
+     * Defaults to 0.
+     */
+    readonly defaultParamValue?: string;
+    /**
+     * Criteria or route to watch and intercept.
+     */
+    readonly criteria: HookMatchCriteria | string;
+    readonly transitionService: TransitionService;
+    /**
+     * Whether or not the current user can view the target id.
+     *
+     * Can return another identifier, or true to allow access, or false/null/undefined to deny access.
+     */
+    readonly canViewModelWithId: (targetId: ModelKey, authService: DbxAuthService, injector: Injector) => Observable<Maybe<boolean | ModelKey>>;
+    /**
+     * Hook priority
+     */
+    readonly priority?: number;
+}
+/**
+ * This hook asserts the user is allowed to view a route with an identifier as a state parameter.
+ */
+declare function redirectForIdentifierParamHook(input: RedirectForIdentifierParamHookInput): void;
+
+declare const DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_VALUE = "0";
+declare const DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_KEY = "uid";
+interface RedirectForUserIdentifierParamHookInput {
+    /**
+     * Route parameter to use.
+     *
+     * Defaults to "uid"
+     */
+    readonly uidParam?: string;
+    /**
+     * The default param value to check against.
+     *
+     * Defaults to 0.
+     */
+    readonly defaultParamValue?: string;
+    /**
+     * Criteria or route to watch and intercept.
+     */
+    readonly criteria: HookMatchCriteria | string;
+    readonly transitionService: TransitionService;
+    /**
+     * Whether or not the current user can view the target user.
+     *
+     * Can return another users identifier, or true to allow access, or false/null/undefined to deny access.
+     */
+    readonly canViewUser: (targetUid: AuthUserIdentifier, authService: DbxAuthService, injector: Injector) => Observable<Maybe<boolean | AuthUserIdentifier>>;
+    /**
+     * Hook priority
+     */
+    readonly priority?: number;
+}
+/**
+ * This hook asserts the user is allowed to view a route with a user identifier as a parameter.
+ */
+declare function redirectForUserIdentifierParamHook(input: RedirectForUserIdentifierParamHookInput): void;
+
+/**
+ * AngularRouter implementation of DbxRouterService and DbxRouterTransitionService.
+ */
+declare class DbxAngularRouterService implements DbxRouterService, DbxRouterTransitionService {
+    readonly router: Router;
+    readonly activatedRoute: ActivatedRoute;
+    readonly params$: Observable<SegueRefRawSegueParams>;
+    readonly transitions$: Observable<DbxRouterTransitionEvent>;
+    go(input: ObservableOrValue<SegueRefOrSegueRefRouterLink<NavigationExtras | NavigationBehaviorOptions>>): Promise<boolean>;
+    updateParams(inputParams: ObservableOrValue<SegueRefRawSegueParams>): Promise<boolean>;
+    isActive(segueRef: SegueRefOrSegueRefRouterLink): boolean;
+    isActiveExactly(segueRef: SegueRefOrSegueRefRouterLink): boolean;
+    comparePrecision(a: SegueRefOrSegueRefRouterLink, b: SegueRefOrSegueRefRouterLink): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxAngularRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxAngularRouterService>;
+}
+
+declare class DbxCoreAngularRouterSegueModule {
+    static forRoot(): ModuleWithProviders<DbxCoreAngularRouterSegueModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreAngularRouterSegueModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreAngularRouterSegueModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreAngularRouterSegueModule>;
+}
+
+/**
+ * UIRouter implementation of DbxRouterService and DbxRouterTransitionService.
+ */
+declare class DbxUIRouterService implements DbxRouterService, DbxRouterTransitionService, OnDestroy {
+    readonly state: StateService;
+    readonly transitionService: TransitionService;
+    readonly uiRouterGlobals: UIRouterGlobals;
+    private readonly _params;
+    readonly params$: Observable<SegueRefRawSegueParams>;
+    private readonly _transitions;
+    readonly transitions$: Observable<DbxRouterTransitionEvent>;
+    constructor();
+    ngOnDestroy(): void;
+    get params(): _uirouter_core.StateParams;
+    go(input: ObservableOrValue<SegueRefOrSegueRefRouterLink<TransitionOptions>>): Promise<boolean>;
+    updateParams(inputParams: ObservableOrValue<SegueRefRawSegueParams>): Promise<boolean>;
+    isActive(input: SegueRefOrSegueRefRouterLink): boolean;
+    isActiveExactly(input: SegueRefOrSegueRefRouterLink): boolean;
+    comparePrecision(aInput: SegueRefOrSegueRefRouterLink, bInput: SegueRefOrSegueRefRouterLink): number;
+    isActiveState(input: SegueRefOrSegueRefRouterLink, exactly: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxUIRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxUIRouterService>;
+}
+
+/**
+ * Provides a DbxUIRouterService and configures it to provide for DbxRouterService and DbxRouterTransitionService.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxUIRouterService(): EnvironmentProviders;
+
+/**
+ * Convenience function for filtering success from the input observable.
+ *
+ * @param obs
+ * @returns
+ */
+declare function successTransition(obs: Observable<DbxRouterTransitionEvent>): Observable<DbxRouterTransitionEvent>;
+declare function filterTransitionSuccess(): MonoTypeOperatorFunction<DbxRouterTransitionEvent>;
+declare function filterTransitionEvent(type: DbxRouterTransitionEventType): MonoTypeOperatorFunction<DbxRouterTransitionEvent>;
+interface LatestSuccessfulRoutesConfigRoute {
+    /**
+     * Route to check if it is active or not.
+     */
+    readonly route: SegueRefOrSegueRefRouterLink;
+    /**
+     * Whether or not to match the route exactly.
+     */
+    readonly activeExactly?: boolean;
+}
+/**
+ * latestSuccessfulRoute() config
+ */
+interface LatestSuccessfulRoutesConfig<T extends LatestSuccessfulRoutesConfigRoute> {
+    readonly dbxRouterTransitionService: DbxRouterTransitionService;
+    readonly dbxRouterService: DbxRouterService;
+    /**
+     * Route or list of routes to check if they're active or not.
+     */
+    readonly routes: ArrayOrValue<T>;
+}
+/**
+ * Creates a new observable that uses the input DbxRouterTransitionService and DbxRouterService to determine whether or not any of the configured routes are active.
+ *
+ * @param obs
+ * @param config
+ * @returns
+ */
+declare function latestSuccessfulRoutes<T extends LatestSuccessfulRoutesConfigRoute>(config: LatestSuccessfulRoutesConfig<T>): Observable<T[]>;
+/**
+ * isLatestSuccessfulRoute() config
+ */
+interface IsLatestSuccessfulRouteConfig {
+    readonly dbxRouterTransitionService: DbxRouterTransitionService;
+    readonly dbxRouterService: DbxRouterService;
+    /**
+     * Route or list of routes to check if they're active or not.
+     */
+    readonly routes: ArrayOrValue<SegueRefOrSegueRefRouterLink>;
+    /**
+     * Whether or not to match route activity exactly.
+     */
+    readonly activeExactly?: boolean;
+}
+/**
+ * Creates a new observable that uses the input DbxRouterTransitionService and DbxRouterService to determine whether or not any of the configured routes are active.
+ *
+ * @param obs
+ * @param config
+ * @returns
+ */
+declare function isLatestSuccessfulRoute(config: IsLatestSuccessfulRouteConfig): Observable<boolean>;
+
+/**
+ * Abstract directive that listens to onSuccess transition events and runs a function.
+ */
+declare abstract class AbstractTransitionDirective {
+    protected readonly dbxRouterTransitionService: DbxRouterTransitionService;
+    readonly transitionSuccess$: Observable<_dereekb_dbx_core.DbxRouterTransitionEvent>;
+    readonly initAndUpdateOnTransitionSuccess$: Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTransitionDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that listens to onSuccess transition events and runs a function.
+ */
+declare abstract class AbstractTransitionWatcherDirective extends AbstractTransitionDirective {
+    protected readonly ngZone: NgZone;
+    constructor();
+    protected zoneUpdateForSuccessfulTransition(): void;
+    protected abstract updateForSuccessfulTransition(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractTransitionWatcherDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractTransitionWatcherDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Function that returns true when the configured segueRef is active.
+ */
+type IsSegueRefActiveFunction = (() => boolean) & {
+    readonly _segueRef: SegueRefOrSegueRefRouterLink;
+    readonly _activeExactly: boolean;
+};
+interface IsSegueRefActiveFunctionConfig {
+    readonly dbxRouterService: DbxRouterService;
+    readonly segueRef: SegueRefOrSegueRefRouterLink;
+    /**
+     * Whether or not to match the route exactly.
+     *
+     * False by default.
+     */
+    readonly activeExactly?: boolean;
+}
+/**
+ * Creates an IsSegueRefActiveFunction
+ *
+ * @param config
+ * @returns
+ */
+declare function isSegueRefActiveFunction(config: IsSegueRefActiveFunctionConfig): IsSegueRefActiveFunction;
+
+declare function onRouterTransitionEventType(events$: Observable<DbxRouterTransitionEvent>, type: DbxRouterTransitionEventType): Observable<DbxRouterTransitionEvent>;
+declare function onRouterTransitionSuccessEvent(events$: Observable<DbxRouterTransitionEvent>): Observable<DbxRouterTransitionEvent>;
+/**
+ * Creates an observable that returns true when the route for the input segueRef is active.
+ *
+ * @param dbxRouterService
+ * @param segueRef
+ */
+declare function isSegueRefActiveOnTransitionSuccess(config: IsSegueRefActiveFunctionConfig): Observable<boolean>;
+interface IsSegueRefActiveConfig extends Pick<IsSegueRefActiveFunctionConfig, 'dbxRouterService' | 'activeExactly'> {
+    /**
+     * What to pipe if the input segueRef is null.
+     */
+    readonly defaultIfNull?: boolean;
+}
+/**
+ * Operator function that maps the input segueRef to a boolean depending on the current route state.
+ *
+ * @param dbxRouterService
+ * @param segueRef
+ */
+declare function isSegueRefActive(config: IsSegueRefActiveConfig): OperatorFunction<Maybe<SegueRefOrSegueRefRouterLink>, boolean>;
+
+/**
+ * Function that will perform navigation with the input route.
+ */
+type GoWithRouter = (route: ObservableOrValue<SegueRef>) => Promise<boolean>;
+/**
+ * Creates a GoWithRouter function.
+ *
+ * @param dbxRouterService
+ * @returns
+ */
+declare function goWithRouter(dbxRouterService: DbxRouterService): (route: ObservableOrValue<SegueRefOrSegueRefRouterLink>) => Promise<boolean>;
+
+/**
+ * Interface used for reading a single value from the DbxRouterService. Supports a default value.
+ */
+interface DbxRouteParamReader<T> {
+    /**
+     * The param value as read from the current router state.
+     */
+    readonly paramValue$: Observable<Maybe<T>>;
+    /**
+     * The default value observable.
+     */
+    readonly defaultValue$: Observable<Maybe<T>>;
+    /**
+     * The current value given the paramValue and the defaultValue.
+     */
+    readonly value$: Observable<Maybe<T>>;
+    /**
+     * Returns the current param key.
+     */
+    getParamKey(): string;
+    /**
+     * Sets a new param key. If the value is undefined, the param reader will use the default key.
+     */
+    setParamKey(paramKey: Maybe<string>): void;
+    /**
+     * Sets the default value source.
+     *
+     * @param defaultValue
+     */
+    setDefaultValue(defaultValue: MaybeObservableOrValueGetter<T>): void;
+    /**
+     * Updates the value on the current route for the paramKey.
+     *
+     * @param value
+     */
+    setParamValue(value: MaybeObservableOrValueGetter<T>): void;
+}
+interface DbxRouteParamReaderInstance<T> extends DbxRouteParamReader<T>, Destroyable {
+    readonly dbxRouterService: DbxRouterService;
+    readonly paramKey$: Observable<string>;
+    readonly nextDefaultValue$: Observable<Maybe<T>>;
+    readonly value$: Observable<Maybe<T>>;
+}
+/**
+ * Creates a new DbxRouteParamReaderInstance from the input.
+ *
+ * @param dbxRouterService
+ * @param defaultParamKey
+ * @param defaultValue
+ * @returns
+ */
+declare function dbxRouteParamReaderInstance<T>(dbxRouterService: DbxRouterService, defaultParamKey: string, defaultValue?: MaybeObservableOrValueGetter<T>): DbxRouteParamReaderInstance<T>;
+
+/**
+ * Utility class used in conjuction with a DbxRouteParamReaderInstance to redirect when the default param is not valid.
+ */
+declare class DbxRouteParamDefaultRedirectInstance<T> implements Initialized, Destroyable {
+    private readonly instance;
+    private readonly _enabled;
+    private readonly _useDefaultFilter;
+    private readonly _sub;
+    constructor(instance: DbxRouteParamReaderInstance<T>);
+    init(): void;
+    destroy(): void;
+    protected redirectWithDefaultValue(value: Maybe<T>): Promise<boolean>;
+    protected redirectWithValue(value: Maybe<T>): Promise<boolean>;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    setUseDefaultFilter(useValueFilter: Maybe<SwitchMapToDefaultFilterFunction<T>>): void;
+}
+
+/**
+ * Default identifier used by dbxRouteModelIdParamRedirect() that corresponds to the id param of the model in the current route.
+ */
+declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_ID_PARAM_KEY = "id";
+/**
+ * Default identifier used by dbxRouteModelIdParamRedirect() that corresponds to the key param of the model in the current route.
+ */
+declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_KEY_PARAM_KEY = "key";
+/**
+ * Default value used by dbxRouteModelIdParamRedirect() for when a value is not available or provided.
+ */
+declare const DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_USE_PARAM_VALUE = "0";
+/**
+ * Used to read an id with a specific key from the current route.
+ *
+ * Can be configured to redirect to a default route if a specific value is seen.
+ */
+interface DbxRouteModelIdParamRedirect extends DbxRouteParamReader<ModelKey> {
+    /**
+     * The id value as it is from the current state's params.
+     */
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    /**
+     * The id value as it is when considering the default value.
+     */
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+}
+/**
+ *DbxRouteModelIdParamRedirect instance
+ */
+interface DbxRouteModelIdParamRedirectInstance extends DbxRouteModelIdParamRedirect, DbxRouteParamReader<ModelKey>, Initialized, Destroyable {
+    readonly paramValue$: Observable<Maybe<string>>;
+    readonly defaultValue$: Observable<Maybe<string>>;
+    readonly value$: Observable<Maybe<string>>;
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    readonly id$: Observable<Maybe<ModelKey>>;
+    setParamKey(paramKey: Maybe<string>): void;
+    setDefaultValue(defaultValue: MaybeObservableOrValueGetter<string>): void;
+    setRedirectEnabled(redirect: Maybe<boolean>): void;
+    setDecider(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>): void;
+    setParamValue(value: MaybeObservableOrValueGetter<string>): void;
+}
+declare function dbxRouteModelKeyParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxRouteModelIdParamRedirectInstance;
+declare function dbxRouteModelIdParamRedirect(dbxRouterService: DbxRouterService, defaultParamKey?: string): DbxRouteModelIdParamRedirectInstance;
+
+/**
+ * DbxRouteModelIdDirective delegate that can recieve an observable of the model id from the route.
+ */
+declare abstract class DbxRouteModelIdDirectiveDelegate {
+    /**
+     * Passes the param value and computed value from the DbxRouteModelIdDirective to this delegate.
+     *
+     * @param idFromParamsObs
+     * @param computedIdObs
+     */
+    abstract useRouteModelIdParamsObservable(idFromParamsObs: Observable<Maybe<ModelKey>>, computedIdObs: Observable<Maybe<ModelKey>>): Subscription;
+}
+/**
+ * Configures providers for a DbxRouteModelIdDirectiveDelegate.
+ */
+declare function provideDbxRouteModelIdDirectiveDelegate<S extends DbxRouteModelIdDirectiveDelegate>(sourceType: Type<S>): Provider[];
+/**
+ * DbxRouteModelKeyDirective delegate that can recieve an observable of the model id from the route.
+ */
+declare abstract class DbxRouteModelKeyDirectiveDelegate {
+    /**
+     * Passes the param value and computed value from the DbxRouteModelKeyDirective to this delegate.
+     *
+     * @param keyFromParamsObs
+     * @param computedKeyObs
+     */
+    abstract useRouteModelKeyParamsObservable(keyFromParamsObs: Observable<Maybe<ModelKey>>, computedKeyObs: Observable<Maybe<ModelKey>>): Subscription;
+}
+/**
+ * Configures providers for a DbxRouteModelKeyDirectiveDelegate.
+ */
+declare function provideDbxRouteModelKeyDirectiveDelegate<S extends DbxRouteModelKeyDirectiveDelegate>(sourceType: Type<S>): Provider[];
+
+/**
+ * Used for retrieving the user's current id DbxAuthService and passes it as an identifier for a DbxRouteModelIdDirectiveDelegate.
+ */
+declare class DbxRouteModelIdFromAuthUserIdDirective {
+    readonly dbxAuthService: DbxAuthService;
+    readonly dbxRouteModelIdDelegate: DbxRouteModelIdDirectiveDelegate;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelIdFromAuthUserIdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelIdFromAuthUserIdDirective, "[dbxRouteModelIdFromAuthUserId]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used for retrieving the model's id from the current route using the configured parameter and passes it to its delegate.
+ */
+declare class DbxRouteModelIdDirective {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxRouteModelIdDelegate: DbxRouteModelIdDirectiveDelegate;
+    private readonly _redirectInstance;
+    readonly idFromParams$: Observable<Maybe<ModelKey>>;
+    readonly id$: Observable<Maybe<ModelKey>>;
+    constructor();
+    get idParam(): string;
+    set idParam(idParam: string);
+    set dbxRouteModelIdDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);
+    /**
+     * Whether or not to enable the redirection. Is enabled by default.
+     */
+    set dbxRouteModelIdDefaultRedirect(redirect: Maybe<boolean> | '');
+    set dbxRouteModelIdDefaultDecision(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelIdDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelIdDirective, "[dbxRouteModelId]", never, { "idParam": { "alias": "dbxRouteModelId"; "required": false; }; "dbxRouteModelIdDefault": { "alias": "dbxRouteModelIdDefault"; "required": false; }; "dbxRouteModelIdDefaultRedirect": { "alias": "dbxRouteModelIdDefaultRedirect"; "required": false; }; "dbxRouteModelIdDefaultDecision": { "alias": "dbxRouteModelIdDefaultDecision"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Used for retrieving the model's key from the current route using the configured parameter and passes it to its delegate.
+ *
+ * If the key does not exist in the params, then the p
+ */
+declare class DbxRouteModelKeyDirective {
+    readonly dbxRouterService: DbxRouterService;
+    readonly dbxRouteModelKeyDelegate: DbxRouteModelKeyDirectiveDelegate;
+    private readonly _redirectInstance;
+    readonly keyFromParams$: Observable<Maybe<ModelKey>>;
+    readonly key$: Observable<Maybe<ModelKey>>;
+    constructor();
+    get keyParam(): string;
+    set keyParam(idParam: string);
+    set dbxRouteModelKeyDefault(defaultValue: MaybeObservableOrValueGetter<ModelKey>);
+    /**
+     * Whether or not to enable the redirection. Is enabled by default.
+     */
+    set dbxRouteModelKeyDefaultRedirect(redirect: Maybe<boolean> | '');
+    set dbxRouteModelKeyDefaultDecision(decider: string | SwitchMapToDefaultFilterFunction<ModelKey>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxRouteModelKeyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxRouteModelKeyDirective, "[dbxRouteModelKey]", never, { "keyParam": { "alias": "dbxRouteModelKey"; "required": false; }; "dbxRouteModelKeyDefault": { "alias": "dbxRouteModelKeyDefault"; "required": false; }; "dbxRouteModelKeyDefaultRedirect": { "alias": "dbxRouteModelKeyDefaultRedirect"; "required": false; }; "dbxRouteModelKeyDefaultDecision": { "alias": "dbxRouteModelKeyDefaultDecision"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Pipes an ObservableOrValueGetter to an Observable value.
+ */
+declare class AsObservablePipe implements PipeTransform {
+    transform<T>(input: ObservableOrValueGetter<T>): Observable<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsObservablePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsObservablePipe, "asObservable", true>;
+}
+
+declare class DateDayRangePipe implements PipeTransform {
+    transform(input: Maybe<DateRange>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDayRangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDayRangePipe, "dateDayRange", true>;
+}
+
+declare class DateDistancePipe implements PipeTransform {
+    transform(input: Maybe<DateOrDateString>, inputTo?: Maybe<Date>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDistancePipe, "dateDistance", true>;
+}
+
+/**
+ * Pipe that takes in a date and appends the distance to it in parenthesis.
+ */
+declare class DateFormatDistancePipe implements PipeTransform {
+    private readonly locale;
+    transform(input: Maybe<DateOrDateString>, format: string, includeSeconds?: boolean): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatDistancePipe, "dateFormatDistance", true>;
+}
+
+/**
+ * Pipe that takes in a date and number of minutes and outputs a formatted date.
+ */
+declare class DateFormatFromToPipe implements PipeTransform {
+    private readonly locale;
+    static formatFromTo(input: Maybe<DateOrDateString>, format: string, minutes: number, locale: string): Maybe<string>;
+    transform(input: Maybe<DateOrDateString>, format: string, minutes: number): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatFromToPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatFromToPipe, "dateFormatFromTo", true>;
+}
+
+declare class DateDayTimeRangePipe implements PipeTransform {
+    transform(input: Maybe<DateRange>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDayTimeRangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDayTimeRangePipe, "dateDayTimeRange", true>;
+}
+
+declare class DateTimeRangePipe implements PipeTransform {
+    transform(input: Maybe<DateRange>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeRangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeRangePipe, "dateTimeRange", true>;
+}
+
+declare class DateRangeDistancePipe implements PipeTransform {
+    transform(input: Maybe<Date | DateRange>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateRangeDistancePipe, "dateRangeDistance", true>;
+}
+
+declare class DateTimeRangeOnlyPipe implements PipeTransform {
+    transform(input: Maybe<DateRange>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeRangeOnlyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeRangeOnlyPipe, "dateTimeRangeOnly", true>;
+}
+
+/**
+ * Converts the input date and timezone to a system date that represents that date/time.
+ */
+declare class TargetDateToSystemDatePipe implements PipeTransform {
+    transform(input: Maybe<Date>, timezone: Maybe<TimezoneString>): Maybe<Date>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TargetDateToSystemDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TargetDateToSystemDatePipe, "targetDateToSystemDate", true>;
+}
+
+declare class DateTimeRangeOnlyDistancePipe implements PipeTransform {
+    transform(input: Maybe<DateRange>, config?: FormatDateRangeDistanceFunctionConfig, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeRangeOnlyDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateTimeRangeOnlyDistancePipe, "dateTimeRangeOnlyDistance", true>;
+}
+
+/**
+ * Converts the input date and timezone to the proper abbreviation. Uses the input date for the context, or uses now.
+ */
+declare class TimezoneAbbreviationPipe implements PipeTransform {
+    transform(timezone: Maybe<TimezoneString>, input?: Maybe<Date>): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimezoneAbbreviationPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimezoneAbbreviationPipe, "timezoneAbbreviation", true>;
+}
+
+/**
+ * Converts the input date and timezone to a target date that represents that date/time for the timezone.
+ */
+declare class SystemDateToTargetDatePipe implements PipeTransform {
+    transform(input: Maybe<Date>, timezone: Maybe<TimezoneString>): Maybe<Date>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemDateToTargetDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SystemDateToTargetDatePipe, "systemDateToTargetDate", true>;
+}
+
+declare class MinutesStringPipe implements PipeTransform {
+    transform(input: Maybe<number | string>): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinutesStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MinutesStringPipe, "minutesString", true>;
+}
+
+declare class TimeDistanceCountdownPipe implements PipeTransform {
+    transform(input: Maybe<DateOrDateString>, soonString?: string, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeDistanceCountdownPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeDistanceCountdownPipe, "timeCountdownDistance", true>;
+}
+declare class TimeDistancePipe implements PipeTransform {
+    transform(input: Maybe<DateOrDateString>, to?: Maybe<Date>, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeDistancePipe, "timeDistance", true>;
+}
+
+declare class ToJsDatePipe implements PipeTransform {
+    static toJsDate(input: DateOrDateString): Date;
+    static toJsDate(input: Maybe<DateOrDateString>): Maybe<Date>;
+    transform(input: Maybe<DateOrDateString>): Maybe<Date>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToJsDatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToJsDatePipe, "toJsDate", true>;
+}
+
+declare class ToMinutesPipe implements PipeTransform {
+    transform(milliseconds: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToMinutesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToMinutesPipe, "toMinutes", true>;
+}
+
+declare class PrettyJsonPipe implements PipeTransform {
+    static toPrettyJson(input: Maybe<unknown>, spacing?: number): Maybe<string>;
+    transform(input: Maybe<unknown>, spacing?: number): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PrettyJsonPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PrettyJsonPipe, "prettyjson", true>;
+}
+
+/**
+ * Pipe that cuts the input text to the requested length and adds elipsis.
+ */
+declare class CutTextPipe implements PipeTransform {
+    transform(input: Maybe<string>, maxLength: number, endText?: Maybe<string>): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CutTextPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CutTextPipe, "cutText", true>;
+}
+
+/**
+ * Retrieves the value from the getter. This is a non-pure pipe. Use the getValueOncePipe instead for a pure pipe.
+ */
+declare class GetValuePipe implements PipeTransform {
+    transform<T, A = any>(input: GetterOrValue<T>, args?: A): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetValuePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GetValuePipe, "getValue", true>;
+}
+/**
+ * Pipes a GetValuePipe to an Observable value.
+ */
+declare class GetValueOncePipe implements PipeTransform {
+    transform<T, A = any>(input: GetterOrValue<T>, args?: A): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GetValueOncePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GetValueOncePipe, "getValueOnce", true>;
+}
+
+/**
+ * Pipe that takes in a number and returns the number formatted as a dollar using dollarAmountString().
+ *
+ * Can provide a default string value to use when the input is null or undefined.
+ */
+declare class DollarAmountPipe implements PipeTransform {
+    transform(input: Maybe<number>, defaultIfNull?: Maybe<string>): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DollarAmountPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DollarAmountPipe, "dollarAmount", true>;
+}
+
+/**
+ * Abstract FilterSourceConnector directive.
+ */
+declare abstract class AbstractFilterSourceConnectorDirective<F> implements FilterSourceConnector<F>, FilterSource<F> {
+    private readonly _source;
+    readonly filter$: Observable<F>;
+    connectWithSource(filterSource: FilterSource<F>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceConnectorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceConnectorDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare const FILTER_SOURCE_DIRECTIVE_DEFAULT_FILTER_TOKEN: InjectionToken<Maybe<Observable<unknown>>>;
+declare abstract class FilterSourceDirective<F = unknown> implements FilterSource<F> {
+    abstract readonly filter$: Observable<F>;
+    abstract initWithFilter(filterObs: Observable<F>): void;
+    abstract setFilter(filter: F): void;
+    abstract resetFilter(): void;
+}
+type ProvideFilterSourceDirectiveDefaultFilterFactoryFunction<F = unknown> = (injector: Injector) => MaybeObservableOrValue<F>;
+/**
+ * Angular provider convenience function for a FilterSourceDirective.
+ */
+declare function provideFilterSourceDirective<S extends FilterSourceDirective<F>, F = unknown>(sourceType: Type<S>, defaultFilterFactory?: ProvideFilterSourceDirectiveDefaultFilterFactoryFunction): Provider[];
+/**
+ * Abstract FilterSource implementation and directive.
+ */
+declare abstract class AbstractFilterSourceDirective<F = unknown> implements FilterSourceDirective<F>, OnDestroy {
+    private readonly _defaultFilter;
+    protected readonly _defaultFilterSource: FilterSourceInstance<F>;
+    readonly filter$: Observable<F>;
+    ngOnDestroy(): void;
+    protected setDefaultFilter(defaultFilter: Observable<Maybe<F>>): void;
+    initWithFilter(filterObs: Observable<F>): void;
+    setFilter(filter: F): void;
+    resetFilter(): void;
+    setInitialFilterTakesPriority(initialFilterTakesPriority: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractFilterSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractFilterSourceDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Connects the host FilterSource to a FilterSourceConnector.
+ */
+declare class DbxFilterConnectSourceDirective<F = unknown> implements OnInit {
+    readonly filterSource: FilterSource<any>;
+    readonly filterSourceConnector: FilterSourceConnector<any>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterConnectSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterConnectSourceDirective<any>, "[dbxFilterConnectSource]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Used as a FilterSource and FilterSourceConnector.
+ */
+declare class DbxFilterSourceConnectorDirective<F = unknown> extends AbstractFilterSourceConnectorDirective<F> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceConnectorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceConnectorDirective<any>, "[dbxFilterSourceConnector]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Angular provider convenience function for a FilterSource.
+ */
+declare function provideFilterSource<S extends FilterSource>(sourceType: Type<S>): Provider[];
+/**
+ * Angular provider convenience function for a FilterSourceConnector.
+ */
+declare function provideFilterSourceConnector<S extends FilterSourceConnector>(sourceType: Type<S>): Provider[];
+
+/**
+ * Provides a FilterSource from a parent FilterMap.
+ */
+declare abstract class AbstractDbxFilterMapInstanceDirective<F> implements OnDestroy {
+    readonly dbxFilterMap: FilterMap<any>;
+    private readonly _currentFilterMapKey;
+    readonly filterMapKey$: rxjs.Observable<string>;
+    readonly instance$: rxjs.Observable<_dereekb_rxjs.FilterMapKeyInstance<any>>;
+    ngOnDestroy(): void;
+    setFilterMapKey(filterMapKey: MaybeObservableOrValue<FilterMapKey>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapInstanceDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that extends AbstractDbxFilterMapInstanceDirective and implements FilterSource.
+ */
+declare abstract class AbstractDbxFilterMapSourceDirective<F> extends AbstractDbxFilterMapInstanceDirective<F> implements FilterSource<F> {
+    readonly filter$: Observable<F>;
+    initWithFilter(filterObs: Observable<F>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxFilterMapSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxFilterMapSourceDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+/**
+ * Provides a FilterSource from a parent FilterMap.
+ */
+declare class DbxFilterMapSourceDirective<F> extends AbstractDbxFilterMapSourceDirective<F> implements FilterSource<F> {
+    readonly dbxFilterMapSource: i0.InputSignal<Maybe<string>>;
+    protected readonly _dbxFilterMapSourceEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceDirective<any>, "[dbxFilterMapSource]", ["dbxFilterMapSource"], { "dbxFilterMapSource": { "alias": "dbxFilterMapSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Acts as an "input" FilterSourceConnector for an FilterMap, as well as a source for the FilterSourceConnector.
+ */
+declare class DbxFilterMapSourceConnectorDirective<F> extends AbstractDbxFilterMapSourceDirective<F> implements FilterSourceConnector<F> {
+    readonly dbxFilterMapSourceConnector: i0.InputSignal<Maybe<string>>;
+    protected readonly _dbxFilterMapSourceConnectorEffect: i0.EffectRef;
+    connectWithSource(filterSource: FilterSource<F>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapSourceConnectorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapSourceConnectorDirective<any>, "[dbxFilterMapSourceConnector]", ["dbxFilterMapSourceConnector"], { "dbxFilterMapSourceConnector": { "alias": "dbxFilterMapSourceConnector"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Direction that provides a FilterMap.
+ */
+declare class DbxFilterMapDirective<F> {
+    readonly filterMap: FilterMap<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterMapDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterMapDirective<any>, "[dbxFilterMap]", ["dbxFilterMap"], {}, {}, never, never, true, never>;
+}
+
+interface ClickableFilterPreset<F extends FilterWithPreset<P>, P extends string = string> extends Pick<ClickableAnchorLink, 'title' | 'icon' | 'disabled'>, FilterPresetStringRef<P> {
+    /**
+     * GetterOrValue that retrieves the filter for this preset.
+     *
+     * A null value or empty object is used for reset.
+     */
+    readonly presetValue: GetterOrValue<FilterWithPresetOptional<F>> | EmptyObject | null;
+}
+declare function isClickableFilterPreset<F extends FilterWithPreset<P>, P extends string = string>(preset: object): preset is ClickableFilterPreset<F, P>;
+interface ClickablePartialFilterPreset<F> extends Pick<ClickableAnchorLink, 'title' | 'icon' | 'disabled'> {
+    /**
+     * GetterOrValue that retrieves the partial filter value.
+     *
+     * A null value or empty object is used for no change.
+     */
+    readonly partialPresetValue: GetterOrValue<Partial<F>> | EmptyObject | null;
+    /**
+     * The current value to test against. Returns true if this partial preset is considered active.
+     */
+    readonly isActive: (currentFilter: Maybe<Partial<F>>) => boolean;
+}
+declare function isClickablePartialFilterPreset<F>(preset: object): preset is ClickablePartialFilterPreset<F>;
+/**
+ * Convenience type for either a ClickableFilterPreset or a ClickablePartialFilterPreset of the same type.
+ */
+type ClickableFilterPresetOrPartialPreset<F extends FilterWithPreset<P>, P extends string = string> = ClickableFilterPreset<F, P> | ClickablePartialFilterPreset<F>;
+
+/**
+ * Basic filter source directive.
+ */
+declare class DbxFilterSourceDirective<F> extends AbstractFilterSourceDirective<F> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFilterSourceDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFilterSourceDirective<any>, "[dbxFilterSource]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxCoreFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreFilterModule, never, [typeof DbxFilterSourceDirective, typeof DbxFilterMapSourceConnectorDirective, typeof DbxFilterConnectSourceDirective, typeof DbxFilterSourceConnectorDirective, typeof DbxFilterMapDirective, typeof DbxFilterMapSourceDirective], [typeof DbxFilterSourceDirective, typeof DbxFilterMapSourceConnectorDirective, typeof DbxFilterConnectSourceDirective, typeof DbxFilterSourceConnectorDirective, typeof DbxFilterMapDirective, typeof DbxFilterMapSourceDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreFilterModule>;
+}
+
+/**
+ * A keyed configuration entry
+ */
+interface DbxInjectionArrayEntry<T = unknown> extends ModelKeyRef {
+    /**
+     * Observable or value containing the DbxInjectionComponentConfig.
+     */
+    readonly injectionConfig: ObservableOrValueGetter<DbxInjectionComponentConfig<T>>;
+}
+
+/**
+ * Component that injects content based on the configuration into the view.
+ */
+declare class DbxInjectionArrayComponent {
+    readonly entries: i0.InputSignal<Maybe<DbxInjectionArrayEntry<unknown>[]>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionArrayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionArrayComponent, "dbx-injection-array", never, { "entries": { "alias": "entries"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that injects content based on the configuration into the view.
+ */
+declare abstract class AbstractDbxInjectionDirective<T> implements OnInit, OnDestroy {
+    private readonly _instance;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setConfig(config: Maybe<ObservableOrValueGetter<Maybe<DbxInjectionComponentConfig<T>>>>): void;
+    setTemplate(template: Maybe<ObservableOrValueGetter<Maybe<DbxInjectionTemplateConfig<T>>>>): void;
+    setContent(content: Maybe<ViewContainerRef>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxInjectionDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxInjectionDirective<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Component that injects content based on the configuration into the view.
+ */
+declare class DbxInjectionComponent<T> extends AbstractDbxInjectionDirective<T> {
+    readonly content: i0.Signal<ViewContainerRef | undefined>;
+    readonly config: i0.InputSignal<Maybe<ObservableOrValueGetter<Maybe<DbxInjectionComponentConfig<T>>>>>;
+    readonly template: i0.InputSignal<Maybe<ObservableOrValueGetter<Maybe<DbxInjectionTemplateConfig<T>>>>>;
+    protected readonly _contentEffect: i0.EffectRef;
+    protected readonly _configEffect: i0.EffectRef;
+    protected readonly _templateEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxInjectionComponent<any>, "dbx-injection, [dbxInjection], [dbx-injection]", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * DbxInjectedViewContext showContext() configuration.
+ */
+interface DbxInjectionContextConfig<T = unknown, O = unknown> {
+    /**
+     * Injected config.
+     */
+    config: DbxInjectionComponentConfig<T>;
+    /**
+     * Promise used to retrieve data from the given instance.
+     */
+    use: (instance: T) => Promise<O>;
+}
+/**
+ * View that can switch to show another arbitrary view, then switch back when the promise ends.
+ *
+ * It is similar to *ngIf/*ngSwitch, but the original child content is retained instead of discarded,
+ * and returns once the special context is done being used.
+ */
+declare abstract class DbxInjectionContext {
+    /**
+     * Shows the given context until the promise ends, then displays the original content.
+     *
+     * The original content is hidden instead of removed from the context to avoid destruction of children elements.
+     */
+    abstract showContext<T = unknown, O = unknown>(config: DbxInjectionContextConfig<T>): Promise<O>;
+    /**
+     * Bails out of any current promise, if one is set.
+     *
+     * Returns true if the bail signal has been sent.
+     */
+    abstract resetContext(): boolean;
+}
+/**
+ * Allows a directive to provide a formly context and form.
+ */
+declare function provideDbxInjectionContext<T extends DbxInjectionContext>(type: Type<T>): Provider[];
+
+/**
+ * DbxInjectedViewContext implementation. Acts similar to *ngIf, but instead switches to a different view without destroying the original child view.
+ */
+declare class DbxInjectionContextDirective<O = unknown> implements DbxInjectionContext, OnInit, OnDestroy {
+    private readonly _injector;
+    private readonly _templateRef;
+    private readonly _viewContainer;
+    private readonly _instance;
+    private _currentPromise;
+    private _embeddedView;
+    private _isDetached;
+    readonly config: i0.InputSignal<Maybe<DbxInjectionComponentConfig<unknown>>>;
+    protected readonly _configEffect: i0.EffectRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    showContext<T, O>(config: DbxInjectionContextConfig<T>): Promise<O>;
+    resetContext(): boolean;
+    setConfig(config: Maybe<DbxInjectionComponentConfig<unknown>>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxInjectionContextDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxInjectionContextDirective<any>, "[dbxInjectionContext]", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract DbxInjectionContext implementation that forwards commands to a host DbxInjectionContext.
+ *
+ * This abstract type is used by related types for dependency injection purposes, so that those types
+ * can be injected instead of just any DbxInjectionContext.
+ */
+declare abstract class AbstractForwardDbxInjectionContextDirective implements DbxInjectionContext {
+    readonly dbxInjectionContext: DbxInjectionContext;
+    showContext<T = unknown, O = unknown>(config: DbxInjectionContextConfig<T, unknown>): Promise<O>;
+    resetContext(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractForwardDbxInjectionContextDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractForwardDbxInjectionContextDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Instance used by components to inject content based on the configuration into the view.
+ */
+declare class DbxInjectionInstance<T> implements Initialized, Destroyable {
+    private readonly _subscriptionObject;
+    private readonly _config;
+    private readonly _template;
+    private readonly _content;
+    private readonly _componentRef;
+    private readonly _injector;
+    readonly config$: rxjs.Observable<Maybe<DbxInjectionComponentConfig<T>>>;
+    readonly template$: rxjs.Observable<Maybe<DbxInjectionTemplateConfig<T>>>;
+    readonly content$: rxjs.Observable<ViewContainerRef>;
+    get config(): MaybeObservableOrValueGetter<DbxInjectionComponentConfig<T>>;
+    set config(config: MaybeObservableOrValueGetter<DbxInjectionComponentConfig<T>>);
+    get template(): MaybeObservableOrValueGetter<DbxInjectionTemplateConfig<T>>;
+    set template(template: MaybeObservableOrValueGetter<DbxInjectionTemplateConfig<T>>);
+    get content(): Maybe<Maybe<ViewContainerRef>>;
+    set content(content: Maybe<Maybe<ViewContainerRef>>);
+    get componentRef(): Maybe<ComponentRef<T>>;
+    set componentRef(componentRef: Maybe<ComponentRef<T>>);
+    constructor(injector: Injector);
+    init(): void;
+    destroy(): void;
+    private _initComponent;
+    private _initTemplate;
+    private _reset;
+}
+
+/**
+ * Provides a switchMap that passes configuration from the observable, unless the value is null/undefined/true in which case it passes the default configuration.
+ *
+ * @param defaultConfig
+ * @returns
+ */
+declare function switchMapDbxInjectionComponentConfig<T extends DbxInjectionComponentConfig<X>, X = any>(defaultConfig?: GetterOrValue<Maybe<T | Type<X>>>): rxjs.OperatorFunction<Maybe<_dereekb_rxjs.ObservableOrValueGetter<Maybe<boolean | T>>>, Maybe<T>>;
+
+/**
+ * Merges the input providers into a single array.
+ *
+ * @param providers
+ * @returns
+ */
+declare function mergeStaticProviders(...providers: Maybe<ArrayOrValue<StaticProvider>>[]): StaticProvider[];
+
+type InjectableType<T> = (Type<T> | AbstractType<T>) & Provider;
+/**
+ * Creates a new instance of the injectable type with the input injector.
+ *
+ * @param type
+ * @param parent
+ * @returns
+ */
+declare function newWithInjector<T>(type: InjectableType<T>, parent: Injector): T;
+
+interface LockSetComponent {
+    readonly lockSet: LockSet;
+}
+interface LockSetComponentStoreConfig {
+    readonly parent?: Maybe<Observable<LockSetComponent>>;
+    readonly locks?: {
+        [key: string]: Observable<boolean>;
+    };
+}
+/**
+ * Abstract ComponentStore extension that provides a LockSet and OnDestroy delaying/cleanup.
+ */
+declare abstract class LockSetComponentStore<S extends object> extends ComponentStore<S> implements OnDestroy {
+    protected readonly initialState?: S | undefined;
+    readonly lockSet: LockSet;
+    protected lockSetDestroyDelayMs: number;
+    protected lockSetDestroyTimeoutMs: Maybe<number>;
+    protected constructor(initialState?: S | undefined);
+    readonly resetStore: () => void;
+    protected setupLockSet({ parent, locks }: LockSetComponentStoreConfig): void;
+    setParentLockSet(obs: ObservableOrValue<Maybe<LockSetComponent>>): void;
+    addLock(key: string, obs: Observable<boolean>): void;
+    ngOnDestroy(): void;
+    /**
+     * Completes the cleanup of the object.
+     */
+    _destroyNow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LockSetComponentStore<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LockSetComponentStore<any>>;
+}
+
+/**
+ * Stored object accessor that can get/set/remove via a key, or be cleared entirely.
+ */
+declare abstract class LimitedStorageAccessor<T> {
+    /**
+     * Attempts to get the value. Throws a DataDoesNotExistError if not available.
+     */
+    abstract get(key: string): Observable<Maybe<T>>;
+    abstract set(key: string, value: Maybe<T>): Observable<void>;
+    abstract remove(key: string): Observable<void>;
+    abstract clear(): Observable<object>;
+}
+/**
+ * LimitedStorageAccessor extension that has knowledge of all stored keys.
+ */
+declare abstract class StorageAccessor<T> extends LimitedStorageAccessor<T> {
+    /**
+     * Returns all values. Filtered by keys of a given prefix.
+     */
+    abstract all(prefix?: string): Observable<T[]>;
+    /**
+     * Returns all keys. Filtered by keys of a given prefix.
+     */
+    abstract allKeys(prefix?: string): Observable<string[]>;
+}
+/**
+ * StorageAccessor-like object that has immediate/synchronous functionality for get/set.
+ */
+declare abstract class InstantStorageAccessor<T> {
+    abstract getNow(key: string): T | undefined;
+    abstract setNow(key: string, value: T): void;
+    abstract removeNow(key: string): void;
+}
+
+interface SimpleStorageAccessorConverter<T> {
+    /**
+     * Converts the input value to a string.
+     */
+    stringifyValue(value: T): StoredDataString;
+    /**
+     * Converts the data string into a value.
+     */
+    parseValue(data: StoredDataString): T;
+}
+/**
+ * SimpleStorageAccessor delegate.
+ */
+interface SimpleStorageAccessorDelegate<T> extends SimpleStorageAccessorConverter<T>, StorageAccessor<StoredDataString> {
+}
+declare class StringifySimpleStorageAccessorConverter<T> implements SimpleStorageAccessorConverter<T> {
+    stringifyValue(value: T): StoredDataString;
+    parseValue(data: StoredDataString): T;
+}
+declare class WrapperSimpleStorageAccessorDelegate<T> implements SimpleStorageAccessorDelegate<T> {
+    private readonly _delegate;
+    private readonly _converter;
+    constructor(delegate: StorageAccessor<StoredDataString>, converter: SimpleStorageAccessorConverter<T>);
+    get(key: string): Observable<Maybe<StoredDataString>>;
+    set(key: string, value: StoredDataString): Observable<void>;
+    remove(key: string): Observable<void>;
+    clear(): Observable<object>;
+    all(prefix?: string): Observable<string[]>;
+    allKeys(prefix?: string): Observable<string[]>;
+    stringifyValue(value: T): StoredDataString;
+    parseValue(data: StoredDataString): T;
+}
+interface SimpleStorageAccessorConfig {
+    /**
+     * Storage Key Prefix
+     */
+    readonly prefix: string;
+    /**
+     * Optional prefix/value splitter.
+     */
+    readonly prefixSplitter?: string;
+    /**
+     * Number in milliseconds that objects stored will expire in.
+     */
+    readonly expiresIn?: number;
+}
+interface ConfiguredSimpleStorageAccessorConfig extends SimpleStorageAccessorConfig {
+    readonly prefixSplitter: string;
+    readonly fullPrefix: string;
+}
+declare function assertValidStorageKeyPrefix(prefix: string, prefixSplitter: string): void;
+declare function isValidStorageKeyPrefix(prefix: string, prefixSpltter: string): boolean;
+/**
+ * LimitedStorageAccessor implementation that uses a Delegate
+ */
+declare class SimpleStorageAccessor<T> implements StorageAccessor<T> {
+    static readonly PREFIX_SPLITTER = "::";
+    private readonly _delegate;
+    protected readonly _config: ConfiguredSimpleStorageAccessorConfig;
+    constructor(delegate: SimpleStorageAccessorDelegate<T>, config: SimpleStorageAccessorConfig);
+    get delegate(): SimpleStorageAccessorDelegate<T>;
+    get config(): ConfiguredSimpleStorageAccessorConfig;
+    get(inputKey: string): Observable<T>;
+    set(inputKey: string, inputValue: T): Observable<void>;
+    remove(key: string): Observable<void>;
+    all(): Observable<T[]>;
+    allKeys(): Observable<string[]>;
+    clear(): Observable<object>;
+    protected readStoredData(storedDataString: StoredDataString): ReadStoredData<T>;
+    protected buildStoredData(value: T): StoredData;
+    protected isExpiredStoredData(storeData: StoredData): boolean;
+    protected makeStorageKey(key: string): StoredDataStorageKey;
+    protected isKeyOfAccessor(storageKey: StoredDataStorageKey): boolean;
+    protected decodeStorageKey(storageKey: StoredDataStorageKey): string;
+    protected stringifyValue(value: T): string;
+}
+
+interface StorageAccessorFactoryConfig<T> extends SimpleStorageAccessorConfig {
+    storage?: StorageAccessor<StoredDataString>;
+    converter?: SimpleStorageAccessorConverter<T>;
+}
+/**
+ * Used for building SimpleStorageAccessor instances from SimpleStorageAccessorConfig.
+ */
+declare class SimpleStorageAccessorFactory {
+    readonly storageObject: FullStorageObject;
+    createStorageAccessor<T>(config: StorageAccessorFactoryConfig<T>): SimpleStorageAccessor<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleStorageAccessorFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SimpleStorageAccessorFactory>;
+}
+
+/**
+ * Simple StorageAccessor implementation that wraps a FullStorageObject.
+ */
+declare class StringStorageAccessor implements StorageAccessor<StoredDataString> {
+    private readonly _storage;
+    constructor(storage: FullStorageObject);
+    get(key: string): Observable<Maybe<StoredDataString>>;
+    set(key: string, value: StoredDataString): Observable<void>;
+    remove(key: string): Observable<void>;
+    clear(): Observable<StoredDataString[]>;
+    all(): Observable<StoredDataString[]>;
+    allKeys(): Observable<string[]>;
+}
+
+declare const DEFAULT_STORAGE_OBJECT_TOKEN: InjectionToken<unknown>;
+declare const DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN: InjectionToken<unknown>;
+
+/**
+ * StorageObject using LocalStorage.
+ */
+declare class FullLocalStorageObject implements FullStorageObject {
+    private readonly _localStorage;
+    constructor(localStorage: StorageObject);
+    get isPersistant(): boolean;
+    get isAvailable(): boolean;
+    get length(): number;
+    getItem(key: StoredDataStorageKey): Maybe<string>;
+    setItem(key: StoredDataStorageKey, item: string): void;
+    removeItem(key: StoredDataStorageKey): void;
+    key(index: number): string | null;
+    removeAll(): string[];
+}
+
+/**
+ * FullStorageObject implementation that uses a localstorage that entirely resides in memory.
+ */
+declare class MemoryStorageObject extends FullLocalStorageObject {
+    get isLastingStorage(): boolean;
+    get isAvailable(): boolean;
+    constructor();
+}
+
+/**
+ * Default storage object factory function that creates a FullLocalStorageObject,
+ * falling back to MemoryStorageObject if localStorage is not available.
+ */
+declare function defaultStorageObjectFactory(): FullStorageObject;
+/**
+ * Creates EnvironmentProviders for providing a default storage object and SimpleStorageAccessorFactory.
+ *
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxStorage(): EnvironmentProviders;
+
+/**
+ * Wraps a Destroyable in a function that registers the input Destroyable to be destroyed
+ * when the DestroyRef is destroyed in the context.
+ *
+ * Must be run in an Angular injection context.
+ */
+declare function clean<T extends Destroyable | DestroyFunction>(input: T): T;
+/**
+ * Wraps a Subject in a function that registers the input Subject to be completed
+ * when the DestroyRef is destroyed in the context.
+ *
+ * Must be run in an Angular injection context.
+ */
+declare function completeOnDestroy<T extends Pick<Subject<any>, 'complete' | 'error'>>(input: T): T;
+
+interface CleanLockSetConfig {
+    /**
+     * Arbitrary onDestroy function to call when onDestroy is called by the internal DestroyRef.
+     */
+    readonly onDestroy?: Maybe<() => void>;
+    /**
+     * Called when the LockSet is finally destroyed.
+     */
+    readonly onLockSetDestroy?: Maybe<() => void>;
+    /**
+     * Configures when the lockset should be destroyed.
+     */
+    readonly destroyLocksetTiming?: Maybe<DestroyOnNextUnlockConfig>;
+}
+/**
+ * Creates a new LockSet that is automatically destroyed when the component is destroyed.
+ *
+ * Must be run within an Angular injection context.
+ *
+ * @param onLockSetDestroy Optional callback to run when the lockset is unlocked.
+ */
+declare function cleanLockSet(config?: Maybe<CleanLockSetConfig>): LockSet;
+/**
+ * Runs the given onDestroy function when the context is destroyed, and the lock set's next unlock occurs.
+ *
+ * Must be run within an Angular injection context.
+ *
+ * @param lockSet The lockset to use.
+ * @param onDestroy The function to run when the lockset is unlocked.
+ */
+declare function cleanWithLockSet(lockSet: LockSet, onDestroy: DestroyFunction): void;
+/**
+ * Config for cleanSubscriptionWithLockSet()
+ */
+interface CleanSubscriptionWithLockSetConfig<T extends Unsubscribable = Unsubscribable> {
+    readonly lockSet: LockSet;
+    readonly sub?: Maybe<GetterOrValue<T>>;
+}
+/**
+ * Creates a new SubscriptionObject that is automatically destroyed when the context is destroyed, and the lock set's next unlock occurs.
+ *
+ * Must be run within an Angular injection context.
+ */
+declare function cleanSubscriptionWithLockSet<T extends Unsubscribable = Unsubscribable>(input: CleanSubscriptionWithLockSetConfig<T>): SubscriptionObject<T>;
+
+/**
+ * Creates a new SubscriptionObject that is automatically destroyed when the context is destroyed.
+ *
+ * Must be run within an Angular injection context.
+ */
+declare function cleanSubscription<T extends Unsubscribable = Unsubscribable>(sub?: Maybe<GetterOrValue<T>>): SubscriptionObject<T>;
+
+/**
+ * Creates a new LoadingStateContext that is automatically destroyed when the context is destroyed.
+ *
+ * Must be run within an Angular injection context.
+ */
+declare function cleanLoadingContext<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingContextEvent = LoadingContextEvent & S>(input?: LoadingStateContextInput<T, S, E>): MutableLoadingStateContext<T, S, E>;
+/**
+ * Creates a new ListLoadingStateContext that is automatically destroyed when the context is destroyed.
+ *
+ * Must be run within an Angular injection context.
+ */
+declare function cleanListLoadingContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>>(input?: ListLoadingStateContextInput<L, S>): MutableListLoadingStateContext<L, S>;
+
+/**
+ * Creates a new DestroyFunctionObject that is automatically destroyed when the context is destroyed.
+ *
+ * Must be run within an Angular injection context.
+ */
+declare function cleanDestroy(input?: Maybe<DestroyFunction>): DestroyFunctionObject;
+
+/**
+ * Convenience function used within observables for views that need to detect changes after a value changes.
+ *
+ * @deprecated reminder to move to Angular signals
+ *
+ * @param cdRef
+ * @param timeout
+ * @returns
+ */
+declare function tapDetectChanges<T>(cdRef: Maybe<ChangeDetectorRef>, timeout?: number): MonoTypeOperatorFunction<T>;
+/**
+ * Triggers a check for detecting any changes on the model safely to ve registered via detectChanges().
+ *
+ * @deprecated reminder to move to Angular signals
+ *
+ * @param cdRef
+ */
+declare function safeDetectChanges(cdRef: ChangeDetectorRef): void;
+/**
+ * Convenience function used within observables for views that use the OnPush ChangeDetectionStrategy and needs to call markForCheck when a new observable value is pushed.
+ *
+ * NOTE: If the observable is being consumed via the "async" pipe, this may not be necessary.
+ *
+ * @deprecated reminder to move to Angular signals
+ * @param cdRef
+ * @param timeout
+ * @returns
+ */
+declare function tapSafeMarkForCheck<T>(cdRef: Maybe<ChangeDetectorRef>, timeout?: number): MonoTypeOperatorFunction<T>;
+/**
+ * Marks the ChangeDetectorRef for changes as long as the view has not been destroyed.
+ *
+ * @deprecated reminder to move to Angular signals
+ *
+ * @param cdRef
+ */
+declare function safeMarkForCheck(cdRef: ChangeDetectorRef): void;
+/**
+ * Triggers a detection change on the input view as long as the view has not been destroyed.
+ *
+ * @deprecated reminder to move to Angular signals
+ * @param cdRef
+ */
+declare function safeUseCdRef(cdRef: ChangeDetectorRef, use: (cdRef: ChangeDetectorRef) => void): void;
+/**
+ * Used to check an injected ElementRef that wraps an ng-content injection point whether or not any content was injected,
+ * or more specifically if the parent component passed any target content to the child. This will still return true if
+ * passed content is empty.
+ *
+ * TS:
+ * @ViewChild('customLoading', { static: false }) customCustom: ElementRef;
+ *
+ * HTML:
+ * <div #customContent>
+ *  <ng-content select="[content]"></ng-content>
+ * </div>
+ */
+declare function checkNgContentWrapperHasContent(ref: Maybe<ElementRef<Element>>): boolean;
+
+/**
+ * Transforms an empty string to undefined.
+ *
+ * Used for Angular inputs that are optional and share the same alias as the directive.
+ */
+declare const transformEmptyStringInputToUndefined: <T>(value: T | "") => T | undefined;
+
+export { APP_ACTION_DISABLED_DIRECTIVE_KEY, APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY, APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY, AbstractDbxActionHandlerDirective, AbstractDbxActionValueGetterDirective, AbstractDbxAnchorDirective, AbstractDbxButtonDirective, AbstractDbxFilterMapInstanceDirective, AbstractDbxFilterMapSourceDirective, AbstractDbxInjectionDirective, AbstractFilterSourceConnectorDirective, AbstractFilterSourceDirective, AbstractForwardDbxInjectionContextDirective, AbstractIfDirective, AbstractTransitionDirective, AbstractTransitionWatcherDirective, ActionContextStore, ActionContextStoreSource, ActionContextStoreSourceMap, AsObservablePipe, CutTextPipe, DBX_ACTION_HANDLER_LOCK_KEY, DBX_APP_APP_CONTEXT_STATE, DBX_APP_AUTH_ROUTER_EFFECTS_TOKEN, DBX_AUTH_APP_CONTEXT_STATE, DBX_INIT_APP_CONTEXT_STATE, DBX_INJECTION_COMPONENT_DATA, DBX_KNOWN_APP_CONTEXT_STATES, DBX_ONBOARD_APP_CONTEXT_STATE, DBX_PUBLIC_APP_CONTEXT_STATE, DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_ID_PARAM_KEY, DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_KEY_PARAM_KEY, DBX_ROUTE_MODEL_ID_PARAM_DEFAULT_USE_PARAM_VALUE, DEFAULT_ACTION_DISABLED_KEY, DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_IDENTIFIER_PARAM_VALUE, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_KEY, DEFAULT_REDIRECT_FOR_USER_IDENTIFIER_PARAM_VALUE, DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN, DEFAULT_STORAGE_OBJECT_TOKEN, DateDayRangePipe, DateDayTimeRangePipe, DateDistancePipe, DateFormatDistancePipe, DateFormatFromToPipe, DateRangeDistancePipe, DateTimeRangeOnlyDistancePipe, DateTimeRangeOnlyPipe, DateTimeRangePipe, DbxActionAutoModifyDirective, DbxActionAutoTriggerDirective, DbxActionButtonDirective, DbxActionButtonTriggerDirective, DbxActionContextBaseSource, DbxActionContextLoggerDirective, DbxActionContextMachine, DbxActionContextMachineAsService, DbxActionContextMapDirective, DbxActionContextStoreSourceInstance, DbxActionDirective, DbxActionDisabledDirective, DbxActionDisabledOnSuccessDirective, DbxActionEnforceModifiedDirective, DbxActionErrorHandlerDirective, DbxActionFromMapDirective, DbxActionHandlerDirective, DbxActionHandlerInstance, DbxActionHandlerValueDirective, DbxActionHasSuccessDirective, DbxActionIdleDirective, DbxActionIsWorkingDirective, DbxActionMapSourceDirective, DbxActionMapWorkingDisableDirective, DbxActionPreSuccessDirective, DbxActionSourceDirective, DbxActionState, DbxActionSuccessHandlerDirective, DbxActionTriggeredDirective, DbxActionValueDirective, DbxActionValueGetterInstance, DbxActionValueStreamDirective, DbxActionValueTriggerDirective, DbxActionWorkInstanceDelegate, DbxAnchor, DbxAngularRouterService, DbxAppAuthRouterEffects, DbxAppAuthRouterService, DbxAppAuthRoutes, DbxAppAuthStateService, DbxAppContextService, DbxAppContextStateDirective, DbxAppEnviroment, DbxAppEnviromentService, DbxAuthHasAnyRoleDirective, DbxAuthHasRolesDirective, DbxAuthNotAnyRoleDirective, DbxAuthService, DbxButton, DbxButtonDirective, DbxButtonSegueDirective, DbxCoreActionModule, DbxCoreAngularRouterSegueModule, DbxCoreButtonModule, DbxCoreFilterModule, DbxFilterConnectSourceDirective, DbxFilterMapDirective, DbxFilterMapSourceConnectorDirective, DbxFilterMapSourceDirective, DbxFilterSourceConnectorDirective, DbxFilterSourceDirective, DbxInjectionArrayComponent, DbxInjectionComponent, DbxInjectionContext, DbxInjectionContextDirective, DbxInjectionInstance, DbxLoadingButtonDirective, DbxRouteModelIdDirective, DbxRouteModelIdDirectiveDelegate, DbxRouteModelIdFromAuthUserIdDirective, DbxRouteModelKeyDirective, DbxRouteModelKeyDirectiveDelegate, DbxRouteParamDefaultRedirectInstance, DbxRouterService, DbxRouterTransitionEventType, DbxRouterTransitionService, DbxUIRouterService, DollarAmountPipe, FILTER_SOURCE_DIRECTIVE_DEFAULT_FILTER_TOKEN, FilterSourceDirective, FullLocalStorageObject, GetValueOncePipe, GetValuePipe, InstantStorageAccessor, LimitedStorageAccessor, LockSetComponentStore, MemoryStorageObject, MinutesStringPipe, NO_AUTH_USER_IDENTIFIER, PrettyJsonPipe, SecondaryActionContextStoreSource, SimpleStorageAccessor, SimpleStorageAccessorFactory, StorageAccessor, StringStorageAccessor, StringifySimpleStorageAccessorConverter, SystemDateToTargetDatePipe, TargetDateToSystemDatePipe, TimeDistanceCountdownPipe, TimeDistancePipe, TimezoneAbbreviationPipe, ToJsDatePipe, ToMinutesPipe, WrapperSimpleStorageAccessorDelegate, actionContextHasNoErrorAndIsModifiedAndCanTrigger, actionContextIsModifiedAndCanTrigger, actionContextStoreSourceMap, actionContextStoreSourceMapReader, actionContextStoreSourcePipe, anchorTypeForAnchor, asSegueRef, asSegueRefString, assertValidStorageKeyPrefix, authRolesSetContainsAllRolesFrom, authRolesSetContainsAnyRoleFrom, authRolesSetContainsNoRolesFrom, authUserIdentifier, canReadyValue, canTriggerAction, canTriggerActionState, checkNgContentWrapperHasContent, clean, cleanDestroy, cleanListLoadingContext, cleanLoadingContext, cleanLockSet, cleanSubscription, cleanSubscriptionWithLockSet, cleanWithLockSet, clickableUrlInNewTab, clickableUrlMailTo, clickableUrlTel, completeOnDestroy, dbxActionWorkProgress, dbxButtonDisplayType, dbxRouteModelIdParamRedirect, dbxRouteModelKeyParamRedirect, dbxRouteParamReaderInstance, defaultStorageObjectFactory, enableHasAuthRoleHook, enableHasAuthStateHook, enableIsLoggedInHook, expandClickableAnchorLinkTree, expandClickableAnchorLinkTreeNode, expandClickableAnchorLinkTrees, filterTransitionEvent, filterTransitionSuccess, flattenExpandedClickableAnchorLinkTree, flattenExpandedClickableAnchorLinkTreeToLinks, fromAllActionContextStoreSourceMapSources, index_d$1 as fromDbxAppAuth, index_d$3 as fromDbxAppContext, goWithRouter, hasAuthRoleDecisionPipe, isActionContextDisabled, isActionContextEnabled, isClickableFilterPreset, isClickablePartialFilterPreset, isDisabledActionContextState, isIdleActionState, isLatestSuccessfulRoute, isSegueRef, isSegueRefActive, isSegueRefActiveFunction, isSegueRefActiveOnTransitionSuccess, isValidStorageKeyPrefix, isWorkingActionState, latestSuccessfulRoutes, loadingStateForActionContextState, loadingStateTypeForActionContextState, loadingStateTypeForActionState, loggedInObsFromIsLoggedIn, loggedOutObsFromIsLoggedIn, makeAuthTransitionHook, makeDbxActionContextSourceReference, mapRefStringObsToSegueRefObs, mergeDbxInjectionComponentConfigs, mergeStaticProviders, newWithInjector, index_d as onDbxAppAuth, index_d$2 as onDbxAppContext, onRouterTransitionEventType, onRouterTransitionSuccessEvent, pipeActionStore, provideActionStoreSource, provideDbxAnchor, provideDbxAppAuth, provideDbxAppAuthRouter, provideDbxAppAuthRouterState, provideDbxAppAuthState, provideDbxAppContextState, provideDbxAppEnviroment, provideDbxButton, provideDbxInjectionContext, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate, provideDbxStorage, provideDbxUIRouterService, provideFilterSource, provideFilterSourceConnector, provideFilterSourceDirective, provideSecondaryActionStoreSource, redirectBasedOnAuthUserState, redirectForIdentifierParamHook, redirectForUserIdentifierParamHook, refStringToSegueRef, safeDetectChanges, safeMarkForCheck, safeUseCdRef, successTransition, switchMapDbxInjectionComponentConfig, tapDetectChanges, tapSafeMarkForCheck, transformEmptyStringInputToUndefined, useActionStore };
+export type { ActionContextState, ActionContextStoreSourceMapReader, ActionKey, AuthTransitionDecision, AuthTransitionDecisionGetterInput, AuthTransitionHookConfig, AuthTransitionHookOptions, AuthTransitionRedirectTarget, AuthTransitionRedirectTargetGetter, AuthTransitionRedirectTargetOrGetter, AuthTransitionStateData, AuthUserIdentifier, AuthUserState, CleanLockSetConfig, CleanSubscriptionWithLockSetConfig, ClickableAnchor, ClickableAnchorLink, ClickableAnchorLinkSegueRef, ClickableAnchorLinkTree, ClickableAnchorType, ClickableFilterPreset, ClickableFilterPresetOrPartialPreset, ClickableFunction, ClickableIconAnchorLink, ClickablePartialFilterPreset, ClickableUrl, DbxActionContextMachineConfig, DbxActionContextSourceReference, DbxActionDisabledKey, DbxActionErrorHandlerFunction, DbxActionRejectedPair, DbxActionSuccessHandlerFunction, DbxActionSuccessPair, DbxActionValueGetterDirectiveComputeInputsConfig, DbxActionValueGetterInstanceConfig, DbxActionValueGetterResult, DbxActionValueGetterValueGetterFunction, DbxActionWorkOrWorkProgress, DbxActionWorkProgress, DbxAppAuthFullState, DbxAppContextFullState, DbxAppContextState, DbxButtonDisplay, DbxButtonDisplayDelegate, DbxButtonDisplayType, DbxButtonInterceptor, DbxButtonWorking, DbxButtonWorkingProgress, DbxInjectionArrayEntry, DbxInjectionComponentConfig, DbxInjectionComponentConfigFactory, DbxInjectionComponentConfigWithoutInjector, DbxInjectionContextConfig, DbxInjectionTemplateConfig, DbxKnownAppContextState, DbxRouteModelIdParamRedirect, DbxRouteModelIdParamRedirectInstance, DbxRouteParamReader, DbxRouteParamReaderInstance, DbxRouterTransitionEvent, ExpandedClickableAnchorLinkTree, GoWithRouter, HasAuthRoleHookConfig, HasAuthRoleStateData, HasAuthRoleStateRoleConfig, HasAuthStateConfig, HasAuthStateData, HasAuthStateHookConfig, HasAuthStateObjectConfig, IconAndTitle, InjectableType, IsLatestSuccessfulRouteConfig, IsLoggedInHookConfig, IsLoggedInStateData, IsSegueRefActiveConfig, IsSegueRefActiveFunction, IsSegueRefActiveFunctionConfig, LatestSuccessfulRoutesConfig, LatestSuccessfulRoutesConfigRoute, LockSetComponent, LockSetComponentStoreConfig, MousableFunction, MouseEventPair, MouseEventType, NoAuthUserIdentifier, ParsedHasAuthRoleStateRoleConfig, PipeActionStoreFunction, ProvideDbxAppAuthConfig, ProvideDbxAppAuthRouterConfig, ProvideDbxAppAuthRouterStateConfig, ProvideFilterSourceDirectiveDefaultFilterFactoryFunction, RedirectForIdentifierParamHookInput, RedirectForUserIdentifierParamHookInput, SegueRef, SegueRefOptions, SegueRefOrSegueRefRouterLink, SegueRefRawSegueParams, SegueRefRouterLink, SimpleStorageAccessorConfig, SimpleStorageAccessorConverter, SimpleStorageAccessorDelegate, StorageAccessorFactoryConfig, UseActionStoreFunction };