@lucca-front/ng 19.3.3 → 20.0.0

package/a11y/index.d.ts

@@ -1,5 +1,29 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/a11y" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { LuTranslation } from '@lucca-front/ng/core';
+
+declare const LU_SKIP_LINKS_TRANSLATIONS: InjectionToken<LuTranslation<ILuSkipLinksLabel>>;
+interface ILuSkipLinksLabel {
+    Goto: string;
+    Goto_Nav_Banner: string;
+    Goto_Nav_Navside: string;
+    Goto_Content: string;
+}
+declare abstract class ALuSkipLinksLabel {
+    Goto: string;
+    Goto_Nav_Banner: string;
+    Goto_Nav_Navside: string;
+    Goto_Content: string;
+}
+declare const luSkipLinksTranslations: LuTranslation<ILuSkipLinksLabel>;
+
+declare class LuSkipLinksComponent {
+    #private;
+    protected intl: ILuSkipLinksLabel;
+    anchor(hash: string, e: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuSkipLinksComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuSkipLinksComponent, "lu-skip-links", never, {}, {}, never, never, true, never>;
+}
+
+export { ALuSkipLinksLabel, LU_SKIP_LINKS_TRANSLATIONS, LuSkipLinksComponent, luSkipLinksTranslations };
+export type { ILuSkipLinksLabel };

package/animations/index.d.ts

@@ -1,5 +1,16 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/animations" />
-export * from './public-api';
+import { AnimationTriggerMetadata, AnimationMetadata } from '@angular/animations';
+
+type LuAnimationType = 'scale' | 'slide' | 'fade';
+declare const LU_DEFAULT_ANIMATION_TIMING = "250ms 0ms ease-out";
+declare function luFadeAnimationFactory(animationInTiming?: string, animationOutTiming?: string, triggerName?: string): AnimationTriggerMetadata;
+declare function luScaleAnimationFactory(animationInTiming?: string, animationOutTiming?: string, triggerName?: string): AnimationTriggerMetadata;
+declare function luSlideAnimationFactory(animationInTiming?: string, animationOutTiming?: string, triggerName?: string): AnimationTriggerMetadata;
+
+declare function luFadingAnimation(inTiming: string, outTiming: string): AnimationMetadata[];
+
+declare function luScalingAnimation(inTiming: string, outTiming: string): AnimationMetadata[];
+
+declare function luSlidingAnimation(inTiming: string, outTiming: string): AnimationMetadata[];
+
+export { LU_DEFAULT_ANIMATION_TIMING, luFadeAnimationFactory, luFadingAnimation, luScaleAnimationFactory, luScalingAnimation, luSlideAnimationFactory, luSlidingAnimation };
+export type { LuAnimationType };

package/api/index.d.ts

@@ -1,5 +1,295 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/api" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnInit, ElementRef, AfterViewInit, ChangeDetectorRef, ViewContainerRef, Renderer2 } from '@angular/core';
+import { ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber } from '@lucca-front/ng/core';
+import { ILuOptionOperator, LuOptionPickerAdvancedComponent, ILuOptionItem, LuOptionComparer } from '@lucca-front/ng/option';
+import { Observable, BehaviorSubject, Subject } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import { FormControl, ControlValueAccessor } from '@angular/forms';
+import { Overlay } from '@angular/cdk/overlay';
+import { ALuSelectInputComponent } from '@lucca-front/ng/select';
+
+interface ILuApiSuggestion<T> {
+    relevance: unknown;
+    item: T;
+}
+interface ILuApiItem<TId = number> {
+    id: TId;
+    name?: string;
+}
+interface ILuApiResponse<D> {
+    data: D;
+}
+type ILuApiCollectionResponse<T> = ILuApiResponse<{
+    items: T[];
+}>;
+
+interface ILuApiService<T extends ILuApiItem = ILuApiItem> {
+    getAll(filters?: string[]): Observable<T[]>;
+    getPaged(page: number, filters?: string[]): Observable<T[]>;
+    searchAll(clue: string, filters?: string[]): Observable<T[]>;
+    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
+}
+declare abstract class ALuApiService<T extends ILuApiItem = ILuApiItem> implements ILuApiService<T> {
+    abstract getAll(filters?: string[]): Observable<T[]>;
+    abstract getPaged(page: number, filters?: string[]): Observable<T[]>;
+    abstract searchAll(clue: string, filters?: string[]): Observable<T[]>;
+    abstract searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
+}
+
+declare class LuApiV3Service<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
+    protected _http: HttpClient;
+    protected _api: string;
+    set api(api: string);
+    protected _fields: string;
+    set fields(fields: string);
+    protected _filters: string[];
+    set filters(filters: string[]);
+    protected _orderBy: string;
+    set orderBy(orderBy: string);
+    get url(): string;
+    constructor(_http: HttpClient);
+    getAll(filters?: string[]): Observable<T[]>;
+    getPaged(page: number, filters?: string[]): Observable<T[]>;
+    searchAll(clue: string, filters?: string[]): Observable<T[]>;
+    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
+    protected _get(url: string): Observable<T[]>;
+    protected _clueFilter(clue: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiV3Service<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiV3Service<any>>;
+}
+
+declare class LuApiV4Service<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
+    protected _http: HttpClient;
+    protected _api: string;
+    set api(api: string);
+    protected _filters: string[];
+    set filters(filters: string[]);
+    get filters(): string[];
+    protected _sort: string;
+    set sort(sort: string);
+    constructor(_http: HttpClient);
+    getAll(filters?: string[]): Observable<T[]>;
+    getPaged(page?: number, filters?: string[]): Observable<T[]>;
+    searchAll(clue?: string, filters?: string[]): Observable<T[]>;
+    searchPaged(clue?: string, page?: number, filters?: string[]): Observable<T[]>;
+    count(): Observable<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiV4Service<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiV4Service<any>>;
+}
+
+declare class LuApiHybridService<T extends ILuApiItem = ILuApiItem> extends ALuApiService<T> {
+    private _http;
+    private _v3Service;
+    private _v4Service;
+    private _standard;
+    set standard(std: 'v3' | 'v4');
+    set api(api: string);
+    set filters(filters: string[]);
+    set fields(fields: string);
+    set orderBy(orderBy: string);
+    set sort(sort: string);
+    private get _service();
+    constructor(_http: HttpClient);
+    getAll(filters?: string[]): Observable<T[]>;
+    getPaged(page: number, filters?: string[]): Observable<T[]>;
+    searchAll(clue: string, filters?: string[]): Observable<T[]>;
+    searchPaged(clue: string, page: number, filters?: string[]): Observable<T[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiHybridService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LuApiHybridService<any>>;
+}
+
+type ILuApiOptionFeeder<T extends ILuApiItem = ILuApiItem> = ILuOptionOperator<T>;
+interface ILuApiFeederService<T extends ILuApiItem = ILuApiItem> {
+    getAll(): Observable<T[]>;
+}
+declare abstract class ALuApiOptionFeeder<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionFeeder<T> {
+    outOptions$: BehaviorSubject<T[]>;
+    protected _service: S;
+    constructor(service: S);
+    onOpen(): void;
+}
+
+declare class LuApiFeederComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionFeeder<T, LuApiHybridService<T>> implements ILuOptionOperator<T>, ILuOnOpenSubscriber {
+    outOptions$: BehaviorSubject<T[]>;
+    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
+    set standard(standard: 'v3' | 'v4');
+    set api(api: string);
+    set fields(fields: string);
+    set filters(filters: string[]);
+    set orderBy(orderBy: string);
+    set sort(sort: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiFeederComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiFeederComponent<any>, "lu-api-feeder", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuApiFeederModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiFeederModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiFeederModule, never, [typeof LuApiFeederComponent], [typeof LuApiFeederComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiFeederModule>;
+}
+
+type ILuApiOptionSearcher<T extends ILuApiItem = ILuApiItem> = ILuApiOptionFeeder<T>;
+declare abstract class ALuApiOptionSearcher<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionFeeder<T>, ILuOnOpenSubscriber {
+    protected _service: S;
+    outOptions$: Subject<T[]>;
+    loading$: Observable<boolean>;
+    empty$: Observable<boolean>;
+    protected _clue$: Observable<string>;
+    set clue$(clue$: Observable<string>);
+    constructor(_service: S);
+    init(): void;
+    onOpen(): void;
+    onClose(): void;
+    protected initObservables(): void;
+    abstract resetClue(): any;
+    protected clearOptions(): void;
+}
+type ILuApiOptionPagedSearcher<T extends ILuApiItem = ILuApiItem> = ILuApiOptionSearcher<T>;
+declare abstract class ALuApiOptionPagedSearcher<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> extends ALuApiOptionSearcher<T, S> implements ILuApiOptionPagedSearcher<T>, ILuOnScrollBottomSubscriber {
+    outOptions$: Subject<T[]>;
+    loading$: Observable<boolean>;
+    protected _loading: boolean;
+    protected _page$: Subject<void>;
+    protected _isLastPage: boolean;
+    protected _options: T[];
+    constructor(service: S);
+    onOpen(): void;
+    onScrollBottom(): void;
+    protected initObservables(): void;
+    abstract resetClue(): any;
+}
+
+declare class LuApiSearcherComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionSearcher<T, LuApiHybridService<T>> implements OnInit {
+    searchInput: ElementRef<HTMLElement>;
+    set standard(standard: 'v3' | 'v4');
+    set api(api: string);
+    set fields(fields: string);
+    set filters(filters: string[]);
+    set orderBy(orderBy: string);
+    set sort(sort: string);
+    debounceTime: number;
+    clueControl: FormControl;
+    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
+    ngOnInit(): void;
+    onOpen(): void;
+    resetClue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSearcherComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiSearcherComponent<any>, "lu-api-searcher", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class LuApiPagedSearcherComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionPagedSearcher<T, LuApiHybridService<T>> implements OnInit {
+    searchInput: ElementRef<HTMLElement>;
+    set standard(standard: 'v3' | 'v4');
+    set api(api: string);
+    set fields(fields: string);
+    set filters(filters: string[]);
+    set orderBy(orderBy: string);
+    set sort(sort: string);
+    debounceTime: number;
+    clueControl: FormControl;
+    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
+    ngOnInit(): void;
+    onOpen(): void;
+    resetClue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagedSearcherComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiPagedSearcherComponent<any>, "lu-api-paged-searcher", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare enum Strategy {
+    append = 0,
+    replace = 1
+}
+type ILuApiOptionPager<T extends ILuApiItem = ILuApiItem> = ILuOptionOperator<T>;
+interface ILuApiPagerService<T extends ILuApiItem = ILuApiItem> {
+    getPaged(page: number): Observable<T[]>;
+}
+declare abstract class ALuApiOptionPager<T extends ILuApiItem = ILuApiItem, S extends ILuApiService<T> = ILuApiService<T>> implements ILuApiOptionPager<T>, ILuOnOpenSubscriber, ILuOnScrollBottomSubscriber {
+    protected _service: S;
+    outOptions$: Subject<T[]>;
+    loading$: Observable<boolean>;
+    protected _loading: boolean;
+    protected _results$: Observable<{
+        items: T[];
+        strategy: Strategy;
+    }>;
+    protected _options: T[];
+    protected _page$: Subject<number>;
+    protected _page: number;
+    protected _initialized: boolean;
+    constructor(_service: S);
+    protected init(): void;
+    onOpen(): void;
+    onScrollBottom(): void;
+    protected initObservables(): void;
+}
+
+declare class LuApiPagerComponent<T extends ILuApiItem = ILuApiItem> extends ALuApiOptionPager<T, LuApiHybridService<T>> implements ILuOptionOperator<T>, OnInit, ILuOnScrollBottomSubscriber, ILuOnOpenSubscriber {
+    constructor(hostService: LuApiHybridService<T>, selfService: LuApiHybridService<T>);
+    set standard(standard: 'v3' | 'v4');
+    set api(api: string);
+    set fields(fields: string);
+    set filters(filters: string[]);
+    set orderBy(orderBy: string);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagerComponent<any>, [{ optional: true; skipSelf: true; }, { self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiPagerComponent<any>, "lu-api-pager", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuApiSelectInputComponent<T extends ILuApiItem = ILuApiItem> extends ALuSelectInputComponent<T, LuOptionPickerAdvancedComponent<T, ILuOptionItem<T>>> implements ControlValueAccessor, AfterViewInit {
+    protected _changeDetectorRef: ChangeDetectorRef;
+    protected _overlay: Overlay;
+    protected _elementRef: ElementRef<HTMLElement>;
+    protected _viewContainerRef: ViewContainerRef;
+    protected _renderer: Renderer2;
+    standard: 'v3' | 'v4';
+    api: string;
+    /**
+     * only works with standard="v3"
+     */
+    fields: string;
+    filters: string[];
+    /**
+     * only works with standard="v3", otherwise use sort
+     */
+    orderBy: string;
+    /**
+     * only works with standard="v4", otherwise use orderBy
+     */
+    sort: string;
+    byId: LuOptionComparer<T>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectInputComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuApiSelectInputComponent<any>, "lu-api-select", never, { "standard": { "alias": "standard"; "required": false; }; "api": { "alias": "api"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "orderBy": { "alias": "orderBy"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LuApiSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectModule, never, [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent], [typeof LuApiFeederComponent, typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent, typeof LuApiPagerComponent, typeof LuApiSelectInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSelectModule>;
+}
+
+declare class LuApiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiModule, never, [typeof LuApiSelectModule], [typeof LuApiSelectModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiModule>;
+}
+
+declare class LuApiSearcherModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSearcherModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSearcherModule, never, [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent], [typeof LuApiPagedSearcherComponent, typeof LuApiSearcherComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSearcherModule>;
+}
+
+declare class LuApiPagerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiPagerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiPagerModule, never, [typeof LuApiPagerComponent], [typeof LuApiPagerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiPagerModule>;
+}
+
+declare class LuApiSelectInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuApiSelectInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LuApiSelectInputModule, never, [typeof LuApiSelectInputComponent], [typeof LuApiSelectInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LuApiSelectInputModule>;
+}
+
+export { ALuApiOptionFeeder, ALuApiOptionPagedSearcher, ALuApiOptionPager, ALuApiOptionSearcher, ALuApiService, LuApiFeederComponent, LuApiFeederModule, LuApiHybridService, LuApiModule, LuApiPagedSearcherComponent, LuApiPagerComponent, LuApiPagerModule, LuApiSearcherComponent, LuApiSearcherModule, LuApiSelectInputComponent, LuApiSelectInputModule, LuApiSelectModule, LuApiV3Service, LuApiV4Service };
+export type { ILuApiCollectionResponse, ILuApiFeederService, ILuApiItem, ILuApiOptionFeeder, ILuApiOptionPagedSearcher, ILuApiOptionPager, ILuApiOptionSearcher, ILuApiPagerService, ILuApiResponse, ILuApiService, ILuApiSuggestion };

package/breadcrumbs/index.d.ts

@@ -1,5 +1,26 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/breadcrumbs" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { TemplateRef } from '@angular/core';
+
+declare class BreadcrumbsLinkDirective {
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BreadcrumbsLinkDirective, "[luBreadcrumbsLink]", never, {}, {}, never, never, true, never>;
+}
+
+interface LuBreadcrumbsLabel {
+    breadcrumbs: string;
+}
+
+declare class BreadcrumbsComponent {
+    intl: LuBreadcrumbsLabel;
+    disableCompact: i0.InputSignalWithTransform<boolean, unknown>;
+    links: i0.Signal<readonly BreadcrumbsLinkDirective[]>;
+    isCompact: i0.Signal<boolean>;
+    id: string;
+    get classCompact(): boolean;
+    get roleAttr(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbsComponent, "lu-breadcrumbs", never, { "disableCompact": { "alias": "disableCompact"; "required": false; "isSignal": true; }; }, {}, ["links"], never, true, never>;
+}
+
+export { BreadcrumbsComponent, BreadcrumbsLinkDirective };

package/button/index.d.ts

@@ -1,5 +1,29 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/button" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { OnChanges, ElementRef } from '@angular/core';
+import { Palette } from '@lucca-front/ng/core';
+
+declare class ButtonComponent implements OnChanges {
+    #private;
+    size: 'M' | 'S' | 'XS';
+    block: boolean;
+    delete: boolean;
+    disclosure: boolean;
+    palette: Palette;
+    state: 'default' | 'loading' | 'error' | 'success';
+    /**
+     * '' is the default value when you just set the `luButton` directive without a value attached to it.
+     * We just make this explicit here.
+     */
+    luButton: '' | 'outlined' | 'text' | 'text-invert';
+    set iconComponentRef(ref: ElementRef<HTMLElement>);
+    private get iconOnly();
+    ngOnChanges(): void;
+    updateClasses(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "button[luButton],a[luButton]", never, { "size": { "alias": "size"; "required": false; }; "block": { "alias": "block"; "required": false; }; "delete": { "alias": "delete"; "required": false; }; "disclosure": { "alias": "disclosure"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "state": { "alias": "state"; "required": false; }; "luButton": { "alias": "luButton"; "required": false; }; }, {}, ["iconComponentRef"], ["*"], true, never>;
+    static ngAcceptInputType_block: unknown;
+    static ngAcceptInputType_delete: unknown;
+    static ngAcceptInputType_disclosure: unknown;
+}
+
+export { ButtonComponent };

package/callout/index.d.ts

@@ -1,5 +1,167 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/callout" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { InjectionToken, EventEmitter, OnDestroy, ElementRef, TemplateRef, OnChanges } from '@angular/core';
+import { LuTranslation, PortalContent, Palette } from '@lucca-front/ng/core';
+import { LuccaIcon } from '@lucca-front/icons';
+
+declare const LU_CALLOUT_TRANSLATIONS: InjectionToken<LuTranslation<LuCalloutLabel>>;
+interface LuCalloutLabel {
+    close: string;
+}
+declare const luCalloutTranslations: LuTranslation<LuCalloutLabel>;
+
+declare const CalloutStates: readonly ["success", "warning", "error"];
+type CalloutState = (typeof CalloutStates)[number];
+
+declare class CalloutComponent {
+    /**
+     * The title of the callout
+     */
+    heading: PortalContent;
+    /**
+     * Which palette should be used for the entire callout.
+     * Defaults to none (inherits parent palette)
+     */
+    palette: Palette;
+    /**
+     * Which size should the callout be? Defaults to medium
+     */
+    size: 'M' | 'S';
+    /**
+     * Should we display the remove icon?
+     */
+    removable: boolean;
+    /**
+     * Which icon should we display in the callout if any?
+     * Defaults to no icon.
+     */
+    icon: LuccaIcon;
+    /**
+     * State is a shorthand to set the icon and the palette to the recommended values for the icon and palette based on
+     * the provided state.
+     *
+     * If one of the icon or palette inputs are filled along with the state input, their values will have the priority over
+     * state (so setting state to success and palette to warning will make the palette warning)
+     */
+    state: CalloutState;
+    /**
+     * Is the callout removed? Works with two way binding too.
+     */
+    removed: boolean;
+    get hiddenAttr(): 'hidden' | null;
+    removedChange: EventEmitter<boolean>;
+    intl: LuCalloutLabel;
+    get calloutClasses(): {
+        [x: string]: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutComponent, "lu-callout", never, { "heading": { "alias": "heading"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "state": { "alias": "state"; "required": false; }; "removed": { "alias": "removed"; "required": false; }; }, { "removedChange": "removedChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_removable: unknown;
+    static ngAcceptInputType_removed: unknown;
+}
+
+declare class CalloutDisclosureComponent {
+    icon: LuccaIcon;
+    heading: PortalContent;
+    palette: Palette;
+    size: 'M' | 'S';
+    /**
+     * State is a shorthand to set the icon and the palette to the recommended values for the icon and palette based on
+     * the provided state.
+     *
+     * If one of the icon or palette inputs are filled along with the state input, their values will have the priority over
+     * state (so setting state to success and palette to warning will make the palette warning)
+     */
+    state: CalloutState;
+    open: boolean;
+    openChange: EventEmitter<boolean>;
+    onToggle(event: Event): void;
+    get calloutClasses(): {
+        [x: string]: boolean;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutDisclosureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutDisclosureComponent, "lu-callout-disclosure", never, { "icon": { "alias": "icon"; "required": false; }; "heading": { "alias": "heading"; "required": true; }; "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; "state": { "alias": "state"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_open: unknown;
+}
+
+declare class CalloutPopoverComponent implements OnDestroy {
+    #private;
+    overlayOrigin: ElementRef;
+    overlayContent: TemplateRef<unknown>;
+    private _hideDelayId;
+    private _showDelayId;
+    /**
+     * Debounce for the popover to open (mouse will have to be on the element fox openDelay milliseconds for popover to show)
+     */
+    readonly openDelay = 50;
+    /**
+     * Debounce for the popover to close (mouse will have to be out of both popover and trigger for closeDelay milliseconds for it to close)
+     */
+    readonly closeDelay = 500;
+    /**
+     * Label to put inside the button, often used to show just a number
+     */
+    buttonLabel: string;
+    /**
+     * Palette for both the button and the popover content
+     */
+    palette: Palette;
+    /**
+     * Size for both button and popover content
+     */
+    size?: 'M' | 'S' | 'XS';
+    /**
+     * Icon shows in button and next to popover's title
+     */
+    icon: LuccaIcon;
+    /**
+     * State is a shorthand to set the icon and the palette to the recommended values for the icon and palette based on
+     * the provided state.
+     *
+     * If one of the icon or palette inputs are filled along with the state input, their values will have the priority over
+     * state (so setting state to success and palette to warning will make the palette warning)
+     */
+    state: CalloutState;
+    /**
+     * Heading for the details popover
+     */
+    heading: PortalContent;
+    get contentSize(): 'S' | 'M' | undefined;
+    get calloutClasses(): {
+        [x: string]: boolean;
+    };
+    get calloutOverlayClasses(): {
+        [x: string]: boolean;
+    };
+    get calloutOverlayHeadClasses(): {
+        [x: string]: boolean;
+    };
+    showContent(): void;
+    private createPanelContent;
+    hideContent(event: MouseEvent | null): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutPopoverComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutPopoverComponent, "lu-callout-popover", never, { "openDelay": { "alias": "openDelay"; "required": false; }; "closeDelay": { "alias": "closeDelay"; "required": false; }; "buttonLabel": { "alias": "buttonLabel"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "state": { "alias": "state"; "required": false; }; "heading": { "alias": "heading"; "required": true; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_openDelay: unknown;
+    static ngAcceptInputType_closeDelay: unknown;
+}
+
+declare class CalloutFeedbackItemDescriptionDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutFeedbackItemDescriptionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CalloutFeedbackItemDescriptionDirective, "lu-feedback-item-description", never, {}, {}, never, never, true, never>;
+}
+declare class CalloutFeedbackItemComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutFeedbackItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutFeedbackItemComponent, "li[lu-callout-feedback-item]", never, {}, {}, never, ["lu-feedback-item-description", "[lu-feedback-item-action]"], true, never>;
+}
+
+declare class CalloutFeedbackListComponent implements OnChanges {
+    #private;
+    palette: Palette;
+    size: 'M' | 'S';
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalloutFeedbackListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CalloutFeedbackListComponent, "ul[lu-callout-feedback-list]", never, { "palette": { "alias": "palette"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+export { CalloutComponent, CalloutDisclosureComponent, CalloutFeedbackItemComponent, CalloutFeedbackItemDescriptionDirective, CalloutFeedbackListComponent, CalloutPopoverComponent, LU_CALLOUT_TRANSLATIONS, luCalloutTranslations };
+export type { LuCalloutLabel };

package/chip/index.d.ts

@@ -1,5 +1,19 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@lucca-front/ng/chip" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+interface ChipTranslate {
+    delete: string;
+}
+
+declare class ChipComponent {
+    intl: ChipTranslate;
+    unkillable: boolean;
+    palette?: string;
+    disabled: boolean;
+    get classPalette(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChipComponent, "lu-chip", never, { "unkillable": { "alias": "unkillable"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_unkillable: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+export { ChipComponent };