@lucca-front/ng 22.0.0-rc.1 → 22.0.0-rc.2

package/types/lucca-front-ng-core-select.d.ts

@@ -1,43 +1,25 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, Provider, OnInit, TemplateRef, PipeTransform, OnChanges, OnDestroy, Type, SimpleChanges, ElementRef, AfterViewInit, Signal, EventEmitter, WritableSignal, ChangeDetectorRef } from '@angular/core';
+import { InjectionToken, OnDestroy, ElementRef, Signal, EventEmitter, TemplateRef, WritableSignal, OnInit, ChangeDetectorRef, Type, Provider, PipeTransform } from '@angular/core';
 import * as _lucca_front_ng_filter_pills from '@lucca-front/ng/filter-pills';
 import { FilterPillInputComponent } from '@lucca-front/ng/filter-pills';
 import { OverlayConfig, OverlayRef } from '@angular/cdk/overlay';
 import { ControlValueAccessor } from '@angular/forms';
 import { PortalContent, LuTranslation } from '@lucca-front/ng/core';
 import * as rxjs from 'rxjs';
-import { BehaviorSubject, Observable, Subject, ReplaySubject } from 'rxjs';
+import { Observable, Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
+import * as _lucca_front_ng_core_select from '@lucca-front/ng/core-select';
 import { Highlightable } from '@angular/cdk/a11y';
 
-interface ILuOptionContext<T> {
-    isDisabled$: BehaviorSubject<boolean>;
-    option$: BehaviorSubject<T | undefined>;
-    destroy(): void;
-}
-declare const LU_OPTION_CONTEXT: InjectionToken<ILuOptionContext<unknown>>;
-declare function provideOptionContext(): Provider;
-
-declare class LuSimpleSelectDefaultOptionComponent {
-    context: ILuOptionContext<{
-        name?: string;
-    }>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuSimpleSelectDefaultOptionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuSimpleSelectDefaultOptionComponent, "lu-simple-select-default-option", never, {}, {}, never, never, true, never>;
-}
-
-declare class LuDisabledOptionDirective {
-    private context;
-    set isDisabled(disabled: boolean | null);
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuDisabledOptionDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisabledOptionDirective, "[luDisabledOption]", never, { "isDisabled": { "alias": "luDisabledOption"; "required": false; }; }, {}, never, never, true, never>;
-}
-
 interface LuOptionContext<T> {
     $implicit: T;
 }
 interface LuOptionGroupByContext<T, TGroup> {
     $implicit: LuOptionGroup<T, TGroup>;
 }
+interface LuOptionGrouping<TOption, TGroup> {
+    selector: (option: TOption) => TGroup;
+    content: PortalContent<LuOptionGroupByContext<TOption, TGroup>>;
+}
 interface LuOptionGroup<T, TGroup> {
     key: TGroup;
     options: T[];
@@ -58,62 +40,6 @@ declare abstract class ɵIsSelectedStrategy<TOption> {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ɵIsSelectedStrategy<any>>;
 }
 
-interface LuOptionGrouping<TOption, TGroup> {
-    selector: (option: TOption) => TGroup;
-    content: PortalContent<LuOptionGroupByContext<TOption, TGroup>>;
-}
-declare class LuOptionGroupDirective<TOption, TValue, TGroup> implements LuOptionGrouping<TOption, TGroup>, OnInit {
-    select: ALuSelectInputComponent<TOption, TValue>;
-    selector: (option: TOption) => TGroup;
-    readonly content: TemplateRef<LuOptionGroupByContext<TOption, TGroup>>;
-    static ngTemplateContextGuard<TOption, TValue, TGroup>(_dir: LuOptionGroupDirective<TOption, TValue, TGroup>, ctx: unknown): ctx is LuOptionGroupByContext<TOption, TGroup>;
-    ngOnInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupDirective<any, any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionGroupDirective<any, any, any>, "[luOptionGroup]", never, { "select": { "alias": "luOptionGroupSelect"; "required": false; }; "selector": { "alias": "luOptionGroupBy"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Generate groups with a O(n) complexity. Note that the options must be sorted by group.
- */
-declare function generateGroups<T, TGroup>(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
-declare class LuOptionGroupPipe<T, TGroup> implements PipeTransform {
-    transform(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
-    transform(options: T, selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupPipe<any, any>, never>;
-    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LuOptionGroupPipe<any, any>, "luOptionGroup", true>;
-}
-
-declare class LuOptionOutletDirective<T> implements OnChanges, OnDestroy {
-    luOptionOutlet?: Type<unknown> | TemplateRef<LuOptionContext<T>>;
-    luOptionOutletValue: T | undefined;
-    luOptionShowNull: boolean;
-    private viewContainerRef;
-    private injector;
-    private embeddedViewRef?;
-    private componentRef?;
-    private optionContext;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    private clearContainer;
-    private createComponent;
-    private updateRefValue;
-    static ngTemplateContextGuard<T>(_dir: LuOptionOutletDirective<T>, ctx: unknown): ctx is void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionOutletDirective<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionOutletDirective<any>, "[luOptionOutlet]", never, { "luOptionOutlet": { "alias": "luOptionOutlet"; "required": false; }; "luOptionOutletValue": { "alias": "luOptionOutletValue"; "required": false; }; "luOptionShowNull": { "alias": "luOptionShowNull"; "required": false; }; }, {}, never, never, true, never>;
-}
-
-interface OptionTranslate {
-    onlyParent: string;
-    onlyChildren: string;
-}
-
-type GroupTemplateLocation = 'group-header' | 'option' | 'none';
-/**
- * In order to avoid a blinking when we go from empty clue to a clue
- * We need to delay the change of group displayer location by waiting for the options to be updated.
- */
-declare function getGroupTemplateLocation(hasGrouping$: Observable<boolean>, clueChange$: Observable<string>, options$: Observable<readonly unknown[]>, searchable?: boolean): Observable<GroupTemplateLocation>;
-
 declare class CoreSelectPanelElement<T> implements Highlightable, OnDestroy {
     #private;
     readonly elementRef: ElementRef<HTMLElement>;
@@ -122,53 +48,18 @@ declare class CoreSelectPanelElement<T> implements Highlightable, OnDestroy {
     readonly idAttribute: _angular_core.Signal<string>;
     readonly isSelected: _angular_core.ModelSignal<boolean>;
     readonly option: _angular_core.InputSignal<T>;
+    readonly disabledInput: _angular_core.InputSignal<boolean>;
+    readonly disabledRef: _angular_core.WritableSignal<boolean>;
     readonly isHighlighted: _angular_core.WritableSignal<boolean>;
     selected: _angular_core.OutputEmitterRef<void>;
-    disabled: boolean;
+    get disabled(): boolean;
+    set disabled(disabled: boolean);
     constructor();
     ngOnDestroy(): void;
     setActiveStyles(): void;
     setInactiveStyles(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoreSelectPanelElement<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectPanelElement<any>, "[luCoreSelectPanelElement]", ["luCoreSelectPanelElement"], { "elementId": { "alias": "elementId"; "required": false; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "option": { "alias": "option"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "isSelected": "isSelectedChange"; "selected": "selected"; }, never, never, true, never>;
-}
-
-declare class LuOptionComponent<T> implements AfterViewInit, OnDestroy, OnInit {
-    protected selectableItem: CoreSelectPanelElement<any>;
-    readonly intl: _angular_core.InputSignalWithTransform<OptionTranslate, Partial<OptionTranslate>>;
-    hasOptionItemClass: boolean;
-    optionTpl: TemplateRef<LuOptionContext<T>> | Type<unknown> | undefined;
-    option?: T;
-    grouping?: LuOptionGrouping<T, unknown>;
-    readonly hasChildren: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    onlyParent: _angular_core.OutputEmitterRef<void>;
-    onlyChildren: _angular_core.OutputEmitterRef<void>;
-    readonly groupIndex: _angular_core.InputSignal<number>;
-    readonly optionIndex: _angular_core.InputSignalWithTransform<string, string | number>;
-    scrollIntoViewOptions: ScrollIntoViewOptions;
-    readonly groupTemplateLocation: _angular_core.InputSignal<GroupTemplateLocation>;
-    private readonly optionContext?;
-    private cdr;
-    private subscription?;
-    get id(): string;
-    protected elementRef: ElementRef<HTMLElement>;
-    protected selectId: number;
-    constructor();
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    ngAfterViewInit(): void;
-    selectOption($event: Event): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuOptionComponent<any>, "lu-select-option", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; }; "option": { "alias": "option"; "required": false; }; "grouping": { "alias": "grouping"; "required": false; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "optionIndex": { "alias": "optionIndex"; "required": true; "isSignal": true; }; "scrollIntoViewOptions": { "alias": "scrollIntoViewOptions"; "required": false; }; "groupTemplateLocation": { "alias": "groupTemplateLocation"; "required": false; "isSignal": true; }; }, { "onlyParent": "onlyParent"; "onlyChildren": "onlyChildren"; }, never, never, true, never>;
-}
-
-declare class LuOptionDirective<TOption, TValue> {
-    private templateRef;
-    set select(select: ALuSelectInputComponent<TOption, TValue>);
-    constructor(templateRef: TemplateRef<LuOptionContext<TOption>>);
-    static ngTemplateContextGuard<TOption, TValue>(_dir: LuOptionDirective<TOption, TValue>, ctx: unknown): ctx is LuOptionContext<TOption>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionDirective<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionDirective<any, any>, "[luOption]", never, { "select": { "alias": "luOptionSelect"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<CoreSelectPanelElement<any>, "[luCoreSelectPanelElement]", ["luCoreSelectPanelElement"], { "elementId": { "alias": "elementId"; "required": false; "isSignal": true; }; "isSelected": { "alias": "isSelected"; "required": false; "isSignal": true; }; "option": { "alias": "option"; "required": false; "isSignal": true; }; "disabledInput": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "isSelected": "isSelectedChange"; "selected": "selected"; }, never, never, true, never>;
 }
 
 interface CoreSelectKeyManagerOptions<T> {
@@ -194,7 +85,7 @@ declare class LuCoreSelectPanelHeaderDirective {
     readonly templateRef: TemplateRef<void>;
     readonly select: _angular_core.InputSignal<ALuSelectInputComponent<unknown, unknown> | ALuSelectInputComponent<unknown, unknown[]>>;
     constructor();
-    static ngTemplateContextGuard(_dir: LuCoreSelectPanelHeaderDirective, ctx: unknown): ctx is void;
+    static ngTemplateContextGuard(_dir: LuCoreSelectPanelHeaderDirective, _ctx: unknown): _ctx is void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuCoreSelectPanelHeaderDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectPanelHeaderDirective, "[luSelectPanelHeader]", never, { "select": { "alias": "luSelectPanelHeader"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -214,6 +105,13 @@ declare abstract class LuSelectPanelRef<TOption, TValue> {
     close(): void;
 }
 
+type GroupTemplateLocation = 'group-header' | 'option' | 'none';
+/**
+ * In order to avoid a blinking when we go from empty clue to a clue
+ * We need to delay the change of group displayer location by waiting for the options to be updated.
+ */
+declare function getGroupTemplateLocation(hasGrouping$: Observable<boolean>, clueChange$: Observable<string>, options$: Observable<readonly unknown[]>, searchable?: boolean): Observable<GroupTemplateLocation>;
+
 interface CoreSelectPanelInstance<T = unknown> {
     options: WritableSignal<CoreSelectPanelElement<T>[]>;
 }
@@ -256,18 +154,17 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     readonly panelOpened: _angular_core.OutputEmitterRef<void>;
     readonly highlightedOption: _angular_core.OutputEmitterRef<TOption>;
     private readonly inputElementRef;
-    readonly placeholder$: BehaviorSubject<string>;
     readonly disabled$: BehaviorSubject<boolean>;
     readonly filterPillDisabled: Signal<boolean>;
     readonly prefix: _angular_core.InputSignal<PortalContent>;
-    set placeholder(value: string);
-    set clearable(value: boolean);
-    get clearable(): boolean;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly clearableInput: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isClearable: Signal<boolean>;
     get searchable(): boolean;
     protected readonly computedAddOptionLabel: Signal<PortalContent>;
-    set addOptionLabel(label: PortalContent);
+    readonly addOptionLabelInput: _angular_core.InputSignal<PortalContent>;
     get addOptionLabel(): PortalContent;
-    set addOptionStrategy(strategy: CoreSelectAddOptionStrategy);
+    readonly addOptionStrategy: _angular_core.InputSignal<CoreSelectAddOptionStrategy>;
     protected get isSelectedClass(): boolean;
     protected get isSearchFilledClass(): boolean;
     protected abstract hasValue(): boolean;
@@ -275,16 +172,21 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     readonly isPanelOpen$: BehaviorSubject<boolean>;
     readonly activeDescendant$: BehaviorSubject<string>;
     get ariaControls(): string;
-    overlayConfig?: OverlayConfig;
-    set loading(value: boolean);
-    set options(options: readonly TOption[]);
-    optionComparer: LuOptionComparer<TOption>;
-    optionKey: (option: TOption) => unknown;
+    readonly overlayConfig: _angular_core.InputSignal<OverlayConfig>;
+    readonly loadingInput: _angular_core.InputSignal<boolean>;
+    readonly optionsInput: _angular_core.InputSignal<TOption[]>;
+    readonly optionComparerInput: _angular_core.InputSignal<LuOptionComparer<TOption>>;
+    readonly optionKeyInput: _angular_core.InputSignal<(option: TOption) => unknown>;
     readonly noClueIcon: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly inputTabindex: _angular_core.InputSignal<number>;
     readonly compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly colorPicker: _angular_core.InputSignalWithTransform<boolean, unknown>;
     protected get isNoClueIconClass(): boolean;
+    readonly options: _angular_core.WritableSignal<TOption[]>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly clearable: _angular_core.WritableSignal<boolean>;
+    readonly optionComparer: _angular_core.WritableSignal<LuOptionComparer<TOption>>;
+    readonly optionKey: _angular_core.WritableSignal<(option: TOption) => unknown>;
     readonly optionTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
     readonly valueTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<LuOptionContext<TOption>>>;
     readonly panelHeaderTpl: _angular_core.ModelSignal<Type<unknown> | TemplateRef<void>>;
@@ -311,15 +213,14 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     readonly isFilterPillClearable: Signal<boolean>;
     get value(): TValue | null;
     protected set value(value: TValue | null);
-    get inputPlaceholder(): string | null;
+    get inputPlaceholder(): string | null | undefined;
     clueChanged(clue: string, skipPanelOpen?: boolean): void;
     protected _value: TValue | null;
     readonly options$: ReplaySubject<readonly TOption[]>;
-    readonly loading$: BehaviorSubject<boolean>;
+    readonly loading$: Observable<boolean>;
     clue: string | null;
     lastEmittedClue: string;
     readonly clue$: Observable<string>;
-    readonly addOptionStrategy$: BehaviorSubject<CoreSelectAddOptionStrategy>;
     shouldDisplayAddOption$: Observable<boolean>;
     protected onChange?: (value: TValue | null) => void;
     protected onTouched?: () => void;
@@ -351,8 +252,7 @@ declare abstract class ALuSelectInputComponent<TOption, TValue> implements OnDes
     onFilterPillOpened(): void;
     onFilterPillClosed(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ALuSelectInputComponent<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "ignorePresentation": { "alias": "ignorePresentation"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "addOptionLabel": { "alias": "addOptionLabel"; "required": false; }; "addOptionStrategy": { "alias": "addOptionStrategy"; "required": false; }; "overlayConfig": { "alias": "overlayConfig"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "options": { "alias": "options"; "required": false; }; "optionComparer": { "alias": "optionComparer"; "required": false; }; "optionKey": { "alias": "optionKey"; "required": false; }; "noClueIcon": { "alias": "noClueIcon"; "required": false; "isSignal": true; }; "inputTabindex": { "alias": "inputTabindex"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "colorPicker": { "alias": "colorPicker"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; "panelFooterTpl": { "alias": "panelFooterTpl"; "required": false; "isSignal": true; }; }, { "panelClosed": "panelClosed"; "panelOpened": "panelOpened"; "highlightedOption": "highlightedOption"; "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "panelFooterTpl": "panelFooterTplChange"; "clueChange": "clueChange"; "nextPage": "nextPage"; "previousPage": "previousPage"; "addOption": "addOption"; }, never, never, true, never>;
-    static ngAcceptInputType_clearable: unknown;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ALuSelectInputComponent<any, any>, never, never, { "ignorePresentation": { "alias": "ignorePresentation"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "clearableInput": { "alias": "clearable"; "required": false; "isSignal": true; }; "addOptionLabelInput": { "alias": "addOptionLabel"; "required": false; "isSignal": true; }; "addOptionStrategy": { "alias": "addOptionStrategy"; "required": false; "isSignal": true; }; "overlayConfig": { "alias": "overlayConfig"; "required": false; "isSignal": true; }; "loadingInput": { "alias": "loading"; "required": false; "isSignal": true; }; "optionsInput": { "alias": "options"; "required": false; "isSignal": true; }; "optionComparerInput": { "alias": "optionComparer"; "required": false; "isSignal": true; }; "optionKeyInput": { "alias": "optionKey"; "required": false; "isSignal": true; }; "noClueIcon": { "alias": "noClueIcon"; "required": false; "isSignal": true; }; "inputTabindex": { "alias": "inputTabindex"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "colorPicker": { "alias": "colorPicker"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "valueTpl": { "alias": "valueTpl"; "required": false; "isSignal": true; }; "panelHeaderTpl": { "alias": "panelHeaderTpl"; "required": false; "isSignal": true; }; "panelFooterTpl": { "alias": "panelFooterTpl"; "required": false; "isSignal": true; }; }, { "panelClosed": "panelClosed"; "panelOpened": "panelOpened"; "highlightedOption": "highlightedOption"; "optionTpl": "optionTplChange"; "valueTpl": "valueTplChange"; "panelHeaderTpl": "panelHeaderTplChange"; "panelFooterTpl": "panelFooterTplChange"; "clueChange": "clueChange"; "nextPage": "nextPage"; "previousPage": "previousPage"; "addOption": "addOption"; }, never, never, true, never>;
 }
 
 declare function provideLuSelectLabelsAndIds(): Provider[];
@@ -373,11 +273,11 @@ declare class TreeDisplayPipe<T> implements PipeTransform {
 
 declare class LuDisplayerDirective<TOption, TValue> {
     private templateRef;
-    set select(select: ALuSelectInputComponent<TOption, TValue>);
+    readonly select: _angular_core.InputSignal<ALuSelectInputComponent<TOption, TValue>>;
     constructor(templateRef: TemplateRef<LuOptionContext<TOption>>);
-    static ngTemplateContextGuard<TOption, TValue>(_dir: LuDisplayerDirective<TOption, TValue>, ctx: unknown): ctx is LuOptionContext<TOption>;
+    static ngTemplateContextGuard<TOption, TValue>(_dir: LuDisplayerDirective<TOption, TValue>, _ctx: unknown): _ctx is LuOptionContext<TOption>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuDisplayerDirective<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisplayerDirective<any, any>, "[luDisplayer]", never, { "select": { "alias": "luDisplayerSelect"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisplayerDirective<any, any>, "[luDisplayer]", never, { "select": { "alias": "luDisplayerSelect"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class LuCoreSelectNoClueDirective {
@@ -386,6 +286,107 @@ declare class LuCoreSelectNoClueDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuCoreSelectNoClueDirective, "lu-simple-select[noClue],lu-multi-select[noClue]", never, {}, {}, never, never, true, never>;
 }
 
+interface ILuOptionContext<T> {
+    isDisabled$: BehaviorSubject<boolean>;
+    option$: BehaviorSubject<T | undefined>;
+    destroy(): void;
+}
+declare const LU_OPTION_CONTEXT: InjectionToken<ILuOptionContext<unknown>>;
+declare function provideOptionContext(): Provider;
+
+declare class LuSimpleSelectDefaultOptionComponent {
+    context: ILuOptionContext<{
+        name?: string;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuSimpleSelectDefaultOptionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuSimpleSelectDefaultOptionComponent, "lu-simple-select-default-option", never, {}, {}, never, never, true, never>;
+}
+
+declare class LuDisabledOptionDirective {
+    readonly isDisabled: _angular_core.InputSignal<boolean>;
+    private context;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuDisabledOptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuDisabledOptionDirective, "[luDisabledOption]", never, { "isDisabled": { "alias": "luDisabledOption"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class LuOptionGroupDirective<TOption, TValue, TGroup> {
+    readonly select: _angular_core.InputSignal<ALuSelectInputComponent<TOption, TValue>>;
+    readonly selector: _angular_core.InputSignal<(option: TOption) => TGroup>;
+    readonly content: TemplateRef<LuOptionGroupByContext<TOption, TGroup>>;
+    static ngTemplateContextGuard<TOption, TValue, TGroup>(_dir: LuOptionGroupDirective<TOption, TValue, TGroup>, _ctx: unknown): _ctx is LuOptionGroupByContext<TOption, TGroup>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupDirective<any, any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionGroupDirective<any, any, any>, "[luOptionGroup]", never, { "select": { "alias": "luOptionGroupSelect"; "required": true; "isSignal": true; }; "selector": { "alias": "luOptionGroupBy"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Generate groups with a O(n) complexity. Note that the options must be sorted by group.
+ */
+declare function generateGroups<T, TGroup>(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
+declare class LuOptionGroupPipe<T, TGroup> implements PipeTransform {
+    transform(options: T[], selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>[];
+    transform(options: T, selector: (option: T) => TGroup): LuOptionGroup<T, TGroup>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionGroupPipe<any, any>, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<LuOptionGroupPipe<any, any>, "luOptionGroup", true>;
+}
+
+declare class LuOptionOutletDirective<T> implements OnDestroy {
+    readonly luOptionOutlet: _angular_core.InputSignal<Type<unknown> | TemplateRef<LuOptionContext<T>>>;
+    readonly luOptionOutletValue: _angular_core.InputSignal<T>;
+    readonly luOptionShowNull: _angular_core.InputSignal<boolean>;
+    private viewContainerRef;
+    private injector;
+    private embeddedViewRef?;
+    private componentRef?;
+    private optionContext;
+    constructor();
+    ngOnDestroy(): void;
+    private clearContainer;
+    static ngTemplateContextGuard<T>(_dir: LuOptionOutletDirective<T>, _ctx: unknown): _ctx is void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionOutletDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionOutletDirective<any>, "[luOptionOutlet]", never, { "luOptionOutlet": { "alias": "luOptionOutlet"; "required": false; "isSignal": true; }; "luOptionOutletValue": { "alias": "luOptionOutletValue"; "required": false; "isSignal": true; }; "luOptionShowNull": { "alias": "luOptionShowNull"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface OptionTranslate {
+    onlyParent: string;
+    onlyChildren: string;
+}
+
+declare class LuOptionComponent<T> implements OnInit {
+    protected selectableItem: CoreSelectPanelElement<any>;
+    readonly intl: _angular_core.InputSignalWithTransform<OptionTranslate, Partial<OptionTranslate>>;
+    readonly optionTpl: _angular_core.InputSignal<Type<unknown> | TemplateRef<LuOptionContext<T>>>;
+    readonly option: _angular_core.InputSignal<T>;
+    readonly grouping: _angular_core.InputSignal<LuOptionGrouping<T, unknown>>;
+    readonly hasChildren: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly onlyParent: _angular_core.OutputEmitterRef<void>;
+    readonly onlyChildren: _angular_core.OutputEmitterRef<void>;
+    readonly groupIndex: _angular_core.InputSignal<number>;
+    readonly optionIndex: _angular_core.InputSignalWithTransform<string, string | number>;
+    readonly scrollIntoViewOptions: _angular_core.InputSignal<ScrollIntoViewOptions>;
+    readonly groupTemplateLocation: _angular_core.InputSignal<GroupTemplateLocation>;
+    readonly optionContext: _angular_core.Signal<_lucca_front_ng_core_select.ILuOptionContext<unknown>>;
+    private cdr;
+    get id(): string;
+    protected elementRef: ElementRef<HTMLElement>;
+    protected selectId: number;
+    constructor();
+    ngOnInit(): void;
+    selectOption($event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LuOptionComponent<any>, "lu-select-option", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "optionTpl": { "alias": "optionTpl"; "required": false; "isSignal": true; }; "option": { "alias": "option"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "hasChildren": { "alias": "hasChildren"; "required": false; "isSignal": true; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "optionIndex": { "alias": "optionIndex"; "required": true; "isSignal": true; }; "scrollIntoViewOptions": { "alias": "scrollIntoViewOptions"; "required": false; "isSignal": true; }; "groupTemplateLocation": { "alias": "groupTemplateLocation"; "required": false; "isSignal": true; }; }, { "onlyParent": "onlyParent"; "onlyChildren": "onlyChildren"; }, never, never, true, never>;
+}
+
+declare class LuOptionDirective<TOption, TValue> {
+    private templateRef;
+    readonly select: _angular_core.InputSignal<ALuSelectInputComponent<TOption, TValue>>;
+    constructor(templateRef: TemplateRef<LuOptionContext<TOption>>);
+    static ngTemplateContextGuard<TOption, TValue>(_dir: LuOptionDirective<TOption, TValue>, _ctx: unknown): _ctx is LuOptionContext<TOption>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LuOptionDirective<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<LuOptionDirective<any, any>, "[luOption]", never, { "select": { "alias": "luOptionSelect"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 declare const applySearchDelimiter: (clue: string, delimiter: string) => string;
 
 declare class LuIsOptionSelectedPipe<T> implements PipeTransform {

package/types/lucca-front-ng-core.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { PipeTransform, InjectionToken, TemplateRef, Type, OnDestroy, Signal, EffectCleanupRegisterFn, CreateEffectOptions, EffectRef, InputOptionsWithTransform } from '@angular/core';
+import { PipeTransform, InjectionToken, TemplateRef, Type, OnDestroy, Signal, input, EffectCleanupRegisterFn, CreateEffectOptions, EffectRef, InputOptionsWithTransform } from '@angular/core';
 import { UrlTree, ActivatedRoute, Params } from '@angular/router';
 export { DecorativePalette, PrClass as LuClass, Palette } from '@lucca/prisme/core';
 
@@ -201,7 +201,7 @@ declare class PortalDirective<T extends object = object> implements OnDestroy {
      * @see https://github.com/angular/angular/pull/51887
      */
     private updateEmbeddedViewContext;
-    static ngTemplateContextGuard<T extends object>(_dir: PortalDirective<T>, ctx: unknown): ctx is void;
+    static ngTemplateContextGuard<T extends object>(_dir: PortalDirective<T>, _ctx: unknown): _ctx is void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PortalDirective<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<PortalDirective<any>, "[luPortal]", never, { "luPortal": { "alias": "luPortal"; "required": true; "isSignal": true; }; "luPortalContext": { "alias": "luPortalContext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -236,6 +236,11 @@ type EffectWithDepsInput = ReadonlyArray<Signal<unknown>> | Record<string, Signa
  * La plupart du temps, seule la lecture des signaux est intéressante à tracker, pas les actions qui en découlent.
  */
 declare function ɵeffectWithDeps<const T extends EffectWithDepsInput>(dependencies: T, action: (...values: [...SignalsValue<T>, EffectCleanupRegisterFn]) => unknown, options?: CreateEffectOptions): EffectRef;
+/**
+ * Utilitaire pour synchroniser un input signal avec une props via un setter.
+ * Évite la répétition des ɵeffectWithDeps + isNotNil.
+ */
+declare function syncInputSignal<T>(signal: ReturnType<typeof input<T>>, setter: (value: T) => void): void;
 
 /**
  * @deprecated use `LuTranslation` instead.
@@ -287,5 +292,5 @@ interface ILuTree<T> {
     disabled?: boolean;
 }
 
-export { ALuDateAdapter, ALuOnCloseSubscriber, ALuOnOpenSubscriber, ALuOnScrollBottomSubscriber, ELuDateGranularity, IntlParamsPipe, LU_NATIVE_DATE_ADAPTER_OPTIONS, LuNativeDateAdapter, LuStringDateAdapter, LuTypeGuardPipe, PORTAL_CONTEXT, PortalDirective, assertNotNil, defaultBreakpoints, generateId, getIntl, intlInputOptions, isNil, isNilOrEmptyString, isNotNil, isNotNilOrEmptyString, isRouterLinkParam, luDefaultNativeDateAdapterOptions, ɵeffectWithDeps };
+export { ALuDateAdapter, ALuOnCloseSubscriber, ALuOnOpenSubscriber, ALuOnScrollBottomSubscriber, ELuDateGranularity, IntlParamsPipe, LU_NATIVE_DATE_ADAPTER_OPTIONS, LuNativeDateAdapter, LuStringDateAdapter, LuTypeGuardPipe, PORTAL_CONTEXT, PortalDirective, assertNotNil, defaultBreakpoints, generateId, getIntl, intlInputOptions, isNil, isNilOrEmptyString, isNotNil, isNotNilOrEmptyString, isRouterLinkParam, luDefaultNativeDateAdapterOptions, syncInputSignal, ɵeffectWithDeps };
 export type { At, Breakpoint, EffectWithDepsInput, EnumValue, ILuDateAdapter, ILuGroup, ILuNativeDateAdapterOptions, ILuOnCloseSubscriber, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber, ILuTranslation, ILuTree, LuDateGranularity, LuTranslation, PortalContent, ResponsiveConfig, ResponsiveProperty, RouterLinkParam };

package/types/lucca-front-ng-date.d.ts

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { PipeTransform, OnInit, ChangeDetectorRef, ElementRef, Renderer2, EventEmitter, TemplateRef, AfterViewInit, ViewContainerRef, InjectionToken } from '@angular/core';
+import { PipeTransform, OnInit, ChangeDetectorRef, ElementRef, Renderer2, EventEmitter, AfterViewInit, ViewContainerRef, InjectionToken } from '@angular/core';
 import { ALuDateAdapter, LuDateGranularity, ELuDateGranularity, LuTranslation } from '@lucca-front/ng/core';
 import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
 import { ALuInput } from '@lucca-front/ng/input';
@@ -89,10 +89,10 @@ declare class LuCalendarInputComponent<D> extends ALuInput<D> implements Control
     private _factory;
     private _adapter;
     readonly intl: i0.InputSignalWithTransform<LuCalendarInputLabel, Partial<LuCalendarInputLabel>>;
-    min?: D;
-    max?: D;
-    granularity: LuDateGranularity;
-    startOn: D;
+    readonly min: i0.InputSignal<D>;
+    readonly max: i0.InputSignal<D>;
+    readonly granularity: i0.InputSignal<string>;
+    readonly startOn: i0.InputSignal<D>;
     viewGranularity: LuDateGranularity;
     header: ICalendarItem<D>;
     items: ICalendarItem<D>[];
@@ -124,21 +124,25 @@ declare class LuCalendarInputComponent<D> extends ALuInput<D> implements Control
     protected previousDecade(): void;
     validate(control: AbstractControl): ValidationErrors | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuCalendarInputComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuCalendarInputComponent<any>, "lu-calendar", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuCalendarInputComponent<any>, "lu-calendar", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "startOn": { "alias": "startOn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class LuDatePickerComponent<D = Date> extends ALuPickerPanel<D> {
     private _adapter;
     _value: D;
-    min?: D;
-    max?: D;
-    granularity: LuDateGranularity;
-    startOn: D;
+    readonly min: i0.InputSignal<D>;
+    readonly max: i0.InputSignal<D>;
+    readonly granularity: i0.InputSignal<string>;
+    readonly startOn: i0.InputSignal<D>;
     close: EventEmitter<void>;
     open: EventEmitter<void>;
     hovered: EventEmitter<boolean>;
     onSelectValue: EventEmitter<D>;
-    set vcTemplateRef(tr: TemplateRef<unknown>);
+    protected readonly closeOutput: i0.OutputRef<void>;
+    protected readonly openOutput: i0.OutputRef<void>;
+    protected readonly hoveredOutput: i0.OutputRef<boolean>;
+    protected readonly onSelectValueOutput: i0.OutputRef<D>;
+    private readonly vcTemplateRef;
     constructor(_adapter: ALuDateAdapter<D>);
     _emitOpenEvent(): void;
     _emitCloseEvent(): void;
@@ -150,19 +154,19 @@ declare class LuDatePickerComponent<D = Date> extends ALuPickerPanel<D> {
     _onEnter(): void;
     _handleKeydown(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDatePickerComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuDatePickerComponent<any>, "lu-date-picker", ["LuDatePicker"], { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, { "close": "close"; "open": "open"; "hovered": "hovered"; "onSelectValue": "onSelectValue"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuDatePickerComponent<any>, "lu-date-picker", ["LuDatePicker"], { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "startOn": { "alias": "startOn"; "required": false; "isSignal": true; }; }, { "closeOutput": "close"; "openOutput": "open"; "hoveredOutput": "hovered"; "onSelectValueOutput": "onSelectValue"; }, never, never, true, never>;
 }
 
-declare class LuDateInputDirective<D> extends ALuInput<D, HTMLInputElement> implements Validator, OnInit {
+declare class LuDateInputDirective<D> extends ALuInput<D, HTMLInputElement> implements Validator {
     private _adapter;
     private _focused;
-    min?: D;
-    max?: D;
-    granularity: LuDateGranularity;
+    readonly min: i0.InputSignal<D>;
+    readonly max: i0.InputSignal<D>;
+    readonly granularity: i0.InputSignal<string>;
+    readonly placeHolderInput: i0.InputSignal<string>;
     set placeholder(p: string);
     readonly intl: i0.InputSignalWithTransform<_lucca_front_ng_date.ILuDateInputLabel, Partial<_lucca_front_ng_date.ILuDateInputLabel>>;
     constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLInputElement>, _renderer: Renderer2, _adapter: ALuDateAdapter<D>);
-    ngOnInit(): void;
     protected render(): void;
     onInput(event: any): void;
     private parse;
@@ -170,7 +174,7 @@ declare class LuDateInputDirective<D> extends ALuInput<D, HTMLInputElement> impl
     onBlur(): void;
     validate(control: AbstractControl): ValidationErrors | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateInputDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDateInputDirective<any>, "input[luDateInput]", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDateInputDirective<any>, "input[luDateInput]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "placeHolderInput": { "alias": "placeholder"; "required": false; "isSignal": true; }; "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class LuDateSelectInputComponent<D> extends ALuSelectInputComponent<D> implements ControlValueAccessor, ILuInputWithPicker<D>, AfterViewInit, Validator {
@@ -180,19 +184,17 @@ declare class LuDateSelectInputComponent<D> extends ALuSelectInputComponent<D> i
     protected _viewContainerRef: ViewContainerRef;
     protected _renderer: Renderer2;
     private _adapter;
-    min?: D;
-    max?: D;
-    granularity: LuDateGranularity;
-    set inputPlaceholder(p: string);
-    hideClearer: boolean;
+    readonly min: i0.InputSignal<D>;
+    readonly max: i0.InputSignal<D>;
+    readonly granularity: i0.InputSignal<string>;
+    readonly hideClearer: i0.InputSignal<boolean>;
+    readonly startOn: i0.InputSignal<D>;
     protected _startOn: D;
-    set startOn(s: D);
-    get startOn(): D;
     get format(): string;
     constructor(_changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _renderer: Renderer2, _adapter: ALuDateAdapter<D>);
     validate(control: AbstractControl): ValidationErrors | null;
     static ɵfac: i0.ɵɵFactoryDeclaration<LuDateSelectInputComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LuDateSelectInputComponent<any>, "lu-date-select", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "inputPlaceholder": { "alias": "placeholder"; "required": false; }; "hideClearer": { "alias": "hideClearer"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuDateSelectInputComponent<any>, "lu-date-select", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "hideClearer": { "alias": "hideClearer"; "required": false; "isSignal": true; }; "startOn": { "alias": "startOn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**

package/types/lucca-front-ng-dialog.d.ts

@@ -24,15 +24,20 @@ declare class DialogHeaderAction {
     static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderAction, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderAction, "[dialogHeaderAction]", never, {}, {}, never, never, true, never>;
 }
+declare class DialogHeaderSubtitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderSubtitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogHeaderSubtitle, "[dialogHeaderSubtitle]", never, {}, {}, never, never, true, never>;
+}
 declare class DialogHeaderComponent implements OnInit {
     #private;
     readonly intl: i0.InputSignalWithTransform<_lucca_front_ng_dialog.LuDialogHeaderTranslations, Partial<_lucca_front_ng_dialog.LuDialogHeaderTranslations>>;
     dismissible: boolean;
     close(): void;
     readonly optionalAction: i0.Signal<DialogHeaderAction>;
+    readonly optionalSubtitle: i0.Signal<DialogHeaderSubtitle>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "lu-dialog-header", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, ["optionalAction"], ["[dialogHeaderAction]", "*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "lu-dialog-header", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, ["optionalAction", "optionalSubtitle"], ["[dialogHeaderAction]", "*", "[dialogHeaderSubtitle]", "[dialogHeaderContent]"], true, never>;
 }
 
 declare const LU_DIALOG_HEADER_TRANSLATIONS: InjectionToken<LuTranslation<LuDialogHeaderTranslations>>;
@@ -136,6 +141,11 @@ type BaseLuDialogConfig<C, TData = LuDialogData<C>> = {
      * @param comp the instance of the component that's inside the dialog box.
      */
     canClose?: (comp: C) => boolean | Observable<boolean>;
+    /**
+     * A hook function to determine if the current dialog can be dismissed or not.
+     * Unlike `canClose`, this does not require a component instance and is suitable for template-based dialogs.
+     */
+    canDismiss?: () => boolean | Observable<boolean>;
     /**
      * Determine if the current dialog can be close by a click on backdrop or escape key
      */
@@ -300,6 +310,7 @@ declare class DialogOpenDirective {
         autoFocus?: _angular_cdk_dialog.AutoFocusTarget | "first-input" | string;
         cdkConfigOverride?: _angular_cdk_dialog.DialogConfig<unknown, unknown, _angular_cdk_portal.BasePortalOutlet>;
         canClose?: (comp: unknown) => boolean | rxjs.Observable<boolean>;
+        canDismiss?: () => boolean | rxjs.Observable<boolean>;
         canCloseWithBackdrop?: boolean;
         size?: _lucca_front_ng_dialog.LuDialogSize;
         mode?: "default" | "drawer" | "drawer-from-bottom" | "fancy";
@@ -310,5 +321,5 @@ declare class DialogOpenDirective {
     static ɵdir: i0.ɵɵDirectiveDeclaration<DialogOpenDirective, "[luDialogOpen]", never, { "dialog": { "alias": "luDialogOpen"; "required": true; "isSignal": true; }; "luDialogConfig": { "alias": "luDialogConfig"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { DIALOG_ROUTE_CLOSE_TRIGGER, DIALOG_ROUTE_CONFIG, DIALOG_ROUTE_DISMISS_TRIGGER, DialogCloseDirective, DialogComponent, DialogContentComponent, DialogDismissDirective, DialogFooterComponent, DialogHeaderAction, DialogHeaderComponent, DialogOpenDirective, DialogRoutingContainerComponent, LU_DIALOG_HEADER_TRANSLATIONS, LuDialogRef, LuDialogService, LuccaDialogRoutingReuseStrategy, configureLuDialog, createDialogRoute, defaultOnClosedFn, dialogLazyRouteFactory, dialogRouteFactory, injectDialogData, injectDialogRef, luDialogHeaderTranslations, provideDialogRoutingReuseStrategy, provideLuDialog };
+export { DIALOG_ROUTE_CLOSE_TRIGGER, DIALOG_ROUTE_CONFIG, DIALOG_ROUTE_DISMISS_TRIGGER, DialogCloseDirective, DialogComponent, DialogContentComponent, DialogDismissDirective, DialogFooterComponent, DialogHeaderAction, DialogHeaderComponent, DialogHeaderSubtitle, DialogOpenDirective, DialogRoutingContainerComponent, LU_DIALOG_HEADER_TRANSLATIONS, LuDialogRef, LuDialogService, LuccaDialogRoutingReuseStrategy, configureLuDialog, createDialogRoute, defaultOnClosedFn, dialogLazyRouteFactory, dialogRouteFactory, injectDialogData, injectDialogRef, luDialogHeaderTranslations, provideDialogRoutingReuseStrategy, provideLuDialog };
 export type { DialogFactoryConfig, DialogFactoryResult, DialogFactoryResultOptions, DialogRouteCloseTrigger, DialogRouteConfig, DialogRouteDialogConfig, DialogRouteDismissTrigger, LuDialogConfig, LuDialogData, LuDialogHeaderTranslations, LuDialogResult, LuDialogSelfRef, LuDialogSize, ɵDialogDataFlag, ɵDialogResultFlag };