@lucca-front/ng 19.3.4 → 20.0.0

package/department/index.d.ts

@@ -1,5 +1,129 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, AfterViewInit, ChangeDetectorRef, ElementRef, ViewContainerRef, Renderer2 } from '@angular/core';
+import { ILuTree, ILuOnOpenSubscriber, LuTranslation } from '@lucca-front/ng/core';
+import { ALuTreeOptionOperator, ILuTreeOptionOperator, ILuTreeOptionPickerPanel, LuOptionComparer } from '@lucca-front/ng/option';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { Overlay } from '@angular/cdk/overlay';
+import { ControlValueAccessor } from '@angular/forms';
+import { ILuInputWithPicker } from '@lucca-front/ng/picker';
+import { ALuSelectInputComponent } from '@lucca-front/ng/select';
+import { ILuApiService, ALuApiService, LuApiV3Service } from '@lucca-front/ng/api';
+
+interface ILuDepartment {
+    id: number;
+    name: string;
+}
+
+interface ILuDepartmentService<D extends ILuDepartment = ILuDepartment> extends ILuApiService<D> {
+    getTrees(): Observable<ILuTree<D>[]>;
+}
+declare abstract class ALuDepartmentService<D extends ILuDepartment = ILuDepartment> extends ALuApiService<D> implements ILuDepartmentService<D> {
+    abstract getTrees(): Observable<ILuTree<D>[]>;
+}
+
+interface IApiDepartment {
+    node: ILuDepartment;
+    children: IApiDepartment[];
+}
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated use {LuDepartmentService} instead.
  */
-/// <amd-module name="@lucca-front/ng/department" />
-export * from './public-api';
+declare class LuDepartmentV3Service extends LuApiV3Service<ILuDepartment> implements ILuDepartmentService<ILuDepartment> {
+    protected _http: HttpClient;
+    protected _api: string;
+    protected _appInstanceId: number | string;
+    set appInstanceId(appInstanceId: number | string);
+    protected _operations: number[];
+    set operations(operations: number[]);
+    constructor(_http: HttpClient);
+    getTrees(): Observable<ILuTree<ILuDepartment>[]>;
+    private format;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentV3Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuDepartmentV3Service>;
+}
+
+declare class LuDepartmentV4Service {
+    private _http;
+    api: string;
+    protected _filters: string[];
+    set filters(filters: string[]);
+    protected _appInstanceId: number | string;
+    set appInstanceId(appInstanceId: number | string);
+    protected _operations: number[];
+    set operations(operations: number[]);
+    protected _uniqueOperation: number;
+    set uniqueOperation(uniqueOperation: number);
+    constructor(_http: HttpClient);
+    getTrees(): rxjs.Observable<ILuTree<ILuDepartment>[]>;
+    private format;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentV4Service, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuDepartmentV4Service>;
+}
+
+declare class LuDepartmentFeederComponent extends ALuTreeOptionOperator<ILuDepartment> implements ILuTreeOptionOperator<ILuDepartment>, ILuOnOpenSubscriber {
+    inOptions$: Observable<ILuTree<ILuDepartment>[]>;
+    outOptions$: Observable<ILuTree<ILuDepartment>[]>;
+    protected _out$: Subject<ILuTree<ILuDepartment>[]>;
+    protected _service: LuDepartmentV4Service;
+    set appInstanceId(appInstanceId: number | string);
+    set operations(operations: number[]);
+    set filters(filters: string[]);
+    set uniqueOperation(uniqueOperation: number);
+    constructor(hostService: LuDepartmentV4Service, selfService: LuDepartmentV4Service);
+    onOpen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentFeederComponent, [{ optional: true; skipSelf: true; }, { self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuDepartmentFeederComponent, "lu-department-feeder", never, { "appInstanceId": { "alias": "appInstanceId"; "required": false; }; "operations": { "alias": "operations"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "uniqueOperation": { "alias": "uniqueOperation"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const LU_DEPARTMENT_SELECT_INPUT_TRANSLATIONS: InjectionToken<LuTranslation<ILuDepartmentSelectInputLabel>>;
+interface ILuDepartmentSelectInputLabel {
+    departments: string;
+}
+declare const luDepartmentSelectInputTranslations: LuTranslation<ILuDepartmentSelectInputLabel>;
+
+declare class LuDepartmentSelectInputComponent<D extends ILuDepartment = ILuDepartment, P extends ILuTreeOptionPickerPanel<D> = ILuTreeOptionPickerPanel<D>> extends ALuSelectInputComponent<D, P> implements ControlValueAccessor, ILuInputWithPicker<D>, AfterViewInit {
+    protected _changeDetectorRef: ChangeDetectorRef;
+    protected _overlay: Overlay;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _viewContainerRef: ViewContainerRef;
+    protected _renderer: Renderer2;
+    byId: LuOptionComparer<D>;
+    appInstanceId: number | string;
+    operations: number[];
+    filters: string[];
+    uniqueOperation: number;
+    intl: ILuDepartmentSelectInputLabel;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _renderer: Renderer2);
+    searchFn(o: D, c: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentSelectInputComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuDepartmentSelectInputComponent<any, any>, "lu-department-select", never, { "appInstanceId": { "alias": "appInstanceId"; "required": false; }; "operations": { "alias": "operations"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "uniqueOperation": { "alias": "uniqueOperation"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuDepartmentSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentSelectModule, never, [typeof LuDepartmentFeederComponent, typeof LuDepartmentSelectInputComponent], [typeof LuDepartmentFeederComponent, typeof LuDepartmentSelectInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentSelectModule>;
+}
+
+declare class LuDepartmentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentModule, never, [typeof LuDepartmentSelectModule], [typeof LuDepartmentSelectModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentModule>;
+}
+
+declare class LuDepartmentFeederModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentFeederModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentFeederModule, never, [typeof LuDepartmentFeederComponent], [typeof LuDepartmentFeederComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentFeederModule>;
+}
+
+declare class LuDepartmentSelectInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDepartmentSelectInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDepartmentSelectInputModule, never, [typeof LuDepartmentSelectInputComponent], [typeof LuDepartmentSelectInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDepartmentSelectInputModule>;
+}
+
+export { ALuDepartmentService, LU_DEPARTMENT_SELECT_INPUT_TRANSLATIONS, LuDepartmentFeederComponent, LuDepartmentFeederModule, LuDepartmentModule, LuDepartmentSelectInputComponent, LuDepartmentSelectInputModule, LuDepartmentSelectModule, LuDepartmentV3Service, LuDepartmentV4Service, luDepartmentSelectInputTranslations };
+export type { IApiDepartment, ILuDepartment, ILuDepartmentSelectInputLabel, ILuDepartmentService };

package/dialog/index.d.ts

@@ -1,5 +1,252 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/dialog" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, EnvironmentProviders, Provider, TemplateRef, AfterViewInit, Injector } from '@angular/core';
+import { LuTranslation } from '@lucca-front/ng/core';
+import { AutoFocusTarget, DialogConfig, DialogRef } from '@angular/cdk/dialog';
+import { Observable, Subscription } from 'rxjs';
+import { ComponentType } from '@angular/cdk/overlay';
+import { Route, CanDeactivateFn, DeprecatedGuard, Router, ActivatedRoute } from '@angular/router';
+import { ComponentType as ComponentType$1 } from '@angular/cdk/portal';
+import * as _angular_cdk_portal_directives_d_DbeNrI5D from '@angular/cdk/portal-directives.d-DbeNrI5D';
+
+declare class DialogContentComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogContentComponent, "lu-dialog-content", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogFooterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogFooterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogFooterComponent, "lu-dialog-footer", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare const LU_DIALOG_HEADER_TRANSLATIONS: InjectionToken<LuTranslation<LuDialogHeaderTranslations>>;
+interface LuDialogHeaderTranslations {
+    close: string;
+}
+declare const luDialogHeaderTranslations: LuTranslation<LuDialogHeaderTranslations>;
+
+declare class DialogHeaderComponent implements OnInit {
+    #private;
+    intl: LuDialogHeaderTranslations;
+    dismissible: boolean;
+    close(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogHeaderComponent, "lu-dialog-header", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare function configureLuDialog(): EnvironmentProviders;
+declare function provideLuDialog(): Provider;
+
+declare const ɵdialogData: unique symbol;
+declare const ɵdialogResult: unique symbol;
+type ɵDialogDataFlag = {
+    [ɵdialogData]: unknown;
+};
+type ɵDialogResultFlag<R> = {
+    [ɵdialogResult]: R;
+};
+type LuDialogData<T> = {
+    [K in keyof T]: T[K] extends ɵDialogDataFlag ? Omit<T[K], typeof ɵdialogData> : never;
+}[keyof T];
+type DialogRefProps<C> = {
+    [K in keyof C]: C[K] extends ɵDialogResultFlag<unknown> ? K : never;
+}[keyof C] & keyof C;
+type LuDialogResult<C> = DialogRefProps<C> extends never ? void : C[DialogRefProps<C>] extends ɵDialogResultFlag<infer T> ? T : void;
+interface BaseLuDialogConfig<C> {
+    /**
+     * The component or template to put inside the dialog container
+     */
+    content: ComponentType<C> | TemplateRef<C>;
+    /**
+     * Data to pass to the component, will be required if the component used `injectDialogData` in a field, specifying the data that's needed.
+     */
+    data: LuDialogData<C>;
+    /**
+     * Should we put a backdrop? Defaults to true
+     */
+    modal?: boolean;
+    /**
+     * Is this dialog a blocking popup that cannot be dismissed ?
+     *
+     * Defaults to false, setting this to true will also remove the close button in the header
+     * if you're using `lu-dialog-header`.
+     */
+    alert?: boolean;
+    /**
+     * Can be used if you don't have a header or aren't using the default one, to set an aria-label
+     * instead of aria-labelledby on the dialog container
+     */
+    ariaLabel?: string;
+    /**
+     * Autofocus target
+     *
+     * Defaults to the close button from the header, first-input is added by us to focus the first available input
+     * or the first input that is contained inside a node that has the `.luDialog-autofocus` class
+     */
+    autoFocus?: AutoFocusTarget | 'first-input' | string;
+    /**
+     * This provides a way to override any of the configuration parameters expected by cdk's `Dialog.open` method.
+     *
+     * WARNING: this will take full authority and override with your values no matter what's computed by LuDialogService,
+     * use with caution.
+     */
+    cdkConfigOverride?: DialogConfig<C>;
+    /**
+     * A hook function to determine if the current dialog can be closed or not, if provided.
+     *
+     * @param comp the instance of the component that's inside the dialog box.
+     */
+    canClose?: (comp: C) => boolean | Observable<boolean>;
+    /**
+     * Determine if the current dialog can be close by a click on backdrop or escape key
+     */
+    canCloseWithBackdrop?: boolean;
+    /**
+     * The size of the panel used for the dialog
+     */
+    size?: 'XS' | 'S' | 'M' | 'L' | 'XL' | 'fitContent' | `maxContent` | 'fullScreen';
+    /**
+     * Should it be a modal (default), a drawer? a drawer from bottom?
+     */
+    mode?: 'default' | 'drawer' | 'drawer-from-bottom';
+    /**
+     * Classes to add to the panel
+     */
+    panelClasses?: string[];
+}
+type LuDialogConfig<T> = LuDialogData<T> extends never ? Omit<BaseLuDialogConfig<T>, 'data'> : BaseLuDialogConfig<T>;
+
+declare const DISMISSED_VALUE: {};
+declare class LuDialogRef<C = unknown> {
+    readonly cdkRef: DialogRef<LuDialogResult<C> | typeof DISMISSED_VALUE, C>;
+    readonly config: LuDialogConfig<C>;
+    /**
+     * Instance of the component that's inside the dialog
+     */
+    get instance(): C;
+    /**
+     * Subscription to the detachments of the dialog
+     * This is used to close the dialog when it is detached
+     */
+    detachSubscription: Subscription | null;
+    /**
+     * Emits when the dialog is closed
+     *
+     * Emits either the output of result$ or undefined depending on how it has been closed
+     */
+    closed$: Observable<LuDialogResult<C> | undefined>;
+    /**
+     * Emits void when the dialog is dismissed
+     */
+    dismissed$: Observable<void>;
+    /**
+     * Emits the result if it has a value that's not DISMISSED_VALUE
+     */
+    result$: Observable<LuDialogResult<C>>;
+    constructor(cdkRef: DialogRef<LuDialogResult<C> | typeof DISMISSED_VALUE, C>, config: LuDialogConfig<C>);
+    dismiss(): void;
+    close(res: LuDialogResult<C>): void;
+}
+type LuDialogSelfRef<R> = {
+    dismiss(): void;
+    close(res: R): void;
+};
+
+declare function injectDialogData<TData>(): TData & ɵDialogDataFlag;
+declare function injectDialogRef<R = void>(): LuDialogSelfRef<R> & ɵDialogResultFlag<R>;
+
+declare class LuDialogService {
+    #private;
+    open<C>(config: LuDialogConfig<C>): LuDialogRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuDialogService>;
+}
+
+declare class DialogComponent implements AfterViewInit {
+    #private;
+    readonly dialogRef: LuDialogRef<unknown>;
+    close(): void;
+    dismiss(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "lu-dialog", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class DialogCloseDirective {
+    #private;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogCloseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogCloseDirective, "[luDialogClose]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogDismissDirective {
+    #private;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogDismissDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogDismissDirective, "[luDialogDismiss]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DialogOpenDirective {
+    #private;
+    dialog: TemplateRef<void>;
+    luDialogConfig: LuDialogConfig<unknown>;
+    click(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogOpenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DialogOpenDirective, "[luDialogOpen]", never, { "dialog": { "alias": "luDialogOpen"; "required": true; }; "luDialogConfig": { "alias": "luDialogConfig"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type Deferrable<T> = Promise<T> | Observable<T> | T;
+declare function deferrableToPromise<T>(deferrable: Promise<T> | Observable<T> | T): Promise<T>;
+declare function deferrableToObservable<T>(deferrable: Promise<T> | Observable<T> | T): Observable<T>;
+declare const DIALOG_ROUTE_CONFIG: InjectionToken<DialogRouteConfig<unknown>>;
+declare function createDialogRoute<C>(config: DialogRouteConfig<C>): Route;
+type DialogFactoryResultOptions<C> = {
+    path: string;
+    dialogRouteConfig?: Partial<Omit<DialogRouteConfig<C>, 'path'>>;
+} & (LuDialogData<C> extends never ? {
+    dataFactory?: never;
+} : {
+    dataFactory: () => Deferrable<LuDialogData<C>>;
+});
+type DialogFactoryResult<C> = (options: DialogFactoryResultOptions<C>) => Route;
+type DialogFactoryConfig<C> = Partial<{
+    dialogConfig: Omit<LuDialogConfig<C>, 'data' | 'content'>;
+    dialogRouteConfig: Partial<DialogRouteConfig<C>>;
+}>;
+declare function dialogRouteFactory<C>(component: ComponentType$1<C>, config?: DialogFactoryConfig<C>): DialogFactoryResult<C>;
+
+type DialogRouteConfig<C> = {
+    dialogConfigFactory: () => Deferrable<LuDialogConfig<C>>;
+    /**
+     * When the dialog is closed, this callback is called with the result of the dialog.
+     * This callback is called within injection context, so you can inject services in it.
+     */
+    onClosed?: (res: LuDialogResult<C>) => unknown;
+    /**
+     * When the dialog is dismissed, this callback is called.
+     * This callback is called within injection context, so you can inject services in it.
+     */
+    onDismissed?: () => unknown;
+    /**
+     * Override canDeactivate to have a stricter type
+     */
+    canDeactivate?: (CanDeactivateFn<C> | DeprecatedGuard)[];
+} & Omit<Route, 'component' | 'canDeactivate'>;
+
+declare const defaultOnClosedFn: <C>(router?: Router, route?: ActivatedRoute, config?: DialogRouteConfig<C>) => void;
+declare class DialogRoutingComponent<C> implements OnInit {
+    #private;
+    readonly injector: Injector;
+    readonly dialogConfig: i0.Signal<LuDialogConfig<C>>;
+    readonly dialogTemplateContent: i0.Signal<TemplateRef<C>>;
+    readonly dialogComponentContent: i0.Signal<_angular_cdk_portal_directives_d_DbeNrI5D.a<C>>;
+    protected readonly dialogTemplate: i0.Signal<TemplateRef<any>>;
+    readonly customInjector: i0.DestroyableInjector;
+    readonly componentInstance: i0.WritableSignal<C>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogRoutingComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DialogRoutingComponent<any>, "lu-dialog-routing", never, {}, {}, never, never, true, never>;
+}
+
+export { DIALOG_ROUTE_CONFIG, DialogCloseDirective, DialogComponent, DialogContentComponent, DialogDismissDirective, DialogFooterComponent, DialogHeaderComponent, DialogOpenDirective, DialogRoutingComponent, LU_DIALOG_HEADER_TRANSLATIONS, LuDialogRef, LuDialogService, configureLuDialog, createDialogRoute, defaultOnClosedFn, deferrableToObservable, deferrableToPromise, dialogRouteFactory, injectDialogData, injectDialogRef, luDialogHeaderTranslations, provideLuDialog };
+export type { Deferrable, DialogFactoryConfig, DialogFactoryResult, DialogFactoryResultOptions, DialogRouteConfig, LuDialogConfig, LuDialogData, LuDialogHeaderTranslations, LuDialogResult, ɵDialogDataFlag, ɵDialogResultFlag };

package/dialog/testing/index.d.ts

@@ -1,5 +1,9 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/dialog/testing" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { LuDialogData } from '@lucca-front/ng/dialog';
+
+declare function provideLuDialogDataTesting<T = unknown>(data: LuDialogData<T>): {
+    provide: _angular_core.InjectionToken<any>;
+    useValue: LuDialogData<T>;
+};
+
+export { provideLuDialogDataTesting };

package/divider/index.d.ts

@@ -1,5 +1,17 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/divider" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { OnChanges, ElementRef } from '@angular/core';
+
+declare class DividerComponent implements OnChanges {
+    #private;
+    content: ElementRef;
+    separatorRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    vertical: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    size: _angular_core.InputSignal<"M" | "S">;
+    withRole: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    ngOnChanges(): void;
+    updateClasses(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "lu-divider", never, { "separatorRole": { "alias": "separatorRole"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "withRole": { "alias": "withRole"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { DividerComponent };

package/dropdown/index.d.ts

@@ -1,5 +1,139 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter, ElementRef, AfterViewInit, TemplateRef, QueryList, ViewContainerRef } from '@angular/core';
+import { Overlay } from '@angular/cdk/overlay';
+import { ILuPopoverPanel, ALuPopoverPanel, ALuPopoverTrigger, ILuPopoverTarget, ILuPopoverTrigger, LuPopoverPosition, LuPopoverAlignment } from '@lucca-front/ng/popover';
+import { Observable } from 'rxjs';
+
+type ILuDropdownPanel = ILuPopoverPanel;
+
+interface ILuDropdownItem {
+    onSelect: Observable<boolean>;
+    focus(): void;
+}
+declare abstract class ALuDropdownItem implements ILuDropdownItem {
+    abstract onSelect: Observable<boolean>;
+    abstract focus(): void;
+}
+
+declare class LuDropdownItemDirective extends ALuDropdownItem implements OnDestroy {
+    private _eltRef;
+    onSelect: EventEmitter<boolean>;
+    constructor(_eltRef: ElementRef<HTMLElement>);
+    onClick(): void;
+    onEnter(): void;
+    focus(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDropdownItemDirective, "[luDropdownItem]", ["LuDropdownItem"], {}, { "onSelect": "onSelect"; }, never, never, true, never>;
+}
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated use `LuDropdownItemDirective` instead
  */
-/// <amd-module name="@lucca-front/ng/dropdown" />
-export * from './public-api';
+declare class LuDropdownItemModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownItemModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDropdownItemModule, never, [typeof LuDropdownItemDirective], [typeof LuDropdownItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDropdownItemModule>;
+}
+
+declare class LuDropdownPanelComponent extends ALuPopoverPanel implements ILuPopoverPanel, OnDestroy, AfterViewInit {
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container.  Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputPanelClasses(classes: string);
+    /**
+     * This method takes classes set on the host lu-popover element and applies them on the
+     * popover template that displays in the overlay container. Otherwise, it's difficult
+     * to style the containing popover from outside the component.
+     * @param classes list of class names
+     */
+    set inputContentClasses(classes: string);
+    /** Event emitted when the popover is closed. */
+    close: EventEmitter<void>;
+    open: EventEmitter<void>;
+    hovered: EventEmitter<boolean>;
+    set vcTemplateRef(tr: TemplateRef<unknown>);
+    protected _items: ILuDropdownItem[];
+    protected _itemsQL: QueryList<ILuDropdownItem>;
+    set optionsQL(ql: QueryList<ILuDropdownItem>);
+    private _subs;
+    constructor();
+    protected initItems(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    _emitCloseEvent(): void;
+    _emitOpenEvent(): void;
+    _emitHoveredEvent(hovered: boolean): void;
+    onOpen(): void;
+    private focusFirstItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuDropdownPanelComponent, "lu-dropdown", ["LuDropdownPanel"], { "inputPanelClasses": { "alias": "panel-classes"; "required": false; }; "inputContentClasses": { "alias": "content-classes"; "required": false; }; }, { "close": "close"; "open": "open"; "hovered": "hovered"; }, ["optionsQL"], ["*"], true, never>;
+}
+
+/**
+ * @deprecated use `LuDropdownPanelComponent` instead
+ */
+declare class LuDropdownPanelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownPanelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDropdownPanelModule, never, [typeof LuDropdownPanelComponent], [typeof LuDropdownPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDropdownPanelModule>;
+}
+
+/**
+ * This directive is intended to be used in conjunction with an lu-dropdown tag.  It is
+ * responsible for toggling the display of the provided dropdown instance.
+ */
+declare class LuDropdownTriggerDirective<TPanel extends ILuDropdownPanel = ILuDropdownPanel> extends ALuPopoverTrigger<TPanel, ILuPopoverTarget> implements ILuPopoverTrigger<TPanel, ILuPopoverTarget>, AfterViewInit, OnDestroy {
+    protected _overlay: Overlay;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _viewContainerRef: ViewContainerRef;
+    /** References the popover instance that the trigger is associated with. */
+    set inputPanel(p: TPanel);
+    /** how you want to position the panel relative to the target, allowed values: above, below, before, after */
+    set inputPosition(pos: LuPopoverPosition);
+    /** how the panel will be align with the target, allowed values: top, bottom, left, right */
+    set inputAlignment(al: LuPopoverAlignment);
+    /** disable popover apparition */
+    set inputDisabled(d: boolean);
+    /** set to true if you want the panel to appear on top of the target */
+    set inputOverlap(ov: boolean);
+    /** Event emitted when the associated popover is opened. */
+    onOpen: EventEmitter<void>;
+    /** Event emitted when the associated popover is closed. */
+    onClose: EventEmitter<void>;
+    /** accessibility attribute - dont override */
+    get _attrAriaExpanded(): boolean;
+    /** accessibility attribute - dont override */
+    get _attrId(): string;
+    /** accessibility attribute - dont override */
+    get _attrAriaControls(): string;
+    constructor(_overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef);
+    onClick(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected _emitOpen(): void;
+    protected _emitClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownTriggerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDropdownTriggerDirective<any>, "[luDropdown]", ["LuDropdownTrigger"], { "inputPanel": { "alias": "luDropdown"; "required": false; }; "inputPosition": { "alias": "luDropdownPosition"; "required": false; }; "inputAlignment": { "alias": "luDropdownAlignment"; "required": false; }; "inputDisabled": { "alias": "luDropdownDisabled"; "required": false; }; "inputOverlap": { "alias": "luDropdownOverlap"; "required": false; }; }, { "onOpen": "luDropdownOnOpen"; "onClose": "luDropdownOnClose"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated use `LuDropdownTriggerDirective` instead
+ */
+declare class LuDropdownTriggerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownTriggerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDropdownTriggerModule, never, [typeof LuDropdownTriggerDirective], [typeof LuDropdownTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDropdownTriggerModule>;
+}
+
+declare class LuDropdownModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuDropdownModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDropdownModule, never, [typeof LuDropdownTriggerModule, typeof LuDropdownPanelModule, typeof LuDropdownItemModule], [typeof LuDropdownTriggerModule, typeof LuDropdownPanelModule, typeof LuDropdownItemModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuDropdownModule>;
+}
+
+export { ALuDropdownItem, LuDropdownItemDirective, LuDropdownItemModule, LuDropdownModule, LuDropdownPanelComponent, LuDropdownPanelModule, LuDropdownTriggerDirective, LuDropdownTriggerModule };
+export type { ILuDropdownItem, ILuDropdownPanel };

package/empty-state/index.d.ts

@@ -1,5 +1,59 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/empty-state" />
-export * from './public-api';
+import { PortalContent, Palette } from '@lucca-front/ng/core';
+import * as i0 from '@angular/core';
+
+type Hx = 1 | 2 | 3 | 4 | 5 | 6;
+
+declare class EmptyStatePageComponent {
+    /**
+     * Icon image (URL)
+     */
+    icon: any;
+    /**
+     * Top right background image (URL)
+     */
+    topRightBackground: string;
+    /**
+     * Top right foreground image (URL)
+     */
+    topRightForeground: string;
+    /**
+     * Bottom left background image (URL)
+     */
+    bottomLeftBackground: string;
+    /**
+     * Bottom left foreground image (URL)
+     */
+    bottomLeftForeground: string;
+    /**
+     * Background color for content (text)
+     */
+    contentBackgroundColor: string;
+    slotTop: PortalContent;
+    heading: string;
+    description: PortalContent;
+    hx: Hx;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStatePageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStatePageComponent, "lu-empty-state-page", never, { "icon": { "alias": "icon"; "required": false; }; "topRightBackground": { "alias": "topRightBackground"; "required": false; }; "topRightForeground": { "alias": "topRightForeground"; "required": false; }; "bottomLeftBackground": { "alias": "bottomLeftBackground"; "required": false; }; "bottomLeftForeground": { "alias": "bottomLeftForeground"; "required": false; }; "contentBackgroundColor": { "alias": "contentBackgroundColor"; "required": false; }; "slotTop": { "alias": "slotTop"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; "description": { "alias": "description"; "required": false; }; "hx": { "alias": "hx"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_hx: unknown;
+}
+
+declare class EmptyStateSectionComponent {
+    /**
+     * Icon URL
+     */
+    icon: string;
+    palette: Palette;
+    center: boolean;
+    heading: string;
+    description: PortalContent;
+    hx: Hx;
+    get emptyStateClasses(): {
+        [x: string]: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmptyStateSectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmptyStateSectionComponent, "lu-empty-state-section", never, { "icon": { "alias": "icon"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "center": { "alias": "center"; "required": false; }; "heading": { "alias": "heading"; "required": false; }; "description": { "alias": "description"; "required": false; }; "hx": { "alias": "hx"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_center: unknown;
+    static ngAcceptInputType_hx: unknown;
+}
+
+export { EmptyStatePageComponent, EmptyStateSectionComponent };