@dereekb/dbx-core 12.0.4 → 12.0.5

package/lib/action/directive/map/action.map.key.directive.d.ts

@@ -1,18 +1,14 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
-import { ActionKey } from './action.map';
 import { SecondaryActionContextStoreSource } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Directive that provides a ActionContextStoreSource using the input key and DbxActionContextMapDirective.
  */
-export declare class DbxActionFromMapDirective implements SecondaryActionContextStoreSource, OnDestroy {
+export declare class DbxActionFromMapDirective implements SecondaryActionContextStoreSource {
     private readonly _actionContextStoreSourceMap;
-    private readonly _key;
+    readonly key: import("@angular/core").InputSignal<Maybe<string>>;
+    readonly key$: import("rxjs").Observable<Maybe<string>>;
     readonly store$: import("rxjs").Observable<import("@dereekb/dbx-core").ActionContextStore<any, any>>;
-    ngOnDestroy(): void;
-    get key(): Maybe<ActionKey>;
-    set key(key: Maybe<ActionKey>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFromMapDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": { "alias": "dbxActionFromMap"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": { "alias": "dbxActionFromMap"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.source.directive.d.ts

@@ -1,6 +1,6 @@
 import { OnDestroy } from '@angular/core';
+import { type Maybe } from '@dereekb/util';
 import { ActionContextStoreSource } from '../../action.store.source';
-import { ActionKey } from './action.map';
 import * as i0 from "@angular/core";
 /**
  * Used to communicate with an dbxActionMap and set the ActionContextStore to the store based on the key.
@@ -8,11 +8,12 @@ import * as i0 from "@angular/core";
 export declare class DbxActionMapSourceDirective implements OnDestroy {
     private readonly _actionContextStoreSourceMap;
     readonly source: ActionContextStoreSource<any, any>;
-    private _key;
+    readonly key: import("@angular/core").InputSignal<Maybe<string>>;
+    private _currentKey;
+    protected readonly _keyEffect: import("@angular/core").EffectRef;
     ngOnDestroy(): void;
-    set key(key: ActionKey);
     private _addToStore;
     private _removeFromToStore;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapSourceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": { "alias": "dbxActionMapSource"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": { "alias": "dbxActionMapSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
@@ -7,14 +7,12 @@ export declare const APP_ACTION_DISABLED_DIRECTIVE_KEY = "dbx_action_disabled";
 /**
  * Directive that allows disabling an action using the inputs.
  */
-export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _disabled;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
     readonly disabled$: import("rxjs").Observable<boolean>;
-    ngOnInit(): void;
+    constructor();
     ngOnDestroy(): void;
-    get disabled(): boolean;
-    set disabled(disabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
@@ -7,14 +7,12 @@ export declare const APP_ACTION_DISABLED_ON_SUCCESS_DIRECTIVE_KEY = "dbx_action_
 /**
  * Directive that will disable the action after the action completes successfully.
  */
-export declare class DbxActionDisabledOnSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionDisabledOnSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _disableOnSuccess;
-    readonly disableOnSuccess$: import("rxjs").Observable<boolean>;
-    ngOnInit(): void;
+    readonly disabledOnSuccess: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly disabledOnSuccess$: import("rxjs").Observable<boolean>;
+    constructor();
     ngOnDestroy(): void;
-    get disabled(): boolean;
-    set disabled(disabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabled": { "alias": "dbxActionDisabledOnSuccess"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabledOnSuccess": { "alias": "dbxActionDisabledOnSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -9,11 +9,10 @@ export declare const APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY = "dbx_action_enf
  */
 export declare class DbxActionEnforceModifiedDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
-    private readonly _enabled;
+    readonly enabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<boolean | "">>;
+    readonly enabled$: import("rxjs").Observable<boolean>;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    get enabled(): boolean;
-    set enabled(enabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -7,8 +7,9 @@ import * as i0 from "@angular/core";
  * Can be configured to hide for a temporary period.
  */
 export declare class DbxActionPreSuccessDirective extends AbstractIfDirective {
-    hideFor?: Maybe<number> | '';
+    private readonly _store;
+    readonly hideFor: import("@angular/core").InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionPreSuccessDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPreSuccessDirective, "[dbxActionPreSuccess]", never, { "hideFor": { "alias": "dbxActionPreSuccess"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPreSuccessDirective, "[dbxActionPreSuccess]", never, { "hideFor": { "alias": "dbxActionPreSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -8,8 +8,9 @@ import * as i0 from "@angular/core";
  * Can be configured to show for a temporary period.
  */
 export declare class DbxActionHasSuccessDirective extends AbstractIfDirective implements OnDestroy {
-    hideAfter?: Maybe<number> | '';
+    private readonly _store;
+    readonly hideAfter: import("@angular/core").InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHasSuccessDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": { "alias": "dbxActionHasSuccess"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": { "alias": "dbxActionHasSuccess"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,3 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractIfDirective } from '../../../view/if.directive';
 import * as i0 from "@angular/core";
@@ -7,9 +6,10 @@ import * as i0 from "@angular/core";
  *
  * Can specify a period in milliseconds that shows how long to show up after working for a particular number of seconds.
  */
-export declare class DbxActionIsWorkingDirective extends AbstractIfDirective implements OnDestroy {
-    showAfter?: Maybe<number> | '';
+export declare class DbxActionIsWorkingDirective extends AbstractIfDirective {
+    private readonly _store;
+    readonly showAfter: import("@angular/core").InputSignalWithTransform<Maybe<number>, "" | Maybe<number>>;
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionIsWorkingDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionIsWorking]", never, { "showAfter": { "alias": "dbxActionIsWorking"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionIsWorkingDirective, "[dbxActionIsWorking]", never, { "showAfter": { "alias": "dbxActionIsWorking"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { AuthRole, ArrayOrValue, type Maybe } from '@dereekb/util';
+import { ArrayOrValue, type Maybe } from '@dereekb/util';
 import { Observable } from 'rxjs';
 import { AbstractIfDirective } from '../view/if.directive';
 import * as i0 from "@angular/core";
@@ -6,11 +6,10 @@ import * as i0 from "@angular/core";
  * Structural decorator directive similar to ngIf that embeds content if the current auth user has any of the target role(s).
  */
 export declare class DbxAuthHasAnyRoleDirective extends AbstractIfDirective {
-    private readonly _targetRoles;
     private readonly _authService;
+    readonly targetRoles: import("@angular/core").InputSignal<Maybe<ArrayOrValue<string>>>;
     readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
     readonly show$: Observable<boolean>;
-    set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasAnyRoleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": { "alias": "dbxAuthHasAnyRole"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasAnyRoleDirective, "[dbxAuthHasAnyRole]", never, { "targetRoles": { "alias": "dbxAuthHasAnyRole"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { Maybe, AuthRole, ArrayOrValue } from '@dereekb/util';
+import { Maybe, ArrayOrValue } from '@dereekb/util';
 import { Observable } from 'rxjs';
 import { AbstractIfDirective } from '../view/if.directive';
 import * as i0 from "@angular/core";
@@ -6,11 +6,10 @@ import * as i0 from "@angular/core";
  * Structural decorator directive similar to ngIf that embeds content if the current auth user has all of the target role(s).
  */
 export declare class DbxAuthHasRolesDirective extends AbstractIfDirective {
-    private readonly _targetRoles;
     private readonly _authService;
+    readonly targetRoles: import("@angular/core").InputSignal<Maybe<ArrayOrValue<string>>>;
     readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
     readonly show$: Observable<boolean>;
-    set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthHasRolesDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": { "alias": "dbxAuthHasRoles"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthHasRolesDirective, "[dbxAuthHasRoles]", never, { "targetRoles": { "alias": "dbxAuthHasRoles"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,4 +1,4 @@
-import { Maybe, AuthRole, ArrayOrValue } from '@dereekb/util';
+import { Maybe, ArrayOrValue } from '@dereekb/util';
 import { Observable } from 'rxjs';
 import { AbstractIfDirective } from '../view/if.directive';
 import * as i0 from "@angular/core";
@@ -6,11 +6,10 @@ import * as i0 from "@angular/core";
  * Structural decorator directive similar to ngIf that embeds content if the current auth user has none of the target role(s).
  */
 export declare class DbxAuthNotAnyRoleDirective extends AbstractIfDirective {
-    private readonly _targetRoles;
     private readonly _authService;
+    readonly targetRoles: import("@angular/core").InputSignal<Maybe<ArrayOrValue<string>>>;
     readonly targetRoles$: Observable<Maybe<ArrayOrValue<string>>>;
     readonly show$: Observable<boolean>;
-    set targetRoles(roles: Maybe<ArrayOrValue<AuthRole>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxAuthNotAnyRoleDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthNotAnyRoleDirective, "[dbxAuthNotAnyRole]", never, { "targetRoles": { "alias": "dbxAuthNotAnyRole"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxAuthNotAnyRoleDirective, "[dbxAuthNotAnyRole]", never, { "targetRoles": { "alias": "dbxAuthNotAnyRole"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -1,19 +1,14 @@
-import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../subscription/subscription.directive';
 import { DbxButton } from '../button';
 import { DbxRouterService } from '../../router/router/service/router.service';
 import { SegueRef } from '../../router/segue';
 import * as i0 from "@angular/core";
-export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxButtonSegueDirective extends AbstractSubscriptionDirective {
     readonly dbxButton: DbxButton;
     readonly dbxRouterService: DbxRouterService;
-    private readonly _segueRef;
-    readonly segueRef$: import("rxjs").Observable<SegueRef<object>>;
-    get segueRef(): Maybe<SegueRef>;
-    set segueRef(segueRef: Maybe<SegueRef>);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
+    readonly segueRef: import("@angular/core").InputSignal<Maybe<SegueRef<object>>>;
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSegueDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": { "alias": "dbxButtonSegue"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSegueDirective, "[dbxButtonSegue]", never, { "segueRef": { "alias": "dbxButtonSegue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

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

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

@@ -14,11 +14,13 @@ export declare class DbxInjectionContextDirective<O = unknown> implements DbxInj
     private _currentPromise;
     private _embeddedView;
     private _isDetached;
-    set config(config: Maybe<DbxInjectionComponentConfig<unknown>>);
+    readonly config: import("@angular/core").InputSignal<Maybe<DbxInjectionComponentConfig<unknown>>>;
+    protected readonly _configEffect: import("@angular/core").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; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxInjectionContextDirective<any>, "[dbxInjectionContext]", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

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

@@ -66,9 +66,6 @@ export declare abstract class DbxAnchor<T extends ClickableAnchor = ClickableAnc
     abstract readonly disabled$: Observable<Maybe<boolean>>;
     abstract readonly selected$: Observable<Maybe<boolean>>;
     abstract readonly anchor$: Observable<Maybe<T>>;
-    abstract readonly disabled: Maybe<boolean>;
-    abstract readonly selected: Maybe<boolean>;
-    abstract readonly anchor: Maybe<T>;
     abstract readonly type$: Observable<ClickableAnchorType>;
 }
 export declare function provideDbxAnchor<S extends DbxAnchor>(sourceType: Type<S>): Provider[];

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

@@ -1,5 +1,4 @@
 import { Observable } from 'rxjs';
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { ClickableAnchorType, ClickableAnchor, DbxAnchor } from './anchor';
 import { SegueRefOrSegueRefRouterLink } from '../segue';
@@ -7,31 +6,24 @@ import * as i0 from "@angular/core";
 /**
  * Abstract anchor directive.
  */
-export declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor, OnDestroy {
-    private readonly _selected;
-    private readonly _disabled;
-    private readonly _anchor;
-    readonly disabled$: Observable<Maybe<boolean>>;
-    readonly anchor$: Observable<Maybe<T>>;
-    readonly selected$: Observable<Maybe<boolean>>;
-    readonly type$: Observable<ClickableAnchorType>;
+export declare class AbstractDbxAnchorDirective<T extends ClickableAnchor = ClickableAnchor> implements DbxAnchor {
+    readonly ref: import("@angular/core").ModelSignal<Maybe<SegueRefOrSegueRefRouterLink>>;
+    readonly anchor: import("@angular/core").ModelSignal<Maybe<T>>;
+    readonly disabled: import("@angular/core").ModelSignal<Maybe<boolean>>;
+    readonly selected: import("@angular/core").ModelSignal<Maybe<boolean>>;
     readonly anchorSignal: import("@angular/core").Signal<Maybe<T>>;
-    readonly disabledSignal: import("@angular/core").Signal<Maybe<boolean>>;
-    readonly selectedSignal: import("@angular/core").Signal<Maybe<boolean>>;
+    readonly selectedSignal: import("@angular/core").Signal<boolean | undefined>;
     readonly typeSignal: import("@angular/core").Signal<ClickableAnchorType>;
     readonly urlSignal: import("@angular/core").Signal<string | undefined>;
     readonly targetSignal: import("@angular/core").Signal<string | undefined>;
-    ngOnDestroy(): void;
-    /**
-     * Convenience input to create an Anchor from the input SegueRef.
-     */
-    set ref(ref: Maybe<SegueRefOrSegueRefRouterLink>);
-    get anchor(): Maybe<T>;
-    set anchor(anchor: Maybe<T>);
-    get disabled(): Maybe<boolean>;
-    set disabled(disabled: Maybe<boolean>);
-    get selected(): Maybe<boolean>;
-    set selected(selected: Maybe<boolean>);
+    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; }; "anchor": { "alias": "anchor"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, never, false, 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, false, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/dbx-core",
-  "version": "12.0.4",
+  "version": "12.0.5",
   "peerDependencies": {
     "@dereekb/util": "*",
     "@dereekb/rxjs": "*",