@dereekb/dbx-core 0.0.1

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

@@ -0,0 +1,15 @@
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Displays the input content when success is set.
+ *
+ * Can be configured to show for a limited time afterwards, etc.
+ */
+export declare class DbNgxActionSuccessComponent {
+    readonly source: ActionContextStoreSourceInstance;
+    hideAfter?: number;
+    readonly show$: import("rxjs").Observable<boolean>;
+    constructor(source: ActionContextStoreSourceInstance);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionSuccessComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionSuccessComponent, "dbx-action-success", never, { "hideAfter": "hideAfter"; }, {}, never, ["*"]>;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Displays the input content when working is set.
+ */
+export declare class DbNgxActionWorkingComponent {
+    readonly source: ActionContextStoreSourceInstance;
+    readonly show$: import("rxjs").Observable<boolean>;
+    constructor(source: ActionContextStoreSourceInstance);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionWorkingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionWorkingComponent, "dbx-action-working", never, {}, {}, never, ["*"]>;
+}

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

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

package/lib/action/index.d.ts

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

package/lib/action/snackbar/index.d.ts

@@ -0,0 +1 @@
+export * from './snackbar';

package/lib/action/snackbar/snackbar.d.ts

@@ -0,0 +1,50 @@
+import { Type } from "@angular/core";
+import { Maybe } from "@dereekb/util";
+import { ActionContextStoreSourceInstance } from "../action.store.source";
+export declare const DEFAULT_SNACKBAR_DIRECTIVE_DURATION: number;
+export declare const DEFAULT_SNACKBAR_UNDO_DIRECTIVE_DURATION: number;
+export declare enum ActionSnackbarDefaultType {
+    NONE = "none",
+    CREATE = "create",
+    SAVE = "save",
+    DELETE = "delete",
+    MERGE = "merge",
+    SEND = "send",
+    CANCEL = "cancel",
+    RESTORE = "restore",
+    REFRESH = "refresh",
+    MARK_READ = "read",
+    MARK_UNREAD = "unread"
+}
+export declare enum ActionSnackbarEventType {
+    WORKING = 0,
+    SUCCESS = 1,
+    REJECTED = 2
+}
+export interface ActionSnackbarEvent<O = any> {
+    type: ActionSnackbarEventType;
+    value?: Maybe<O>;
+    error?: Maybe<any>;
+}
+export interface ActionSnackBarOpenConfig {
+    message: string;
+    action?: string;
+}
+export interface ActionSnackbarPopupConfig<C = any> {
+    open?: ActionSnackBarOpenConfig;
+    component?: Maybe<Type<any>>;
+    config?: C;
+}
+/**
+ * Performs the action on success.
+ */
+export declare type ActionSnackbarFunction<O = any, C = any> = (event: ActionSnackbarEvent<O>) => ActionSnackbarPopupConfig<C>;
+export interface DbNgxActionSnackbarGetUndoConfig extends Omit<DbNgxActionSnackbarComponentConfig, 'message' | 'action'>, Partial<Pick<DbNgxActionSnackbarComponentConfig, 'message' | 'action'>> {
+    duration?: number;
+}
+export declare type ActionSnackbarGetUndoConfigFunction = () => Maybe<DbNgxActionSnackbarGetUndoConfig>;
+export interface DbNgxActionSnackbarComponentConfig {
+    action: string;
+    message?: Maybe<string>;
+    actionSource: ActionContextStoreSourceInstance;
+}

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

@@ -0,0 +1,18 @@
+import { OnInit, OnDestroy, NgZone } from '@angular/core';
+import { DbNgxButton } from '../button';
+import { ActionContextStoreSourceInstance } from '../../action/action.store.source';
+import { DbNgxActionButtonTriggerDirective } from './action.button.trigger.directive';
+import * as i0 from "@angular/core";
+/**
+ * Context used for linking a button to an ActionContext.
+ */
+export declare class DbNgxActionButtonDirective extends DbNgxActionButtonTriggerDirective implements OnInit, OnDestroy {
+    private readonly ngZone;
+    private _workingSub;
+    private _disabledSub;
+    constructor(button: DbNgxButton, source: ActionContextStoreSourceInstance, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionButtonDirective, [{ host: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never>;
+}

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

@@ -0,0 +1,17 @@
+import { OnInit } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../subscription';
+import { DbNgxButton } from '../button';
+import { ActionContextStoreSourceInstance } from '../../action/action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Context used for linking a button to an ActionContext and only look for triggers.
+ */
+export declare class DbNgxActionButtonTriggerDirective extends AbstractSubscriptionDirective implements OnInit {
+    readonly button: DbNgxButton;
+    readonly source: ActionContextStoreSourceInstance;
+    constructor(button: DbNgxButton, source: ActionContextStoreSourceInstance);
+    ngOnInit(): void;
+    protected _buttonClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionButtonTriggerDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never>;
+}

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

@@ -0,0 +1,2 @@
+export * from './action.button.directive';
+export * from './action.button.trigger.directive';

package/lib/button/button.d.ts

@@ -0,0 +1,26 @@
+import { Type, Provider } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { Observable } from 'rxjs';
+/**
+ * Used for intercepting button click events.
+ *
+ * Can be used to delay/modify trigger/click behaviors.
+ */
+export interface DbNgxButtonInterceptor {
+    /**
+     * Handles a button click event. Returns an observable that will say whether or not to continue the click event.
+     */
+    interceptButtonClick: () => Observable<boolean>;
+}
+export declare abstract class DbNgxButton {
+    abstract disabled$: Observable<boolean>;
+    abstract working$: Observable<boolean>;
+    abstract disabled: Maybe<boolean>;
+    abstract working: Maybe<boolean>;
+    abstract icon?: string;
+    abstract text?: string;
+    abstract clicked$: Observable<any>;
+    abstract setButtonInterceptor(interceptor: DbNgxButtonInterceptor): void;
+    abstract clickButton(): void;
+}
+export declare function ProvideDbNgxButton<S extends DbNgxButton>(sourceType: Type<S>): Provider[];

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

@@ -0,0 +1,52 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { AbstractSubscriptionDirective } from '../subscription';
+import { DbNgxButton, DbNgxButtonInterceptor } from './button';
+import * as i0 from "@angular/core";
+/**
+ * Abstract button component.
+ */
+export declare abstract class AbstractDbNgxButtonDirective extends AbstractSubscriptionDirective implements DbNgxButton, OnInit, OnDestroy {
+    private _disabled;
+    private _working;
+    readonly disabled$: import("rxjs").Observable<boolean>;
+    readonly working$: import("rxjs").Observable<boolean>;
+    get disabled(): boolean;
+    set disabled(disabled: boolean);
+    get working(): boolean;
+    set working(working: boolean);
+    icon?: string;
+    text?: string;
+    readonly buttonClick: EventEmitter<any>;
+    readonly clicked$: import("rxjs").Observable<any>;
+    constructor();
+    /**
+     * Pre-interceptor button click.
+     */
+    protected _buttonClick: Subject<void>;
+    protected _buttonInterceptor: BehaviorSubject<Maybe<DbNgxButtonInterceptor>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Sets the button interceptor. If any interceptor is already set, it is replaced.
+     */
+    setButtonInterceptor(interceptor: DbNgxButtonInterceptor): 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<AbstractDbNgxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxButtonDirective, never, never, { "disabled": "disabled"; "working": "working"; "icon": "icon"; "text": "text"; }, { "buttonClick": "buttonClick"; }, never>;
+}
+/**
+ * Provides an DbNgxButton directive.
+ */
+export declare class DbNgxButtonDirective extends AbstractDbNgxButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never>;
+}

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

@@ -0,0 +1,21 @@
+import { NgZone } from '@angular/core';
+import { LoadingContext } from '@dereekb/rxjs';
+import { AbstractSubscriptionDirective } from '../subscription';
+import { DbNgxButton } from './button';
+import * as i0 from "@angular/core";
+/**
+ * Context used for linking a button to a LoadingContext.
+ *
+ * It will be set working when the context is set loading.
+ */
+export declare class DbNgxLoadingButtonDirective extends AbstractSubscriptionDirective {
+    readonly button: DbNgxButton;
+    readonly ngZone: NgZone;
+    constructor(button: DbNgxButton, ngZone: NgZone);
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set context(context: LoadingContext);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxLoadingButtonDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxLoadingButtonDirective, "[dbxLoadingButton]", never, { "context": "dbxLoadingButton"; }, {}, never>;
+}

package/lib/button/button.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button.directive";
+import * as i2 from "./button.loading.directive";
+import * as i3 from "./action/action.button.trigger.directive";
+import * as i4 from "./action/action.button.directive";
+import * as i5 from "./router/button.segue.directive";
+export declare class DbNgxCoreButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxCoreButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxCoreButtonModule, [typeof i1.DbNgxButtonDirective, typeof i2.DbNgxLoadingButtonDirective, typeof i3.DbNgxActionButtonTriggerDirective, typeof i4.DbNgxActionButtonDirective, typeof i5.DbNgxButtonSegueDirective], never, [typeof i1.DbNgxButtonDirective, typeof i2.DbNgxLoadingButtonDirective, typeof i3.DbNgxActionButtonTriggerDirective, typeof i4.DbNgxActionButtonDirective, typeof i5.DbNgxButtonSegueDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxCoreButtonModule>;
+}

package/lib/button/index.d.ts

@@ -0,0 +1,6 @@
+export * from './action';
+export * from './router';
+export * from './button.directive';
+export * from './button.loading.directive';
+export * from './button.module';
+export * from './button';

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

@@ -0,0 +1,18 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { AbstractSubscriptionDirective } from '../../subscription';
+import { DbNgxButton } from '../button';
+import { SegueRef, DbNgxRouterService } from '../../router';
+import * as i0 from "@angular/core";
+export declare class DbNgxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly dbxButton: DbNgxButton;
+    readonly dbxRouterService: DbNgxRouterService;
+    private _segueRef;
+    readonly segueRef$: import("rxjs").Observable<SegueRef<any>>;
+    get segueRef(): Maybe<SegueRef>;
+    set segueRef(segueRef: Maybe<SegueRef>);
+    constructor(dbxButton: DbNgxButton, dbxRouterService: DbNgxRouterService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonSegueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": "dbxButtonSegue"; }, {}, never>;
+}

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

@@ -0,0 +1 @@
+export * from './button.segue.directive';

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+export * from './action';
+export * from './button';
+export * from './router';
+export * from './pipe';
+export * from './injected';
+export * from './storage';
+export * from './subscription';
+export * from './util';

package/lib/injected/index.d.ts

@@ -0,0 +1,5 @@
+export * from './injected.component.module';
+export * from './injected.component';
+export * from './injected.instance';
+export * from './injected.directive';
+export * from './injected';

package/lib/injected/injected.component.d.ts

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

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

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./injected.component";
+import * as i2 from "@angular/common";
+export declare class DbNgxInjectedComponentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxInjectedComponentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxInjectedComponentModule, [typeof i1.DbNgxInjectedComponent], [typeof i2.CommonModule], [typeof i1.DbNgxInjectedComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxInjectedComponentModule>;
+}

package/lib/injected/injected.d.ts

@@ -0,0 +1,26 @@
+import { Injector, TemplateRef, Type, ViewRef } from "@angular/core";
+import { Maybe } from "@dereekb/util";
+export interface DbNgxInjectedComponentConfig<T = any> {
+    /**
+     * Type of Component to initialize.
+     */
+    componentClass: Type<T>;
+    /**
+     * Custom Injector to use when creating the component.
+     */
+    injector?: Injector;
+    /**
+     * Custom initialization code when an instance is created.
+     */
+    init?: (instance: T) => void;
+}
+export interface DbNgxInjectedTemplateConfig<T = any> {
+    /**
+     * Template ref to display.
+     */
+    templateRef?: Maybe<TemplateRef<T>>;
+    /**
+     * View ref to inject.
+     */
+    viewRef?: Maybe<ViewRef>;
+}

package/lib/injected/injected.directive.d.ts

@@ -0,0 +1,17 @@
+import { ViewContainerRef, OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { DbNgxInjectedComponentConfig, DbNgxInjectedTemplateConfig } from './injected';
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that injects content based on the configuration into the view.
+ */
+export declare abstract class AbstractDbNgxInjectedDirective<T> implements OnInit, OnDestroy {
+    private _instance;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    setConfig(config: Maybe<DbNgxInjectedComponentConfig>): void;
+    setTemplate(template: Maybe<DbNgxInjectedTemplateConfig>): void;
+    setContent(content: Maybe<ViewContainerRef>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbNgxInjectedDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxInjectedDirective<any>, never, never, {}, {}, never>;
+}

package/lib/injected/injected.instance.d.ts

@@ -0,0 +1,29 @@
+import { ComponentRef, ViewContainerRef } from '@angular/core';
+import { DbNgxInjectedComponentConfig, DbNgxInjectedTemplateConfig } from './injected';
+import { Initialized, Destroyable, Maybe } from '@dereekb/util';
+/**
+ * Instance used by components to inject content based on the configuration into the view.
+ */
+export declare class DbNgxInjectedComponentInstance<T> implements Initialized, Destroyable {
+    private _subscriptionObject;
+    private _config;
+    private _template;
+    private _content;
+    private _componentRef;
+    readonly config$: import("rxjs").Observable<Maybe<DbNgxInjectedComponentConfig<T>>>;
+    readonly template$: import("rxjs").Observable<Maybe<DbNgxInjectedTemplateConfig<T>>>;
+    readonly content$: import("rxjs").Observable<ViewContainerRef>;
+    get config(): Maybe<DbNgxInjectedComponentConfig<T>>;
+    set config(config: Maybe<DbNgxInjectedComponentConfig<T>>);
+    get template(): Maybe<DbNgxInjectedTemplateConfig<T>>;
+    set template(template: Maybe<DbNgxInjectedTemplateConfig<T>>);
+    get content(): Maybe<Maybe<ViewContainerRef>>;
+    set content(content: Maybe<Maybe<ViewContainerRef>>);
+    get componentRef(): Maybe<ComponentRef<T>>;
+    set componentRef(componentRef: Maybe<ComponentRef<T>>);
+    init(): void;
+    destroy(): void;
+    private _initComponent;
+    private _initTemplate;
+    private _reset;
+}

package/lib/pipe/date/date.pipe.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./datefromtoformat.pipe";
+import * as i2 from "./dateformatdistance.pipe";
+import * as i3 from "./minutesstring.pipe";
+import * as i4 from "./timedistance.pipe";
+import * as i5 from "./datedistance.pipe";
+import * as i6 from "./tojsdate.pipe";
+import * as i7 from "./tominutes.pipe";
+export declare class DbNgxDatePipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxDatePipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxDatePipeModule, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe], never, [typeof i1.DateFromToTimePipe, typeof i2.DateFormatDistancePipe, typeof i3.MinutesStringPipe, typeof i4.TimeDistanceCountdownPipe, typeof i4.TimeDistancePipe, typeof i5.DateDistancePipe, typeof i6.ToJsDatePipe, typeof i7.ToMinutesPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxDatePipeModule>;
+}

package/lib/pipe/date/datedistance.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { DateOrDateString } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare class DateDistancePipe implements PipeTransform {
+    transform(input: DateOrDateString | undefined, to: Date, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateDistancePipe, "dateDistance">;
+}

package/lib/pipe/date/dateformatdistance.pipe.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '@angular/core';
+import { DateOrDateString, Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Pipe that takes in a date and appends the distance to it in parenthesis.
+ */
+export declare class DateFormatDistancePipe implements PipeTransform {
+    private locale;
+    constructor(locale: string);
+    transform(input: Maybe<DateOrDateString>, format: string, includeSeconds?: boolean): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatDistancePipe, "dateFormatDistance">;
+}

package/lib/pipe/date/datefromtoformat.pipe.d.ts

@@ -0,0 +1,14 @@
+import { PipeTransform } from '@angular/core';
+import { Maybe, DateOrDateString } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Pipe that takes in a date and number of minutes and outputs a formatted date.
+ */
+export declare class DateFromToTimePipe implements PipeTransform {
+    private locale;
+    constructor(locale: string);
+    transform(input: Maybe<DateOrDateString>, format: string, minutes: number): Maybe<string>;
+    static formatFromTo(input: Maybe<DateOrDateString>, format: string, minutes: number, locale: string): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFromToTimePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFromToTimePipe, "dateFromPlusTo">;
+}

package/lib/pipe/date/index.d.ts

@@ -0,0 +1,8 @@
+export * from './date.pipe.module';
+export * from './datedistance.pipe';
+export * from './dateformatdistance.pipe';
+export * from './datefromtoformat.pipe';
+export * from './minutesstring.pipe';
+export * from './timedistance.pipe';
+export * from './tojsdate.pipe';
+export * from './tominutes.pipe';

package/lib/pipe/date/minutesstring.pipe.d.ts

@@ -0,0 +1,8 @@
+import { PipeTransform } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare class MinutesStringPipe implements PipeTransform {
+    transform(input: Maybe<number | string>): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinutesStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MinutesStringPipe, "minutesString">;
+}

package/lib/pipe/date/timedistance.pipe.d.ts

@@ -0,0 +1,13 @@
+import { PipeTransform } from '@angular/core';
+import { Maybe, DateOrDateString } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export 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">;
+}
+export declare class TimeDistancePipe implements PipeTransform {
+    transform(input: Maybe<DateOrDateString>, to?: Date, unavailable?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeDistancePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeDistancePipe, "timeDistance">;
+}

package/lib/pipe/date/tojsdate.pipe.d.ts

@@ -0,0 +1,9 @@
+import { PipeTransform } from '@angular/core';
+import { DateOrDateString, Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export declare class ToJsDatePipe implements PipeTransform {
+    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">;
+}

package/lib/pipe/date/tominutes.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ToMinutesPipe implements PipeTransform {
+    transform(milliseconds: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToMinutesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ToMinutesPipe, "toMinutes">;
+}

package/lib/pipe/index.d.ts

@@ -0,0 +1 @@
+export * from './date';

package/lib/router/anchor/anchor.d.ts

@@ -0,0 +1,31 @@
+import { ClickableFunction, ClickableUrl } from './clickable';
+import { SegueRef } from '../segue';
+import { Maybe } from '@dereekb/util';
+import { Type, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+export interface ClickableAnchor extends ClickableFunction, ClickableUrl, SegueRef {
+    disabled?: boolean;
+}
+export interface ClickableAnchorLink extends ClickableAnchor {
+    title: string;
+    icon?: string;
+}
+export interface ClickableIconAnchorLink extends Omit<ClickableAnchorLink, 'title'> {
+    icon: string;
+}
+export declare enum AnchorType {
+    None = 0,
+    Clickable = 1,
+    Sref = 2,
+    Href = 3,
+    Disabled = 4
+}
+export declare function anchorTypeForAnchor(anchor: Maybe<ClickableAnchor>, disabled?: Maybe<boolean>): AnchorType;
+export declare abstract class DbNgxAnchor<T extends ClickableAnchor = ClickableAnchor> {
+    abstract disabled$: Observable<Maybe<boolean>>;
+    abstract anchor$: Observable<Maybe<T>>;
+    abstract disabled: Maybe<boolean>;
+    abstract anchor: Maybe<T>;
+    abstract type$: Observable<AnchorType>;
+}
+export declare function ProvideDbNgxAnchor<S extends DbNgxAnchor>(sourceType: Type<S>): Provider[];

package/lib/router/anchor/anchor.directive.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { Maybe } from '@dereekb/util';
+import { AnchorType, ClickableAnchor, DbNgxAnchor } from './anchor';
+import * as i0 from "@angular/core";
+/**
+ * Abstract anchor directive.
+ */
+export declare class AbstractDbNgxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbNgxAnchor {
+    private _disabled;
+    private _anchor;
+    readonly disabled$: Observable<Maybe<boolean>>;
+    readonly anchor$: Observable<Maybe<T>>;
+    readonly type$: Observable<AnchorType>;
+    get anchor(): Maybe<T>;
+    set anchor(anchor: Maybe<T>);
+    get disabled(): Maybe<boolean>;
+    set disabled(disabled: Maybe<boolean>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbNgxAnchorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxAnchorDirective<any>, never, never, { "anchor": "anchor"; "disabled": "disabled"; }, {}, never>;
+}